public virtual async Task <long> Add([NotNull] BenchmarkDto entity) { var newEntity = new Benchmark() { Name = entity.BenchmarkName, Description = entity.Description, OwnerId = entity.OwnerId, HtmlPreparationCode = entity.HtmlPreparationCode, ScriptPreparationCode = entity.ScriptPreparationCode, BenchmarkTest = new List <BenchmarkTest>() }; foreach (var test in entity.TestCases) { var newTest = new BenchmarkTest() { TestName = test.TestCaseName, BenchmarkText = test.BenchmarkCode, }; newEntity.BenchmarkTest.Add(newTest); } this.Validate(newEntity); this.m_db.Benchmark.Add(newEntity); await this.m_db.SaveChangesAsync().ConfigureAwait(false); return(newEntity.Id); }
protected override void Execute(BenchmarkTest test) { for (var i = 0; i < test.NTimes; i++) { test.Function.Invoke(); } }
private void DoBenchmark() { BenchmarkSuite testSuite = new BenchmarkSuite(); testSuite.OnTestFinish += Report; try { foreach (var benchmark in History) { if (Cancellation.IsCancellationRequested) { break; } Current = benchmark; testSuite.ExecuteInit(benchmark); // Write. ApplicationManager.SetCurrentMethod(TestMethod.Write); CurrentStatus = TestMethod.Write.ToString(); testSuite.ExecuteWrite(benchmark); // Read. ApplicationManager.SetCurrentMethod(TestMethod.Read); CurrentStatus = TestMethod.Read.ToString(); testSuite.ExecuteRead(benchmark); // Secondary Read. ApplicationManager.SetCurrentMethod(TestMethod.SecondaryRead); CurrentStatus = TestMethod.SecondaryRead.ToString(); testSuite.ExecuteSecondaryRead(benchmark); // Finish. CurrentStatus = TestMethod.None.ToString(); testSuite.ExecuteFinish(benchmark); } } finally { Current = null; if (Cancellation.IsCancellationRequested) { History.Clear(); } else { if (!(bool)Properties.Settings.Default["HideReportForm"]) { StartOnlineReport(); } } } }
public void Test(BenchmarkTest test) { var timer = Stopwatch.StartNew(); timer.Start(); Execute(test); timer.Stop(); test.Duration = timer.ElapsedMilliseconds; }
private void EventSelectedIndexChanged(object sender, EventArgs e) { if (ReferenceEquals(sender, cbTest)) { BenchmarkTest benchmark = cbTest.SelectedItem as BenchmarkTest; lbSingleThreadDevResults.Text = $"Single Thread: {benchmark.DevSingleThreadResult} {RunsAbbreviation}"; lbMultiThreadDevResults.Text = $"Multi Thread: {benchmark.DevMultiThreadResult} {RunsAbbreviation}"; return; } }
public void execute(BenchmarkTest test) { // clear previous results for (int i = 0; i < timers.Length; i++) timers[i] = null; // loop for the specified number of iterations or until the time limit long startTime = NanoTime.Now; for (int i = 0; i < timers.Length && ((NanoTime.Now - startTime) / 1000000000) < timeLimit; i++) { UI.printInfo(UI.Module.BENCH, "Running iteration {0}", (i + 1)); timers[i] = new Timer(); test.kernelBegin(); timers[i].start(); test.kernelMain(); timers[i].end(); test.kernelEnd(); } // report stats double avg = 0; double min = double.PositiveInfinity; double max = double.NegativeInfinity; int n = 0; foreach (Timer t in timers) { if (t == null) break; double s = t.seconds(); min = Math.Min(min, s); max = Math.Max(max, s); avg += s; n++; } if (n == 0) return; avg /= n; double stdDev = 0; foreach (Timer t in timers) { if (t == null) break; double s = t.seconds(); stdDev += (s - avg) * (s - avg); } stdDev = Math.Sqrt(stdDev / n); UI.printInfo(UI.Module.BENCH, "Benchmark results:"); UI.printInfo(UI.Module.BENCH, " * Iterations: {0}", n); UI.printInfo(UI.Module.BENCH, " * Average: {0}", Timer.tostring(avg)); UI.printInfo(UI.Module.BENCH, " * Fastest: {0}", Timer.tostring(min)); UI.printInfo(UI.Module.BENCH, " * Longest: {0}", Timer.tostring(max)); UI.printInfo(UI.Module.BENCH, " * Deviation: {0}", Timer.tostring(stdDev)); for (int i = 0; i < timers.Length && timers[i] != null; i++) UI.printDetailed(UI.Module.BENCH, " * Iteration {0}: {1}", i + 1, timers[i]); }
private void makeTestToggles(int indexStart, int indexEnd) { using (new GUILayout.VerticalScope()) { for (int i = indexStart; i < indexEnd; i++) { GUILayout.Space(10f); BenchmarkTest benchmarkTest = Config.Tests[i]; activeTests[i] = GUILayout.Toggle(activeTests[i], benchmarkTest.name); GUILayout.Space(10f); } } }
public static void ExportSettings(StreamWriter writer, BenchmarkTest session) { int tableCount = session.FlowCount; long recordCount = session.RecordCount; string sequential = session.KeysType.ToString(); string randomness = string.Format("{0}%", session.Randomness * 100); writer.WriteLine("Settings:"); writer.WriteLine("Table count;Record count;Keys type;Randomness"); writer.Write(tableCount + ";"); writer.Write(recordCount + ";"); writer.Write(sequential + ";"); writer.WriteLine(randomness + ";"); }
public string ProcessBenchmark(CollectorCommand command) { try { var benchmark = new BenchmarkTest(command.ThreadsCount); benchmark.AddLoadTestFactory(CreateReaderTest(ReadJsonFile(command.FileName), command.TableName, command.HashFileName, command.CountReplics, command.PageSize)); benchmark.Run(); } catch (Exception e) { return(e.Message); } return(string.Empty); }
private void startButton_Click(object sender, EventArgs e) { // Parse test parameters. TableCount = Int32.Parse(cbFlowsCount.Text.Replace(" ", "")); RecordCount = Int64.Parse(cbRecordCount.Text.Replace(" ", "")); Randomness = trackBar1.Value / 20.0f; var databases = ApplicationManager.SelectedDatabases; if (databases.Length == 0) { return; } History.Clear(); Cancellation = new CancellationTokenSource(); foreach (var database in databases) { var session = new BenchmarkTest(database, TableCount, RecordCount, Randomness, Cancellation); History.Add(session); try { foreach (var directory in Directory.GetDirectories(database.DataDirectory)) { Directory.Delete(directory, true); } foreach (var files in Directory.GetFiles(database.DataDirectory, "*.*", SearchOption.AllDirectories)) { File.Delete(files); } } catch (Exception exc) { Logger.Error("Application exception occured...", exc); } } ApplicationManager.Prepare(); // Start the benchmark. MainTask = Task.Factory.StartNew(DoBenchmark, Cancellation.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default); }
private void Export(ReportFormat reportFormat, ReportType reportType, SaveFileDialog dialog) { dialog.FileName = String.Format("Database Benchmark {0:yyyy-MM-dd HH.mm}", DateTime.Now); if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK) { try { // Start loading and disable MainForm. LoadingForm.Start(string.Format("Exporting to {0} ....", reportFormat), Bounds); Enabled = false; switch (reportFormat) { case ReportFormat.CSV: CsvUtils.ExportResults(History, saveFileDialogCsv.FileName, reportType); break; case ReportFormat.JSON: ComputerConfiguration configuration = SystemUtils.GetComputerConfiguration(); JsonUtils.ExportToJson(saveFileDialogJson.FileName, configuration, History, reportType); break; case ReportFormat.PDF: BenchmarkTest test = History[0]; PdfUtils.Export(saveFileDialogPdf.FileName, ApplicationManager.StepFrames, test.FlowCount, test.RecordCount, test.Randomness, SystemUtils.GetComputerConfiguration(), reportType); break; } // Stop loading end enable MainForm LoadingForm.Stop(); Enabled = true; } catch (Exception exc) { string message = string.Format("Export results to {0} failed...", reportFormat); Logger.Error(message, exc); ReportError(message); Enabled = true; LoadingForm.Stop(); } } }
public void TestsFileSystemDataFeedSpeed() { var job = new BacktestNodePacket(); var resultHandler = new BacktestingResultHandler(); var mapFileProvider = new LocalDiskMapFileProvider(); var factorFileProvider = new LocalDiskFactorFileProvider(mapFileProvider); var dataProvider = new DefaultDataProvider(); var algorithm = new BenchmarkTest(); var feed = new FileSystemDataFeed(); feed.Initialize(algorithm, job, resultHandler, mapFileProvider, factorFileProvider, dataProvider); algorithm.Initialize(); var feedThreadStarted = new ManualResetEvent(false); Task.Factory.StartNew(() => { feedThreadStarted.Set(); feed.Run(); }); feedThreadStarted.WaitOne(); var stopwatch = Stopwatch.StartNew(); var lastMonth = -1; var count = 0; foreach (var timeSlice in feed) { if (timeSlice.Time.Month != lastMonth) { Console.WriteLine(DateTime.Now + " - Time: " + timeSlice.Time); lastMonth = timeSlice.Time.Month; } count++; } Console.WriteLine("Count: " + count); stopwatch.Stop(); Console.WriteLine("Elapsed time: " + stopwatch.Elapsed); }
public static void ExportSummaryTestResults(List <BenchmarkTest> sessions, string path) { // ---Write Summary File--- //#time //#database;write speed (rec/sec);read speed;secondary read speed;size (MB) string extension = ".csv"; string[] fullPath = path.Split(new string[] { extension }, StringSplitOptions.None); string summaryFileName = fullPath[0] + ".summary" + extension; using (StreamWriter writer = new StreamWriter(summaryFileName)) { // write settings ExportSettings(writer, sessions[0]); // write computer configuration writer.WriteLine(); ExportComputerConfiguration(writer, SystemUtils.GetComputerConfiguration()); writer.WriteLine(); // write date writer.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH.mm")); writer.WriteLine(); writer.WriteLine(String.Join(";", "Database;Write speed(rec/sec);Read speed(rec/sec);Seconady read speed(rec/sec);Size(MB)")); for (int i = 0; i < sessions.Count; i++) { BenchmarkTest test = sessions[i]; // write database info writer.Write(test.Database.Name + ";"); writer.Write(test.GetSpeed(TestMethod.Write) + ";"); writer.Write(test.GetSpeed(TestMethod.Read) + ";"); writer.Write(test.GetSpeed(TestMethod.SecondaryRead) + ";"); writer.WriteLine(test.DatabaseSize / (1024.0 * 1024.0) + ";"); } } }
private void Report(BenchmarkTest benchmark, TestMethod method) { try { Action <string, object, Color> updateChart = null; StepFrame ActiveStepFrame = ApplicationManager.GetCurrentStepFrame(); string databaseName = benchmark.Database.Name; Color databaseColor = benchmark.Database.Color; // Speed chart. updateChart = ActiveStepFrame.AddAverageSpeedToBar; Report(databaseName, databaseColor, updateChart, benchmark.GetSpeed(method)); // Size chart. updateChart = ActiveStepFrame.AddSizeToBar; Report(databaseName, databaseColor, updateChart, benchmark.DatabaseSize / (1024.0 * 1024.0)); // Time chart. updateChart = ActiveStepFrame.AddTimeToBar; Report(databaseName, databaseColor, updateChart, new DateTime(benchmark.GetTime(method).Ticks)); // CPU chart. //updateChart = ActiveStepFrame.AddCpuUsageToBar; //Report(databaseName, databaseColor, updateChart, benchmark.GetAverageProcessorTime(method)); // Memory chart. updateChart = ActiveStepFrame.AddMemoryUsageToBar; Report(databaseName, databaseColor, updateChart, benchmark.GetPeakWorkingSet(method) / (1024.0 * 1024.0)); // I/O chart. //updateChart = ActiveStepFrame.AddIoUsageToBar; //Report(databaseName, databaseColor, updateChart, benchmark.GetAverageIOData(method) / (1024.0 * 1024.0)); } catch (Exception exc) { Logger.Error("Report results failed...", exc); } }
public void TestsFileSystemDataFeedSpeed() { var job = new BacktestNodePacket(); var resultHandler = new BacktestingResultHandler(); var mapFileProvider = new LocalDiskMapFileProvider(); var factorFileProvider = new LocalDiskFactorFileProvider(mapFileProvider); var dataFileProvider = new DefaultDataFileProvider(); var algorithm = new BenchmarkTest(); var feed = new FileSystemDataFeed(); feed.Initialize(algorithm, job, resultHandler, mapFileProvider, factorFileProvider, dataFileProvider); algorithm.Initialize(); var feedThreadStarted = new ManualResetEvent(false); Task.Factory.StartNew(() => { feedThreadStarted.Set(); feed.Run(); }); feedThreadStarted.WaitOne(); var stopwatch = Stopwatch.StartNew(); var lastMonth = -1; var count = 0; foreach (var timeSlice in feed) { if (timeSlice.Time.Month != lastMonth) { Console.WriteLine(DateTime.Now + " - Time: " + timeSlice.Time); lastMonth = timeSlice.Time.Month; } count++; } Console.WriteLine("Count: " + count); stopwatch.Stop(); Console.WriteLine("Elapsed time: " + stopwatch.Elapsed); }
public string ProcessBenchmark(WriterCommand command) { try { var benchmark = new BenchmarkTest(command.ThreadsCount, command.DataCount); var testTypes = ParseTestTypes(command.TestType, () => new DbWriterAdapter(command.Host, command.Port, command.TableName), command.Generator, new KeyGenerator(command.KeyRange)); foreach (var func in testTypes) { benchmark.AddLoadTestFactory(func); } benchmark.Run(); } catch (Exception e) { return(e.Message); } return(string.Empty); }
public void PlusReturnValueAddsTest() { BenchmarkTest <int, int> test = new BenchmarkTest <int, int>(x => x, "foo"); Assert.AreSame(test, EmptySuite.Plus(test).First()); }
public static int Main(string[] args) { List <string> temp = new List <string>(args); Verbose = temp.Remove("/verbose") || temp.Remove("-verbose"); OtherFormats = temp.Remove("/formats") || temp.Remove("-formats"); foreach (string arg in temp) { if (arg.StartsWith("/log:", StringComparison.OrdinalIgnoreCase) || arg.StartsWith("-log:", StringComparison.OrdinalIgnoreCase)) { _logFile = arg.Substring(5); if (!String.IsNullOrEmpty(_logFile)) { File.AppendAllText(_logFile, Environment.NewLine + "Started benchmarks at " + DateTime.Now + Environment.NewLine); } temp.Remove(arg); break; } } if (true == (FastTest = (temp.Remove("/fast") || temp.Remove("-fast")))) { TargetTime = TimeSpan.FromSeconds(10); } RunBenchmark = BenchmarkV1; if (temp.Remove("/v2") || temp.Remove("-v2")) { Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime; Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1); RunBenchmark = BenchmarkV2; } if (temp.Remove("/all") || temp.Remove("-all")) { if (FastTest) { TargetTime = TimeSpan.FromSeconds(5); } foreach (KeyValuePair <string, string> item in MakeTests()) { temp.Add(item.Key); temp.Add(item.Value); } } args = temp.ToArray(); if (args.Length < 2 || (args.Length % 2) != 0) { Console.Error.WriteLine("Usage: ProtoBench [/fast] <descriptor type name> <input data>"); Console.Error.WriteLine("The descriptor type name is the fully-qualified message name,"); Console.Error.WriteLine( "including assembly - e.g. Google.ProtocolBuffers.BenchmarkProtos.Message1,ProtoBench"); Console.Error.WriteLine("(You can specify multiple pairs of descriptor type name and input data.)"); return(1); } bool success = true; for (int i = 0; i < args.Length; i += 2) { success &= RunTest(args[i], args[i + 1], null); } return(success ? 0 : 1); }
private void StartBenchmark() { if (!btnStart.Enabled) { return; } cbTest.Enabled = btnStart.Enabled = false; btnStop.Enabled = true; TokenSource = new CancellationTokenSource(); progressBar.Style = ProgressBarStyle.Marquee; BenchmarkTest benchmark = cbTest.SelectedItem as BenchmarkTest; MethodInfo theMethod = GetType().GetMethod(benchmark.FunctionName); if (!benchmark.Name.Equals(StressCPUTestName)) { lbSingleThreadResults.Text = $"Single Thread: Running {SingleThreadTests} tests"; lbMultiThreadResults.Text = $"Multi Thread: Running {MultiThreadTests} tests"; } Task.Factory.StartNew(() => { try { if (benchmark.Name.Equals(StressCPUTestName)) { while (true) { if (Token.IsCancellationRequested) { break; } Parallel.For(0, MultiThreadTests, i => { if (Token.IsCancellationRequested) { return; } theMethod.Invoke(this, null); }); } return; } Stopwatch sw = Stopwatch.StartNew(); for (int i = 0; i < SingleThreadTests; i++) { if (Token.IsCancellationRequested) { Token.ThrowIfCancellationRequested(); } theMethod.Invoke(this, null); } sw.Stop(); Invoke((MethodInvoker) delegate { // Running on the UI thread UpdateResults(true, sw.ElapsedMilliseconds); }); if (Token.IsCancellationRequested) { Token.ThrowIfCancellationRequested(); } sw.Restart(); Parallel.For(0, MultiThreadTests, i => { if (Token.IsCancellationRequested) { return; } theMethod.Invoke(this, null); }); sw.Stop(); if (Token.IsCancellationRequested) { Token.ThrowIfCancellationRequested(); } Invoke((MethodInvoker) delegate { // Running on the UI thread UpdateResults(false, sw.ElapsedMilliseconds); }); } catch (OperationCanceledException) { } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { Invoke((MethodInvoker)StopBenchmark); } }, Token); }
public static void Main(string[] args) { string filePath = ""; int sampleSize = -1; int dbSize = -1; double minSupport = -1; int k = -1; bool help = false; bool benchmark = false; long killTime = int.MaxValue; OptionSet p = new OptionSet(); p.Add("f|file=", "Source data file {PATH}.", arg => filePath = arg); p.Add("b|benchmark", "Benchmark performance.", arg => { if (arg != null) { benchmark = true; } }); p.Add("s|support=", "Minimum pattern {SUPPORT}.", arg => { if (arg != null) { minSupport = double.Parse(arg); } }); p.Add("z|size=", "Sample {SIZE}.", arg => { if (arg != null) { sampleSize = int.Parse(arg); } }); p.Add("d|db-size=", "Database {SIZE}.", arg => { if (arg != null) { dbSize = int.Parse(arg); } }); p.Add("k|top-k=", "Mine top-{K} sequences.", arg => { if (arg != null) { k = int.Parse(arg); } }); p.Add("kill=", "Stop program after {TIME} miliseconds", arg => { if (arg != null) { killTime = int.Parse(arg); } }); p.Add("?|h|help", "Show this message and exit.", arg => { if (arg != null) { help = true; } }); try { p.Parse(args); } catch {} if (benchmark && filePath != "" && sampleSize >= 500 && dbSize > 0) { List <double> minSupports = new List <double>(); minSupports.Add(0.01); minSupports.Add(0.025); minSupports.Add(0.05); minSupports.Add(0.1); // TODO: use top-k here BenchmarkTest.StartBenchmark(filePath, minSupports, new List <int>(), sampleSize, dbSize); } else if (!help && filePath != "" && (minSupport > 0 || k > 0) && sampleSize >= 500 && dbSize > 0) { if (k > 0 && minSupport > 0) { printHelp(p); } else { Console.WriteLine("Kill-after: " + killTime); processFile(filePath, minSupport, k, k > 0, sampleSize, dbSize, killTime).Wait(); } } else { printHelp(p); } }
public void execute(BenchmarkTest test) { // clear previous results for (int i = 0; i < timers.Length; i++) { timers[i] = null; } // loop for the specified number of iterations or until the time limit long startTime = NanoTime.Now; for (int i = 0; i < timers.Length && ((NanoTime.Now - startTime) / 1000000000) < timeLimit; i++) { UI.printInfo(UI.Module.BENCH, "Running iteration {0}", (i + 1)); timers[i] = new Timer(); test.kernelBegin(); timers[i].start(); test.kernelMain(); timers[i].end(); test.kernelEnd(); } // report stats double avg = 0; double min = double.PositiveInfinity; double max = double.NegativeInfinity; int n = 0; foreach (Timer t in timers) { if (t == null) { break; } double s = t.seconds(); min = Math.Min(min, s); max = Math.Max(max, s); avg += s; n++; } if (n == 0) { return; } avg /= n; double stdDev = 0; foreach (Timer t in timers) { if (t == null) { break; } double s = t.seconds(); stdDev += (s - avg) * (s - avg); } stdDev = Math.Sqrt(stdDev / n); UI.printInfo(UI.Module.BENCH, "Benchmark results:"); UI.printInfo(UI.Module.BENCH, " * Iterations: {0}", n); UI.printInfo(UI.Module.BENCH, " * Average: {0}", Timer.tostring(avg)); UI.printInfo(UI.Module.BENCH, " * Fastest: {0}", Timer.tostring(min)); UI.printInfo(UI.Module.BENCH, " * Longest: {0}", Timer.tostring(max)); UI.printInfo(UI.Module.BENCH, " * Deviation: {0}", Timer.tostring(stdDev)); for (int i = 0; i < timers.Length && timers[i] != null; i++) { UI.printDetailed(UI.Module.BENCH, " * Iteration {0}: {1}", i + 1, timers[i]); } }
public static JsonObjectCollection ConvertToJson(BenchmarkTest benchmark, ReportType type) { JsonObjectCollection jsonBenchmark = new JsonObjectCollection("BenchmarkTest"); // Test info parameters. JsonObjectCollection jsonSettings = new JsonObjectCollection("TestInfo"); jsonSettings.Add(new JsonNumericValue("FlowCount", benchmark.FlowCount)); jsonSettings.Add(new JsonNumericValue("RecordCount", benchmark.RecordCount)); jsonSettings.Add(new JsonNumericValue("Randomness", benchmark.Randomness * 100)); long elapsedTime = benchmark.EndTime.Ticks - benchmark.StartTime.Ticks; jsonSettings.Add(new JsonNumericValue("ElapsedTime", new TimeSpan(elapsedTime).TotalMilliseconds)); JsonObjectCollection jsonDatabase = new JsonObjectCollection("Database"); jsonDatabase.Add(new JsonStringValue("Name", benchmark.Database.Name)); jsonDatabase.Add(new JsonStringValue("IndexingTechnology", benchmark.Database.IndexingTechnology.ToString())); jsonDatabase.Add(new JsonStringValue("Category", benchmark.Database.Name)); jsonDatabase.Add(new JsonNumericValue("AverageWriteSpeed", benchmark.GetSpeed(TestMethod.Write))); jsonDatabase.Add(new JsonNumericValue("AverageReadSpeed", benchmark.GetSpeed(TestMethod.Read))); jsonDatabase.Add(new JsonNumericValue("AverageSecondaryReadSpeed", benchmark.GetSpeed(TestMethod.SecondaryRead))); jsonDatabase.Add(new JsonNumericValue("WritePeakMemoryUsage", benchmark.GetPeakWorkingSet(TestMethod.Write) / (1024.0 * 1024.0))); jsonDatabase.Add(new JsonNumericValue("ReadPeakMemoryUsage", benchmark.GetPeakWorkingSet(TestMethod.Read) / (1024.0 * 1024.0))); jsonDatabase.Add(new JsonNumericValue("SecondaryReadPeakMemoryUsage", benchmark.GetPeakWorkingSet(TestMethod.SecondaryRead) / (1024.0 * 1024.0))); jsonDatabase.Add(new JsonNumericValue("Size", benchmark.DatabaseSize / (1024.0 * 1024.0))); JsonObjectCollection jsonDatabaseSettings = new JsonObjectCollection("Settings"); if (benchmark.Database.Settings != null) { foreach (var item in benchmark.Database.Settings) { jsonDatabaseSettings.Add(new JsonStringValue(item.Key, item.Value)); } } jsonDatabase.Add(jsonDatabaseSettings); // Test results. JsonObjectCollection jsonTestData = new JsonObjectCollection("TestResults"); JsonObject jsonWrite = null; JsonObject jsonRead = null; JsonObject jsonSecondaryRead = null; if (type == ReportType.Summary) { jsonWrite = new JsonNumericValue("Write", benchmark.GetSpeed(TestMethod.Write)); jsonRead = new JsonNumericValue("Read", benchmark.GetSpeed(TestMethod.Read)); jsonSecondaryRead = new JsonNumericValue("SecondaryRead", benchmark.GetSpeed(TestMethod.SecondaryRead)); } else // type == ReportType.Detailed { // Get statistics and convert them to JSON. SpeedStatistics writeStat = benchmark.SpeedStatistics[(int)TestMethod.Write]; SpeedStatistics readStat = benchmark.SpeedStatistics[(int)TestMethod.Read]; SpeedStatistics secondaryReadStat = benchmark.SpeedStatistics[(int)TestMethod.SecondaryRead]; jsonWrite = ConvertStatisticToJson(writeStat, "Write"); jsonRead = ConvertStatisticToJson(readStat, "Read"); jsonSecondaryRead = ConvertStatisticToJson(secondaryReadStat, "SecondaryRead"); } jsonTestData.Add(jsonWrite); jsonTestData.Add(jsonRead); jsonTestData.Add(jsonSecondaryRead); // Form the end JSON structure. jsonBenchmark.Add(jsonSettings); jsonBenchmark.Add(jsonDatabase); jsonBenchmark.Add(jsonTestData); return(jsonBenchmark); }
protected abstract void Execute(BenchmarkTest test);
protected override void Execute(BenchmarkTest test) { Parallel.For(0, test.NTimes, i => test.Function.Invoke()); }
public static void ExportDetailedTestResults(List <BenchmarkTest> sessions, string path) { if (sessions.Count == 0) { return; } // ---Write Detailed Results File--- using (StreamWriter writer = new StreamWriter(path)) { // write settings ExportSettings(writer, sessions[0]); // write computer configuration writer.WriteLine(); ExportComputerConfiguration(writer, SystemUtils.GetComputerConfiguration()); writer.WriteLine(); // write databases writer.WriteLine(String.Join(";;;;;;;;;;;", sessions.Select(x => x.Database.Name))); writer.WriteLine(String.Join(";", Enumerable.Repeat("Records;Write time;Read time;Secondary read time;Average write;Average read;Average secondary read;Moment write;Moment read;Moment secondary read;", sessions.Count))); StringBuilder builder = new StringBuilder(); for (int i = 0; i < BenchmarkTest.INTERVAL_COUNT; i++) { for (int k = 0; k < sessions.Count; k++) { BenchmarkTest session = sessions[k]; // get statistics SpeedStatistics writeStat = session.SpeedStatistics[(int)TestMethod.Write]; SpeedStatistics readStat = session.SpeedStatistics[(int)TestMethod.Read]; SpeedStatistics secondaryReadStat = session.SpeedStatistics[(int)TestMethod.SecondaryRead]; // calculate average speeds var avgWriteSpeed = writeStat.GetAverageSpeedAt(i); var avgReadSpeed = readStat.GetAverageSpeedAt(i); var avgSecondaryReadSpeed = secondaryReadStat.GetAverageSpeedAt(i); // calculate moment speeds var momentWriteSpeed = writeStat.GetMomentSpeedAt(i); var momentReadSpeed = readStat.GetMomentSpeedAt(i); var momentSecondaryReadSpeed = secondaryReadStat.GetMomentSpeedAt(i); // number of records & write timespan var rec = writeStat.GetRecordAt(i); builder.AppendFormat("{0};{1};", rec.Key, rec.Value.TotalMilliseconds); // read timespan rec = readStat.GetRecordAt(i); builder.AppendFormat("{0};", rec.Value.TotalMilliseconds); // secondary read timespan rec = secondaryReadStat.GetRecordAt(i); builder.AppendFormat("{0};", rec.Value.TotalMilliseconds); // speeds builder.Append(avgWriteSpeed + ";"); builder.Append(avgReadSpeed + ";"); builder.Append(avgSecondaryReadSpeed + ";"); builder.Append(momentWriteSpeed + ";"); builder.Append(momentReadSpeed + ";"); builder.Append(momentSecondaryReadSpeed + ";"); builder.Append(";"); } writer.WriteLine(builder.ToString()); builder.Clear(); } // write size writer.WriteLine(); writer.WriteLine(String.Join(";;;;;;;;;;;", Enumerable.Repeat("Size(MB)", sessions.Count))); writer.WriteLine(String.Join(";;;;;;;;;;;", sessions.Select(x => x.Database.Size / (1024.0 * 1024.0)))); } }
public void PlusReturnValueAddsTest() { BenchmarkTest<int, int> test = new BenchmarkTest<int, int>(x => x, "foo"); Assert.AreSame(test, EmptySuite.Plus(test).First()); }