public void ShouldPublishEvent()
{
_ringBuffer.AddGatingSequences(new NoOpEventProcessor <LongEvent>(_ringBuffer).Sequence);
_ringBuffer.PublishEvent(this);
_ringBuffer.PublishEvent(this);
Assert.AreEqual(0L + _valueAdd, _ringBuffer[0].Value);
Assert.AreEqual(1L + _valueAdd, _ringBuffer[1].Value);
}
public void Should_Publish_Event()
{
_ringBuffer.AddGatingSequences(new NoOpEventProcessor <LongEvent>(_ringBuffer).GetSequence());
_ringBuffer.PublishEvent(this);
_ringBuffer.PublishEvent(this);
Assert.Equal(_ringBuffer.Get(0).Value, 29L + 0);
Assert.Equal(_ringBuffer.Get(1).Value, 29L + 1);
}
public void shouldPublishEvent()
{
// RingBuffer<LongEvent> ringBuffer = RingBuffer<LongEvent>.CreateMultiProducer(() => new LongEvent(0L), BUFFER_SIZE);
ringBuffer.AddGatingSequences(new NoOpEventProcessor <LongEvent>(ringBuffer).Sequence);
for (var i = 0; i < 4; i++)
{
ringBuffer.PublishEvent(this);
ringBuffer.PublishEvent(this);
Console.WriteLine("ringBuffer[0].Value=={0} ", ringBuffer[0].Value);
Console.WriteLine("ringBuffer[1].Value=={0} ", ringBuffer[1].Value);
}
}
public OneToThreeDiamondSequencedThroughputTest()
{
var sequenceBarrier = _ringBuffer.NewBarrier();
var fizzHandler = new FizzBuzzEventHandler(FizzBuzzStep.Fizz);
_batchProcessorFizz = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, fizzHandler);
var buzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.Buzz);
_batchProcessorBuzz = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, buzzHandler);
var sequenceBarrierFizzBuzz = _ringBuffer.NewBarrier(_batchProcessorFizz.Sequence, _batchProcessorBuzz.Sequence);
_fizzBuzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.FizzBuzz);
_batchProcessorFizzBuzz = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrierFizzBuzz, _fizzBuzzHandler);
var temp = 0L;
for (long i = 0; i < _iterations; i++)
{
var fizz = 0 == (i % 3L);
var buzz = 0 == (i % 5L);
if (fizz && buzz)
{
++temp;
}
}
_expectedResult = temp;
_ringBuffer.AddGatingSequences(_batchProcessorFizzBuzz.Sequence);
}
public RingBufferTests()
{
_ringBuffer = RingBuffer <StubEvent> .CreateMultiProducer(() => new StubEvent(-1), 32);
_sequenceBarrier = _ringBuffer.NewBarrier();
_ringBuffer.AddGatingSequences(new NoOpEventProcessor <StubEvent>(_ringBuffer).Sequence);
}
public BatchedPoller(RingBuffer <DataEvent> ringBuffer, int batchSize)
{
_poller = ringBuffer.NewPoller();
ringBuffer.AddGatingSequences(_poller.Sequence);
_polledData = new BatchedData(batchSize);
}
public OneToOneSequencedPollerThroughputTest()
{
_ringBuffer = RingBuffer<ValueEvent>.CreateSingleProducer(ValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
_poller = _ringBuffer.NewPoller();
_ringBuffer.AddGatingSequences(_poller.Sequence);
_pollRunnable = new PollRunnable(_poller);
}
public OneToThreeSequencedThroughputTest()
: base(Test_Disruptor, ITERATIONS, 7)
{
ThreadPool.SetMaxThreads(NUM_EVENT_PROCESSORS, NUM_EVENT_PROCESSORS);
for (long i = 0; i < ITERATIONS; i++)
{
results[0] = Operation.Addition.Op(results[0], i);
results[1] = Operation.Substraction.Op(results[1], i);
results[2] = Operation.And.Op(results[2], i);
}
sequenceBarrier = ringBuffer.NewBarrier();
handlers[0] = new ValueMutationEventHandler_v3(Operation.Addition);
handlers[1] = new ValueMutationEventHandler_v3(Operation.Substraction);
handlers[2] = new ValueMutationEventHandler_v3(Operation.And);
batchEventProcessors[0] = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handlers[0]);
batchEventProcessors[1] = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handlers[1]);
batchEventProcessors[2] = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handlers[2]);
ringBuffer.AddGatingSequences(
batchEventProcessors[0].Sequence,
batchEventProcessors[1].Sequence,
batchEventProcessors[2].Sequence);
}
public Ring_Buffer_Test()
{
_ringBuffer = RingBuffer <StubEvent> .CreateMultiProducer(StubEvent.EventFactory, 32);
_barrier = _ringBuffer.NewBarrier();
_ringBuffer.AddGatingSequences(new NoOpEventProcessor <StubEvent>(_ringBuffer).GetSequence());
}
private void doRun()
{
BatchEventProcessor <EventHolder> batchEventProcessor =
new BatchEventProcessor <EventHolder>(ringBuffer,
ringBuffer.NewBarrier(),
eventHolderHandler);
ringBuffer.AddGatingSequences(batchEventProcessor.Sequence);
Thread t = new Thread(o => (o as BatchEventProcessor <EventHolder>).Run());
t.Start(batchEventProcessor);
long iterations = Constants.ITERATIONS;
for (long l = 0; l < iterations; l++)
{
SimpleEvent e = new SimpleEvent(l, l, l, l);
ringBuffer.PublishEvent(new EventTranslatorOneArg(), e);
}
while (batchEventProcessor.Sequence.Value != iterations - 1)
{
Thread.Sleep(0);
}
batchEventProcessor.Halt();
t.Join();
}
public void ShouldCallExceptionHandlerOnTimeoutException()
{
var waitStrategy = new AsyncWaitStrategy(TimeSpan.FromMilliseconds(1));
var ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), new SingleProducerSequencer(16, waitStrategy));
var sequenceBarrier = ringBuffer.NewAsyncBarrier();
var exception = new TaskCompletionSource <Exception>();
var exceptionHandler = new TestExceptionHandler <StubEvent>(x => exception.TrySetResult(x.ex));
var eventHandler = new TestAsyncBatchEventHandler <StubEvent> {
OnTimeoutAction = TestException.ThrowOnce()
};
var eventProcessor = CreateEventProcessor(ringBuffer, sequenceBarrier, eventHandler);
ringBuffer.AddGatingSequences(eventProcessor.Sequence);
eventProcessor.SetExceptionHandler(exceptionHandler);
var task = eventProcessor.Start();
Assert.IsTrue(exception.Task.Wait(TimeSpan.FromSeconds(2)));
Assert.AreEqual(0, exceptionHandler.EventExceptionCount);
Assert.AreEqual(1, exceptionHandler.TimeoutExceptionCount);
Assert.AreEqual(0, exceptionHandler.BatchExceptionCount);
eventProcessor.Halt();
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(2)));
}
public OneToOneSequencedBatchThroughputTest()
: base(Test_Disruptor, ITERATIONS, 7)
{
ThreadPool.SetMaxThreads(4, 4);
sequenceBarrier = ringBuffer.NewBarrier();
batchEventProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handler);
ringBuffer.AddGatingSequences(batchEventProcessor.Sequence);
}
public OneToOneSequencedPollerThroughputTest()
: base(Test_Disruptor, ITERATIONS, 7)
{
ThreadPool.SetMaxThreads(1, 1);
poller = ringBuffer.NewPoller();
pollRunnable = new PollRunnable(poller);
ringBuffer.AddGatingSequences(poller.GetSequence());
}
public OneToOneSequencedBatchThroughputTest()
{
_ringBuffer = RingBuffer<ValueEvent>.CreateSingleProducer(ValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new ValueAdditionEventHandler();
_batchEventProcessor = new BatchEventProcessor<ValueEvent>(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public OneToOneSequencedLongArrayThroughputTest()
{
_ringBuffer = RingBuffer<long[]>.CreateSingleProducer(() => new long[_arraySize], _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new LongArrayEventHandler();
_batchEventProcessor = new BatchEventProcessor<long[]>(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public OneToOneSequencedPollerThroughputTest()
{
_ringBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
_poller = _ringBuffer.NewPoller();
_ringBuffer.AddGatingSequences(_poller.Sequence);
_pollRunnable = new PollRunnable(_poller);
}
public OnePublisherToOneProcessorUniCastThroughputTest()
: base("Disruptor", ITERATIONS)
{
sequenceBarrier = ringBuffer.NewBarrier();
batchEventProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, disruptorHandler);
ringBuffer.AddGatingSequences(batchEventProcessor.Sequence);
//queueHandler = new ValueAdditionQueueProcessor_V3(blockQueue, ITERATIONS - 1);
}
/// <summary>
/// Set up custom event processors to handle events from the ring buffer. The disruptor will
/// automatically start this processors when <see cref="Start"/> is called.
///
/// This method can be used as the start of a chain. For example if the processor <code>A</code> must
/// process events before handler<code>B</code>:
/// <code>dw.HandleEventsWith(A).Then(B);</code>
/// </summary>
/// <param name="processors">processors the event processors that will process events</param>
/// <returns>a <see cref="EventHandlerGroup{T}"/> that can be used to chain dependencies.</returns>
public EventHandlerGroup <T> HandleEventsWith(params IEventProcessor[] processors)
{
foreach (var processor in processors)
{
_consumerRepository.Add(processor);
}
var sequences = new ISequence[processors.Length];
for (int i = 0; i < processors.Length; i++)
{
sequences[i] = processors[i].Sequence;
}
_ringBuffer.AddGatingSequences(sequences);
return(new EventHandlerGroup <T>(this, _consumerRepository, Util.GetSequencesFor(processors)));
}
public void Setup()
{
_ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), 16);
_sequenceBarrier = _ringBuffer.NewBarrier();
_batchHandlerMock = new Mock <IEventHandler <StubEvent> >();
_countDownEvent = new CountdownEvent(1);
_batchEventProcessor = new BatchEventProcessor <StubEvent>(_ringBuffer, _sequenceBarrier, _batchHandlerMock.Object);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public void Setup()
{
_ringBuffer = new RingBuffer<StubEvent>(()=>new StubEvent(-1), 16);
_sequenceBarrier = _ringBuffer.NewBarrier();
_batchHandlerMock = new Mock<IEventHandler<StubEvent>>();
_countDownEvent = new CountdownEvent(1);
_batchEventProcessor = new BatchEventProcessor<StubEvent>(_ringBuffer, _sequenceBarrier, _batchHandlerMock.Object);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public void SetUp()
{
_ringBuffer = RingBuffer <StubEvent> .CreateMultiProducer(() => new StubEvent(-1), 64);
_eventProcessorMock1 = new Mock <IEventProcessor>();
_eventProcessorMock2 = new Mock <IEventProcessor>();
_eventProcessorMock3 = new Mock <IEventProcessor>();
_ringBuffer.AddGatingSequences(new NoOpEventProcessor <StubEvent>(_ringBuffer).Sequence);
}
public OneToOneSequencedBatchThroughputTest()
{
_ringBuffer = RingBuffer <ValueEvent> .CreateSingleProducer(ValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new ValueAdditionEventHandler();
_batchEventProcessor = new BatchEventProcessor <ValueEvent>(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public BatchEventProcessorBenchmarks()
{
_ringBuffer = new RingBuffer <TestEvent>(() => new TestEvent(), new SingleProducerSequencer(4096, new SpinWaitWaitStrategy()));
_eventHandler = new TestEventHandler();
_processor = BatchEventProcessorFactory.Create(_ringBuffer, _ringBuffer.NewBarrier(), _eventHandler);
_eventHandler.Processor = _processor;
_eventHandler.RingBuffer = _ringBuffer;
_ringBuffer.AddGatingSequences(_processor.Sequence);
}
public void SetUp()
{
_ringBuffer = RingBuffer<StubEvent>.CreateMultiProducer(() => new StubEvent(-1), 64);
_eventProcessorMock1 = new Mock<IEventProcessor>();
_eventProcessorMock2 = new Mock<IEventProcessor>();
_eventProcessorMock3 = new Mock<IEventProcessor>();
_ringBuffer.AddGatingSequences(new NoOpEventProcessor<StubEvent>(_ringBuffer).Sequence);
}
public OneToOneSequencedThroughputTest_BatchPublisher_BatchHandler()
{
_ringBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new AdditionBatchEventHandler();
_eventProcessor = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_eventProcessor.Sequence);
}
public OneToOneSequencedLongArrayThroughputTest()
{
_ringBuffer = RingBuffer <long[]> .CreateSingleProducer(() => new long[_arraySize], _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new LongArrayEventHandler();
_batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public ThreeToOneSequencedThroughputTest()
{
_sequenceBarrier = _ringBuffer.NewBarrier();
_batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, _sequenceBarrier, _handler);
for (var i = 0; i < _numPublishers; i++)
{
_valuePublishers[i] = ValuePublisher;
}
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public OneToOneSequencedThroughputTest()
{
_latch = new ManualResetEvent(false);
_eventHandler = new AdditionEventHandler();
_ringBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _eventHandler);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public void ShouldPublishEvent()
{
ringBuffer.AddGatingSequences(new NoOpEventProcessor <LongEvent>(ringBuffer).Sequence);
ringBuffer.PublishEvent(this);
ringBuffer.PublishEvent(this);
Console.WriteLine("ringBuffer[0].Value={0}", ringBuffer[0].Value);
Console.WriteLine("ringBuffer[0].Value={0}", ringBuffer[1].Value);
Assert.AreEqual(ringBuffer[0].Value, 29L);
Assert.AreEqual(ringBuffer[1].Value, 30L);
}
public BatchedPoller(RingBuffer <DataEvent> ringBuffer, int batchSize)
{
_poller = ringBuffer.NewPoller();
ringBuffer.AddGatingSequences(_poller.Sequence);
if (batchSize < 1)
{
batchSize = 20;
}
_maxBatchSize = batchSize;
_polledData = new BatchedData(_maxBatchSize);
}
/// <summary>
/// Starts the event processors and returns the fully configured ring buffer.
///
/// The ring buffer is set up to prevent overwriting any entry that is yet to
/// be processed by the slowest event processor.
///
/// This method must only be called once after all event processors have been added.
/// </summary>
/// <returns>the configured ring buffer</returns>
public RingBuffer <T> Start()
{
_ringBuffer.AddGatingSequences(_consumerRepository.GetLastSequenceInChain(true));
CheckOnlyStartedOnce();
foreach (var consumerInfo in _consumerRepository)
{
consumerInfo.Start(_executor);
}
return(_ringBuffer);
}
public ThreeToOneSequencedBatchThroughputTest()
: base(Test_Disruptor, ITERATIONS, 7)
{
ThreadPool.SetMaxThreads(4, 4);
sequenceBarrier = ringBuffer.NewBarrier();
batchEventProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handler);
for (int i = 0; i < NUM_PUBLISHERS; i++)
{
valuePublishers[i] = new ValueBatchPublisher(cyclicBarrier, ringBuffer, ITERATIONS / NUM_PUBLISHERS, 10);
}
ringBuffer.AddGatingSequences(batchEventProcessor.Sequence);
}
/// <summary>
/// Set up custom event processors to handle events from the ring buffer. The Disruptor will automatically start these processors when <see cref="StartAsync"/> is called.
/// </summary>
/// <param name="processors">the event processors that will process events.</param>
/// <returns>a <see cref="EventHandlerGroup{T}"/> that can be used to chain dependencies.</returns>
public EventHandlerGroup <T> HandleEventsWith(params IEventProcessor[] processors)
{
if (processors == null)
{
return(null);
}
foreach (var processor in processors)
{
_consumerRepository.Add(processor);
}
var sequences = new ISequence[processors.Length];
for (var i = 0; i < processors.Length; i++)
{
sequences[i] = processors[i].GetSequence();
}
_ringBuffer.AddGatingSequences(sequences);
return(new EventHandlerGroup <T>(this, _consumerRepository, SequenceGroupManager.GetSequencesFor(processors)));
}
/// <summary>
/// <p>Starts the event processors and returns the fully configured ring buffer.</p>
///
/// <p>The ring buffer is set up to prevent overwriting any entry that is yet to
/// be processed by the slowest event processor.</p>
///
/// <p>This method must only be called once after all event processors have been added.</p>
/// </summary>
/// <returns>the configured ring buffer.</returns>
public RingBuffer <T> Start()
{
var gatingSequences = consumerRepository.GetLastSequenceInChain(true);
ringBuffer.AddGatingSequences(gatingSequences);
CheckOnlyStartedOnce();
foreach (var consumerInfo in consumerRepository.AllConsumerInfos)
{
consumerInfo.Start(taskScheduler);
}
return(ringBuffer);
}
public PingPongLatencyTest()
{
InitHistogram();
pongBarrier = pongBuffer.NewBarrier();
pinger = new Pinger(pingBuffer, ITERATIONS, PAUSE_NANOS);
pingProcessor = new BatchEventProcessor <ValueEvent>(pongBuffer, pongBarrier, pinger);
pingBarrier = pingBuffer.NewBarrier();
ponger = new Ponger(pongBuffer);
pongProcessor = new BatchEventProcessor <ValueEvent>(pingBuffer, pingBarrier, ponger);
pingBuffer.AddGatingSequences(pongProcessor.Sequence);
pongBuffer.AddGatingSequences(pingProcessor.Sequence);
}
public OneToThreeSequencedThroughputTest()
{
for (long i = 0; i < _iterations; i++)
{
_results[0] = Operation.Addition.Op(_results[0], i);
_results[1] = Operation.Subtraction.Op(_results[1], i);
_results[2] = Operation.And.Op(_results[2], i);
}
_ringBuffer = RingBuffer<ValueEvent>.CreateSingleProducer(ValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handlers[0] = new ValueMutationEventHandler(Operation.Addition);
_handlers[1] = new ValueMutationEventHandler(Operation.Subtraction);
_handlers[2] = new ValueMutationEventHandler(Operation.And);
for (var i = 0; i < _numEventProcessors; i++)
{
_batchEventProcessors[i] = new BatchEventProcessor<ValueEvent>(_ringBuffer, sequenceBarrier, _handlers[i]);
}
_ringBuffer.AddGatingSequences(_batchEventProcessors.Select(x => x.Sequence).ToArray());
}
public OnePublisherToThreeProcessorDiamondThroughputTest()
: base(TestName, 1000L * 1000L * 100L)
{
ringBuffer = RingBuffer<FizzBuzzEvent>.CreateSingleProducer(() => new FizzBuzzEvent(), 1024 * 8, new YieldingWaitStrategy());
sequenceBarrier = ringBuffer.NewBarrier();
batchProcessorFizz = new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrier, fizzHandler);
batchProcessorBuzz = new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrier, buzzHandler);
sequenceBarrierFizzBuzz = ringBuffer.NewBarrier(batchProcessorFizz.Sequence, batchProcessorBuzz.Sequence);
batchProcessorFizzBuzz = new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrierFizzBuzz, fizzBuzzHandler);
ringBuffer.AddGatingSequences(batchProcessorFizzBuzz.Sequence);
}
