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); }
protected override long RunQueuePass() { CountdownEvent latch = new CountdownEvent(1); stepThreeQueueProcessor.reset(latch); CancellationTokenSource cance = new CancellationTokenSource(); var t1 = Task.Factory.StartNew(() => stepOneQueueProcessor.run(), cance.Token, TaskCreationOptions.None, TaskScheduler.Default); var t2 = Task.Factory.StartNew(() => stepTwoQueueProcessor.run(), cance.Token, TaskCreationOptions.None, TaskScheduler.Default); var t3 = Task.Factory.StartNew(() => stepThreeQueueProcessor.run(), cance.Token, TaskCreationOptions.None, TaskScheduler.Default); var start = Stopwatch.StartNew(); long operandTwo = OPERAND_TWO_INITIAL_VALUE; for (long i = 0; i < ITERATIONS; i++) { long[] values = new long[2]; values[0] = i; values[1] = operandTwo--; stepOneQueue.Enqueue(values); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (start.ElapsedMilliseconds); stepOneQueueProcessor.halt(); stepTwoQueueProcessor.halt(); stepThreeQueueProcessor.halt(); cance.Cancel(); PerfTestUtil.failIf(expectedResult, 0); return(opsPerSecond); }
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) { 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); }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); long expectedCount = batchEventProcessor.Sequence.Value + ITERATIONS; handler.Reset(latch, ITERATIONS); Task.Factory.StartNew(() => batchEventProcessor.Run()); Stopwatch start = Stopwatch.StartNew(); RingBuffer <long[]> rb = ringBuffer; for (long i = 0; i < ITERATIONS; i++) { long next = rb.Next(); long[] @event = rb.Get(next); for (int j = 0; j < @event.Length; j++) { @event[j] = i; } rb.Publish(next); } latch.Wait(); long opsPerSecond = (ITERATIONS * ARRAY_SIZE * 1000L) / (start.ElapsedMilliseconds); waitForEventProcessorSequence(expectedCount); batchEventProcessor.Halt(); PerfTestUtil.failIf(0, handler.Value); return(opsPerSecond); }
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) { 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); }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); long expectedCount = batchEventProcessor.Sequence.Value + ITERATIONS; handler.reset(latch, expectedCount); //executor.submit(batchEventProcessor); //Task.Factory.StartNew(() => batchEventProcessor.Run() // , CancellationToken.None // , TaskCreationOptions.LongRunning // , new LimitedConcurrencyLevelTaskScheduler(4)); ThreadPool.UnsafeQueueUserWorkItem(o => batchEventProcessor.Run(), null); Stopwatch start = Stopwatch.StartNew(); RingBuffer <ValueEvent> rb = ringBuffer; for (long i = 0; i < ITERATIONS; i++) { long next = rb.Next(); rb[next].Value = i; rb.Publish(next); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (start.ElapsedMilliseconds); waitForEventProcessorSequence(expectedCount); batchEventProcessor.Halt(); PerfTestUtil.failIfNot(expectedResult, handler.Value); return(opsPerSecond); }
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 (!_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); }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); fizzBuzzHandler.rset(latch, batchProcessorFizzBuzz.Sequence.Value + ITERATIONS); Task.Run(() => batchProcessorFizz.Run()); Task.Run(() => batchProcessorBuzz.Run()); Task.Run(() => batchProcessorFizzBuzz.Run()); Stopwatch start = Stopwatch.StartNew(); for (long i = 0; i < ITERATIONS; i++) { long sequence = ringBuffer.Next(); ringBuffer[sequence].Value = i; ringBuffer.Publish(sequence); } //mr.WaitOne (); latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (start.ElapsedMilliseconds); batchProcessorFizz.Halt(); batchProcessorBuzz.Halt(); batchProcessorFizzBuzz.Halt(); PerfTestUtil.failIfNot(expectedResult, fizzBuzzHandler.FizzBuzzCounter); return(opsPerSecond); }
protected override long RunQueuePass() { CountdownEvent latch = new CountdownEvent(1); fizzBuzzQueueProcessor.Reset(latch); CancellationTokenSource cance = new CancellationTokenSource(); var t1 = Task.Factory.StartNew(() => fizzQueueProcessor.Run(), cance.Token, TaskCreationOptions.None, TaskScheduler.Default); var t2 = Task.Factory.StartNew(() => buzzQueueProcessor.Run(), cance.Token, TaskCreationOptions.None, TaskScheduler.Default); var t3 = Task.Factory.StartNew(() => fizzBuzzQueueProcessor.Run(), cance.Token, TaskCreationOptions.None, TaskScheduler.Default); var run = Stopwatch.StartNew(); for (long i = 0; i < ITERATIONS; i++) { fizzInputQueue.Enqueue(i); buzzInputQueue.Enqueue(i); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / run.ElapsedMilliseconds; fizzQueueProcessor.Halt(); buzzQueueProcessor.Halt(); fizzBuzzQueueProcessor.Halt(); cance.Cancel(); PerfTestUtil.failIf(ExpectedResult, 0); return(opsPerSecond); }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); long expectedCount = poller.GetSequence().Value + ITERATIONS; pollRunnable.reset(latch, expectedCount); Task.Factory.StartNew(() => pollRunnable.Run()); Stopwatch watch = Stopwatch.StartNew(); RingBuffer <ValueEvent> rb = ringBuffer; for (long i = 0; i < ITERATIONS; i++) { long next = rb.Next(); rb[next].Value = i; rb.Publish(next); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (watch.ElapsedMilliseconds); waitForEventProcessorSequence(expectedCount); pollRunnable.Halt(); PerfTestUtil.failIfNot(expectedResult, pollRunnable.getValue()); return(opsPerSecond); }
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); }
protected override long RunDisruptorPass() { MutableLong value = this.value; CountdownEvent latch = new CountdownEvent(1); long expectedCount = ringBuffer.GetMinimumGatingSequence() + ITERATIONS; handler.reset(latch, expectedCount); var start = Stopwatch.StartNew(); RingBuffer <ValueEvent> rb = ringBuffer; for (long l = 0; l < ITERATIONS; l++) { value.Value = l; rb.PublishEvent(Translator.INSTANCE, value); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (start.ElapsedMilliseconds); waitForEventProcessorSequence(expectedCount); PerfTestUtil.failIfNot(expectedResult, handler.Value); return(opsPerSecond); }
protected override long RunQueuePass() { CountdownEvent latch = new CountdownEvent(1); queueProcessor.Reset(latch); CancellationTokenSource canncel = new CancellationTokenSource(); Task.Factory.StartNew(() => queueProcessor.Run(), canncel.Token); var start = Stopwatch.StartNew(); for (long i = 0; i < ITERATIONS; i++) { blockingQueue.Add(i); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (start.ElapsedMilliseconds); queueProcessor.Halt(); canncel.Cancel(true); PerfTestUtil.failIf(expectedResult, 0); return(opsPerSecond); }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); stepThreeFunctionHandler.reset(latch, stepThreeBatchProcessor.Sequence.Value + ITERATIONS); Task.Run(() => stepOneBatchProcessor.Run()); Task.Run(() => stepTwoBatchProcessor.Run()); Task.Run(() => stepThreeBatchProcessor.Run()); Stopwatch start = Stopwatch.StartNew(); long operandTwo = OPERAND_TWO_INITIAL_VALUE; for (long i = 0; i < ITERATIONS; i++) { long sequence = ringBuffer.Next(); FunctionEvent @event = ringBuffer[sequence]; @event.OperandOne = i; @event.OperandTwo = operandTwo--; ringBuffer.Publish(sequence); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (start.ElapsedMilliseconds); stepOneBatchProcessor.Halt(); stepTwoBatchProcessor.Halt(); stepThreeBatchProcessor.Halt(); PerfTestUtil.failIfNot(expectedResult, stepThreeFunctionHandler.StepThreeCounter); return(opsPerSecond); }
public long Run(Stopwatch stopwatch) { var signal = new ManualResetEvent(false); var expectedCount = _batchEventProcessor.Sequence.Value + _iterations; _handler.Reset(signal, _iterations); var processorTask = _executor.Execute(_batchEventProcessor.Run); stopwatch.Start(); var rb = _ringBuffer; for (var i = 0; i < _iterations; i++) { var next = rb.Next(); var @event = rb[next]; for (var j = 0; j < @event.Length; j++) { @event[j] = i; } rb.Publish(next); } signal.WaitOne(); stopwatch.Stop(); WaitForEventProcessorSequence(expectedCount); _batchEventProcessor.Halt(); processorTask.Wait(2000); PerfTestUtil.FailIf(0, _handler.Value, "Handler has not processed any event"); return(_iterations * _arraySize); }
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(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 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) { 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) { 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) { 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); }
protected override long RunDisruptorPass() { resetCounters(); RingBuffer <ValueEvent> ringBuffer = workerPool.start(TaskScheduler.Default); var start = Stopwatch.StartNew(); for (long i = 0; i < ITERATIONS; i++) { long sequence = ringBuffer.Next(); ringBuffer.Get(sequence).Value = i; ringBuffer.Publish(sequence); } workerPool.drainAndHalt(); long opsPerSecond = (ITERATIONS * 1000L) / start.ElapsedMilliseconds; PerfTestUtil.failIfNot(ITERATIONS, sumCounters()); return(opsPerSecond); }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(NUM_EVENT_PROCESSORS); Enumerable.Range(0, NUM_EVENT_PROCESSORS).Select(i => { //return Task.Run(() => batchEventProcessors[i].Run()); return(ThreadPool.UnsafeQueueUserWorkItem(o => { handlers[Convert.ToInt32(o)].reset(latch, batchEventProcessors[i].Sequence.Value + ITERATIONS); batchEventProcessors[Convert.ToInt32(o)].Run(); }, i)); //return 1; }).ToList(); //handlers[0].reset(latch, batchEventProcessors[0].Sequence.Value + ITERATIONS); //Task.Run(() => batchEventProcessors[0].Run()); //handlers[1].reset(latch, batchEventProcessors[1].Sequence.Value + ITERATIONS); //Task.Run(() => batchEventProcessors[1].Run()); //handlers[2].reset(latch, batchEventProcessors[2].Sequence.Value + ITERATIONS); //Task.Run(() => batchEventProcessors[2].Run()); Stopwatch start = Stopwatch.StartNew(); for (long i = 0; i < ITERATIONS; i++) { long sequence = ringBuffer.Next(); ringBuffer[sequence].Value = i; ringBuffer.Publish(sequence); } latch.Wait(); long opsPerSecond = (ITERATIONS * 1000L) / (start.ElapsedMilliseconds); for (int i = 0; i < NUM_EVENT_PROCESSORS; i++) { batchEventProcessors[i].Halt(); PerfTestUtil.failIfNot(results[i], handlers[i].Value); } return(opsPerSecond); }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); //ManualResetEvent latch = new ManualResetEvent(false); long expectedCount = batchEventProcessor.Sequence.Value + ITERATIONS * BATCH_SIZE; handler.reset(latch, expectedCount); Task.Factory.StartNew(() => batchEventProcessor.Run() , CancellationToken.None , TaskCreationOptions.LongRunning , new LimitedConcurrencyLevelTaskScheduler(4)); //ThreadPool.QueueUserWorkItem(o=>batchEventProcessor.Run()); Stopwatch start = Stopwatch.StartNew(); RingBuffer <ValueEvent> rb = ringBuffer; for (long i = 0; i < ITERATIONS; i++) { long hi = rb.Next(BATCH_SIZE); long lo = hi - (BATCH_SIZE - 1); for (long l = lo; l <= hi; l++) { rb.Get(l).Value = i; } rb.Publish(lo, hi); } latch.Wait(); long opsPerSecond = (BATCH_SIZE * ITERATIONS * 1000L) / (start.ElapsedMilliseconds); waitForEventProcessorSequence(expectedCount); batchEventProcessor.Halt(); Console.WriteLine("expectedResult={0:###,###,###},realValue={1:###,###,###}", expectedResult, handler.Value); PerfTestUtil.failIfNot(expectedResult, handler.Value); return(opsPerSecond); }
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); }