Split pool and reader/writer into separate packages

pakrym · pakrym · commit c0a99b8506ca · 2018-04-24T12:15:47.000-07:00
diff --git a/NuGetPackageVerifier.json b/NuGetPackageVerifier.json
@@ -5,6 +5,7 @@
       "Microsoft.AspNetCore.Analyzer.Testing": {},
       "Microsoft.AspNetCore.BenchmarkRunner.Sources": {},
       "Microsoft.Extensions.Buffers.Sources": {},
+      "Microsoft.Extensions.Buffers.MemoryPool.Sources": {},
       "Microsoft.Extensions.Buffers.Testing.Sources": {},
       "Microsoft.AspNetCore.Certificates.Generation.Sources": {},
       "Microsoft.Extensions.ClosedGenericMatcher.Sources": {},
diff --git a/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolBlock.Debug.cs b/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolBlock.Debug.cs
@@ -45,7 +45,7 @@ public override Memory<byte> Memory
         {
             get
             {
-                if (!Slab.IsActive) ThrowHelper.ThrowObjectDisposedException(ExceptionArgument.MemoryPoolBlock);
+                if (!Slab.IsActive) MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);
 
                 return CreateMemory(_length);
             }
@@ -74,11 +74,11 @@ public override Memory<byte> Memory
 
         protected override void Dispose(bool disposing)
         {
-            if (!Slab.IsActive) ThrowHelper.ThrowObjectDisposedException(ExceptionArgument.MemoryPoolBlock);
+            if (!Slab.IsActive) MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);
 
             if (Volatile.Read(ref _pinCount) > 0)
             {
-                ThrowHelper.ThrowInvalidOperationException_ReturningPinnedBlock();
+                MemoryPoolThrowHelper.ThrowInvalidOperationException_ReturningPinnedBlock();
             }
 
             Pool.Return(this);
@@ -88,8 +88,8 @@ protected override void Dispose(bool disposing)
 
         public override MemoryHandle Pin(int byteOffset = 0)
         {
-            if (!Slab.IsActive) ThrowHelper.ThrowObjectDisposedException(ExceptionArgument.MemoryPoolBlock);
-            if (byteOffset < 0 || byteOffset > _length) ThrowHelper.ThrowArgumentOutOfRangeException(_length, byteOffset);
+            if (!Slab.IsActive) MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);
+            if (byteOffset < 0 || byteOffset > _length) MemoryPoolThrowHelper.ThrowArgumentOutOfRangeException(_length, byteOffset);
 
             Interlocked.Increment(ref _pinCount);
             unsafe
@@ -108,7 +108,7 @@ public override void Unpin()
         {
             if (Interlocked.Decrement(ref _pinCount) < 0)
             {
-                ThrowHelper.ThrowInvalidOperationException_ReferenceCountZero();
+                MemoryPoolThrowHelper.ThrowInvalidOperationException_ReferenceCountZero();
             }
         }
 
diff --git a/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolBlock.Release.cs b/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolBlock.Release.cs
diff --git a/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolSlab.cs b/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolSlab.cs
diff --git a/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolThrowHelper.cs b/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolThrowHelper.cs
@@ -6,7 +6,7 @@
 
 namespace System.Buffers
 {
-    internal class ThrowHelper
+    internal class MemoryPoolThrowHelper
     {
         public static void ThrowArgumentOutOfRangeException(int sourceLength, int offset)
         {
@@ -30,7 +30,7 @@ public static void ThrowArgumentOutOfRangeException(ExceptionArgument argument)
         {
             throw GetArgumentOutOfRangeException(argument);
         }
-        
+
         public static void ThrowInvalidOperationException_ReferenceCountZero()
         {
             throw new InvalidOperationException("Can't release when reference count is already zero");
@@ -75,13 +75,13 @@ private static string GetArgumentName(ExceptionArgument argument)
 
             return argument.ToString();
         }
-    }
 
-    internal enum ExceptionArgument
-    {
-        size,
-        offset,
-        length,
-        MemoryPoolBlock
+        internal enum ExceptionArgument
+        {
+            size,
+            offset,
+            length,
+            MemoryPoolBlock
+        }
     }
 }
diff --git a/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/SlabMemoryPool.cs b/shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/SlabMemoryPool.cs
@@ -61,7 +61,7 @@ public override IMemoryOwner<byte> Rent(int size = AnySize)
             if (size == AnySize) size = _blockSize;
             else if (size > _blockSize)
             {
-                ThrowHelper.ThrowArgumentOutOfRangeException_BufferRequestTooLarge(_blockSize);
+                MemoryPoolThrowHelper.ThrowArgumentOutOfRangeException_BufferRequestTooLarge(_blockSize);
             }
 
             var block = Lease();
diff --git a/shared/Microsoft.Extensions.Buffers.Sources/BufferReader.cs b/shared/Microsoft.Extensions.Buffers.Sources/BufferReader.cs
@@ -94,7 +94,7 @@ public void Advance(int byteCount)
         {
             if (byteCount < 0)
             {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
+                BuffersThrowHelper.ThrowArgumentOutOfRangeException(BuffersThrowHelper.ExceptionArgument.length);
             }
 
             _consumedBytes += byteCount;
@@ -118,7 +118,7 @@ public void Advance(int byteCount)
 
             if (byteCount > 0)
             {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
+                BuffersThrowHelper.ThrowArgumentOutOfRangeException(BuffersThrowHelper.ExceptionArgument.length);
             }
         }
     }
