Serialized storage cache

benchmarks/Neo.Benchmarks/Benchmarks.Cache.cs

@@ -0,0 +1,69 @@
+// Copyright (C) 2015-2025 The Neo Project.
+//
+// Benchmarks.Cache.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using BenchmarkDotNet.Attributes;
+using Neo.Persistence;
+using Neo.Persistence.Providers;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using System.Numerics;
+
+namespace Neo.Benchmark
+{
+    public class Benchmarks_Cache
+    {
+        readonly MemoryStore _store;
+        readonly StoreCache _snapshot;
+
+        public Benchmarks_Cache()
+        {
+            _store = new MemoryStore();
+            _snapshot = new(_store.GetSnapshot());
+
+            // Ledger.CurrentIndex
+
+            _snapshot.GetAndChange(new KeyBuilder(NativeContract.Ledger.Id, 12), () => new StorageItem(new HashIndexState() { Hash = UInt256.Zero, Index = 2 }));
+
+            // Gas Per block
+
+            _snapshot.GetAndChange(new KeyBuilder(NativeContract.NEO.Id, 29).AddBigEndian(0), () => new StorageItem(0));
+            _snapshot.GetAndChange(new KeyBuilder(NativeContract.NEO.Id, 29).AddBigEndian(1), () => new StorageItem(1));
+            _snapshot.GetAndChange(new KeyBuilder(NativeContract.NEO.Id, 29).AddBigEndian(2), () => new StorageItem(2));
+        }
+
+        [Benchmark]
+        public void WithCache()
+        {
+            for (var x = 0; x < 1_000; x++)
+            {
+                var ret = NativeContract.NEO.GetGasPerBlock(_snapshot);
+                if (ret != 2) throw new Exception("Test error");
+            }
+        }
+
+        [Benchmark]
+        public void WithoutCache()
+        {
+            for (var x = 0; x < 1_000; x++)
+            {
+                var ret = OldCode();
+                if (ret != 2) throw new Exception("Test error");
+            }
+        }
+
+        private BigInteger OldCode()
+        {
+            var end = NativeContract.Ledger.CurrentIndex(_snapshot) + 1;
+            var last = NativeContract.NEO.GetSortedGasRecords(_snapshot, end).First();
+            return last.GasPerBlock;
+        }
+    }
+}

src/Neo/Neo.csproj

@@ -27,6 +27,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <InternalsVisibleTo Include="Neo.Benchmarks" />
     <InternalsVisibleTo Include="Neo.SmartContract.Testing" />
     <InternalsVisibleTo Include="Neo.SmartContract.TestEngine" />
     <InternalsVisibleTo Include="Neo.Plugins.RpcServer.Tests" />

src/Neo/Persistence/ClonedCache.cs

@@ -20,7 +20,7 @@ class ClonedCache : DataCache
     {
         private readonly DataCache _innerCache;
 
-        public ClonedCache(DataCache innerCache)
+        public ClonedCache(DataCache innerCache) : base(innerCache.SerializedCacheChanges)
         {
             _innerCache = innerCache;
         }

src/Neo/Persistence/DataCache.cs

@@ -24,7 +24,7 @@ namespace Neo.Persistence
     /// <summary>
     /// Represents a cache for the underlying storage of the NEO blockchain.
     /// </summary>
-    public abstract class DataCache : IReadOnlyStore
+    public abstract class DataCache : ICacheableReadOnlyStore
     {
         /// <summary>
         /// Represents an entry in the cache.
@@ -45,6 +45,25 @@ public class Trackable(StorageItem item, TrackState state)
         private readonly Dictionary<StorageKey, Trackable> _dictionary = [];
         private readonly HashSet<StorageKey> _changeSet = [];
 
+        /// <summary>
+        /// Serialized cache
+        /// </summary>
+        public SerializedCache SerializedCache { get; }
+
+        /// <summary>
+        /// This is where the cache changes are stored
+        /// </summary>
+        internal SerializedCache SerializedCacheChanges { get; } = new();
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="serializedCache">Serialized cache</param>
+        protected DataCache(SerializedCache serializedCache)
+        {
+            SerializedCache = serializedCache;
+        }
+
         /// <summary>
         /// Reads a specified entry from the cache. If the entry is not in the cache, it will be automatically loaded from the underlying storage.
         /// </summary>
@@ -101,6 +120,51 @@ public void Add(StorageKey key, StorageItem value)
             }
         }
 
