Faster CopyFromAscii

Author: benaadams

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

@@ -636,68 +636,119 @@ public unsafe void CopyFrom(byte[] data, int offset, int count)
 
         public unsafe void CopyFromAscii(string data)
         {
-            Debug.Assert(_block != null);
-            Debug.Assert(_block.Pool != null);
-            Debug.Assert(_block.Next == null);
-            Debug.Assert(_block.End == _index);
-
-            var pool = _block.Pool;
             var block = _block;
             var blockIndex = _index;
-            var length = data.Length;
+            var count = data.Length;
 
-            var bytesLeftInBlock = block.BlockEndOffset - blockIndex;
-            var bytesLeftInBlockMinusSpan = bytesLeftInBlock - 3;
+            var blockRemaining = block.BlockEndOffset - blockIndex;
 
             fixed (char* pData = data)
             {
-                var input = pData;
-                var inputEnd = pData + length;
-                var inputEndMinusSpan = inputEnd - 3;
+                if (blockRemaining >= count)
+                {
+                    _index = blockIndex + count;
+
+                    fixed (byte* output = block.Array)
+                    {
+                        CopyFromAscii(pData, output + blockIndex, count);
+                    }
 
-                while (input < inputEnd)
+                    block.End = _index;
+                    return;
+                }
+
+                var input = pData;
+                do
                 {
-                    if (bytesLeftInBlock == 0)
+                    if (blockRemaining == 0)
                     {
-                        var nextBlock = pool.Lease();
-                        block.End = blockIndex;
+                        var nextBlock = block.Pool.Lease();
+                        blockIndex = nextBlock.Data.Offset;
+                        blockRemaining = nextBlock.Data.Count;
                         block.Next = nextBlock;
                         block = nextBlock;
-
-                        blockIndex = block.Data.Offset;
-                        bytesLeftInBlock = block.Data.Count;
-                        bytesLeftInBlockMinusSpan = bytesLeftInBlock - 3;
                     }
 
-                    fixed (byte* pOutput = block.Data.Array)
+                    if (count > blockRemaining)
                     {
-                        var output = pOutput + block.End;
+                        count -= blockRemaining;
 
-                        var copied = 0;
-                        for (; input < inputEndMinusSpan && copied < bytesLeftInBlockMinusSpan; copied += 4)
+                        fixed (byte* output = block.Array)
                         {
-                            *(output) = (byte)*(input);
-                            *(output + 1) = (byte)*(input + 1);
-                            *(output + 2) = (byte)*(input + 2);
-                            *(output + 3) = (byte)*(input + 3);
-                            output += 4;
-                            input += 4;
+                            CopyFromAscii(input, output + blockIndex, blockRemaining);
                         }
-                        for (; input < inputEnd && copied < bytesLeftInBlock; copied++)
+
+                        block.End = blockIndex + blockRemaining;
+                        input += blockRemaining;
+                        blockRemaining = 0;
+                        continue;
+                    }
+                    else
+                    {
+                        _index = blockIndex + count;
+
+                        fixed (byte* output = block.Array)
                         {
-                            *(output++) = (byte)*(input++);
+                            CopyFromAscii(input, output + blockIndex, count);
                         }
 
-                        blockIndex += copied;
-                        bytesLeftInBlockMinusSpan -= copied;
-                        bytesLeftInBlock -= copied;
+                        block.End = _index;
+                        _block = block;
+                        return;
                     }
-                }
+                } while (true);
             }
+        }
 
-            block.End = blockIndex;
-            _block = block;
-            _index = blockIndex;
+        private unsafe static void CopyFromAscii(char* input, byte* output, int count)
+        {
+            var i = 0;
+
+            while (i + 11 < count)
+            {
+                i += 12;
+                *(output) = (byte)*(input);
+                *(output + 1) = (byte)*(input + 1);
+                *(output + 2) = (byte)*(input + 2);
+                *(output + 3) = (byte)*(input + 3);
+                *(output + 4) = (byte)*(input + 4);
+                *(output + 5) = (byte)*(input + 5);
+                *(output + 6) = (byte)*(input + 6);
+                *(output + 7) = (byte)*(input + 7);
+                *(output + 8) = (byte)*(input + 8);
+                *(output + 9) = (byte)*(input + 9);
+                *(output + 10) = (byte)*(input + 10);
+                *(output + 11) = (byte)*(input + 11);
+                output += 12;
+                input += 12;
+            }
+            if (i + 6 < count)
+            {
+                i += 6;
+                *(output) = (byte)*(input);
+                *(output + 1) = (byte)*(input + 1);
+                *(output + 2) = (byte)*(input + 2);
+                *(output + 3) = (byte)*(input + 3);
+                *(output + 4) = (byte)*(input + 4);
+                *(output + 5) = (byte)*(input + 5);
+                output += 6;
+                input += 6;
+            }
+            if (i + 3 < count)
+            {
+                i += 4;
+                *(output) = (byte)*(input);
+                *(output + 1) = (byte)*(input + 1);
+                *(output + 2) = (byte)*(input + 2);
+                *(output + 3) = (byte)*(input + 3);
+                output += 4;
+                input += 4;
+            }
+            while (i < count)
+            {
+                i++;
+                *(output++) = (byte)*(input++);
+            }
         }
     }
 }