Using MemoryMarshal.GetArrayDataReference in .net5.0

cuteant · cuteant · commit 9e0a7409f344 · 2021-06-24T22:13:10.000+08:00
diff --git a/src/DotNetty.Buffers/ArrayPooledByteBuffer.cs b/src/DotNetty.Buffers/ArrayPooledByteBuffer.cs
@@ -24,6 +24,9 @@
 using System.Buffers;
 using DotNetty.Common;
 using DotNetty.Common.Internal;
+#if NET
+using System.Runtime.InteropServices;
+#endif
 
 namespace DotNetty.Buffers
 {
@@ -186,7 +189,11 @@ public sealed override byte[] Array
         public sealed override ref byte GetPinnableMemoryAddress()
         {
             EnsureAccessible();
+#if NET
+            return ref MemoryMarshal.GetArrayDataReference(Memory);
+#else
             return ref Memory[0];
+#endif
         }
 
         public sealed override IntPtr AddressOfPinnedMemory() => IntPtr.Zero;
diff --git a/src/DotNetty.Buffers/ArrayPooledUnsafeDirectByteBuffer.cs b/src/DotNetty.Buffers/ArrayPooledUnsafeDirectByteBuffer.cs
@@ -27,6 +27,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 using DotNetty.Common;
+#if NET
+using System.Runtime.InteropServices;
+#endif
 
 namespace DotNetty.Buffers
 {
@@ -248,7 +251,14 @@ public sealed override IByteBuffer Copy(int index, int length)
         }
 
         [MethodImpl(InlineMethod.AggressiveOptimization)]
-        ref byte Addr(int index) => ref Memory[index];
+        ref byte Addr(int index)
+        {
+#if NET
+            return ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Memory), index);
+#else
+            return ref Memory[index];
+#endif
+        }
 
         public sealed override IByteBuffer SetZero(int index, int length)
         {
diff --git a/src/DotNetty.Buffers/PooledHeapByteBuffer.cs b/src/DotNetty.Buffers/PooledHeapByteBuffer.cs
@@ -31,6 +31,10 @@ namespace DotNetty.Buffers
     using System.Threading.Tasks;
     using DotNetty.Common;
     using DotNetty.Common.Internal;
+#if NET
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+#endif
 
     sealed partial class PooledHeapByteBuffer : PooledByteBuffer<byte[]>
     {
@@ -212,7 +216,11 @@ public sealed override byte[] Array
         public sealed override ref byte GetPinnableMemoryAddress()
         {
             EnsureAccessible();
+#if NET
+            return ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Memory), Offset);
+#else
             return ref Memory[Offset];
+#endif
         }
 
         public sealed override IntPtr AddressOfPinnedMemory() => IntPtr.Zero;
diff --git a/src/DotNetty.Buffers/UnpooledHeapByteBuffer.cs b/src/DotNetty.Buffers/UnpooledHeapByteBuffer.cs
@@ -30,6 +30,9 @@ namespace DotNetty.Buffers
     using System.Threading;
     using System.Threading.Tasks;
     using DotNetty.Common.Internal;
+#if NET
+    using System.Runtime.InteropServices;
+#endif
 
     partial class UnpooledHeapByteBuffer : AbstractReferenceCountedByteBuffer
     {
@@ -134,7 +137,11 @@ public sealed override byte[] Array
         public sealed override ref byte GetPinnableMemoryAddress()
         {
             EnsureAccessible();
+#if NET
+            return ref MemoryMarshal.GetArrayDataReference(_array);
+#else
             return ref _array[0];
+#endif
         }
 
         public sealed override IntPtr AddressOfPinnedMemory() => IntPtr.Zero;
diff --git a/src/DotNetty.Buffers/UnpooledUnsafeDirectByteBuffer.cs b/src/DotNetty.Buffers/UnpooledUnsafeDirectByteBuffer.cs
@@ -31,6 +31,9 @@ namespace DotNetty.Buffers
     using System.Threading;
     using System.Threading.Tasks;
     using DotNetty.Common.Internal;
+#if NET
+    using System.Runtime.InteropServices;
+#endif
 
     unsafe partial class UnpooledUnsafeDirectByteBuffer : AbstractReferenceCountedByteBuffer
     {
@@ -190,7 +193,11 @@ protected internal sealed override void Deallocate()
         public sealed override ref byte GetPinnableMemoryAddress()
         {
             EnsureAccessible();
+#if NET
+            return ref MemoryMarshal.GetArrayDataReference(_buffer);
+#else
             return ref _buffer[0];
+#endif
         }
 
         public sealed override bool IsContiguous => true;
@@ -393,7 +400,14 @@ public sealed override IByteBuffer Copy(int index, int length)
         }
 
         [MethodImpl(InlineMethod.AggressiveOptimization)]
-        ref byte Addr(int index) => ref _buffer[index];
+        ref byte Addr(int index)
+        {
+#if NET
+            return ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_buffer), index);
+#else
+            return ref _buffer[index];
+#endif
+        }
 
         public sealed override IByteBuffer SetZero(int index, int length)
         {
diff --git a/src/DotNetty.Common/Internal/PlatformDependent.cs b/src/DotNetty.Common/Internal/PlatformDependent.cs
@@ -12,6 +12,9 @@ namespace DotNetty.Common.Internal
     using System.Threading;
     using DotNetty.Common.Internal.Logging;
     using DotNetty.Common.Utilities;
+#if NET
+    using System.Runtime.InteropServices;
+#endif
 
     using static PlatformDependent0;
 
@@ -262,6 +265,11 @@ public static void CopyMemory(byte[] src, int srcIndex, byte[] dst, int dstIndex
                     }
                 }
             }
