Loop unrolled direct string inject

Author: benaadams

src/Microsoft.AspNet.Server.Kestrel/Infrastructure/MemoryPoolIterator2Extensions.cs

@@ -9,8 +9,6 @@ namespace Microsoft.AspNet.Server.Kestrel.Infrastructure
 {
     public static class MemoryPoolIterator2Extensions
     {
-        private const int _maxStackAllocBytes = 16384;
-
         private static Encoding _utf8 = Encoding.UTF8;
 
         public const string HttpConnectMethod = "CONNECT";
@@ -69,77 +67,58 @@ private unsafe static long GetAsciiStringAsLong(string str)
             }
         }
 
-        private static unsafe string GetAsciiStringStack(byte[] input, int inputOffset, int length)
+        private unsafe static string GetAsciiString(MemoryPoolBlock2 start, MemoryPoolIterator2 end, int inputOffset, int length)
         {
-            // avoid declaring other local vars, or doing work with stackalloc
-            // to prevent the .locals init cil flag , see: https://github.com/dotnet/coreclr/issues/1279
-            char* output = stackalloc char[length];
-
-            return GetAsciiStringImplementation(output, input, inputOffset, length);
-        }
+            var asciiString = new string('\0', length);
 
-        private static unsafe string GetAsciiStringImplementation(char* output, byte[] input, int inputOffset, int length)
-        {
-            for (var i = 0; i < length; i++)
+            fixed (char* outputStart = asciiString)
             {
-                output[i] = (char)input[inputOffset + i];
-            }
-
-            return new string(output, 0, length);
-        }
-
-        private static unsafe string GetAsciiStringStack(MemoryPoolBlock2 start, MemoryPoolIterator2 end, int inputOffset, int length)
-        {
-            // avoid declaring other local vars, or doing work with stackalloc
-            // to prevent the .locals init cil flag , see: https://github.com/dotnet/coreclr/issues/1279
-            char* output = stackalloc char[length];
-
-            return GetAsciiStringImplementation(output, start, end, inputOffset, length);
-        }
-
-        private unsafe static string GetAsciiStringHeap(MemoryPoolBlock2 start, MemoryPoolIterator2 end, int inputOffset, int length)
-        {
-            var buffer = new char[length];
-
-            fixed (char* output = buffer)
-            {
-                return GetAsciiStringImplementation(output, start, end, inputOffset, length);
-            }
-        }
-
-        private static unsafe string GetAsciiStringImplementation(char* output, MemoryPoolBlock2 start, MemoryPoolIterator2 end, int inputOffset, int length)
-        {
-            var outputOffset = 0;
-            var block = start;
-            var remaining = length;
-
-            var endBlock = end.Block;
-            var endIndex = end.Index;
+                var output = outputStart;
+                var block = start;
+                var remaining = length;
 
-            while (true)
-            {
-                int following = (block != endBlock ? block.End : endIndex) - inputOffset;
+                var endBlock = end.Block;
+                var endIndex = end.Index;
 
-                if (following > 0)
+                while (true)
                 {
-                    var input = block.Array;
-                    for (var i = 0; i < following; i++)
+                    int following = (block != endBlock ? block.End : endIndex) - inputOffset;
+
+                    if (following > 0)
                     {
-                        output[i + outputOffset] = (char)input[i + inputOffset];
+                        fixed (byte* blockStart = block.Array)
+                        {
+                            var input = blockStart + inputOffset;
+                            var i = 0;
+                            var followingMinusSpan = following - 3;
+                            for (; i < followingMinusSpan; i += 4)
+                            {
+                                *(output) = (char)*(input);
+                                *(output + 1) = (char)*(input + 1);
+                                *(output + 2) = (char)*(input + 2);
+                                *(output + 3) = (char)*(input + 3);
+                                output += 4;
+                                input += 4;
+                            }
+                            for (; i < following; i++)
+                            {
+                                *(output++) = (char)*(input++);
+                            }
+                        }
+                        remaining -= following;
                     }
 
-                    remaining -= following;
-                    outputOffset += following;
-                }
+                    if (remaining == 0)
+                    {
+                        break;
+                    }
 
-                if (remaining == 0)
-                {
-                    return new string(output, 0, length);
+                    block = block.Next;
+                    inputOffset = block.Start;
                 }
-
-                block = block.Next;
-                inputOffset = block.Start;
             }
+
+            return asciiString;
         }
 
         public static string GetAsciiString(this MemoryPoolIterator2 start, MemoryPoolIterator2 end)
@@ -151,20 +130,16 @@ public static string GetAsciiString(this MemoryPoolIterator2 start, MemoryPoolIt
 
             var length = start.GetLength(end);
 
-            // Bytes out of the range of ascii are treated as "opaque data" 
-            // and kept in string as a char value that casts to same input byte value
-            // https://tools.ietf.org/html/rfc7230#section-3.2.4
-            if (end.Block == start.Block)
+            if (length == 0)
             {
-                return GetAsciiStringStack(start.Block.Array, start.Index, length);
+                return default(string);
             }
 
-            if (length > _maxStackAllocBytes)
-            {
-                return GetAsciiStringHeap(start.Block, end, start.Index, length);
-            }
+            // Bytes out of the range of ascii are treated as "opaque data" 
+            // and kept in string as a char value that casts to same input byte value
+            // https://tools.ietf.org/html/rfc7230#section-3.2.4
 
-            return GetAsciiStringStack(start.Block, end, start.Index, length);
+            return GetAsciiString(start.Block, end, start.Index, length);
         }
 
         public static string GetUtf8String(this MemoryPoolIterator2 start, MemoryPoolIterator2 end)

test/Microsoft.AspNet.Server.KestrelTests/AsciiDecoder.cs

@@ -13,7 +13,7 @@ public class AsciiDecoderTests
         [Fact]
         private void FullByteRangeSupported()
         {
-            var byteRange = Enumerable.Range(0, 255).Select(x => (byte)x).ToArray();
+            var byteRange = Enumerable.Range(0, 256).Select(x => (byte)x).ToArray();
 
             var mem = MemoryPoolBlock2.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null);
             mem.End = byteRange.Length;
@@ -74,7 +74,7 @@ private void MultiBlockProducesCorrectResults()
         }
 
         [Fact]
-        private void HeapAllocationProducesCorrectResults()
+        private void LargeAllocationProducesCorrectResults()
         {
             var byteRange = Enumerable.Range(0, 16384 + 64).Select(x => (byte)x).ToArray();
             var expectedByteRange = byteRange.Concat(byteRange).ToArray();