/// <summary>
/// Create a new Disruptor with specified starting Cursor
/// </summary>
/// <param name="eventFactory"></param>
/// <param name="claimStrategy"></param>
/// <param name="waitStrategy"></param>
/// <param name="taskScheduler"></param>
/// <param name="startSequence"></param>
public Disruptor(Func <T> eventFactory,
IClaimStrategy claimStrategy,
IWaitStrategy waitStrategy,
TaskScheduler taskScheduler, long startSequence)
: this(new RingBuffer <T>(eventFactory, claimStrategy, waitStrategy, startSequence), taskScheduler)
{
}
private static Disruptor <T> CreateDisruptor <T>(IClaimStrategy claim, IWaitStrategy wait) where T : class, new()
{
var disruptor = new Disruptor <T>(() => new T(), claim, wait, TaskScheduler.Default);
disruptor.HandleExceptionsWith(new LogAndTerminateProcessHandler());
return(disruptor);
}
/// <summary>
/// Construct a RingBuffer with the full option set.
/// </summary>
/// <param name="entryFactory"> entryFactory to create instances of T for filling the RingBuffer</param>
/// <param name="size">size of the RingBuffer that will be rounded up to the next power of 2</param>
/// <param name="claimStrategyOption"> threading strategy for producers claiming entries in the ring.</param>
/// <param name="waitStrategyOption">waiting strategy employed by consumers waiting on entries becoming available.</param>
public RingBuffer(Func <T> entryFactory, int size, ClaimStrategyFactory.ClaimStrategyOption claimStrategyOption = ClaimStrategyFactory.ClaimStrategyOption.Multithreaded, WaitStrategyFactory.WaitStrategyOption waitStrategyOption = WaitStrategyFactory.WaitStrategyOption.Blocking)
{
_claimStrategyOption = claimStrategyOption;
var sizeAsPowerOfTwo = Util.CeilingNextPowerOfTwo(size);
_ringModMask = sizeAsPowerOfTwo - 1;
_entries = new Entry <T> [sizeAsPowerOfTwo];
_claimStrategy = ClaimStrategyFactory.GetInstance(claimStrategyOption);
_waitStrategy = WaitStrategyFactory.GetInstance(waitStrategyOption);
Fill(entryFactory);
}
public ProducerBarrier(RingBuffer <T> ringBuffer, params IBatchConsumer[] consumers)
{
if (consumers.Length == 0)
{
throw new ArgumentException("There must be at least one Consumer to track for preventing ring wrap");
}
_ringBuffer = ringBuffer;
_consumers = consumers;
_entries = _ringBuffer._entries;
_claimStrategy = _ringBuffer._claimStrategy;
_ringModMask = _ringBuffer._ringModMask;
_ringBufferSize = _entries.Length;
_waitStrategy = _ringBuffer._waitStrategy;
_isMultithreaded = _ringBuffer._claimStrategyOption == ClaimStrategyFactory.ClaimStrategyOption.Multithreaded;
}
/// <summary>
/// Construct a RingBuffer with the full option set.
/// </summary>
/// <param name="eventFactory">eventFactory to create entries for filling the RingBuffer</param>
/// <param name="claimStrategy">threading strategy for publisher claiming entries in the ring.</param>
/// <param name="waitStrategy">waiting strategy employed by processorsToTrack waiting on entries becoming available.</param>
public RingBuffer(Func <T> eventFactory, IClaimStrategy claimStrategy, IWaitStrategy waitStrategy)
: base(claimStrategy, waitStrategy)
{
if (Util.CeilingNextPowerOfTwo(claimStrategy.BufferSize) != claimStrategy.BufferSize)
{
throw new ArgumentException("bufferSize must be a power of 2");
}
_indexMask = claimStrategy.BufferSize - 1;
_entries = new T[claimStrategy.BufferSize];
for (int i = 0; i < _entries.Length; i++)
{
_entries[i] = eventFactory();
}
}
public RingBuffer(IEntryFactory <T> entryFactory,
int size,
IClaimStrategy claimStrategyOption,
IWaitStrategy <T> waitStrategyOption)
{
int sizeAsPowerOfTwo = Util.CeilingNextPowerOfTwo(size);
_ringModMask = sizeAsPowerOfTwo - 1;
_entries = new T[sizeAsPowerOfTwo];
_entryFactory = entryFactory;
_claimStrategy = claimStrategyOption;
_waitStrategy = waitStrategyOption;
Fill();
}
/// <summary>
/// Construct a work pool with an internal <see cref="RingBuffer{T}"/> for convenience.
///
/// This option does not require <see cref="Sequencer.SetGatingSequences"/> to be called before the work pool is started.
/// </summary>
/// <param name="eventFactory">eventFactory for filling the <see cref="RingBuffer{T}"/></param>
/// <param name="claimStrategy">claimStrategy for the <see cref="RingBuffer{T}"/></param>
/// <param name="waitStrategy">waitStrategy for the <see cref="RingBuffer{T}"/></param>
/// <param name="exceptionHandler">exceptionHandler to callback when an error occurs which is not handled by the <see cref="IWorkHandler{T}"/>s.</param>
/// <param name="workHandlers">workHandlers to distribute the work load across.</param>
public WorkerPool(Func <T> eventFactory,
IClaimStrategy claimStrategy,
IWaitStrategy waitStrategy,
IExceptionHandler exceptionHandler,
params IWorkHandler <T>[] workHandlers)
{
_ringBuffer = new RingBuffer <T>(eventFactory, claimStrategy, waitStrategy);
var barrier = _ringBuffer.NewBarrier();
int numWorkers = workHandlers.Length;
_workProcessors = new WorkProcessor <T> [numWorkers];
for (int i = 0; i < numWorkers; i++)
{
_workProcessors[i] = new WorkProcessor <T>(_ringBuffer,
barrier,
workHandlers[i],
exceptionHandler,
_workSequence);
}
_ringBuffer.SetGatingSequences(WorkerSequences);
}
public void SetUp()
{
_claimStrategy = new SingleThreadedClaimStrategy(BufferSize);
}
public void SetUp()
{
_claimStrategy = new SingleThreadedClaimStrategy(BufferSize);
}
/// <summary>
///
/// </summary>
/// <param name="claimStrategy"></param>
/// <param name="waitStrategy"></param>
/// <param name="startSequence"></param>
public Sequencer(IClaimStrategy claimStrategy, IWaitStrategy waitStrategy, long startSequence)
{
_claimStrategy = claimStrategy;
_waitStrategy = waitStrategy;
_cursor = new Sequence(startSequence);
}
/// <summary>
/// Construct a Sequencer with the selected strategies.
/// </summary>
/// <param name="claimStrategy">claimStrategy for those claiming sequences.</param>
/// <param name="waitStrategy">waitStrategy for those waiting on sequences.</param>
public Sequencer(IClaimStrategy claimStrategy, IWaitStrategy waitStrategy)
{
_claimStrategy = claimStrategy;
_waitStrategy = waitStrategy;
}
/// <summary>
/// Construct a Sequencer with the selected strategies.
/// </summary>
/// <param name="claimStrategy">claimStrategy for those claiming sequences.</param>
/// <param name="waitStrategy">waitStrategy for those waiting on sequences.</param>
public Sequencer(IClaimStrategy claimStrategy, IWaitStrategy waitStrategy)
{
_claimStrategy = claimStrategy;
_waitStrategy = waitStrategy;
}
public void SetUp()
{
_claimStrategy = new MultiThreadedLowContentionClaimStrategy(BufferSize);
}
public void SetUp()
{
_claimStrategy = new MultiThreadedLowContentionClaimStrategy(BufferSize);
}
public void SetUp()
{
_claimStrategy = new MultiThreadedClaimStrategy(BufferSize);
}
/// <summary>
/// Construct a Sequencer with the selected strategies.
/// </summary>
/// <param name="claimStrategy">claimStrategy for those claiming sequences.</param>
/// <param name="waitStrategy">waitStrategy for those waiting on sequences.</param>
public Sequencer(IClaimStrategy claimStrategy, IWaitStrategy waitStrategy)
{
_claimStrategy = claimStrategy;
_waitStrategy = waitStrategy;
_cursor = new Sequence(InitialCursorValue);
}
public void SetUp()
{
_claimStrategy = new MultiThreadedClaimStrategy(BufferSize);
}
/// <summary>
/// Create a new Disruptor.
/// </summary>
/// <param name="eventFactory">the factory to create events in the ring buffer.</param>
/// <param name="claimStrategy">the claim strategy to use for the ring buffer.</param>
/// <param name="waitStrategy">the wait strategy to use for the ring buffer.</param>
public Disruptor(Func <T> eventFactory,
IClaimStrategy claimStrategy,
IWaitStrategy waitStrategy)
: this(new RingBuffer <T>(eventFactory, claimStrategy, waitStrategy))
{
}