diff --git a/shared/Microsoft.Extensions.Buffers.Sources/BuffersThrowHelper.cs b/shared/Microsoft.Extensions.Buffers.Sources/BuffersThrowHelper.cs
@@ -0,0 +1,34 @@
+﻿// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace System.Buffers
+{
+    internal class BuffersThrowHelper
+    {
+        public static void ThrowArgumentOutOfRangeException(ExceptionArgument argument)
+        {
+            throw GetArgumentOutOfRangeException(argument);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument)
+        {
+            return new ArgumentOutOfRangeException(GetArgumentName(argument));
+        }
+
+        private static string GetArgumentName(ExceptionArgument argument)
+        {
+            Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");
+
+            return argument.ToString();
+        }
+
+        internal enum ExceptionArgument
+        {
+            length,
+        }
+    }
+}
diff --git a/test/Microsoft.Extensions.Internal.Test/Microsoft.Extensions.Internal.Test.csproj b/test/Microsoft.Extensions.Internal.Test/Microsoft.Extensions.Internal.Test.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFrameworks>$(StandardTestTfms)</TargetFrameworks>
@@ -10,6 +10,7 @@
     <Compile Include="..\..\shared\Microsoft.AspNetCore.Certificates.Generation.Sources\**\*.cs" />
     <Compile Include="..\..\shared\Microsoft.Extensions.ActivatorUtilities.Sources\**\*.cs" />
     <Compile Include="..\..\shared\Microsoft.Extensions.Buffers.Sources\**\*.cs" />
