common/hexutil: hex encode/decode in simd

.github/workflows/ci-gate.yml

@@ -97,6 +97,11 @@ jobs:
     needs: [changes]
     uses: ./.github/workflows/test-bench.yml
 
+  simd:
+    if: needs.changes.outputs.code != 'false'
+    needs: [changes]
+    uses: ./.github/workflows/test-simd.yml
+
   kurtosis:
     if: needs.changes.outputs.code != 'false'
     needs: [changes]
@@ -135,6 +140,7 @@ jobs:
       - docs-site
       - large-files
       - bench
+      - simd
       - kurtosis
       - repro
       - sonar

.github/workflows/test-simd.yml

@@ -0,0 +1,32 @@
+name: SIMD tests
+
+# The simd/archsimd kernels only build with Go 1.27 and GOEXPERIMENT=simd, which the regular
+# test jobs (Go from go.mod, default experiments) never compile.
+on:
+  workflow_call:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  simd:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 1
+          persist-credentials: false
+
+      - uses: actions/setup-go@v6
+        with:
+          go-version: '1.27.x'
+          check-latest: true
+          cache: false
+
+      - name: Test the SIMD kernels
+        env:
+          GOEXPERIMENT: jsonv2,simd
+          GOTOOLCHAIN: local
+        run: go test -count=1 ./common/hexutil/...

common/hexutil/bytes.go

@@ -20,6 +20,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"reflect"
+	"slices"
 )
 
 var bytesT = reflect.TypeFor[Bytes]()
@@ -33,25 +34,26 @@ const HexPrefix = `0x`
 
 // MarshalText implements encoding.TextMarshaler
 func (b Bytes) MarshalText() ([]byte, error) {
-	result := make([]byte, len(b)*2+2)
-	copy(result, HexPrefix)
-	hex.Encode(result[2:], b)
-	return result, nil
+	return b.AppendText(nil)
 }
 
 // AppendText implements encoding.TextAppender: the alloc-free, byte-identical
 // counterpart to MarshalText. Only encoding/json/v2 consults it today.
 func (b Bytes) AppendText(dst []byte) ([]byte, error) {
-	dst = append(dst, HexPrefix...)
-	return hex.AppendEncode(dst, b), nil
+	n, size := len(dst), len(HexPrefix)+2*len(b)
+	dst = slices.Grow(dst, size)[:n+size]
+	dst[n], dst[n+1] = '0', 'x'
+	encodeHex(dst[n+2:], b)
+	return dst, nil
 }
 
 // QuotedLen is the length of n bytes encoded by AppendQuoted.
 func QuotedLen(n int) int { return len(`"0x"`) + 2*n }
 
 // AppendQuoted appends b as a 0x-prefixed hex JSON string.
 func AppendQuoted(dst, b []byte) []byte {
-	return append(hex.AppendEncode(append(dst, `"`+HexPrefix...), b), '"')
+	dst, _ = Bytes(b).AppendText(append(dst, '"'))
+	return append(dst, '"')
 }
 
 // UnmarshalJSON implements json.Unmarshaler.

common/hexutil/encode_generic.go

@@ -0,0 +1,23 @@
+// Copyright 2026 The Erigon Authors
+// This file is part of Erigon.
+//
+// Erigon is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Erigon is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Erigon. If not, see <http://www.gnu.org/licenses/>.
+
+//go:build !(go1.27 && goexperiment.simd && amd64)
+
+package hexutil
+
+import "encoding/hex"
+
+func encodeHex(dst, src []byte) { hex.Encode(dst, src) }

common/hexutil/encode_simd.go

