make perf changes to memoize and remove gc pressure

Author: tac0turtle

block/internal/cache/generic_cache.go

@@ -61,6 +61,10 @@ func (c *Cache) isSeen(hash string) bool {
 func (c *Cache) setSeen(hash string, height uint64) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
+	if existing, ok := c.hashByHeight[height]; ok && existing == hash {
+		c.hashes[existing] = true
+		return
+	}
 	c.hashes[hash] = true
 	c.hashByHeight[height] = hash
 }

block/internal/syncing/syncer.go

@@ -1166,8 +1166,9 @@ func (s *Syncer) IsSyncedWithRaft(raftState *raft.RaftBlockState) (int, error) {
 		s.logger.Error().Err(err).Uint64("height", raftState.Height).Msg("failed to get header for sync check")
 		return 0, fmt.Errorf("get header for sync check at height %d: %w", raftState.Height, err)
 	}
-	if !bytes.Equal(header.Hash(), raftState.Hash) {
-		return 0, fmt.Errorf("header hash mismatch: %x vs %x", header.Hash(), raftState.Hash)
+	headerHash := header.Hash()
+	if !bytes.Equal(headerHash, raftState.Hash) {
+		return 0, fmt.Errorf("header hash mismatch: %x vs %x", headerHash, raftState.Hash)
 	}
 
 	return 0, nil

pkg/store/cached_store.go

@@ -97,6 +97,8 @@ func (cs *CachedStore) GetHeader(ctx context.Context, height uint64) (*types.Sig
 		return nil, err
 	}
 
+	header.MemoizeHash()
+
 	// Add to cache
 	cs.headerCache.Add(height, header)
 
@@ -116,6 +118,8 @@ func (cs *CachedStore) GetBlockData(ctx context.Context, height uint64) (*types.
 		return nil, nil, err
 	}
 
+	header.MemoizeHash()
+
 	// Add to cache
 	cs.blockDataCache.Add(height, &blockDataEntry{header: header, data: data})
 

types/hashing.go

@@ -41,12 +41,38 @@ func (h *Header) HashLegacy() (Hash, error) {
 	return hash[:], nil
 }
 
-// Hash returns hash of the header
+// Hash returns the header hash. It reuses a memoized value if one has already
+// been prepared via MemoizeHash, but it does not write to the header itself.
 func (h *Header) Hash() Hash {
 	if h == nil {
 		return nil
 	}
+	if h.cachedHash != nil {
+		return h.cachedHash
+	}
+
+	return h.computeHash()
+}
+
+// MemoizeHash computes the header hash and stores it on the header for future
+// Hash() calls. Call this before publishing the header to shared goroutines or
+// caches.
+func (h *Header) MemoizeHash() Hash {
+	if h == nil {
+		return nil
+	}
+	if h.cachedHash != nil {
+		return h.cachedHash
+	}
+
+	hash := h.computeHash()
+	if hash != nil {
+		h.cachedHash = hash
+	}
+	return hash
+}
 
+func (h *Header) computeHash() Hash {
 	slimHash, err := h.HashSlim()
 	if err != nil {
 		return nil
@@ -62,6 +88,14 @@ func (h *Header) Hash() Hash {
 	return slimHash
 }
 
+// InvalidateHash clears the memoized hash, forcing recomputation on the next
+// Hash() call. Must be called after any mutation of Header fields.
+func (h *Header) InvalidateHash() {
+	if h != nil {
+		h.cachedHash = nil
+	}
+}
+
 // Hash returns hash of the Data
 func (d *Data) Hash() Hash {
 	// Ignoring the marshal error for now to satisfy the go-header interface

types/hashing_test.go

@@ -21,6 +21,11 @@ func TestHeaderHash(t *testing.T) {
 	}
 
 	hash1 := header.Hash()
+	assert.Nil(t, header.cachedHash, "Hash() should not memoize")
+
+	memoizedHash := header.MemoizeHash()
+	assert.Equal(t, hash1, memoizedHash)
+	assert.NotNil(t, header.cachedHash, "MemoizeHash() should store the computed value")
 
 	headerBytes, err := header.MarshalBinary()
 	require.NoError(t, err)
@@ -31,6 +36,8 @@ func TestHeaderHash(t *testing.T) {
 	assert.Equal(t, Hash(expectedHash[:]), hash1, "Header hash should match manual calculation")
 
 	header.BaseHeader.Height = 2
+	header.InvalidateHash()
+	assert.Nil(t, header.cachedHash)
 	hash2 := header.Hash()
 	assert.NotEqual(t, hash1, hash2, "Different headers should have different hashes")
 }
@@ -143,3 +150,17 @@ func TestHeaderHashWithBytes(t *testing.T) {
 	require.NoError(t, targetHeader.UnmarshalBinary(headerBytes))
 	assert.Equal(t, hash1, targetHeader.Hash(), "HeaderHash should produce same result as Header.Hash()")
 }
+
+func TestHeaderCloneDropsCachedHash(t *testing.T) {
+	header := &Header{
+		BaseHeader: BaseHeader{Height: 1, Time: 1234567890},
+		DataHash:   []byte("datahash"),
+	}
+
+	header.MemoizeHash()
+	require.NotNil(t, header.cachedHash)
+
+	clone := header.Clone()
+	assert.Nil(t, clone.cachedHash, "Clone should not copy memoized hash state")
+	assert.Equal(t, header.Hash(), clone.Hash())
+}

types/header.go

@@ -82,6 +82,10 @@ type Header struct {
 	// representation but may still be required for backwards compatible binary
 	// serialization (e.g. legacy signing payloads).
 	Legacy *LegacyHeaderFields
+
+	// cachedHash holds the memoized result of MemoizeHash(). nil means cold.
+	// Any caller that mutates header fields must call InvalidateHash() to clear it.
+	cachedHash Hash
 }
 
 // New creates a new Header.
@@ -250,6 +254,7 @@ func (h *Header) ApplyLegacyDefaults() {
 		h.Legacy = &LegacyHeaderFields{}
 	}
 	h.Legacy.EnsureDefaults()
+	h.InvalidateHash()
 }
 
 // Clone creates a deep copy of the header, ensuring all mutable slices are
@@ -262,6 +267,7 @@ func (h Header) Clone() Header {
 	clone.ValidatorHash = cloneBytes(h.ValidatorHash)
 	clone.ProposerAddress = cloneBytes(h.ProposerAddress)
 	clone.Legacy = h.Legacy.Clone()
+	clone.cachedHash = nil
 
 	return clone
 }

types/serialization.go

@@ -257,6 +257,7 @@ func (h *Header) FromProto(other *pb.Header) error {
 	if other == nil {
 		return errors.New("header is nil")
 	}
+	h.InvalidateHash()
 	if other.Version != nil {
 		h.Version.Block = other.Version.Block
 		h.Version.App = other.Version.App

types/serialization_test.go

@@ -356,6 +356,27 @@ func TestHeader_HashFields_NilAndEmpty(t *testing.T) {
 	assert.Nil(t, h2.ValidatorHash)
 }
 
+func TestHeaderFromProtoClearsCachedHash(t *testing.T) {
+	t.Parallel()
+
+	header := &Header{
+		BaseHeader: BaseHeader{Height: 1, Time: 1234567890},
+		DataHash:   []byte("datahash"),
+	}
+	header.MemoizeHash()
+	require.NotNil(t, header.cachedHash)
+
+	protoMsg := (&Header{
+		BaseHeader: BaseHeader{Height: 2, Time: 1234567891},
+		DataHash:   []byte("otherhash"),
+	}).ToProto()
+
+	require.NoError(t, header.FromProto(protoMsg))
+	assert.Nil(t, header.cachedHash)
+	assert.Equal(t, uint64(2), header.Height())
+	assert.Equal(t, Hash([]byte("otherhash")), header.DataHash)
+}
+
 func TestHeaderMarshalBinary_PreservesLegacyFields(t *testing.T) {
 	t.Parallel()
 

types/utils.go

@@ -126,6 +126,7 @@ func GetRandomNextHeader(header Header, chainID string) Header {
 	nextHeader.LastHeaderHash = header.Hash()
 	nextHeader.ProposerAddress = header.ProposerAddress
 	nextHeader.ValidatorHash = header.ValidatorHash
+	nextHeader.InvalidateHash()
 	return nextHeader
 }
 

types/utils_test.go

@@ -2,6 +2,7 @@ package types_test
 
 import (
 	// Import bytes package
+	"crypto/sha256"
 	"testing"
 	"time" // Used for time.Time comparison
 
@@ -56,6 +57,20 @@ func TestGetRandomHeader(t *testing.T) {
 	}
 }
 
+func TestGetRandomNextHeader_InvalidatesCachedHash(t *testing.T) {
+	header := types.GetRandomHeader("TestGetRandomNextHeader", types.GetRandomBytes(32))
+	header.MemoizeHash()
+
+	nextHeader := types.GetRandomNextHeader(header, "TestGetRandomNextHeader")
+	gotHash := nextHeader.Hash()
+
+	headerBytes, err := nextHeader.MarshalBinary()
+	assert.NoError(t, err)
+	expected := sha256.Sum256(headerBytes)
+
+	assert.Equal(t, types.Hash(expected[:]), gotHash)
+}
+
 func TestGetFirstSignedHeader(t *testing.T) {
 	testCases := []struct {
 		name    string