Performance: Add warmup cache

[Giulio2002]

This PR introduces a warmup cache for the commitment trie processing that reduces redundant DB reads during block execution. Data fetched during the warmup phase is cached and reused during the actual trie computation, improving performance.

Key Changes

• New WarmupCache - A cache that stores pre-fetched branch, account, and storage data using maphash.Map for efficient byte slice lookups without allocations
• Cache integration in Warmuper - The warmuper now optionally caches data it reads, making it available during trie processing
• BranchEncoder cache support - Branch lookups check the cache first before hitting the DB
• Key eviction - Keys being modified are evicted from the cache to ensure consistency

Architecture Diagram

┌─────────────────────────────────────────────────────────────────────┐
│                        Block Execution                               │
└─────────────────────────────────────────────────────────────────────┘
                                  │
                                  ▼
┌─────────────────────────────────────────────────────────────────────┐
│                          Warmuper                                    │
│  ┌──────────────────┐    ┌──────────────────┐                       │
│  │  Parallel Workers │───▶│   WarmupCache    │                       │
│  │  (prefetch data)  │    │                  │                       │
│  └──────────────────┘    │  ┌────────────┐  │                       │
│                          │  │  branches  │  │                       │
│                          │  ├────────────┤  │                       │
│                          │  │  accounts  │  │                       │
│                          │  ├────────────┤  │                       │
│                          │  │  storage   │  │                       │
│                          │  └────────────┘  │                       │
│                          └────────┬─────────┘                       │
└───────────────────────────────────┼─────────────────────────────────┘
                                    │
                    ┌───────────────┴───────────────┐
                    │         Cache Lookup          │
                    ▼                               ▼
         ┌─────────────────┐             ┌─────────────────┐
         │   Cache Hit     │             │   Cache Miss    │
         │  (return data)  │             │   (read DB)     │
         └─────────────────┘             └─────────────────┘
                                                  │
                                                  ▼
┌─────────────────────────────────────────────────────────────────────┐
│                     HexPatriciaHashed Trie                          │
│                                                                      │
│   Process() ──▶ BranchEncoder.CollectUpdate()                       │
│                        │                                             │
│                        ▼                                             │
│              ┌─────────────────┐                                    │
│              │ Check WarmupCache│                                    │
│              │   for branch     │                                    │
│              └────────┬────────┘                                    │
│                       │                                              │
│           ┌───────────┴───────────┐                                 │
│           ▼                       ▼                                 │
│     Cache Hit               Cache Miss                              │
│   (skip DB read)          (read from DB)                            │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘
                                  │
                                  ▼
┌─────────────────────────────────────────────────────────────────────┐
│                      Key Eviction Flow                              │
│                                                                      │
│   Updates.HashSort() ──▶ For each modified key:                     │
│                              cache.EvictKey(key)                    │
│                                                                      │
│   (Ensures modified keys are re-read from DB, not stale cache)     │
└─────────────────────────────────────────────────────────────────────┘

[mh0lt]

How is this code dealing with hash collisions ?

Given that you are using a 64 bit hash this is quite likely, if this happens the value returned won't necessarily be for the expected key - which is likely to cause hard to debug issues.

[Giulio2002]

@mh0lt this is not likely, do the math yourself. it is very hard even with birthday paradox

[Giulio2002]

here is the math, thanks to claude. it become significant if someone can spam it with 100million kvs but this is not actualizable since the attacker has no way of knowing the seed and has limited attack. this is also a method Nethermind uses

[Giulio2002]

btw in the entire history of the chain there is 100% a collision no doubt but for it to happen, you need to use THAT pair and that probability is actually bounded in the best-case (pessimistic) by random reads. in reality, we dont do random reads in blockchain. pattern exists so even that pessimistic unlikely case is too optimistic.

[Giulio2002]

@antonis19 can you approve?

[antonis19]

This code can be simplified into ctx.Branch(prefix) the behavior will be different based on the concrete type of ctx (i.e if it is with cache or without cache)

[antonis19]

Can use hph.ctx , just have 2 concrete implementations (1 with cache, 1 without). The desired implementation can be instantiated based on the config