public void SimpleStoreTest()
{
var config = new MeasurementStoreConfig()
{
StoreType = StoreType.MicrosoftSqlServer,
ConnectionString = @"server=(localdb)\MSSqlLocalDb;Database=SimpleStoreTest"
};
var trace = new MeasuredTrace()
{
PackageFileName = "xyz"
};
var measurement = new CpuSampled()
{
ProcessName = "Foo", IsDpc = true, Count = 100, TotalSamplesDuringInterval = 1000, CpuCoreCount = 1
};
var measurement2 = new TraceAttribute()
{
Name = "FooA"
};
trace.AddMeasurement(measurement);
trace.AddMeasurement(measurement2);
using (var store = new MeasurementStore(config))
{
store.Database.EnsureCreated();
store.Database.EnsureDeleted();
store.Database.EnsureCreated();
Assert.True(store.SaveTraceAndMeasurements(trace) == 3);
}
}
public void SimpleProcessingTest()
{
var dataSource =
@"https://github.com/MatthewMWR/WinPerf/blob/master/Scenarios/BOOT-REFERENCE__NormalLightlyManaged.zip?raw=true";
var dataIncomingDir = Path.Combine(Path.GetTempPath(), "SimpleProcessingTest-In");
Directory.CreateDirectory(dataIncomingDir);
var dataArchiveDir = Path.Combine(Path.GetTempPath(), "SimpleProcessingTest-Archive");
Directory.CreateDirectory(dataArchiveDir);
var webClient = new WebClient();
webClient.DownloadFile(dataSource, Path.Combine(dataIncomingDir, "Original.zip"));
var testCopyCount = 30;
var i = 0;
while (i < testCopyCount)
{
i++;
File.Copy(Path.Combine(dataIncomingDir, "Original.zip"), Path.Combine(dataIncomingDir, $"Copy{i}.zip"), true);
}
var storeConfig = new MeasurementStoreConfig()
{
StoreType = StoreType.MicrosoftSqlServer,
ConnectionString = @"server=(localdb)\MSSqlLocalDb;Database=SimpleProcessingTest"
};
var processingConfig = new ProcessingConfig()
{
DestinationDataPath = dataArchiveDir
};
processingConfig.IncomingDataPaths.Add(dataIncomingDir);
using (var store = new MeasurementStore(storeConfig))
{
store.Database.EnsureCreated();
store.Database.EnsureDeleted();
store.Database.EnsureCreated();
}
DoWork.InvokeProcessingOnce(processingConfig, storeConfig);
using (var store = new MeasurementStore(storeConfig))
{
Assert.True(store.ProcessingRecords.Count() == testCopyCount + 1);
Assert.True(store.ProcessingRecords.Count(pr => pr.ProcessingState == ProcessingState.Measured) ==
processingConfig.ParallelMeasuringThrottle);
Assert.True(store.ProcessingRecords.Count(pr => pr.ProcessingState == ProcessingState.Moved) ==
processingConfig.ParallelMovesThrottle - processingConfig.ParallelMeasuringThrottle);
}
DoWork.InvokeProcessingOnce(processingConfig, storeConfig);
DoWork.InvokeProcessingOnce(processingConfig, storeConfig);
DoWork.InvokeProcessingOnce(processingConfig, storeConfig);
using (var store = new MeasurementStore(storeConfig))
{
Assert.True(store.ProcessingRecords.Count(pr => pr.ProcessingState == ProcessingState.Measured) == testCopyCount + 1);
}
}
public void BasicQueriesWork()
{
var config = new MeasurementStoreConfig()
{
StoreType = StoreType.MicrosoftSqlServer,
ConnectionString = @"server=(localdb)\MSSqlLocalDb;Database=QueryTests;MultipleActiveResultSets = True"
};
using (var store = new MeasurementStore(config))
{
store.Database.EnsureCreated();
store.Database.EnsureDeleted();
store.Database.EnsureCreated();
foreach (var n in new[] { 1, 2, 3 })
{
var trace = new MeasuredTrace()
{
PackageFileName = $"Trace{n}"
};
var measurement = new CpuSampled()
{
ProcessName = "ProcessX",
IsDpc = true,
Count = 100,
TotalSamplesDuringInterval = 1000,
CpuCoreCount = 1
};
var measurement2 = new TraceAttribute()
{
Name = "AttributeX", WholeNumberValue = n
};
trace.AddMeasurement(measurement);
trace.AddMeasurement(measurement2);
Assert.True(store.SaveTraceAndMeasurements(trace) == 3);
trace.ProcessingRecords.Add(new ProcessingRecord()
{
Path = "xxx",
StateChangeTime = new DateTime(1980, 2, 2),
ProcessingState = ProcessingState.Discovered
});
Assert.True(store.SaveChanges() == 1);
}
}
using (var store = new MeasurementStore(config))
{
foreach (var trace in store.GetTraceByFilter(t => true, true))
{
Assert.NotEmpty(trace.ProcessingRecords);
var measurements = trace.GetMeasurementsAll();
Assert.True(measurements.Count() == 2);
}
}
}
//Einstieg ins Programm
static void Main(string[] args)
{
System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.LowLatency;
var generatorFor1kb = new GeneratorFor1kb();
var generatorFor10kb = new GeneratorFor10kb();
var generatorFor100kb = new GeneratorFor100kb();
var generatorFor1000kb = new GeneratorFor1000kb();
var databaseMongo = new MongoDB();
var databasePost = new PostGreSQL();
var databaseMemory = new InMemory();
var store = new MeasurementStore();
var resultLogger = new CSVResultLogger();
var export = new Export(store, resultLogger);
var logger = new ConsoleLogger();
List <IMeasureAlgorithm> CreateAlgorithmForDatabase(IDatabase db, ILogger logger, IDocumentGenerator documentGenerator, string documentSize)
{
var algorithms = new List <IMeasureAlgorithm>();
algorithms.Add(new SingleInsert(db, logger));
algorithms.Add(new SingleUpdate(db, logger));
algorithms.Add(new SingleDelete(db, logger));
algorithms.Add(new SingleSelect(db, logger));
algorithms.Add(new BulkInsert(db, logger));
algorithms.Add(new BulkUpdate(db, logger));
algorithms.Add(new BulkDelete(db, logger));
algorithms.Add(new BulkSelect(db, logger));
var testAlgorithms = new List <IMeasureAlgorithm>();
testAlgorithms.Add(new SingleInsert(db, logger));
testAlgorithms.Add(new SingleUpdate(db, logger));
testAlgorithms.Add(new SingleDelete(db, logger));
testAlgorithms.Add(new SingleSelect(db, logger));
SetUpEmptyDB(db);
foreach (var testAlgorithm in testAlgorithms)
{
testAlgorithm.StartMeasure(generatorFor1kb.GetDocumentsForMeasurement);
testAlgorithm.CleanUp(db, documentGenerator);
}
string database = "";
if (db is MongoDB)
{
database = "MongoDB";
}
if (db is PostGreSQL)
{
database = "PostGreSQL";
}
if (db is InMemory)
{
database = "InMemory";
}
SetUpEmptyDB(db);
foreach (var algorithm in algorithms)
{
store.SaveResult($"{algorithm}:Empty", algorithm
.StartMeasure(documentGenerator.GetDocumentsForMeasurement), documentSize, database);
algorithm.CleanUp(db, documentGenerator);
}
SetUpFilledDB(db);
foreach (var algorithm in algorithms)
{
store.SaveResult($"{algorithm}:Filled", algorithm
.StartMeasure(documentGenerator.GetDocumentsForMeasurement), documentSize, database);
algorithm.CleanUp(db, documentGenerator);
}
return(algorithms);
}
var jsonString1kb = JsonConvert.SerializeObject(generatorFor1kb.GetDocumentsForMeasurement[0]);
var jsonString10kb = JsonConvert.SerializeObject(generatorFor10kb.GetDocumentsForMeasurement[0]);
var jsonString100kb = JsonConvert.SerializeObject(generatorFor100kb.GetDocumentsForMeasurement[0]);
var jsonString1000kb = JsonConvert.SerializeObject(generatorFor1000kb.GetDocumentsForMeasurement[0]);
Console.WriteLine($"One Document of 1kb Generator.List is size of {jsonString1kb.Length * sizeof(char)} Bytes or {jsonString1kb.Length * sizeof(char) / 1000} Kilobytes");
Console.WriteLine($"One Document of 10kb Generator.List is size of {jsonString10kb.Length * sizeof(char)} Bytes or {jsonString10kb.Length * sizeof(char) / 1000} Kilobytes");
Console.WriteLine($"One Document of 100kb Generator.List is size of {jsonString100kb.Length * sizeof(char)} Bytes or {jsonString100kb.Length * sizeof(char) / 1000} Kilobytes");
Console.WriteLine($"One Document of 1000kb Generator.List is size of {jsonString1000kb.Length * sizeof(char)} Bytes or {jsonString1000kb.Length * sizeof(char) / 1000} Kilobytes");
Console.WriteLine("\nStarting Tests for 1kb");
Console.WriteLine("\nPostgres:");
CreateAlgorithmForDatabase(databasePost, logger, generatorFor1kb, "1kb");
Console.WriteLine("\nMongoDB:");
CreateAlgorithmForDatabase(databaseMongo, logger, generatorFor1kb, "1kb");
Console.WriteLine("\nIn Memory:");
CreateAlgorithmForDatabase(databaseMemory, logger, generatorFor1kb, "1kb");
Console.WriteLine("\nStarting Tests for 10kb");
Console.WriteLine("\nPostgres:");
CreateAlgorithmForDatabase(databasePost, logger, generatorFor10kb, "10kb");
Console.WriteLine("\nMongoDB:");
CreateAlgorithmForDatabase(databaseMongo, logger, generatorFor10kb, "10kb");
Console.WriteLine("\nIn Memory:");
CreateAlgorithmForDatabase(databaseMemory, logger, generatorFor10kb, "10kb");
Console.WriteLine("\nStarting Tests for 100kb");
Console.WriteLine("\nPostgres:");
CreateAlgorithmForDatabase(databasePost, logger, generatorFor100kb, "100kb");
Console.WriteLine("\nMongoDB:");
CreateAlgorithmForDatabase(databaseMongo, logger, generatorFor100kb, "100kb");
Console.WriteLine("\nIn Memory:");
CreateAlgorithmForDatabase(databaseMemory, logger, generatorFor100kb, "100kb");
Console.WriteLine("\nStarting Tests for 1000kb");
Console.WriteLine("\nPostgres:");
CreateAlgorithmForDatabase(databasePost, logger, generatorFor1000kb, "1000kb");
Console.WriteLine("\nMongoDB:");
CreateAlgorithmForDatabase(databaseMongo, logger, generatorFor1000kb, "1000kb");
Console.WriteLine("\nIn Memory:");
CreateAlgorithmForDatabase(databaseMemory, logger, generatorFor1000kb, "1000kb");
//Export the CSV File into folder
export.ConfigureResult();
void SetUpEmptyDB(IDatabase db)
{
db.CleanDatabase();
Console.WriteLine("Database is empty");
}
void SetUpFilledDB(IDatabase db)
{
db.BulkInsert(generatorFor1kb.GetDocumentsPopulateDatabase);
Console.WriteLine("Database is highly Filled");
}
}
public void SimpleProcessingTest()
{
var dataSource =
@"https://github.com/MatthewMWR/WinPerf/blob/master/Scenarios/BOOT-REFERENCE__NormalLightlyManaged.zip?raw=true";
var dataIncomingDir = Path.Combine(Path.GetTempPath(), "SimpleProcessingTest-In");
Directory.CreateDirectory(dataIncomingDir);
var dataArchiveDir = Path.Combine(Path.GetTempPath(), "SimpleProcessingTest-Archive");
Directory.CreateDirectory(dataArchiveDir);
var dataDownloadStageDir = Path.Combine(Path.GetTempPath(), "SimpleProcessingTest-DownloadStage");
Directory.CreateDirectory(dataDownloadStageDir);
var stagedDownlodFilePath = Path.Combine(dataDownloadStageDir, "original.zip");
if (!File.Exists(stagedDownlodFilePath))
{
var webClient = new WebClient();
webClient.DownloadFile(dataSource, stagedDownlodFilePath);
}
var testCopyCount = 26;
var i = 0;
while (i < testCopyCount)
{
i++;
File.Copy(stagedDownlodFilePath, Path.Combine(dataIncomingDir, $"Copy{i}.zip"), true);
}
var storeConfig = new MeasurementStoreConfig()
{
StoreType = StoreType.MicrosoftSqlServer,
ConnectionString = @"server=(localdb)\MSSqlLocalDb;Database=SimpleProcessingTest"
};
var processingConfig = new ProcessingConfig()
{
DestinationDataPath = dataArchiveDir
};
processingConfig.IncomingDataPaths.Add(dataIncomingDir);
using (var store = new MeasurementStore(storeConfig))
{
store.Database.EnsureCreated();
store.Database.EnsureDeleted();
store.Database.EnsureCreated();
}
Automate.InvokeProcessingOnce(processingConfig, storeConfig);
using (var store = new MeasurementStore(storeConfig))
{
Assert.True(store.Traces.Count() == testCopyCount);
var measuredCount = store.Traces
.Include(t => t.ProcessingRecords)
.Count(t => t.ProcessingRecords.OrderBy(pr => pr.StateChangeTime).Last().ProcessingState == ProcessingState.Measured);
Assert.True(measuredCount == processingConfig.ParallelMeasuringThrottle);
var movedCount = store.ProcessingRecords.Count(pr => pr.ProcessingState == ProcessingState.Moved);
Assert.True(movedCount == processingConfig.ParallelMovesThrottle);
}
Automate.InvokeProcessingOnce(processingConfig, storeConfig);
Automate.InvokeProcessingOnce(processingConfig, storeConfig);
Automate.InvokeProcessingOnce(processingConfig, storeConfig);
using (var store = new MeasurementStore(storeConfig))
{
var measuredCount = store.Traces
.Include(t => t.ProcessingRecords)
.Count(t => t.ProcessingRecords.OrderBy(pr => pr.StateChangeTime).Last().ProcessingState == ProcessingState.Measured);
Assert.True(measuredCount == testCopyCount);
var measuredCountByDifferentPath = store.GetTraceByState(ProcessingState.Measured).Count();
Assert.True(measuredCountByDifferentPath == testCopyCount);
var measuredCountByThirdPath =
store.GetTraceByFilter(t => t.ProcessingRecords.Latest().ProcessingState == ProcessingState.Measured).Count();
Assert.True(measuredCountByThirdPath == testCopyCount);
Assert.True(store.GetTraceByName("copy1.zip", false) != null);
Assert.True(store.GetTraceByFilter(t => t.ProcessingRecords.Count == 3).AsEnumerable().Count() == testCopyCount);
Assert.NotEmpty(store.GetTraceByName("copy1.zip", true).GetMeasurements <DiskIo>());
}
}
