private BenchmarkCase(Descriptor descriptor, Job job, ParameterInstances parameters, ImmutableConfig config)
{
Descriptor = descriptor;
Job = job;
Parameters = parameters;
Config = config;
}
private string Format(Summary summary, ImmutableConfig config, Statistics statistics, SummaryStyle style)
{
if (statistics == null)
{
return("NA");
}
var allValues = summary
.Reports
.Where(r => r.ResultStatistics != null)
.Select(r => calc(r.ResultStatistics))
.Where(v => !double.IsNaN(v) && !double.IsInfinity(v))
.Select(v => UnitType == UnitType.Time ? v / style.TimeUnit.NanosecondAmount : v)
.ToList();
double minValue = allValues.Any() ? allValues.Min() : 0;
bool allValuesAreZeros = allValues.All(v => Math.Abs(v) < 1e-9);
string format = "N" + (allValuesAreZeros ? 1 : GetBestAmountOfDecimalDigits(minValue));
double value = calc(statistics);
if (double.IsNaN(value))
{
return("NA");
}
return(UnitType == UnitType.Time
? value.ToTimeStr(style.TimeUnit, config.Encoding, format, 1, style.PrintUnitsInContent)
: value.ToStr(format));
}
private string Format(Summary summary, ImmutableConfig config, Statistics statistics, SummaryStyle style)
{
if (statistics == null)
{
return("NA");
}
int precision = summary.DisplayPrecisionManager.GetPrecision(style, this, parentColumn);
string format = "N" + precision;
double value = calc(statistics);
if (double.IsNaN(value))
{
return("NA");
}
return(UnitType == UnitType.Time
? TimeInterval.FromNanoseconds(value)
.ToString(
style.TimeUnit,
style.CultureInfo,
format,
UnitPresentation.FromVisibility(style.PrintUnitsInContent))
: value.ToString(format, style.CultureInfo));
}
public static string getDetailedResultsAndSummary(this Summary summary)
{
StringLogger?logger = new StringLogger();
if (summary.HasCriticalValidationErrors)
{
foreach (ValidationError validationError in summary.ValidationErrors)
{
logger.WriteLine(validationError.Message);
}
}
else
{
// extracted from https://github.com/dotnet/BenchmarkDotNet/blob/ceef311bfc73a08a3b07f177f6b9f9782191b794/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs PrintSummary()
CultureInfo?cultureInfo = summary.GetCultureInfo();
// logger.WriteLineHeader("// * Detailed results *");
// BenchmarkReportExporter.Default.ExportToLog(summary, logger);
logger.WriteLineHeader("// * Summary *");
MarkdownExporter.Console.ExportToLog(summary, logger);
ImmutableConfig config = DefaultConfig.Instance.CreateImmutableConfig();
ConclusionHelper.Print(logger, config.GetCompositeAnalyser().Analyse(summary).Distinct().ToList());
/*var columnWithLegends = summary.Table.Columns.Select(c => c.OriginalColumn).Where(c => !string.IsNullOrEmpty(c.Legend)).ToList();
* var effectiveTimeUnit = summary.Table.EffectiveSummaryStyle.TimeUnit;
* if (columnWithLegends.Any() || effectiveTimeUnit != null) {
* logger.WriteLine();
* logger.WriteLineHeader("// * Legends *");
* int maxNameWidth = 0;
* if (columnWithLegends.Any())
* maxNameWidth = Math.Max(maxNameWidth, columnWithLegends.Select(c => c.ColumnName.Length).Max());
* if (effectiveTimeUnit != null)
* maxNameWidth = Math.Max(maxNameWidth, effectiveTimeUnit.Name.ToString(cultureInfo).Length + 2);
*
* foreach (var column in columnWithLegends)
* logger.WriteLineHint($" {column.ColumnName.PadRight(maxNameWidth, ' ')} : {column.Legend}");
*
* if (effectiveTimeUnit != null)
* logger.WriteLineHint($" {("1 " + effectiveTimeUnit.Name).PadRight(maxNameWidth, ' ')} :" +
* $" 1 {effectiveTimeUnit.Description} ({TimeUnit.Convert(1, effectiveTimeUnit, TimeUnit.Second).ToString("0.#########", summary.GetCultureInfo())} sec)");
* }*/
if (config.GetDiagnosers().Any())
{
logger.WriteLine();
config.GetCompositeDiagnoser().DisplayResults(logger);
}
}
return(logger.toString());
}
private string Format(Summary summary, ImmutableConfig config, Statistics statistics, SummaryStyle style)
{
string strRes = "NA";
if (statistics != null)
{
double value = calc(statistics);
if (!double.IsNaN(value))
{
strRes = value.ToString("P", CultureInfo.InvariantCulture);
}
}
return(strRes);
}
private static IEnumerable <BenchmarkCase> GenerateBenchmarkCases(int count)
{
MethodInfo publicMethod = typeof(PartitionFilterTests)
.GetMethods()
.Single(method => method.Name == nameof(NoBenchmarksAreOmitted_MockData));
Descriptor target = new (typeof(PartitionFilterTests), publicMethod);
ParameterInstances parameterInstances = new (Array.Empty <ParameterInstance>());
ImmutableConfig config = ManualConfig.CreateEmpty().CreateImmutableConfig();
for (int i = 0; i < count; i++)
{
yield return(BenchmarkCase.Create(target, Job.Default, parameterInstances, config));
}
}
private static ImmutableConfig GetFullMethodConfig(MethodInfo method, ImmutableConfig typeConfig)
{
var methodAttributes = method.GetCustomAttributes(true).OfType <IConfigSource>();
if (!methodAttributes.Any()) // the most common case
{
return(typeConfig);
}
var config = ManualConfig.Create(typeConfig);
foreach (var configFromAttribute in methodAttributes)
{
config = ManualConfig.Union(config, configFromAttribute.Config);
}
return(ImmutableConfigBuilder.Create(config));
}
private string Format(Summary summary, ImmutableConfig config, Statistics statistics, SummaryStyle style)
{
if (statistics == null)
{
return("NA");
}
int precision = summary.DisplayPrecisionManager.GetPrecision(style, this, parentColumn);
string format = "N" + precision;
double value = calc(statistics);
if (double.IsNaN(value))
{
return("NA");
}
return(UnitType == UnitType.Time
? value.ToTimeStr(style.TimeUnit, config.Encoding, format, 1, style.PrintUnitsInContent)
: value.ToStr(format));
}
private static BenchmarkRunInfo MethodsToBenchmarksWithFullConfig(Type containingType, MethodInfo[] benchmarkMethods, ImmutableConfig immutableConfig)
{
if (immutableConfig == null)
{
throw new ArgumentNullException(nameof(immutableConfig));
}
var helperMethods = containingType.GetMethods(); // benchmarkMethods can be filtered, without Setups, look #564
var globalSetupMethods = GetAttributedMethods <GlobalSetupAttribute>(helperMethods, "GlobalSetup");
var globalCleanupMethods = GetAttributedMethods <GlobalCleanupAttribute>(helperMethods, "GlobalCleanup");
var iterationSetupMethods = GetAttributedMethods <IterationSetupAttribute>(helperMethods, "IterationSetup");
var iterationCleanupMethods = GetAttributedMethods <IterationCleanupAttribute>(helperMethods, "IterationCleanup");
var targetMethods = benchmarkMethods.Where(method => method.HasAttribute <BenchmarkAttribute>()).ToArray();
var parameterDefinitions = GetParameterDefinitions(containingType);
var parameterInstancesList = parameterDefinitions.Expand(immutableConfig.SummaryStyle);
var jobs = immutableConfig.GetJobs();
var targets = GetTargets(targetMethods, containingType, globalSetupMethods, globalCleanupMethods, iterationSetupMethods, iterationCleanupMethods).ToArray();
var benchmarks = new List <BenchmarkCase>();
foreach (var target in targets)
{
var argumentsDefinitions = GetArgumentsDefinitions(target.WorkloadMethod, target.Type, immutableConfig.SummaryStyle).ToArray();
var parameterInstances =
(from parameterInstance in parameterInstancesList
from argumentDefinition in argumentsDefinitions
select new ParameterInstances(parameterInstance.Items.Concat(argumentDefinition.Items).ToArray())).ToArray();
benchmarks.AddRange(
from job in jobs
from parameterInstance in parameterInstances
select BenchmarkCase.Create(target, job, parameterInstance, immutableConfig)
);
}
var filters = immutableConfig.GetFilters().ToArray();
var filteredBenchmarks = GetFilteredBenchmarks(benchmarks, filters);
var orderedBenchmarks = immutableConfig.Orderer.GetExecutionOrder(filteredBenchmarks).ToArray();
return(new BenchmarkRunInfo(orderedBenchmarks, containingType, immutableConfig));
}
public ValidationParameters(IReadOnlyList <BenchmarkCase> benchmarks, ImmutableConfig config)
{
Benchmarks = benchmarks;
Config = config;
}
public static BenchmarkCase Create(Descriptor descriptor, Job job, ParameterInstances parameters, ImmutableConfig config) => new BenchmarkCase(descriptor, job.MakeSettingsUserFriendly(descriptor), parameters, config);
public BenchmarkRunInfo(BenchmarkCase[] benchmarksCase, Type type, ImmutableConfig config)
{
BenchmarksCases = benchmarksCase;
Type = type;
Config = config;
}
public BenchmarkBuildInfo(BenchmarkCase benchmarkCase, ImmutableConfig config, int id)
{
BenchmarkCase = benchmarkCase;
Config = config;
Id = new BenchmarkId(id, benchmarkCase);
}
