Precomputed header bytes

Author: benaadams

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

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Text;
 using System.Threading;
 using Microsoft.AspNet.Server.Kestrel.Infrastructure;
 
@@ -17,6 +18,9 @@ public class DateHeaderValueManager : IDisposable
         private readonly TimeSpan _timerInterval;
 
         private volatile string _dateValue;
+        private volatile bool _activeDateBytes;
+        private readonly byte[] _dateBytes0 = Encoding.ASCII.GetBytes("\r\nDate: DDD, dd mmm yyyy hh:mm:ss GMT");
+        private readonly byte[] _dateBytes1 = Encoding.ASCII.GetBytes("\r\nDate: DDD, dd mmm yyyy hh:mm:ss GMT");
         private object _timerLocker = new object();
         private bool _isDisposed = false;
         private bool _hadRequestsSinceLastTimerTick = false;
@@ -62,6 +66,12 @@ public virtual string GetDateHeaderValue()
             return _dateValue ?? _systemClock.UtcNow.ToString(Constants.RFC1123DateFormat);
         }
 
+        public byte[] GetDateHeaderValueBytes()
+        {
+            PumpTimer();
+            return _activeDateBytes ? _dateBytes0 : _dateBytes1;
+        }
+
         /// <summary>
         /// Releases all resources used by the current instance of <see cref="DateHeaderValueManager"/>.
         /// </summary>
@@ -92,6 +102,8 @@ private void PumpTimer()
                         // here as the timer won't fire until the timer interval has passed and we want a value assigned
                         // inline now to serve requests that occur in the meantime.
                         _dateValue = _systemClock.UtcNow.ToString(Constants.RFC1123DateFormat);
+                        Encoding.ASCII.GetBytes(_dateValue, 0, _dateValue.Length, !_activeDateBytes ? _dateBytes0 : _dateBytes1, "\r\nDate: ".Length);
+                        _activeDateBytes = !_activeDateBytes;
                         _dateValueTimer = new Timer(UpdateDateValue, state: null, dueTime: _timerInterval, period: _timerInterval);
                     }
                 }
@@ -105,6 +117,8 @@ private void UpdateDateValue(object state)
 
             // See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.18 for required format of Date header
             _dateValue = now.ToString(Constants.RFC1123DateFormat);
