perf: use autoresearch to reduce allocations (#3225)

* Baseline - current block production performance with 100 txs

Result: {"status":"keep","allocs_per_op":81,"bytes_per_op":25934,"ns_per_op":34001}

* sync.Pool for sha256.Hash in leafHashOpt — eliminates 2 sha256.New() allocations per block

Result: {"status":"keep","allocs_per_op":79,"bytes_per_op":25697,"ns_per_op":34147}

* Unsafe reinterpret cast of Txs to [][]byte in ApplyBlock — eliminates make([][]byte, n) allocation

Result: {"status":"keep","allocs_per_op":78,"bytes_per_op":22996,"ns_per_op":33091}

* Direct pb.Data serialization in DACommitment — avoids pruned Data wrapper and txsToByteSlices allocations

Result: {"status":"keep","allocs_per_op":77,"bytes_per_op":20276,"ns_per_op":32480}

* unsafe.Slice in Data.ToProto() — eliminates txsToByteSlices [][]byte allocation

Result: {"status":"keep","allocs_per_op":74,"bytes_per_op":12192,"ns_per_op":31624}

* sync.Pool for protobuf message structs in MarshalBinary — eliminates 10 allocs per block

Replace per-call allocation of pb.Header/pb.Version/pb.Data/pb.Metadata with
sync.Pool reuse in the hot MarshalBinary path. ToProto() API is unchanged —
only MarshalBinary is affected since it consumes the result immediately.

Metrics (100_txs benchmark):
- 74 → 64 allocs/op (-13.5%)
- ~12.1 → ~11.1 KB (-8.3%)
- ~31ns flat

* pool SignedHeader.MarshalBinary — reuse pb.SignedHeader/pb.Header/pb.Signer/pb.Version

Eliminates 4 struct allocations per signed header marshal: pb.SignedHeader,
pb.Header, pb.Version, pb.Signer. These are now borrowed from sync.Pool and
returned after proto.Marshal completes.

Metrics (100_txs benchmark):
- 64 → 56 allocs/op
- ~11KB → ~10.2KB

* pool State.MarshalBinary and use it in UpdateState — saves 2 allocs per block

State.ToProto allocated pb.State + pb.Version + timestamppb.Timestamp per block.
MarshalBinary now pools those structs and returns the marshaled bytes directly.
pkg/store/batch.UpdateState switched from ToProto+proto.Marshal to MarshalBinary.

* fix lint

* remove files

* remove extra comments

* deps

* comments

* go fix

* changes++

---------

Co-authored-by: Julien Robert <julien@rbrt.fr>

Author: tac0turtle

block/internal/executing/executor.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"sync/atomic"
 	"time"
+	"unsafe"
 
 	"github.com/ipfs/go-datastore"
 	"github.com/libp2p/go-libp2p/core/crypto"
@@ -801,14 +802,12 @@ func (e *Executor) CreateBlock(ctx context.Context, height uint64, batchData *Ba
 func (e *Executor) ApplyBlock(ctx context.Context, header types.Header, data *types.Data) (types.State, error) {
 	currentState := e.getLastState()
 
-	// Convert Txs to [][]byte for the execution client.
-	// types.Tx is []byte, so this is a type conversion, not a copy.
+	// Reinterpret []Tx as [][]byte without allocation.
+	// types.Tx is defined as []byte and has the same slice-header layout.
+	// Using unsafe.Slice/unsafe.SliceData avoids the heap allocation of make([][]byte, n).
 	var rawTxs [][]byte
 	if n := len(data.Txs); n > 0 {
-		rawTxs = make([][]byte, n)
-		for i, tx := range data.Txs {
-			rawTxs[i] = []byte(tx)
-		}
+		rawTxs = unsafe.Slice((*[]byte)(unsafe.SliceData(data.Txs)), n)
 	}
 
 	// Execute transactions

pkg/store/batch.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	ds "github.com/ipfs/go-datastore"
-	"google.golang.org/protobuf/proto"
 
 	"github.com/evstack/ev-node/types"
 )
@@ -84,18 +83,13 @@ func (b *DefaultBatch) SaveBlockDataFromBytes(header *types.SignedHeader, header
 	return nil
 }
 
-// UpdateState updates the state in the batch
+// UpdateState updates the state in the batch.
 func (b *DefaultBatch) UpdateState(state types.State) error {
-	// Save the state at the height specified in the state itself
 	height := state.LastBlockHeight
 
-	pbState, err := state.ToProto()
+	data, err := state.MarshalBinary()
 	if err != nil {
-		return fmt.Errorf("failed to convert type state to protobuf type: %w", err)
-	}
-	data, err := proto.Marshal(pbState)
-	if err != nil {
-		return fmt.Errorf("failed to marshal state to protobuf: %w", err)
+		return fmt.Errorf("failed to marshal state: %w", err)
 	}
 
 	return b.batch.Put(b.ctx, ds.RawKey(getStateAtHeightKey(height)), data)

types/hash_memo_bench_test.go

@@ -0,0 +1,42 @@
+package types
+
+import (
+	"testing"
+)
+
+// BenchmarkHeaderHash_NoMemo measures the cost of the old 3× call pattern with no
+// memoization: each call re-marshals every field via ToProto → proto.Marshal → sha256.
+func BenchmarkHeaderHash_NoMemo(b *testing.B) {
+	h := GetRandomHeader("bench-chain", GetRandomBytes(32))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_ = h.Hash()
+		_ = h.Hash()
+		_ = h.Hash()
+	}
+}
+
+// BenchmarkHeaderHash_Memoized measures the cost of the same 3× call pattern after
+// explicit memoization: first call pays full cost, subsequent two are cache hits.
+func BenchmarkHeaderHash_Memoized(b *testing.B) {
+	h := GetRandomHeader("bench-chain", GetRandomBytes(32))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		h.InvalidateHash()
+		_ = h.MemoizeHash() // compute and store
+		_ = h.Hash()        // cache hit
+		_ = h.Hash()        // cache hit
+	}
+}
+
+// BenchmarkHeaderHash_Single is a baseline: cost of one Hash() call with a cold cache.
+func BenchmarkHeaderHash_Single(b *testing.B) {
+	h := GetRandomHeader("bench-chain", GetRandomBytes(32))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_ = h.Hash()
+	}
+}

