public MultiProducerSequencerBenchmarks()
{
_sequencer = new MultiProducerSequencer(1024, new BusySpinWaitStrategy());
_sequencerPointer = new MultiProducerSequencerPointer(1024, new BusySpinWaitStrategy());
_sequence = _sequencer.Next();
_sequencerPointer.Next();
}
public CustomSequenceBarrier(MultiProducerSequencer sequencer, IWaitStrategy waitStrategy, Sequence cursorSequence, ISequence[] dependentSequences)
{
_sequencer = sequencer;
_waitStrategy = waitStrategy;
_dependentSequences = new DependentSequenceGroup(cursorSequence, dependentSequences);
_cancellationTokenSource = new CancellationTokenSource();
}
public MultiProducerSequencerBenchmarks()
{
_sequencer = new MultiProducerSequencer(1024, new BusySpinWaitStrategy());
_sequencerRef1 = new MultiProducerSequencerRef1(1024, new BusySpinWaitStrategy());
_sequencerRef2 = new MultiProducerSequencerRef2(1024, new BusySpinWaitStrategy());
Sequence = 42;
}
protected SequenceBarrierBenchmarks()
{
_requesterSequencer = new MultiProducerSequencer(1024, new YieldingWaitStrategy());
_requesterRingBuffer = new RingBuffer <Event>(() => new Event(), _requesterSequencer);
_replierSequencer = new MultiProducerSequencer(1024, new YieldingWaitStrategy());
_replierRingBuffer = new RingBuffer <Event>(() => new Event(), _replierSequencer);
}
public void ShouldOnlyAllowMessagesToBeAvailableIfSpecificallyPublished()
{
var sequencer = new MultiProducerSequencer(32);
sequencer.Publish(3);
sequencer.Publish(5);
Assert.That(sequencer.IsAvailable(0), Is.EqualTo(false));
Assert.That(sequencer.IsAvailable(1), Is.EqualTo(false));
Assert.That(sequencer.IsAvailable(2), Is.EqualTo(false));
Assert.That(sequencer.IsAvailable(3), Is.EqualTo(true));
Assert.That(sequencer.IsAvailable(4), Is.EqualTo(false));
Assert.That(sequencer.IsAvailable(5), Is.EqualTo(true));
Assert.That(sequencer.IsAvailable(6), Is.EqualTo(false));
}
public void ShouldGetHighestPublishedSequence([Range(2, 7)] int publishedSequence)
{
var sequencer = new MultiProducerSequencer(32);
for (var i = 0; i <= 7; i++)
{
sequencer.Next();
}
for (var i = 0; i <= publishedSequence; i++)
{
sequencer.Publish(i);
}
Assert.That(sequencer.GetHighestPublishedSequence(3, 7), Is.EqualTo(publishedSequence));
}
public void ShouldOnlyAllowMessagesToBeAvailableIfSpecificallyPublished()
{
var publisher = new MultiProducerSequencer(1024, new BlockingWaitStrategy());
publisher.Publish(3);
publisher.Publish(5);
publisher.Publish(6);
publisher.Publish(7);
Assert.AreEqual(publisher.IsAvailable(0), false);
Assert.AreEqual(publisher.IsAvailable(1), false);
Assert.AreEqual(publisher.IsAvailable(2), false);
Assert.AreEqual(publisher.IsAvailable(3), true);
Assert.AreEqual(publisher.IsAvailable(4), false);
Assert.AreEqual(publisher.IsAvailable(5), true);
Assert.AreEqual(publisher.IsAvailable(6), true);
Assert.AreEqual(publisher.IsAvailable(6), true);
}
public SequencerDispatcherBenchmarks_MultiProducer()
{
_singleProducerSequencer = new MultiProducerSequencer(1024, new YieldingWaitStrategy());
_sequencer = _singleProducerSequencer;
_dispatcher = new SequencerDispatcher(_sequencer);
}
public void SetUp()
{
_publisher = new MultiProducerSequencer(1024);
}
/// <summary>
/// Create a new multiple 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> CreateMultiProducer(Func <T> factory, int bufferSize, IWaitStrategy waitStrategy)
{
MultiProducerSequencer sequencer = new MultiProducerSequencer(bufferSize, waitStrategy);
return(new RingBuffer <T>(factory, sequencer));
}
