public long Run(Stopwatch stopwatch) { var latch = new ManualResetEvent(false); var expectedCount = _poller.Sequence.Value + _iterations; _pollRunnable.Reset(latch, expectedCount); var processorTask = _executor.Execute(_pollRunnable.Run); stopwatch.Start(); var rb = _ringBuffer; for (var i = 0; i < _iterations; i++) { var next = rb.Next(); rb[next].Value = i; rb.Publish(next); } latch.WaitOne(); stopwatch.Stop(); WaitForEventProcessorSequence(expectedCount); _pollRunnable.Halt(); processorTask.Wait(2000); PerfTestUtil.FailIfNot(_expectedResult, _pollRunnable.Value, $"Poll runnable should have processed {_expectedResult} but was {_pollRunnable.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { _eventHandler.Reset(_iterations - 1); _consumer.Start(); sessionContext.Start(); var spinWait = new SpinWait(); for (long i = 0; i < _iterations; i++) { var data = new PerfEvent { Value = i }; while (_queue.Count == _bufferSize) { spinWait.SpinOnce(); } _queue.Enqueue(data); spinWait.Reset(); } _eventHandler.WaitForSequence(); sessionContext.Stop(); _consumer.Stop(); sessionContext.SetBatchData(_eventHandler.BatchesProcessed, _iterations); PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { var latch = new ManualResetEvent(false); var expectedCount = _poller.Sequence.Value + _iterations; _pollRunnable.Reset(latch, expectedCount); var processorTask = _pollRunnable.Start(); sessionContext.Start(); var ringBuffer = _ringBuffer; for (var i = 0; i < _iterations; i++) { var next = ringBuffer.Next(); ringBuffer[next].Value = i; ringBuffer.Publish(next); } latch.WaitOne(); sessionContext.Stop(); WaitForEventProcessorSequence(expectedCount); _pollRunnable.Halt(); processorTask.Wait(2000); sessionContext.SetBatchData(_pollRunnable.BatchesProcessedCount.Value, _iterations); PerfTestUtil.FailIfNot(_expectedResult, _pollRunnable.Value, $"Poll runnable should have processed {_expectedResult} but was {_pollRunnable.Value}"); return(_iterations); }
public long Run(Stopwatch stopwatch) { long expectedCount = _batchEventProcessor.Sequence.Value + _iterations; _latch.Reset(); _eventHandler.Reset(_latch, expectedCount); var processorTask = _executor.Execute(_batchEventProcessor.Run); stopwatch.Start(); for (long i = 0; i < _iterations; i++) { long sequence = _ringBuffer.Next(); _ringBuffer[sequence].Value = i; _ringBuffer.Publish(sequence); } _latch.WaitOne(); stopwatch.Stop(); PerfTestUtil.WaitForEventProcessorSequence(expectedCount, _batchEventProcessor); _batchEventProcessor.Halt(); processorTask.Wait(2000); PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { _eventHandler.Reset(_iterations - 1); _consumer.Start(); sessionContext.Start(); var spinWait = new SpinWait(); for (long i = 0; i < _iterations; i++) { var data = new PerfEvent { Value = i }; while (!_channel.Writer.TryWrite(data)) { spinWait.SpinOnce(); } spinWait.Reset(); } _eventHandler.Latch.WaitOne(); sessionContext.Stop(); _consumer.Stop(); sessionContext.SetBatchData(_eventHandler.BatchesProcessedCount.Value, _iterations); PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { long expectedCount = _eventProcessor.Sequence.Value + _iterations; _eventHandler.Reset(expectedCount); var processorTask = _eventProcessor.Start(); _eventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5)); sessionContext.Start(); var ringBuffer = _ringBuffer; for (long i = 0; i < _iterations; i++) { var s = ringBuffer.Next(); ringBuffer[s].Value = i; ringBuffer.Publish(s); } _eventHandler.WaitForSequence(); sessionContext.Stop(); PerfTestUtil.WaitForEventProcessorSequence(expectedCount, _eventProcessor); _eventProcessor.Halt(); processorTask.Wait(2000); sessionContext.SetBatchData(_eventHandler.BatchesProcessed, _iterations); PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { var latch = new ManualResetEvent(false); _fizzBuzzHandler.Reset(latch, _batchProcessorFizzBuzz.Sequence.Value + _iterations); var processorTask1 = Task.Run(() => _batchProcessorFizz.Run()); var processorTask2 = Task.Run(() => _batchProcessorBuzz.Run()); var processorTask3 = Task.Run(() => _batchProcessorFizzBuzz.Run()); _batchProcessorFizz.WaitUntilStarted(TimeSpan.FromSeconds(5)); _batchProcessorBuzz.WaitUntilStarted(TimeSpan.FromSeconds(5)); _batchProcessorFizzBuzz.WaitUntilStarted(TimeSpan.FromSeconds(5)); sessionContext.Start(); for (long i = 0; i < _iterations; i++) { var sequence = _ringBuffer.Next(); _ringBuffer[sequence].Value = i; _ringBuffer.Publish(sequence); } latch.WaitOne(); sessionContext.Stop(); _batchProcessorFizz.Halt(); _batchProcessorBuzz.Halt(); _batchProcessorFizzBuzz.Halt(); Task.WaitAll(processorTask1, processorTask2, processorTask3); PerfTestUtil.FailIfNot(_expectedResult, _fizzBuzzHandler.FizzBuzzCounter); return(_iterations); }
public long Run(Stopwatch stopwatch) { var signal = new ManualResetEvent(false); var expectedCount = _batchEventProcessor.Sequence.Value + _iterations * _batchSize; _handler.Reset(signal, expectedCount); var processorTask = _executor.Execute(_batchEventProcessor.Run); stopwatch.Start(); var rb = _ringBuffer; for (var i = 0; i < _iterations; i++) { var hi = rb.Next(_batchSize); var lo = hi - (_batchSize - 1); for (var l = lo; l <= hi; l++) { rb[l].Value = (i); } rb.Publish(lo, hi); } signal.WaitOne(); stopwatch.Stop(); PerfTestUtil.WaitForEventProcessorSequence(expectedCount, _batchEventProcessor); _batchEventProcessor.Halt(); processorTask.Wait(2000); PerfTestUtil.FailIfNot(_expectedResult, _handler.Value, $"Handler should have processed {_expectedResult} events, but was: {_handler.Value}"); return(_batchSize * _iterations); }
public long Run(ThroughputSessionContext sessionContext) { var value = _value; var latch = new ManualResetEvent(false); var expectedCount = _ringBuffer.GetMinimumGatingSequence() + _iterations; _handler.Reset(latch, expectedCount); sessionContext.Start(); var rb = _ringBuffer; for (long l = 0; l < _iterations; l++) { value.Value = l; rb.PublishEvent(Translator.Instance, value); } latch.WaitOne(); sessionContext.Stop(); WaitForEventProcessorSequence(expectedCount); PerfTestUtil.FailIfNot(_expectedResult, _handler.Value); sessionContext.SetBatchData(_handler.BatchesProcessedCount.Value, _iterations); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { ResetCounters(); _workerPool.Start(); sessionContext.Start(); var ringBuffer = _ringBuffer; for (long i = 0; i < _iterations; i++) { var sequence = ringBuffer.Next(); ringBuffer[sequence].Value = i; ringBuffer.Publish(sequence); } _workerPool.DrainAndHalt(); // Workaround to ensure that the last worker(s) have completed after releasing their events Thread.Sleep(1); sessionContext.Stop(); PerfTestUtil.FailIfNot(_iterations, SumCounters()); return(_iterations); }
public long Run(Stopwatch stopwatch) { var latch = new Barrier(_numEventProcessors + 1); var processorTasks = new List <Task>(); for (var i = 0; i < _numEventProcessors; i++) { _handlers[i].Reset(latch, _batchEventProcessors[i].Sequence.Value + _iterations); processorTasks.Add(_executor.Execute(_batchEventProcessors[i].Run)); } stopwatch.Start(); for (long i = 0; i < _iterations; i++) { var sequence = _ringBuffer.Next(); _ringBuffer[sequence].Value = i; _ringBuffer.Publish(sequence); } latch.SignalAndWait(); stopwatch.Stop(); for (var i = 0; i < _numEventProcessors; i++) { _batchEventProcessors[i].Halt(); PerfTestUtil.FailIfNot(_results[i], _handlers[i].Value, $"Result {_results[i]} != {_handlers[i].Value}"); } Task.WaitAll(processorTasks.ToArray()); return(_numEventProcessors * _iterations); }
public long Run(ThroughputSessionContext sessionContext) { var completedSignal = new ManualResetEvent(false); _streamProcessor.Reset(completedSignal); var processorTask = _streamProcessor.Start(); sessionContext.Start(); var ringBuffer = _ringBuffer; for (var i = 0; i < _iterations; i++) { var next = ringBuffer.Next(); ringBuffer[next].Value = i; ringBuffer.Publish(next); } completedSignal.WaitOne(); sessionContext.Stop(); _streamProcessor.Halt(); processorTask.Wait(); sessionContext.SetBatchData(_streamProcessor.BatchesProcessedCount, _iterations); PerfTestUtil.FailIfNot(_expectedResult, _streamProcessor.Value, $"Poll runnable should have processed {_expectedResult} but was {_streamProcessor.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { long expectedCount = _batchEventProcessor.Sequence.Value + _iterations; _eventHandler.Reset(expectedCount); var processorTask = _executor.Execute(() => { using var _ = ThreadAffinityUtil.SetThreadAffinity(0); Thread.CurrentThread.Priority = ThreadPriority.Highest; _batchEventProcessor.Run(); }); _batchEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5)); using var _ = ThreadAffinityUtil.SetThreadAffinity(1); Thread.CurrentThread.Priority = ThreadPriority.Highest; sessionContext.Start(); var ringBuffer = _ringBuffer; for (long i = 0; i < _iterations; i++) { var s = ringBuffer.Next(); ringBuffer[s].Value = i; // ExtraWork(1); ringBuffer.Publish(s); } _eventHandler.WaitForSequence(); sessionContext.Stop(); PerfTestUtil.WaitForEventProcessorSequence(expectedCount, _batchEventProcessor); _batchEventProcessor.Halt(); processorTask.Wait(2000); sessionContext.SetBatchData(_eventHandler.BatchesProcessed, _iterations); PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { var latch = new ManualResetEvent(false); _stepThreeFunctionHandler.Reset(latch, _stepThreeEventProcessor.Sequence.Value + _iterations); var processorTask1 = _stepOneEventProcessor.Start(); var processorTask2 = _stepTwoEventProcessor.Start(); var processorTask3 = _stepThreeEventProcessor.Start(); _stepOneEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5)); _stepTwoEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5)); _stepThreeEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5)); sessionContext.Start(); var ringBuffer = _ringBuffer; var operandTwo = _operandTwoInitialValue; for (long i = 0; i < _iterations; i++) { var sequence = ringBuffer.Next(); var @event = ringBuffer[sequence]; @event.OperandOne = i; @event.OperandTwo = operandTwo--; ringBuffer.Publish(sequence); } latch.WaitOne(); sessionContext.Stop(); _stepOneEventProcessor.Halt(); _stepTwoEventProcessor.Halt(); _stepThreeEventProcessor.Halt(); Task.WaitAll(processorTask1, processorTask2, processorTask3); PerfTestUtil.FailIfNot(_expectedResult, _stepThreeFunctionHandler.StepThreeCounter); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { _channel = Channel.CreateBounded <PerfEvent>(new BoundedChannelOptions(_bufferSize) { FullMode = BoundedChannelFullMode.Wait, SingleReader = true, SingleWriter = true, }); _consumer = new Consumer(_channel.Reader, _eventHandler); _eventHandler.Reset(_iterations - 1); _consumer.Start(); var producerSignal = new ManualResetEventSlim(); var producer = Task.Run(async() => { producerSignal.Wait(); await PublishOneByOne(); //await PublishBatched(); }); sessionContext.Start(); producerSignal.Set(); _eventHandler.Latch.WaitOne(); sessionContext.Stop(); _channel.Writer.Complete(); producer.Wait(); _consumer.Stop(); sessionContext.SetBatchData(_eventHandler.BatchesProcessedCount.Value, _iterations); PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}"); return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { var latch = new Barrier(_numEventProcessors + 1); var processorTasks = new List <Task>(); for (var i = 0; i < _numEventProcessors; i++) { _handlers[i].Reset(latch, _eventProcessors[i].Sequence.Value + _iterations); processorTasks.Add(_eventProcessors[i].Start()); _eventProcessors[i].WaitUntilStarted(TimeSpan.FromSeconds(5)); } sessionContext.Start(); var ringBuffer = _ringBuffer; for (long i = 0; i < _iterations; i++) { var sequence = ringBuffer.Next(); ringBuffer[sequence].Value = i; ringBuffer.Publish(sequence); } latch.SignalAndWait(); sessionContext.Stop(); for (var i = 0; i < _numEventProcessors; i++) { _eventProcessors[i].Halt(); PerfTestUtil.FailIfNot(_results[i], _handlers[i].Value, $"Result {_results[i]} != {_handlers[i].Value}"); } Task.WaitAll(processorTasks.ToArray()); sessionContext.SetBatchData(_handlers.Sum(x => x.BatchesProcessedCount.Value), _numEventProcessors * _iterations); return(_numEventProcessors * _iterations); }
public long Run(Stopwatch stopwatch) { ResetCounters(); RingBuffer<ValueEvent> ringBuffer = _workerPool.Start(new BasicExecutor(TaskScheduler.Default)); stopwatch.Start(); for (long i = 0; i < _iterations; i++) { long sequence = ringBuffer.Next(); ringBuffer[sequence].Value = i; ringBuffer.Publish(sequence); } _workerPool.DrainAndHalt(); // Workaround to ensure that the last worker(s) have completed after releasing their events Thread.Sleep(1); stopwatch.Stop(); PerfTestUtil.FailIfNot(_iterations, SumCounters()); return _iterations; }
public long Run(ThroughputSessionContext sessionContext) { ResetCounters(); var workerPool = new WorkerPool <PerfEvent>(_ringBuffer, _ringBuffer.NewBarrier(), new FatalExceptionHandler <PerfEvent>(), _handlers); _ringBuffer.AddGatingSequences(workerPool.GetWorkerSequences()); workerPool.Start(); workerPool.WaitUntilStarted(TimeSpan.FromSeconds(5)); sessionContext.Start(); var ringBuffer = _ringBuffer; for (long i = 0; i < _iterations; i++) { var sequence = ringBuffer.Next(); ringBuffer[sequence].Value = i; ringBuffer.Publish(sequence); } workerPool.DrainAndHalt(); // Workaround to ensure that the last worker(s) have completed after releasing their events Thread.Sleep(1); sessionContext.Stop(); PerfTestUtil.FailIfNot(_iterations, SumCounters()); foreach (var workerSequence in workerPool.GetWorkerSequences()) { _ringBuffer.RemoveGatingSequence(workerSequence); } return(_iterations); }
public long Run(ThroughputSessionContext sessionContext) { var expectedCount = _eventProcessor.Sequence.Value + _iterations * _batchSize; _handler.Reset(expectedCount); var processorTask = _eventProcessor.Start(); _eventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5)); sessionContext.Start(); var ringBuffer = _ringBuffer; for (var i = 0; i < _iterations; i++) { var hi = ringBuffer.Next(_batchSize); var lo = hi - (_batchSize - 1); for (var l = lo; l <= hi; l++) { ringBuffer[l].Value = (i); } ringBuffer.Publish(lo, hi); } _handler.WaitForSequence(); sessionContext.Stop(); PerfTestUtil.WaitForEventProcessorSequence(expectedCount, _eventProcessor); _eventProcessor.Halt(); processorTask.Wait(2000); sessionContext.SetBatchData(_handler.BatchesProcessed, _iterations * _batchSize); PerfTestUtil.FailIfNot(_expectedResult, _handler.Value, $"Handler should have processed {_expectedResult} events, but was: {_handler.Value}"); return(_batchSize * _iterations); }
public long Run(Stopwatch stopwatch) { var latch = new ManualResetEvent(false); _stepThreeFunctionHandler.Reset(latch, _stepThreeBatchProcessor.Sequence.Value + _iterations); var processorTask1 = _executor.Submit(_stepOneBatchProcessor); var processorTask2 = _executor.Submit(_stepTwoBatchProcessor); var processorTask3 = _executor.Submit(_stepThreeBatchProcessor); stopwatch.Start(); var operandTwo = _operandTwoInitialValue; for (long i = 0; i < _iterations; i++) { var sequence = _ringBuffer.Next(); var @event = _ringBuffer[sequence]; @event.OperandOne = i; @event.OperandTwo = operandTwo--; _ringBuffer.Publish(sequence); } latch.WaitOne(); stopwatch.Stop(); _stepOneBatchProcessor.Halt(); _stepTwoBatchProcessor.Halt(); _stepThreeBatchProcessor.Halt(); Task.WaitAll(processorTask1, processorTask2, processorTask3); PerfTestUtil.FailIfNot(_expectedResult, _stepThreeFunctionHandler.StepThreeCounter); return(_iterations); }