public void MeasureTimerOverhead_Stopwatch()
{
var minDiff = TimerMeasurer.MeasureOverhead(new StopwatchTimer());
// The call to Now itself takes time so precision is often many ticks e.g. 100
_output.WriteLine(minDiff.ToString());
}
public void MeasureMinOverhead_Random()
{
int min = 3;
var timer = new RandomStepTimer(17, 3, 42);
var m = TimerMeasurer.MeasureOverhead(timer);
Assert.Equal(min, m.Value);
}
public void MeasureMinOverhead_ConstantStep()
{
long step = 17;
var timer = new ConstantStepTimer()
{
Step = step
};
var m = TimerMeasurer.MeasureOverhead(timer);
Assert.Equal(step, m.Value);
}
private void MeasureTimerPrecision <TTimer>(TTimer timer)
where TTimer : ITimer
{
for (int i = 0; i < 10; i++)
{
TimerMeasurer.MeasurePrecision(timer, m_precisionMeasurements);
m_precisionMeasurements.Sort();
var min = m_precisionMeasurements.First();
var median = m_precisionMeasurements.Middle();
var max = m_precisionMeasurements.Last();
_output.WriteLine($"Precision {min} - {median} - {max} ticks");
}
}
public void MeasurePrecision_Random()
{
int min = 3;
int max = 42;
var timer = new RandomStepTimer(17, min, max);
var measurements = new Ticks[53];
TimerMeasurer.MeasurePrecision(timer, new ArraySegment <Ticks>(measurements));
foreach (var m in measurements)
{
Assert.InRange(m.Value, min, max);
}
}
public void MeasurePrecision_ConstantStep()
{
long step = 17;
var timer = new ConstantStepTimer()
{
Step = step
};
var measurements = new Ticks[53];
TimerMeasurer.MeasurePrecision(timer, new ArraySegment <Ticks>(measurements));
foreach (var m in measurements)
{
Assert.Equal(step, m.Value);
}
}
public QuickPerfMeasurements Run(Action <string> log)//<T>(this QuickPerfConfig<T> config)
{
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime;
Thread.CurrentThread.Priority = ThreadPriority.Highest;
var timer = new StopwatchTimer();
var timerSpec = timer.Spec;
Func <double, double> toNs = ticks => 1000 * 1000 * 1000 * ticks / (double)timerSpec.Frequency;
const int MinTicksExtraMultiplier = 40;
const int PrecisionDigits = 3;
int precisionMultiplier = 1;
for (int i = 0; i < PrecisionDigits; i++)
{
precisionMultiplier *= 10;
}
const int precisionMeasurementCount = 11;
const int measurementsPerParamPerMethodCount = 21;
// Measure timer precision
var precisionMeasurements = ReserveMeasurements(precisionMeasurementCount);
TimerMeasurer.MeasurePrecision(timer, precisionMeasurements);
precisionMeasurements.Sort();
var min = precisionMeasurements.First();
var median = precisionMeasurements.Middle();
var max = precisionMeasurements.Last();
log?.Invoke($"Precision {min} - {median} - {max} ticks");
var minTicksForMeasurement = median * precisionMultiplier * MinTicksExtraMultiplier;
foreach (var param in m_params)
{
// TODO: When to do
m_setup?.Invoke(param);
foreach (var namedMethod in m_methods)
{
var method = namedMethod.Method;
var methodAction = new DelegateAction(method);
var idleAction = new DelegateAction(IdleAction);
// Pre-JIT and warmup
var warmupIdleTime = Measurer.MeasureDiffOutsideLoop(timer, idleAction, 3);
var warmupTime = Measurer.MeasureDiffOutsideLoop(timer, methodAction, 3);
ForceAndWaitForGarbageCollection();
var iterationCount = FindIterationCount(timer, method, minTicksForMeasurement, log);
//ForceAndWaitForGarbageCollection();
var idleTime = Measurer.MeasureDiffOutsideLoop(timer, idleAction, iterationCount);
log?.Invoke($"Idle Ticks: {idleTime} ns: {toNs(idleTime / (double)iterationCount)}");
var measurements = ReserveMeasurements(measurementsPerParamPerMethodCount);
ForceAndWaitForGarbageCollection();
for (int i = 0; i < measurements.Count; i++)
{
//ForceAndWaitForGarbageCollection();
var methodTime = Measurer.MeasureDiffOutsideLoop(timer, methodAction, iterationCount);
measurements.Set(i, methodTime);
log?.Invoke($"{namedMethod.Name} Ticks: {methodTime} ns: {toNs(methodTime / (double)iterationCount)}");
}
}
}
return(new QuickPerfMeasurements());
}
