Convert TimeoutControl to timestamps

Author: Tratcher

src/Servers/Kestrel/Core/src/Internal/Http2/Http2Connection.cs

@@ -1270,7 +1270,7 @@ private void UpdateCompletedStreams()
             if (stream.DrainExpirationTicks == default)
             {
                 _serverActiveStreamCount--;
-                stream.DrainExpirationTicks = now + (long)(Constants.RequestBodyDrainTimeout.TotalSeconds * TimeProvider.TimestampFrequency);
+                stream.DrainExpirationTicks = now + Constants.RequestBodyDrainTimeout.ToTicks(TimeProvider.TimestampFrequency);
             }
 
             if (stream.EndStreamReceived || stream.RstStreamReceived || stream.DrainExpirationTicks < now)

src/Servers/Kestrel/Core/src/Internal/Http2/Http2KeepAlive.cs

@@ -29,9 +29,9 @@ internal sealed class Http2KeepAlive
 
     public Http2KeepAlive(TimeSpan keepAliveInterval, TimeSpan keepAliveTimeout, TimeProvider timeProvider)
     {
-        _keepAliveInterval = (long)(keepAliveInterval.TotalSeconds * timeProvider.TimestampFrequency);
+        _keepAliveInterval = keepAliveInterval.ToTicks(timeProvider.TimestampFrequency);
         _keepAliveTimeout = keepAliveTimeout == TimeSpan.MaxValue ? long.MaxValue
-            : (long)(keepAliveTimeout.TotalSeconds * timeProvider.TimestampFrequency);
+            : keepAliveTimeout.ToTicks(timeProvider.TimestampFrequency);
         _timeProvider = timeProvider;
     }
 

src/Servers/Kestrel/Core/src/Internal/HttpConnection.cs

@@ -36,7 +36,7 @@ public HttpConnection(BaseHttpConnectionContext context)
         _context = context;
         _timeProvider = _context.ServiceContext.TimeProvider;
 
-        _timeoutControl = new TimeoutControl(this);
+        _timeoutControl = new TimeoutControl(this, _timeProvider.TimestampFrequency);
 
         // Tests override the timeout control sometimes
         _context.TimeoutControl ??= _timeoutControl;
@@ -49,7 +49,7 @@ public async Task ProcessRequestsAsync<TContext>(IHttpApplication<TContext> http
         try
         {
             // Ensure TimeoutControl._lastTimestamp is initialized before anything that could set timeouts runs.
-            _timeoutControl.Initialize(_timeProvider.GetUtcNow().Ticks);
+            _timeoutControl.Initialize(_timeProvider.GetTimestamp());
 
             IRequestProcessor? requestProcessor = null;
 
@@ -236,9 +236,9 @@ private void Tick()
             return;
         }
 
-        // It's safe to use UtcNowUnsynchronized since Tick is called by the Heartbeat.
         var now = _timeProvider.GetUtcNow();
-        _timeoutControl.Tick(now);
+        var ticks = _timeProvider.GetTimestamp();
+        _timeoutControl.Tick(ticks);
         _requestProcessor!.Tick(now);
     }
 

src/Servers/Kestrel/Core/src/Internal/Infrastructure/ITimeoutControl.cs

@@ -14,7 +14,7 @@ internal interface ITimeoutControl
     void CancelTimeout();
 
     void InitializeHttp2(InputFlowControl connectionInputFlowControl);
-    void Tick(DateTimeOffset now);
+    void Tick(long now);
 
     void StartRequestBody(MinDataRate minRate);
     void StopRequestBody();

src/Servers/Kestrel/Core/src/Internal/Infrastructure/TimeSpanExtensions.cs

@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System;
+
+internal static class TimeSpanExtensions
+{
+    public static long ToTicks(this TimeSpan timeSpan, long tickFrequency)
+    {
+        return (long)(timeSpan.TotalSeconds * tickFrequency);
+    }
+}

src/Servers/Kestrel/Core/src/Internal/Infrastructure/TimeoutControl.cs

