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)
This commit is contained in:
Kamron Batman
GitHub
parent
b99d520019
commit
fb915992dd
138 changed files with 468 additions and 802 deletions
|
|
@ -14,39 +14,19 @@
|
|||
*************************************************************************/
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Threading;
|
||||
using Server.Diagnostics;
|
||||
|
||||
namespace Server
|
||||
{
|
||||
public enum TimerPriority
|
||||
{
|
||||
EveryTick,
|
||||
TenMS,
|
||||
TwentyFiveMS,
|
||||
FiftyMS,
|
||||
TwoFiftyMS,
|
||||
OneSecond,
|
||||
FiveSeconds,
|
||||
OneMinute
|
||||
}
|
||||
|
||||
public partial class Timer
|
||||
{
|
||||
private static readonly Queue<Timer> m_Queue = new();
|
||||
// We need to know what ring/slot we are in so we can be removed if we are "head" of the link list.
|
||||
private int _ring;
|
||||
private int _slot;
|
||||
|
||||
private static int m_QueueCountAtSlice;
|
||||
private long m_Delay;
|
||||
private long m_Interval;
|
||||
private List<Timer> m_List;
|
||||
private long m_Next;
|
||||
private TimerPriority m_Priority;
|
||||
private bool m_PrioritySet;
|
||||
|
||||
private bool m_Queued;
|
||||
private bool m_Running;
|
||||
private long _remaining;
|
||||
private Timer _nextTimer;
|
||||
private Timer _prevTimer;
|
||||
|
||||
public Timer(TimeSpan delay) : this(delay, TimeSpan.Zero, 1)
|
||||
{
|
||||
|
|
@ -54,130 +34,13 @@ namespace Server
|
|||
|
||||
public Timer(TimeSpan delay, TimeSpan interval, int count = 0)
|
||||
{
|
||||
m_Delay = (long)delay.TotalMilliseconds;
|
||||
m_Interval = (long)interval.TotalMilliseconds;
|
||||
Delay = delay;
|
||||
Interval = interval;
|
||||
Count = count;
|
||||
_nextTimer = null;
|
||||
_prevTimer = null;
|
||||
Next = Core.Now + Delay;
|
||||
|
||||
if (!m_PrioritySet)
|
||||
{
|
||||
m_Priority = ComputePriority(count == 1 ? delay : interval);
|
||||
m_PrioritySet = true;
|
||||
}
|
||||
|
||||
if (DefRegCreation)
|
||||
{
|
||||
RegCreation();
|
||||
}
|
||||
}
|
||||
|
||||
public TimerPriority Priority
|
||||
{
|
||||
get => m_Priority;
|
||||
set
|
||||
{
|
||||
if (!m_PrioritySet)
|
||||
{
|
||||
m_PrioritySet = true;
|
||||
}
|
||||
|
||||
if (m_Priority != value)
|
||||
{
|
||||
m_Priority = value;
|
||||
|
||||
if (m_Running)
|
||||
{
|
||||
TimerThread.PriorityChange(this, (int)m_Priority);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public DateTime Next => DateTime.UtcNow + TimeSpan.FromMilliseconds(m_Next - Core.TickCount);
|
||||
|
||||
public TimeSpan Delay
|
||||
{
|
||||
get => TimeSpan.FromMilliseconds(m_Delay);
|
||||
set => m_Delay = (long)value.TotalMilliseconds;
|
||||
}
|
||||
|
||||
public TimeSpan Interval
|
||||
{
|
||||
get => TimeSpan.FromMilliseconds(m_Interval);
|
||||
set => m_Interval = (long)value.TotalMilliseconds;
|
||||
}
|
||||
|
||||
public int Index { get; private set; }
|
||||
|
||||
public int Count { get; }
|
||||
|
||||
public bool Running
|
||||
{
|
||||
get => m_Running;
|
||||
set
|
||||
{
|
||||
if (value)
|
||||
{
|
||||
Start();
|
||||
}
|
||||
else
|
||||
{
|
||||
Stop();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static int BreakCount { get; set; } = 20000;
|
||||
|
||||
public virtual bool DefRegCreation => true;
|
||||
|
||||
private static string FormatDelegate(Delegate callback) =>
|
||||
callback == null ? "null" : $"{callback.Method.DeclaringType?.FullName ?? ""}.{callback.Method.Name}";
|
||||
|
||||
public static void DumpInfo(TextWriter tw)
|
||||
{
|
||||
TimerThread.DumpInfo(tw);
|
||||
}
|
||||
|
||||
public TimerProfile GetProfile()
|
||||
{
|
||||
if (!Core.Profiling)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var name = ToString();
|
||||
|
||||
return TimerProfile.Acquire(name);
|
||||
}
|
||||
|
||||
public static int Slice()
|
||||
{
|
||||
var index = 0;
|
||||
|
||||
lock (m_Queue)
|
||||
{
|
||||
m_QueueCountAtSlice = m_Queue.Count;
|
||||
|
||||
while (index < BreakCount && m_Queue.Count != 0)
|
||||
{
|
||||
var t = m_Queue.Dequeue();
|
||||
var prof = t.GetProfile();
|
||||
|
||||
prof?.Start();
|
||||
|
||||
t.OnTick();
|
||||
t.m_Queued = false;
|
||||
index++;
|
||||
|
||||
prof?.Finish();
|
||||
}
|
||||
}
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
public void RegCreation()
|
||||
{
|
||||
var prof = GetProfile();
|
||||
|
||||
if (prof != null)
|
||||
|
|
@ -186,321 +49,59 @@ namespace Server
|
|||
}
|
||||
}
|
||||
|
||||
public override string ToString() => GetType().FullName ?? "";
|
||||
public DateTime Next { get; private set; }
|
||||
public TimeSpan Delay { get; set; }
|
||||
public TimeSpan Interval { get; set; }
|
||||
public int Index { get; private set; }
|
||||
public int Count { get; }
|
||||
public bool Running { get; private set; }
|
||||
|
||||
public static TimerPriority ComputePriority(TimeSpan ts)
|
||||
public TimerProfile GetProfile() => !Core.Profiling ? null : TimerProfile.Acquire(ToString() ?? "null");
|
||||
|
||||
public override string ToString() => GetType().FullName;
|
||||
|
||||
public Timer Start()
|
||||
{
|
||||
if (ts >= TimeSpan.FromMinutes(1.0))
|
||||
if (Running)
|
||||
{
|
||||
return TimerPriority.FiveSeconds;
|
||||
return this;
|
||||
}
|
||||
|
||||
if (ts >= TimeSpan.FromSeconds(10.0))
|
||||
Running = true;
|
||||
AddTimer(this, (long)Delay.TotalMilliseconds);
|
||||
|
||||
var prof = GetProfile();
|
||||
|
||||
if (prof != null)
|
||||
{
|
||||
return TimerPriority.OneSecond;
|
||||
prof.Started++;
|
||||
}
|
||||
|
||||
if (ts >= TimeSpan.FromSeconds(5.0))
|
||||
{
|
||||
return TimerPriority.TwoFiftyMS;
|
||||
}
|
||||
|
||||
if (ts >= TimeSpan.FromSeconds(2.5))
|
||||
{
|
||||
return TimerPriority.FiftyMS;
|
||||
}
|
||||
|
||||
if (ts >= TimeSpan.FromSeconds(1.0))
|
||||
{
|
||||
return TimerPriority.TwentyFiveMS;
|
||||
}
|
||||
|
||||
if (ts >= TimeSpan.FromSeconds(0.5))
|
||||
{
|
||||
return TimerPriority.TenMS;
|
||||
}
|
||||
|
||||
return TimerPriority.EveryTick;
|
||||
return this;
|
||||
}
|
||||
|
||||
public void Start()
|
||||
public Timer Stop()
|
||||
{
|
||||
if (!m_Running)
|
||||
if (!Running)
|
||||
{
|
||||
m_Running = true;
|
||||
TimerThread.AddTimer(this);
|
||||
|
||||
var prof = GetProfile();
|
||||
|
||||
if (prof != null)
|
||||
{
|
||||
prof.Started++;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
public void Stop()
|
||||
{
|
||||
if (m_Running)
|
||||
Running = false;
|
||||
RemoveTimer(this);
|
||||
|
||||
var prof = GetProfile();
|
||||
|
||||
if (prof != null)
|
||||
{
|
||||
m_Running = false;
|
||||
TimerThread.RemoveTimer(this);
|
||||
|
||||
var prof = GetProfile();
|
||||
|
||||
if (prof != null)
|
||||
{
|
||||
prof.Stopped++;
|
||||
}
|
||||
prof.Stopped++;
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
protected virtual void OnTick()
|
||||
{
|
||||
}
|
||||
|
||||
public class TimerThread
|
||||
{
|
||||
private static readonly Dictionary<Timer, TimerChangeEntry>
|
||||
m_Changed = new();
|
||||
|
||||
private static readonly long[] m_NextPriorities = new long[8];
|
||||
|
||||
private static readonly long[] m_PriorityDelays =
|
||||
{
|
||||
0,
|
||||
10,
|
||||
25,
|
||||
50,
|
||||
250,
|
||||
1000,
|
||||
5000,
|
||||
60000
|
||||
};
|
||||
|
||||
private static readonly List<Timer>[] m_Timers =
|
||||
{
|
||||
new(),
|
||||
new(),
|
||||
new(),
|
||||
new(),
|
||||
new(),
|
||||
new(),
|
||||
new(),
|
||||
new()
|
||||
};
|
||||
|
||||
private static readonly AutoResetEvent m_Signal = new(false);
|
||||
|
||||
public static void DumpInfo(TextWriter tw)
|
||||
{
|
||||
for (var i = 0; i < 8; ++i)
|
||||
{
|
||||
tw.WriteLine("Priority: {0}", (TimerPriority)i);
|
||||
tw.WriteLine();
|
||||
|
||||
var hash = new Dictionary<string, List<Timer>>();
|
||||
|
||||
for (var j = 0; j < m_Timers[i].Count; ++j)
|
||||
{
|
||||
var t = m_Timers[i][j];
|
||||
|
||||
var key = t.ToString();
|
||||
|
||||
if (!hash.TryGetValue(key, out var list))
|
||||
{
|
||||
hash[key] = list = new List<Timer>();
|
||||
}
|
||||
|
||||
list.Add(t);
|
||||
}
|
||||
|
||||
foreach (var kv in hash)
|
||||
{
|
||||
var key = kv.Key;
|
||||
var list = kv.Value;
|
||||
|
||||
tw.WriteLine(
|
||||
"Type: {0}; Count: {1}; Percent: {2}%",
|
||||
key,
|
||||
list.Count,
|
||||
(int)(100 * (list.Count / (double)m_Timers[i].Count))
|
||||
);
|
||||
}
|
||||
|
||||
tw.WriteLine();
|
||||
tw.WriteLine();
|
||||
}
|
||||
}
|
||||
|
||||
public static void Change(Timer t, int newIndex, bool isAdd)
|
||||
{
|
||||
lock (m_Changed)
|
||||
{
|
||||
m_Changed[t] = TimerChangeEntry.GetInstance(t, newIndex, isAdd);
|
||||
}
|
||||
|
||||
m_Signal.Set();
|
||||
}
|
||||
|
||||
public static void AddTimer(Timer t)
|
||||
{
|
||||
Change(t, (int)t.Priority, true);
|
||||
}
|
||||
|
||||
public static void PriorityChange(Timer t, int newPrio)
|
||||
{
|
||||
Change(t, newPrio, false);
|
||||
}
|
||||
|
||||
public static void RemoveTimer(Timer t)
|
||||
{
|
||||
Change(t, -1, false);
|
||||
}
|
||||
|
||||
private static void ProcessChanged()
|
||||
{
|
||||
lock (m_Changed)
|
||||
{
|
||||
var curTicks = Core.TickCount;
|
||||
|
||||
foreach (var tce in m_Changed.Values)
|
||||
{
|
||||
var timer = tce.m_Timer;
|
||||
var newIndex = tce.m_NewIndex;
|
||||
|
||||
timer.m_List?.Remove(timer);
|
||||
|
||||
if (tce.m_IsAdd)
|
||||
{
|
||||
timer.m_Next = curTicks + timer.m_Delay;
|
||||
timer.Index = 0;
|
||||
}
|
||||
|
||||
if (newIndex >= 0)
|
||||
{
|
||||
timer.m_List = m_Timers[newIndex];
|
||||
timer.m_List.Add(timer);
|
||||
}
|
||||
else
|
||||
{
|
||||
timer.m_List = null;
|
||||
}
|
||||
|
||||
tce.Free();
|
||||
}
|
||||
|
||||
m_Changed.Clear();
|
||||
}
|
||||
}
|
||||
|
||||
public static void Set()
|
||||
{
|
||||
m_Signal.Set();
|
||||
}
|
||||
|
||||
public void TimerMain()
|
||||
{
|
||||
while (!Core.Closing)
|
||||
{
|
||||
if (World.Loading || World.Saving)
|
||||
{
|
||||
m_Signal.WaitOne(1, false);
|
||||
continue;
|
||||
}
|
||||
|
||||
ProcessChanged();
|
||||
|
||||
for (var i = 0; i < m_Timers.Length; i++)
|
||||
{
|
||||
var now = Core.TickCount;
|
||||
if (now < m_NextPriorities[i])
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
m_NextPriorities[i] = now + m_PriorityDelays[i];
|
||||
|
||||
for (var j = 0; j < m_Timers[i].Count; j++)
|
||||
{
|
||||
var t = m_Timers[i][j];
|
||||
|
||||
if (!t.m_Queued && now > t.m_Next)
|
||||
{
|
||||
t.m_Queued = true;
|
||||
|
||||
lock (m_Queue)
|
||||
{
|
||||
m_Queue.Enqueue(t);
|
||||
}
|
||||
|
||||
if (t.Count != 0 && ++t.Index >= t.Count)
|
||||
{
|
||||
t.Stop();
|
||||
}
|
||||
else
|
||||
{
|
||||
t.m_Next = now + t.m_Interval;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
m_Signal.WaitOne(1, false);
|
||||
}
|
||||
}
|
||||
|
||||
private class TimerChangeEntry
|
||||
{
|
||||
private static readonly Queue<TimerChangeEntry> m_InstancePool = new();
|
||||
public bool m_IsAdd;
|
||||
public int m_NewIndex;
|
||||
public Timer m_Timer;
|
||||
|
||||
private TimerChangeEntry(Timer t, int newIndex, bool isAdd)
|
||||
{
|
||||
m_Timer = t;
|
||||
m_NewIndex = newIndex;
|
||||
m_IsAdd = isAdd;
|
||||
}
|
||||
|
||||
public void Free()
|
||||
{
|
||||
lock (m_InstancePool)
|
||||
{
|
||||
if (m_InstancePool.Count < 200) // Arbitrary
|
||||
{
|
||||
m_InstancePool.Enqueue(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static TimerChangeEntry GetInstance(Timer t, int newIndex, bool isAdd)
|
||||
{
|
||||
TimerChangeEntry e = null;
|
||||
|
||||
lock (m_InstancePool)
|
||||
{
|
||||
if (m_InstancePool.Count > 0)
|
||||
{
|
||||
e = m_InstancePool.Dequeue();
|
||||
}
|
||||
}
|
||||
|
||||
if (e != null)
|
||||
{
|
||||
e.m_Timer = t;
|
||||
e.m_NewIndex = newIndex;
|
||||
e.m_IsAdd = isAdd;
|
||||
}
|
||||
else
|
||||
{
|
||||
e = new TimerChangeEntry(t, newIndex, isAdd);
|
||||
}
|
||||
|
||||
return e;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue