perf(evm): integrate hash-aware code info path for extcode cache

Author: kamilchodola

src/Nethermind/Nethermind.Blockchain/CachedCodeInfoRepository.cs

@@ -36,6 +36,16 @@ public ICodeInfo GetCachedCodeInfo(Address codeSource, bool followDelegation, IR
         return baseCodeInfoRepository.GetCachedCodeInfo(codeSource, followDelegation, vmSpec, out delegationAddress);
     }
 
+    public ICodeInfo GetCachedCodeInfo(Address codeSource, in ValueHash256 codeHash, IReleaseSpec vmSpec)
+    {
+        if (vmSpec.IsPrecompile(codeSource) && _cachedPrecompile.TryGetValue(codeSource, out PrecompileInfo cachedCodeInfo))
+        {
+            return cachedCodeInfo;
+        }
+
+        return baseCodeInfoRepository.GetCachedCodeInfo(codeSource, in codeHash, vmSpec);
+    }
+
     public ValueHash256 GetExecutableCodeHash(Address address, IReleaseSpec spec)
     {
         return baseCodeInfoRepository.GetExecutableCodeHash(address, spec);

src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs

@@ -47,6 +47,16 @@ public ICodeInfo GetCachedCodeInfo(Address codeSource, bool followDelegation, IR
         return cachedCodeInfo;
     }
 
+    public ICodeInfo GetCachedCodeInfo(Address codeSource, in ValueHash256 codeHash, IReleaseSpec vmSpec)
+    {
+        if (vmSpec.IsPrecompile(codeSource))
+        {
+            return _localPrecompiles[codeSource];
+        }
+
+        return InternalGetCachedCode(_worldState, in codeHash, vmSpec);
+    }
+
     private ICodeInfo InternalGetCachedCode(Address codeSource, IReleaseSpec vmSpec)
     {
         ref readonly ValueHash256 codeHash = ref _worldState.GetCodeHash(codeSource);
@@ -187,4 +197,3 @@ public bool TryGet(in ValueHash256 codeHash, [NotNullWhen(true)] out ICodeInfo?
         }
     }
 }
-

src/Nethermind/Nethermind.Evm/ICodeInfoRepository.cs

@@ -12,6 +12,7 @@ namespace Nethermind.Evm;
 public interface ICodeInfoRepository
 {
     ICodeInfo GetCachedCodeInfo(Address codeSource, bool followDelegation, IReleaseSpec vmSpec, out Address? delegationAddress);
+    ICodeInfo GetCachedCodeInfo(Address codeSource, in ValueHash256 codeHash, IReleaseSpec vmSpec);
     ValueHash256 GetExecutableCodeHash(Address address, IReleaseSpec spec);
     void InsertCode(ReadOnlyMemory<byte> code, Address codeOwner, IReleaseSpec spec);
     void SetDelegation(Address codeSource, Address authority, IReleaseSpec spec);

src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.CodeCopy.cs

@@ -179,7 +179,7 @@ public static EvmExceptionType InstructionExtCodeCopy<TGasPolicy, TTracingInst>(
             }
 
             // If EOF is enabled and the code is an EOF contract, use a predefined magic value.
-            if (spec.IsEofEnabled && EofValidator.IsEof(externalCode, out _))
+            if (spec.IsEofEnabled && codeInfo is EofCodeInfo)
             {
                 externalCode = EofValidator.MAGIC;
             }

src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Environment.cs

@@ -675,20 +675,27 @@ public static EvmExceptionType InstructionExtCodeHashEof<TGasPolicy, TTracingIns
         {
             stack.PushZero<TTracingInst>();
         }
+        else
+        {
+            ref readonly ValueHash256 codeHash = ref state.GetCodeHash(address);
+            if (codeHash == Keccak.OfAnEmptyString.ValueHash256)
+            {
+                stack.Push32Bytes<TTracingInst>(in codeHash);
+                return EvmExceptionType.None;
+            }
+
+            CodeInfo codeInfo = vm.CodeInfoRepository.GetCachedCodeInfo(address, in codeHash, spec);
+            // If the code is EOF, push the EOF-specific hash.
+            if (codeInfo is EofCodeInfo)
+            {
+                stack.PushBytes<TTracingInst>(EofHash256);
+            }
             else
             {
-                CodeInfo codeInfo = vm.GetExtCodeInfoCached(address, spec);
-                // If the code is EOF, push the EOF-specific hash.
-                if (codeInfo is EofCodeInfo)
-                {
-                    stack.PushBytes<TTracingInst>(EofHash256);
-                }
-                else
-                {
-                    // Otherwise, push the standard code hash.
-                    stack.PushBytes<TTracingInst>(state.GetCodeHash(address).Bytes);
-                }
+                // Otherwise, push the standard code hash.
+                stack.Push32Bytes<TTracingInst>(in codeHash);
             }
+        }
 
         return EvmExceptionType.None;
     // Jump forward to be unpredicted by the branch predictor.

src/Nethermind/Nethermind.Evm/VirtualMachine.ExtCodeCache.cs

@@ -54,7 +54,7 @@ internal uint GetExtCodeSizeCached(Address address, IReleaseSpec spec)
             return entry.CodeSize;
         }
 
