Merge branch 'main' into importer

Author: Scooletz

src/Paprika.Tests/Store/DataPageTests.cs

@@ -64,10 +64,26 @@ public void Should_hold_all_needed_full_branches_of_Merkle(byte oddity)
         var batch = NewBatch(BatchId);
         var data = ((IBatchContext)batch).GetNewPage<DataPage>(out _);
 
+        const int count = 16;
+
         var path = NibblePath.Empty;
         data.Set(path, GetValue(path), batch);
 
-        const int count = 16;
+        for (byte i = 0; i < count; i++)
+        {
+            path = NibblePath.Single(i, oddity);
+            data.Set(path, GetValue(path), batch);
+        }
+
+        // next batch
+        batch = batch.Next();
+
+        data = new DataPage(batch.GetWritableCopy(data.AsPage()));
+
+        // set again
+        path = NibblePath.Empty;
+        data.Set(path, GetValue(path), batch);
+
         for (byte i = 0; i < count; i++)
         {
             path = NibblePath.Single(i, oddity);
@@ -81,7 +97,7 @@ public void Should_hold_all_needed_full_branches_of_Merkle(byte oddity)
             result.SequenceEqual(GetValue(path)).Should().BeTrue();
         }
 
-        batch.PageCount.Should().Be(3, "One for the data page and two for the Merkle children");
+        batch.PageCount.Should().Be(6, "One for the data page and two for the Merkle children");
 
         return;
         static byte[] GetValue(in NibblePath path)

src/Paprika.Tests/Store/StorageFanOutTests.cs

@@ -0,0 +1,48 @@
+using FluentAssertions;
+using Paprika.Store;
+
+namespace Paprika.Tests.Store;
+
+public class StorageFanOutTests
+{
+    private const uint Meg = 1024u * 1024u;
+
+    [TestCase(0u)]
+    [TestCase(1u)]
+    [TestCase(1023u)]
+    [TestCase(1024u)]
+    [TestCase(1025u)]
+    [TestCase(Meg - 1)]
+    [TestCase(Meg)]
+    [TestCase(Meg + 1)]
+    [TestCase(Meg * 2 - 1)]
+    [TestCase(Meg * 2)]
+    [TestCase(Meg * 2 + 1)]
+    [TestCase(Meg * 4 - 1)]
+    [TestCase(Meg * 4)]
+    [TestCase(Meg * 4 + 1)]
+    [TestCase(Meg * 8 - 1)]
+    [TestCase(Meg * 8)]
+    [TestCase(Meg * 8 + 1)]
+    [TestCase(Meg * 16 - 1)]
+    [TestCase(Meg * 16)]
+    [TestCase(Meg * 16 + 1)]
+    [TestCase(Meg * 32 - 1)]
+    [TestCase(Meg * 32)]
+    [TestCase(Meg * 32 + 1)]
+    [TestCase(Meg * 64 - 1)]
+    [TestCase(Meg * 64)]
+    [TestCase(Meg * 64 + 1)]
+    public void AssertBoundaries(uint at)
+    {
+        (uint next0, int index0) = StorageFanOut.GetIndex(at, 0);
+        index0.Should().BeLessThan(1024, $"L0 failed at: {at}");
+
+        (uint next1, int index1) = StorageFanOut.GetIndex(next0, 1);
+        index1.Should().BeLessThan(1024, $"L1 failed at: {at}");
+
+        (byte bucket2, int index2) = StorageFanOut.Level2Page.GetIndex(next1);
+        index2.Should().BeLessThan(256, $"L2 failed at: {at}");
+        bucket2.Should().BeLessThan(16, $"L2 failed at: {at}");
+    }
+}

src/Paprika/Data/SlottedArray.cs

@@ -7,6 +7,7 @@
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using Paprika.Crypto;
+using Paprika.Merkle;
 using Paprika.Utils;
 
 namespace Paprika.Data;
@@ -1216,10 +1217,10 @@ public void Clear()
 
     private const int NotFound = -1;
 
-    [OptimizationOpportunity(OptimizationType.CPU,
-        "key encoding is delayed but it might be called twice, here + TrySet")]
     private int TryGetImpl(in NibblePath key, ushort hash, byte preamble, out Span<byte> data)
     {
+        // AssertHeader();
+
         var count = _header.Low / Slot.TotalSize;
         var jump = DoubleVectorSize / sizeof(ushort);
         var aligned = AlignToDoubleVectorSize(_header.Low) / sizeof(ushort);
@@ -1751,6 +1752,21 @@ private struct Header
 
         public readonly ushort TakenAfterOneMoreSlot => (ushort)(AlignToDoubleVectorSize(Low + Slot.TotalSize) + High);
     }
+
+    // private void AssertHeader()
+    // {
+    //     if (_header.Deleted > _data.Length / Slot.Size)
+    //     {
+    //         throw new Exception("Deleted breached potential size");
+    //     }
+    //     // Debug.Assert(_header.Deleted <= _data.Length / Slot.Size, "Deleted breached the ");
+    //
+    //     if (_header.High + _header.Low > _data.Length)
+    //     {
+    //         throw new Exception("Breached HiLo");
+    //     }
+    //     // Debug.Assert(_header.High + _header.Low <= _data.Length);
+    // }
 }
 
 public readonly ref struct MapSource

