Add thread metrics and category support to Profiler and visualizer

2026-08-05 11:47:21 +02:00
parent 2d4139fb2c
commit 83f77d1ebe
3 changed files with 350 additions and 18 deletions
@@ -14,6 +14,7 @@ namespace Nerfed.Editor.Systems
        private int selectedFrame = 0;
        private int previousSelectedFrame = -1;
        private IOrderedEnumerable<KeyValuePair<string, (double ms, double selfMs, uint calls, double avgMs, double p95Ms)>> orderedCombinedData = null;
+        private IOrderedEnumerable<KeyValuePair<int, Profiler.RollingThreadMetrics>> orderedThreadRollingData = null;
        private readonly ProfilerVisualizer.TimelineState timelineState = new ProfilerVisualizer.TimelineState();
        private readonly List<Profiler.Frame> frameSnapshot = new List<Profiler.Frame>(256);

@@ -67,6 +68,22 @@ namespace Nerfed.Editor.Systems
                timelineState.FollowLatest = true;
            }

+            ImGui.SameLine();
+            int mode = (int)Profiler.Mode;
+            ImGui.SetNextItemWidth(130f);
+            if (ImGui.Combo("Mode", ref mode, "Instrumented\0Sampled\0"))
+            {
+                Profiler.Mode = (Profiler.CaptureMode)mode;
+            }
+
+            ImGui.SameLine();
+            int stride = Profiler.SamplingStride;
+            ImGui.SetNextItemWidth(90f);
+            if (ImGui.SliderInt("Stride", ref stride, 1, 64))
+            {
+                Profiler.SamplingStride = stride;
+            }
+
            if (Profiler.IsRecording)
            {
                // Select last frame when recording to see latest frame data.
@@ -86,6 +103,7 @@ namespace Nerfed.Editor.Systems
            double s = 1000;
            ImGui.Text($"Frame: {frame.FrameCount} ({ms:0.000} ms | {(s / ms):0} fps)");
            ImGui.Text($"Budget: {frame.BudgetMilliseconds:0.00} ms ({(frame.OverBudget ? "over" : "within")})");
+            ImGui.Text($"Thread Budget: {Profiler.ThreadBudgetMilliseconds:0.00} ms | Capture: {Profiler.Mode}");
            ImGui.Text($"Alloc: {frame.AllocatedBytesDelta / 1024d:0.0} KB | GC: G0 {frame.Gen0CollectionsDelta}, G1 {frame.Gen1CollectionsDelta}, G2 {frame.Gen2CollectionsDelta}");
            ImGui.EndChild();

@@ -102,8 +120,11 @@ namespace Nerfed.Editor.Systems
            {
                previousSelectedFrame = selectedFrame;
                orderedCombinedData = CalculateCombinedData(frame);
+                orderedThreadRollingData = CalculateThreadRollingData();
            }

+            DrawThreadRolling(orderedThreadRollingData);
+
            DrawHierachy(frame);

            ImGui.SameLine();
@@ -122,12 +143,14 @@ namespace Nerfed.Editor.Systems

            ImGui.BeginChild("Hierachy", new Vector2(150, 0), ImGuiChildFlags.ResizeX);

-            if (ImGui.BeginTable("ProfilerData", 4, tableFlags, new Vector2(0, 0)))
+            if (ImGui.BeginTable("ProfilerData", 6, tableFlags, new Vector2(0, 0)))
            {
-                ImGui.TableSetupColumn("name", ImGuiTableColumnFlags.WidthStretch, 0.6f, 0);
-                ImGui.TableSetupColumn("thread", ImGuiTableColumnFlags.WidthStretch, 0.15f, 1);
-                ImGui.TableSetupColumn("ms", ImGuiTableColumnFlags.WidthStretch, 0.15f, 1);
-                ImGui.TableSetupColumn("self", ImGuiTableColumnFlags.WidthStretch, 0.15f, 2);
+                ImGui.TableSetupColumn("name", ImGuiTableColumnFlags.WidthStretch, 0.40f, 0);
+                ImGui.TableSetupColumn("category", ImGuiTableColumnFlags.WidthStretch, 0.15f, 1);
+                ImGui.TableSetupColumn("tags", ImGuiTableColumnFlags.WidthStretch, 0.10f, 2);
+                ImGui.TableSetupColumn("thread", ImGuiTableColumnFlags.WidthStretch, 0.10f, 3);
+                ImGui.TableSetupColumn("ms", ImGuiTableColumnFlags.WidthStretch, 0.10f, 4);
+                ImGui.TableSetupColumn("self", ImGuiTableColumnFlags.WidthStretch, 0.10f, 5);
                ImGui.TableSetupScrollFreeze(0, 1); // Make row always visible
                ImGui.TableHeadersRow();

@@ -158,6 +181,10 @@ namespace Nerfed.Editor.Systems
                isOpen = ImGui.TreeNodeEx(node.Label, treeNodeFlags);
            }

+            ImGui.TableNextColumn();
+            ImGui.Text($"{node.Category}");
+            ImGui.TableNextColumn();
+            ImGui.Text($"0x{node.TagMask:X}");
            ImGui.TableNextColumn();
            ImGui.Text($"{node.ManagedThreadId}");
            ImGui.TableNextColumn();
@@ -235,6 +262,53 @@ namespace Nerfed.Editor.Systems
            return combinedRecordData.OrderByDescending(x => x.Value.ms);
        }