+    <Compile Include="..\..\shared\Microsoft.Extensions.Buffers.MemoryPool.Sources\**\*.cs" />
     <Compile Include="..\..\shared\Microsoft.Extensions.Buffers.Testing.Sources\**\*.cs" />
     <Compile Include="..\..\shared\Microsoft.Extensions.ClosedGenericMatcher.Sources\**\*.cs" />
     <Compile Include="..\..\shared\Microsoft.Extensions.CopyOnWriteDictionary.Sources\**\*.cs" />

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public override Memory<byte> Memory`
`45`	`45`	`{`
`46`	`46`	`get`
`47`	`47`	`{`
`48`		`- if (!Slab.IsActive) ThrowHelper.ThrowObjectDisposedException(ExceptionArgument.MemoryPoolBlock);`
	`48`	`+ if (!Slab.IsActive) MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);`
`49`	`49`
`50`	`50`	`return CreateMemory(_length);`
`51`	`51`	`}`
`@@ -74,11 +74,11 @@ public override Memory<byte> Memory`
`74`	`74`
`75`	`75`	`protected override void Dispose(bool disposing)`
`76`	`76`	`{`
`77`		`- if (!Slab.IsActive) ThrowHelper.ThrowObjectDisposedException(ExceptionArgument.MemoryPoolBlock);`
	`77`	`+ if (!Slab.IsActive) MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);`
`78`	`78`
`79`	`79`	`if (Volatile.Read(ref _pinCount) > 0)`
`80`	`80`	`{`
`81`		`- ThrowHelper.ThrowInvalidOperationException_ReturningPinnedBlock();`
	`81`	`+ MemoryPoolThrowHelper.ThrowInvalidOperationException_ReturningPinnedBlock();`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`Pool.Return(this);`
`@@ -88,8 +88,8 @@ protected override void Dispose(bool disposing)`
`88`	`88`
`89`	`89`	`public override MemoryHandle Pin(int byteOffset = 0)`
`90`	`90`	`{`
`91`		`- if (!Slab.IsActive) ThrowHelper.ThrowObjectDisposedException(ExceptionArgument.MemoryPoolBlock);`
`92`		`- if (byteOffset < 0 \|\| byteOffset > _length) ThrowHelper.ThrowArgumentOutOfRangeException(_length, byteOffset);`
	`91`	`+ if (!Slab.IsActive) MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);`
	`92`	`+ if (byteOffset < 0 \|\| byteOffset > _length) MemoryPoolThrowHelper.ThrowArgumentOutOfRangeException(_length, byteOffset);`
`93`	`93`
`94`	`94`	`Interlocked.Increment(ref _pinCount);`
`95`	`95`	`unsafe`
`@@ -108,7 +108,7 @@ public override void Unpin()`
`108`	`108`	`{`
`109`	`109`	`if (Interlocked.Decrement(ref _pinCount) < 0)`
`110`	`110`	`{`
`111`		`- ThrowHelper.ThrowInvalidOperationException_ReferenceCountZero();`
	`111`	`+ MemoryPoolThrowHelper.ThrowInvalidOperationException_ReferenceCountZero();`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`namespace System.Buffers`
`8`	`8`	`{`
`9`		`- internal class ThrowHelper`
	`9`	`+ internal class MemoryPoolThrowHelper`
`10`	`10`	`{`
`11`	`11`	`public static void ThrowArgumentOutOfRangeException(int sourceLength, int offset)`
`12`	`12`	`{`
`@@ -30,7 +30,7 @@ public static void ThrowArgumentOutOfRangeException(ExceptionArgument argument)`
`30`	`30`	`{`
`31`	`31`	`throw GetArgumentOutOfRangeException(argument);`
`32`	`32`	`}`
`33`		`-`
	`33`	`+`
`34`	`34`	`public static void ThrowInvalidOperationException_ReferenceCountZero()`
`35`	`35`	`{`
`36`	`36`	`throw new InvalidOperationException("Can't release when reference count is already zero");`
`@@ -75,13 +75,13 @@ private static string GetArgumentName(ExceptionArgument argument)`
`75`	`75`
`76`	`76`	`return argument.ToString();`
`77`	`77`	`}`
`78`		`- }`
`79`	`78`
`80`		`- internal enum ExceptionArgument`
`81`		`- {`
`82`		`- size,`
`83`		`- offset,`
`84`		`- length,`
`85`		`- MemoryPoolBlock`
	`79`	`+ internal enum ExceptionArgument`
	`80`	`+ {`
	`81`	`+ size,`
	`82`	`+ offset,`
	`83`	`+ length,`
	`84`	`+ MemoryPoolBlock`
	`85`	`+ }`
`86`	`86`	`}`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ public override IMemoryOwner<byte> Rent(int size = AnySize)`
`61`	`61`	`if (size == AnySize) size = _blockSize;`
`62`	`62`	`else if (size > _blockSize)`
`63`	`63`	`{`
`64`		`- ThrowHelper.ThrowArgumentOutOfRangeException_BufferRequestTooLarge(_blockSize);`
	`64`	`+ MemoryPoolThrowHelper.ThrowArgumentOutOfRangeException_BufferRequestTooLarge(_blockSize);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`var block = Lease();`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ public void Advance(int byteCount)`
`94`	`94`	`{`
`95`	`95`	`if (byteCount < 0)`
`96`	`96`	`{`
`97`		`- ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);`
	`97`	`+ BuffersThrowHelper.ThrowArgumentOutOfRangeException(BuffersThrowHelper.ExceptionArgument.length);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`_consumedBytes += byteCount;`
`@@ -118,7 +118,7 @@ public void Advance(int byteCount)`
`118`	`118`
`119`	`119`	`if (byteCount > 0)`
`120`	`120`	`{`
`121`		`- ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);`
	`121`	`+ BuffersThrowHelper.ThrowArgumentOutOfRangeException(BuffersThrowHelper.ExceptionArgument.length);`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`	`}`