NetSharp

commit bd3d3a56ae0835746dd9089083ca26e61a14de62
parent ad902fdd4a8c07adc5fab988ad2c58d17a4b9106
Author: Mikolaj Lenczewski <mikolaj.lenczewski308@gmail.com>
Date:   Tue,  9 Jun 2020 21:44:46 +0100

cleaned up benchmark helper and raw stream network reader, and started on reimplementation of RawStreamNetworkWriter

Diffstat:
M
NetSharp/NetSharp/Raw/Stream/RawStreamNetworkReader.cs
 | 
3
+--
M
NetSharp/NetSharp/Raw/Stream/RawStreamNetworkWriter.cs
 | 
127
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------
M
NetSharp/NetSharpExamples/BenchmarkHelper.cs
 | 
7
++++++-

3 files changed, 111 insertions(+), 26 deletions(-)
diff --git a/NetSharp/NetSharp/Raw/Stream/RawStreamNetworkReader.cs b/NetSharp/NetSharp/Raw/Stream/RawStreamNetworkReader.cs
@@ -33,8 +33,7 @@ namespace NetSharp.Raw.Stream
 
         private void CloseClientConnection(SocketAsyncEventArgs args)
         {
-            byte[] rentedBuffer = args.Buffer;
-            BufferPool.Return(rentedBuffer, true);
+            BufferPool.Return(args.Buffer, true);
 
             Socket clientSocket = args.AcceptSocket;
 
diff --git a/NetSharp/NetSharp/Raw/Stream/RawStreamNetworkWriter.cs b/NetSharp/NetSharp/Raw/Stream/RawStreamNetworkWriter.cs
@@ -1,11 +1,11 @@
 using System;
 using System.Net;
 using System.Net.Sockets;
-using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 
 namespace NetSharp.Raw.Stream
 {
+    // TODO finish off implementation
     public sealed class RawStreamNetworkWriter : RawNetworkWriterBase
     {
         /// <inheritdoc />
@@ -67,10 +67,90 @@ namespace NetSharp.Raw.Stream
 
         private void CompleteReceive(SocketAsyncEventArgs args)
         {
+            void CompleteReceiveHeader(SocketAsyncEventArgs args)
+            {
+            }
+
+            void CompleteReceiveData(SocketAsyncEventArgs args)
+            {
+            }
         }
 
         private void CompleteSend(SocketAsyncEventArgs args)
         {
+            void CompleteSendHeader(SocketAsyncEventArgs args)
+            {
+            }
+
+            void CompleteSendData(SocketAsyncEventArgs args)
+            {
+            }
+        }
+
+        private void ConfigureReceiveData(SocketAsyncEventArgs args, in RawStreamPacketHeader receivedPacketHeader)
+        {
+            BufferPool.Return(args.Buffer, true);  // return and clear the requestHeaderBuffer (as it was already parsed)
+
+            byte[] pendingPacketDataBuffer = BufferPool.Rent(receivedPacketHeader.DataSize);
+
+            args.SetBuffer(pendingPacketDataBuffer, 0, receivedPacketHeader.DataSize);
+
+            // TODO add transmission state token
+            args.UserToken = new RequestReadToken(receivedPacketHeader.DataSize, receivedPacketHeader);
+        }
+
+        private void ConfigureReceiveHeader(SocketAsyncEventArgs args)
+        {
+            byte[] pendingPacketHeaderBuffer = BufferPool.Rent(RawStreamPacketHeader.TotalSize);
+
+            args.SetBuffer(pendingPacketHeaderBuffer, 0, RawStreamPacketHeader.TotalSize);
+
+            // TODO add transmission state token
+            args.UserToken = new RequestReadToken(RawStreamPacketHeader.TotalSize, null);
+        }
+
+        private void ConfigureSendData(SocketAsyncEventArgs args, in RawStreamPacketHeader pendingPacketHeader, in ReadOnlyMemory<byte> pendingPacketData)
+        {
+            BufferPool.Return(args.Buffer, true);  // return and clear the requestHeaderBuffer (as it was already sent)
+
+            byte[] pendingPacketDataBuffer = BufferPool.Rent(pendingPacketHeader.DataSize);
+
+            args.SetBuffer(pendingPacketDataBuffer, 0, pendingPacketHeader.DataSize);
+
+            // TODO add transmission state token
+            args.UserToken = new ResponseWriteToken(pendingPacketHeader.DataSize);
+        }
+
+        private void ConfigureSendHeader(SocketAsyncEventArgs args, in RawStreamPacketHeader pendingPacketHeader)
+        {
+            byte[] pendingPacketHeaderBuffer = BufferPool.Rent(RawStreamPacketHeader.TotalSize);
+
+            pendingPacketHeader.Serialise(pendingPacketHeaderBuffer);
+
+            args.SetBuffer(pendingPacketHeaderBuffer, 0, RawStreamPacketHeader.TotalSize);
+
+            // TODO add transmission state token
+            args.UserToken = new ResponseWriteToken(RawStreamPacketHeader.TotalSize);
+        }
+
+        private void ContinueReceive(SocketAsyncEventArgs args)
+        {
+            if (Connection.ReceiveAsync(args))
+            {
+                return;
+            }
+
+            CompleteReceive(args);
+        }
+
+        private void ContinueSend(SocketAsyncEventArgs args)
+        {
+            if (Connection.SendAsync(args))
+            {
+                return;
+            }
+
+            CompleteSend(args);
         }
 
         private void HandleIoCompleted(object sender, SocketAsyncEventArgs args)
@@ -101,28 +181,6 @@ namespace NetSharp.Raw.Stream
             return true;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected void ContinueReceive(SocketAsyncEventArgs args)
-        {
-            if (Connection.ReceiveAsync(args))
-            {
-                return;
-            }
-
-            CompleteReceive(args);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected void ContinueSend(SocketAsyncEventArgs args)
-        {
-            if (Connection.SendAsync(args))
-            {
-                return;
-            }
-
-            CompleteSend(args);
-        }
-
         /// <inheritdoc />
         protected override SocketAsyncEventArgs CreateStateObject()
         {
@@ -215,5 +273,28 @@ namespace NetSharp.Raw.Stream
         {
             throw new NotImplementedException();
         }
+
+        private readonly struct RequestReadToken
+        {
+            public readonly int BytesToTransfer;
+            public readonly RawStreamPacketHeader? Header;
+
+            public RequestReadToken(int bytesToTransfer, in RawStreamPacketHeader? header)
+            {
+                BytesToTransfer = bytesToTransfer;
+
+                Header = header;
+            }
+        }
+
+        private readonly struct ResponseWriteToken
+        {
+            public readonly int BytesToTransfer;
+
+            public ResponseWriteToken(int bytesToTransfer)
+            {
+                BytesToTransfer = bytesToTransfer;
+            }
+        }
     }
 }
 \ No newline at end of file
diff --git a/NetSharp/NetSharpExamples/BenchmarkHelper.cs b/NetSharp/NetSharpExamples/BenchmarkHelper.cs
@@ -3,13 +3,18 @@ using System.Diagnostics;
 
 namespace NetSharpExamples
 {
-    public class BenchmarkHelper
+    public sealed class BenchmarkHelper
     {
         private readonly Stopwatch stopwatch = new Stopwatch();
         private long lastTicksSnapshot = 0, lastMsSnapshot = 0;
         private long minRttMs = int.MaxValue, maxRttMs = int.MinValue;
         private long minRttTicks = int.MaxValue, maxRttTicks = int.MinValue;
 
+        public BenchmarkHelper()
+        {
+            stopwatch.Reset();
+        }
+
         public long RttMs => stopwatch.ElapsedMilliseconds;
 
         public long RttTicks => stopwatch.ElapsedTicks;