@@ -11,11 +11,14 @@ internal sealed class TimeoutControl : ITimeoutControl, IConnectionTimeoutFeatur
 {
     private readonly ITimeoutHandler _timeoutHandler;
 
+    private readonly long _heartbeatIntervalTicks;
+    private readonly long _tickFrequency;
     private long _lastTimestamp;
     private long _timeoutTimestamp = long.MaxValue;
 
     private readonly object _readTimingLock = new object();
     private MinDataRate? _minReadRate;
+    private long _minReadRateGracePeriodTicks;
     private bool _readTimingEnabled;
     private bool _readTimingPauseRequested;
     private long _readTimingElapsedTicks;
@@ -29,9 +32,11 @@ internal sealed class TimeoutControl : ITimeoutControl, IConnectionTimeoutFeatur
     private int _concurrentAwaitingWrites;
     private long _writeTimingTimeoutTimestamp;
 
-    public TimeoutControl(ITimeoutHandler timeoutHandler)
+    public TimeoutControl(ITimeoutHandler timeoutHandler, long tickFrequency)
     {
         _timeoutHandler = timeoutHandler;
+        _tickFrequency = tickFrequency;
+        _heartbeatIntervalTicks = Heartbeat.Interval.ToTicks(_tickFrequency);
     }
 
     public TimeoutReason TimerReason { get; private set; }
@@ -43,9 +48,9 @@ internal void Initialize(long nowTicks)
         _lastTimestamp = nowTicks;
     }
 
