public void ShouldNotUpdateCursorDuringHasAvailableCapacity() { var sequencer = new SingleProducerSequencer(16, new BusySpinWaitStrategy()); for (int i = 0; i < 32; i++) { var next = sequencer.Next(); Assert.That(sequencer.Cursor, Is.Not.EqualTo(next)); sequencer.HasAvailableCapacity(13); Assert.That(sequencer.Cursor, Is.Not.EqualTo(next)); sequencer.Publish(next); } }
public void ShouldAlwaysHalt() { var waitStrategy = new BusySpinWaitStrategy(); var sequencer = new SingleProducerSequencer(8, waitStrategy); var barrier = ProcessingSequenceBarrierFactory.Create(sequencer, waitStrategy, new Sequence(-1), new Sequence[0]); var dp = new DummyDataProvider <object>(); var h1 = new LifeCycleHandler(); var p1 = CreateBatchEventProcessor(dp, barrier, h1); var t1 = new Thread(p1.Run); p1.Halt(); t1.Start(); Assert.IsTrue(h1.WaitStart(TimeSpan.FromSeconds(2))); Assert.IsTrue(h1.WaitShutdown(TimeSpan.FromSeconds(2))); for (int i = 0; i < 1000; i++) { var h2 = new LifeCycleHandler(); var p2 = CreateBatchEventProcessor(dp, barrier, h2); var t2 = new Thread(p2.Run); t2.Start(); p2.Halt(); Assert.IsTrue(h2.WaitStart(TimeSpan.FromSeconds(2))); Assert.IsTrue(h2.WaitShutdown(TimeSpan.FromSeconds(2))); } for (int i = 0; i < 1000; i++) { var h2 = new LifeCycleHandler(); var p2 = CreateBatchEventProcessor(dp, barrier, h2); var t2 = new Thread(p2.Run); t2.Start(); Thread.Yield(); p2.Halt(); Assert.IsTrue(h2.WaitStart(TimeSpan.FromSeconds(2))); Assert.IsTrue(h2.WaitShutdown(TimeSpan.FromSeconds(2))); } }
public EventProcessorBenchmarks_Wait() { var waitStrategy = new YieldingWaitStrategy(); var sequencer = new SingleProducerSequencer(64, waitStrategy); var cursorSequence = new Sequence(); var dependentSequences = new ISequence[0]; var sequenceBarrier = new SequenceBarrier(sequencer, waitStrategy, cursorSequence, dependentSequences); var sequenceBarrierClass = new SequenceBarrierClass(sequencer, waitStrategy, cursorSequence, dependentSequences); var sequenceBarrierProxy = StructProxy.CreateProxyInstance(sequenceBarrierClass); var eventProcessorType = typeof(PartialEventProcessor <,>).MakeGenericType(typeof(ISequenceBarrierOptions.IsDependentSequencePublished), sequenceBarrierProxy.GetType()); _processor1 = (IPartialEventProcessor)Activator.CreateInstance(eventProcessorType, sequenceBarrier, sequenceBarrierProxy); _processor2 = new PartialEventProcessor <ISequenceBarrierOptions.IsDependentSequencePublished, SequenceBarrierStruct>(sequenceBarrier, new SequenceBarrierStruct(sequencer, waitStrategy, cursorSequence, dependentSequences)); sequencer.Publish(42); cursorSequence.SetValue(42); }
public void ShouldAlwaysHalt() { var waitStrategy = new BusySpinWaitStrategy(); var sequencer = new SingleProducerSequencer(8, waitStrategy); var barrier = new SequenceBarrier(sequencer, waitStrategy, new Sequence(-1), new Sequence[0]); var dp = new ArrayValueDataProvider <long>(sequencer.BufferSize); var h1 = new LifeCycleHandler(); var p1 = CreateEventProcessor(dp, barrier, h1); p1.Halt(); p1.Start(); Assert.IsTrue(h1.WaitStart(TimeSpan.FromSeconds(2))); Assert.IsTrue(h1.WaitShutdown(TimeSpan.FromSeconds(2))); for (int i = 0; i < 1000; i++) { var h2 = new LifeCycleHandler(); var p2 = CreateEventProcessor(dp, barrier, h2); p2.Start(); p2.Halt(); Assert.IsTrue(h2.WaitStart(TimeSpan.FromSeconds(2))); Assert.IsTrue(h2.WaitShutdown(TimeSpan.FromSeconds(2))); } for (int i = 0; i < 1000; i++) { var h2 = new LifeCycleHandler(); var p2 = CreateEventProcessor(dp, barrier, h2); p2.Start(); Thread.Yield(); p2.Halt(); Assert.IsTrue(h2.WaitStart(TimeSpan.FromSeconds(2))); Assert.IsTrue(h2.WaitShutdown(TimeSpan.FromSeconds(2))); } }
public void Should_Poll_For_Events() { var gatingSequence = new Sequence(); var sequencer = new SingleProducerSequencer(16, new BusySpinWaitStrategy()); var handler = new EventPollerHandler(); var data = new object[16]; var provider = new DataProvider(data); var poller = sequencer.NewPoller(provider, gatingSequence); var @event = new object(); data[0] = @event; Assert.Equal(EventPoller <object> .PollState.Idle, poller.Poll(handler)); sequencer.Publish(sequencer.Next()); Assert.Equal(EventPoller <object> .PollState.Gating, poller.Poll(handler)); gatingSequence.IncrementAndGet(); Assert.Equal(EventPoller <object> .PollState.Processing, poller.Poll(handler)); }
public void ShouldPollForEvents() { var gatingSequence = new Sequence(); var sequencer = new SingleProducerSequencer(16, new BusySpinWaitStrategy()); bool Handler(object e, long s, bool b) => false; var provider = new ArrayDataProvider <object>(new object[16]); provider.Data[0] = new object(); var poller = sequencer.NewPoller(provider, gatingSequence); Assert.That(poller.Poll(Handler), Is.EqualTo(EventPoller.PollState.Idle)); // Publish Event. sequencer.Publish(sequencer.Next()); Assert.That(poller.Poll(Handler), Is.EqualTo(EventPoller.PollState.Gating)); gatingSequence.IncrementAndGet(); Assert.That(poller.Poll(Handler), Is.EqualTo(EventPoller.PollState.Processing)); }
public SequencerDispatcherBenchmarks_SingleProducer() { _singleProducerSequencer = new SingleProducerSequencer(1024, new YieldingWaitStrategy()); _sequencer = _singleProducerSequencer; _dispatcher = new SequencerDispatcher(_sequencer); }
/// <summary> /// Create a new single producer RingBuffer with the specified wait strategy. /// </summary> /// <param name="factory">used to create the events within the ring buffer.</param> /// <param name="bufferSize">number of elements to create within the ring buffer.</param> /// <param name="waitStrategy">used to determine how to wait for new elements to become available.</param> /// <returns>a constructed ring buffer.</returns> /// <exception cref="ArgumentException">if bufferSize is less than 1 or not a power of 2</exception> public static RingBuffer <T> CreateSingleProducer(Func <T> factory, int bufferSize, IWaitStrategy waitStrategy) { SingleProducerSequencer sequencer = new SingleProducerSequencer(bufferSize, waitStrategy); return(new RingBuffer <T>(factory, sequencer)); }
// padding: 7 public SequencerDispatcher(ISequencer sequencer) { _singleProducerSequencer = default !;