[DESIGN] Damianedwards/date header perf

KestrelHttpServer.sln

@@ -12,6 +12,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		build.cmd = build.cmd
 		global.json = global.json
 		makefile.shade = makefile.shade
+		NuGet.Config = NuGet.Config
 	EndProjectSection
 EndProject
 Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SampleApp", "samples\SampleApp\SampleApp.xproj", "{2C3CB3DC-EEBF-4F52-9E1C-4F2F972E76C3}"

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

@@ -18,6 +18,7 @@ public ConnectionContext(ConnectionContext context) : base(context)
             SocketInput = context.SocketInput;
             SocketOutput = context.SocketOutput;
             ConnectionControl = context.ConnectionControl;
+            DateHeaderValueManager = context.DateHeaderValueManager;
         }
 
         public SocketInput SocketInput { get; set; }

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

@@ -0,0 +1,149 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Threading;
+using Microsoft.AspNet.Server.Kestrel.Infrastructure;
+
+namespace Microsoft.AspNet.Server.Kestrel.Http
+{
+    /// <summary>
+    /// Manages the generation of the date header value.
+    /// </summary>
+    public class DateHeaderValueManager : IDisposable
+    {
+        private readonly ISystemClock _systemClock;
+        private readonly TimeSpan _timeWithoutRequestsUntilIdle;
+        private readonly TimeSpan _timerInterval;
+        private readonly uint _timerTicksWithoutRequestsUntilIdle;
+
+        private volatile string _dateValue;
+        private bool _isDisposed = false;
+        private bool _hadRequestsSinceLastTimerTick = false;
+        private Timer _dateValueTimer;
+        private object _timerLocker = new object();
+        private int _timerTicksSinceLastRequest;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DateHeaderValueManager"/> class.
+        /// </summary>
+        public DateHeaderValueManager()
+            : this(
+                  systemClock: new SystemClock(),
+                  timeWithoutRequestsUntilIdle: TimeSpan.FromSeconds(10),
+                  timerInterval: TimeSpan.FromSeconds(1))
+        {
+
+        }
+
+        // Internal for testing
+        internal DateHeaderValueManager(
+            ISystemClock systemClock,
+            TimeSpan timeWithoutRequestsUntilIdle,
+            TimeSpan timerInterval)
+        {
+            _systemClock = systemClock;
+            _timeWithoutRequestsUntilIdle = timeWithoutRequestsUntilIdle;
+            _timerInterval = timerInterval;
+
+            // Calculate the number of timer ticks where no requests are seen before we're considered to be idle.
+            // Once we're idle, the timer is shutdown to prevent code from running while there are no requests.
+            // The timer is started again on the next request.
+            _timerTicksWithoutRequestsUntilIdle = (uint)(_timeWithoutRequestsUntilIdle.TotalMilliseconds / _timerInterval.TotalMilliseconds);
+        }
+
+        /// <summary>
+        /// Returns a value representing the current server date/time for use in the HTTP "Date" response header
+        /// in accordance with http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.18
+        /// </summary>
+        /// <returns>The value.</returns>
+        public string GetDateHeaderValue()
+        {
+            PumpTimer();
+
+            // See https://msdn.microsoft.com/en-us/library/az4se3k1(v=vs.110).aspx#RFC1123 for info on the format
+            // string used here.
+            // The null-coalesce here is to protect against returning null after Dispose() is called, at which
+            // point _dateValue will be null forever after.
+            return _dateValue ?? _systemClock.UtcNow.ToString("r");
+        }
+
+        /// <summary>
+        /// Releases all resources used by the current instance of <see cref="DateHeaderValueManager"/>.
+        /// </summary>
+        public void Dispose()
+        {
+            lock (_timerLocker)
+            {
+                if (_dateValueTimer != null)
+                {
+                    DisposeTimer();
+                }
+
+                _isDisposed = true;
+            }
+        }
+
+        private void PumpTimer()
+        {
+            _hadRequestsSinceLastTimerTick = true;
+
+            // If we're already disposed we don't care about starting the timer again. This avoids us having to worry
+            // about requests in flight during dispose (not that that should actually happen) as those will just get
+            // SystemClock.UtcNow (aka "the slow way").
+            if (!_isDisposed && _dateValueTimer == null)
+            {
+                lock (_timerLocker)
+                {
+                    if (!_isDisposed && _dateValueTimer == null)
+                    {
+                        // Immediately assign the date value and start the timer again. We assign the value immediately
+                        // 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("r");
+                        _dateValueTimer = new Timer(UpdateDateValue, state: null, dueTime: _timerInterval, period: _timerInterval);
+                    }
+                }
+            }
+        }
+
+        // Called by the Timer (background) thread
+        private void UpdateDateValue(object state)
+        {
+            // See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.18 for required format of Date header
+            _dateValue = _systemClock.UtcNow.ToString("r");
+
+            if (_hadRequestsSinceLastTimerTick)
+            {
+                // We served requests since the last tick, reset the flag and return as we're still active
+                _hadRequestsSinceLastTimerTick = false;
+                _timerTicksSinceLastRequest = 0;
+                return;
+            }
+
+            // No requests since the last timer tick, we need to check if we're beyond the idle threshold
+            _timerTicksSinceLastRequest++;
+            if (_timerTicksSinceLastRequest == _timerTicksWithoutRequestsUntilIdle)
+            {
+                // No requests since idle threshold so stop the timer if it's still running
+                if (_dateValueTimer != null)
+                {
+                    lock (_timerLocker)
+                    {
+                        if (_dateValueTimer != null)
+                        {
+                            DisposeTimer();
+                        }
+                    }
+                }
+            }
+        }
+
+        private void DisposeTimer()
+        {
+            _dateValueTimer.Dispose();
+            _dateValueTimer = null;
+            _dateValue = null;
+        }
+    }
+}

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

