fix: Limit signal updates by time instead of count

Author: twpol

Source/Orts.Simulation/Simulation/Signalling/Signals.cs

@@ -64,7 +64,7 @@ public class Signals
         public int noSignals;
         private int foundSignals;
 
-        private static int updatecount;
+        private static int UpdateIndex;
 
         public List<TrackCircuitSection> TrackCircuitList;
         private Dictionary<int, CrossOverItem> CrossoverList = new Dictionary<int, CrossOverItem>();
@@ -553,6 +553,11 @@ private void BuildSignalWorld(Simulator simulator, SignalConfigurationFile sigcf
 
         }  //BuildSignalWorld
 
+        Stopwatch UpdateTimer = new Stopwatch();
+        long UpdateCounter = 0;
+        long UpdateTickTarget = 10000;
+        // long DebugUpdateCounter = 0;
+
         /// <summary>
         /// Update : perform signal updates
         /// </summary>
@@ -562,30 +567,39 @@ public void Update(bool preUpdate)
 
             if (foundSignals > 0)
             {
-
                 // loop through all signals
                 // update required part
-                // in preupdate, process all
-
-                int totalSignal = foundSignals;
-
-                int updatestep = (totalSignal / 20) + 1;
-                if (preUpdate)
-                {
-                    updatestep = totalSignal;
-                }
-
-                for (int icount = updatecount; icount < Math.Min(totalSignal, updatecount + updatestep); icount++)
+                var updates = 0;
+                var updateStep = 0;
+                var targetTicks = Stopwatch.GetTimestamp() + UpdateTickTarget;
+                UpdateTimer.Start();
+                while (updateStep < foundSignals)
                 {
-                    SignalObject signal = SignalObjects[icount];
+                    var signal = SignalObjects[(UpdateIndex + updateStep) % foundSignals];
                     if (signal != null && !signal.noupdate) // to cater for orphans, and skip signals which do not require updates
                     {
                         signal.Update();
+                        updates++;
                     }
+                    updateStep++;
+
+                    // in preupdate, process all
+                    if (!preUpdate && updates % 10 == 0 && Stopwatch.GetTimestamp() >= targetTicks) break;
                 }
+                UpdateCounter += updates;
+                UpdateTimer.Stop();
 
-                updatecount += updatestep;
-                updatecount = updatecount >= totalSignal ? 0 : updatecount;
+                if (UpdateIndex + updateStep >= foundSignals)
+                {
+                    // Calculate how long it takes to update all signals and target 1/20th of that
+                    // Slow adjustment using clamp stops it jumping around too much
+                    var ticksPerSignal = (double)UpdateTimer.ElapsedTicks / UpdateCounter;
+                    UpdateTickTarget = (long)MathHelper.Clamp((float)(ticksPerSignal * foundSignals / 20), UpdateTickTarget - 100, UpdateTickTarget + 100);
+                    // if (++DebugUpdateCounter % 10 == 0) Trace.WriteLine($"Signal update for {UpdateCounter,5} signals took {(double)UpdateTimer.ElapsedTicks * 1000 / Stopwatch.Frequency,9:F6} ms ({ticksPerSignal * 1000 / Stopwatch.Frequency,9:F6} ms/signal); new {(double)UpdateTickTarget * 1000 / Stopwatch.Frequency,6:F6} ms target");
+                    UpdateTimer.Reset();
+                    UpdateCounter = 0;
+                }
+                UpdateIndex = (UpdateIndex + updateStep) % foundSignals;
             }
         }