Cumulative updates (ACEmulator#4180)

* Many lb group performance related updates

* fixes

* tweak partitioner

* Implement LandblockGroupMinSpacingWhenDormant

* More threaddebug

* cleanup

Source/ACE.Common/Performance/RateMonitor.cs

@@ -42,18 +42,17 @@ public void Resume()
 
         /// <summary>
         /// Stops time interval measurement.
-        /// Registers the completion of an event and returns the elapsed seconds for this event
         /// </summary>
-        public double RegisterEventEnd()
+        public void RegisterEventEnd()
         {
             stopwatch.Stop();
 
-            return RegisterEvent(stopwatch.Elapsed.TotalSeconds);
+            RegisterEvent(stopwatch.Elapsed.TotalSeconds);
         }
 
-        public double RegisterEvent(double totalSeconds)
+        public void RegisterEvent(double totalSeconds)
         {
-            return EventHistory.RegisterEvent(totalSeconds);
+            EventHistory.RegisterEvent(totalSeconds);
         }
 
         public void ClearEventHistory()

Source/ACE.Common/Performance/RollingAmountOverHitsTracker.cs

@@ -0,0 +1,80 @@
+using System;
+
+namespace ACE.Common.Performance
+{
+    public class RollingAmountOverHitsTracker
+    {
+        public readonly long HitsBeingTracked;
+
+        private readonly double[] amounts;
+
+        private int nextIndex = 0;
+
+        private bool rolledOver;
+
+
+        public double LastAmount { get; private set; }
+
+        public long TotalAmounts
+        {
+            get
+            {
+                if (rolledOver)
+                    return HitsBeingTracked;
+
+                return nextIndex;
+            }
+        }
+
+        public double Sum { get; private set; }
+
+        public double AverageAmount => TotalAmounts == 0 ? 0 : Sum / TotalAmounts;
+
+        /// <summary>
+        /// Use this sparingly as it iterates over the entire collection
+        /// </summary>
+        public double LargestAmount
+        {
+            get
+            {
+                if (TotalAmounts == 0)
+                    return 0;
+
+                var largest = double.MinValue;
+
+                for (int i = 0; i < TotalAmounts; i++)
+                {
+                    if (amounts[i] > largest)
+                        largest = amounts[i];
+                }
+
+                return largest;
+            }
+        }
+
+        public RollingAmountOverHitsTracker(long hitsToTrack)
+        {
+            HitsBeingTracked = hitsToTrack;
+
+            amounts = new double[hitsToTrack];
+        }
+
+
+        public void RegisterAmount(double amount)
+        {
+            LastAmount = amount;
+
+            Sum -= amounts[nextIndex];
+            amounts[nextIndex] = amount;
+            Sum += amounts[nextIndex];
+
+            nextIndex++;
+
+            if (nextIndex == HitsBeingTracked)
+            {
+                nextIndex = 0;
+                rolledOver = true;
+            }
+        }
+    }
+}

Source/ACE.Common/Performance/RollingAmountOverTimeTracker.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+
+namespace ACE.Common.Performance
+{
+    public class RollingAmountOverTimeTracker
+    {
+        public readonly TimeSpan TimeBeingTracked;
+
+        private readonly LinkedList<Tuple<DateTime, double>> amounts = new LinkedList<Tuple<DateTime, double>>();
+
+
+        public double LastAmount { get; private set; }
+
+        public long TotalAmounts => amounts.Count;
+
+        public double Sum { get; private set; }
+
+        public double AverageAmount => TotalAmounts == 0 ? 0 : Sum / TotalAmounts;
+
+        /// <summary>
+        /// Use this sparingly as it iterates over the entire collection
+        /// </summary>
+        public double LargestAmount
+        {
+            get
+            {
+                if (TotalAmounts == 0)
+                    return 0;
+
+                var largest = double.MinValue;
+
+                foreach (var amount in amounts)
+                {
+                    if (amount.Item2 > largest)
+                        largest = amount.Item2;
+                }
+
+                return largest;
+            }
+        }
+
+        public RollingAmountOverTimeTracker(TimeSpan timeToTrack)
+        {
+            TimeBeingTracked = timeToTrack;
+        }
+
+
+        public void RegisterAmount(double amount)
+        {
+            LastAmount = amount;
+
+            var now = DateTime.UtcNow;
+
+            var pruneBefore = now - TimeBeingTracked;
+
+            while (amounts.Count > 0 && amounts.First.Value.Item1 < pruneBefore)
+            {
+                Sum -= amounts.First.Value.Item2;
+
+                amounts.RemoveFirst();
+            }
+
+            Sum += amount;
+
+            amounts.AddLast(new Tuple<DateTime, double>(now, amount));
+        }
+    }
+}

Source/ACE.Common/Performance/TimedEventHistory.cs

@@ -27,7 +27,7 @@ public class TimedEventHistory
         /// </summary>
         public double AverageEventDuration => TotalSeconds / TotalEvents;
 
-        public double RegisterEvent(double totalSeconds)
+        public void RegisterEvent(double totalSeconds)
         {
             LastEvent = totalSeconds;
 
@@ -39,8 +39,6 @@ public double RegisterEvent(double totalSeconds)
 
             if (LastEvent < ShortestEvent)
                 ShortestEvent = LastEvent;
-
-            return LastEvent;
         }
 
         public void ClearHistory()

Source/ACE.Server/Command/Handlers/AdminStatCommands.cs

@@ -32,33 +32,15 @@ public static void HandleAllStats(Session session, params string[] parameters)
 
             HandleServerPerformance(session, parameters);
 
-            HandleLandblockPerformance(session, parameters);
+            HandleLandblockStats(session, parameters);
+
+            HandleLBGroupStats(session, parameters);
 
             HandleGCStatus(session, parameters);
 
             DeveloperDatabaseCommands.HandleDatabaseQueueInfo(session, parameters);
         }
 