+        /// <summary>
+        /// Adds a new entry to the cache.
+        /// </summary>
+        /// <param name="key">The key of the entry.</param>
+        /// <param name="value">The data of the entry.</param>
+        /// <exception cref="ArgumentException">The entry has already been cached.</exception>
+        /// <remarks>Note: This method does not read the internal storage to check whether the record already exists.</remarks>
+        public void Add<T>(StorageKey key, T value) where T : IStorageCacheEntry
+        {
+            lock (_dictionary)
+            {
+                Add(key, value.GetStorageItem());
+                AddToCache(value);
+            }
+        }
+
+        /// <summary>
+        /// Adds a new entry to the cache.
+        /// </summary>
+        /// <param name="value">The data of the entry.</param>
+        /// <exception cref="ArgumentException">The entry has already been cached.</exception>
+        /// <remarks>Note: This method does not read the internal storage to check whether the record already exists.</remarks>
+        public void AddToCache<T>(T? value = default) where T : IStorageCacheEntry
+        {
+            var type = typeof(T);
+            SerializedCacheChanges.Set(type, value);
+        }
+
+        /// <summary>
+        /// Tries to get the entry from cache.
+        /// </summary>
+        /// <typeparam name="T">Cache type</typeparam>
+        /// <returns>The entry if found, null otherwise.</returns>
+        public T? GetFromCache<T>() where T : IStorageCacheEntry
+        {
+            var value = SerializedCacheChanges.Get<T>();
+
+            if (value != null)
+            {
+                return value;
+            }
+
+            return SerializedCache.Get<T>();
+        }
+
         /// <summary>
         /// Adds a new entry to the underlying storage.
         /// </summary>
@@ -134,6 +198,8 @@ public virtual void Commit()
                             break;
                     }
                 }
+                SerializedCache.CopyFrom(SerializedCacheChanges);
+                SerializedCacheChanges.Clear();
                 _changeSet.Clear();
             }
         }
@@ -365,6 +431,19 @@ public bool Contains(StorageKey key)
             }
         }
 
+        /// <summary>
+        /// Reads a specified entry from the cache, and mark it as <see cref="TrackState.Changed"/>.
+        /// If the entry is not in the cache, it will be automatically loaded from the underlying storage.
+        /// </summary>
+        /// <param name="key">The key of the entry.</param>
+        /// <param name="serializedCache">Serialized cache</param>
+        public void Upsert<T>(StorageKey key, T serializedCache) where T : IStorageCacheEntry
+        {
+            var ret = GetAndChange(key, serializedCache.GetStorageItem);
+            ret!.FromReplica(serializedCache.GetStorageItem());
+            AddToCache(serializedCache);
+        }
+
         /// <summary>
         /// Reads a specified entry from the cache.
         /// If the entry is not in the cache, it will be automatically loaded from the underlying storage.

src/Neo/Persistence/ICacheableReadOnlyStore.cs