+            Encoding.ASCII.GetBytes(_dateValue, 0, _dateValue.Length, !_activeDateBytes ? _dateBytes0 : _dateBytes1, "\r\nDate: ".Length);
+            _activeDateBytes = !_activeDateBytes;
 
             if (_hadRequestsSinceLastTimerTick)
             {

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

@@ -29,6 +29,17 @@ public partial class Frame : FrameContext, IFrameControl
         private static readonly ArraySegment<byte> _emptyData = new ArraySegment<byte>(new byte[0]);
         private static readonly byte[] _hex = Encoding.ASCII.GetBytes("0123456789abcdef");
 
+        private static readonly byte[] _bytesConnectionClose = Encoding.ASCII.GetBytes("\r\nConnection: close");
+        private static readonly byte[] _bytesConnectionKeepAlive = Encoding.ASCII.GetBytes("\r\nConnection: keep-alive");
+        private static readonly byte[] _bytesTransferEncodingChunked = Encoding.ASCII.GetBytes("\r\nTransfer-Encoding: chunked");
+        private static readonly byte[] _bytesHttpVersion1_0 = Encoding.ASCII.GetBytes("HTTP/1.0 ");
+        private static readonly byte[] _bytesHttpVersion1_1 = Encoding.ASCII.GetBytes("HTTP/1.1 ");
+        private static readonly byte[] _bytesContentLengthZero = Encoding.ASCII.GetBytes("\r\nContent-Length: 0");
+        private static readonly byte[] _bytesSpace = Encoding.ASCII.GetBytes(" ");
+        private static readonly byte[] _bytesServer = Encoding.ASCII.GetBytes("\r\nServer: Kestrel");
+        private static readonly byte[] _bytesDate = Encoding.ASCII.GetBytes("Date: ");
+        private static readonly byte[] _bytesEndHeaders = Encoding.ASCII.GetBytes("\r\n\r\n");
+
         private readonly object _onStartingSync = new Object();
         private readonly object _onCompletedSync = new Object();
         private readonly FrameRequestHeaders _requestHeaders = new FrameRequestHeaders();
@@ -53,6 +64,8 @@ public partial class Frame : FrameContext, IFrameControl
         private bool _autoChunk;
         private Exception _applicationException;
 
+        private HttpVersionType _httpVersion;
+
         private readonly IPEndPoint _localEndPoint;
         private readonly IPEndPoint _remoteEndPoint;
         private readonly Action<IFeatureCollection> _prepareRequest;
@@ -81,7 +94,37 @@ public Frame(ConnectionContext context,
         public string RequestUri { get; set; }
         public string Path { get; set; }
         public string QueryString { get; set; }
-        public string HttpVersion { get; set; }
+        public string HttpVersion
+        {
+            get
+            {
+                if (_httpVersion == HttpVersionType.Http1_1)
+                {
+                    return "HTTP/1.1";
+                }
+                if (_httpVersion == HttpVersionType.Http1_0)
+                {
+                    return "HTTP/1.0";
+                }
+                return "";
+            }
+            set
+            {
+                if (value == "HTTP/1.1")
+                {
+                    _httpVersion = HttpVersionType.Http1_1;
+                }
+                else if (value == "HTTP/1.0")
+                {
+                    _httpVersion = HttpVersionType.Http1_0;
+                }
+                else
+                {
+                    _httpVersion = HttpVersionType.Unknown;
+                }
+            }
+        }
+
         public IHeaderDictionary RequestHeaders { get; set; }
         public Stream RequestBody { get; set; }
 
@@ -118,7 +161,7 @@ public void Reset()
             RequestUri = null;
             Path = null;
             QueryString = null;
-            HttpVersion = null;
+            _httpVersion = HttpVersionType.Unknown;
             RequestHeaders = _requestHeaders;
             RequestBody = null;
             StatusCode = 200;
@@ -151,8 +194,12 @@ public void Reset()
         public void ResetResponseHeaders()
         {
             _responseHeaders.Reset();
-            _responseHeaders.HeaderServer = "Kestrel";
-            _responseHeaders.HeaderDate = DateHeaderValueManager.GetDateHeaderValue();
+            _responseHeaders.SetRawDate(
+                DateHeaderValueManager.GetDateHeaderValue(),
+                DateHeaderValueManager.GetDateHeaderValueBytes());
+            _responseHeaders.SetRawServer(
+                "Kestrel",
+                _bytesServer);
         }
 
         /// <summary>
@@ -502,7 +549,7 @@ public void ProduceContinue()
             if (_responseStarted) return;
 
             StringValues expect;
-            if (HttpVersion.Equals("HTTP/1.1") &&
+            if (_httpVersion == HttpVersionType.Http1_1 &&
                 RequestHeaders.TryGetValue("Expect", out expect) &&
                 (expect.FirstOrDefault() ?? "").Equals("100-continue", StringComparison.OrdinalIgnoreCase))
             {
@@ -526,19 +573,14 @@ public async Task ProduceStartAndFireOnStarting(bool immediate = true)
             await ProduceStart(immediate, appCompleted: false);
         }
 
-        private async Task ProduceStart(bool immediate, bool appCompleted)
+        private Task ProduceStart(bool immediate, bool appCompleted)
         {
-            if (_responseStarted) return;
+            if (_responseStarted) return TaskUtilities.CompletedTask;
             _responseStarted = true;
 
-            var status = ReasonPhrases.ToStatus(StatusCode, ReasonPhrase);
-
-            var responseHeader = CreateResponseHeader(status, appCompleted);
+            var statusBytes = ReasonPhrases.ToStatusBytes(StatusCode, ReasonPhrase);
 
-            using (responseHeader.Item2)
-            {
-                await SocketOutput.WriteAsync(responseHeader.Item1, immediate: immediate);
-            }
+            return CreateResponseHeader(statusBytes, appCompleted, immediate);
         }
 
         private async Task ProduceEnd()
@@ -557,7 +599,7 @@ private async Task ProduceEnd()
                     ReasonPhrase = null;
 
                     ResetResponseHeaders();
-                    _responseHeaders.HeaderContentLength = "0";
+                    _responseHeaders.SetRawContentLength("0", _bytesContentLengthZero);
                 }
             }
 
@@ -576,58 +618,26 @@ private async Task ProduceEnd()
             }
         }
 
