refactoring and simplifications

src/csharp/Grpc.Core/Internal/DefaultSerializationContext.cs

@@ -30,7 +30,7 @@ namespace Grpc.Core.Internal
 
         bool isComplete;
         //byte[] payload;
-        NativeBufferWriter bufferWriter;
+        SliceBufferSafeHandle sliceBuffer;
 
         public DefaultSerializationContext()
         {
@@ -43,10 +43,10 @@ namespace Grpc.Core.Internal
             this.isComplete = true;
 
             GetBufferWriter();
-            var destSpan = bufferWriter.GetSpan(payload.Length);
+            var destSpan = sliceBuffer.GetSpan(payload.Length);
             payload.AsSpan().CopyTo(destSpan);
-            bufferWriter.Advance(payload.Length);
-            bufferWriter.Complete();
+            sliceBuffer.Advance(payload.Length);
+            sliceBuffer.Complete();
             //this.payload = payload;
         }
 
@@ -55,12 +55,12 @@ namespace Grpc.Core.Internal
         /// </summary>
         public override IBufferWriter<byte> GetBufferWriter()
         {
-            if (bufferWriter == null)
+            if (sliceBuffer == null)
             {
                 // TODO: avoid allocation..
-                bufferWriter = new NativeBufferWriter();
+                sliceBuffer = SliceBufferSafeHandle.Create();
             }
-            return bufferWriter;
+            return sliceBuffer;
         }
 
         /// <summary>
@@ -69,20 +69,20 @@ namespace Grpc.Core.Internal
         public override void Complete()
         {
             GrpcPreconditions.CheckState(!isComplete);
-            bufferWriter.Complete();
+            sliceBuffer.Complete();
             this.isComplete = true;
         }
 
         internal SliceBufferSafeHandle GetPayload()
         {
-            return bufferWriter.GetSliceBuffer();
+            return sliceBuffer;
         }
 
         public void Reset()
         {
             this.isComplete = false;
             //this.payload = null;
-            this.bufferWriter = null;
+            this.sliceBuffer = null;  // reset instead...
         }
 
         public static DefaultSerializationContext GetInitializedThreadLocal()
@@ -92,35 +92,6 @@ namespace Grpc.Core.Internal
             return instance;
         }
 
-        private class NativeBufferWriter : IBufferWriter<byte>
-        {
-            private SliceBufferSafeHandle sliceBuffer = SliceBufferSafeHandle.Create();
-
-            public void Advance(int count)
-            {
-                sliceBuffer.Advance(count);
-            }
-
-            public Memory<byte> GetMemory(int sizeHint = 0)
-            {
-                // TODO: implement
-                throw new NotImplementedException();
-            }
-
-            public Span<byte> GetSpan(int sizeHint = 0)
-            {
-                return sliceBuffer.GetSpan(sizeHint);
-            }
-
-            public void Complete()
-            {
-                sliceBuffer.Complete();
-            }
-
-            public SliceBufferSafeHandle GetSliceBuffer()
-            {
-                return sliceBuffer;
-            }
-        }
+        
     }
 }

src/csharp/Grpc.Core/Internal/NativeMethods.Generated.cs

@@ -126,6 +126,7 @@ namespace Grpc.Core.Internal
         public readonly Delegates.grpcsharp_slice_buffer_adjust_tail_space_delegate grpcsharp_slice_buffer_adjust_tail_space;
         public readonly Delegates.grpcsharp_slice_buffer_slice_count_delegate grpcsharp_slice_buffer_slice_count;
         public readonly Delegates.grpcsharp_slice_buffer_slice_peek_delegate grpcsharp_slice_buffer_slice_peek;
+        public readonly Delegates.grpcsharp_slice_buffer_reset_and_unref_delegate grpcsharp_slice_buffer_reset_and_unref;
         public readonly Delegates.grpcsharp_slice_buffer_destroy_delegate grpcsharp_slice_buffer_destroy;
         public readonly Delegates.gprsharp_now_delegate gprsharp_now;
         public readonly Delegates.gprsharp_inf_future_delegate gprsharp_inf_future;