-    public void Tick(DateTimeOffset now)
+    public void Tick(long now)
     {
-        var timestamp = now.Ticks;
+        var timestamp = now;
 
         CheckForTimeout(timestamp);
         CheckForReadDataRateTimeout(timestamp);
@@ -108,13 +113,13 @@ private void CheckForReadDataRateTimeout(long timestamp)
 
             // Assume overly long tick intervals are the result of server resource starvation.
             // Don't count extra time between ticks against the rate limit.
-            _readTimingElapsedTicks += Math.Min(timestamp - _lastTimestamp, Heartbeat.Interval.Ticks);
+            _readTimingElapsedTicks += Math.Min(timestamp - _lastTimestamp, _heartbeatIntervalTicks);
 
             Debug.Assert(_minReadRate != null);
 
-            if (_minReadRate.BytesPerSecond > 0 && _readTimingElapsedTicks > _minReadRate.GracePeriod.Ticks)
+            if (_minReadRate.BytesPerSecond > 0 && _readTimingElapsedTicks > _minReadRateGracePeriodTicks)
             {
-                var elapsedSeconds = (double)_readTimingElapsedTicks / TimeSpan.TicksPerSecond;
+                var elapsedSeconds = (double)_readTimingElapsedTicks / _tickFrequency;
                 var rate = _readTimingBytesRead / elapsedSeconds;
 
                 timeout = rate < _minReadRate.BytesPerSecond && !Debugger.IsAttached;
@@ -145,7 +150,7 @@ private void CheckForWriteDataRateTimeout(long timestamp)
         {
             // Assume overly long tick intervals are the result of server resource starvation.
             // Don't count extra time between ticks against the rate limit.
-            var extraTimeForTick = timestamp - _lastTimestamp - Heartbeat.Interval.Ticks;
+            var extraTimeForTick = timestamp - _lastTimestamp - _heartbeatIntervalTicks;
 
             if (extraTimeForTick > 0)
             {
@@ -186,7 +191,7 @@ private void AssignTimeout(long ticks, TimeoutReason timeoutReason)
         TimerReason = timeoutReason;
 
         // Add Heartbeat.Interval since this can be called right before the next heartbeat.
-        Interlocked.Exchange(ref _timeoutTimestamp, Interlocked.Read(ref _lastTimestamp) + ticks + Heartbeat.Interval.Ticks);
+        Interlocked.Exchange(ref _timeoutTimestamp, Interlocked.Read(ref _lastTimestamp) + ticks + _heartbeatIntervalTicks);
     }
 
     public void InitializeHttp2(InputFlowControl connectionInputFlowControl)
@@ -202,6 +207,7 @@ public void StartRequestBody(MinDataRate minRate)
             Debug.Assert(_concurrentIncompleteRequestBodies == 0 || minRate == _minReadRate, "Multiple simultaneous read data rates are not supported.");
 
             _minReadRate = minRate;
+            _minReadRateGracePeriodTicks = minRate.GracePeriod.ToTicks(_tickFrequency);
             _concurrentIncompleteRequestBodies++;
 
             if (_concurrentIncompleteRequestBodies == 1)
@@ -282,14 +288,14 @@ public void BytesWrittenToBuffer(MinDataRate minRate, long count)
         lock (_writeTimingLock)
         {
             // Add Heartbeat.Interval since this can be called right before the next heartbeat.
-            var currentTimeUpperBound = Interlocked.Read(ref _lastTimestamp) + Heartbeat.Interval.Ticks;
-            var ticksToCompleteWriteAtMinRate = TimeSpan.FromSeconds(count / minRate.BytesPerSecond).Ticks;
+            var currentTimeUpperBound = Interlocked.Read(ref _lastTimestamp) + _heartbeatIntervalTicks;
+            var ticksToCompleteWriteAtMinRate = TimeSpan.FromSeconds(count / minRate.BytesPerSecond).ToTicks(_tickFrequency);
 
             // If ticksToCompleteWriteAtMinRate is less than the configured grace period,
             // allow that write to take up to the grace period to complete. Only add the grace period
             // to the current time and not to any accumulated timeout.
             var singleWriteTimeoutTimestamp = currentTimeUpperBound + Math.Max(
-                minRate.GracePeriod.Ticks,
+                minRate.GracePeriod.ToTicks(_tickFrequency),
                 ticksToCompleteWriteAtMinRate);
 
             // Don't penalize a connection for completing previous writes more quickly than required.
@@ -316,7 +322,7 @@ void IConnectionTimeoutFeature.SetTimeout(TimeSpan timeSpan)
             throw new InvalidOperationException(CoreStrings.ConcurrentTimeoutsNotSupported);
         }
 
-        SetTimeout(timeSpan.Ticks, TimeoutReason.TimeoutFeature);
+        SetTimeout(timeSpan.ToTicks(_tickFrequency), TimeoutReason.TimeoutFeature);
     }
 
     void IConnectionTimeoutFeature.ResetTimeout(TimeSpan timeSpan)
@@ -326,13 +332,13 @@ void IConnectionTimeoutFeature.ResetTimeout(TimeSpan timeSpan)
             throw new ArgumentException(CoreStrings.PositiveFiniteTimeSpanRequired, nameof(timeSpan));
         }
 
-        ResetTimeout(timeSpan.Ticks, TimeoutReason.TimeoutFeature);
+        ResetTimeout(timeSpan.ToTicks(_tickFrequency), TimeoutReason.TimeoutFeature);
     }
 
     public long GetResponseDrainDeadline(long ticks, MinDataRate minRate)
     {
         // On grace period overflow, use max value.
-        var gracePeriod = ticks + minRate.GracePeriod.Ticks;
+        var gracePeriod = ticks + minRate.GracePeriod.ToTicks(_tickFrequency);
         gracePeriod = gracePeriod >= 0 ? gracePeriod : long.MaxValue;
 
         return Math.Max(_writeTimingTimeoutTimestamp, gracePeriod);

src/Servers/Kestrel/Core/test/StartLineTests.cs

@@ -532,7 +532,7 @@ public StartLineTests()
             serviceContext: serviceContext,
             connectionContext: Mock.Of<ConnectionContext>(),
             transport: Transport,
-            timeoutControl: new TimeoutControl(timeoutHandler: null),
+            timeoutControl: new TimeoutControl(timeoutHandler: null, new MockTimeProvider().TimestampFrequency),
             memoryPool: MemoryPool,
             connectionFeatures: new FeatureCollection());