src/Paprika/Data/UShortSlottedArray.cs

@@ -330,8 +330,6 @@ public bool TryGet(ushort key, out ReadOnlySpan<byte> data)
         return false;
     }
 
-    [OptimizationOpportunity(OptimizationType.CPU,
-        "key encoding is delayed but it might be called twice, here + TrySet")]
     private bool TryGetImpl(ushort key, out Span<byte> data, out int slotIndex)
     {
         var to = _header.Low;

src/Paprika/Store/BottomPage.cs

@@ -566,10 +566,10 @@ public Page Set(in NibblePath key, in ReadOnlySpan<byte> data, IBatchContext bat
 
         foreach (var item in copy.EnumerateAll())
         {
-            bottom.Set(item.Key, item.RawData, batch);
+            page.Set(item.Key, item.RawData, batch);
         }
 
-        bottom.Set(key, data, batch);
+        page.Set(key, data, batch);
 
         ArrayPool<byte>.Shared.Return(array);
 

src/Paprika/Store/DataPage.cs

@@ -149,6 +149,8 @@ private static void Set(DbAddress at, in NibblePath key, in ReadOnlySpan<byte> d
             current = childAddr;
         }
 
+        return;
+
         static bool TryTurnToFanOut(Page page, Page child, int bucket, IBatchContext batch)
         {
             if (page.Header.Level % 2 != 0 || page.Header.PageType != PageType.DataPage)
@@ -174,6 +176,8 @@ static bool TryTurnToFanOut(Page page, Page child, int bucket, IBatchContext bat
             var children = payload.Buckets;
             payload.Buckets.Clear();
 
+            // First, set all the grand-children right
+
             for (byte i = 0; i < Payload.NotFanOutBucketCount; i++)
             {
                 var p = batch.GetAt(children[i]);
@@ -197,14 +201,9 @@ static bool TryTurnToFanOut(Page page, Page child, int bucket, IBatchContext bat
                 }
 
                 // The child data page is no longer needed and can be recycled with its Merkle side-cars
-                if (dp.Data.MerkleLeft.IsNull == false)
+                if (dp.Data.Merkle.IsNull == false)
                 {
-                    batch.RegisterForFutureReuse(batch.GetAt(dp.Data.MerkleLeft), true);
-                }
-
-                if (dp.Data.MerkleRight.IsNull == false)
-                {
-                    batch.RegisterForFutureReuse(batch.GetAt(dp.Data.MerkleRight), true);
+                    batch.RegisterForFutureReuse(batch.GetAt(dp.Data.Merkle), true);
                 }
 
                 batch.RegisterForFutureReuse(dp.AsPage(), true);
@@ -231,16 +230,14 @@ private static bool TrySetAtBottom(in NibblePath key, ReadOnlySpan<byte> data, I
     /// </summary>
     private const int MerkleInMapToNibble = 3;
 
-    private const int MerkleInRightFromInclusive = 9;
-
     private static void SetLocally(in NibblePath key, ReadOnlySpan<byte> data, IBatchContext batch, ref Payload payload,
         PageHeader header)
     {
         // The key should be kept locally
         var map = new SlottedArray(payload.DataSpan);
 
         // Check if deletion with empty local
-        if (data.IsEmpty && payload.MerkleLeft.IsNull)
+        if (data.IsEmpty && payload.Merkle.IsNull)
         {
             map.Delete(key);
             return;
@@ -252,88 +249,24 @@ private static void SetLocally(in NibblePath key, ReadOnlySpan<byte> data, IBatc
             return;
         }
 
-        var left = batch.EnsureWritableOrGetNew<ChildBottomPage>(ref payload.MerkleLeft, header.Level);
-
-        ChildBottomPage right;
-        if (payload.MerkleRight.IsNull)
-        {
-            // Only left exist, try to move everything there.
-            foreach (var item in map.EnumerateAll())
-            {
-                // We keep these three values  
-                if (ShouldBeKeptLocalInMap(item.Key))
-                    continue;
-
-                if (left.Map.TrySet(item.Key, item.RawData))
-                {
-                    map.Delete(item);
-                }
-            }
-
-            if (map.TrySet(key, data))
-            {
-                // All good, map can hold the data.
-                return;
-            }
-
-            // Not enough space. Create the right and perform the split
-            right = batch.GetNewPage<ChildBottomPage>(out payload.MerkleRight, header.Level);
-
-            // Only left exist, try to move everything there.
-            foreach (var item in left.Map.EnumerateAll())
-            {
-                // We keep these three values  
-                if (ShouldBeKeptInRight(item.Key))
-                {
-                    right.Map.Set(item.Key, item.RawData);
-                    left.Map.Delete(item);
-                }
-            }
-        }
-
-        right = new ChildBottomPage(batch.EnsureWritableCopy(ref payload.MerkleRight));
+        var merkle = payload.Merkle.IsNull
+            ? batch.GetNewCleanPage<ChildBottomPage>(out payload.Merkle, header.Level).AsPage()
+            : batch.EnsureWritableCopy(ref payload.Merkle);
 
-        // Redistribute keys again
+        // Move all that are not local to the Merkle page.
         foreach (var item in map.EnumerateAll())
         {
             // We keep these three values  
             if (ShouldBeKeptLocalInMap(item.Key))
                 continue;
 
-            if (ShouldBeKeptInRight(item.Key))
-            {
-                if (item.RawData.IsEmpty)
-                    right.Map.Delete(item.Key);
-                else
-                    right.Map.Set(item.Key, item.RawData);
-            }
-            else
-            {
-                if (item.RawData.IsEmpty)
-                    left.Map.Delete(item.Key);
-                else
-                    left.Map.Set(item.Key, item.RawData);
-            }
-
+            merkle.Set(item.Key, item.RawData, batch);
             map.Delete(item);
         }
 
-        if (ShouldBeKeptLocalInMap(key))
-        {
-            map.Set(key, data);
-        }
-        else if (ShouldBeKeptInRight(key))
-        {
-            right.Map.Set(key, data);
-        }
-        else
-        {
-            left.Map.Set(key, data);
-        }
+        map.Set(key, data);
     }
 
-    private static bool ShouldBeKeptInRight(in NibblePath key) => key.Nibble0 >= MerkleInRightFromInclusive;
-
     private static bool ShouldBeKeptLocal(in NibblePath key) => key.IsEmpty || key.Length == 1;
 
     /// <summary>
@@ -357,19 +290,15 @@ public struct Payload
         /// <summary>
         /// The size of the raw byte data held in this page. Must be long aligned.
         /// </summary>
-        private const int DataSize = Size - BucketSize - DbAddress.Size * 2 - sizeof(int);
+        private const int DataSize = Size - BucketSize - DbAddress.Size - sizeof(int);
 
         private const int DataOffset = Size - DataSize;
 
-
         [FieldOffset(0)] public DbAddressList.Of256 Buckets;
 
-        [FieldOffset(BucketSize)] public DbAddress MerkleLeft;
+        [FieldOffset(BucketSize)] public DbAddress Merkle;
 
         [FieldOffset(BucketSize + DbAddress.Size)]
-        public DbAddress MerkleRight;
-
-        [FieldOffset(BucketSize + DbAddress.Size * 2)]
         public int ChildDataPages;
 
         /// <summary>
@@ -385,14 +314,12 @@ public struct Payload
         public void Clear()
         {
             new SlottedArray(DataSpan).Clear();
-            MerkleLeft = default;
-            MerkleRight = default;
+            Merkle = default;
             Buckets.Clear();
             ChildDataPages = 0;
         }
 
-        public bool IsClean => MerkleLeft.IsNull &&
-                               MerkleRight.IsNull &&
+        public bool IsClean => Merkle.IsNull &&
                                ChildDataPages == 0 &&
                                new SlottedArray(DataSpan).IsEmpty &&
                                Buckets.IsClean;
@@ -469,18 +396,12 @@ private bool TryGetLocally(scoped in NibblePath key, IPageResolver batch, out Re
             return true;
         }
 
-        // TODO: potential IO optimization to search left only if the right does not exist or the key does not belong to the right
-        if (Data.MerkleLeft.IsNull == false && batch.GetAt(Data.MerkleLeft).TryGet(batch, key, out result))
+        if (Data.Merkle.IsNull)
         {
-            return true;
-        }
-
-        if (Data.MerkleRight.IsNull == false && batch.GetAt(Data.MerkleRight).TryGet(batch, key, out result))
-        {
-            return true;
+            return false;
         }
 
-        return false;
+        return batch.GetAt(Data.Merkle).TryGet(batch, key, out result);
     }
 
     public SlottedArray Map => new(Data.DataSpan);

src/Paprika/Store/PagedDb.cs

@@ -533,7 +533,11 @@ public IDictionary<Keccak, uint> IdCache
 
         public void Prefetch(DbAddress address) => db.Prefetch(address);
 
-        public Page GetAt(DbAddress address) => db._manager.GetAt(address);
+        public Page GetAt(DbAddress address)
+        {
+            root.Assert(address);
+            return db._manager.GetAt(address);
+        }
 
         public override string ToString() => $"{nameof(ReadOnlyBatch)}, Name: {name}, BatchId: {BatchId}";
     }
@@ -695,8 +699,7 @@ public void VerifyDbPagesOnCommit()
         public override Page GetAt(DbAddress address)
         {
             // Getting a page beyond root!
-            var nextFree = _root.Data.NextFreePage;
-            Debug.Assert(address < nextFree, $"Breached the next free page, NextFree: {nextFree}, retrieved {address}");
+            _root.Assert(address);
             var page = _db.GetAt(address);
             return page;
         }