public void General_Test()
{
var time1 = new TimeSpan(0, 0, 0, 59);
var time2 = new TimeSpan(0, 0, 2, 1);
var time3 = new TimeSpan(0, 1, 0, 0); // max
var statistics = new SpeedStatistics("TestName");
statistics.Add(time1);
statistics.Add(time2);
statistics.Add(time3);
Assert.AreEqual("TestName", statistics.Name, "Name");
Assert.AreEqual(time1, statistics.ExecutionTimes.ToList()[0], "time1");
Assert.AreEqual(time2, statistics.ExecutionTimes.ToList()[1], "time2");
Assert.AreEqual(time3, statistics.ExecutionTimes.ToList()[2], "time3");
Assert.AreEqual(3, statistics.Count(), "Count();");
Assert.AreEqual(time1, statistics.Min(), "Max();");
Assert.AreEqual(time3, statistics.Max(), "Min();");
Assert.AreEqual(new TimeSpan(0, 0, 21, 0), statistics.Average(), "Average();");
Assert.AreEqual(new TimeSpan(0, 1, 2, 60), statistics.Total(), "Total();");
}
public static JsonObjectCollection ConvertStatisticToJson(SpeedStatistics statistic, string statisticName)
{
JsonObjectCollection jsonTest = new JsonObjectCollection(statisticName);
JsonArrayCollection jsonRecords = new JsonArrayCollection("Records");
JsonArrayCollection jsonTime = new JsonArrayCollection("Time");
JsonArrayCollection jsonAverageSpeed = new JsonArrayCollection("AverageSpeed");
JsonArrayCollection jsonMomentSpeed = new JsonArrayCollection("MomentSpeed");
for (int i = 0; i < BenchmarkTest.INTERVAL_COUNT; i++)
{
// Number of records & timespan.
var rec = statistic.GetRecordAt(i);
jsonRecords.Add(new JsonNumericValue(rec.Key));
jsonTime.Add(new JsonNumericValue(rec.Value.TotalMilliseconds));
// Average speed.
var averageSpeed = statistic.GetAverageSpeedAt(i);
jsonAverageSpeed.Add(new JsonNumericValue(averageSpeed));
// Moment write speed.
var momentSpeed = statistic.GetMomentSpeedAt(i);
jsonMomentSpeed.Add(new JsonNumericValue(momentSpeed));
}
jsonTest.Add(jsonRecords);
jsonTest.Add(jsonTime);
jsonTest.Add(jsonAverageSpeed);
jsonTest.Add(jsonMomentSpeed);
return(jsonTest);
}
public BenchmarkTest(Database database, int flowCount, long recordCount, float randomness, CancellationTokenSource cancellation)
{
Database = database;
FlowCount = flowCount;
RecordCount = recordCount;
Randomness = randomness;
KeysType = Randomness == 0f ? KeysType.Sequential : KeysType.Random;
// Statistics.
int length = Enum.GetValues(typeof(TestMethod)).Length - 1;
SpeedStatistics = new SpeedStatistics[length];
MemoryStatistics = new MemoryStatistics[length];
int step = (int)((recordCount) / INTERVAL_COUNT);
for (int i = 0; i < length; i++)
{
SpeedStatistics[i] = new SpeedStatistics(INTERVAL_COUNT);
SpeedStatistics[i].Step = step;
MemoryStatistics[i] = new MemoryStatistics(INTERVAL_COUNT);
MemoryStatistics[i].Step = step;
}
Cancellation = cancellation;
}
public PerformanceWatch(string name, int step)
{
this.name = name;
SpeedStatistics = new SpeedStatistics(Benchmark.INTERVAL_COUNT, step);
MemoryStatistics = new MemoryStatistics(Benchmark.INTERVAL_COUNT, step);
}
/// <summary>
/// Stop all statistics.
/// </summary>
public void Stop()
{
SpeedStatistics.Stop();
MemoryStatistics.Stop();
if (OnStop != null)
{
OnStop(this);
}
}
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);
}
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))));
}
}
/// <summary>
/// Add point (measurement) to all statistics.
/// </summary>
public void Add()
{
SpeedStatistics.Add();
MemoryStatistics.Add();
}
