BAL cache lineage (PR #6 of the perf stack)

cmd/evm/staterunner.go

@@ -35,6 +35,7 @@ import (
 	"github.com/erigontech/erigon/common/log/v3"
 	"github.com/erigontech/erigon/db/datadir"
 	"github.com/erigontech/erigon/db/kv/temporal/temporaltest"
+	"github.com/erigontech/erigon/db/state/execctx"
 	"github.com/erigontech/erigon/execution/tests/testutil"
 	"github.com/erigontech/erigon/execution/tracing/tracers/logger"
 	"github.com/erigontech/erigon/execution/vm"
@@ -224,7 +225,18 @@ func runStateTest(ctx *cli.Context, cfg vm.Config, fname string) ([]testResult,
 				}
 				defer tx.Rollback()
 
-				statedb, root, err := test.Run(nil, tx, st, cfg, dirs)
+				// Per-subtest SD scope: caller-owned, never Flushed. Closing
+				// without Flush discards every write made during the subtest
+				// (pre-state + tx execution + commitment), so per-subtest state
+				// never enters the long-lived branch cache.
+				sd, err := execctx.NewSharedDomains(context.Background(), tx, log.New())
+				if err != nil {
+					result.Pass, result.Error = false, err.Error()
+					return
+				}
+				defer sd.Close()
+
+				statedb, root, err := test.Run(nil, sd, tx, st, cfg, dirs)
 				if err != nil {
 					result.Pass, result.Error = false, err.Error()
 				}
@@ -238,8 +250,26 @@ func runStateTest(ctx *cli.Context, cfg vm.Config, fname string) ([]testResult,
 					}
 				}
 				if bench {
+					// Run the benchmark on a fresh tx + SD so the timed work
+					// starts from the same pre-state every iteration; the
+					// preceding test.Run mutated sd in place (pre-state +
+					// tx execution + commitment), which would otherwise
+					// skew the gas/throughput numbers.
+					benchTx, err := db.BeginTemporalRw(context.Background())
+					if err != nil {
+						result.Pass, result.Error = false, err.Error()
+						return
+					}
+					defer benchTx.Rollback()
+					benchSD, err := execctx.NewSharedDomains(context.Background(), benchTx, log.New())
+					if err != nil {
+						result.Pass, result.Error = false, err.Error()
+						return
+					}
+					defer benchSD.Close()
+
 					_, stats, _ := timedExec(true, func() ([]byte, uint64, error) {
-						_, _, gasUsed, _ := test.RunNoVerify(nil, tx, st, cfg, dirs)
+						_, _, gasUsed, _ := test.RunNoVerify(nil, benchSD, benchTx, st, cfg, dirs)
 						return nil, gasUsed, nil
 					})
 					result.Stats = &stats

common/dbg/experiments.go

@@ -120,8 +120,20 @@ var (
 	BorValidateHeaderTime = EnvBool("BOR_VALIDATE_HEADER_TIME", true)
 	TraceDeletion         = EnvBool("TRACE_DELETION", false)
 
-	RpcDropResponse  = EnvBool("RPC_DROP_RESPONSE", false)
-	TipTrieWarmupers = EnvInt("TIP_TRIE_WARMUPERS", runtime.NumCPU()*8) //io-bound (not cpu-bound). it's ok to have `io-threads > cpus`
+	RpcDropResponse = EnvBool("RPC_DROP_RESPONSE", false)
+	// The original default was NumCPU()*8 with the rationale "io-bound, more
+	// workers drive more concurrent I/O." Our measurements (cold-cgroup 6c
+	// vs unconstrained 12c on the SSTORE-bloat bench) show read_bytes
+	// nearly identical (1.28 GB vs 1.24 GB) regardless of worker count,
+	// and 76 % of TEST-block CPU sits in the warmer's recsplit/xorfilter/
+	// seg-decompress path. The hot path is CPU-bound, not I/O-bound; the
+	// "drives I/O" rationale isn't borne out. Oversubscribing past
+	// available cores adds scheduler/context-switch overhead and queue
+	// noise without throughput gain. The constraint is queue depth on the
+	// warmer's work channel (sized at numWorkers*64), not worker count.
+	// GOMAXPROCS respects cgroup CPU caps under Go 1.25+, so this scales
+	// correctly inside a constrained envelope.
+	TipTrieWarmupers = EnvInt("TIP_TRIE_WARMUPERS", runtime.GOMAXPROCS(0))
 
 	PerfProfiles = EnvBool("PERF_PROFILES", false)
 )

common/maphash/maphash.go

@@ -61,6 +61,24 @@ func (m *Map[V]) Clear() {
 	m.m.Clear()
 }
 
+// Range iterates over every (hash, value) pair. Iteration order is
+// unspecified. Return false from fn to stop early. Concurrent
+// modification during Range is permitted by the underlying xsync.Map.
+//
+// The original byte-key is not recoverable — Set hashes-and-discards.
+// Pair with DeleteByHash to evict entries discovered via Range.
+func (m *Map[V]) Range(fn func(hash uint64, v V) bool) {
+	m.m.Range(func(key uint64, value V) bool {
+		return fn(key, value)
+	})
+}
+
+// DeleteByHash removes the entry under the pre-computed hash. Use
+// alongside Range when the byte-key is unknown.
+func (m *Map[V]) DeleteByHash(hash uint64) {
+	m.m.Delete(hash)
+}
+
 // NonConcurrentMap is a non-thread-safe map that uses maphash to hash []byte keys.
 // Use this when you don't need concurrent access for better performance.
 type NonConcurrentMap[V any] struct {
@@ -163,3 +181,30 @@ func (l *LRU[V]) SetByHash(hash uint64, value V) {
 func (l *LRU[V]) ContainsByHash(hash uint64) bool {
 	return l.cache.Contains(hash)
 }
+
+// DeleteByHash removes the entry under the pre-computed hash. Use
+// alongside Range when the byte-key is unknown.
+func (l *LRU[V]) DeleteByHash(hash uint64) {
+	l.cache.Remove(hash)
+}
+
+// Range iterates over every (hash, value) pair without affecting LRU
+// recency (uses Peek under the hood). Iteration order is unspecified.
+// Return false from fn to stop early.
+//
+// The original byte-key is not recoverable — Set hashes-and-discards.
+// Use the hash itself as the identity in callers that need cross-cache
+// comparisons; same byte-key always maps to the same hash, so equality
+// of (hash, value) sets is equivalent to equality of (key, value) sets
+// modulo collision (vanishingly unlikely at typical working-set sizes).
+func (l *LRU[V]) Range(fn func(hash uint64, v V) bool) {
+	for _, h := range l.cache.Keys() {
+		v, ok := l.cache.Peek(h)
+		if !ok {
+			continue
+		}
+		if !fn(h, v) {
+			return
+		}
+	}
+}

db/datastruct/existence/existence_filter.go

@@ -22,6 +22,7 @@ import (
 	"hash"
 	"os"
 	"path/filepath"
+	"sync/atomic"
 
 	bloomfilter "github.com/holiman/bloomfilter/v2"
 
@@ -79,15 +80,40 @@ func (b *Filter) AddHash(hash uint64) error {
 	b.filter.AddHash(hash)
 	return nil
 }
+
+// Process-cumulative counters of ContainsHash outcomes.
+// True = "probably present" (filter does not short-circuit, lookup proceeds).
+// False = "definitely not present" (filter short-circuits the lookup).
+// Hit-rate = true / (true + false). Used to size the value of bypassing
+// the filter for callers known to lookup present keys (e.g. warmer).
+var (
+	containsTrueCount  atomic.Uint64
+	containsFalseCount atomic.Uint64
+)
+
+// ContainsHashStats returns (true, false) cumulative counts since process
+// start. To get a per-block delta, snapshot before/after.
+func ContainsHashStats() (containsTrue, containsFalse uint64) {
+	return containsTrueCount.Load(), containsFalseCount.Load()
+}
+
 func (b *Filter) ContainsHash(hashedKey uint64) bool {
 	if b.empty {
+		containsTrueCount.Add(1)
 		return true
 	}
+	var ok bool
 	if b.useFuse {
-		return b.fuseReader.ContainsHash(hashedKey)
+		ok = b.fuseReader.ContainsHash(hashedKey)
+	} else {
+		ok = b.filter.ContainsHash(hashedKey)
 	}
-
-	return b.filter.ContainsHash(hashedKey)
+	if ok {
+		containsTrueCount.Add(1)
+	} else {
+		containsFalseCount.Add(1)
+	}
+	return ok
 }
 func (b *Filter) Contains(v hash.Hash64) bool {
 	if b.empty {

db/kv/kv_interface.go

@@ -530,6 +530,7 @@ type TemporalMemBatch interface {
 	HasPrefixInRAM(domain Domain, prefix []byte) bool
 	SizeEstimate() uint64
 	Flush(ctx context.Context, tx RwTx) error
+	FlushWithCallback(ctx context.Context, tx RwTx, cb func(domain Domain, k []byte, v []byte, txNum uint64)) error
 	Close()
 	PutForkable(id ForkableId, num Num, v []byte) error
 	DiscardWrites(domain Domain)

db/kv/tables.go

@@ -61,8 +61,6 @@ const (
 	HeaderTD        = "HeadersTotalDifficulty" // block_num_u64 + hash -> td (RLP)
 
 	BlockBody = "BlockBody" // block_num_u64 + hash -> block body
-	// BlockAccessList stores RLP-encoded block access lists, keyed by block_num_u64 + hash.
-	BlockAccessList = "BlockAccessList"
 
 	// Naming:
 	//  TxNum - Ethereum canonical transaction number - same across all nodes.
@@ -315,7 +313,6 @@ var ChaindataTables = []string{
 	HeaderNumber,
 	BadHeaderNumber,
 	BlockBody,
-	BlockAccessList,
 	TxLookup,
 	ConfigTable,
 	DatabaseInfo,

db/rawdb/accessors_chain.go

@@ -595,23 +595,6 @@ func ReadBody(db kv.Getter, hash common.Hash, number uint64) (*types.Body, uint6
 	return body, bodyForStorage.BaseTxnID.First(), bodyForStorage.TxCount - 2 // 1 system txn in the beginning of block, and 1 at the end
 }
 
-// ReadBlockAccessListBytes reads the RLP-encoded block access list sidecar for a block.
-func ReadBlockAccessListBytes(db kv.Getter, hash common.Hash, number uint64) ([]byte, error) {
-	data, err := db.GetOne(kv.BlockAccessList, dbutils.BlockBodyKey(number, hash))
-	if err != nil {
-		return nil, err
-	}
-	return data, nil
-}
-
-// WriteBlockAccessListBytes stores the RLP-encoded block access list sidecar for a block.
-func WriteBlockAccessListBytes(db kv.Putter, hash common.Hash, number uint64, data []byte) error {
-	if err := db.Put(kv.BlockAccessList, dbutils.BlockBodyKey(number, hash), data); err != nil {
-		return fmt.Errorf("failed to store block access list: %w", err)
-	}
-	return nil
-}
-
 func HasSenders(db kv.Getter, hash common.Hash, number uint64) (bool, error) {
 	return db.Has(kv.Senders, dbutils.BlockBodyKey(number, hash))
 }
@@ -698,9 +681,6 @@ func DeleteBody(db kv.Putter, hash common.Hash, number uint64) {
 	if err := db.Delete(kv.BlockBody, dbutils.BlockBodyKey(number, hash)); err != nil {
 		log.Crit("Failed to delete block body", "err", err)
 	}
-	if err := db.Delete(kv.BlockAccessList, dbutils.BlockBodyKey(number, hash)); err != nil {
-		log.Crit("Failed to delete block access list", "err", err)
-	}
 }
 
 func AppendCanonicalTxNums(tx kv.RwTx, from uint64) (err error) {
@@ -898,9 +878,6 @@ func PruneBlocks(tx kv.RwTx, blockTo uint64, blocksDeleteLimit int) (deleted int
 		if err = tx.Delete(kv.BlockBody, kCopy); err != nil {
 			return deleted, err
 		}
-		if err = tx.Delete(kv.BlockAccessList, kCopy); err != nil {
-			return deleted, err
-		}
 		if err = tx.Delete(kv.Headers, kCopy); err != nil {
 			return deleted, err
 		}
@@ -949,9 +926,6 @@ func TruncateBlocks(ctx context.Context, tx kv.RwTx, blockFrom uint64) error {
 		if err := tx.Delete(kv.BlockBody, kCopy); err != nil {
 			return err
 		}
-		if err := tx.Delete(kv.BlockAccessList, kCopy); err != nil {
-			return err
-		}
 		if err := tx.Delete(kv.Headers, kCopy); err != nil {
 			return err
 		}

db/rawdb/accessors_chain_test.go

@@ -40,7 +40,6 @@ import (
 	"github.com/erigontech/erigon/execution/execmodule/execmoduletester"
 	"github.com/erigontech/erigon/execution/rlp"
 	"github.com/erigontech/erigon/execution/types"
-	"github.com/erigontech/erigon/execution/types/accounts"
 )
 
 func newTestLegacyTx(nonce uint64, to common.Address, value uint256.Int, gasLimit uint64, gasPrice uint256.Int) *types.LegacyTx {
@@ -1127,59 +1126,6 @@ func TestBlockWithdrawalsStorage(t *testing.T) {
 	require.Nil(entry)
 }
 
-func TestBlockAccessListStorage(t *testing.T) {
-	t.Parallel()
-	_, tx := memdb.NewTestTx(t)
-	defer tx.Rollback()
-
-	block := types.NewBlockWithHeader(&types.Header{
-		Number:      *uint256.NewInt(1),
-		Extra:       []byte("test block"),
-		UncleHash:   empty.UncleHash,
-		TxHash:      empty.RootHash,
-		ReceiptHash: empty.RootHash,
-	})
-
-	data, err := rawdb.ReadBlockAccessListBytes(tx, block.Hash(), block.NumberU64())
-	require.NoError(t, err)
-	require.Empty(t, data)
-
-	nonEmpty := types.BlockAccessList{
-		{
-			Address: accounts.InternAddress(common.HexToAddress("0x00000000000000000000000000000000000000aa")),
-		},
-	}
-	nonEmptyBytes, err := types.EncodeBlockAccessListBytes(nonEmpty)
-	require.NoError(t, err)
-	require.NoError(t, rawdb.WriteBlockAccessListBytes(tx, block.Hash(), block.NumberU64(), nonEmptyBytes))
-
-	data, err = rawdb.ReadBlockAccessListBytes(tx, block.Hash(), block.NumberU64())
-	require.NoError(t, err)
-	require.Equal(t, nonEmptyBytes, data)
-
-	decoded, err := types.DecodeBlockAccessListBytes(data)
-	require.NoError(t, err)
-	require.NoError(t, decoded.Validate())
-	require.Equal(t, nonEmpty.Hash(), decoded.Hash())
-
-	emptyBytes, err := types.EncodeBlockAccessListBytes(nil)
-	require.NoError(t, err)
-	require.NoError(t, rawdb.WriteBlockAccessListBytes(tx, block.Hash(), block.NumberU64(), emptyBytes))
-
-	data, err = rawdb.ReadBlockAccessListBytes(tx, block.Hash(), block.NumberU64())
-	require.NoError(t, err)
-	require.Equal(t, emptyBytes, data)
-
-	decoded, err = types.DecodeBlockAccessListBytes(data)
-	require.NoError(t, err)
-	// EIP-7928: Decoding 0xc0 (empty RLP list) should return an initialized empty slice,
-	// rather than nil, to distinguish a valid empty BAL from a missing/pruned one.
-	require.NotNil(t, decoded)
-	require.Empty(t, decoded)
-	require.NoError(t, decoded.Validate())
-	require.Equal(t, empty.BlockAccessListHash, decoded.Hash())
-}
-
 // Tests pre-shanghai body to make sure withdrawals doesn't panic
 func TestPreShanghaiBodyNoPanicOnWithdrawals(t *testing.T) {
 	t.Parallel()