public void SetUp()
{
_ringBuffer = ValueRingBuffer <StubValueEvent> .CreateMultiProducer(() => new StubValueEvent(-1), 32);
_sequenceBarrier = _ringBuffer.NewBarrier();
_ringBuffer.AddGatingSequences(new NoOpEventProcessor <StubValueEvent>(_ringBuffer).Sequence);
}
internal ValueEventHandlerGroup <T> CreateEventProcessors(ISequence[] barrierSequences, IValueEventHandler <T>[] eventHandlers)
{
CheckNotStarted();
var processorSequences = new ISequence[eventHandlers.Length];
var barrier = _ringBuffer.NewBarrier(barrierSequences);
for (int i = 0; i < eventHandlers.Length; i++)
{
var eventHandler = eventHandlers[i];
var batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, barrier, eventHandler);
if (_exceptionHandler != null)
{
batchEventProcessor.SetExceptionHandler(_exceptionHandler);
}
_consumerRepository.Add(batchEventProcessor, eventHandler, barrier);
processorSequences[i] = batchEventProcessor.Sequence;
}
UpdateGatingSequencesForNextInChain(barrierSequences, processorSequences);
return(new ValueEventHandlerGroup <T>(this, _consumerRepository, processorSequences));
}
public void ShouldCallExceptionHandlerOnTimeoutException()
{
var waitStrategy = new TimeoutBlockingWaitStrategy(TimeSpan.FromMilliseconds(1));
var ringBuffer = new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(-1), new SingleProducerSequencer(16, waitStrategy));
var sequenceBarrier = ringBuffer.NewBarrier();
var exceptionSignal = new CountdownEvent(1);
var exceptionHandler = new TestValueExceptionHandler <StubValueEvent>(x => exceptionSignal.Signal());
var eventHandler = new TestValueEventHandler <StubValueEvent> {
OnTimeoutAction = TestException.ThrowOnce()
};
var eventProcessor = CreateEventProcessor(ringBuffer, sequenceBarrier, eventHandler);
ringBuffer.AddGatingSequences(eventProcessor.Sequence);
eventProcessor.SetExceptionHandler(exceptionHandler);
var task = eventProcessor.Start();
Assert.IsTrue(exceptionSignal.Wait(TimeSpan.FromSeconds(2)));
Assert.AreEqual(0, exceptionHandler.EventExceptionCount);
Assert.AreEqual(1, exceptionHandler.TimeoutExceptionCount);
eventProcessor.Halt();
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(2)));
}
public OneToOneSequencedBatchValueThroughputTest()
{
_ringBuffer = ValueRingBuffer <PerfValueEvent> .CreateSingleProducer(PerfValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new AdditionEventHandler();
_batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public PingPongSequencedValueLatencyTest()
{
_pingBuffer = ValueRingBuffer <PerfValueEvent> .CreateSingleProducer(PerfValueEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
_pongBuffer = ValueRingBuffer <PerfValueEvent> .CreateSingleProducer(PerfValueEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
_pingBarrier = _pingBuffer.NewBarrier();
_pongBarrier = _pongBuffer.NewBarrier();
_pinger = new Pinger(_pingBuffer, _iterations, _pauseNanos);
_ponger = new Ponger(_pongBuffer);
_pingProcessor = BatchEventProcessorFactory.Create(_pongBuffer, _pongBarrier, _pinger);
_pongProcessor = BatchEventProcessorFactory.Create(_pingBuffer, _pingBarrier, _ponger);
_pingBuffer.AddGatingSequences(_pongProcessor.Sequence);
_pongBuffer.AddGatingSequences(_pingProcessor.Sequence);
}
public void ShouldCallOnTimeout()
{
var waitStrategy = new TimeoutBlockingWaitStrategy(TimeSpan.FromMilliseconds(1));
var ringBuffer = new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(-1), new SingleProducerSequencer(16, waitStrategy));
var sequenceBarrier = ringBuffer.NewBarrier();
var onTimeoutSignal = new ManualResetEvent(false);
var eventHandler = new TestValueEventHandler <StubValueEvent> {
OnTimeoutAction = () => onTimeoutSignal.Set()
};
var eventProcessor = CreateEventProcessor(ringBuffer, sequenceBarrier, eventHandler);
ringBuffer.AddGatingSequences(eventProcessor.Sequence);
var task = eventProcessor.Start();
Assert.IsTrue(onTimeoutSignal.WaitOne(TimeSpan.FromSeconds(2)));
eventProcessor.Halt();
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(2)));
}
public ValueEventProcessorTests()
{
_ringBuffer = new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(-1), 16);
_sequenceBarrier = _ringBuffer.NewBarrier();
}
public void Setup()
{
_ringBuffer = new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(-1), 16);
_sequenceBarrier = _ringBuffer.NewBarrier();
}
public IEventProcessor CreateEventProcessor(ValueRingBuffer <TestValueEvent> ringBuffer, ISequence[] barrierSequences)
{
Assert.AreEqual(_sequenceLength, barrierSequences.Length, "Should not have had any barrier sequences");
return(BatchEventProcessorFactory.Create(_disruptor.RingBuffer, ringBuffer.NewBarrier(barrierSequences), _eventHandler));
}