@@ -0,0 +1,44 @@
+// Copyright (C) 2015-2025 The Neo Project.
+//
+// ICacheableReadOnlyStore.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+#nullable enable
+
+using Neo.SmartContract;
+using System;
+
+namespace Neo.Persistence
+{
+    /// <summary>
+    /// This interface provides methods to read from the database.
+    /// </summary>
+    public interface ICacheableReadOnlyStore : ICacheableReadOnlyStore<StorageKey, StorageItem>, IReadOnlyStore { }
+
+    /// <summary>
+    /// This interface provides methods to read from the database.
+    /// </summary>
+    public interface ICacheableReadOnlyStore<TKey, TValue> : IReadOnlyStore<TKey, TValue>
+    {
+        /// <summary>
+        /// Tries to get the entry from cache.
+        /// </summary>
+        /// <typeparam name="T">Cache type</typeparam>
+        /// <returns>The entry if found, null otherwise.</returns>
+        public T? GetFromCache<T>() where T : IStorageCacheEntry;
+
+        /// <summary>
+        /// Adds a new entry to the cache.
+        /// </summary>
+        /// <param name="value">The data of the entry.</param>
+        /// <exception cref="ArgumentException">The entry has already been cached.</exception>
+        /// <remarks>Note: This method does not read the internal storage to check whether the record already exists.</remarks>
+        public void AddToCache<T>(T? value = default) where T : IStorageCacheEntry;
+    }
+}

src/Neo/Persistence/IStorageCacheEntry.cs

@@ -0,0 +1,20 @@
+// Copyright (C) 2015-2025 The Neo Project.
+//
+// IStorageCacheEntry.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.SmartContract;
+
+namespace Neo.Persistence
+{
+    public interface IStorageCacheEntry
+    {
+        public StorageItem GetStorageItem();
+    }
+}

src/Neo/Persistence/IStore.cs

@@ -23,6 +23,11 @@ public interface IStore :
         IWriteStore<byte[], byte[]>,
         IDisposable
     {
+        /// <summary>
+        /// Serialized cache
+        /// </summary>
+        SerializedCache SerializedCache { get; }
+
         /// <summary>
         /// Creates a snapshot of the database.
         /// </summary>

src/Neo/Persistence/Providers/MemoryStore.cs

@@ -26,6 +26,7 @@ namespace Neo.Persistence.Providers
     public class MemoryStore : IStore
     {
         private readonly ConcurrentDictionary<byte[], byte[]> _innerData = new(ByteArrayEqualityComparer.Default);
+        public SerializedCache SerializedCache { get; } = new();
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Delete(byte[] key)

src/Neo/Persistence/SerializedCache.cs

@@ -0,0 +1,108 @@
+// Copyright (C) 2015-2025 The Neo Project.
+//
+// SerializedCache.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace Neo.Persistence
+{
+    public class SerializedCache
+    {
+        private readonly Dictionary<Type, IStorageCacheEntry> _cache = [];
+
+        /// <summary>
+        /// Get cached entry
+        /// </summary>
+        /// <typeparam name="T">Type</typeparam>
+        /// <returns>The cached entry. If not cached, the default value will be returned</returns>
+        public T? Get<T>()
+        {
+            if (_cache.TryGetValue(typeof(T), out var ret))
+            {
+                return (T)ret;
+            }
+
+            return default;
+        }
+
+        /// <summary>
+        /// Set entry
+        /// </summary>
+        /// <typeparam name="T">Type</typeparam>
+        /// <param name="value">Value</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Set<T>(T? value) where T : IStorageCacheEntry
+        {
+            Set(typeof(T), value);
+        }
+
+        /// <summary>
+        /// Set entry
+        /// </summary>
+        /// <param name="type">Type</param>
+        /// <param name="value">Value</param>
+        public void Set(Type type, IStorageCacheEntry? value)
+        {
+            if (value == null)
+            {
+                Remove(type);
+            }
+            else
+            {
+                lock (_cache)
+                {
+                    _cache[type] = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove entry
+        /// </summary>
+        /// <param name="type">Type</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Remove(Type type)
+        {
+            lock (_cache)
+            {
+                _cache.Remove(type, out _);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear()
+        {
+            lock (_cache)
+            {
+                _cache.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Copy from
+        /// </summary>
+        /// <param name="value">Value</param>
+        public void CopyFrom(SerializedCache value)
+        {
+            if (ReferenceEquals(this, value)) return;
+            lock (_cache) lock (value._cache)
+                {
+                    foreach (var serialized in value._cache)
+                    {
+                        _cache[serialized.Key] = serialized.Value;
+                    }
+                }
+        }
+    }
+}