async void Button_Clicked(object sender, EventArgs e)
{
SetIsRunning(true);
try
{
var logger = new AccumulationLogger();
await Task.Run(() =>
{
var config = default(IConfig);
#if DEBUG
config = new DebugInProcessConfig();
#endif
var summary = BenchmarkRunner.Run <IntroBasic>(config);
MarkdownExporter.Console.ExportToLog(summary, logger);
ConclusionHelper.Print(logger,
summary.BenchmarksCases
.SelectMany(benchmark => benchmark.Config.GetCompositeAnalyser().Analyse(summary))
.Distinct()
.ToList());
});
SetSummary(logger.GetLog());
}
catch (Exception exc)
{
await DisplayAlert("Error", exc.Message, "Ok");
}
finally
{
SetIsRunning(false);
}
}
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());
}
public void ReceiveParameter(object parameter)
{
var report = parameter as FireHazardReport;
if (report == null)
{
return;
}
SelectedWeatherRecord = report.Weather;
SelectedReport = report;
Conclusion = ConclusionHelper.GetConclusion(report);
GetRecentReports();
}
public static int Main()
{
try
{
Console.WriteLine("Working directory: {0}", Environment.CurrentDirectory);
var config = DefaultConfig
.Instance
.AddColumn(new SizeInBytesColumn())
.WithOptions(ConfigOptions.Default | ConfigOptions.StopOnFirstError)
;
var summaries = BenchmarkRunner.Run(new[]
{
BenchmarkConverter.TypeToBenchmarks(typeof(DecimalRead), config),
BenchmarkConverter.TypeToBenchmarks(typeof(DecimalWrite), config),
BenchmarkConverter.TypeToBenchmarks(typeof(FloatTimeSeriesRead), config),
BenchmarkConverter.TypeToBenchmarks(typeof(FloatTimeSeriesWrite), config)
});
// Re-print to the console all the summaries.
var logger = ConsoleLogger.Default;
logger.WriteLine();
foreach (var summary in summaries)
{
logger.WriteLine();
logger.WriteHeader(summary.Title);
MarkdownExporter.Console.ExportToLog(summary, logger);
ConclusionHelper.Print(logger, config.GetAnalysers().SelectMany(a => a.Analyse(summary)).ToList());
}
return(0);
}
catch (Exception exception)
{
var colour = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("ERROR: {0}", exception);
Console.ForegroundColor = colour;
}
return(1);
}
async void Button_Clicked(object sender, EventArgs e)
{
SetIsRunning(true);
try {
var logger = new ActionLogger(SetSummary);
var summary = await Task.Run(() => BenchmarkRunner.Run(BenchmarkType, DefaultConfig.Instance.AddLogger(logger)));
ConclusionHelper.Print(logger,
summary.BenchmarksCases
.SelectMany(benchmark => benchmark.Config.GetCompositeAnalyser().Analyse(summary))
.Distinct()
.ToList());
} catch (Exception exc) {
SetSummary("Unhandled exception: " + exc);
} finally {
SetIsRunning(false);
}
}
static void Main(string[] args)
{
Console.WriteLine($"Number of available requests: {new RequestFactory().Count() }");
var config = DefaultConfig.Instance
.WithOptions(ConfigOptions.DisableOptimizationsValidator)
.CreateImmutableConfig();
var dummySummary = BenchmarkRunner.Run <UsingDummyConfigurationWithFakeRunner>(config);
var defaultSummary = BenchmarkRunner.Run <UsingDefaultConfigurationWithActualRunner>(config);
var logger = ConsoleLogger.Default;
MarkdownExporter.Console.ExportToLog(dummySummary, logger);
ConclusionHelper.Print(logger, config.GetCompositeAnalyser().Analyse(dummySummary).ToList());
MarkdownExporter.Console.ExportToLog(defaultSummary, logger);
ConclusionHelper.Print(logger, config.GetCompositeAnalyser().Analyse(defaultSummary).ToList());
Console.ReadKey();
}
public static void Main()
{
var config = new ManualConfig();
config.Add(Job.Core);
config.Add(DefaultConfig.Instance.GetColumnProviders().ToArray());
config.Add(DefaultConfig.Instance.GetExporters().ToArray());
config.Add(DefaultConfig.Instance.GetDiagnosers().ToArray());
config.Add(DefaultConfig.Instance.GetAnalysers().ToArray());
config.Add(DefaultConfig.Instance.GetJobs().ToArray());
config.Add(DefaultConfig.Instance.GetValidators().ToArray());
config.Add(new MemoryDiagnoser());
config.UnionRule = ConfigUnionRule.AlwaysUseGlobal;
var summary = BenchmarkRunner.Run <Program>();
var logger = ConsoleLogger.Default;
MarkdownExporter.Console.ExportToLog(summary, logger);
ConclusionHelper.Print(logger, config.GetCompositeAnalyser().Analyse(summary).ToList());
}
public static Summary Run(BenchmarkRunInfo benchmarkRunInfo, ILogger logger, string title, string rootArtifactsFolderPath, Func <Job, IToolchain> toolchainProvider, IResolver resolver, List <string> artifactsToCleanup)
{
var benchmarks = benchmarkRunInfo.Benchmarks;
var config = benchmarkRunInfo.Config;
logger.WriteLineHeader("// ***** BenchmarkRunner: Start *****");
logger.WriteLineInfo("// Found benchmarks:");
foreach (var benchmark in benchmarks)
{
logger.WriteLineInfo($"// {benchmark.DisplayInfo}");
}
logger.WriteLine();
var validationErrors = Validate(benchmarks, logger, config);
if (validationErrors.Any(validationError => validationError.IsCritical))
{
return(Summary.CreateFailed(benchmarks, title, HostEnvironmentInfo.GetCurrent(), config, GetResultsFolderPath(rootArtifactsFolderPath), validationErrors));
}
var globalChronometer = Chronometer.Start();
var reports = new List <BenchmarkReport>();
var buildResults = BuildInParallel(logger, rootArtifactsFolderPath, toolchainProvider, resolver, benchmarks, config, ref globalChronometer);
foreach (var benchmark in benchmarks)
{
var buildResult = buildResults[benchmark];
if (!config.KeepBenchmarkFiles)
{
artifactsToCleanup.AddRange(buildResult.ArtifactsToCleanup);
}
if (buildResult.IsBuildSuccess)
{
var report = RunCore(benchmark, logger, config, rootArtifactsFolderPath, toolchainProvider, resolver, buildResult);
reports.Add(report);
if (report.GetResultRuns().Any())
{
logger.WriteLineStatistic(report.GetResultRuns().GetStatistics().ToTimeStr());
}
}
else
{
reports.Add(new BenchmarkReport(benchmark, buildResult, buildResult, null, null, default));
if (buildResult.GenerateException != null)
{
logger.WriteLineError($"// Generate Exception: {buildResult.GenerateException.Message}");
}
if (buildResult.BuildException != null)
{
logger.WriteLineError($"// Build Exception: {buildResult.BuildException.Message}");
}
}
logger.WriteLine();
}
var clockSpan = globalChronometer.GetElapsed();
var summary = new Summary(title, reports, HostEnvironmentInfo.GetCurrent(), config, GetResultsFolderPath(rootArtifactsFolderPath), clockSpan.GetTimeSpan(), validationErrors);
logger.WriteLineHeader("// ***** BenchmarkRunner: Finish *****");
logger.WriteLine();
logger.WriteLineHeader("// * Export *");
var currentDirectory = Directory.GetCurrentDirectory();
foreach (var file in config.GetCompositeExporter().ExportToFiles(summary, logger))
{
logger.WriteLineInfo($" {file.Replace(currentDirectory, string.Empty).Trim('/', '\\')}");
}
logger.WriteLine();
logger.WriteLineHeader("// * Detailed results *");
// TODO: make exporter
foreach (var report in reports)
{
logger.WriteLineInfo(report.Benchmark.DisplayInfo);
logger.WriteLineStatistic($"Runtime = {report.GetRuntimeInfo()}; GC = {report.GetGcInfo()}");
var resultRuns = report.GetResultRuns();
if (resultRuns.IsEmpty())
{
logger.WriteLineError("There are not any results runs");
}
else
{
logger.WriteLineStatistic(resultRuns.GetStatistics().ToTimeStr());
}
logger.WriteLine();
}
LogTotalTime(logger, clockSpan.GetTimeSpan());
logger.WriteLine();
logger.WriteLineHeader("// * Summary *");
MarkdownExporter.Console.ExportToLog(summary, logger);
// TODO: make exporter
ConclusionHelper.Print(logger, config.GetCompositeAnalyser().Analyse(summary).ToList());
// TODO: move to conclusions
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.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).ToStr("0.#########")} sec)");
}
}
if (config.GetDiagnosers().Any())
{
logger.WriteLine();
config.GetCompositeDiagnoser().DisplayResults(logger);
}
logger.WriteLine();
logger.WriteLineHeader("// ***** BenchmarkRunner: End *****");
return(summary);
}
public static Summary Run(Benchmark[] benchmarks, ILogger logger, string title, IConfig config, string rootArtifactsFolderPath, Func <Job, IToolchain> toolchainProvider, IResolver resolver)
{
logger.WriteLineHeader("// ***** BenchmarkRunner: Start *****");
logger.WriteLineInfo("// Found benchmarks:");
foreach (var benchmark in benchmarks)
{
logger.WriteLineInfo($"// {benchmark.DisplayInfo}");
}
logger.WriteLine();
var validationErrors = Validate(benchmarks, logger, config);
if (validationErrors.Any(validationError => validationError.IsCritical))
{
return(Summary.CreateFailed(benchmarks, title, HostEnvironmentInfo.GetCurrent(), config, GetResultsFolderPath(rootArtifactsFolderPath), validationErrors));
}
var globalChronometer = Chronometer.Start();
var reports = new List <BenchmarkReport>();
foreach (var benchmark in benchmarks)
{
var report = Run(benchmark, logger, config, rootArtifactsFolderPath, toolchainProvider, resolver);
reports.Add(report);
if (report.GetResultRuns().Any())
{
logger.WriteLineStatistic(report.GetResultRuns().GetStatistics().ToTimeStr());
}
logger.WriteLine();
}
var clockSpan = globalChronometer.Stop();
var summary = new Summary(title, reports, HostEnvironmentInfo.GetCurrent(), config, GetResultsFolderPath(rootArtifactsFolderPath), clockSpan.GetTimeSpan(), validationErrors);
logger.WriteLineHeader("// ***** BenchmarkRunner: Finish *****");
logger.WriteLine();
logger.WriteLineHeader("// * Export *");
var currentDirectory = Directory.GetCurrentDirectory();
foreach (var file in config.GetCompositeExporter().ExportToFiles(summary))
{
logger.WriteLineInfo($" {file.Replace(currentDirectory, string.Empty).Trim('/', '\\')}");
}
logger.WriteLine();
logger.WriteLineHeader("// * Detailed results *");
// TODO: make exporter
foreach (var report in reports)
{
logger.WriteLineInfo(report.Benchmark.DisplayInfo);
var resultRuns = report.GetResultRuns();
if (resultRuns.IsEmpty())
{
logger.WriteLineError("There are no any results runs");
}
else
{
logger.WriteLineStatistic(resultRuns.GetStatistics().ToTimeStr());
}
logger.WriteLine();
}
LogTotalTime(logger, clockSpan.GetTimeSpan());
logger.WriteLine();
logger.WriteLineHeader("// * Summary *");
MarkdownExporter.Console.ExportToLog(summary, logger);
// TODO: make exporter
ConclusionHelper.Print(logger, config.GetCompositeAnalyser().Analyse(summary).ToList());
if (config.GetDiagnosers().Any())
{
logger.WriteLine();
config.GetCompositeDiagnoser().DisplayResults(logger);
}
logger.WriteLine();
logger.WriteLineHeader("// ***** BenchmarkRunner: End *****");
return(summary);
}
