public double[] GetActualOutliers(OutlierMode outlierMode)
{
switch (outlierMode)
{
#pragma warning disable 618
case OutlierMode.None:
case OutlierMode.DontRemove:
return(Array.Empty <double>());
case OutlierMode.OnlyUpper:
case OutlierMode.RemoveUpper:
return(UpperOutliers);
case OutlierMode.OnlyLower:
case OutlierMode.RemoveLower:
return(LowerOutliers);
case OutlierMode.All:
case OutlierMode.RemoveAll:
return(AllOutliers);
#pragma warning restore 618
default:
throw new ArgumentOutOfRangeException(nameof(outlierMode), outlierMode, null);
}
}
private static bool IsOutlier(OutlierMode outlierMode, double value, double lowerFence, double upperFence)
{
switch (outlierMode)
{
#pragma warning disable 618
case OutlierMode.None:
case OutlierMode.DontRemove:
return(false);
case OutlierMode.OnlyUpper:
case OutlierMode.RemoveUpper:
return(value > upperFence);
case OutlierMode.OnlyLower:
case OutlierMode.RemoveLower:
return(value < lowerFence);
case OutlierMode.All:
case OutlierMode.RemoveAll:
return(value < lowerFence || value > upperFence);
#pragma warning restore 618
default:
throw new ArgumentOutOfRangeException(nameof(outlierMode), outlierMode, null);
}
}
public bool IsActualOutlier(double value, OutlierMode outlierMode)
{
switch (outlierMode)
{
#pragma warning disable 618
case OutlierMode.None:
case OutlierMode.DontRemove:
return(false);
case OutlierMode.OnlyUpper:
case OutlierMode.RemoveUpper:
return(IsUpperOutlier(value));
case OutlierMode.OnlyLower:
case OutlierMode.RemoveLower:
return(IsLowerOutlier(value));
case OutlierMode.All:
case OutlierMode.RemoveAll:
return(IsOutlier(value));
#pragma warning restore 618
default:
throw new ArgumentOutOfRangeException(nameof(outlierMode), outlierMode, null);
}
}
public RunResults(
[CanBeNull] IReadOnlyList <Measurement> idle, [NotNull] IReadOnlyList <Measurement> main, OutlierMode outlierMode, GcStats gcStats)
{
this.outlierMode = outlierMode;
Idle = idle;
Main = main;
GCStats = gcStats;
}
public EngineActualStage(IEngine engine) : base(engine)
{
targetCount = engine.TargetJob.ResolveValueAsNullable(RunMode.IterationCountCharacteristic);
maxRelativeError = engine.TargetJob.ResolveValue(AccuracyMode.MaxRelativeErrorCharacteristic, engine.Resolver);
maxAbsoluteError = engine.TargetJob.ResolveValueAsNullable(AccuracyMode.MaxAbsoluteErrorCharacteristic);
outlierMode = engine.TargetJob.ResolveValue(AccuracyMode.OutlierModeCharacteristic, engine.Resolver);
minIterationCount = engine.TargetJob.ResolveValue(RunMode.MinIterationCountCharacteristic, engine.Resolver);
maxIterationCount = engine.TargetJob.ResolveValue(RunMode.MaxIterationCountCharacteristic, engine.Resolver);
}
public RunResults([CanBeNull] IReadOnlyList <Measurement> overhead,
[NotNull] IReadOnlyList <Measurement> workload,
OutlierMode outlierMode,
GcStats gcStats,
Encoding encoding)
{
this.outlierMode = outlierMode;
this.encoding = encoding;
Overhead = overhead;
Workload = workload;
GCStats = gcStats;
}
public RunResults([CanBeNull] IReadOnlyList <Measurement> overhead,
[NotNull] IReadOnlyList <Measurement> workload,
OutlierMode outlierMode,
GcStats gcStats,
ThreadingStats threadingStats)
{
this.outlierMode = outlierMode;
Overhead = overhead;
Workload = workload;
GCStats = gcStats;
ThreadingStats = threadingStats;
}
private static void SumWithoutOutliers(OutlierMode outlierMode, List <Measurement> measurements,
double lowerFence, double upperFence, out double sum, out int n)
{
sum = 0;
n = 0;
for (int i = 0; i < measurements.Count; i++)
{
if (!IsOutlier(outlierMode, measurements[i].Nanoseconds, lowerFence, upperFence))
{
sum += measurements[i].Nanoseconds;
++n;
}
}
}
private static void SumWithoutOutliers(OutlierMode outlierMode, List <Measurement> measurements,
double lowerFence, double upperFence, out double sum, out int n)
{
sum = 0;
n = 0;
foreach (var m in measurements)
{
if (!IsOutlier(outlierMode, m.Nanoseconds, lowerFence, upperFence))
{
sum += m.Nanoseconds;
++n;
}
}
}
private static double VarianceWithoutOutliers(OutlierMode outlierMode, List <Measurement> measurements, int n, double mean, double lowerFence, double upperFence)
{
if (n == 1)
{
return(0);
}
double variance = 0;
foreach (var m in measurements)
{
if (!IsOutlier(outlierMode, m.Nanoseconds, lowerFence, upperFence))
{
variance += (m.Nanoseconds - mean) * (m.Nanoseconds - mean) / (n - 1);
}
}
return(variance);
}
private static bool IsOutlier(OutlierMode outlierMode, double value, double lowerFence, double upperFence)
{
switch (outlierMode)
{
case OutlierMode.DontRemove:
return(false);
case OutlierMode.RemoveUpper:
return(value > upperFence);
case OutlierMode.RemoveLower:
return(value < lowerFence);
case OutlierMode.RemoveAll:
return(value < lowerFence || value > upperFence);
default:
throw new ArgumentOutOfRangeException(nameof(outlierMode), outlierMode, null);
}
}
public double[] GetActualOutliers(OutlierMode outlierMode)
{
switch (outlierMode)
{
case OutlierMode.None:
return(Array.Empty <double>());
case OutlierMode.OnlyUpper:
return(UpperOutliers);
case OutlierMode.OnlyLower:
return(LowerOutliers);
case OutlierMode.All:
return(AllOutliers);
default:
throw new ArgumentOutOfRangeException(nameof(outlierMode), outlierMode, null);
}
}
public bool IsActualOutlier(double value, OutlierMode outlierMode)
{
switch (outlierMode)
{
case OutlierMode.None:
return(false);
case OutlierMode.OnlyUpper:
return(IsUpperOutlier(value));
case OutlierMode.OnlyLower:
return(IsLowerOutlier(value));
case OutlierMode.All:
return(IsOutlier(value));
default:
throw new ArgumentOutOfRangeException(nameof(outlierMode), outlierMode, null);
}
}
public MemoryRandomizationAttribute(bool enable = true, OutlierMode outlierMode = OutlierMode.DontRemove)
: base(Job.Default.WithMemoryRandomization(enable).WithOutlierMode(outlierMode))
{
}
private static void CheckResults(int expectedResultCount, List <Measurement> measurements, OutlierMode outlierMode)
{
Assert.Equal(expectedResultCount, new RunResults(null, measurements, outlierMode, default, default).GetMeasurements().Count());
public IReadOnlyList <double> ApplyOutlierMode(IReadOnlyList <double> values, OutlierMode mode)
{
switch (mode)
{
case OutlierMode.DontRemove:
return(values);
case OutlierMode.RemoveUpper:
return(WithoutUpperOutliers(values));
case OutlierMode.RemoveLower:
return(WithoutLowerOutliers(values));
case OutlierMode.RemoveAll:
return(WithoutAllOutliers(values));
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
}
public OutliersAttribute(OutlierMode outlierMode) : base(Job.Default.WithOutlierMode(outlierMode))
{
}
public static MeasurementsStatistics Calculate(List <Measurement> measurements, OutlierMode outlierMode)
{
int n = measurements.Count;
if (n == 0)
{
throw new InvalidOperationException("StatSummary: Sequence contains no elements");
}
double sum = Sum(measurements);
double mean = sum / n;
double variance = Variance(measurements, n, mean);
double standardDeviation = Math.Sqrt(variance);
double standardError = standardDeviation / Math.Sqrt(n);
var confidenceInterval = new ConfidenceInterval(mean, standardError, n);
if (outlierMode == OutlierMode.DontRemove) // most simple scenario is done without allocations! but this is not the default case
{
return(new MeasurementsStatistics(standardError, mean, confidenceInterval));
}
measurements.Sort(); // sort in place
double q1, q3;
if (n == 1)
{
q1 = q3 = measurements[0].Nanoseconds;
}
else
{
q1 = GetQuartile(measurements, measurements.Count / 2);
q3 = GetQuartile(measurements, measurements.Count * 3 / 2);
}
double interquartileRange = q3 - q1;
double lowerFence = q1 - 1.5 * interquartileRange;
double upperFence = q3 + 1.5 * interquartileRange;
SumWithoutOutliers(outlierMode, measurements, lowerFence, upperFence, out sum, out n); // updates sum and N
mean = sum / n;
variance = VarianceWithoutOutliers(outlierMode, measurements, n, mean, lowerFence, upperFence);
standardDeviation = Math.Sqrt(variance);
standardError = standardDeviation / Math.Sqrt(n);
confidenceInterval = new ConfidenceInterval(mean, standardError, n);
return(new MeasurementsStatistics(standardError, mean, confidenceInterval));
}
public static IEnumerable <double> ApplyOutlierMode([NotNull] this IOutlierDetector outlierDetector,
[NotNull] IEnumerable <double> values, OutlierMode mode)
{
switch (mode)
{
case OutlierMode.DontRemove:
return(values);
case OutlierMode.RemoveUpper:
return(outlierDetector.WithoutUpperOutliers(values));
case OutlierMode.RemoveLower:
return(outlierDetector.WithoutLowerOutliers(values));
case OutlierMode.RemoveAll:
return(outlierDetector.WithoutAllOutliers(values));
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
}
/// <summary> /// Specifies which outliers should be removed from the distribution /// </summary> public static Job WithOutlierMode(this Job job, OutlierMode value) => job.WithCore(j => j.Accuracy.OutlierMode = value);