-        private Tuple<ArraySegment<byte>, IDisposable> CreateResponseHeader(
-            string status,
-            bool appCompleted)
+        private Task CreateResponseHeader(
+            byte[] statusBytes,
+            bool appCompleted,
+            bool immediate)
         {
-            var writer = new MemoryPoolTextWriter(Memory);
-            writer.Write(HttpVersion);
-            writer.Write(' ');
-            writer.Write(status);
-            writer.Write('\r');
-            writer.Write('\n');
-
-            var hasConnection = false;
-            var hasTransferEncoding = false;
-            var hasContentLength = false;
-
-            foreach (var header in _responseHeaders)
+            var memoryBlock = Memory2.Lease();
+            var begin = memoryBlock.GetIterator();
+            var end = begin;
+            if (_keepAlive)
             {
-                var isConnection = false;
-                if (!hasConnection &&
-                    string.Equals(header.Key, "Connection", StringComparison.OrdinalIgnoreCase))
-                {
-                    hasConnection = isConnection = true;
-                }
-                else if (!hasTransferEncoding &&
-                    string.Equals(header.Key, "Transfer-Encoding", StringComparison.OrdinalIgnoreCase))
+                foreach (var connectionValue in _responseHeaders.HeaderConnection)
                 {
-                    hasTransferEncoding = true;
-                }
-                else if (!hasContentLength &&
-                    string.Equals(header.Key, "Content-Length", StringComparison.OrdinalIgnoreCase))
-                {
-                    hasContentLength = true;
-                }
-
-                foreach (var value in header.Value)
-                {
-                    writer.Write(header.Key);
-                    writer.Write(':');
-                    writer.Write(' ');
-                    writer.Write(value);
-                    writer.Write('\r');
-                    writer.Write('\n');
-
-                    if (isConnection && value.IndexOf("close", StringComparison.OrdinalIgnoreCase) != -1)
+                    if (connectionValue.IndexOf("close", StringComparison.OrdinalIgnoreCase) != -1)
                     {
                         _keepAlive = false;
                     }
                 }
-
             }
 
-            if (_keepAlive && !hasTransferEncoding && !hasContentLength)
+            if (_keepAlive && !_responseHeaders.HasTransferEncoding && !_responseHeaders.HasContentLength)
             {
                 if (appCompleted)
                 {
@@ -637,15 +647,15 @@ private Tuple<ArraySegment<byte>, IDisposable> CreateResponseHeader(
                     {
                         // Since the app has completed and we are only now generating
                         // the headers we can safely set the Content-Length to 0.
-                        writer.Write("Content-Length: 0\r\n");
+                        _responseHeaders.SetRawContentLength("0", _bytesContentLengthZero);
                     }
                 }
                 else
                 {
-                    if (HttpVersion == "HTTP/1.1")
+                    if (_httpVersion == HttpVersionType.Http1_1)
                     {
                         _autoChunk = true;
-                        writer.Write("Transfer-Encoding: chunked\r\n");
+                        _responseHeaders.SetRawTransferEncoding("chunked", _bytesTransferEncodingChunked);
                     }
                     else
                     {
@@ -654,21 +664,58 @@ private Tuple<ArraySegment<byte>, IDisposable> CreateResponseHeader(
                 }
             }
 
-            if (_keepAlive == false && hasConnection == false && HttpVersion == "HTTP/1.1")
+            if (_keepAlive == false && _responseHeaders.HasConnection == false && _httpVersion == HttpVersionType.Http1_1)
             {
-                writer.Write("Connection: close\r\n\r\n");
+                _responseHeaders.SetRawConnection("close", _bytesConnectionClose);
             }
-            else if (_keepAlive && hasConnection == false && HttpVersion == "HTTP/1.0")
+            else if (_keepAlive && _responseHeaders.HasConnection == false && _httpVersion == HttpVersionType.Http1_0)
             {
-                writer.Write("Connection: keep-alive\r\n\r\n");
+                _responseHeaders.SetRawConnection("keep-alive", _bytesConnectionKeepAlive);
+            }
+
+            end.CopyFrom(_httpVersion == HttpVersionType.Http1_1 ? _bytesHttpVersion1_1 : _bytesHttpVersion1_0);
+            end.CopyFrom(statusBytes);
+            _responseHeaders.CopyTo(ref end);
+            end.CopyFrom(_bytesEndHeaders, 0, _bytesEndHeaders.Length);
+
+            // TODO: change this to SocketOutput.ProduceStart/ProduceComplete once that change is made 
+            var scan = begin.Block;
+            while (scan.Next != null)
+            {
+                if (scan.Start != scan.End)
+                {
+                    SocketOutput.WriteAsync(
+                        new ArraySegment<byte>(scan.Array, scan.Start, scan.End - scan.Start),
+                        false);
+                }
+                var next = scan.Next;
+                Memory2.Return(scan);
+                scan = next;
+            }
+            var writeTask = SocketOutput.WriteAsync(
+                new ArraySegment<byte>(scan.Array, scan.Start, scan.End - scan.Start),
+                immediate);
+
+            if (writeTask.IsCompleted)
+            {
+                Memory2.Return(scan);
+                return TaskUtilities.CompletedTask;
             }
             else
             {
-                writer.Write('\r');
-                writer.Write('\n');
+                return writeTask.ContinueWith(
+                    (t, o) =>
+                    {
+                        var mb = (MemoryPoolBlock2)o;
+                        mb.Pool.Return(mb);
+
+                        if (t.IsFaulted)
+                        {
+                            throw t.Exception;
+                        }
+                    }, 
+                    scan);
             }
-            writer.Flush();
-            return new Tuple<ArraySegment<byte>, IDisposable>(writer.Buffer, writer);
         }
 
         private bool TakeStartLine(SocketInput input)
@@ -877,5 +924,12 @@ private void ReportApplicationError(Exception ex)
             _applicationException = ex;
             Log.ApplicationError(ex);
         }
+
+        private enum HttpVersionType
+        {
+            Unknown = -1,
+            Http1_0 = 0,
+            Http1_1 = 1
+        }
     }
 }