@@ -233,6 +234,7 @@ namespace Grpc.Core.Internal
             this.grpcsharp_slice_buffer_adjust_tail_space = GetMethodDelegate<Delegates.grpcsharp_slice_buffer_adjust_tail_space_delegate>(library);
             this.grpcsharp_slice_buffer_slice_count = GetMethodDelegate<Delegates.grpcsharp_slice_buffer_slice_count_delegate>(library);
             this.grpcsharp_slice_buffer_slice_peek = GetMethodDelegate<Delegates.grpcsharp_slice_buffer_slice_peek_delegate>(library);
+            this.grpcsharp_slice_buffer_reset_and_unref = GetMethodDelegate<Delegates.grpcsharp_slice_buffer_reset_and_unref_delegate>(library);
             this.grpcsharp_slice_buffer_destroy = GetMethodDelegate<Delegates.grpcsharp_slice_buffer_destroy_delegate>(library);
             this.gprsharp_now = GetMethodDelegate<Delegates.gprsharp_now_delegate>(library);
             this.gprsharp_inf_future = GetMethodDelegate<Delegates.gprsharp_inf_future_delegate>(library);
@@ -339,6 +341,7 @@ namespace Grpc.Core.Internal
             this.grpcsharp_slice_buffer_adjust_tail_space = DllImportsFromStaticLib.grpcsharp_slice_buffer_adjust_tail_space;
             this.grpcsharp_slice_buffer_slice_count = DllImportsFromStaticLib.grpcsharp_slice_buffer_slice_count;
             this.grpcsharp_slice_buffer_slice_peek = DllImportsFromStaticLib.grpcsharp_slice_buffer_slice_peek;
+            this.grpcsharp_slice_buffer_reset_and_unref = DllImportsFromStaticLib.grpcsharp_slice_buffer_reset_and_unref;
             this.grpcsharp_slice_buffer_destroy = DllImportsFromStaticLib.grpcsharp_slice_buffer_destroy;
             this.gprsharp_now = DllImportsFromStaticLib.gprsharp_now;
             this.gprsharp_inf_future = DllImportsFromStaticLib.gprsharp_inf_future;
@@ -445,6 +448,7 @@ namespace Grpc.Core.Internal
             this.grpcsharp_slice_buffer_adjust_tail_space = DllImportsFromSharedLib.grpcsharp_slice_buffer_adjust_tail_space;
             this.grpcsharp_slice_buffer_slice_count = DllImportsFromSharedLib.grpcsharp_slice_buffer_slice_count;
             this.grpcsharp_slice_buffer_slice_peek = DllImportsFromSharedLib.grpcsharp_slice_buffer_slice_peek;
+            this.grpcsharp_slice_buffer_reset_and_unref = DllImportsFromSharedLib.grpcsharp_slice_buffer_reset_and_unref;
             this.grpcsharp_slice_buffer_destroy = DllImportsFromSharedLib.grpcsharp_slice_buffer_destroy;
             this.gprsharp_now = DllImportsFromSharedLib.gprsharp_now;
             this.gprsharp_inf_future = DllImportsFromSharedLib.gprsharp_inf_future;
@@ -554,6 +558,7 @@ namespace Grpc.Core.Internal
             public delegate IntPtr grpcsharp_slice_buffer_adjust_tail_space_delegate(SliceBufferSafeHandle sliceBuffer, UIntPtr availableTailSpace, UIntPtr requestedTailSpace);
             public delegate UIntPtr grpcsharp_slice_buffer_slice_count_delegate(SliceBufferSafeHandle sliceBuffer);
             public delegate void grpcsharp_slice_buffer_slice_peek_delegate(SliceBufferSafeHandle sliceBuffer, UIntPtr index, out UIntPtr sliceLen, out IntPtr sliceDataPtr);
+            public delegate void grpcsharp_slice_buffer_reset_and_unref_delegate(SliceBufferSafeHandle sliceBuffer);
             public delegate void grpcsharp_slice_buffer_destroy_delegate(IntPtr sliceBuffer);
             public delegate Timespec gprsharp_now_delegate(ClockType clockType);
             public delegate Timespec gprsharp_inf_future_delegate(ClockType clockType);
@@ -849,6 +854,9 @@ namespace Grpc.Core.Internal
             [DllImport(ImportName)]
             public static extern void grpcsharp_slice_buffer_slice_peek(SliceBufferSafeHandle sliceBuffer, UIntPtr index, out UIntPtr sliceLen, out IntPtr sliceDataPtr);
             
