[WIP] Akka.IO / Akka.Streams: ByteString rewrite

src/core/Akka.Streams/Dsl/Framing.cs

@@ -169,39 +169,45 @@ public FramingException(string message) : base(message)
             protected FramingException(SerializationInfo info, StreamingContext context) : base(info, context) { }
         }
 
-        private static readonly Func<IEnumerator<byte>, int, int> BigEndianDecoder = (enumerator, length) =>
+        private static int BigEndianDecoder(ref ReadOnlySpan<byte> enumerator, int length)
         {
-            var count = length;
-            var decoded = 0;
-            while (count > 0)
+            if (length > enumerator.Length)
+            {
+                throw new ArgumentException("Length exceeds the size of the enumerator.");
+            }
+
+            var result = 0;
+
+            // Assuming 'length' is 4 for a 32-bit integer.
+            // Adjust the loop and shift amounts if dealing with different sizes.
+            for (var i = 0; i < length; i++)
             {
-                decoded <<= 8;
-                if (!enumerator.MoveNext()) throw new IndexOutOfRangeException("LittleEndianDecoder reached end of byte string");
-                decoded |= enumerator.Current & 0xFF;
-                count--;
+                result |= enumerator[i] << ((length - 1 - i) * 8);
             }
 
-            return decoded;
-        };
+            return result;
+        }
 
