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 !;