Persistence Refactoring (#44)

* Extensions.Seek

* move nullstore out of CheckpointStorageProvider

* new None to default(None)

* initial MemoryTrackingStore

* add seek tests

* minor cleanup

* RocksDbStore

* Checkpoint class

* remove storageProvider specific Store and Snapshot

* MemoryTrackingStore.AtomicUpdate

* fix CheckpointStorageProvider.GetStorageProviderStore

* RocksDbUtility

* remove global.json

Co-authored-by: Harry <[email protected]>

Author: devhawk

global.json

@@ -4,35 +4,32 @@
 
 namespace Neo.BlockchainToolkit.Persistence
 {
-    internal class ByteArrayComparer : IEqualityComparer<byte[]>, IComparer<byte[]>
+    class ByteArrayComparer : IEqualityComparer<byte[]>, IComparer<byte[]>
     {
         public static ByteArrayComparer Default { get; } = new ByteArrayComparer(false);
         public static ByteArrayComparer Reverse { get; } = new ByteArrayComparer(true);
 
-        private readonly bool reverse;
+        readonly bool reverse;
 
-        private ByteArrayComparer(bool reverse = false)
+        ByteArrayComparer(bool reverse = false)
         {
             this.reverse = reverse;
         }
 
-        public int Compare([AllowNull] byte[] x, [AllowNull] byte[] y)
+        public int Compare(byte[]? x, byte[]? y)
         {
-            return reverse ? -Compare() : Compare();
+            if (x == null && y == null) return 0;
+            if (x == null) return reverse ? 1 : -1;
+            if (y == null) return reverse ? -1 : 1;
+            return Compare(x.AsSpan(), y.AsSpan());
+        }
 
-            int Compare()
-            {
-                if (x == null && y == null)
-                    return 0;
-                if (x == null)
-                    return -1;
-                if (y == null)
-                    return 1;
-                return x.AsSpan().SequenceCompareTo(y.AsSpan());
-            }
+        public int Compare(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y)
+        {
+            return reverse ? y.SequenceCompareTo(x) : x.SequenceCompareTo(y);
         }
 
-        public bool Equals([AllowNull] byte[] x, [AllowNull] byte[] y)
+        public bool Equals(byte[]? x, byte[]? y)
         {
             if (x == null && y == null)
                 return true;
@@ -41,14 +38,14 @@ public bool Equals([AllowNull] byte[] x, [AllowNull] byte[] y)
             return x.AsSpan().SequenceEqual(y.AsSpan());
         }
 
-        public int GetHashCode([DisallowNull] byte[] obj)
+        public int GetHashCode(byte[] obj)
         {
-            int hash = 0;
+            var hash = new HashCode();
             for (int i = 0; i < obj.Length; i++)
             {
-                hash = HashCode.Combine(hash, i, obj[i]);
+                hash.Add(obj[i]);
             }
-            return hash;
+            return hash.ToHashCode();
         }
     }
 }

src/bctklib/persistence/ByteArrayComparer.cs

@@ -2,121 +2,54 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using Neo.Persistence;
-using OneOf;
-using None = OneOf.Types.None;
+using Neo.Plugins;
 
 namespace Neo.BlockchainToolkit.Persistence
 {
-    using TrackingMap = ImmutableSortedDictionary<byte[], OneOf<byte[]?, None>>;
-
     public partial class CheckpointStorageProvider : IDisposableStorageProvider
     {
-        public readonly static TrackingMap EMPTY_TRACKING_MAP = TrackingMap.Empty.WithComparers(ByteArrayComparer.Default);
-
-        readonly RocksDbStorageProvider? rocksDbProvider;
-        readonly bool disposeRocksDbProvider;
+        readonly IStorageProvider? storageProvider;
         readonly IDisposable? checkpointCleanup;
+        readonly Lazy<IStore> defaultStore;
+        ImmutableDictionary<string, IStore> stores = ImmutableDictionary<string, IStore>.Empty;
 
-        ImmutableDictionary<string, TrackingMap> trackingMaps = ImmutableDictionary<string, TrackingMap>.Empty;
-        TrackingMap defaultTrackingMap = EMPTY_TRACKING_MAP;
+        public CheckpointStorageProvider(RocksDbStorageProvider? rocksDbStorageProvider, IDisposable? checkpointCleanup = null)
+            : this((IStorageProvider?)rocksDbStorageProvider, checkpointCleanup)
+        {
+        }
 
-        public CheckpointStorageProvider(RocksDbStorageProvider? rocksDbStorageProvider, bool disposeRocksDbProvider = true, IDisposable? checkpointCleanup = null)
+        public CheckpointStorageProvider(IStorageProvider? storageProvider, IDisposable? checkpointCleanup = null)
         {
-            this.rocksDbProvider = rocksDbStorageProvider;
-            this.disposeRocksDbProvider = disposeRocksDbProvider;
+            this.storageProvider = storageProvider;
             this.checkpointCleanup = checkpointCleanup;
+
+            defaultStore = new Lazy<IStore>(() => new MemoryTrackingStore(GetStorageProviderStore(null)));
         }
 
         public void Dispose()
         {
-            if (disposeRocksDbProvider) rocksDbProvider?.Dispose();
+            (storageProvider as IDisposable)?.Dispose();
             checkpointCleanup?.Dispose();
         }
 
-        internal TrackingMap GetTrackingMap(string? storeName)
-            => storeName == null
-                ? defaultTrackingMap
-                : trackingMaps.TryGetValue(storeName, out var trackingMap)
-                    ? trackingMap
-                    : EMPTY_TRACKING_MAP;
-
-        IReadOnlyStore GetReadOnlyStore(string? storeName)
-            => (rocksDbProvider != null && rocksDbProvider.TryGetStore(storeName, out var store))
-                ? store
-                : NullStore.Instance;
-
         public IStore GetStore(string? storeName)
         {
-            return new Store(this, storeName);
+            if (storeName == null) return defaultStore.Value;
+            return ImmutableInterlocked.GetOrAdd(ref stores, storeName, 
+                key => new MemoryTrackingStore(GetStorageProviderStore(key)));
         }
 
-        internal ISnapshot GetSnapshot(string? storeName)
+        IReadOnlyStore GetStorageProviderStore(string? path)
         {
-            var map = GetTrackingMap(storeName);
-            return new CheckpointStorageProvider.Snapshot(this, map, storeName);
-        }
-
-        internal byte[]? TryGet(string? storeName, byte[]? key) => TryGet(storeName, GetTrackingMap(storeName), key);
-
-        internal byte[]? TryGet(string? storeName, TrackingMap map, byte[]? key)
-        {
-            if (map.TryGetValue(key ?? Array.Empty<byte>(), out var mapValue))
+            IReadOnlyStore? roStore = null;
+            try
             {
-                return mapValue.Match<byte[]?>(v => v, n => null);
+                roStore = storageProvider?.GetStore(path);
             }
+            catch {}
 
-            return GetReadOnlyStore(storeName).TryGet(key);
-        }
-
-        internal IEnumerable<(byte[] Key, byte[]? Value)> Seek(string? storeName, byte[]? key, SeekDirection direction)
-            => Seek(storeName, GetTrackingMap(storeName), key, direction);
-
-        internal IEnumerable<(byte[] Key, byte[]? Value)> Seek(string? storeName, TrackingMap map, byte[]? key, SeekDirection direction)
-        {
-            key ??= Array.Empty<byte>();
-            var comparer = direction == SeekDirection.Forward ? ByteArrayComparer.Default : ByteArrayComparer.Reverse;
-
-            var memoryItems = map
-                .Where(kvp => kvp.Value.IsT0)
-                .Where(kvp => key.Length == 0 || comparer.Compare(kvp.Key, key) >= 0)
-                .Select(kvp => (kvp.Key, Value: kvp.Value.AsT0));
-
-            var storeItems = GetReadOnlyStore(storeName)
-                .Seek(key, direction)
-                .Where<(byte[] Key, byte[]? Value)>(kvp => !map.ContainsKey(kvp.Key));
-
-            return memoryItems.Concat(storeItems).OrderBy(kvp => kvp.Key, comparer);
-        }
-
-        internal void Update(string? storeName, byte[]? key, OneOf<byte[]?, None> value)
-        {
-            var trackingMap = GetTrackingMap(storeName);
-            trackingMap = trackingMap.SetItem(key ?? Array.Empty<byte>(), value);
-            UpdateTrackingMap(storeName, trackingMap);
-        }
-
-        internal void Update(string? storeName, TrackingMap changes)
-        {
-            var trackingMap = GetTrackingMap(storeName);
-            foreach (var change in changes)
-            {
-                trackingMap = trackingMap.SetItem(change.Key, change.Value);
-            }
-            UpdateTrackingMap(storeName, trackingMap);
-        }
-
-        void UpdateTrackingMap(string? storeName, TrackingMap changes)
-        {
-            if (storeName == null)
-            {
-                defaultTrackingMap = changes;
-            }
-            else
-            {
-                trackingMaps = trackingMaps.SetItem(storeName, changes);
-            }
+            return roStore ?? NullStore.Instance;
         }
     }
 }