fix(core): Adds Hashed & Hierarchical Timer Wheel (#655)

- Removes TimerPriority
- Removes TimerThread
- Adds a [Hashed & Hierarchical Timer Wheel](http://www.cs.columbia.edu/~nahum/w6998/papers/ton97-timing-wheels.pdf)

Projects/Server/Timer/Timer.TimerWheel.cs

@@ -0,0 +1,263 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2021 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: Timer.TimerWheel.cs                                             *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Server
+{
+    public partial class Timer
+    {
+        private const int _ringSizePowerOf2 = 12;
+        private const int _ringSize = 1 << _ringSizePowerOf2; // 4096
+        private const int _ringLayers = 3;
+        private const int _tickRatePowerOf2 = 3;
+        private const int _tickRate = 1 << _tickRatePowerOf2; // 8ms
+
+        private static long _lastTickTurned = -1;
+
+        private static readonly Timer[][] _rings = new Timer[_ringLayers][];
+        private static readonly int[] _ringIndexes = new int[_ringLayers];
+
+        public static void Initialize(long tickCount)
+        {
+            _lastTickTurned = tickCount;
+
+            for (int i = 0; i < _rings.Length; i++)
+            {
+                _rings[i] = new Timer[_ringSize];
+                _ringIndexes[i] = 0;
+            }
+        }
+
+        public static int Slice(long tickCount)
+        {
+            var deltaSinceTurn = tickCount - _lastTickTurned;
+            var events = 0;
+            while (deltaSinceTurn >= _tickRate)
+            {
+                deltaSinceTurn -= _tickRate;
+                _lastTickTurned += _tickRate;
+                events += Turn() ? 1 : 0;
+            }
+
+            return events;
+        }
+
+        private static bool Turn()
+        {
+            bool events = false;
+
+            for (var i = 0; i < _ringLayers; i++)
+            {
+                // Increment the ring index, then get the timer.
+                var ringIndex = ++_ringIndexes[i];
+                bool turnNextWheel = ringIndex >= _ringSize;
+
+                if (turnNextWheel)
+                {
+                    ringIndex = _ringIndexes[i] = 0;
+                }
+
+                var timer = _rings[i][ringIndex];
+
+                if (timer != null)
+                {
+                    events = true;
+
+                    if (i > 0 && timer._remaining > 0)
+                    {
+                        Promote(timer);
+                    }
+                    else
+                    {
+                        Execute(timer);
+                    }
+
+                    // Clear the slot
+                    _rings[i][ringIndex] = null;
+                }
+
+                if (!turnNextWheel)
+                {
+                    break;
+                }
+            }
+
+            return events;
+        }
+
+        private static void Execute(Timer timer)
+        {
+            do
+            {
+                var next = timer._nextTimer;
+                var prof = timer.GetProfile();
+
+                prof?.Start();
+                timer.OnTick();
+                prof?.Finish();
+
+                if (timer.Running)
+                {
+                    RemoveTimer(timer);
+
+                    if (timer.Count == 0 || ++timer.Index < timer.Count)
+                    {
+                        timer.Delay = timer.Interval;
+                        timer.Next = Core.Now + timer.Interval;
+                        AddTimer(timer, (long)timer.Delay.TotalMilliseconds);
+                    }
+                }
+
+                timer = next;
+            } while (timer != null);
+        }
+
+        private static void Promote(Timer timer)
+        {
+            do
+            {
+                var next = timer._nextTimer;
+                RemoveTimer(timer);
+                AddTimer(timer, timer._remaining);
+                timer = next;
+            } while (timer != null);
+        }
+
+        private static void AddTimer(Timer timer, long delay)
+        {
+            delay = Math.Max(0, delay);
+
+            var resolutionPowerOf2 = _tickRatePowerOf2;
+            for (var i = 0; i < _ringLayers; i++)
+            {
+                var resolution = 1 << resolutionPowerOf2;
+                var nextResolutionPowerOf2 = resolutionPowerOf2 + _ringSizePowerOf2;
+                long max = 1 << nextResolutionPowerOf2;
+                if (delay < max)
+                {
+                    var remaining = delay & (resolution - 1);
+                    var slot = (delay >> resolutionPowerOf2) + _ringIndexes[i] + (remaining > 0 ? 1 : 0);
+
+                    // Round up if we have a delay of 0
+                    if (delay == 0)
+                    {
+                        slot++;
+                        remaining = 0;
+                    }
+
+                    if (slot >= _ringSize)
+                    {
+                        slot -= _ringSize;
+                    }
+
+                    timer._nextTimer = _rings[i][slot];
+                    if (timer._nextTimer != null)
+                    {
+                        timer._nextTimer._prevTimer = timer;
+                    }
+
+                    timer._remaining = remaining;
+                    timer._ring = i;
+                    timer._slot = (int)slot;
+
+                    _rings[i][slot] = timer;
+                    break;
+                }
+
+                // The remaining amount until we turn this ring
+                delay -= resolution * (_ringSize - _ringIndexes[i]);
+                resolutionPowerOf2 = nextResolutionPowerOf2;
+            }
+        }
+
+        private static void RemoveTimer(Timer timer)
+        {
+            if (timer._prevTimer != null)
+            {
+                timer._prevTimer._nextTimer = timer._nextTimer;
+            }
+            else
+            {
+                _rings[timer._ring][timer._slot] = timer._nextTimer;
+            }
+
+            if (timer._nextTimer != null)
+            {
+                timer._nextTimer._prevTimer = timer._prevTimer;
+            }
+
+            timer._nextTimer = null;
+            timer._prevTimer = null;
+        }
+
+        public static void DumpInfo(TextWriter tw)
+        {
+            var now = DateTime.UtcNow;
+
+            tw.WriteLine("Date: {0}", now);
+            tw.WriteLine();
+
+            var total = 0.0;
+            var hash = new Dictionary<string, int>();
+
+            for (var i = 0; i < _ringLayers; i++)
+            {
+                for (var j = 0; j < _ringSize; j++)
+                {
+                    var t = _rings[i][j];
+
+                    var name = t.ToString();
+
+                    hash.TryGetValue(name, out var count);
+                    hash[name] = count + 1;
+
+                    total++;
+                }
+            }
+
+            foreach (var (name, count) in hash.OrderByDescending(o => o.Value))
+            {
+                tw.WriteLine($"Type: {name}; Count: {count}; Percent: {count / total}%");
+            }
+
+            tw.WriteLine();
+            tw.WriteLine();
+        }
+
+        public static void ClearAllTimers(long tickCount)
+        {
+            _lastTickTurned = tickCount;
+
+            foreach (var t in _rings)
+            {
+                for (var i = 0; i < _ringSize; i++)
+                {
+                    var node = t[i];
+                    Timer next;
+
+                    do
+                    {
+                        next = node?._nextTimer;
+                        node?.Stop();
+                    } while (next != null);
+                }
+            }
+        }
+    }
+}