max/Nerfed
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects 2 Releases Wiki Activity

Add thread metrics and category support to Profiler and visualizer

Browse Source
This commit is contained in:
max
2026-08-05 11:47:21 +02:00
parent 2d4139fb2c
commit 83f77d1ebe
3 changed files with 350 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Nerfed.Runtime/Profiler.cs
+269 -13
View File
@@ -10,6 +10,11 @@ public struct ProfilerScope : IDisposable
Profiler.BeginSample(label);
}
public ProfilerScope(string label, string category, ulong tagMask = 0)
{
Profiler.BeginSample(label, category, tagMask);
}
public void Dispose()
{
Profiler.EndSample();
@@ -18,6 +23,20 @@ public struct ProfilerScope : IDisposable
public static class Profiler
{
public enum CaptureMode
{
Instrumented = 0,
SampledInstrumentation = 1,
}
private sealed class ThreadProfilerState
{
public readonly Stack<ScopeNode> Scopes = new Stack<ScopeNode>();
public readonly Stack<bool> CaptureDecisions = new Stack<bool>();
public int SampleCursor;
public int ThreadId;
}
public readonly struct LabelMetrics
{
public LabelMetrics(double inclusiveMs, double selfMs, uint calls, double minInclusiveMs, double maxInclusiveMs)
@@ -54,6 +73,40 @@ public static class Profiler
public int Samples { get; }
}
public readonly struct ThreadMetrics
{
public ThreadMetrics(double inclusiveMs, double selfMs, uint calls, bool overBudget)
{
InclusiveMs = inclusiveMs;
SelfMs = selfMs;
Calls = calls;
OverBudget = overBudget;
}
public double InclusiveMs { get; }
public double SelfMs { get; }
public uint Calls { get; }
public bool OverBudget { get; }
}
public readonly struct RollingThreadMetrics
{
public RollingThreadMetrics(double averageMs, double p95Ms, double maxMs, int samples, int budgetMisses)
{
AverageMs = averageMs;
P95Ms = p95Ms;
MaxMs = maxMs;
Samples = samples;
BudgetMisses = budgetMisses;
}
public double AverageMs { get; }
public double P95Ms { get; }
public double MaxMs { get; }
public int Samples { get; }
public int BudgetMisses { get; }
}
private sealed class RollingWindow
{
private readonly double[] values;
@@ -104,6 +157,61 @@ public static class Profiler
}
}
private sealed class RollingThreadWindow
{
private readonly double[] durations;
private readonly byte[] misses;
private int index;
private int count;
public RollingThreadWindow(int capacity)
{
int size = Math.Max(8, capacity);
durations = new double[size];
misses = new byte[size];
}
public void Add(double durationMs, bool budgetMiss)
{
durations[index] = durationMs;
misses[index] = budgetMiss ? (byte)1 : (byte)0;
index = (index + 1) % durations.Length;
if (count < durations.Length)
{
count++;
}
}
public RollingThreadMetrics Snapshot()
{
if (count == 0)
{
return default;
}
double sum = 0;
double max = double.MinValue;
int budgetMisses = 0;
double[] sorted = new double[count];
int start = (index - count + durations.Length) % durations.Length;
for (int i = 0; i < count; i++)
{
int at = (start + i) % durations.Length;
double value = durations[at];
sum += value;
max = Math.Max(max, value);
budgetMisses += misses[at];
sorted[i] = value;
}
Array.Sort(sorted);
int percentileIndex = (int)Math.Ceiling((count - 1) * 0.95d);
double p95 = sorted[Math.Clamp(percentileIndex, 0, count - 1)];
return new RollingThreadMetrics(sum / count, p95, max, count, budgetMisses);
}
}
public class Frame(uint frameCount)
{
public uint FrameCount { get; } = frameCount;
@@ -113,10 +221,14 @@ public static class Profiler
private readonly List<ScopeNode> rootNodes = new List<ScopeNode>(8);
private readonly object rootNodesLock = new object();
private readonly Dictionary<string, LabelMetrics> labelMetrics = new Dictionary<string, LabelMetrics>(128, StringComparer.Ordinal);
private readonly Dictionary<string, LabelMetrics> categoryMetrics = new Dictionary<string, LabelMetrics>(32, StringComparer.Ordinal);
private readonly Dictionary<int, ThreadMetrics> threadMetrics = new Dictionary<int, ThreadMetrics>(16);
public IReadOnlyList<ScopeNode> RootNodes => rootNodes;
public IReadOnlyDictionary<string, LabelMetrics> LabelMetrics => labelMetrics;
public IReadOnlyDictionary<string, LabelMetrics> CategoryMetrics => categoryMetrics;
public IReadOnlyDictionary<int, ThreadMetrics> ThreadMetrics => threadMetrics;
public long AllocatedBytesStart { get; } = GC.GetTotalAllocatedBytes(false);
public long AllocatedBytesEnd { get; private set; }
public long AllocatedBytesDelta { get; private set; }
@@ -168,13 +280,25 @@ public static class Profiler
private void BuildLabelMetrics()
{
labelMetrics.Clear();
categoryMetrics.Clear();
threadMetrics.Clear();
lock (rootNodesLock)
{
for (int i = 0; i < rootNodes.Count; i++)
{
AccumulateLabelMetrics(rootNodes[i]);
}
foreach (ScopeNode rootNode in rootNodes)
{
for (int i = 0; i < rootNode.Children.Count; i++)
{
AccumulateThreadMetrics(rootNode.ManagedThreadId, rootNode.Children[i]);
}
}
}
ApplyThreadBudgetFlags();
}
private void AccumulateLabelMetrics(ScopeNode node)
@@ -196,16 +320,69 @@ public static class Profiler
labelMetrics[node.Label] = new LabelMetrics(inclusiveMs, selfMs, 1, inclusiveMs, inclusiveMs);
}
if (categoryMetrics.TryGetValue(node.Category, out LabelMetrics categoryCurrent))
{
categoryMetrics[node.Category] = new LabelMetrics(
categoryCurrent.InclusiveMs + inclusiveMs,
categoryCurrent.SelfMs + selfMs,
categoryCurrent.Calls + 1,
Math.Min(categoryCurrent.MinInclusiveMs, inclusiveMs),
Math.Max(categoryCurrent.MaxInclusiveMs, inclusiveMs));
}
else
{
categoryMetrics[node.Category] = new LabelMetrics(inclusiveMs, selfMs, 1, inclusiveMs, inclusiveMs);
}
for (int i = 0; i < node.Children.Count; i++)
{
AccumulateLabelMetrics(node.Children[i]);
}
}
private void AccumulateThreadMetrics(int threadId, ScopeNode node)
{
double inclusiveMs = node.ElapsedMilliseconds();
double selfMs = node.SelfMilliseconds();
if (threadMetrics.TryGetValue(threadId, out ThreadMetrics current))
{
threadMetrics[threadId] = new ThreadMetrics(current.InclusiveMs + inclusiveMs, current.SelfMs + selfMs, current.Calls + 1, false);
}
else
{
threadMetrics[threadId] = new ThreadMetrics(inclusiveMs, selfMs, 1, false);
}
for (int i = 0; i < node.Children.Count; i++)
{
AccumulateThreadMetrics(threadId, node.Children[i]);
}
}
private void ApplyThreadBudgetFlags()
{
double perThreadBudget = Math.Max(0d, ThreadBudgetMilliseconds);
if (perThreadBudget <= 0d)
{
return;
}
int[] keys = threadMetrics.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
int key = keys[i];
ThreadMetrics metric = threadMetrics[key];
threadMetrics[key] = new ThreadMetrics(metric.InclusiveMs, metric.SelfMs, metric.Calls, metric.InclusiveMs > perThreadBudget);
}
}
}
public class ScopeNode
{
public string Label { get; private set; } = string.Empty;
public string Category { get; private set; } = DefaultCategory;
public ulong TagMask { get; private set; }
public long StartTime { get; private set; }
public long EndTime { get; private set; }
public int ManagedThreadId { get; private set; }
@@ -213,9 +390,11 @@ public static class Profiler
internal ScopeNode Parent { get; private set; }
internal long ChildrenDurationTicks { get; private set; }
internal void Reset(string label, int managedThreadId, ScopeNode parent)
internal void Reset(string label, string category, ulong tagMask, int managedThreadId, ScopeNode parent)
{
Label = label;
Category = string.IsNullOrWhiteSpace(category) ? DefaultCategory : category;
TagMask = tagMask;
ManagedThreadId = managedThreadId;
Parent = parent;
StartTime = Stopwatch.GetTimestamp();
@@ -251,9 +430,9 @@ public static class Profiler
}
// Add a child node (used for nested scopes)
internal ScopeNode AddChild(string label)
internal ScopeNode AddChild(string label, string category, ulong tagMask)
{
ScopeNode child = RentNode(label, ManagedThreadId, this);
ScopeNode child = RentNode(label, category, tagMask, ManagedThreadId, this);
Children.Add(child);
return child;
}
@@ -261,18 +440,23 @@ public static class Profiler
private const int maxFrames = 128;
private const int rollingWindowSize = 240;
private const string DefaultCategory = "General";
public static bool IsRecording { get; private set; } = true;
public static double FrameBudgetMilliseconds { get; set; } = 16.667;
public static double ThreadBudgetMilliseconds { get; set; } = 8.333;
public static CaptureMode Mode { get; set; } = CaptureMode.Instrumented;
public static int SamplingStride { get; set; } = 8;
// Store only the last x amount of frames in memory.
public static readonly BoundedQueue<Frame> Frames = new(maxFrames);
// Use ThreadLocal to store a stack of ScopeNodes per thread and enable tracking of thread-local values.
private static readonly ThreadLocal<Stack<ScopeNode>> threadLocalScopes = new ThreadLocal<Stack<ScopeNode>>(() => new Stack<ScopeNode>(), true);
private static readonly ThreadLocal<ThreadProfilerState> threadStates = new ThreadLocal<ThreadProfilerState>(() => new ThreadProfilerState(), true);
private static readonly ConcurrentDictionary<int, string> threadRootLabelCache = new ConcurrentDictionary<int, string>();
private static readonly ConcurrentBag<ScopeNode> nodePool = new ConcurrentBag<ScopeNode>();
private static readonly Dictionary<string, RollingWindow> rollingWindows = new Dictionary<string, RollingWindow>(256, StringComparer.Ordinal);
private static readonly Dictionary<int, RollingThreadWindow> rollingThreadWindows = new Dictionary<int, RollingThreadWindow>(16);
private static readonly object rollingWindowsLock = new object();
private static Frame currentFrame = null;
@@ -313,6 +497,20 @@ public static class Profiler
}
}
public static IReadOnlyDictionary<int, RollingThreadMetrics> GetRollingThreadMetricsSnapshot()
{
lock (rollingWindowsLock)
{
Dictionary<int, RollingThreadMetrics> snapshot = new Dictionary<int, RollingThreadMetrics>(rollingThreadWindows.Count);
foreach (KeyValuePair<int, RollingThreadWindow> pair in rollingThreadWindows)
{
snapshot[pair.Key] = pair.Value.Snapshot();
}
return snapshot;
}
}
[Conditional("PROFILING")]
public static void BeginFrame()
{
@@ -342,30 +540,49 @@ public static class Profiler
[Conditional("PROFILING")]
public static void BeginSample(string label)
{
BeginSample(label, DefaultCategory, 0);
}
[Conditional("PROFILING")]
public static void BeginSample(string label, string category, ulong tagMask = 0)
{
if (!IsRecording || currentFrame == null)
{
return;
}
Stack<ScopeNode> scopes = threadLocalScopes.Value; // Get the stack for the current thread
ThreadProfilerState state = threadStates.Value;
state.ThreadId = Environment.CurrentManagedThreadId;
bool parentCaptured = state.CaptureDecisions.Count > 0 && state.CaptureDecisions.Peek();
bool capture = parentCaptured || Mode == CaptureMode.Instrumented || ShouldSample(state);
state.CaptureDecisions.Push(capture);
if (!capture)
{
return;
}
Stack<ScopeNode> scopes = state.Scopes;
Frame frame = currentFrame;
if (frame == null)
{
state.CaptureDecisions.Pop();
return;
}
if (scopes.Count == 0)
{
// First scope for this thread (new root for this thread)
int threadId = Environment.CurrentManagedThreadId;
ScopeNode rootScopeNode = RentNode(GetThreadRootLabel(threadId), threadId, null);
int threadId = state.ThreadId;
ScopeNode rootScopeNode = RentNode(GetThreadRootLabel(threadId), DefaultCategory, 0, threadId, null);
scopes.Push(rootScopeNode);
frame.AddRootNode(rootScopeNode);
}
// Create a new child under the current top of the stack
ScopeNode newScope = scopes.Peek().AddChild(label);
ScopeNode newScope = scopes.Peek().AddChild(label, category, tagMask);
scopes.Push(newScope); // Push new scope to the thread's stack
}
@@ -378,7 +595,19 @@ public static class Profiler
return;
}
Stack<ScopeNode> scopes = threadLocalScopes.Value;
ThreadProfilerState state = threadStates.Value;
if (state.CaptureDecisions.Count == 0)
{
return;
}
bool captured = state.CaptureDecisions.Pop();
if (!captured)
{
return;
}
Stack<ScopeNode> scopes = state.Scopes;
if (scopes.Count > 1)
{
@@ -387,19 +616,26 @@ public static class Profiler
}
}
private static bool ShouldSample(ThreadProfilerState state)
{
int stride = Math.Max(1, SamplingStride);
state.SampleCursor++;
return state.SampleCursor % stride == 0;
}
private static string GetThreadRootLabel(int threadId)
{
return threadRootLabelCache.GetOrAdd(threadId, static id => $"Thread-{id}");
}
private static ScopeNode RentNode(string label, int managedThreadId, ScopeNode parent)
private static ScopeNode RentNode(string label, string category, ulong tagMask, int managedThreadId, ScopeNode parent)
{
if (!nodePool.TryTake(out ScopeNode node))
{
node = new ScopeNode();
}
node.Reset(label, managedThreadId, parent);
node.Reset(label, category, tagMask, managedThreadId, parent);
return node;
}
@@ -410,7 +646,7 @@ public static class Profiler
ReturnNodeTree(node.Children[i]);
}
node.Reset(string.Empty, 0, null);
node.Reset(string.Empty, DefaultCategory, 0, 0, null);
nodePool.Add(node);
}
@@ -422,8 +658,9 @@ public static class Profiler
return;
}
foreach (Stack<ScopeNode> scopes in threadLocalScopes.Values)
foreach (ThreadProfilerState state in threadStates.Values)
{
Stack<ScopeNode> scopes = state.Scopes;
while (scopes.Count > 0)
{
ScopeNode currentScope = scopes.Pop();
@@ -431,6 +668,7 @@ public static class Profiler
}
scopes.Clear();
state.CaptureDecisions.Clear();
}
frame.End(FrameBudgetMilliseconds);
@@ -444,6 +682,7 @@ public static class Profiler
}
UpdateRollingWindows(frame);
UpdateRollingThreadWindows(frame);
frameCount++;
currentFrame = null;
}
@@ -464,4 +703,21 @@ public static class Profiler
}
}
}
private static void UpdateRollingThreadWindows(Frame frame)
{
lock (rollingWindowsLock)
{
foreach (KeyValuePair<int, ThreadMetrics> pair in frame.ThreadMetrics)
{
if (!rollingThreadWindows.TryGetValue(pair.Key, out RollingThreadWindow window))
{
window = new RollingThreadWindow(rollingWindowSize);
rollingThreadWindows.Add(pair.Key, window);
}
window.Add(pair.Value.InclusiveMs, pair.Value.OverBudget);
}
}
}
}