types/hashing.go

@@ -4,10 +4,25 @@ import (
 	"crypto/sha256"
 	"errors"
 	"hash"
+	"sync"
+	"unsafe"
+
+	"google.golang.org/protobuf/proto"
+
+	pb "github.com/evstack/ev-node/types/pb/evnode/v1"
 )
 
 var (
 	leafPrefix = []byte{0}
+
+	// sha256Pool reuses sha256 Hash instances to avoid per-block allocation.
+	// sha256.New() allocates ~213 bytes (216B on 64-bit) per call. Pooling
+	// eliminates this allocation entirely in the hot path.
+	sha256Pool = sync.Pool{
+		New: func() any {
+			return sha256.New()
+		},
+	}
 )
 
 // HashSlim returns the SHA256 hash of the header using the slim (current) binary encoding.
@@ -105,17 +120,21 @@ func (d *Data) Hash() Hash {
 	// Ignoring the marshal error for now to satisfy the go-header interface
 	// Later on the usage of Hash should be replaced with DA commitment
 	dBytes, _ := d.MarshalBinary()
-	return leafHashOpt(sha256.New(), dBytes)
+	s := sha256Pool.Get().(hash.Hash)
+	defer sha256Pool.Put(s)
+	return leafHashOpt(s, dBytes)
 }
 
-// DACommitment returns the DA commitment of the Data excluding the Metadata
+// DACommitment returns the DA commitment of the Data excluding the Metadata.
 func (d *Data) DACommitment() Hash {
-	// Prune the Data to only include the Txs
-	prunedData := &Data{
-		Txs: d.Txs,
+	var pbData pb.Data
+	if d.Txs != nil {
+		pbData.Txs = unsafe.Slice((*[]byte)(unsafe.SliceData(d.Txs)), len(d.Txs))
 	}
-	dBytes, _ := prunedData.MarshalBinary()
-	return leafHashOpt(sha256.New(), dBytes)
+	dBytes, _ := proto.Marshal(&pbData)
+	s := sha256Pool.Get().(hash.Hash)
+	defer sha256Pool.Put(s)
+	return leafHashOpt(s, dBytes)
 }
 
 func leafHashOpt(s hash.Hash, leaf []byte) []byte {