Perf/dont redownload downloaded code

src/Nethermind/Nethermind.State.Test/SnapSync/RecreateStateFromAccountRangesTests.cs

@@ -5,13 +5,16 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using FluentAssertions;
+using Nethermind.Blockchain;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Test.Builders;
 using Nethermind.Db;
 using Nethermind.Logging;
 using Nethermind.State;
 using Nethermind.State.Proofs;
+using Nethermind.State.Snap;
 using Nethermind.Synchronization.SnapSync;
 using Nethermind.Trie;
 using Nethermind.Trie.Pruning;
@@ -260,5 +263,52 @@ public void MissingAccountFromRange()
             Assert.That(db.Keys.Count, Is.EqualTo(6));
             Assert.IsFalse(db.KeyExists(rootHash));
         }
+
+        [Test]
+        public void Will_not_redownload_persisted_code()
+        {
+            MemDb db = new();
+            MemDb codeDb = new();
+            DbProvider dbProvider = new();
+            dbProvider.RegisterDb(DbNames.State, db);
+            dbProvider.RegisterDb(DbNames.Code, codeDb);
+
+            BlockTree tree = Build.A.BlockTree().OfChainLength(5).TestObject;
+            using ProgressTracker progressTracker = new(tree, dbProvider.GetDb<IDb>(DbNames.State), LimboLogs.Instance, accountRangePartitionCount: 1);
+            SnapProvider snapProvider = new(progressTracker, dbProvider, LimboLogs.Instance);
+
+            PathWithAccount[] accountsWithPath =
+            [
+                new PathWithAccount(new Hash256("0000000000000000000000000000000000000000000000000000000001112345"),
+                    new Account(0, 0, Keccak.EmptyTreeHash, TestItem.Keccaks[0])),
+                new PathWithAccount(new Hash256("0000000000000000000000000000000000000000000000000000000001113456"),
+                    new Account(0, 0, Keccak.EmptyTreeHash, TestItem.Keccaks[1])),
+                new PathWithAccount(new Hash256("0000000000000000000000000000000000000000000000000000000001114567"),
+                    new Account(0, 0, Keccak.EmptyTreeHash, TestItem.Keccaks[2])),
+                new PathWithAccount(new Hash256("0000000000000000000000000000000000000000000000000000000001123456"),
+                    new Account(0, 0, Keccak.EmptyTreeHash, TestItem.Keccaks[3])),
+                new PathWithAccount(new Hash256("0000000000000000000000000000000000000000000000000000000001123457"),
+                    new Account(0, 0, Keccak.EmptyTreeHash, TestItem.Keccaks[4]))
+            ];
+
+            codeDb[TestItem.Keccaks[1].Bytes] = [1];
+            codeDb[TestItem.Keccaks[2].Bytes] = [1];
+
+            StateTree stateTree = new StateTree();
+            foreach (PathWithAccount pathWithAccount in accountsWithPath)
+            {
+                stateTree.Set(pathWithAccount.Path, pathWithAccount.Account);
+            }
+            stateTree.UpdateRootHash();
+
+            snapProvider.AddAccountRange(1,
+                stateTree.RootHash,
+                accountsWithPath[0].Path,
+                accountsWithPath);
+
+            progressTracker.IsFinished(out SnapSyncBatch nextRequest).Should().BeFalse();
+            progressTracker.IsFinished(out nextRequest).Should().BeFalse();
+            nextRequest.CodesRequest.Count.Should().Be(3);
+        }
     }
 }

src/Nethermind/Nethermind.Synchronization/SnapSync/ISnapProvider.cs

@@ -26,5 +26,6 @@ public interface ISnapProvider
 
         bool IsSnapGetRangesFinished();
         void UpdatePivot();
+        void Dispose();
     }
 }

src/Nethermind/Nethermind.Synchronization/SnapSync/SnapProvider.cs

@@ -8,6 +8,7 @@
 using System.Threading;
 using Microsoft.Extensions.ObjectPool;
 using Nethermind.Core;
+using Nethermind.Core.Caching;
 using Nethermind.Core.Collections;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Extensions;
@@ -29,6 +30,9 @@ public class SnapProvider : ISnapProvider
 
         private readonly ProgressTracker _progressTracker;
 
+        // This is actually close to 97% effective.
+        private readonly LruKeyCache<ValueHash256> _codeExistKeyCache = new(1024 * 16, "");
+
         public SnapProvider(ProgressTracker progressTracker, IDbProvider dbProvider, ILogManager logManager)
         {
             _dbProvider = dbProvider ?? throw new ArgumentNullException(nameof(dbProvider));
@@ -88,7 +92,18 @@ public AddRangeResult AddAccountRange(long blockNumber, in ValueHash256 expected
                         _progressTracker.EnqueueAccountStorage(item);
                     }
 
-                    _progressTracker.EnqueueCodeHashes(CollectionsMarshal.AsSpan(codeHashes));
+
+                    using ArrayPoolList<ValueHash256> filteredCodeHashes = codeHashes.AsParallel().Where((code) =>
+                    {
+                        if (_codeExistKeyCache.Get(code)) return false;
+
+                        bool exist = _dbProvider.CodeDb.KeyExists(code.Bytes);
+                        if (exist) _codeExistKeyCache.Set(code);
+                        return !exist;
+                    }).ToPooledList(codeHashes.Count);
+
+                    _progressTracker.EnqueueCodeHashes(filteredCodeHashes.AsSpan());
+
                     _progressTracker.UpdateAccountRangePartitionProgress(effectiveHashLimit, accounts[^1].Path, moreChildrenToRight);
                 }
                 else if (result == AddRangeResult.MissingRootHashInProofs)
@@ -324,6 +339,11 @@ public void UpdatePivot()
             _progressTracker.UpdatePivot();
         }
 
+        public void Dispose()
+        {
+            _codeExistKeyCache.Clear();
+        }
+
         private class TrieStorePoolPolicy : IPooledObjectPolicy<ITrieStore>
         {
             private readonly IKeyValueStoreWithBatching _stateDb;

src/Nethermind/Nethermind.Synchronization/SnapSync/SnapSyncFeed.cs

@@ -205,6 +205,7 @@ public override void SyncModeSelectorOnChanged(SyncMode current)
             if (_disposed) return;
             if (CurrentState == SyncFeedState.Dormant)
             {
+                _snapProvider.Dispose();
                 if ((current & SyncMode.SnapSync) == SyncMode.SnapSync)
                 {
                     if (_snapProvider.CanSync())