private List <Measurement> RunAuto(long invokeCount, IterationMode iterationMode, int unrollFactor)
        {
            int    iterationCounter = 0;
            bool   isIdle           = iterationMode.IsIdle();
            double maxErrorRelative = isIdle ? MaxIdleStdErrRelative : maxStdErrRelative;

            while (true)
            {
                iterationCounter++;
                var measurement = RunIteration(iterationMode, iterationCounter, invokeCount, unrollFactor);
                measurements.Add(measurement);

                var    statistics  = MeasurementsStatistics.Calculate(measurements, removeOutliers);
                double actualError = statistics.StandardError;
                double maxError    = maxErrorRelative * statistics.Mean;

                if (iterationCounter >= MinIterationCount && actualError < maxError)
                {
                    break;
                }

                if (iterationCounter >= MaxIterationCount || (isIdle && iterationCounter >= MaxIdleIterationCount))
                {
                    break;
                }
            }
            if (!IsDiagnoserAttached)
            {
                WriteLine();
            }
            return(measurements);
        }
        private List <Measurement> RunAuto(long invokeCount, IterationMode iterationMode, int unrollFactor)
        {
            var measurements = measurementsPool.Next();
            var measurementsForStatistics = measurementsPool.Next();

            int    iterationCounter          = 0;
            bool   isIdle                    = iterationMode.IsIdle();
            double effectiveMaxRelativeError = isIdle ? MaxIdleRelativeError : maxRelativeError;

            while (true)
            {
                iterationCounter++;
                var measurement = RunIteration(iterationMode, iterationCounter, invokeCount, unrollFactor);
                measurements.Add(measurement);
                measurementsForStatistics.Add(measurement);

                var    statistics  = MeasurementsStatistics.Calculate(measurementsForStatistics, removeOutliers);
                double actualError = statistics.ConfidenceInterval.Margin;

                double maxError1 = effectiveMaxRelativeError * statistics.Mean;
                double maxError2 = maxAbsoluteError?.Nanoseconds ?? double.MaxValue;
                double maxError  = Math.Min(maxError1, maxError2);

                if (iterationCounter >= MinIterationCount && actualError < maxError)
                {
                    break;
                }

                if (iterationCounter >= MaxIterationCount || (isIdle && iterationCounter >= MaxIdleIterationCount))
                {
                    break;
                }
            }
            if (!IsDiagnoserAttached)
            {
                WriteLine();
            }
            return(measurements);
        }
Example #3
0
        private List <Measurement> RunAuto(long invokeCount, IterationMode iterationMode, int unrollFactor)
        {
            var measurements = new List <Measurement>(maxIterationCount);
            var measurementsForStatistics = new List <Measurement>(maxIterationCount);

            int    iterationCounter          = 0;
            bool   isOverhead                = iterationMode == IterationMode.Overhead;
            double effectiveMaxRelativeError = isOverhead ? MaxOverheadRelativeError : maxRelativeError;

            while (true)
            {
                iterationCounter++;
                var measurement = RunIteration(iterationMode, IterationStage.Actual, iterationCounter, invokeCount, unrollFactor);
                measurements.Add(measurement);
                measurementsForStatistics.Add(measurement);

                var    statistics  = MeasurementsStatistics.Calculate(measurementsForStatistics, outlierMode);
                double actualError = statistics.ConfidenceInterval.Margin;

                double maxError1 = effectiveMaxRelativeError * statistics.Mean;
                double maxError2 = maxAbsoluteError?.Nanoseconds ?? double.MaxValue;
                double maxError  = Math.Min(maxError1, maxError2);

                if (iterationCounter >= minIterationCount && actualError < maxError)
                {
                    break;
                }

                if (iterationCounter >= maxIterationCount || (isOverhead && iterationCounter >= MaxOverheadIterationCount))
                {
                    break;
                }
            }
            WriteLine();

            return(measurements);
        }