public RingBufferReadBenchmarks()
{
_ringBuffer = new RingBuffer <Event>(() => new Event(), new SingleProducerSequencer(4096, new BusySpinWaitStrategy()));
_valueRingBuffer = new ValueRingBuffer <ValueEvent>(() => new ValueEvent(), new SingleProducerSequencer(4096, new BusySpinWaitStrategy()));
_unmanagedRingBufferMemory = UnmanagedRingBufferMemory.Allocate(4096, () => new ValueEvent());
_unmanagedRingBuffer = new UnmanagedRingBuffer <ValueEvent>(_unmanagedRingBufferMemory, ProducerType.Single, new BusySpinWaitStrategy());
}
public void SetUp()
{
_ringBuffer = null;
_delayedEventHandlers = new List <DelayedEventHandler>();
_taskScheduler = new StubTaskScheduler();
_disruptor = new ValueDisruptor <TestValueEvent>(() => new TestValueEvent(), 4, _taskScheduler);
}
public void SetUp()
{
_ringBuffer = null;
_delayedEventHandlers = new List <DelayedEventHandler>();
_executor = new StubExecutor();
_disruptor = new ValueDisruptor <TestValueEvent>(() => new TestValueEvent(), 4, _executor);
}
public Pinger(ValueRingBuffer <PerfValueEvent> buffer, long maxEvents, long pauseTimeNs)
{
_buffer = buffer;
_maxEvents = maxEvents;
_pauseTimeNs = pauseTimeNs;
_pauseTimeTicks = LatencyTestSession.ConvertNanoToStopwatchTicks(pauseTimeNs);
}
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 void SetUp()
{
_ringBuffer = ValueRingBuffer <StubValueEvent> .CreateMultiProducer(() => new StubValueEvent(-1), 32);
_sequenceBarrier = _ringBuffer.NewBarrier();
_ringBuffer.AddGatingSequences(new NoOpEventProcessor <StubValueEvent>(_ringBuffer).Sequence);
}
public void ShouldSuccessfullyPollWhenBufferIsFull()
{
var events = new List <byte>();
byte Factory() => 0;
bool Handler(ref byte data, long sequence, bool endOfBatch)
{
events.Add(data);
return(!endOfBatch);
}
var ringBuffer = ValueRingBuffer <byte> .CreateMultiProducer(Factory, 4, new SleepingWaitStrategy());
var poller = ringBuffer.NewPoller();
ringBuffer.AddGatingSequences(poller.Sequence);
const int count = 4;
for (byte i = 1; i <= count; ++i)
{
var next = ringBuffer.Next();
ringBuffer[next] = i;
ringBuffer.Publish(next);
}
// think of another thread
poller.Poll(Handler);
Assert.That(events, Is.EquivalentTo(new byte[] { 1, 2, 3, 4 }));
}
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 ValueEventProcessorBenchmarks()
{
_ringBuffer = new ValueRingBuffer <XEvent>(() => new XEvent(), new SingleProducerSequencer(_ringBufferSize, new BusySpinWaitStrategy()));
for (var i = 0; i < _ringBufferSize; i++)
{
using var scope = _ringBuffer.PublishEvent();
scope.Event().Data = i;
}
}
public void ShouldNotPublishEventsIfBatchIsLargerThanRingBuffer()
{
var ringBuffer = ValueRingBuffer <long> .CreateSingleProducer(() => - 1L, 4);
try
{
Assert.Throws <ArgumentException>(() => ringBuffer.TryPublishEvents(5));
}
finally
{
AssertEmptyRingBuffer(ringBuffer);
}
}
public static void PublishStubEvent(this ValueRingBuffer <StubValueEvent> ringBuffer, int value)
{
var sequence = ringBuffer.Next();
try
{
ringBuffer[sequence].Value = value;
}
finally
{
ringBuffer.Publish(sequence);
}
}
public void ShouldNotTryPublishEventsWhenBatchSizeIs0()
{
var ringBuffer = ValueRingBuffer <long> .CreateSingleProducer(() => - 1L, 4);
try
{
Assert.Throws <ArgumentException>(() => ringBuffer.TryPublishEvents(0));
}
finally
{
AssertEmptyRingBuffer(ringBuffer);
}
}
private void PublishEvent()
{
if (_ringBuffer == null)
{
_ringBuffer = _disruptor.Start();
foreach (var eventHandler in _delayedEventHandlers)
{
eventHandler.AwaitStart();
}
}
_disruptor.PublishEvent().Dispose();
}
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 ShouldPublishEvent()
{
var ringBuffer = ValueRingBuffer <long> .CreateSingleProducer(() => - 1L, 4);
using (var scope = ringBuffer.PublishEvent())
{
scope.Event() = scope.Sequence;
}
using (var scope = ringBuffer.TryPublishEvent())
{
Assert.IsTrue(scope.HasEvent);
Assert.IsTrue(scope.TryGetEvent(out var e));
e.Event() = e.Sequence;
}
Assert.That(ringBuffer, ValueRingBufferEqualsConstraint.IsValueRingBufferWithEvents(0L, 1L));
}
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 void ShouldReportValueEventHandlerProgressByUpdatingSequenceViaCallback()
{
var ringBuffer = ValueRingBuffer <StubValueEvent> .CreateMultiProducer(() => new StubValueEvent(-1), 16);
var sequenceBarrier = ringBuffer.NewBarrier();
var handler = new TestSequenceReportingEventHandler();
var batchEventProcessor = BatchEventProcessorFactory.Create(ringBuffer, sequenceBarrier, handler);
ringBuffer.AddGatingSequences(batchEventProcessor.Sequence);
var task = Task.Run(batchEventProcessor.Run);
Assert.AreEqual(-1L, batchEventProcessor.Sequence.Value);
ringBuffer.Publish(ringBuffer.Next());
handler.CallbackSignal.WaitOne();
Assert.AreEqual(0L, batchEventProcessor.Sequence.Value);
handler.OnEndOfBatchSignal.Set();
Assert.AreEqual(0L, batchEventProcessor.Sequence.Value);
batchEventProcessor.Halt();
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(10)));
}
public LoopbackEventHandler(ValueRingBuffer <StubValueEvent> ringBuffer, List <long> batchSizes, CountdownEvent signal)
{
_batchSizes = batchSizes;
_ringBuffer = ringBuffer;
_signal = signal;
}
public ValueEventProcessorTests()
{
_ringBuffer = new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(-1), 16);
_sequenceBarrier = _ringBuffer.NewBarrier();
}
public void ShouldGetEventFromSequence(long sequence)
{
var index = 0;
var ringBuffer = new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(index++), 32);
ref var evt = ref ringBuffer[sequence];
public NullableUnpublishedEventBatchScope(ValueRingBuffer <T>?ringBuffer, long startSequence, long endSequence)
{
_ringBuffer = ringBuffer;
_startSequence = startSequence;
_endSequence = endSequence;
}
/// <summary>
/// Create a new ValueDisruptor. Will default to <see cref="BlockingWaitStrategy"/> and <see cref="ProducerType.Multi"/>.
/// </summary>
/// <param name="eventFactory">the factory to create events in the ring buffer</param>
/// <param name="ringBufferSize">the size of the ring buffer, must be power of 2</param>
/// <param name="executor">an <see cref="IExecutor"/> to create threads for processors</param>
public ValueDisruptor(Func <T> eventFactory, int ringBufferSize, IExecutor executor)
: this(ValueRingBuffer <T> .CreateMultiProducer(eventFactory, ringBufferSize), executor)
{
}
/// <summary>
/// Create a new ValueDisruptor. Will default to <see cref="BlockingWaitStrategy"/> and <see cref="ProducerType.Multi"/>.
/// </summary>
/// <param name="eventFactory">the factory to create events in the ring buffer</param>
/// <param name="ringBufferSize">the size of the ring buffer, must be power of 2</param>
/// <param name="taskScheduler">a <see cref="TaskScheduler"/> to create threads for processors</param>
public ValueDisruptor(Func <T> eventFactory, int ringBufferSize, TaskScheduler taskScheduler)
: this(ValueRingBuffer <T> .CreateMultiProducer(eventFactory, ringBufferSize), new BasicExecutor(taskScheduler))
{
}
public EventBatchRef(ValueRingBuffer <T> ringBuffer, long startSequence, long endSequence)
{
_ringBuffer = ringBuffer;
_startSequence = startSequence;
_endSequence = endSequence;
}
public void Setup()
{
_ringBuffer = new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(-1), 16);
_sequenceBarrier = _ringBuffer.NewBarrier();
}
public Ponger(ValueRingBuffer <PerfValueEvent> buffer)
{
_buffer = buffer;
}
/// <summary>
/// Create a new ValueDisruptor.
/// </summary>
/// <param name="eventFactory">the factory to create events in the ring buffer</param>
/// <param name="ringBufferSize">the size of the ring buffer, must be power of 2</param>
/// <param name="taskScheduler">a <see cref="TaskScheduler"/> to create threads for processors</param>
/// <param name="producerType">the claim strategy to use for the ring buffer</param>
/// <param name="waitStrategy">the wait strategy to use for the ring buffer</param>
public ValueDisruptor(Func <T> eventFactory, int ringBufferSize, TaskScheduler taskScheduler, ProducerType producerType, IWaitStrategy waitStrategy)
: this(ValueRingBuffer <T> .Create(producerType, eventFactory, ringBufferSize, waitStrategy), new BasicExecutor(taskScheduler))
{
}
public void TestSimpleWriteRead()
{
var b = new ValueRingBuffer <int>(16);
Assert.Equal(3, b.TryWrite(stackalloc int[] { 1, 2, 3 }));
private ValueDisruptor(ValueRingBuffer <T> ringBuffer, IExecutor executor)
{
_ringBuffer = ringBuffer;
_executor = executor;
}
private ValueDisruptor(ValueRingBuffer <T> ringBuffer, TaskScheduler taskScheduler)
: base(ringBuffer, taskScheduler)
{
}