@@ -26,7 +26,7 @@ public class Frame : FrameContext, IFrameControl
         private bool _keepAlive;
         private bool _autoChunk;
         private readonly FrameRequestHeaders _requestHeaders = new FrameRequestHeaders();
-        private readonly FrameResponseHeaders _responseHeaders = new FrameResponseHeaders();
+        private readonly FrameResponseHeaders _responseHeaders;
 
         private List<KeyValuePair<Func<object, Task>, object>> _onStarting;
         private List<KeyValuePair<Func<object, Task>, object>> _onCompleted;
@@ -38,6 +38,7 @@ public Frame(ConnectionContext context) : base(context)
             FrameControl = this;
             StatusCode = 200;
             RequestHeaders = _requestHeaders;
+            _responseHeaders = new FrameResponseHeaders(DateHeaderValueManager.GetDateHeaderValue());
             ResponseHeaders = _responseHeaders;
         }
 
@@ -388,8 +389,8 @@ public void ProduceEnd(Exception ex)
                     // the app func has failed. https://github.com/aspnet/KestrelHttpServer/issues/43
                     _onStarting = null;
 
-                    ResponseHeaders = new FrameResponseHeaders();
-                    ResponseHeaders["Content-Length"] = new[] { "0" };
+                    ResponseHeaders = new FrameResponseHeaders(DateHeaderValueManager.GetDateHeaderValue());
+                    ResponseHeaders["Content-Length"] = "0";
                 }
             }
 

src/Microsoft.AspNet.Server.Kestrel/Http/FrameHeaders.Generated.cs