+        private static IOrderedEnumerable<KeyValuePair<int, Profiler.RollingThreadMetrics>> CalculateThreadRollingData()
+        {
+            IReadOnlyDictionary<int, Profiler.RollingThreadMetrics> rollingData = Profiler.GetRollingThreadMetricsSnapshot();
+            return rollingData.OrderByDescending(x => x.Value.P95Ms);
+        }
+
+        private static void DrawThreadRolling(in IOrderedEnumerable<KeyValuePair<int, Profiler.RollingThreadMetrics>> orderedThreadRollingData)
+        {
+            if (orderedThreadRollingData == null)
+            {
+                return;
+            }
+
+            ImGui.BeginChild("ThreadRolling", new Vector2(0, 140), ImGuiChildFlags.Border);
+            if (ImGui.BeginTable("ProfilerThreadRollingData", 6, tableFlags, new Vector2(0, 0)))
+            {
+                ImGui.TableSetupColumn("thread", ImGuiTableColumnFlags.WidthStretch, 0.15f, 0);
+                ImGui.TableSetupColumn("avg", ImGuiTableColumnFlags.WidthStretch, 0.20f, 1);
+                ImGui.TableSetupColumn("p95", ImGuiTableColumnFlags.WidthStretch, 0.20f, 2);
+                ImGui.TableSetupColumn("max", ImGuiTableColumnFlags.WidthStretch, 0.20f, 3);
+                ImGui.TableSetupColumn("samples", ImGuiTableColumnFlags.WidthStretch, 0.15f, 4);
+                ImGui.TableSetupColumn("misses", ImGuiTableColumnFlags.WidthStretch, 0.15f, 5);
+                ImGui.TableHeadersRow();
+
+                foreach (KeyValuePair<int, Profiler.RollingThreadMetrics> metric in orderedThreadRollingData)
+                {
+                    ImGui.TableNextRow();
+                    ImGui.TableNextColumn();
+                    ImGui.Text($"T{metric.Key}");
+                    ImGui.TableNextColumn();
+                    ImGui.Text($"{metric.Value.AverageMs:0.000}");
+                    ImGui.TableNextColumn();
+                    ImGui.Text($"{metric.Value.P95Ms:0.000}");
+                    ImGui.TableNextColumn();
+                    ImGui.Text($"{metric.Value.MaxMs:0.000}");
+                    ImGui.TableNextColumn();
+                    ImGui.Text($"{metric.Value.Samples}");
+                    ImGui.TableNextColumn();
+                    ImGui.Text($"{metric.Value.BudgetMisses}");
+                }
+
+                ImGui.EndTable();
+            }
+
+            ImGui.EndChild();
+        }
+
        private static ProfilerVisualizer.TimelineRenderResult DrawFlameGraph(IReadOnlyList<Profiler.Frame> frames, ProfilerVisualizer.TimelineState timelineState)
        {
            if (frames == null || frames.Count == 0)
@@ -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,14 +280,26 @@ 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);
+            }
+        }
+    }
 }
@@ -352,6 +352,8 @@ public static class ProfilerVisualizer
        ImGui.BeginTooltip();
        ImGui.Text($"{hover.Node.Label}");
        ImGui.Separator();
+        ImGui.Text($"Category: {hover.Node.Category}");
+        ImGui.Text($"Tags: 0x{hover.Node.TagMask:X}");
        ImGui.Text($"Frame: {hover.Frame.FrameCount} (idx {hover.FrameIndex})");
        ImGui.Text($"Thread: {hover.Node.ManagedThreadId}");
        ImGui.Text($"Depth: {hover.Depth}");