public long Run(ThroughputSessionContext sessionContext)
{
var signal = new ManualResetEvent(false);
_fizzBuzzQueueProcessor.Reset(signal);
var tasks = new Task[_eventProcessorCount];
tasks[0] = _executor.Execute(_fizzQueueProcessor.Run);
tasks[1] = _executor.Execute(_buzzQueueProcessor.Run);
tasks[2] = _executor.Execute(_fizzBuzzQueueProcessor.Run);
sessionContext.Start();
for (var i = 0; i < _iterations; i++)
{
_fizzInputQueue.Enqueue(i);
_buzzInputQueue.Enqueue(i);
}
signal.WaitOne();
sessionContext.Stop();
_fizzQueueProcessor.Halt();
_buzzQueueProcessor.Halt();
_fizzBuzzQueueProcessor.Halt();
Task.WaitAll(tasks);
PerfTestUtil.FailIf(_expectedResult, 0);
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);
var expectedCount = _myRunnable.Sequence.Value + _iterations;
_myRunnable.Reset(latch, expectedCount);
var consumerTask = Task.Factory.StartNew(() => _myRunnable.Run(), CancellationToken.None, TaskCreationOptions.None, _taskScheduler);
sessionContext.Start();
var sequencer = _sequencer;
var producerTask = Task.Factory.StartNew(() =>
{
for (long i = 0; i < _iterations; i++)
{
var next = sequencer.Next();
sequencer.Publish(next);
}
latch.WaitOne();
}, CancellationToken.None, TaskCreationOptions.None, _taskScheduler);
producerTask.Wait();
sessionContext.Stop();
WaitForEventProcessorSequence(expectedCount);
consumerTask.Wait();
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(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(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(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)
{
_cyclicBarrier.Reset();
_handler.Reset(_batchEventProcessor.Sequence.Value + ((_iterations / _numPublishers) * _numPublishers));
var futures = new Task[_numPublishers];
for (var i = 0; i < _numPublishers; i++)
{
var index = i;
futures[i] = Task.Factory.StartNew(() => _valuePublishers[index](_cyclicBarrier, _ringBuffer, _iterations / _numPublishers), CancellationToken.None, TaskCreationOptions.None, _scheduler);
}
var processorTask = Task.Factory.StartNew(() => _batchEventProcessor.Run(), CancellationToken.None, TaskCreationOptions.None, _scheduler);
_batchEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5));
sessionContext.Start();
_cyclicBarrier.Signal();
_cyclicBarrier.Wait();
for (var i = 0; i < _numPublishers; i++)
{
futures[i].Wait();
}
_handler.WaitForSequence();
sessionContext.Stop();
_batchEventProcessor.Halt();
processorTask.Wait(2000);
sessionContext.SetBatchData(_handler.BatchesProcessed, _iterations);
return(_iterations);
}
public long Run(ThroughputSessionContext sessionContext)
{
var signal = new ManualResetEvent(false);
_queueProcessor.Reset(signal);
var tasks = new Task[_publisherCount];
for (var i = 0; i < _publisherCount; i++)
{
tasks[i] = _perfQueueProducers[i].Start();
}
var processorTask = _queueProcessor.Start();
sessionContext.Start();
_signal.SignalAndWait();
Task.WaitAll(tasks);
signal.WaitOne();
sessionContext.Stop();
_queueProcessor.Halt();
processorTask.Wait();
return(_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)
{
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)
{
_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 = _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)
{
_cyclicBarrier.Reset();
var expected = _ringBuffer.Cursor + (_numPublishers * _iterations);
var futures = new Task[_numPublishers];
for (var i = 0; i < _numPublishers; i++)
{
var index = i;
futures[i] = Task.Run(() => _valuePublishers[index].Run());
}
foreach (var processor in _workProcessors)
{
Task.Run(() => processor.Run());
}
sessionContext.Start();
_cyclicBarrier.Signal();
_cyclicBarrier.Wait();
for (var i = 0; i < _numPublishers; i++)
{
futures[i].Wait();
}
while (_workSequence.Value < expected)
{
Thread.Yield();
}
sessionContext.Stop();
Thread.Sleep(1000);
foreach (var processor in _workProcessors)
{
processor.Halt();
}
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)
{
_cyclicBarrier.Reset();
var latch = new ManualResetEvent(false);
_handler.Reset(latch, _batchEventProcessor.Sequence.Value + ((_iterations / _numPublishers) * _numPublishers));
var futures = new Task[_numPublishers];
for (var i = 0; i < _numPublishers; i++)
{
var index = i;
futures[i] = Task.Run(() => _valuePublishers[index].Run());
}
var processorTask = Task.Run(() => _batchEventProcessor.Run());
_batchEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5));
sessionContext.Start();
_cyclicBarrier.Signal();
_cyclicBarrier.Wait();
for (var i = 0; i < _numPublishers; i++)
{
futures[i].Wait();
}
latch.WaitOne();
sessionContext.Stop();
_batchEventProcessor.Halt();
processorTask.Wait(2000);
sessionContext.SetBatchData(_handler.BatchesProcessedCount.Value, _iterations);
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(ThroughputSessionContext sessionContext)
{
var latch = new ManualResetEvent(false);
_queueProcessor.Reset(latch);
var future = Task.Run(() => _queueProcessor.Run());
sessionContext.Start();
for (long i = 0; i < _iterations; i++)
{
_blockingQueue.Enqueue(3L);
}
latch.WaitOne();
sessionContext.Stop();
_queueProcessor.Halt();
future.Wait();
PerfTestUtil.FailIf(_expectedResult, 0);
return(_iterations);
}
public long Run(ThroughputSessionContext sessionContext)
{
var signal = new ManualResetEvent(false);
_stepThreeQueueProcessor.Reset(signal);
var tasks = new Task[_eventProcessorCount];
tasks[0] = _stepOneQueueProcessor.Start();
tasks[1] = _stepTwoQueueProcessor.Start();
tasks[2] = _stepThreeQueueProcessor.Start();
sessionContext.Start();
long operandTwo = _operandTwoInitialValue;
for (long i = 0; i < _iterations; i++)
{
long[] values = new long[2];
values[0] = i;
values[1] = operandTwo--;
_stepOneQueue.Enqueue(values);
}
signal.WaitOne();
sessionContext.Stop();
_stepOneQueueProcessor.Halt();
_stepTwoQueueProcessor.Halt();
_stepThreeQueueProcessor.Halt();
Task.WaitAll(tasks);
PerfTestUtil.FailIf(_expectedResult, 0);
return(_iterations);
}
public long Run(ThroughputSessionContext sessionContext)
{
var signal = new ManualResetEvent(false);
var expectedCount = _batchEventProcessor.Sequence.Value + _iterations * _batchSize;
_handler.Reset(signal, expectedCount);
var processorTask = _executor.Execute(_batchEventProcessor.Run);
_batchEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5));
sessionContext.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();
sessionContext.Stop();
PerfTestUtil.WaitForEventProcessorSequence(expectedCount, _batchEventProcessor);
_batchEventProcessor.Halt();
processorTask.Wait(2000);
sessionContext.SetBatchData(_handler.BatchesProcessedCount.Value, _iterations * _batchSize);
PerfTestUtil.FailIfNot(_expectedResult, _handler.Value, $"Handler should have processed {_expectedResult} events, but was: {_handler.Value}");
return(_batchSize * _iterations);
}
public long Run(ThroughputSessionContext sessionContext)
{
var signal = new ManualResetEvent(false);
var expectedCount = _batchEventProcessor.Sequence.Value + _iterations;
_handler.Reset(signal, _iterations);
var processorTask = _batchEventProcessor.Start();
_batchEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5));
sessionContext.Start();
var ringBuffer = _ringBuffer;
for (var i = 0; i < _iterations; i++)
{
var next = ringBuffer.Next();
var @event = ringBuffer[next];
for (var j = 0; j < @event.Length; j++)
{
@event[j] = i;
}
ringBuffer.Publish(next);
}
signal.WaitOne();
sessionContext.Stop();
WaitForEventProcessorSequence(expectedCount);
_batchEventProcessor.Halt();
processorTask.Wait(2000);
sessionContext.SetBatchData(_handler.BatchesProcessed, _iterations);
PerfTestUtil.FailIf(0, _handler.Value, "Handler has not processed any event");
return(_iterations * _arraySize);
}
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)
{
int batchSize = 10;
var latch = new ManualResetEvent(false);
var expectedCount = _myRunnable.Sequence.Value + _iterations * batchSize;
_myRunnable.Reset(latch, expectedCount);
Task.Run(() => _myRunnable.Run());
sessionContext.Start();
var sequencer = _sequencer;
for (long i = 0; i < _iterations; i++)
{
var next = sequencer.Next(batchSize);
sequencer.Publish(next - (batchSize - 1), next);
}
latch.WaitOne();
sessionContext.Stop();
WaitForEventProcessorSequence(expectedCount);
return(_iterations * batchSize);
}
public long Run(ThroughputSessionContext sessionContext)
{
_cyclicBarrier.Reset();
var latch = new ManualResetEvent(false);
_handler.Reset(latch, _iterations);
var futures = new Task[_numPublishers];
for (var i = 0; i < _numPublishers; i++)
{
var index = i;
futures[i] = Task.Run(() => _valuePublishers[index](_cyclicBarrier, _buffers[index], _iterations / _numPublishers, _arraySize));
}
var processorTask = Task.Run(() => _batchEventProcessor.Run());
sessionContext.Start();
_cyclicBarrier.Signal();
_cyclicBarrier.Wait();
for (var i = 0; i < _numPublishers; i++)
{
futures[i].Wait();
}
latch.WaitOne();
sessionContext.Stop();
_batchEventProcessor.Halt();
processorTask.Wait(2000);
sessionContext.SetBatchData(_handler.BatchesProcessedCount, _iterations * _arraySize);
return(_iterations * _arraySize);
}
public ThroughputTestSessionResult(long totalOperationsInRun, TimeSpan duration, int gen0, int gen1, int gen2, ThroughputSessionContext sessionContext)
{
TotalOperationsInRun = totalOperationsInRun;
BatchPercent = sessionContext.BatchPercent;
AverageBatchSize = sessionContext.AverageBatchSize;
Duration = duration;
Gen0 = gen0;
Gen1 = gen1;
Gen2 = gen2;
}
