Use New Cache Key For Unaggregated Attestations

CHANGELOG.md

@@ -50,6 +50,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Capella blocks are execution.
 - Fixed panic when http request to subscribe to event stream fails.
 - Return early for blob reconstructor during capella fork
+- Add more efficient method of computing the cache key for unaggregated attestations.
 
 ### Deprecated
 

beacon-chain/sync/BUILD.bazel

@@ -149,6 +149,7 @@ go_test(
     size = "small",
     srcs = [
         "batch_verifier_test.go",
+        "benchmark_test.go",
         "blobs_test.go",
         "block_batcher_test.go",
         "broadcast_bls_changes_test.go",
@@ -268,3 +269,20 @@ go_test(
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
+
+go_test(
+    name = "go_benchmark_test",
+    size = "medium",
+    srcs = ["benchmark_test.go"],
+    args = [
+        "-test.bench=.",
+        "-test.benchmem",
+        "-test.v",
+    ],
+    embed = [":go_default_library"],
+    local = True,
+    tags = [
+        "benchmark",
+        "no-cache",
+    ],
+)

beacon-chain/sync/benchmark_test.go

@@ -0,0 +1,25 @@
+package sync
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+)
+
+func BenchmarkCacheKeyImplementations(b *testing.B) {
+
+	b.Run("Old Cache Key Implementation", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			b := append(bytesutil.Bytes32(uint64(i)), bytesutil.Bytes32(uint64(i+10))...)
+			b = append(b, bytesutil.SafeCopyBytes([]byte("random"))...)
+			_ = string(b)
+		}
+	})
+
+	b.Run("New Cache Key Implementation", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			_ = seenAttCacheKey(primitives.Slot(i), primitives.CommitteeIndex(i+10), []byte("random"))
+		}
+	})
+}

beacon-chain/sync/validate_beacon_attestation.go

@@ -2,6 +2,7 @@ package sync
 
 import (
 	"context"
+	"encoding/binary"
 	"fmt"
 	"reflect"
 	"strings"
@@ -306,19 +307,15 @@ func (s *Service) validateBitLength(
 func (s *Service) hasSeenCommitteeIndicesSlot(slot primitives.Slot, committeeID primitives.CommitteeIndex, aggregateBits []byte) bool {
 	s.seenUnAggregatedAttestationLock.RLock()
 	defer s.seenUnAggregatedAttestationLock.RUnlock()
-	b := append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(committeeID))...)
-	b = append(b, aggregateBits...)
-	_, seen := s.seenUnAggregatedAttestationCache.Get(string(b))
+	_, seen := s.seenUnAggregatedAttestationCache.Get(seenAttCacheKey(slot, committeeID, aggregateBits))
 	return seen
 }
 
 // Set committee's indices and slot as seen for incoming attestations.
 func (s *Service) setSeenCommitteeIndicesSlot(slot primitives.Slot, committeeID primitives.CommitteeIndex, aggregateBits []byte) {
 	s.seenUnAggregatedAttestationLock.Lock()
 	defer s.seenUnAggregatedAttestationLock.Unlock()
-	b := append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(committeeID))...)
-	b = append(b, bytesutil.SafeCopyBytes(aggregateBits)...)
-	s.seenUnAggregatedAttestationCache.Add(string(b), true)
+	s.seenUnAggregatedAttestationCache.Add(seenAttCacheKey(slot, committeeID, aggregateBits), true)
 }
 
 // hasBlockAndState returns true if the beacon node knows about a block and associated state in the
@@ -328,3 +325,15 @@ func (s *Service) hasBlockAndState(ctx context.Context, blockRoot [32]byte) bool
 	hasState := hasStateSummary || s.cfg.beaconDB.HasState(ctx, blockRoot)
 	return hasState && s.cfg.chain.HasBlock(ctx, blockRoot)
 }
+
+// Amount of bytes required to store a uint64 value.
+const uint64ByteLength = 8
+
+func seenAttCacheKey(slot primitives.Slot, committeeID primitives.CommitteeIndex, aggregationBits []byte) string {
+	totalLen := uint64ByteLength + uint64ByteLength + len(aggregationBits)
+	key := make([]byte, totalLen)
+	binary.LittleEndian.PutUint64(key[:8], uint64(slot))
+	binary.LittleEndian.PutUint64(key[8:16], uint64(committeeID))
+	copy(key[16:], aggregationBits)
+	return bytesutil.UnsafeCastToString(key)
+}

beacon-chain/sync/validate_beacon_attestation_test.go

@@ -327,3 +327,11 @@ func TestService_setSeenCommitteeIndicesSlot(t *testing.T) {
 	require.Equal(t, false, s.hasSeenCommitteeIndicesSlot(0, 2, b1))
 	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(1, 2, b1))
 }
+
+func TestAttestationCacheKey(t *testing.T) {
+	stringKey := seenAttCacheKey(1, 1024, []byte("aggregation"))
+	wantedKey := append(bytesutil.Bytes8(1), bytesutil.Bytes8(1024)...)
+	wantedKey = append(wantedKey, []byte("aggregation")...)
+
+	require.Equal(t, string(wantedKey), stringKey)
+}