-        CodeInfo codeInfo = _codeInfoRepository.GetCachedCodeInfo(address, followDelegation: false, spec, out _);
+        CodeInfo codeInfo = _codeInfoRepository.GetCachedCodeInfo(address, in codeHash, spec);
         uint codeSize = codeInfo is EofCodeInfo ? (uint)EofValidator.MAGIC.Length : (uint)codeInfo.CodeSpan.Length;
 
         StoreCacheEntry(key, codeHash, codeSize, codeInfo);
@@ -99,7 +99,7 @@ internal CodeInfo GetExtCodeInfoCached(Address address, IReleaseSpec spec)
             return entry.CodeInfo;
         }
 
-        CodeInfo codeInfo = _codeInfoRepository.GetCachedCodeInfo(address, followDelegation: false, spec, out _);
+        CodeInfo codeInfo = _codeInfoRepository.GetCachedCodeInfo(address, in codeHash, spec);
         uint codeSize = codeInfo is EofCodeInfo ? (uint)EofValidator.MAGIC.Length : (uint)codeInfo.CodeSpan.Length;
         StoreCacheEntry(key, codeHash, codeSize, codeInfo);
         return codeInfo;
@@ -113,10 +113,13 @@ private void StoreCacheEntry(AddressAsKey key, in ValueHash256 codeHash, uint co
             return;
         }
 
+        // Under high-cardinality workloads, clearing the whole dictionary causes avoidable churn.
+        // Once capacity is reached, keep current hot set and skip admitting new entries.
         if (_extCodeCache!.Count >= _maxExtCodeCacheEntries)
         {
-            _extCodeCache.Clear();
+            return;
         }
+
         _extCodeCache[key] = new ExtCodeCacheEntry(codeHash, codeSize, codeInfo);
     }
 

src/Nethermind/Nethermind.State/OverridableEnv/OverridableCodeInfoRepository.cs

@@ -35,6 +35,21 @@ public ICodeInfo GetCachedCodeInfo(Address codeSource, bool followDelegation, IR
         return codeInfoRepository.GetCachedCodeInfo(codeSource, followDelegation, vmSpec, out delegationAddress);
     }
 
+    public ICodeInfo GetCachedCodeInfo(Address codeSource, in ValueHash256 codeHash, IReleaseSpec vmSpec)
+    {
+        if (_precompileOverrides.TryGetValue(codeSource, out var precompile))
+        {
+            return precompile.codeInfo;
+        }
+
+        if (_codeOverrides.TryGetValue(codeSource, out var result))
+        {
+            return result.codeInfo;
+        }
+
+        return codeInfoRepository.GetCachedCodeInfo(codeSource, in codeHash, vmSpec);
+    }
+
     public void InsertCode(ReadOnlyMemory<byte> code, Address codeOwner, IReleaseSpec spec) =>
         codeInfoRepository.InsertCode(code, codeOwner, spec);