// Compile with: csc CRefTest.cs -doc:Results.xml
using System;
using UnityEngine;
using System.Collections.Generic;
using System.IO;
using UnityEngine.Profiling;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using UnityEngine.SceneManagement;
namespace MLAgents
{
[DataContract]
internal class TimerNode
{
static string s_Separator = ".";
static double s_TicksToSeconds = 1e-7; // 100 ns per tick
///
/// Full name of the node. This is the node's parents full name concatenated with this
/// node's name.
///
string m_FullName;
///
/// Child nodes, indexed by name.
///
[DataMember(Name = "children", Order = 999)]
Dictionary m_Children;
///
/// Gauge Nodes to measure arbitrary values.
///
[DataMember(Name = "gauges", EmitDefaultValue = false)]
Dictionary m_Gauges;
///
/// Custom sampler used to add timings to the profiler.
///
CustomSampler m_Sampler;
///
/// Number of total ticks elapsed for this node.
///
long m_TotalTicks;
///
/// If the node is currently running, the time (in ticks) when the node was started.
/// If the node is not running, is set to 0.
///
long m_TickStart;
///
/// Number of times the corresponding code block has been called.
///
[DataMember(Name = "count")]
int m_NumCalls;
///
/// The total recorded ticks for the timer node, plus the currently elapsed ticks
/// if the timer is still running (i.e. if m_TickStart is non-zero).
///
public long CurrentTicks
{
get
{
var currentTicks = m_TotalTicks;
if (m_TickStart != 0)
{
currentTicks += (DateTime.Now.Ticks - m_TickStart);
}
return currentTicks;
}
}
///
/// Total elapsed seconds.
///
[DataMember(Name = "total")]
public double TotalSeconds
{
get { return CurrentTicks * s_TicksToSeconds; }
set {} // Serialization needs this, but unused.
}
public Dictionary Gauges
{
get { return m_Gauges; }
}
///
/// Total seconds spent in this block, excluding it's children.
///
[DataMember(Name = "self")]
public double SelfSeconds
{
get
{
long totalChildTicks = 0;
if (m_Children != null)
{
foreach (var child in m_Children.Values)
{
totalChildTicks += child.m_TotalTicks;
}
}
var selfTicks = Mathf.Max(0, CurrentTicks - totalChildTicks);
return selfTicks * s_TicksToSeconds;
}
set {} // Serialization needs this, but unused.
}
public IReadOnlyDictionary Children
{
get { return m_Children; }
}
public int NumCalls
{
get { return m_NumCalls; }
}
public TimerNode(string name, bool isRoot = false)
{
m_FullName = name;
if (isRoot)
{
// The root node is considered always running. This means that when we output stats, it'll
// have a sensible value for total time (the running time since reset).
// The root node doesn't have a sampler since that could interfere with the profiler.
m_NumCalls = 1;
m_TickStart = DateTime.Now.Ticks;
m_Gauges = new Dictionary();
}
else
{
m_Sampler = CustomSampler.Create(m_FullName);
}
}
///
/// Start timing a block of code.
///
public void Begin()
{
m_Sampler?.Begin();
m_TickStart = DateTime.Now.Ticks;
}
///
/// Stop timing a block of code, and increment internal counts.
///
public void End(bool isRecording)
{
if (isRecording)
{
var elapsed = DateTime.Now.Ticks - m_TickStart;
m_TotalTicks += elapsed;
m_TickStart = 0;
m_NumCalls++;
}
// Note that samplers are always updated regardless of recording state, to ensure matching start and ends.
m_Sampler?.End();
}
///
/// Return a child node for the given name.
/// The children dictionary will be created if it does not already exist, and
/// a new Node will be created if it's not already in the dictionary.
/// Note that these allocations only happen once for a given timed block.
///
///
///
public TimerNode GetChild(string name)
{
// Lazily create the children dictionary.
if (m_Children == null)
{
m_Children = new Dictionary();
}
if (!m_Children.ContainsKey(name))
{
var childFullName = m_FullName + s_Separator + name;
var newChild = new TimerNode(childFullName);
m_Children[name] = newChild;
return newChild;
}
return m_Children[name];
}
///
/// Recursively form a string representing the current timer information.
///
///
///
///
public string DebugGetTimerString(string parentName = "", int level = 0)
{
var indent = new string(' ', 2 * level); // TODO generalize
var shortName = (level == 0) ? m_FullName : m_FullName.Replace(parentName + s_Separator, "");
string timerString;
if (level == 0)
{
timerString = $"{shortName}(root)\n";
}
else
{
timerString = $"{indent}{shortName}\t\traw={TotalSeconds} rawCount={m_NumCalls}\n";
}
// TODO use StringBuilder? might be overkill since this is only debugging code?
if (m_Children != null)
{
foreach (var c in m_Children.Values)
{
timerString += c.DebugGetTimerString(m_FullName, level + 1);
}
}
return timerString;
}
}
///
/// Tracks the most recent value of a metric. This is analogous to gauges in statsd.
///
[DataContract]
internal class GaugeNode
{
const float k_SmoothingFactor = .25f; // weight for exponential moving average.
[DataMember]
public float value;
[DataMember(Name = "min")]
public float minValue;
[DataMember(Name = "max")]
public float maxValue;
[DataMember(Name = "weightedAverage")]
public float weightedAverage;
[DataMember]
public uint count;
public GaugeNode(float value)
{
this.value = value;
weightedAverage = value;
minValue = value;
maxValue = value;
count = 1;
}
public void Update(float newValue)
{
minValue = Mathf.Min(minValue, newValue);
maxValue = Mathf.Max(maxValue, newValue);
// update exponential moving average
weightedAverage = (k_SmoothingFactor * newValue) + ((1f - k_SmoothingFactor) * weightedAverage);
value = newValue;
++count;
}
}
///
/// A "stack" of timers that allows for lightweight hierarchical profiling of long-running processes.
///
/// Example usage:
///
/// using(TimerStack.Instance.Scoped("foo"))
/// {
/// doSomeWork();
/// for (int i=0; i<5; i++)
/// {
/// using(myTimer.Scoped("bar"))
/// {
/// doSomeMoreWork();
/// }
/// }
/// }
///
///
///
///
/// This implements the Singleton pattern (solution 4) as described in
/// https://csharpindepth.com/articles/singleton
///
public class TimerStack : IDisposable
{
static readonly TimerStack k_Instance = new TimerStack();
Stack m_Stack;
TimerNode m_RootNode;
// Whether or not new timers and gauges can be added.
bool m_Recording = true;
// Explicit static constructor to tell C# compiler
// not to mark type as beforefieldinit
static TimerStack()
{
}
TimerStack()
{
Reset();
}
///
/// Resets the timer stack and the root node.
///
/// Name of the root node.
public void Reset(string name = "root")
{
m_Stack = new Stack();
m_RootNode = new TimerNode(name, true);
m_Stack.Push(m_RootNode);
}
///
/// The singleton instance.
///
public static TimerStack Instance
{
get { return k_Instance; }
}
internal TimerNode RootNode
{
get { return m_RootNode; }
}
///
/// Whether or not new timers and gauges can be added.
///
public bool Recording
{
get { return m_Recording; }
set { m_Recording = value; }
}
///
/// Updates the referenced gauge in the root node with the provided value.
///
/// The name of the Gauge to modify.
/// The value to update the Gauge with.
public void SetGauge(string name, float value)
{
if (!Recording)
{
return;
}
if (!float.IsNaN(value))
{
GaugeNode gauge;
if (m_RootNode.Gauges.TryGetValue(name, out gauge))
{
gauge.Update(value);
}
else
{
m_RootNode.Gauges[name] = new GaugeNode(value);
}
}
}
void Push(string name)
{
var current = m_Stack.Peek();
var next = current.GetChild(name);
m_Stack.Push(next);
next.Begin();
}
void Pop()
{
var node = m_Stack.Pop();
node.End(Recording);
}
///
/// Start a scoped timer. This should be used with the "using" statement.
///
///
///
public TimerStack Scoped(string name)
{
Push(name);
return this;
}
///
/// Closes the current scoped timer. This should never be called directly, only
/// at the end of a "using" statement.
/// Note that the instance is not actually disposed of; this is just to allow it to be used
/// conveniently with "using".
///
public void Dispose()
{
Pop();
}
///
/// Get a string representation of the timers.
/// Potentially slow so call sparingly.
///
///
internal string DebugGetTimerString()
{
return m_RootNode.DebugGetTimerString();
}
///
/// Save the timers in JSON format to the provided filename.
/// If the filename is null, a default one will be used.
///
///
public void SaveJsonTimers(string filename = null)
{
# if UNITY_EDITOR || UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX || UNITY_STANDALONE_LINUX
try
{
if (filename == null)
{
var activeScene = SceneManager.GetActiveScene();
var timerDir = Path.Combine(Application.dataPath, "ML-Agents", "Timers");
Directory.CreateDirectory(timerDir);
filename = Path.Combine(timerDir, $"{activeScene.name}_timers.json");
}
var fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
SaveJsonTimers(fs);
fs.Close();
}
catch (IOException)
{
// It's possible we don't have write access to the directory.
Debug.LogWarning($"Unable to save timers to file {filename}");
}
#endif
}
///
/// Write the timers in JSON format to the provided stream.
///
///
public void SaveJsonTimers(Stream stream)
{
var jsonSettings = new DataContractJsonSerializerSettings();
jsonSettings.UseSimpleDictionaryFormat = true;
var ser = new DataContractJsonSerializer(typeof(TimerNode), jsonSettings);
ser.WriteObject(stream, m_RootNode);
}
}
}