813 lines
27 KiB
C#
813 lines
27 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Diagnostics;
|
|
|
|
namespace Nerfed.Runtime;
|
|
|
|
public struct ProfilerScope : IDisposable
|
|
{
|
|
public ProfilerScope(string label)
|
|
{
|
|
Profiler.BeginSample(label);
|
|
}
|
|
|
|
public ProfilerScope(string label, string category, ulong tagMask = 0)
|
|
{
|
|
Profiler.BeginSample(label, category, tagMask);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Profiler.EndSample();
|
|
}
|
|
}
|
|
|
|
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, long allocatedBytes, long selfAllocatedBytes)
|
|
{
|
|
InclusiveMs = inclusiveMs;
|
|
SelfMs = selfMs;
|
|
Calls = calls;
|
|
MinInclusiveMs = minInclusiveMs;
|
|
MaxInclusiveMs = maxInclusiveMs;
|
|
AllocatedBytes = allocatedBytes;
|
|
SelfAllocatedBytes = selfAllocatedBytes;
|
|
}
|
|
|
|
public double InclusiveMs { get; }
|
|
public double SelfMs { get; }
|
|
public uint Calls { get; }
|
|
public double MinInclusiveMs { get; }
|
|
public double MaxInclusiveMs { get; }
|
|
public long AllocatedBytes { get; }
|
|
public long SelfAllocatedBytes { get; }
|
|
}
|
|
|
|
public readonly struct RollingLabelMetrics
|
|
{
|
|
public RollingLabelMetrics(double averageMs, double minMs, double maxMs, double p95Ms, int samples)
|
|
{
|
|
AverageMs = averageMs;
|
|
MinMs = minMs;
|
|
MaxMs = maxMs;
|
|
P95Ms = p95Ms;
|
|
Samples = samples;
|
|
}
|
|
|
|
public double AverageMs { get; }
|
|
public double MinMs { get; }
|
|
public double MaxMs { get; }
|
|
public double P95Ms { get; }
|
|
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;
|
|
private readonly double[] sortBuffer; // pre-allocated; avoids per-snapshot heap allocation
|
|
private int index;
|
|
private int count;
|
|
|
|
public RollingWindow(int capacity)
|
|
{
|
|
int size = Math.Max(8, capacity);
|
|
values = new double[size];
|
|
sortBuffer = new double[size];
|
|
}
|
|
|
|
public void Add(double value)
|
|
{
|
|
values[index] = value;
|
|
index = (index + 1) % values.Length;
|
|
if (count < values.Length)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
public RollingLabelMetrics Snapshot()
|
|
{
|
|
if (count == 0)
|
|
{
|
|
return default;
|
|
}
|
|
|
|
double sum = 0;
|
|
double min = double.MaxValue;
|
|
double max = double.MinValue;
|
|
|
|
int start = (index - count + values.Length) % values.Length;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
double value = values[(start + i) % values.Length];
|
|
sortBuffer[i] = value;
|
|
sum += value;
|
|
min = Math.Min(min, value);
|
|
max = Math.Max(max, value);
|
|
}
|
|
|
|
Array.Sort(sortBuffer, 0, count);
|
|
int percentileIndex = (int)Math.Ceiling((count - 1) * 0.95d);
|
|
double p95 = sortBuffer[Math.Clamp(percentileIndex, 0, count - 1)];
|
|
return new RollingLabelMetrics(sum / count, min, max, p95, count);
|
|
}
|
|
}
|
|
|
|
private sealed class RollingThreadWindow
|
|
{
|
|
private readonly double[] durations;
|
|
private readonly double[] sortBuffer; // pre-allocated; avoids per-snapshot heap allocation
|
|
private readonly byte[] misses;
|
|
private int index;
|
|
private int count;
|
|
|
|
public RollingThreadWindow(int capacity)
|
|
{
|
|
int size = Math.Max(8, capacity);
|
|
durations = new double[size];
|
|
sortBuffer = 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;
|
|
|
|
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];
|
|
sortBuffer[i] = value;
|
|
}
|
|
|
|
Array.Sort(sortBuffer, 0, count);
|
|
int percentileIndex = (int)Math.Ceiling((count - 1) * 0.95d);
|
|
double p95 = sortBuffer[Math.Clamp(percentileIndex, 0, count - 1)];
|
|
return new RollingThreadMetrics(sum / count, p95, max, count, budgetMisses);
|
|
}
|
|
}
|
|
|
|
public class Frame
|
|
{
|
|
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);
|
|
private readonly List<int> knownThreadIds = new List<int>(16); // avoids Keys.ToArray() in ApplyThreadBudgetFlags
|
|
|
|
public uint FrameCount { get; private set; }
|
|
public long StartTime { get; private set; }
|
|
public long EndTime { get; private set; }
|
|
|
|
public IReadOnlyList<ScopeNode> RootNodes => rootNodes;
|
|
public IReadOnlyDictionary<string, LabelMetrics> LabelMetrics => labelMetrics;
|
|
public IReadOnlyDictionary<string, LabelMetrics> CategoryMetrics => categoryMetrics;
|
|
public IReadOnlyDictionary<int, ThreadMetrics> ThreadMetrics => threadMetrics;
|
|
|
|
// Return concrete types so callers can use the struct enumerator and avoid boxing.
|
|
internal Dictionary<string, LabelMetrics> LabelMetricsRaw => labelMetrics;
|
|
internal Dictionary<int, ThreadMetrics> ThreadMetricsRaw => threadMetrics;
|
|
|
|
public long AllocatedBytesStart { get; private set; }
|
|
public long AllocatedBytesEnd { get; private set; }
|
|
public long AllocatedBytesDelta { get; private set; }
|
|
public int Gen0CollectionsStart { get; private set; }
|
|
public int Gen1CollectionsStart { get; private set; }
|
|
public int Gen2CollectionsStart { get; private set; }
|
|
public int Gen0CollectionsEnd { get; private set; }
|
|
public int Gen1CollectionsEnd { get; private set; }
|
|
public int Gen2CollectionsEnd { get; private set; }
|
|
public int Gen0CollectionsDelta { get; private set; }
|
|
public int Gen1CollectionsDelta { get; private set; }
|
|
public int Gen2CollectionsDelta { get; private set; }
|
|
public bool OverBudget { get; private set; }
|
|
public double BudgetMilliseconds { get; private set; }
|
|
|
|
internal void Reset(uint frameCount)
|
|
{
|
|
FrameCount = frameCount;
|
|
StartTime = Stopwatch.GetTimestamp();
|
|
EndTime = 0;
|
|
OverBudget = false;
|
|
BudgetMilliseconds = 0;
|
|
AllocatedBytesStart = GC.GetTotalAllocatedBytes(false);
|
|
AllocatedBytesEnd = 0;
|
|
AllocatedBytesDelta = 0;
|
|
Gen0CollectionsStart = GC.CollectionCount(0);
|
|
Gen1CollectionsStart = GC.CollectionCount(1);
|
|
Gen2CollectionsStart = GC.CollectionCount(2);
|
|
Gen0CollectionsEnd = 0;
|
|
Gen1CollectionsEnd = 0;
|
|
Gen2CollectionsEnd = 0;
|
|
Gen0CollectionsDelta = 0;
|
|
Gen1CollectionsDelta = 0;
|
|
Gen2CollectionsDelta = 0;
|
|
lock (rootNodesLock)
|
|
{
|
|
rootNodes.Clear();
|
|
}
|
|
}
|
|
|
|
internal void AddRootNode(ScopeNode rootNode)
|
|
{
|
|
lock (rootNodesLock)
|
|
{
|
|
rootNodes.Add(rootNode);
|
|
}
|
|
}
|
|
|
|
internal void End(double budgetMilliseconds)
|
|
{
|
|
EndTime = Stopwatch.GetTimestamp();
|
|
BudgetMilliseconds = budgetMilliseconds;
|
|
OverBudget = budgetMilliseconds > 0 && ElapsedMilliseconds() > budgetMilliseconds;
|
|
|
|
AllocatedBytesEnd = GC.GetTotalAllocatedBytes(false);
|
|
AllocatedBytesDelta = AllocatedBytesEnd - AllocatedBytesStart;
|
|
|
|
Gen0CollectionsEnd = GC.CollectionCount(0);
|
|
Gen1CollectionsEnd = GC.CollectionCount(1);
|
|
Gen2CollectionsEnd = GC.CollectionCount(2);
|
|
Gen0CollectionsDelta = Gen0CollectionsEnd - Gen0CollectionsStart;
|
|
Gen1CollectionsDelta = Gen1CollectionsEnd - Gen1CollectionsStart;
|
|
Gen2CollectionsDelta = Gen2CollectionsEnd - Gen2CollectionsStart;
|
|
|
|
BuildLabelMetrics();
|
|
}
|
|
|
|
public double ElapsedMilliseconds()
|
|
{
|
|
long elapsedTicks = EndTime - StartTime;
|
|
return ((double)(elapsedTicks * 1000)) / Stopwatch.Frequency;
|
|
}
|
|
|
|
private void BuildLabelMetrics()
|
|
{
|
|
labelMetrics.Clear();
|
|
categoryMetrics.Clear();
|
|
threadMetrics.Clear();
|
|
knownThreadIds.Clear();
|
|
lock (rootNodesLock)
|
|
{
|
|
for (int i = 0; i < rootNodes.Count; i++)
|
|
{
|
|
AccumulateLabelMetrics(rootNodes[i]);
|
|
}
|
|
|
|
for (int i = 0; i < rootNodes.Count; i++)
|
|
{
|
|
ScopeNode rootNode = rootNodes[i];
|
|
for (int j = 0; j < rootNode.Children.Count; j++)
|
|
{
|
|
AccumulateThreadMetrics(rootNode.ManagedThreadId, rootNode.Children[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
ApplyThreadBudgetFlags();
|
|
}
|
|
|
|
private void AccumulateLabelMetrics(ScopeNode node)
|
|
{
|
|
double inclusiveMs = node.ElapsedMilliseconds();
|
|
double selfMs = node.SelfMilliseconds();
|
|
long allocBytes = node.AllocatedBytes;
|
|
long selfAllocBytes = node.SelfAllocatedBytes();
|
|
|
|
if (labelMetrics.TryGetValue(node.Label, out LabelMetrics current))
|
|
{
|
|
labelMetrics[node.Label] = new LabelMetrics(
|
|
current.InclusiveMs + inclusiveMs,
|
|
current.SelfMs + selfMs,
|
|
current.Calls + 1,
|
|
Math.Min(current.MinInclusiveMs, inclusiveMs),
|
|
Math.Max(current.MaxInclusiveMs, inclusiveMs),
|
|
current.AllocatedBytes + allocBytes,
|
|
current.SelfAllocatedBytes + selfAllocBytes);
|
|
}
|
|
else
|
|
{
|
|
labelMetrics[node.Label] = new LabelMetrics(inclusiveMs, selfMs, 1, inclusiveMs, inclusiveMs, allocBytes, selfAllocBytes);
|
|
}
|
|
|
|
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),
|
|
categoryCurrent.AllocatedBytes + allocBytes,
|
|
categoryCurrent.SelfAllocatedBytes + selfAllocBytes);
|
|
}
|
|
else
|
|
{
|
|
categoryMetrics[node.Category] = new LabelMetrics(inclusiveMs, selfMs, 1, inclusiveMs, inclusiveMs, allocBytes, selfAllocBytes);
|
|
}
|
|
|
|
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);
|
|
knownThreadIds.Add(threadId);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// knownThreadIds avoids Keys.ToArray() allocation
|
|
for (int i = 0; i < knownThreadIds.Count; i++)
|
|
{
|
|
int key = knownThreadIds[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; }
|
|
public List<ScopeNode> Children { get; } = new List<ScopeNode>();
|
|
public long AllocatedBytes { get; private set; }
|
|
public long ProfilerSetupBytes { get; private set; }
|
|
internal ScopeNode Parent { get; private set; }
|
|
internal long ChildrenDurationTicks { get; private set; }
|
|
internal long ChildrenAllocatedBytes { get; private set; }
|
|
private long allocatedBytesAtStart;
|
|
|
|
internal void Reset(string label, string category, ulong tagMask, int managedThreadId, ScopeNode parent)
|
|
{
|
|
Label = label;
|
|
Category = string.IsNullOrEmpty(category) ? DefaultCategory : category;
|
|
TagMask = tagMask;
|
|
ManagedThreadId = managedThreadId;
|
|
Parent = parent;
|
|
StartTime = Stopwatch.GetTimestamp();
|
|
EndTime = 0;
|
|
ChildrenDurationTicks = 0;
|
|
ChildrenAllocatedBytes = 0;
|
|
AllocatedBytes = 0;
|
|
ProfilerSetupBytes = 0;
|
|
Children.Clear();
|
|
allocatedBytesAtStart = GC.GetAllocatedBytesForCurrentThread();
|
|
}
|
|
|
|
internal void End()
|
|
{
|
|
if (EndTime != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
EndTime = Stopwatch.GetTimestamp();
|
|
if (Parent != null)
|
|
{
|
|
// Root nodes are ended from FinalizeCurrentFrame on the main thread, so their
|
|
// GC counter would be from the wrong thread. Only track alloc on non-root nodes.
|
|
AllocatedBytes = Math.Max(0, GC.GetAllocatedBytesForCurrentThread() - allocatedBytesAtStart);
|
|
Parent.ChildrenDurationTicks += Math.Max(0, EndTime - StartTime);
|
|
Parent.ChildrenAllocatedBytes += AllocatedBytes;
|
|
}
|
|
}
|
|
|
|
public double ElapsedMilliseconds()
|
|
{
|
|
return ((double)(Math.Max(0, EndTime - StartTime))) * 1000 / Stopwatch.Frequency;
|
|
}
|
|
|
|
public double SelfMilliseconds()
|
|
{
|
|
long elapsedTicks = Math.Max(0, EndTime - StartTime);
|
|
long selfTicks = Math.Max(0, elapsedTicks - ChildrenDurationTicks);
|
|
return ((double)selfTicks) * 1000 / Stopwatch.Frequency;
|
|
}
|
|
|
|
public long SelfAllocatedBytes()
|
|
{
|
|
return Math.Max(0, AllocatedBytes - ChildrenAllocatedBytes);
|
|
}
|
|
|
|
// Called after all profiler setup (Children.Add + scopes.Push) to measure overhead within this scope's window.
|
|
internal void NoteSetupOverhead()
|
|
{
|
|
ProfilerSetupBytes = Math.Max(0, GC.GetAllocatedBytesForCurrentThread() - allocatedBytesAtStart);
|
|
}
|
|
|
|
internal ScopeNode AddChild(string label, string category, ulong tagMask)
|
|
{
|
|
ScopeNode child = RentNode(label, category, tagMask, ManagedThreadId, this);
|
|
Children.Add(child);
|
|
return child;
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
public static readonly BoundedQueue<Frame> Frames = new(maxFrames);
|
|
|
|
// trackAllValues=false; registeredThreadStates avoids ThreadLocal.Values allocating a ReadOnlyCollection each call
|
|
private static readonly ThreadLocal<ThreadProfilerState> threadStates =
|
|
new ThreadLocal<ThreadProfilerState>(() =>
|
|
{
|
|
ThreadProfilerState state = new ThreadProfilerState();
|
|
lock (registeredThreadStatesLock)
|
|
{
|
|
registeredThreadStates.Add(state);
|
|
}
|
|
|
|
return state;
|
|
});
|
|
|
|
private static readonly List<ThreadProfilerState> registeredThreadStates = new List<ThreadProfilerState>(8);
|
|
private static readonly object registeredThreadStatesLock = new object();
|
|
|
|
private static readonly ConcurrentDictionary<int, string> threadRootLabelCache = new ConcurrentDictionary<int, string>();
|
|
private static readonly ConcurrentBag<ScopeNode> nodePool = new ConcurrentBag<ScopeNode>();
|
|
private static readonly ConcurrentBag<Frame> framePool = new ConcurrentBag<Frame>(); // pooled; avoids per-frame Frame allocation
|
|
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;
|
|
private static uint frameCount = 0;
|
|
|
|
public static void SetActive(bool isRecording)
|
|
{
|
|
if (IsRecording && !isRecording)
|
|
{
|
|
FinalizeCurrentFrame();
|
|
}
|
|
|
|
IsRecording = isRecording;
|
|
}
|
|
|
|
public static int CopyFramesTo(List<Frame> destination)
|
|
{
|
|
return Frames.CopyTo(destination);
|
|
}
|
|
|
|
public static IReadOnlyDictionary<string, RollingLabelMetrics> GetRollingLabelMetricsSnapshot()
|
|
{
|
|
lock (rollingWindowsLock)
|
|
{
|
|
Dictionary<string, RollingLabelMetrics> snapshot = new Dictionary<string, RollingLabelMetrics>(rollingWindows.Count, StringComparer.Ordinal);
|
|
foreach (KeyValuePair<string, RollingWindow> pair in rollingWindows)
|
|
{
|
|
snapshot[pair.Key] = pair.Value.Snapshot();
|
|
}
|
|
|
|
return snapshot;
|
|
}
|
|
}
|
|
|
|
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()
|
|
{
|
|
if (!IsRecording)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (currentFrame != null)
|
|
{
|
|
FinalizeCurrentFrame();
|
|
}
|
|
|
|
currentFrame = RentFrame(frameCount);
|
|
}
|
|
|
|
[Conditional("PROFILING")]
|
|
public static void EndFrame()
|
|
{
|
|
if (!IsRecording)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FinalizeCurrentFrame();
|
|
}
|
|
|
|
[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;
|
|
}
|
|
|
|
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)
|
|
{
|
|
int threadId = state.ThreadId;
|
|
ScopeNode rootScopeNode = RentNode(GetThreadRootLabel(threadId), DefaultCategory, 0, threadId, null);
|
|
scopes.Push(rootScopeNode);
|
|
frame.AddRootNode(rootScopeNode);
|
|
}
|
|
|
|
ScopeNode newScope = scopes.Peek().AddChild(label, category, tagMask);
|
|
scopes.Push(newScope);
|
|
newScope.NoteSetupOverhead();
|
|
}
|
|
|
|
[Conditional("PROFILING")]
|
|
public static void EndSample()
|
|
{
|
|
if (!IsRecording || currentFrame == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
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)
|
|
{
|
|
ScopeNode currentScope = scopes.Pop();
|
|
currentScope.End();
|
|
}
|
|
}
|
|
|
|
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 Frame RentFrame(uint count)
|
|
{
|
|
if (!framePool.TryTake(out Frame frame))
|
|
{
|
|
frame = new Frame();
|
|
}
|
|
|
|
frame.Reset(count);
|
|
return frame;
|
|
}
|
|
|
|
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, category, tagMask, managedThreadId, parent);
|
|
return node;
|
|
}
|
|
|
|
private static void ReturnNodeTree(ScopeNode node)
|
|
{
|
|
for (int i = 0; i < node.Children.Count; i++)
|
|
{
|
|
ReturnNodeTree(node.Children[i]);
|
|
}
|
|
|
|
node.Reset(string.Empty, DefaultCategory, 0, 0, null);
|
|
nodePool.Add(node);
|
|
}
|
|
|
|
private static void FinalizeCurrentFrame()
|
|
{
|
|
Frame frame = currentFrame;
|
|
if (frame == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lock (registeredThreadStatesLock)
|
|
{
|
|
for (int i = 0; i < registeredThreadStates.Count; i++)
|
|
{
|
|
ThreadProfilerState state = registeredThreadStates[i];
|
|
Stack<ScopeNode> scopes = state.Scopes;
|
|
while (scopes.Count > 0)
|
|
{
|
|
scopes.Pop().End();
|
|
}
|
|
|
|
state.CaptureDecisions.Clear();
|
|
}
|
|
}
|
|
|
|
frame.End(FrameBudgetMilliseconds);
|
|
|
|
if (Frames.Enqueue(frame, out Frame evictedFrame))
|
|
{
|
|
for (int i = 0; i < evictedFrame.RootNodes.Count; i++)
|
|
{
|
|
ReturnNodeTree(evictedFrame.RootNodes[i]);
|
|
}
|
|
|
|
framePool.Add(evictedFrame);
|
|
}
|
|
|
|
UpdateRollingWindows(frame);
|
|
UpdateRollingThreadWindows(frame);
|
|
frameCount++;
|
|
currentFrame = null;
|
|
}
|
|
|
|
private static void UpdateRollingWindows(Frame frame)
|
|
{
|
|
lock (rollingWindowsLock)
|
|
{
|
|
foreach (KeyValuePair<string, LabelMetrics> pair in frame.LabelMetricsRaw)
|
|
{
|
|
if (!rollingWindows.TryGetValue(pair.Key, out RollingWindow window))
|
|
{
|
|
window = new RollingWindow(rollingWindowSize);
|
|
rollingWindows.Add(pair.Key, window);
|
|
}
|
|
|
|
window.Add(pair.Value.InclusiveMs);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void UpdateRollingThreadWindows(Frame frame)
|
|
{
|
|
lock (rollingWindowsLock)
|
|
{
|
|
foreach (KeyValuePair<int, ThreadMetrics> pair in frame.ThreadMetricsRaw)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|