static void benchmarkingRunFinished(IBenchmarkable sender, BenchmarkResult result) { ConsoleBuilder.AddResult(++FinishedRunCount, sender as RunBenchmark, result); if (CsvFilePath != String.Empty) CsvBuilder.AddResult(FinishedRunCount, sender as RunBenchmark, result); Console.WriteLine("Finished " + FinishedRunCount + "/" + TotalRunCount + " ..."); if (FinishedRunCount >= TotalRunCount) { if (CsvFilePath != String.Empty) { var csvContent = CsvBuilder.Build(); var exporter = new FileHelper(); try { exporter.Save(csvContent, CsvFilePath); } catch (Exception) { Console.WriteLine("Saving CSV failed. Do you have the required access privileges?"); } } Console.Write(ConsoleBuilder.Build()); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("Press any key to exit."); } }
/// <summary> /// Misst die Zeitspane, wenn eine Implementierung mit einer vorgegebenen Menge an Arbeit läuft. /// </summary> /// <param name="implementation">Die Implementierung, deren Leistung gemessen wird.</param> /// <param name="levelOfLoad">Die Menge an Arbeit zum Testen.</param> /// <returns>Die Zeitspane, bis die Aufgabe erledigt wird.</returns> private TimeSpan Measure(IBenchmarkable implementation, uint levelOfLoad) { DateTime start = System.DateTime.Now; implementation.Run(levelOfLoad); DateTime end = System.DateTime.Now; return(end - start); }
public List <BenchmarkResult> Run(IBenchmarkable benchmark, List <object> configurations) { List <BenchmarkResult> result = new List <BenchmarkResult>(); foreach (object configuration in configurations) { result.Add(Run(benchmark, configuration)); } return(result); }
public BenchmarkResult Run(IBenchmarkable benchmark, object configuration) { DateTime start = DateTime.Now; double performance = benchmark.RunBenchmark(configuration); return(new BenchmarkResult() { RunTime = DateTime.Now - start, Performance = performance }); }
static void Main() { var implementations = new IBenchmarkable[] { new SimpleForLoop(), new ForeachLoop() }; foreach (IBenchmarkable implementation in implementations) { Console.WriteLine($"\nLeistung der Implementierung '{implementation.Name}':"); var benchmarker = new Benchmarking.Benchmarker(); var performanceMeasurements = benchmarker.Measure(implementation); foreach (var measurement in performanceMeasurements) { Console.WriteLine(measurement.Explain("Durchlauf", "Durchläufe")); } } Console.WriteLine("Ende!"); }
/// <summary> /// Misst wie schnell eine vorgegebene Implementierung ist. /// </summary> /// <param name="implementation">Die zu messende Implementierung.</param> /// <returns>Eine Liste, die einige Messungen enthält.</returns> public List <Result> Measure(IBenchmarkable implementation) { uint maxLoad = (uint)Math.Pow(10, Math.Floor(Math.Log10(uint.MaxValue))); double loadPerSecond = 0.0; for (uint load = 1; load < maxLoad; load *= 10) { TimeSpan elapsed = Measure(implementation, load); if (elapsed.TotalMilliseconds >= 50) { loadPerSecond = 1000 * load / elapsed.TotalMilliseconds; break; } } if (loadPerSecond == 0.0) { throw new ApplicationException($"Die Implementierung von '{implementation.Name}' ist schlicht so schnell, dass die Messung von ihrem Tempo unmöglich ist."); } var targetedTimeLapses = new TimeSpan[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(4) }; var measurements = new List <Result>(targetedTimeLapses.Length); foreach (TimeSpan timeLapse in targetedTimeLapses) { var load = (uint)(loadPerSecond * timeLapse.TotalSeconds); // eingeschätzt TimeSpan elapsed = Measure(implementation, load); measurements.Add(new Result(load, elapsed)); } return(measurements); }
void benchmarkSingle(IBenchmarkable benchmarkable) { benchmarkable.BenchmarkingFinished += new BenchmarkingFinishedEventHandler(benchmarkingFinished); benchmarkable.StartBenchmarking(); }
void benchmarkingFinished(IBenchmarkable sender, BenchmarkResult result) { BenchmarkingFinished.Invoke(sender, result); if (_benchmarkableEnumerator.MoveNext()) benchmarkSingle(_benchmarkableEnumerator.Current); }