-        [CommandHandler("threaddebug", AccessLevel.Advocate, CommandHandlerFlag.None, 0, "temporary thread testing")]
-        public static void HandleThreadDebug(Session session, params string[] parameters)
-        {
-            var sb = new StringBuilder();
-
-            sb.Append($"TickPhysicsInformation.Values.Count: {LandblockManager.TickPhysicsInformation.Values.Count}{'\n'}");
-            foreach (var value in LandblockManager.TickPhysicsInformation.Values)
-            {
-                sb.Append($"NumberOfParalellHits: {value.NumberOfParalellHits.ToString().PadLeft(3)}, NumberOfLandblocksInThisThread: {value.NumberOfLandblocksInThisThread.ToString().PadLeft(3)}, TotalTickDuration: {value.TotalTickDuration.TotalMilliseconds.ToString("N1").PadLeft(4)} ms, LongestTickedLandblockGroup: {value.LongestTickedLandblockGroup.TotalMilliseconds.ToString("N1").PadLeft(4)} ms{'\n'}");
-            }
-
-            sb.Append($"TickMultiThreadedWorkInformation.Values.Count: {LandblockManager.TickMultiThreadedWorkInformation.Values.Count}{'\n'}");
-            foreach (var value in LandblockManager.TickMultiThreadedWorkInformation.Values)
-            {
-                sb.Append($"NumberOfParalellHits: {value.NumberOfParalellHits.ToString().PadLeft(3)}, NumberOfLandblocksInThisThread: {value.NumberOfLandblocksInThisThread.ToString().PadLeft(3)}, TotalTickDuration: {value.TotalTickDuration.TotalMilliseconds.ToString("N1").PadLeft(4)} ms, LongestTickedLandblockGroup: {value.LongestTickedLandblockGroup.TotalMilliseconds.ToString("N1").PadLeft(4)} ms{'\n'}");
-            }
-
-            CommandHandlerHelper.WriteOutputInfo(session, $"{sb}");
-        }
-
         // serverstatus
         [CommandHandler("serverstatus", AccessLevel.Advocate, CommandHandlerFlag.None, 0, "Displays a summary of server statistics and usage")]
         public static void HandleServerStatus(Session session, params string[] parameters)
@@ -212,7 +194,8 @@ public static void HandleServerPerformance(Session session, params string[] para
         }
 
         [CommandHandler("landblockperformance", AccessLevel.Advocate, CommandHandlerFlag.None, 0, "Displays a summary of landblock performance statistics")]
