perf(trie): share cached nodes across read-only walks (CloneForReadOnly 19.2 GB -> 1.4 MB)

src/Nethermind/Nethermind.Consensus.Test/BlockCachePreWarmerTests.cs

@@ -411,30 +411,33 @@ private sealed class DisposalTrackingPolicy(
         PreBlockCaches caches,
         ConcurrentBag<IReadOnlyTxProcessorSource> created,
         ConcurrentBag<IReadOnlyTxProcessorSource> disposed)
-        : IPooledObjectPolicy<IReadOnlyTxProcessorSource>
+        : IPooledObjectPolicy<IPreBlockCacheWarmupSource>
     {
-        public IReadOnlyTxProcessorSource Create()
+        public IPreBlockCacheWarmupSource Create()
         {
-            TrackingEnv env = new(factory.Create(caches), disposed);
+            TrackingEnv env = new((IPreBlockCacheWarmupSource)factory.Create(caches), disposed);
             created.Add(env);
             return env;
         }
 
-        public bool Return(IReadOnlyTxProcessorSource obj) => true;
+        public bool Return(IPreBlockCacheWarmupSource obj) => true;
 
         /// <summary>
         /// Wraps an inner env and records itself in <paramref name="disposed"/> when
         /// <see cref="Dispose"/> is called, allowing the test to distinguish envs
         /// disposed by pool eviction from those still retained.
         /// </summary>
         private sealed class TrackingEnv(
-            IReadOnlyTxProcessorSource inner,
+            IPreBlockCacheWarmupSource inner,
             ConcurrentBag<IReadOnlyTxProcessorSource> disposed)
-            : IReadOnlyTxProcessorSource
+            : IPreBlockCacheWarmupSource
         {
             public IReadOnlyTxProcessingScope Build(BlockHeader? baseBlock) =>
                 inner.Build(baseBlock);
 
+            public IPreBlockCacheWarmupSession BuildPreBlockCacheWarmup(BlockHeader? baseBlock) =>
+                inner.BuildPreBlockCacheWarmup(baseBlock);
+
             public void Dispose()
             {
                 disposed.Add(this);

src/Nethermind/Nethermind.Consensus/Processing/BlockAccessListManager.cs

@@ -905,14 +905,24 @@ private TxProcessorWithWorldState NewProcessor()
             DefaultObjectPoolProvider provider = new() { MaximumRetained = ProcessorPoolSize };
             if (prewarmerEnvFactory is not null && preBlockCaches is not null)
             {
-                return provider.Create(new BlockCachePreWarmer.ReadOnlyTxProcessingEnvPooledObjectPolicy(prewarmerEnvFactory, preBlockCaches));
+                // The prewarmer's policy hands out the tighter IPreBlockCacheWarmupSource; here we
+                // only need IReadOnlyTxProcessorSource - upcast at the policy boundary.
+                return provider.Create(new PrewarmerPolicyAdapter(
+                    new BlockCachePreWarmer.ReadOnlyTxProcessingEnvPooledObjectPolicy(prewarmerEnvFactory, preBlockCaches)));
             }
 
             return readOnlyTxProcessingEnvFactory is not null
                 ? provider.Create(new ReadOnlyTxProcessingEnvPooledObjectPolicy(readOnlyTxProcessingEnvFactory))
                 : null;
         }
 
+        private sealed class PrewarmerPolicyAdapter(BlockCachePreWarmer.ReadOnlyTxProcessingEnvPooledObjectPolicy inner)
+            : IPooledObjectPolicy<IReadOnlyTxProcessorSource>
+        {
+            public IReadOnlyTxProcessorSource Create() => inner.Create();
+            public bool Return(IReadOnlyTxProcessorSource obj) => inner.Return((IPreBlockCacheWarmupSource)obj);
+        }
+
         private static BlockHeader CreateParentStateHeader(Block block, Hash256 stateRoot)
         {
             Hash256 parentHash = block.ParentHash ?? Keccak.Zero;