public static Ticks MeasureOverhead <TTimer>(TTimer timer) where TTimer : ITimer { // TODO: Clean this up, do we really need the whole warm-up thing... // refactor constants etc. // JIT var diffJit = Measurer.MeasureMinDiffInsideLoop(timer, new NoOpAction(), 10); // Warm-up var diffWarmUp = Measurer.MeasureMinDiffInsideLoop(timer, new NoOpAction(), 100); // Measure return(Measurer.MeasureMinDiffInsideLoop(timer, new NoOpAction(), 1000)); }
public static void MeasurePrecision <TTimer>(TTimer timer, ArraySegment <Ticks> measurements) where TTimer : ITimer { // JIT & Warm-up Measurer.MeasureNonZeroTickDifference(timer, measurements); // Measure Measurer.MeasureNonZeroTickDifference(timer, measurements); //// TODO: Make reliable, do proper monotonic search i.e. binary or something //// TODO: Clean this up, do we really need the whole warm-up thing... //// refactor constants etc. //var action = new DelegateAction(Delegates.NoOpAction); //// JIT/Warmup //var diffJit = Measurer.MeasureDiffOutsideLoop(timer, action, 100); //// Find minimal iterations before dependably getting a non-zero diff //// Increase or decrease iterations to get close to zero //bool hasBeenZero = false; //bool hasBeenNonZero = false; //int iterations = 100000; // Start guess //int iterationsZero = iterations; //int iterationsNonZero = iterations; //while (!hasBeenZero || !hasBeenNonZero) //{ // var diffNew = Measurer.MeasureDiffOutsideLoop(timer, action, iterations); // if (diffNew <= 0) // { // iterationsZero = iterations; // hasBeenZero = true; // iterations *= 2; // } // else // { // iterationsNonZero = iterations; // hasBeenNonZero = true; // iterations = Math.Max(1, iterations / 2); // } //} //// Find reliable non-zero iterations //const int nonZeroTrials = 10; //Ticks minDiff = 0; //iterationsNonZero = Math.Max(1, iterationsNonZero / 2); //while (minDiff <= 0) //{ // iterationsNonZero *= 2; // for (int i = 0; i < nonZeroTrials; i++) // { // minDiff = Math.Min(minDiff, Measurer.MeasureDiffOutsideLoop(timer, action, iterationsNonZero)); // } //} //// Now we have upper bound (always non-zero) //Ticks maxDiff = long.MaxValue; //iterationsZero = iterationsNonZero * 2; //while (maxDiff > 0 || iterationsNonZero == 0) //{ // iterationsZero /= 2; // for (int i = 0; i < nonZeroTrials; i++) // { // maxDiff = Math.Min(maxDiff, Measurer.MeasureDiffOutsideLoop(timer, action, iterationsZero)); // } //} //// Now we have lower bound (always zero) //// Keep moving the two closer... //var currentIterationsZero = iterationsZero; //var previousIterationsZero = 0; //var currentIterationsNonZero = iterationsNonZero; //var previousIterationsNonZero = 0; //// Then find minimal increase in iterations for this to yield dependable diff of diffs //Ticks diff = 0; //var iterations1 = 0; //var iterations2 = 1; //var previousIterations2 = iterations2; //int factor = 10; //while (diff == 0 || previousIterations2 != iterations2) //{ // var diff1 = Measurer.MeasureDiffOutsideLoop(timer, action, iterations1); // var diff2 = Measurer.MeasureDiffOutsideLoop(timer, action, iterations2); // diff = Math.Max(0, diff2 - diff1); // if (diff == 0) // { // previousIterations2 = iterations2; // iterations2 *= factor; // } // else // { // iterations2 = (iterations2 + previousIterations2) / 2; // factor = Math.Max(2, factor / 2); // } // // TODO: Handle searching backwards from diff to minimum diff //} //Debug.WriteLine(iterations2); //return diff; }