-        public static void HandleLandblockPerformance(Session session, params string[] parameters)
+        [CommandHandler("landblockstats", AccessLevel.Advocate, CommandHandlerFlag.None, 0, "Displays a summary of landblock performance statistics")]
+        public static void HandleLandblockStats(Session session, params string[] parameters)
         {
             var sb = new StringBuilder();
 
@@ -270,33 +253,37 @@ public static void HandleLandblockPerformance(Session session, params string[] p
             CommandHandlerHelper.WriteOutputInfo(session, sb.ToString());
         }
 
+        // lbgroupstats
         [CommandHandler("lbgroupstats", AccessLevel.Advocate, CommandHandlerFlag.None, 0, "Displays a summary of landblock group stats")]
         public static void HandleLBGroupStats(Session session, params string[] parameters)
         {
             var sb = new StringBuilder();
 
+            sb.Append($"TickPhysicsEfficiencyTracker: {LandblockManager.TickPhysicsEfficiencyTracker.AverageAmount,3:N0} %, TickMultiThreadedWorkEfficiencyTracker: {LandblockManager.TickMultiThreadedWorkEfficiencyTracker.AverageAmount,3:N0} %{'\n'}");
+
             var loadedLanblockGroups = LandblockManager.GetLoadedLandblockGroups();
 
+            var sortedByLargest = loadedLanblockGroups.OrderByDescending(r => r.Count).Take(5);
 
             sb.Append($"Largest Landblock Groups{'\n'}");
-            sb.Append($"Cnt, XMin - XMax, YMin - YMax, NextTrySplitTime{'\n'}");
-
-            var sortedByLargest = loadedLanblockGroups.OrderByDescending(r => r.Count).ToList();
+            sb.Append($"Cnt, XMin - XMax, YMin - YMax, TickPhysicsTracker avg   max, TickMultiThreadedWorkTracker avg   max (s){'\n'}");
 
-            for (int i = 0; i < Math.Min(5, sortedByLargest.Count - 1); i++)
-            {
-                var landblockGroup = sortedByLargest[i];
+            foreach (var landblockGroup in sortedByLargest)
+                sb.Append($"{landblockGroup.Count,3},   {landblockGroup.XMin,2:X2} - {landblockGroup.XMax,2:X2},     {landblockGroup.YMin,2:X2} - {landblockGroup.YMax,2:X2}  ,                  {landblockGroup.TickPhysicsTracker.AverageAmount,5:N3} {landblockGroup.TickPhysicsTracker.LargestAmount,5:N3},                            {landblockGroup.TickMultiThreadedWorkTracker.AverageAmount,5:N3} {landblockGroup.TickMultiThreadedWorkTracker.LargestAmount,5:N3}{'\n'}");
 
-                sb.Append($"{landblockGroup.Count.ToString().PadLeft(3)},   {landblockGroup.XMin.ToString("X2").PadLeft(2)} - {landblockGroup.XMax.ToString("X2").PadLeft(2)},     {landblockGroup.YMin.ToString("X2").PadLeft(2)} - {landblockGroup.YMax.ToString("X2").PadLeft(2)},      {(landblockGroup.NextTrySplitTime - DateTime.UtcNow).TotalMinutes.ToString("N1").PadLeft(4)} m{'\n'}");
-            }
+            var sortedByTopTickPhysicsTracker = loadedLanblockGroups.OrderByDescending(r => r.TickPhysicsTracker.AverageAmount).Take(5);
 
+            sb.Append($"Top TickPhysicsTracker Landblock Groups{'\n'}");
 
-            sb.Append($"Highest Compute Landblock Groups{'\n'}");
+            foreach (var landblockGroup in sortedByTopTickPhysicsTracker)
+                sb.Append($"{landblockGroup.Count,3},   {landblockGroup.XMin,2:X2} - {landblockGroup.XMax,2:X2},     {landblockGroup.YMin,2:X2} - {landblockGroup.YMax,2:X2}  ,                  {landblockGroup.TickPhysicsTracker.AverageAmount,5:N3} {landblockGroup.TickPhysicsTracker.LargestAmount,5:N3},                            {landblockGroup.TickMultiThreadedWorkTracker.AverageAmount,5:N3} {landblockGroup.TickMultiThreadedWorkTracker.LargestAmount,5:N3}{'\n'}");
 
-            //var sortedByHighestCompute = loadedLanblockGroups.OrderByDescending(r => r.Count);
+            var sortedByTopTickMultiThreadedWorkTracker = loadedLanblockGroups.OrderByDescending(r => r.TickMultiThreadedWorkTracker.AverageAmount).Take(5);
 
-            // todo
+            sb.Append($"Top TickMultiThreadedWorkTracker Landblock Groups{'\n'}");
 
+            foreach (var landblockGroup in sortedByTopTickMultiThreadedWorkTracker)
+                sb.Append($"{landblockGroup.Count,3},   {landblockGroup.XMin,2:X2} - {landblockGroup.XMax,2:X2},     {landblockGroup.YMin,2:X2} - {landblockGroup.YMax,2:X2}  ,                  {landblockGroup.TickPhysicsTracker.AverageAmount,5:N3} {landblockGroup.TickPhysicsTracker.LargestAmount,5:N3},                            {landblockGroup.TickMultiThreadedWorkTracker.AverageAmount,5:N3} {landblockGroup.TickMultiThreadedWorkTracker.LargestAmount,5:N3}{'\n'}");
 
             CommandHandlerHelper.WriteOutputInfo(session, sb.ToString());
         }