Change ValueRlpStream to be Span based (#7961)

benaadams · web-flow · commit 372e6e7102eb · 2024-12-23T01:34:13.000Z
diff --git a/src/Nethermind/Nethermind.Serialization.Rlp/ValueRlpStream.cs b/src/Nethermind/Nethermind.Serialization.Rlp/ValueRlpStream.cs
@@ -15,29 +15,27 @@ namespace Nethermind.Serialization.Rlp;
 
 public ref struct ValueRlpStream(in CappedArray<byte> data)
 {
-    private readonly ref readonly CappedArray<byte> _data = ref data;
+    public readonly ReadOnlySpan<byte> Data = data.AsSpan();
     private int _position = 0;
 
     internal readonly string Description =>
-        Data.AsSpan(0, Math.Min(Rlp.DebugMessageContentLength, Length)).ToHexString() ?? "0x";
-
-    public readonly ref readonly CappedArray<byte> Data => ref _data;
+        Data[..Math.Min(Rlp.DebugMessageContentLength, Data.Length)].ToHexString() ?? "0x";
 
     public int Position
     {
         readonly get => _position;
         set => _position = value;
     }
 
-    public readonly bool IsNull => Unsafe.IsNullRef(ref Unsafe.AsRef(in _data));
+    public readonly bool IsNull => Unsafe.IsNullRef(ref MemoryMarshal.GetReference(Data));
     public readonly bool IsNotNull => !IsNull;
     public readonly int Length => Data.Length;
 
     public int PeekNumberOfItemsRemaining(int? beforePosition = null, int maxSearch = int.MaxValue)
     {
-        int positionStored = Position;
+        int positionStored = _position;
         int numberOfItems = 0;
-        while (Position < (beforePosition ?? Length))
+        while (_position < (beforePosition ?? Data.Length))
         {
             int prefix = ReadByte();
             if (prefix <= 128)
@@ -61,7 +59,7 @@ public int PeekNumberOfItemsRemaining(int? beforePosition = null, int maxSearch
             }
             else
             {
-                Position--;
+                _position--;
                 int sequenceLength = ReadSequenceLength();
                 SkipBytes(sequenceLength);
             }
@@ -73,7 +71,7 @@ public int PeekNumberOfItemsRemaining(int? beforePosition = null, int maxSearch
             }
         }
 
-        Position = positionStored;
+        _position = positionStored;
         return numberOfItems;
     }
 
@@ -157,7 +155,7 @@ public int ReadSequenceLength()
         if (prefix < 192)
         {
             throw new RlpException(
-                $"Expected a sequence prefix to be in the range of <192, 255> and got {prefix} at position {Position} in the message of length {Length} starting with {Description}");
+                $"Expected a sequence prefix to be in the range of <192, 255> and got {prefix} at position {_position} in the message of length {Data.Length} starting with {Description}");
         }
 
         if (prefix <= 247)
@@ -271,22 +269,22 @@ static void ThrowArgumentOutOfRangeException(int lengthOfLength)
 
     public byte ReadByte()
     {
-        return Data![_position++];
+        return Data[_position++];
     }
 
     public readonly byte PeekByte()
     {
-        return Data![_position];
+        return Data[_position];
     }
 
     public void SkipBytes(int length)
     {
         _position += length;
     }
 
-    public Span<byte> Read(int length)
+    public ReadOnlySpan<byte> Read(int length)
     {
-        Span<byte> data = Data.AsSpan(_position, length);
+        ReadOnlySpan<byte> data = Data.Slice(_position, length);
         _position += length;
         return data;
     }
@@ -302,10 +300,10 @@ public Span<byte> Read(int length)
         if (prefix != 128 + 32)
         {
             throw new RlpException(
-                $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {Position} in the message of length {Length} starting with {Description}");
+                $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {_position} in the message of length {Data.Length} starting with {Description}");
         }
 
-        Span<byte> keccakSpan = Read(32);
+        ReadOnlySpan<byte> keccakSpan = Read(32);
         if (keccakSpan.SequenceEqual(Keccak.OfAnEmptyString.Bytes))
         {
             return Keccak.OfAnEmptyString;
@@ -331,28 +329,28 @@ public bool DecodeValueKeccak(out ValueHash256 keccak)
         if (prefix != 128 + 32)
         {
             throw new RlpException(
-                $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {Position} in the message of length {Length} starting with {Description}");
+                $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {_position} in the message of length {Data.Length} starting with {Description}");
         }
 
-        Span<byte> keccakSpan = Read(32);
+        ReadOnlySpan<byte> keccakSpan = Read(32);
         keccak = new ValueHash256(keccakSpan);
         return true;
     }
 
-    public readonly Span<byte> PeekNextItem()
+    public readonly ReadOnlySpan<byte> PeekNextItem()
     {
         int length = PeekNextRlpLength();
         return Peek(length);
     }
 
-    public readonly Span<byte> Peek(int length)
+    public readonly ReadOnlySpan<byte> Peek(int length)
     {
         return Peek(0, length);
     }
 
-    public readonly Span<byte> Peek(int offset, int length)
+    public readonly ReadOnlySpan<byte> Peek(int offset, int length)
     {
-        return Data.AsSpan(_position + offset, length);
+        return Data.Slice(_position + offset, length);
     }
 
     public byte[] DecodeByteArray()
@@ -450,7 +448,7 @@ public void SkipItem()
 
     public void Reset()
     {
-        Position = 0;
+        _position = 0;
     }
 
     private const byte EmptyArrayByte = 128;
@@ -459,6 +457,6 @@ public void Reset()
 
     public override readonly string ToString()
     {
-        return $"[{nameof(RlpStream)}|{Position}/{Length}]";
+        return $"[{nameof(RlpStream)}|{_position}/{Data.Length}]";
     }
 }
diff --git a/src/Nethermind/Nethermind.Trie/TrieNode.Decoder.cs b/src/Nethermind/Nethermind.Trie/TrieNode.Decoder.cs
@@ -368,7 +368,7 @@ private static void WriteChildrenRlpBranchRlp(ITrieNodeResolver tree, ref TreePa
                     if (data is null)
                     {
                         int length = rlpStream.PeekNextRlpLength();
-                        Span<byte> nextItem = rlpStream.Data.AsSpan(rlpStream.Position, length);
+                        ReadOnlySpan<byte> nextItem = rlpStream.Data.Slice(rlpStream.Position, length);
                         nextItem.CopyTo(destination.Slice(position, nextItem.Length));
                         position += nextItem.Length;
                         rlpStream.SkipBytes(length);
diff --git a/src/Nethermind/Nethermind.Trie/TrieNode.cs b/src/Nethermind/Nethermind.Trie/TrieNode.cs
@@ -1242,7 +1242,7 @@ private void SeekChildNotNull(ref ValueRlpStream rlpStream, int itemToSetOn)
                         default:
                             {
                                 rlpStream.Position--;
-                                Span<byte> fullRlp = rlpStream.PeekNextItem();
+                                ReadOnlySpan<byte> fullRlp = rlpStream.PeekNextItem();
                                 TrieNode child = new(NodeType.Unknown, fullRlp.ToArray());
                                 data = childOrRef = child;
                                 break;
@@ -1309,7 +1309,7 @@ private void ResolveAllChildBranch(ITrieNodeResolver tree, ref TreePath path, Tr
                         }
                     default:
                         {
-                            Span<byte> fullRlp = rlpStream.PeekNextItem();
+                            ReadOnlySpan<byte> fullRlp = rlpStream.PeekNextItem();
                             TrieNode child = new(NodeType.Unknown, fullRlp.ToArray());
                             rlpStream.SkipItem();
                             output[i] = child;

Original file line number	Diff line number	Diff line change
`@@ -15,29 +15,27 @@ namespace Nethermind.Serialization.Rlp;`
`15`	`15`
`16`	`16`	`public ref struct ValueRlpStream(in CappedArray<byte> data)`
`17`	`17`	`{`
`18`		`- private readonly ref readonly CappedArray<byte> _data = ref data;`
	`18`	`+ public readonly ReadOnlySpan<byte> Data = data.AsSpan();`
`19`	`19`	`private int _position = 0;`
`20`	`20`
`21`	`21`	`internal readonly string Description =>`
`22`		`- Data.AsSpan(0, Math.Min(Rlp.DebugMessageContentLength, Length)).ToHexString() ?? "0x";`
`23`		`-`
`24`		`- public readonly ref readonly CappedArray<byte> Data => ref _data;`
	`22`	`+ Data[..Math.Min(Rlp.DebugMessageContentLength, Data.Length)].ToHexString() ?? "0x";`
`25`	`23`
`26`	`24`	`public int Position`
`27`	`25`	`{`
`28`	`26`	`readonly get => _position;`
`29`	`27`	`set => _position = value;`
`30`	`28`	`}`
`31`	`29`
`32`		`- public readonly bool IsNull => Unsafe.IsNullRef(ref Unsafe.AsRef(in _data));`
	`30`	`+ public readonly bool IsNull => Unsafe.IsNullRef(ref MemoryMarshal.GetReference(Data));`
`33`	`31`	`public readonly bool IsNotNull => !IsNull;`
`34`	`32`	`public readonly int Length => Data.Length;`
`35`	`33`
`36`	`34`	`public int PeekNumberOfItemsRemaining(int? beforePosition = null, int maxSearch = int.MaxValue)`
`37`	`35`	`{`
`38`		`- int positionStored = Position;`
	`36`	`+ int positionStored = _position;`
`39`	`37`	`int numberOfItems = 0;`
`40`		`- while (Position < (beforePosition ?? Length))`
	`38`	`+ while (_position < (beforePosition ?? Data.Length))`
`41`	`39`	`{`
`42`	`40`	`int prefix = ReadByte();`
`43`	`41`	`if (prefix <= 128)`
`@@ -61,7 +59,7 @@ public int PeekNumberOfItemsRemaining(int? beforePosition = null, int maxSearch`
`61`	`59`	`}`
`62`	`60`	`else`
`63`	`61`	`{`
`64`		`- Position--;`
	`62`	`+ _position--;`
`65`	`63`	`int sequenceLength = ReadSequenceLength();`
`66`	`64`	`SkipBytes(sequenceLength);`
`67`	`65`	`}`
`@@ -73,7 +71,7 @@ public int PeekNumberOfItemsRemaining(int? beforePosition = null, int maxSearch`
`73`	`71`	`}`
`74`	`72`	`}`
`75`	`73`
`76`		`- Position = positionStored;`
	`74`	`+ _position = positionStored;`
`77`	`75`	`return numberOfItems;`
`78`	`76`	`}`
`79`	`77`
`@@ -157,7 +155,7 @@ public int ReadSequenceLength()`
`157`	`155`	`if (prefix < 192)`
`158`	`156`	`{`
`159`	`157`	`throw new RlpException(`
`160`		`- $"Expected a sequence prefix to be in the range of <192, 255> and got {prefix} at position {Position} in the message of length {Length} starting with {Description}");`
	`158`	`+ $"Expected a sequence prefix to be in the range of <192, 255> and got {prefix} at position {_position} in the message of length {Data.Length} starting with {Description}");`
`161`	`159`	`}`
`162`	`160`
`163`	`161`	`if (prefix <= 247)`
`@@ -271,22 +269,22 @@ static void ThrowArgumentOutOfRangeException(int lengthOfLength)`
`271`	`269`
`272`	`270`	`public byte ReadByte()`
`273`	`271`	`{`
`274`		`- return Data![_position++];`
	`272`	`+ return Data[_position++];`
`275`	`273`	`}`
`276`	`274`
`277`	`275`	`public readonly byte PeekByte()`
`278`	`276`	`{`
`279`		`- return Data![_position];`
	`277`	`+ return Data[_position];`
`280`	`278`	`}`
`281`	`279`
`282`	`280`	`public void SkipBytes(int length)`
`283`	`281`	`{`
`284`	`282`	`_position += length;`
`285`	`283`	`}`
`286`	`284`
`287`		`- public Span<byte> Read(int length)`
	`285`	`+ public ReadOnlySpan<byte> Read(int length)`
`288`	`286`	`{`
`289`		`- Span<byte> data = Data.AsSpan(_position, length);`
	`287`	`+ ReadOnlySpan<byte> data = Data.Slice(_position, length);`
`290`	`288`	`_position += length;`
`291`	`289`	`return data;`
`292`	`290`	`}`
`@@ -302,10 +300,10 @@ public Span<byte> Read(int length)`
`302`	`300`	`if (prefix != 128 + 32)`
`303`	`301`	`{`
`304`	`302`	`throw new RlpException(`
`305`		`- $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {Position} in the message of length {Length} starting with {Description}");`
	`303`	`+ $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {_position} in the message of length {Data.Length} starting with {Description}");`
`306`	`304`	`}`
`307`	`305`
`308`		`- Span<byte> keccakSpan = Read(32);`
	`306`	`+ ReadOnlySpan<byte> keccakSpan = Read(32);`
`309`	`307`	`if (keccakSpan.SequenceEqual(Keccak.OfAnEmptyString.Bytes))`
`310`	`308`	`{`
`311`	`309`	`return Keccak.OfAnEmptyString;`
`@@ -331,28 +329,28 @@ public bool DecodeValueKeccak(out ValueHash256 keccak)`
`331`	`329`	`if (prefix != 128 + 32)`
`332`	`330`	`{`
`333`	`331`	`throw new RlpException(`
`334`		`- $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {Position} in the message of length {Length} starting with {Description}");`
	`332`	`+ $"Unexpected prefix of {prefix} when decoding {nameof(Hash256)} at position {_position} in the message of length {Data.Length} starting with {Description}");`
`335`	`333`	`}`
`336`	`334`
`337`		`- Span<byte> keccakSpan = Read(32);`
	`335`	`+ ReadOnlySpan<byte> keccakSpan = Read(32);`
`338`	`336`	`keccak = new ValueHash256(keccakSpan);`
`339`	`337`	`return true;`
`340`	`338`	`}`
`341`	`339`
`342`		`- public readonly Span<byte> PeekNextItem()`
	`340`	`+ public readonly ReadOnlySpan<byte> PeekNextItem()`
`343`	`341`	`{`
`344`	`342`	`int length = PeekNextRlpLength();`
`345`	`343`	`return Peek(length);`
`346`	`344`	`}`
`347`	`345`
`348`		`- public readonly Span<byte> Peek(int length)`
	`346`	`+ public readonly ReadOnlySpan<byte> Peek(int length)`
`349`	`347`	`{`
`350`	`348`	`return Peek(0, length);`
`351`	`349`	`}`
`352`	`350`
`353`		`- public readonly Span<byte> Peek(int offset, int length)`
	`351`	`+ public readonly ReadOnlySpan<byte> Peek(int offset, int length)`
`354`	`352`	`{`
`355`		`- return Data.AsSpan(_position + offset, length);`
	`353`	`+ return Data.Slice(_position + offset, length);`
`356`	`354`	`}`
`357`	`355`
`358`	`356`	`public byte[] DecodeByteArray()`
`@@ -450,7 +448,7 @@ public void SkipItem()`
`450`	`448`
`451`	`449`	`public void Reset()`
`452`	`450`	`{`
`453`		`- Position = 0;`
	`451`	`+ _position = 0;`
`454`	`452`	`}`
`455`	`453`
`456`	`454`	`private const byte EmptyArrayByte = 128;`
`@@ -459,6 +457,6 @@ public void Reset()`
`459`	`457`
`460`	`458`	`public override readonly string ToString()`
`461`	`459`	`{`
`462`		`- return $"[{nameof(RlpStream)}\|{Position}/{Length}]";`
	`460`	`+ return $"[{nameof(RlpStream)}\|{_position}/{Data.Length}]";`
`463`	`461`	`}`
`464`	`462`	`}`
Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ private static void WriteChildrenRlpBranchRlp(ITrieNodeResolver tree, ref TreePa`
`368`	`368`	`if (data is null)`
`369`	`369`	`{`
`370`	`370`	`int length = rlpStream.PeekNextRlpLength();`
`371`		`- Span<byte> nextItem = rlpStream.Data.AsSpan(rlpStream.Position, length);`
	`371`	`+ ReadOnlySpan<byte> nextItem = rlpStream.Data.Slice(rlpStream.Position, length);`
`372`	`372`	`nextItem.CopyTo(destination.Slice(position, nextItem.Length));`
`373`	`373`	`position += nextItem.Length;`
`374`	`374`	`rlpStream.SkipBytes(length);`
Original file line number	Diff line number	Diff line change
`@@ -1242,7 +1242,7 @@ private void SeekChildNotNull(ref ValueRlpStream rlpStream, int itemToSetOn)`
`1242`	`1242`	`default:`
`1243`	`1243`	`{`
`1244`	`1244`	`rlpStream.Position--;`
`1245`		`- Span<byte> fullRlp = rlpStream.PeekNextItem();`
	`1245`	`+ ReadOnlySpan<byte> fullRlp = rlpStream.PeekNextItem();`
`1246`	`1246`	`TrieNode child = new(NodeType.Unknown, fullRlp.ToArray());`
`1247`	`1247`	`data = childOrRef = child;`
`1248`	`1248`	`break;`
`@@ -1309,7 +1309,7 @@ private void ResolveAllChildBranch(ITrieNodeResolver tree, ref TreePath path, Tr`
`1309`	`1309`	`}`
`1310`	`1310`	`default:`
`1311`	`1311`	`{`
`1312`		`- Span<byte> fullRlp = rlpStream.PeekNextItem();`
	`1312`	`+ ReadOnlySpan<byte> fullRlp = rlpStream.PeekNextItem();`
`1313`	`1313`	`TrieNode child = new(NodeType.Unknown, fullRlp.ToArray());`
`1314`	`1314`	`rlpStream.SkipItem();`
`1315`	`1315`	`output[i] = child;`