Merge pull request #6605 from smoogipoo/fast-decoupled-reference

Author: peppy

osu.Framework/Development/DebugUtils.cs

@@ -8,11 +8,31 @@
 using NUnit.Framework;
 using NUnit.Framework.Internal;
 using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Platform;
+using osu.Framework.Timing;
 
 namespace osu.Framework.Development
 {
     public static class DebugUtils
     {
+        /// <summary>
+        /// This represents a clock that runs at a faster-than-realtime pace during unit testing,
+        /// and is intended to substitute for a <see cref="StopwatchClock"/> that would normally
+        /// be used to track a realtime reference.
+        /// </summary>
+        /// <remarks>
+        /// <list type="bullet">
+        ///   <item>
+        ///     Components such as <see cref="DecouplingFramedClock"/> use this to advance time at a faster
+        ///     pace in order to not induce artificial delays from having to way on wall clock time to elapse.
+        ///   </item>
+        ///   <item>
+        ///     Note that this property is only populated after the <see cref="GameHost"/> is run.
+        ///   </item>
+        /// </list>
+        /// </remarks>
+        internal static IClock? RealtimeClock { get; set; }
+
         public static bool IsNUnitRunning => is_nunit_running.Value;
 
         private static readonly Lazy<bool> is_nunit_running = new Lazy<bool>(() =>

osu.Framework/Platform/HeadlessGameHost.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Configuration;
+using osu.Framework.Development;
 using osu.Framework.Graphics.Rendering.Dummy;
 using osu.Framework.Input.Handlers;
 using osu.Framework.Logging;
@@ -79,7 +80,8 @@ protected override void SetupForRun()
 
             if (!realtime)
             {
-                customClock = new FramedClock(new FastClock(CLOCK_RATE, Threads.ToArray()));
+                DebugUtils.RealtimeClock = new FastClock(CLOCK_RATE, Threads.ToArray());
+                customClock = new FramedClock(DebugUtils.RealtimeClock);
 
                 // time is incremented per frame, rather than based on the real-world time.
                 // therefore our goal is to run frames as fast as possible.
@@ -106,6 +108,12 @@ protected override void UpdateFrame()
 
         protected override IEnumerable<InputHandler> CreateAvailableInputHandlers() => Array.Empty<InputHandler>();
 
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            DebugUtils.RealtimeClock = null;
+        }
+
         private class FastClock : IClock
         {
             private readonly double increment;
@@ -134,20 +142,23 @@ public double CurrentTime
             {
                 get
                 {
-                    double realElapsedTime = stopwatch.Elapsed.TotalMilliseconds;
-                    stopwatch.Restart();
-
-                    if (allThreadsHaveProgressed)
+                    lock (stopwatch)
                     {
-                        for (int i = 0; i < gameThreads.Length; i++)
-                            gameThreadLastFrames[i] = gameThreads[i].FrameIndex;
+                        double realElapsedTime = stopwatch.Elapsed.TotalMilliseconds;
+                        stopwatch.Restart();
 
-                        // Increment time at the expedited rate.
-                        return time += increment;
-                    }
+                        if (allThreadsHaveProgressed)
+                        {
+                            for (int i = 0; i < gameThreads.Length; i++)
+                                gameThreadLastFrames[i] = gameThreads[i].FrameIndex;
+
+                            // Increment time at the expedited rate.
+                            return time += increment;
+                        }
 
-                    // Fall back to real time to ensure we don't break random tests that expect threads to be running.
-                    return time += realElapsedTime;
+                        // Fall back to real time to ensure we don't break random tests that expect threads to be running.
+                        return time += realElapsedTime;
+                    }
                 }
             }
 

osu.Framework/Timing/DecouplingFramedClock.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Diagnostics;
+using osu.Framework.Development;
 
 namespace osu.Framework.Timing
 {
@@ -70,7 +71,7 @@ public sealed class DecouplingFramedClock : ISourceChangeableClock, IAdjustableC
         /// <summary>
         /// This clock is used when we are decoupling from the source.
         /// </summary>
-        private readonly StopwatchClock realtimeReferenceClock = new StopwatchClock(true);
+        private readonly IClock realtimeReferenceClock = DebugUtils.RealtimeClock ?? new StopwatchClock(true);
 
         private IAdjustableClock adjustableSourceClock;