@@ -7,10 +7,10 @@ namespace Microsoft.AspNet.Server.Kestrel.Http
 {
     public partial class FrameResponseHeaders
     {
-        public FrameResponseHeaders()
+        public FrameResponseHeaders(string dateHeaderValue)
         {
             _Server = "Kestrel";
-            _Date = DateTime.UtcNow.ToString("r");
+            _Date = dateHeaderValue;
             _bits = 67108868L;
         }
     }

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

@@ -20,7 +20,7 @@ StringValues IDictionary<string, StringValues>.this[string key]
             get
             {
                 return GetValueFast(key);
-            }
+        }
 
             set
             {

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

@@ -15,6 +15,7 @@ public abstract class Listener : ListenerContext, IDisposable
     {
         protected Listener(ServiceContext serviceContext) : base(serviceContext)
         {
+
         }
 
         protected UvStreamHandle ListenSocket { get; private set; }
@@ -56,7 +57,7 @@ protected static void ConnectionCallback(UvStreamHandle stream, int status, Exce
             if (error != null)
             {
                 listener.Log.LogError("Listener.ConnectionCallback ", error);
-            }
+        }
             else
             {
                 listener.OnConnection(stream, status);

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

@@ -14,6 +14,7 @@ public ListenerContext() { }
         public ListenerContext(ServiceContext serviceContext)
         {
             Memory = serviceContext.Memory;
+            DateHeaderValueManager = serviceContext.DateHeaderValueManager;
             Log = serviceContext.Log;
         }
 
@@ -22,6 +23,7 @@ public ListenerContext(ListenerContext listenerContext)
             Thread = listenerContext.Thread;
             Application = listenerContext.Application;
             Memory = listenerContext.Memory;
+            DateHeaderValueManager = listenerContext.DateHeaderValueManager;
             Log = listenerContext.Log;
         }
 
@@ -31,6 +33,8 @@ public ListenerContext(ListenerContext listenerContext)
 
         public IMemoryPool Memory { get; set; }
 
+        public DateHeaderValueManager DateHeaderValueManager { get; set; }
+
         public IKestrelTrace Log { get; }
     }
 }

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

@@ -18,6 +18,7 @@ public abstract class ListenerSecondary : ListenerContext, IDisposable
     {
         protected ListenerSecondary(ServiceContext serviceContext) : base(serviceContext)
         {
+
         }
 
         UvPipeHandle DispatchPipe { get; set; }

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

@@ -0,0 +1,18 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNet.Server.Kestrel.Infrastructure
+{
+    /// <summary>
+    /// Abstracts the system clock to facilitate testing.
+    /// </summary>
+    public interface ISystemClock
+    {
+        /// <summary>
+        /// Retrieves the current system time in UTC.
+        /// </summary>
+        DateTimeOffset UtcNow { get; }
+    }
+}

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

@@ -0,0 +1,24 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNet.Server.Kestrel.Infrastructure
+{
+    /// <summary>
+    /// Provides access to the normal system clock.
+    /// </summary>
+    public class SystemClock : ISystemClock
+    {
+        /// <summary>
+        /// Retrieves the current system time in UTC.
+        /// </summary>
+        public DateTimeOffset UtcNow
+        {
+            get
+            {
+                return DateTimeOffset.UtcNow;
+            }
+        }
+    }
+}

src/Microsoft.AspNet.Server.Kestrel/KestrelEngine.cs

@@ -75,13 +75,15 @@ private KestrelEngine(IApplicationShutdown appShutdownService, ILogger logger)
             {
                 AppShutdown = appShutdownService,
                 Memory = new MemoryPool(),
+                DateHeaderValueManager = new DateHeaderValueManager(),
                 Log = new KestrelTrace(logger)
             };
 
             Threads = new List<KestrelThread>();
         }
 
         public Libuv Libuv { get; private set; }
+
         public List<KestrelThread> Threads { get; private set; }
 
         public void Start(int count)
@@ -104,6 +106,8 @@ public void Dispose()
                 thread.Stop(TimeSpan.FromSeconds(2.5));
             }
             Threads.Clear();
+
+            _serviceContext.DateHeaderValueManager.Dispose();
         }
 
         public IDisposable CreateServer(string scheme, string host, int port, Func<Frame, Task> application)

src/Microsoft.AspNet.Server.Kestrel/ServiceContext.cs

@@ -13,6 +13,8 @@ public class ServiceContext
 
         public IMemoryPool Memory { get; set; }
 
+        public DateHeaderValueManager DateHeaderValueManager { get; set; }
+
         public IKestrelTrace Log { get; set; }
     }
 }

src/Microsoft.AspNet.Server.Kestrel/project.json

@@ -32,7 +32,8 @@
         "System.Threading": "4.0.11-beta-*",
         "System.Threading.Tasks": "4.0.11-beta-*",
         "System.Threading.Thread": "4.0.0-beta-*",
-        "System.Threading.ThreadPool": "4.0.10-beta-*"
+        "System.Threading.ThreadPool": "4.0.10-beta-*",
+        "System.Threading.Timer": "4.0.0"
       }
     }
   },