@@ -0,0 +1,47 @@
+// Copyright 2026 The Erigon Authors
+// This file is part of Erigon.
+//
+// Erigon is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Erigon is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Erigon. If not, see <http://www.gnu.org/licenses/>.
+
+//go:build go1.27 && goexperiment.simd && amd64
+
+package hexutil
+
+import (
+	"encoding/hex"
+	"simd/archsimd"
+)
+
+var (
+	hexDigits32 = [32]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
+		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}
+	hasAVX2 = archsimd.X86.AVX2()
+)
+
+// encodeHex is hex.Encode with whole 16-byte blocks done by AVX2. Each byte is widened to a
+// uint16 holding its high nibble in the low byte and its low nibble in the high byte, so one
+// in-lane byte shuffle turns the nibbles into digits in output order.
+func encodeHex(dst, src []byte) {
+	if hasAVX2 {
+		digits := archsimd.LoadUint8x32Array(&hexDigits32)
+		low := archsimd.BroadcastUint16x16(0x0f)
+		for len(src) >= 16 && len(dst) >= 32 {
+			w := archsimd.LoadUint8x16Array((*[16]uint8)(src)).ExtendToUint16()
+			w = w.ShiftAllRight(4).Or(w.And(low).ShiftAllLeft(8))
+			digits.PermuteOrZeroGrouped(w.AsUint8x32().AsInt8x32()).StoreArray((*[32]uint8)(dst))
+			src, dst = src[16:], dst[32:]
+		}
+	}
+	hex.Encode(dst, src)
+}

common/hexutil/hexutil.go

@@ -289,9 +289,7 @@ func EncodeTs(number uint64) []byte {
 
 // Encode encodes b as a hex string with 0x prefix.
 func Encode(b []byte) string {
-	enc := make([]byte, len(b)*2+2)
-	copy(enc, "0x")
-	hex.Encode(enc[2:], b)
+	enc, _ := Bytes(b).AppendText(nil)
 	return string(enc)
 }
 

common/hexutil/hexutil_bench_test.go

@@ -17,6 +17,8 @@
 package hexutil
 
 import (
+	"encoding/hex"
+	"fmt"
 	"math/big"
 	"testing"
 )
@@ -33,3 +35,25 @@ func BenchmarkEncodeBig(b *testing.B) {
 		}
 	}
 }
+
+func BenchmarkAppendQuoted(b *testing.B) {
+	for _, n := range []int{20, 32, 64, 256, 1024} {
+		src := make([]byte, n)
+		for i := range src {
+			src[i] = byte(i * 7)
+		}
+		dst := make([]byte, 0, QuotedLen(n))
+		b.Run(fmt.Sprintf("stdlib/%d", n), func(b *testing.B) {
+			b.SetBytes(int64(n))
+			for b.Loop() {
+				dst = append(hex.AppendEncode(append(dst[:0], `"0x`...), src), '"')
+			}
+		})
+		b.Run(fmt.Sprintf("hexutil/%d", n), func(b *testing.B) {
+			b.SetBytes(int64(n))
+			for b.Loop() {
+				dst = AppendQuoted(dst[:0], src)
+			}
+		})
+	}
+}

common/hexutil/hexutil_test.go

@@ -17,8 +17,10 @@
 package hexutil
 
 import (
+	"encoding/hex"
 	"fmt"
 	"math/big"
+	"math/rand/v2"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -261,3 +263,20 @@ func TestIsValidQuantity(t *testing.T) {
 		})
 	}
 }
+
+func TestEncodeHexMatchesStdlib(t *testing.T) {
+	r := rand.New(rand.NewPCG(1, 2))
+	for n := 0; n <= 300; n++ {
+		src := make([]byte, n)
+		for i := range src {
+			src[i] = byte(r.Uint32())
+		}
+		want := hex.EncodeToString(src)
+		dst := make([]byte, 2*n)
+		encodeHex(dst, src)
+		require.Equal(t, want, string(dst), "len %d", n)
+		require.Equal(t, `x"0x`+want+`"`, string(AppendQuoted([]byte("x"), src)), "len %d", n)
+		text, _ := Bytes(src).AppendText([]byte("x"))
+		require.Equal(t, "x0x"+want, string(text), "len %d", n)
+	}
+}