+            [DllImport(ImportName)]
+            public static extern void grpcsharp_slice_buffer_reset_and_unref(SliceBufferSafeHandle sliceBuffer);
+            
             [DllImport(ImportName)]
             public static extern void grpcsharp_slice_buffer_destroy(IntPtr sliceBuffer);
             
@@ -1163,6 +1171,9 @@ namespace Grpc.Core.Internal
             [DllImport(ImportName)]
             public static extern void grpcsharp_slice_buffer_slice_peek(SliceBufferSafeHandle sliceBuffer, UIntPtr index, out UIntPtr sliceLen, out IntPtr sliceDataPtr);
             
+            [DllImport(ImportName)]
+            public static extern void grpcsharp_slice_buffer_reset_and_unref(SliceBufferSafeHandle sliceBuffer);
+            
             [DllImport(ImportName)]
             public static extern void grpcsharp_slice_buffer_destroy(IntPtr sliceBuffer);
             

src/csharp/Grpc.Core/Internal/SliceBufferSafeHandle.cs

@@ -17,6 +17,7 @@
 #endregion
 
 using System;
+using System.Buffers;
 using System.Runtime.InteropServices;
 using Grpc.Core;
 using Grpc.Core.Logging;
@@ -25,9 +26,10 @@ using Grpc.Core.Utils;
 namespace Grpc.Core.Internal
 {
     /// <summary>
-    /// grpc_slice_buffer
+    /// Represents grpc_slice_buffer with some extra utility functions to allow
+    /// writing data to it using the <c>IBufferWriter</c> interface.
     /// </summary>
-    internal class SliceBufferSafeHandle : SafeHandleZeroIsInvalid
+    internal class SliceBufferSafeHandle : SafeHandleZeroIsInvalid, IBufferWriter<byte>
     {
         static readonly NativeMethods Native = NativeMethods.Get();
         static readonly ILogger Logger = GrpcEnvironment.Logger.ForType<SliceBufferSafeHandle>();
@@ -35,8 +37,7 @@ namespace Grpc.Core.Internal
         public static readonly SliceBufferSafeHandle NullInstance = new SliceBufferSafeHandle();
 
         private IntPtr tailSpacePtr;
-        private UIntPtr tailSpaceLen;
-        
+        private int tailSpaceLen;
 
         private SliceBufferSafeHandle()
         {
@@ -59,21 +60,30 @@ namespace Grpc.Core.Internal
         {
             GrpcPreconditions.CheckArgument(count >= 0);
             GrpcPreconditions.CheckArgument(tailSpacePtr != IntPtr.Zero || count == 0);
-            GrpcPreconditions.CheckArgument(tailSpaceLen.ToUInt64() >= (ulong)count);
-            tailSpaceLen = new UIntPtr(tailSpaceLen.ToUInt64() - (ulong)count);
+            GrpcPreconditions.CheckArgument(tailSpaceLen >= count);
+            tailSpaceLen = tailSpaceLen - count;
             tailSpacePtr += count;
         }
 
-        public unsafe Span<byte> GetSpan(int sizeHint)
+        // provides access to the "tail space" of this buffer.
+        // Use GetSpan when possible for better efficiency.
+        public Memory<byte> GetMemory(int sizeHint = 0)
+        {
+            // TODO: implement
+            throw new NotImplementedException();
+        }
+
+        // provides access to the "tail space" of this buffer.
+        public unsafe Span<byte> GetSpan(int sizeHint = 0)
         {
             GrpcPreconditions.CheckArgument(sizeHint >= 0);
-            if (tailSpaceLen.ToUInt64() < (ulong) sizeHint)
+            if (tailSpaceLen < sizeHint)
             {
                 // TODO: should we ignore the hint sometimes when
                 // available tail space is close enough to the sizeHint?
                 AdjustTailSpace(sizeHint);
             }
-            return new Span<byte>(tailSpacePtr.ToPointer(), (int) tailSpaceLen.ToUInt64());
+            return new Span<byte>(tailSpacePtr.ToPointer(), tailSpaceLen);
         }
 
         public void Complete()
@@ -81,8 +91,17 @@ namespace Grpc.Core.Internal
             AdjustTailSpace(0);
         }
 
+        // resets the data contained by this slice buffer
+        public void Reset()
+        {
+            // deletes all the data in the slice buffer
+            tailSpacePtr = IntPtr.Zero;
+            tailSpaceLen = 0;
+            Native.grpcsharp_slice_buffer_reset_and_unref(this);
+        }
+
         // copies the content of the slice buffer to a newly allocated byte array
-        // due to its overhead, this method should only be used for testing.
+        // Note that this method has a relatively high overhead and should maily be used for testing.
         public byte[] ToByteArray()
         {
             ulong sliceCount = Native.grpcsharp_slice_buffer_slice_count(this).ToUInt64();
@@ -111,9 +130,8 @@ namespace Grpc.Core.Internal
         private void AdjustTailSpace(int requestedSize)
         {
             GrpcPreconditions.CheckArgument(requestedSize >= 0);
-            var requestedTailSpaceLen = new UIntPtr((ulong) requestedSize);
-            tailSpacePtr = Native.grpcsharp_slice_buffer_adjust_tail_space(this, tailSpaceLen, requestedTailSpaceLen);
-            tailSpaceLen = requestedTailSpaceLen;
+            tailSpacePtr = Native.grpcsharp_slice_buffer_adjust_tail_space(this, new UIntPtr((ulong) tailSpaceLen), new UIntPtr((ulong) requestedSize));
+            tailSpaceLen = requestedSize;
         }
         protected override bool ReleaseHandle()
         {

src/csharp/ext/grpc_csharp_ext.c

@@ -1195,6 +1195,11 @@ grpcsharp_slice_buffer_create() {
   return slice_buffer;
 }
 
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_slice_buffer_reset_and_unref(grpc_slice_buffer* buffer) {
+  grpc_slice_buffer_reset_and_unref(buffer);
+}
+
 GPR_EXPORT void GPR_CALLTYPE
 grpcsharp_slice_buffer_destroy(grpc_slice_buffer* buffer) {
   grpc_slice_buffer_destroy(buffer);
@@ -1214,8 +1219,6 @@ grpcsharp_slice_buffer_slice_peek(grpc_slice_buffer* buffer, size_t index, size_
   *slice_data_ptr = GRPC_SLICE_START_PTR(*slice_ptr);
 }
 
-
-
 GPR_EXPORT void* GPR_CALLTYPE
 grpcsharp_slice_buffer_adjust_tail_space(grpc_slice_buffer* buffer, size_t available_tail_space,
     size_t requested_tail_space) {

src/csharp/unitypackage/unitypackage_skeleton/Plugins/Grpc.Core/runtimes/grpc_csharp_ext_dummy_stubs.c

@@ -390,6 +390,10 @@ void grpcsharp_slice_buffer_slice_peek() {
   fprintf(stderr, "Should never reach here");
   abort();
 }
+void grpcsharp_slice_buffer_reset_and_unref() {
+  fprintf(stderr, "Should never reach here");
+  abort();
+}
 void grpcsharp_slice_buffer_destroy() {
   fprintf(stderr, "Should never reach here");
   abort();

templates/src/csharp/Grpc.Core/Internal/native_methods.include

@@ -92,6 +92,7 @@ native_method_signatures = [
     'IntPtr grpcsharp_slice_buffer_adjust_tail_space(SliceBufferSafeHandle sliceBuffer, UIntPtr availableTailSpace, UIntPtr requestedTailSpace)',
     'UIntPtr grpcsharp_slice_buffer_slice_count(SliceBufferSafeHandle sliceBuffer)',
     'void grpcsharp_slice_buffer_slice_peek(SliceBufferSafeHandle sliceBuffer, UIntPtr index, out UIntPtr sliceLen, out IntPtr sliceDataPtr)',
+    'void grpcsharp_slice_buffer_reset_and_unref(SliceBufferSafeHandle sliceBuffer)',
     'void grpcsharp_slice_buffer_destroy(IntPtr sliceBuffer)',
     'Timespec gprsharp_now(ClockType clockType)',
     'Timespec gprsharp_inf_future(ClockType clockType)',