Exemple #1
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        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);
 }