public void ShouldDelgateNextAndPublish()
{
_sequencerMock.Setup(x => x.Next()).Returns(34L);
_ringBuffer.Publish(_ringBuffer.Next());
_sequencerMock.Verify(x => x.Next(), Times.Once());
_sequencerMock.Verify(x => x.Publish(34L), Times.Once());
}
public void EnqueueExecution(int securityId, long price, long quantity)
{
var sequence = _ringBuffer.Next();
try
{
var evt = _ringBuffer[sequence];
evt.OnAcquired();
evt.SetExecution(securityId, price, quantity);
}
finally
{
_ringBuffer.Publish(sequence);
}
}
protected override long RunDisruptorPass()
{
var latch = new ManualResetEvent(false);
stepThreeFunctionHandler.Reset(latch, stepThreeBatchProcessor.Sequence.Value + ITERATIONS);
Task.Factory.StartNew(() => stepOneBatchProcessor.Run(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
Task.Factory.StartNew(() => stepTwoBatchProcessor.Run(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
Task.Factory.StartNew(() => stepThreeBatchProcessor.Run(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
var runTime = Stopwatch.StartNew();
var operandTwo = OPERAND_TWO_INITIAL_VALUE;
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();
var opsPerSecond = (ITERATIONS * 1000L) / runTime.ElapsedMilliseconds;
stepOneBatchProcessor.Halt();
stepTwoBatchProcessor.Halt();
stepThreeBatchProcessor.Halt();
InitResult();
Assert.AreEqual(expectedResult, stepThreeFunctionHandler.GetStepThreeCounter);
return(opsPerSecond);
}
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);
}
protected override long RunDisruptorPass()
{
var latch = new ManualResetEvent(false);
fizzBuzzHandler.Reset(latch, batchProcessorFizzBuzz.Sequence.Value + ITERATIONS);
Task.Factory.StartNew(() => batchProcessorFizz.Run(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
Task.Factory.StartNew(() => batchProcessorBuzz.Run(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
Task.Factory.StartNew(() => batchProcessorFizzBuzz.Run(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
var run = DateTime.Now;//Stopwatch.StartNew();
for (long i = 0; i < ITERATIONS; i++)
{
var sequence = ringBuffer.Next();
ringBuffer[sequence].Value = i;
ringBuffer.Publish(sequence);
}
latch.WaitOne();
var opsPerSecond = (ITERATIONS * 1000L) / (long)DateTime.Now.Subtract(run).Milliseconds;
batchProcessorFizz.Halt();
batchProcessorBuzz.Halt();
batchProcessorFizzBuzz.Halt();
Assert.AreEqual(ExpectedResult, fizzBuzzHandler.FizzBuzzCounter);
return(opsPerSecond);
}
/// <summary>
/// Raised when new order execution is recieved from the running strategies
/// </summary>
/// <param name="execution">Contains execution info</param>
private void OnExecutionArrived(Execution execution)
{
try
{
// Get Next Sequence number
long sequenceNumber = _ringBuffer.Next();
// Get new entry value
var entry = _ringBuffer[sequenceNumber];
// Update values
entry.Fill = execution.Fill;
entry.Order = execution.Order;
//entry.BarClose = execution.BarClose;
// Publish updated entry
_ringBuffer.Publish(sequenceNumber);
//if (_asyncClassLogger.IsDebugEnabled)
//{
// _asyncClassLogger.Debug("Execution arrived for: " + execution.Order.OrderID, _type.FullName, "OnExecutionArrived");
//}
//// Create new object to be used with Event Aggregator
//UpdateStats updateStats= new UpdateStats(execution);
////Raise event to notify listeners
//EventSystem.Publish<UpdateStats>(updateStats);
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "OnExecutionArrived");
}
}
public override void RunPass()
{
_disruptor.Start();
Task.Factory.StartNew(
() =>
{
for (long i = 0; i < Iterations; i++)
{
var sequence = _ringBuffer.Next();
_ringBuffer[sequence].Value = Stopwatch.GetTimestamp();
_ringBuffer.Publish(sequence);
var pauseStart = Stopwatch.GetTimestamp();
while (PauseNanos > (Stopwatch.GetTimestamp() - pauseStart) * TicksToNanos)
{
// busy spin
}
}
}, CancellationToken.None, TaskCreationOptions.None, _scheduler);
_mru.WaitOne();
_disruptor.Shutdown();
_scheduler.Dispose();
}
public void Publish(string filepath)
{
if (_disposeCount != 0)
{
throw new ObjectDisposedException(this.GetType().Name);
}
if (!_started)
{
throw new InvalidOperationException("Method Start() must be called before this method.");
}
if (string.IsNullOrEmpty(filepath))
{
throw new ArgumentNullException("filepath");
}
long seqNo;
seqNo = _ringBuffer.Next();
try
{
Event entry = _ringBuffer[seqNo];
entry.Filepath = filepath;
}
finally
{
_ringBuffer.Publish(seqNo);
}
}
public override long RunPass()
{
_disruptor.Start();
var sw = Stopwatch.StartNew();
var operandTwo = OperandTwoInitialValue;
for (long i = 0; i < Iterations; i++)
{
var sequence = _ringBuffer.Next();
var evt = _ringBuffer[sequence];
evt.OperandOne = i;
evt.OperandTwo = operandTwo--;
_ringBuffer.Publish(sequence);
}
_mru.WaitOne();
var opsPerSecond = (Iterations * 1000L) / sw.ElapsedMilliseconds;
_disruptor.Shutdown();
Assert.AreEqual(ExpectedResult, _stepThreeFunctionEventHandler.StepThreeCounter);
return(opsPerSecond);
}
public void Dispose()
{
if (_ringBuffer != null)
{
_ringBuffer.Publish(_sequence);
}
}
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)
{
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(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 void ShouldReportProgressByUpdatingSequenceViaCallback()
{
var ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(0), 16);
var sequenceBarrier = ringBuffer.NewBarrier();
var handler = new TestSequenceReportingEventHandler(_callbackLatch);
var batchEventProcessor = new BatchEventProcessor <StubEvent>(ringBuffer, sequenceBarrier, handler);
ringBuffer.SetGatingSequences(batchEventProcessor.Sequence);
var thread = new Thread(batchEventProcessor.Run)
{
IsBackground = true
};
thread.Start();
Assert.AreEqual(-1L, batchEventProcessor.Sequence.Value);
ringBuffer.Publish(ringBuffer.Next());
_callbackLatch.WaitOne();
Assert.AreEqual(0L, batchEventProcessor.Sequence.Value);
_onEndOfBatchLatch.Set();
Assert.AreEqual(0L, batchEventProcessor.Sequence.Value);
batchEventProcessor.Halt();
thread.Join();
}
public override long RunPass()
{
_disruptor.Start();
var sw = Stopwatch.StartNew();
Task.Factory.StartNew(
() =>
{
for (long i = 0; i < Iterations; i++)
{
var sequence = _ringBuffer.Next();
_ringBuffer[sequence].Value = i;
_ringBuffer.Publish(sequence);
}
}, CancellationToken.None, TaskCreationOptions.None, _scheduler);
_mru.WaitOne();
var opsPerSecond = (Iterations * 1000L) / sw.ElapsedMilliseconds;
_disruptor.Shutdown();
Assert.AreEqual(ExpectedResult, _fizzBuzzEventHandler.FizzBuzzCounter);
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);
}
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);
}
public void Dispose()
{
if (_ringBuffer != null)
{
_ringBuffer.Publish(_startSequence, _endSequence);
}
}
public override long RunPass()
{
_disruptor.Start();
var sw = Stopwatch.StartNew();
Task.Factory.StartNew(
() =>
{
for (long i = 0; i < Iterations; i++)
{
var sequence = _ringBuffer.Next();
_ringBuffer[sequence].Value = i;
_ringBuffer.Publish(sequence);
}
}, CancellationToken.None, TaskCreationOptions.None, _scheduler);
_latch.Wait();
var opsPerSecond = (Iterations * 1000L) / sw.ElapsedMilliseconds;
_disruptor.Shutdown();
_scheduler.Dispose();
Assert.AreEqual(ExpectedResults[0], _handler1.Value, "Addition");
Assert.AreEqual(ExpectedResults[1], _handler2.Value, "Sub");
Assert.AreEqual(ExpectedResults[2], _handler3.Value, "And");
return(opsPerSecond);
}
public void OnEvent(ValueEvent @event, long sequence, bool endOfBatch)
{
long next = buffer.Next();
buffer[next].Value = @event.Value;
buffer.Publish(next);
}
private void RunDisruptorPass()
{
var latch = new System.Threading.ManualResetEvent(false);
stepThreeFunctionHandler.Reset(latch, stepThreeBatchProcessor.Sequence.Value + ITERATIONS);
Task.Factory.StartNew(() => stepOneBatchProcessor.Run());
Task.Factory.StartNew(() => stepTwoBatchProcessor.Run());
Task.Factory.StartNew(() => stepThreeBatchProcessor.Run());
for (long i = 0; i < ITERATIONS; i++)
{
var t0 = Stopwatch.GetTimestamp();
var sequence = ringBuffer.Next();
ringBuffer[sequence].Value = t0;
ringBuffer.Publish(sequence);
var pauseStart = Stopwatch.GetTimestamp();
while (PAUSE_NANOS > ((Stopwatch.GetTimestamp() - pauseStart) * TicksToNanos))
{
// busy spin
}
}
latch.WaitOne();
stepOneBatchProcessor.Halt();
stepTwoBatchProcessor.Halt();
stepThreeBatchProcessor.Halt();
}
protected override long RunDisruptorPass()
{
Setup();
var latch = new CountdownEvent(NUM_EVENT_PROCESSORS);
var listTh = new List <Thread>();
for (int i = 0; i < 3; i++)
{
handlers[i].Reset(latch, -1 + ITERATIONS);
}
disruptor.Start();
var start = System.Diagnostics.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++)
{
Assert.AreEqual(results[i], handlers[i].Value);
}
disruptor.Shutdown();
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 void Run()
{
try
{
_start.Signal();
_start.Wait();
var i = _iterations;
while (--i != -1)
{
var next = _ringBuffer.Next();
var testEvent = _ringBuffer[next];
testEvent.Sequence = next;
testEvent.A = next + 13;
testEvent.B = next - 7;
//testEvent.S = "wibble-" + next;
_ringBuffer.Publish(next);
}
}
catch (Exception e)
{
Failed = true;
}
finally
{
_end.Signal();
}
}
public override long RunPass()
{
_disruptor.Start();
var sw = Stopwatch.StartNew();
for (long i = 0; i < Iterations; i++)
{
var sequence = _ringBuffer.Next();
_ringBuffer[sequence].Value = i;
_ringBuffer.Publish(sequence);
}
_latch.Wait();
var opsPerSecond = (Iterations * 1000L) / sw.ElapsedMilliseconds;
_disruptor.Shutdown();
Assert.AreEqual(ExpectedResults[0], _handler1.Value, "Addition");
Assert.AreEqual(ExpectedResults[1], _handler2.Value, "Sub");
Assert.AreEqual(ExpectedResults[2], _handler3.Value, "And");
return(opsPerSecond);
}
public void Run(Stopwatch sw)
{
var mre = new ManualResetEvent(false);
_fizzBuzzHandler.Reset(mre, _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));
sw.Start();
for (long i = 0; i < _iterations; i++)
{
var sequence = _ringBuffer.Next();
_ringBuffer[sequence].Value = i;
_ringBuffer.Publish(sequence);
}
mre.WaitOne();
sw.Stop();
_batchProcessorFizz.Halt();
_batchProcessorBuzz.Halt();
_batchProcessorFizzBuzz.Halt();
Task.WaitAll(processorTask1, processorTask2, processorTask3);
}
public void OnEvent(PerfEvent data, long sequence, bool endOfBatch)
{
var next = _buffer.Next();
_buffer[next].Value = data.Value;
_buffer.Publish(next);
}
public long Run(ThroughputSessionContext sessionContext)
{
long expectedCount = _batchEventProcessor.Sequence.Value + _iterations;
_latch.Reset();
_eventHandler.Reset(_latch, expectedCount);
var processorTask = _executor.Execute(_batchEventProcessor.Run);
_batchEventProcessor.WaitUntilStarted(TimeSpan.FromSeconds(5));
sessionContext.Start();
for (long i = 0; i < _iterations; i++)
{
long sequence = _ringBuffer.Next();
_ringBuffer[sequence].Value = i;
_ringBuffer.Publish(sequence);
}
_latch.WaitOne();
sessionContext.Stop();
PerfTestUtil.WaitForEventProcessorSequence(expectedCount, _batchEventProcessor);
_batchEventProcessor.Halt();
processorTask.Wait(2000);
sessionContext.SetBatchData(_eventHandler.BatchesProcessedCount, _iterations);
PerfTestUtil.FailIfNot(_expectedResult, _eventHandler.Value, $"Handler should have processed {_expectedResult} events, but was: {_eventHandler.Value}");
return(_iterations);
}
public override long RunPass()
{
_disruptor.Start();
const int batchSize = 10;
var batchDescriptor = _ringBuffer.NewBatchDescriptor(batchSize);
var sw = Stopwatch.StartNew();
Task.Factory.StartNew(
() =>
{
long offset = 0;
for (long i = 0; i < Iterations; i += batchSize)
{
_ringBuffer.Next(batchDescriptor);
for (long sequence = batchDescriptor.Start; sequence <= batchDescriptor.End; sequence++)
{
_ringBuffer[sequence].Value = offset++;
}
_ringBuffer.Publish(batchDescriptor);
}
}, CancellationToken.None, TaskCreationOptions.None, _scheduler);
_mru.WaitOne();
long opsPerSecond = (Iterations * 1000L) / sw.ElapsedMilliseconds;
_disruptor.Shutdown();
_scheduler.Dispose();
Assert.AreEqual(ExpectedResult, _eventHandler.Value);
return(opsPerSecond);
}
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 void ShouldPreventProducersOvertakingEventProcessorsWrapPoint()
{
const int ringBufferSize = 4;
var mre = new ManualResetEvent(false);
var producerComplete = false;
var ringBuffer = new RingBuffer<StubEvent>(() => new StubEvent(-1), ringBufferSize);
var processor = new TestEventProcessor(ringBuffer.NewBarrier());
ringBuffer.SetGatingSequences(processor.Sequence);
var thread = new Thread(
() =>
{
for (int i = 0; i <= ringBufferSize; i++) // produce 5 events
{
var sequence = ringBuffer.Next();
StubEvent evt = ringBuffer[sequence];
evt.Value = i;
ringBuffer.Publish(sequence);
if (i == 3) // unblock main thread after 4th event published
{
mre.Set();
}
}
producerComplete = true;
});
thread.Start();
mre.WaitOne();
Assert.AreEqual(ringBufferSize - 1, ringBuffer.Cursor);
Assert.IsFalse(producerComplete);
processor.Run();
thread.Join();
Assert.IsTrue(producerComplete);
}
private static void ValuePublisher(CountdownEvent countdownEvent, RingBuffer<long[]> ringBuffer, long iterations, long arraySize)
{
countdownEvent.Signal();
countdownEvent.Wait();
for (long i = 0; i < iterations; i++)
{
var sequence = ringBuffer.Next();
var eventData = ringBuffer[sequence];
for (var j = 0; j < arraySize; j++)
{
eventData[j] = i + j;
}
ringBuffer.Publish(sequence);
}
}
private static void ValuePublisher(CountdownEvent countdownEvent, RingBuffer<ValueEvent> ringBuffer, long iterations)
{
countdownEvent.Signal();
countdownEvent.Wait();
for (long i = 0; i < iterations; i++)
{
var sequence = ringBuffer.Next();
var eventData = ringBuffer[sequence];
eventData.Value = i;
ringBuffer.Publish(sequence);
}
}