+#elif NET
+            Unsafe.CopyBlockUnaligned(
+                ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(dst), dstIndex), 
+                ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(src), srcIndex), 
+                nlen);
 #else
             Unsafe.CopyBlockUnaligned(ref dst[dstIndex], ref src[srcIndex], nlen);
 #endif

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,9 @@`
`24`	`24`	`using System.Buffers;`
`25`	`25`	`using DotNetty.Common;`
`26`	`26`	`using DotNetty.Common.Internal;`
	`27`	`+#if NET`
	`28`	`+using System.Runtime.InteropServices;`
	`29`	`+#endif`
`27`	`30`
`28`	`31`	`namespace DotNetty.Buffers`
`29`	`32`	`{`
`@@ -186,7 +189,11 @@ public sealed override byte[] Array`
`186`	`189`	`public sealed override ref byte GetPinnableMemoryAddress()`
`187`	`190`	`{`
`188`	`191`	`EnsureAccessible();`
	`192`	`+#if NET`
	`193`	`+ return ref MemoryMarshal.GetArrayDataReference(Memory);`
	`194`	`+#else`
`189`	`195`	`return ref Memory[0];`
	`196`	`+#endif`
`190`	`197`	`}`
`191`	`198`
`192`	`199`	`public sealed override IntPtr AddressOfPinnedMemory() => IntPtr.Zero;`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,9 @@ namespace DotNetty.Buffers`
`30`	`30`	`using System.Threading;`
`31`	`31`	`using System.Threading.Tasks;`
`32`	`32`	`using DotNetty.Common.Internal;`
	`33`	`+#if NET`
	`34`	`+ using System.Runtime.InteropServices;`
	`35`	`+#endif`
`33`	`36`
`34`	`37`	`partial class UnpooledHeapByteBuffer : AbstractReferenceCountedByteBuffer`
`35`	`38`	`{`
`@@ -134,7 +137,11 @@ public sealed override byte[] Array`
`134`	`137`	`public sealed override ref byte GetPinnableMemoryAddress()`
`135`	`138`	`{`
`136`	`139`	`EnsureAccessible();`
	`140`	`+#if NET`
	`141`	`+ return ref MemoryMarshal.GetArrayDataReference(_array);`
	`142`	`+#else`
`137`	`143`	`return ref _array[0];`
	`144`	`+#endif`
`138`	`145`	`}`
`139`	`146`
`140`	`147`	`public sealed override IntPtr AddressOfPinnedMemory() => IntPtr.Zero;`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,9 @@ namespace DotNetty.Common.Internal`
`12`	`12`	`using System.Threading;`
`13`	`13`	`using DotNetty.Common.Internal.Logging;`
`14`	`14`	`using DotNetty.Common.Utilities;`
	`15`	`+#if NET`
	`16`	`+ using System.Runtime.InteropServices;`
	`17`	`+#endif`
`15`	`18`
`16`	`19`	`using static PlatformDependent0;`
`17`	`20`
`@@ -262,6 +265,11 @@ public static void CopyMemory(byte[] src, int srcIndex, byte[] dst, int dstIndex`
`262`	`265`	`}`
`263`	`266`	`}`
`264`	`267`	`}`
	`268`	`+#elif NET`
	`269`	`+ Unsafe.CopyBlockUnaligned(`
	`270`	`+ ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(dst), dstIndex),`
	`271`	`+ ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(src), srcIndex),`
	`272`	`+ nlen);`
`265`	`273`	`#else`
`266`	`274`	`Unsafe.CopyBlockUnaligned(ref dst[dstIndex], ref src[srcIndex], nlen);`
`267`	`275`	`#endif`