-        private static readonly Func<IEnumerator<byte>, int, int> LittleEndianDecoder = (enumerator, length) =>
+        private static int LittleEndianDecoder(ref ReadOnlySpan<byte> span, int length)
         {
-            var highestOcted = (length - 1) << 3;
-            var mask = (int) (1L << (length << 3)) - 1;
-            var count = length;
+            if (length > span.Length)
+            {
+                throw new IndexOutOfRangeException("LittleEndianDecoder reached end of byte span");
+            }
+
             var decoded = 0;
+            var highestOctetShift = (length - 1) << 3;
+            var mask = (int)(1L << (length << 3)) - 1;
 
-            while (count > 0)
+            for (var i = 0; i < length; i++)
             {
-                // decoded >>>= 8 on the jvm
-                decoded = (int) ((uint) decoded >> 8);
-                if (!enumerator.MoveNext()) throw new IndexOutOfRangeException("LittleEndianDecoder reached end of byte string");
-                decoded += (enumerator.Current & 0xFF) << highestOcted;
-                count--;
+                // Shift and add the ith byte to 'decoded'. No need for >>>= as in JVM; just shift appropriately.
+                var shiftAmount = highestOctetShift - (i << 3);
+                decoded |= (span[i] & 0xFF) << shiftAmount;
             }
 
             return decoded & mask;
-        };
+        }
 
         private sealed class SimpleFramingProtocolEncoderStage : SimpleLinearGraphStage<ByteString>
         {
@@ -342,8 +348,8 @@ private void DoParse()
                         else if (_buffer.HasSubstring(_stage._separatorBytes, possibleMatchPosition))
                         {
                             // Found a match
-                            var parsedFrame = _buffer.Slice(0, possibleMatchPosition).Compact();
-                            _buffer = _buffer.Slice(possibleMatchPosition + _stage._separatorBytes.Count).Compact();
+                            var parsedFrame = _buffer.Slice(0, possibleMatchPosition);
+                            _buffer = _buffer.Slice(possibleMatchPosition + _stage._separatorBytes.Count);
                             _nextPossibleMatch = 0;
                             Push(_stage.Outlet, parsedFrame);
 
@@ -422,7 +428,7 @@ public override void OnUpstreamFinish()
                 /// </summary>
                 private void PushFrame()
                 {
-                    var emit = _buffer.Slice(0, _frameSize).Compact();
+                    var emit = _buffer.Slice(0, _frameSize);
                     _buffer = _buffer.Slice(_frameSize);
                     _frameSize = int.MaxValue;
                     Push(_stage.Outlet, emit);
@@ -440,9 +446,14 @@ private void TryPushFrame()
                         PushFrame();
                     else if (bufferSize >= _stage._minimumChunkSize)
                     {
-                        var iterator = _buffer.Slice(_stage._lengthFieldOffset).GetEnumerator();
-                        var parsedLength = _stage._intDecoder(iterator, _stage._lengthFieldLength);
-
+                        var iterator = _buffer.Memory.Span.Slice(_stage._lengthFieldOffset);
+                        var parsedLength = _stage._byteOrder switch {
+                            ByteOrder.BigEndian => BigEndianDecoder(ref iterator, _stage._lengthFieldLength),
+                            ByteOrder.LittleEndian => LittleEndianDecoder(ref iterator, _stage._lengthFieldLength),
+                            _ => throw new NotSupportedException($"ByteOrder {_stage._byteOrder} is not supported")
+                        }; 
+
+                        // TODO: AVOID ARRAY COPYING AGAIN HERE
                         _frameSize = _stage._computeFrameSize.HasValue
                             ? _stage._computeFrameSize.Value(_buffer.Slice(0, _stage._lengthFieldOffset).ToArray(), parsedLength)
                             : parsedLength + _stage._minimumChunkSize;
@@ -480,7 +491,7 @@ private void TryPull()
             private readonly int _maximumFramelength;
             private readonly int _lengthFieldOffset;
             private readonly int _minimumChunkSize;
-            private readonly Func<IEnumerator<byte>, int, int> _intDecoder;
+            private readonly ByteOrder _byteOrder;
             private readonly Option<Func<IReadOnlyList<byte>, int, int>> _computeFrameSize;
 
             // For the sake of binary compatibility
@@ -500,7 +511,7 @@ public LengthFieldFramingStage(
                 _lengthFieldOffset = lengthFieldOffset;
                 _minimumChunkSize = lengthFieldOffset + lengthFieldLength;
                 _computeFrameSize = computeFrameSize;
-                _intDecoder = byteOrder == ByteOrder.BigEndian ? BigEndianDecoder : LittleEndianDecoder;
+                _byteOrder = byteOrder;
             }
 
             protected override GraphStageLogic CreateLogic(Attributes inheritedAttributes) => new Logic(this);

src/core/Akka.Tests/Util/ByteStringSpec.cs

@@ -5,6 +5,7 @@
 // </copyright>
 //-----------------------------------------------------------------------
 
+using System;
 using System.Linq;
 using System.Text;
 using Akka.IO;
@@ -14,15 +15,10 @@
 
 namespace Akka.Tests.Util
 {
-
-    /// <summary>
-    /// TODO: Should we use the FsCheck.XUnit integration when they upgrade to xUnit 2
-    /// </summary>
     public class ByteStringSpec
     {
         class Generators
         {
-
             // TODO: Align with JVM Akka Generator
             public static Arbitrary<ByteString> ByteStrings()
             {
@@ -45,7 +41,7 @@ public void A_ByteString_must_have_correct_size_when_concatenating()
         [Fact]
         public void A_ByteString_must_have_correct_size_when_slicing_from_index()
         {
-            var a = ByteString.FromBytes(new byte[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9} );
+            var a = ByteString.FromBytes(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
             var b = ByteString.FromBytes(new byte[] { 10, 11, 12, 13, 14, 15, 16, 17, 18 });
 
             (a + b).Slice(b.Count).Count.Should().Be(a.Count);
@@ -54,32 +50,24 @@ public void A_ByteString_must_have_correct_size_when_slicing_from_index()
         [Fact]
         public void A_ByteString_must_be_sequential_when_slicing_from_start()
         {
-            Prop.ForAll((ByteString a, ByteString b) => (a + b).Slice(0, a.Count).SequenceEqual(a))
+            Prop.ForAll((ByteString a, ByteString b) =>
+                    (a + b).Slice(0, a.Count).Memory.Span.SequenceEqual(a.Memory.Span))
                 .QuickCheckThrowOnFailure();
         }
+
         [Fact]
         public void A_ByteString_must_be_sequential_when_slicing_from_index()
         {
-            var a = ByteString.FromBytes(new byte[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9} );
+            var a = ByteString.FromBytes(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
             var b = ByteString.FromBytes(new byte[] { 10, 11, 12, 13, 14, 15, 16, 17, 18 });
 
             (a + b).Slice(a.Count).Should().BeEquivalentTo(b);
         }
 
-        [Fact]
-        public void A_ByteString_must_be_equal_to_the_original_when_compacting()
-        {
-            Prop.ForAll((ByteString xs) =>
-            {
-                var ys = xs.Compact();
-                return xs.SequenceEqual(ys) && ys.IsCompact;
-            }).QuickCheckThrowOnFailure();
-        }
-
         [Fact]
         public void A_ByteString_must_be_equal_to_the_original_when_recombining()
         {
-            var xs = ByteString.FromBytes(new byte[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9} );
+            var xs = ByteString.FromBytes(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
             var tmp1 = xs.Slice(0, xs.Count / 2);
             var tmp2 = xs.Slice(xs.Count / 2);
             var tmp11 = tmp1.Slice(0, tmp1.Count / 2);
@@ -90,32 +78,24 @@ public void A_ByteString_must_be_equal_to_the_original_when_recombining()
         [Fact]
         public void A_ByteString_must_behave_as_expected_when_created_from_and_decoding_to_String()
         {
-            Prop.ForAll((string s) => ByteString.FromString(s, Encoding.UTF8).ToString(Encoding.UTF8) == (s ?? "")) // TODO: What should we do with null string?
+            Prop.ForAll((string s) =>
+                    ByteString.FromString(s, Encoding.UTF8).ToString(Encoding.UTF8) ==
+                    (s ?? "")) // TODO: What should we do with null string?
                 .QuickCheckThrowOnFailure();
         }
 
         [Fact]
         public void A_ByteString_must_behave_as_expected_when_created_from_and_decoding_to_unicode_String()
         {
-            Prop.ForAll((string s) => ByteString.FromString(s, Encoding.Unicode).ToString(Encoding.Unicode) == (s ?? "")) // TODO: What should we do with null string?
+            Prop.ForAll(
+                    (string s) =>
+                        ByteString.FromString(s, Encoding.Unicode).ToString(Encoding.Unicode) ==
+                        (s ?? "")) // TODO: What should we do with null string?
                 .QuickCheckThrowOnFailure();
         }
 
-        [Fact]
-        public void A_ByteString_must_behave_as_expected_when_compacting()
-        {
-            Prop.ForAll((ByteString a) =>
-            {
-                var wasCompact = a.IsCompact;
-                var b = a.Compact();
-                return ((!wasCompact) || (b == a)) &&
-                       b.SequenceEqual(a) &&
-                       b.IsCompact &&
-                       b.Compact() == b;
-            }).QuickCheckThrowOnFailure();
-        }
-
-        [Fact(DisplayName = @"A concatenated byte string should return the index of a byte in one the two byte strings.")]
+        [Fact(DisplayName =
+            @"A concatenated byte string should return the index of a byte in one the two byte strings.")]
         public void A_concatenated_bytestring_must_return_correct_index_of_elements_in_string()
         {
             var b = ByteString.FromBytes(new byte[] { 1 }) + ByteString.FromBytes(new byte[] { 2 });
@@ -124,7 +104,8 @@ public void A_concatenated_bytestring_must_return_correct_index_of_elements_in_s
             Assert.Equal(1, offset);
         }
 
-        [Fact(DisplayName = @"A concatenated byte string should return -1 when it was not found in the concatenated byte strings")]
+        [Fact(DisplayName =
+            @"A concatenated byte string should return -1 when it was not found in the concatenated byte strings")]
         public void A_concatenated_bytestring_must_return_negative_one_when_an_element_was_not_found()
         {
             var b = ByteString.FromBytes(new byte[] { 1 }) + ByteString.FromBytes(new byte[] { 2 });
@@ -133,7 +114,8 @@ public void A_concatenated_bytestring_must_return_negative_one_when_an_element_w
             Assert.Equal(-1, offset);
         }
 
-        [Fact(DisplayName = "A concatenated byte string composed of partial characters must return the correct string for ToString(Unicode)")]
+        [Fact(DisplayName =
+            "A concatenated byte string composed of partial characters must return the correct string for ToString(Unicode)")]
         public void A_concatenated_ByteString_with_partial_characters_must_return_correct_string_for_ToString_Unicode()
         {
             // In Unicode encoding, characters present in the ASCII character set are 2 bytes long.
@@ -152,7 +134,8 @@ public void A_concatenated_ByteString_with_partial_characters_must_return_correc
             Assert.Equal(expected, actual);
         }
 
-        [Fact(DisplayName = "A concatenated byte string composed of partial characters must return the correct string for ToString(UTF8)")]
+        [Fact(DisplayName =
+            "A concatenated byte string composed of partial characters must return the correct string for ToString(UTF8)")]
         public void A_concatenated_ByteString_with_partial_characters_must_return_correct_string_for_ToString_UTF8()
         {
             // In UTF-8 encoding, characters present in the ASCII character set are only 1 byte long.
@@ -213,4 +196,4 @@ public void A_sliced_ByteString_using_Range_must_return_correct_string_for_ToStr
         }
 #endif
     }
-}
+}

src/core/Akka/IO/SocketEventArgsPool.cs

@@ -82,44 +82,13 @@ public void Release(SocketAsyncEventArgs e)
 
     internal static class SocketAsyncEventArgsExtensions
     {
-        public static void SetBuffer(this SocketAsyncEventArgs args, ByteString data)
-        {
-            if (data.IsCompact)
-            {
-                var buffer = data.Buffers[0];
-                if (args.BufferList != null)
-                {
-                    // BufferList property setter is not simple member association operation, 
-                    // but the getter is. Therefore we first check if we need to clear buffer list
-                    // and only do so if necessary.
-                    args.BufferList = null;
-                }
-                args.SetBuffer(buffer.Array, buffer.Offset, buffer.Count);
-            }
-            else
-            {
-                if (RuntimeDetector.IsMono)
-                {
-                    // Mono doesn't support BufferList - falback to compacting ByteString
-                    var compacted = data.Compact();
-                    var buffer = compacted.Buffers[0];
-                    args.SetBuffer(buffer.Array, buffer.Offset, buffer.Count);
-                }
-                else
-                {
-                    args.SetBuffer(null, 0, 0);
-                    args.BufferList = data.Buffers;
-                }
-            }
-        }
-
         public static void SetBuffer(this SocketAsyncEventArgs args, IEnumerable<ByteString> dataCollection)
         {
             if (RuntimeDetector.IsMono)
             {
                 // Mono doesn't support BufferList - falback to compacting ByteString
                 var dataList = dataCollection.ToList();
-                var totalSize = dataList.SelectMany(d => d.Buffers).Sum(d => d.Count);
+                var totalSize = dataList.Count;
                 var bytes = new byte[totalSize];
                 var position = 0;
                 foreach (var byteString in dataList)
@@ -132,7 +101,8 @@ public static void SetBuffer(this SocketAsyncEventArgs args, IEnumerable<ByteStr
             else
             {
                 args.SetBuffer(null, 0, 0);
-                args.BufferList = dataCollection.SelectMany(d => d.Buffers).ToList();
+                // TODO: fix this before we ship
+                args.BufferList = new List<ArraySegment<byte>>(dataCollection.Select(bs => new ArraySegment<byte>(bs.ToArray())));
             }
         }
     }

src/core/Akka/IO/TcpConnection.cs

@@ -945,6 +945,7 @@ public override void DoWrite(ConnectionInfo info)
             {
                 try
                 {
+                    // TODO: avoid use of SocketAsyncEventArgs on newer platforms
                     _sendArgs.SetBuffer(_dataToSend);
                     if (!_connection.Socket.SendAsync(_sendArgs))
                         _self.Tell(SocketSent.Instance);