public void GenerateOneBencharkInstance_JobParametersList_LengthIsCorrect() { IGenerationArgs generationArgsMock = Mock.Of <IGenerationArgs>(generationArgs => generationArgs.NumberOfJobs == 10); BenchmarkInstance bi = BPMGeneratorMethods.GenerateOneBencharkInstance(generationArgsMock); bi.JobsList.Should().HaveCount(generationArgsMock.NumberOfJobs); }
public BenchmarkProportionParameter(BenchmarkInstance benchmark) : base( $"{benchmark.Suite.Name}.{benchmark.Name}.Proportion", $"Sets execution proportion for benchmark {benchmark.Name} in suite {benchmark.Suite.Name}", "100" ) { _benchmark = benchmark; }
public void GenerateOneBencharkInstance_MachineCapacity_ValueIsCorrect() { IGenerationArgs generationArgsMock = Mock.Of <IGenerationArgs>(generationArgs => generationArgs.MachineCapacity == 55); BenchmarkInstance bi = BPMGeneratorMethods.GenerateOneBencharkInstance(generationArgsMock); bi.MachineCapacity.Should().Be(generationArgsMock.MachineCapacity); }
public void GenerateOneBencharkInstance_NumberOfJobs_ValueIsCorrect() { IGenerationArgs generationArgsMock = Mock.Of <IGenerationArgs>(generationArgs => generationArgs.NumberOfJobs == 10); BenchmarkInstance bi = BPMGeneratorMethods.GenerateOneBencharkInstance(generationArgsMock); bi.NumberOfJobs.Should().Be(generationArgsMock.NumberOfJobs); }
public BenchmarkSelectedParameter(BenchmarkInstance benchmark) : base( $"{benchmark.Suite.Name}.{benchmark.Name}.Selected", $"Selecting benchmark {benchmark.Name} in suite {benchmark.Suite.Name}", "true" ) { _benchmark = benchmark; }
public BenchmarkProportionParameter(BenchmarkInstance benchmark) : base( string.Format("{0}.{1}.Proportion", benchmark.Suite.Name, benchmark.Name), string.Format("Sets execution proportion for benchmark {0} in suite {1}", benchmark.Name, benchmark.Suite.Name), "100" ) { _benchmark = benchmark; }
public BenchmarkSelectedParameter(BenchmarkInstance benchmark) : base( string.Format("{0}.{1}.Selected", benchmark.Suite.Name, benchmark.Name), string.Format("Selecting benchmark {0} in suite {1}", benchmark.Name, benchmark.Suite.Name), "true" ) { _benchmark = benchmark; }
public void BenchmarkInstance_NewObjectMachineCapacity_IsCorrect() { List <JobParameters> list = new List <JobParameters>(); var jobParametersMock = It.IsAny <JobParameters>(); list.Add(jobParametersMock); var benchmark = new BenchmarkInstance(5, 10, "Test", list); benchmark.MachineCapacity.Should().Be(10); }
public void BenchmarkInstance_NewObjectNumberOfJobs_IsCorrect() { List <JobParameters> list = new List <JobParameters>(); var jobParametersMock = It.IsAny <JobParameters>(); list.Add(jobParametersMock); var benchmark = new BenchmarkInstance(5, 10, "Test", list); benchmark.NumberOfJobs.Should().Be(5); }
public void BenchmarkInstance_NewObjectJobsList_ContaintTwoObjects() { List <JobParameters> list = new List <JobParameters>(); var jobParametersMock = It.IsAny <JobParameters>(); list.Add(jobParametersMock); list.Add(jobParametersMock); var benchmark = new BenchmarkInstance(5, 10, "Test", list); benchmark.JobsList.Should().HaveCount(2); }
private void StopBenchmarkingThreads() { lock (SyncRoot) { _runningBenchmark = null; if (_tasks != null) { for (int index = 0; index < _tasks.Length; index++) { //_tasks[index].Abort(); _tasks[index] = null; } _tasks = null; } } }
private void StartBenchmarkingThreads(BenchmarkInstance benchmark) { lock (SyncRoot) { _runningBenchmark = benchmark; _tasks = new Task[Process.NumberOfThreads]; for (int index = 0; index < Process.NumberOfThreads; index++) { _tasks[index] = Task.Run(() => PerformBenchmarking(_controlTaskCancellation.Token)); //_tasks[index].Name = string.Format("Benchmarking Thread #{0}/{1}", index, Process.NumberOfThreads); //_tasks[index].Priority = ThreadPriority.Highest; //_tasks[index].Start(); } //Task.WaitAll(_tasks); } }
private void Execute(CancellationToken token) { int lastExecutedTicks = System.Environment.TickCount; int benchmarkCount = _activeBenchmarks.Count; BenchmarkInstance onlyBenchmark = benchmarkCount == 1 ? _activeBenchmarks[0] : null; try { while (_running && !token.IsCancellationRequested) { if (_configuration.MeasurementType == MeasurementType.Nominal) { double ticksToNextTransaction = _ticksPerTransaction - (System.Environment.TickCount - lastExecutedTicks); // Wait to ensure nominal transaction rate if (ticksToNextTransaction > 0) { Thread.Sleep((int)ticksToNextTransaction); } } var benchmark = onlyBenchmark ?? ChooseBenchmarkProportionally(); if (benchmark != null) { ExecuteBenchmark(benchmark); lastExecutedTicks = System.Environment.TickCount; _aggregator.IncrementCounter(1, lastExecutedTicks); } else { Thread.Sleep(500); } } } catch (OperationCanceledException) { // Ignore the exception... } }
protected void ExecuteBenchmark(BenchmarkInstance benchmark) { try { benchmark.Execute(); } catch (ThreadAbortException) { throw; } catch (Exception ex) { ReportError(ex.Message); if (!Process.IsForceContinue) { throw ex; } } }
private void ExecuteBenchmark(BenchmarkInstance benchmark) { try { benchmark.Execute(); } catch (ThreadAbortException) { throw; } catch (Exception ex) { _results.NotifyError(ex); if (!_configuration.ForceContinue) { throw; } } }
private void PerformBenchmarking(CancellationToken token) { BenchmarkInstance benchmark = _runningBenchmark; int lastExecutedTicks = System.Environment.TickCount; int endTicks = System.Environment.TickCount + Process.Duration; try { int currentTicks = System.Environment.TickCount; while (_running && benchmark == _runningBenchmark && endTicks > currentTicks) { if (Process.MeasurementType == MeasurementType.Nominal) { double ticksToNextTransaction = _ticksPerTransaction - (currentTicks - lastExecutedTicks); // Wait to ensure nominal transaction rate if (ticksToNextTransaction > 0) { Thread.Sleep((int)ticksToNextTransaction); } } lastExecutedTicks = currentTicks; ExecuteBenchmark(benchmark); currentTicks = System.Environment.TickCount; IncrementCounter(1, lastExecutedTicks); if (token.IsCancellationRequested) { break; } } } catch (OperationCanceledException) { // Ignore the exception... } }
private void PerformBenchmarking(CancellationToken token) { System.Random randomGenerator = new System.Random(); int lastExecutedTicks = System.Environment.TickCount; int numberOfTests = Benchmarks.Count; BenchmarkInstance firstBenchmark = Benchmarks.Count == 1 ? Benchmarks[0] : null; NotifyResultUpdate(ExecutionState.Starting); try { while (_running) { if (Process.MeasurementType == MeasurementType.Nominal) { double ticksToNextTransaction = _ticksPerTransaction - (System.Environment.TickCount - lastExecutedTicks); // Wait to ensure nominal transaction rate if (ticksToNextTransaction > 0) { Thread.Sleep((int)ticksToNextTransaction); } } if (numberOfTests == 1) { ExecuteBenchmark(firstBenchmark); lastExecutedTicks = System.Environment.TickCount; IncrementCounter(1, lastExecutedTicks); } else if (numberOfTests == 0) { Thread.Sleep(500); } else { double selector = randomGenerator.NextDouble(); for (int index = 0; index < Benchmarks.Count; index++) { var benchmark = Benchmarks[index]; if (benchmark.IsTriggered(selector)) { lastExecutedTicks = System.Environment.TickCount; ExecuteBenchmark(benchmark); IncrementCounter(1, lastExecutedTicks); break; } } } if (token.IsCancellationRequested) { break; } } } catch (OperationCanceledException) { // Ignore the exception... } finally { NotifyResultUpdate(ExecutionState.Completed); } }