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) { }