Reduce GetString allocs and conversions

Author: benaadams

src/Microsoft.AspNet.Server.Kestrel/Http/Frame.cs

@@ -627,7 +627,7 @@ private bool TakeStartLine(SocketInput input)
                 {
                     return false;
                 }
-                var method = begin.GetString(scan);
+                var method = begin.GetAsciiString(scan);
 
                 scan.Take();
                 begin = scan;
@@ -651,7 +651,7 @@ private bool TakeStartLine(SocketInput input)
                     {
                         return false;
                     }
-                    queryString = begin.GetString(scan);
+                    queryString = begin.GetAsciiString(scan);
                 }
 
                 scan.Take();
@@ -660,20 +660,24 @@ private bool TakeStartLine(SocketInput input)
                 {
                     return false;
                 }
-                var httpVersion = begin.GetString(scan);
+                var httpVersion = begin.GetAsciiString(scan);
 
                 scan.Take();
                 if (scan.Take() != '\n')
                 {
                     return false;
                 }
 
+                string requestUrlPath;
                 if (needDecode)
                 {
                     pathEnd = UrlPathDecoder.Unescape(pathBegin, pathEnd);
+                    requestUrlPath = pathBegin.GetUtf8String(pathEnd);
+                }
+                else
+                {
+                    requestUrlPath = pathBegin.GetAsciiString(pathEnd);
                 }
-
-                var requestUrlPath = pathBegin.GetString(pathEnd);
 
                 consumed = scan;
                 Method = method;
@@ -785,7 +789,7 @@ public static bool TakeMessageHeaders(SocketInput input, FrameRequestHeaders req
                         }
 
                         var name = beginName.GetArraySegment(endName);
-                        var value = beginValue.GetString(endValue);
+                        var value = beginValue.GetAsciiString(endValue);
                         if (wrapping)
                         {
                             value = value.Replace("\r\n", " ");

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

@@ -488,7 +488,76 @@ public int GetLength(MemoryPoolIterator2 end)
             }
         }
 
-        public string GetString(MemoryPoolIterator2 end)
+        private static unsafe string SingleBlockAsciiString(byte[] input, int offset, 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 SingleBlockAsciiIter(output, input, offset, length);
+        }
+
+        private static unsafe string SingleBlockAsciiIter(char* output, byte[] input, int offset, 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
+            for (var i = 0; i < length; i++)
+            {
+                output[i] = (char)input[i + offset];
+            }
+            return new string(output, 0, length);
+        }
+
+        private static unsafe string MultiBlockAsciiString(MemoryPoolBlock2 block, int offset, 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 MultiBlockAsciiIter(output, block, offset, length);
+        }
+        
+        private static unsafe string MultiBlockAsciiIter(char* output, MemoryPoolBlock2 block, int offset, 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
+            while (length > 0)
+            {
+                var following = block.End - offset;
+                var input = block.Array;
+
+                for (var i = 0; i < following; i++)
+                {
+                    output[i] = (char)input[i + offset];
+                }
+
+                length -= following;
+
+                block = block.Next;
+                offset = block.Start;
+            }
+
+            return new string(output, 0, length);
+        }
+
+        public string GetAsciiString(MemoryPoolIterator2 end)
+        {
+            // 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
+            if (IsDefault || end.IsDefault)
+            {
+                return default(string);
+            }
+
+            if (end._block == _block)
+            {
+                return SingleBlockAsciiString(_block.Array, _index, end._index - _index);
+            }
+
+            return MultiBlockAsciiString(_block, _index, GetLength(end));
+        }
+
+        public string GetUtf8String(MemoryPoolIterator2 end)
         {
             if (IsDefault || end.IsDefault)
             {

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

@@ -115,7 +115,7 @@ public void DecodeWithBoundary(string raw, int rawLength, string expect, int exp
             var end = GetIterator(begin, rawLength);
 
             var end2 = UrlPathDecoder.Unescape(begin, end);
-            var result = begin.GetString(end2);
+            var result = begin.GetUtf8String(end2);
 
             Assert.Equal(expectLength, result.Length);
             Assert.Equal(expect, result);
@@ -147,7 +147,7 @@ private void PositiveAssert(string raw, string expect)
             var end = GetIterator(begin, raw.Length);
 
             var result = UrlPathDecoder.Unescape(begin, end);
-            Assert.Equal(expect, begin.GetString(result));
+            Assert.Equal(expect, begin.GetUtf8String(result));
         }
 
         private void PositiveAssert(string raw)
@@ -156,7 +156,7 @@ private void PositiveAssert(string raw)
             var end = GetIterator(begin, raw.Length);
 
             var result = UrlPathDecoder.Unescape(begin, end);
-            Assert.NotEqual(raw.Length, begin.GetString(result).Length);
+            Assert.NotEqual(raw.Length, begin.GetUtf8String(result).Length);
         }
 
         private void NegativeAssert(string raw)
@@ -165,7 +165,7 @@ private void NegativeAssert(string raw)
             var end = GetIterator(begin, raw.Length);
 
             var resultEnd = UrlPathDecoder.Unescape(begin, end);
-            var result = begin.GetString(resultEnd);
+            var result = begin.GetUtf8String(resultEnd);
             Assert.Equal(raw, result);
         }
     }