public void WaitForCursor(long sequence, IRingBuffer ringBuffer)
{
while (ringBuffer.Cursor != sequence)
{
// busy spin
}
}
public void WaitForCursor(long sequence, IRingBuffer ringBuffer)
{
while (ringBuffer.Cursor != sequence)
{
// busy spin
}
}
public Pipeline3StepLatencyPerfTest()
{
InitHistogram();
InitStopwatchTimeCostNs();
ringBuffer =
new RingBuffer <ValueEntry>(new ValueEntryFactory(), SIZE,
new SingleThreadedStrategy(),
new BusySpinStrategy <ValueEntry>());
stepOneConsumerBarrier = ringBuffer.CreateConsumerBarrier();
stepOneFunctionHandler = new LatencyStepHandler(FunctionStep.ONE, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepOneBatchConsumer = new BatchConsumer <ValueEntry>(stepOneConsumerBarrier, stepOneFunctionHandler);
stepTwoConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepOneBatchConsumer);
stepTwoFunctionHandler = new LatencyStepHandler(FunctionStep.TWO, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepTwoBatchConsumer = new BatchConsumer <ValueEntry>(stepTwoConsumerBarrier, stepTwoFunctionHandler);
stepThreeConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepTwoBatchConsumer);
stepThreeFunctionHandler = new LatencyStepHandler(FunctionStep.THREE, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepThreeBatchConsumer = new BatchConsumer <ValueEntry>(stepThreeConsumerBarrier, stepThreeFunctionHandler);
producerBarrier = ringBuffer.CreateProducerBarrier(stepThreeBatchConsumer);
stepOneQueue = new BlockingCollection <long>(SIZE);
stepTwoQueue = new BlockingCollection <long>(SIZE);
stepThreeQueue = new BlockingCollection <long>(SIZE);
stepOneQueueConsumer = new LatencyStepQueueConsumer(
FunctionStep.ONE, stepOneQueue, stepTwoQueue, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepTwoQueueConsumer = new LatencyStepQueueConsumer(
FunctionStep.TWO, stepTwoQueue, stepThreeQueue, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepThreeQueueConsumer = new LatencyStepQueueConsumer(
FunctionStep.THREE, stepThreeQueue, null, _histogram, _stopwatchTimeCostNs, _stopwatch);
}
public SystemSnapshotTracker(long journaledSequence, int frequency, IRingBuffer <SnapshotItem> snapshotRing, IRepository repository)
{
if (journaledSequence < 0)
{
throw new ArgumentOutOfRangeException("journaledSequence");
}
if (frequency < 100)
{
throw new ArgumentOutOfRangeException("frequency");
}
if (snapshotRing == null)
{
throw new ArgumentNullException("snapshotRing");
}
if (repository == null)
{
throw new ArgumentNullException("repository");
}
this.frequency = frequency;
this.nextSnapshotSequence = ((journaledSequence / this.frequency) * this.frequency) + this.frequency;
this.snapshotRing = snapshotRing;
this.repository = repository;
}
private void Restore(BootstrapInfo info, IRingBuffer <TransformationItem> transformRing, IRingBuffer <JournalItem> journalRing)
{
var startingSequence = Math.Min(info.DispatchSequence + 1, info.SnapshotSequence + 1);
Log.InfoFormat("Restoring from sequence {0}, will dispatch and will replay messages (this could take some time...).", startingSequence);
var replayed = false;
foreach (var message in this.store.Load(startingSequence))
{
replayed = Replay(info, transformRing, message) || replayed;
this.Dispatch(info, journalRing, message);
if (message.Sequence % 25000 == 0)
{
Log.InfoFormat("Pushed message sequence {0} for replay", message.Sequence);
}
}
Log.Info("All journaled messages restored into transformation disruptor; awaiting transformation completion.");
if (!replayed)
{
this.OnComplete(true);
}
}
public long WaitFor(IConsumer[] consumers, IRingBuffer <T> ringBuffer, IConsumerBarrier <T> barrier, long sequence)
{
long availableSequence;
if (0 == consumers.Length)
{
while ((availableSequence = ringBuffer.Cursor) < sequence)
{
if (barrier.IsAlerted())
{
throw AlertException.ALERT_EXCEPTION;
}
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(consumers)) < sequence)
{
if (barrier.IsAlerted())
{
throw AlertException.ALERT_EXCEPTION;
}
}
}
return(availableSequence);
}
public TransformationHandler(
long journaledSequence,
IRingBuffer <JournalItem> journalRing,
IDeliveryHandler deliveryHandler,
ISystemSnapshotTracker snapshot)
{
if (journaledSequence < 0)
{
throw new ArgumentOutOfRangeException("journaledSequence");
}
if (journalRing == null)
{
throw new ArgumentNullException("journalRing");
}
if (deliveryHandler == null)
{
throw new ArgumentNullException("deliveryHandler");
}
if (snapshot == null)
{
throw new ArgumentNullException("snapshot");
}
this.currentSequnce = journaledSequence;
this.journalRing = journalRing;
this.deliveryHandler = deliveryHandler;
this.snapshot = snapshot;
this.canHandle = true;
}
public RingBufferConsumer(
IRingBuffer <TMessage> messageQueue,
ISequenceBarrier sequenceBarrier,
IMessageHandler <TMessage> batchMessageHandler)
{
this._messageBuffer = messageQueue;
this._sequenceBarrier = sequenceBarrier;
this._batchMessageHandler = batchMessageHandler;
}
private static void Publish(SystemSnapshotStreamReader reader, IRingBuffer <BootstrapItem> ring)
{
foreach (var memento in reader.Read())
{
var next = ring.Next();
var claimed = ring[next];
claimed.AsSnapshot(memento.Item1, memento.Item2, memento.Item3);
ring.Publish(next);
}
}
/// <summary>
/// Attempts to pop the next available value from the front of the buffer.
/// </summary>
static public bool TryPopFront <T>(this IRingBuffer <T> ioBuffer, out T outValue)
{
if (ioBuffer.Count <= 0)
{
outValue = default(T);
return(false);
}
outValue = ioBuffer.PopFront();
return(true);
}
/// <summary>
/// Attempts to peek the next available value from the back of the buffer.
/// </summary>
static public bool TryPeekBack <T>(this IRingBuffer <T> inBuffer, out T outValue)
{
if (inBuffer.Count <= 0)
{
outValue = default(T);
return(false);
}
outValue = inBuffer.PeekBack();
return(true);
}
/// <summary>
/// Shuffles the given array.
/// </summary>
static public void Shuffle <T>(this Random inRandom, IRingBuffer <T> inBuffer)
{
int i = inBuffer.Count;
int j;
while (--i > 0)
{
T old = inBuffer[i];
inBuffer[i] = inBuffer[j = inRandom.Next(i + 1)];
inBuffer[j] = old;
}
}
/// <summary>
/// Shuffles a region within the given array.
/// </summary>
static public void Shuffle <T>(this Random inRandom, IRingBuffer <T> inBuffer, int inIndex, int inLength)
{
int i = Math.Min(inIndex + inLength, inBuffer.Count);
int j;
while (--i > inIndex)
{
T old = inBuffer[i];
inBuffer[i] = inBuffer[j = inRandom.Next(inIndex, i + 1)];
inBuffer[j] = old;
}
}
private static void Consume(IRingBuffer <int> buffer, ref bool shouldStop)
{
while (!shouldStop || !buffer.IsEmpty())
{
if (!buffer.IsEmpty())
{
Thread.Sleep(500);
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Consume data[{0}] on Thread [{1}]", buffer.Dequeue(), Thread.CurrentThread.Name);
Console.ResetColor();
}
}
}
public static void Parallel(IRingBuffer ringBuffer)
{
var threadPushing = new Thread(() => Pushing(ringBuffer));
var threadPopping = new Thread(() => Popping(ringBuffer));
threadPushing.Start();
threadPopping.Start();
Thread.Sleep(500);
threadPopping.Interrupt();
threadPushing.Interrupt();
}
public void SetUp()
{
NopBuffer = Substitute.For <IRingBuffer>();
ABuffer = Substitute.For <IRingBuffer>();
AbBuffer = Substitute.For <IRingBuffer>();
Registry = new ActorRegistry(new[]
{
Tuple.Create(new ActorDescriptor(new NopHandler()), NopBuffer, NoopId),
Tuple.Create(new ActorDescriptor(new AHandler()), ABuffer, AId),
Tuple.Create(new ActorDescriptor(new ABHandler()), AbBuffer, ABId)
});
}
public DriverProxy(IRingBuffer toDriverCommandBuffer)
{
if (toDriverCommandBuffer == null) throw new ArgumentNullException(nameof(toDriverCommandBuffer));
_toDriverCommandBuffer = toDriverCommandBuffer;
_publicationMessage.Wrap(_buffer, 0);
_subscriptionMessage.Wrap(_buffer, 0);
_correlatedMessage.Wrap(_keepaliveBuffer, 0);
_removeMessage.Wrap(_buffer, 0);
_clientId = toDriverCommandBuffer.NextCorrelationId();
}
private static void Popping(IRingBuffer ringBuffer)
{
Console.WriteLine($"Popping thread: {Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine("Start popping");
var stopwatch = new Stopwatch();
stopwatch.Start();
uint nbOfElementsPopped = 0;
try
{
var spleepCount = 0;
while (true)
{
if (spleepCount == 5)
{
break;
}
if (ringBuffer.Size() == 0)
{
Thread.Sleep(2);
spleepCount += 1;
continue;
}
spleepCount = 0;
var r = ringBuffer.Pop();
nbOfElementsPopped += 1;
}
}
catch (EmptyRingException e)
{
Console.WriteLine(e.Message);
}
finally
{
stopwatch.Stop();
Console.WriteLine($"Popping done in {stopwatch.ElapsedMilliseconds} milliseconds");
// Doesn't pop every elements due to push concurrency (NoConcurrency implementation), thread should write on the same slot
// Pop 3 000 000 elements as expected with write concurrency implementation
// Sometimes pop only 1 951 424 elements, correspond to 3 000 000 - 1048576 (ring size)
// Issue : Read misses one complete tour of the ring
Console.WriteLine($"Nb of element popped : {nbOfElementsPopped}");
}
}
private static void Produce(IRingBuffer <int> buffer, ref bool shouldStop)
{
Thread.Sleep(500);
int i = 0;
while (i <= 100)
{
if (!buffer.IsFull())
{
// Console.WriteLine("Produce data [{0}] Thread[{1}]", i, Thread.CurrentThread.Name);
Thread.Sleep(500);
buffer.Enqueue(i++);
}
}
shouldStop = true;
}
public DriverProxy(IRingBuffer toDriverCommandBuffer)
{
if (toDriverCommandBuffer == null)
{
throw new ArgumentNullException(nameof(toDriverCommandBuffer));
}
_toDriverCommandBuffer = toDriverCommandBuffer;
_publicationMessage.Wrap(_buffer, 0);
_subscriptionMessage.Wrap(_buffer, 0);
_correlatedMessage.Wrap(_keepaliveBuffer, 0);
_removeMessage.Wrap(_buffer, 0);
_clientId = toDriverCommandBuffer.NextCorrelationId();
}
private static bool Replay(BootstrapInfo info, IRingBuffer <TransformationItem> transformRing, JournaledMessage message)
{
if (message.Sequence <= info.SnapshotSequence)
{
return(false);
}
var next = transformRing.Next();
var claimed = transformRing[next];
claimed.AsJournaledMessage(message.Sequence,
message.SerializedBody,
message.SerializedType,
message.SerializedHeaders);
transformRing.Publish(next);
return(true);
}
private static void Pushing(IRingBuffer ringBuffer)
{
Console.WriteLine($"Pushing thread: {Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine("Start pushing");
Console.WriteLine($"Nb of elements to push: {NbOfPush}");
var stopwatch = new Stopwatch();
stopwatch.Start();
foreach (var i in Enumerable.Range(0, NbOfPush))
{
ringBuffer.Push(i);
}
stopwatch.Stop();
Console.WriteLine($"Pushing done in {stopwatch.ElapsedMilliseconds} milliseconds");
}
private void TryTakeSystemSnapshot(IRepository repository, IRingBuffer <SnapshotItem> ringBuffer, BootstrapInfo info)
{
if ((info.JournaledSequence - info.SnapshotSequence) <= this.snapshotFrequency)
{
return;
}
var items = repository.Items;
var remaining = items.Count;
foreach (var hydratable in items)
{
var next = ringBuffer.Next();
var claimed = ringBuffer[next];
claimed.AsPartOfSystemSnapshot(info.JournaledSequence, --remaining, hydratable.Key, hydratable.Memento, hydratable.MementoType);
ringBuffer.Publish(next);
}
}
public static void Parallel(IRingBuffer ringBuffer)
{
var threadPushing1 = new Thread(() => Pushing(ringBuffer, 1));
var threadPushing2 = new Thread(() => Pushing(ringBuffer, 2));
var threadPushing3 = new Thread(() => Pushing(ringBuffer, 3));
var threadPopping1 = new Thread(() => Popping(ringBuffer, 1));
var threadPopping2 = new Thread(() => Popping(ringBuffer, 2));
var threadPopping3 = new Thread(() => Popping(ringBuffer, 3));
threadPopping1.Start();
threadPopping2.Start();
threadPopping3.Start();
threadPushing1.Start();
threadPushing2.Start();
threadPushing3.Start();
Thread.Sleep(500);
}
public DriverProxy(IRingBuffer toDriverCommandBuffer, long clientId)
{
if (toDriverCommandBuffer == null)
{
throw new ArgumentNullException(nameof(toDriverCommandBuffer));
}
_toDriverCommandBuffer = toDriverCommandBuffer;
_publicationMessage.Wrap(_buffer, 0);
_subscriptionMessage.Wrap(_buffer, 0);
_correlatedMessage.Wrap(_buffer, 0);
_removeMessage.Wrap(_buffer, 0);
_destinationMessage.Wrap(_buffer, 0);
_correlatedMessage.ClientId(clientId);
}
public Runner(IRingBuffer buffer, IStructSizeCounter counter, Func <Type, int> messageIdGetter, int batchSize,
params IActor[] actors)
{
Buffer = buffer;
_batchSize = batchSize;
if (actors.Length > 1)
{
var actor = new CompositeActor(actors, counter, messageIdGetter);
_batchAware = actor;
_handler = actor.MessageHandler;
Descriptor = actor.Descriptor;
}
else
{
_handler = new MessageReader(actors[0], counter, messageIdGetter).MessageHandlerImpl;
Descriptor = new ActorDescriptor(actors[0]);
_batchAware = actors[0] as IBatchAware;
}
}
public Runner(IRingBuffer buffer, IStructSizeCounter counter, Func<Type, int> messageIdGetter, int batchSize,
params IActor[] actors)
{
Buffer = buffer;
_batchSize = batchSize;
if (actors.Length > 1)
{
var actor = new CompositeActor(actors, counter, messageIdGetter);
_batchAware = actor;
_handler = actor.MessageHandler;
Descriptor = actor.Descriptor;
}
else
{
_handler = new MessageReader(actors[0], counter, messageIdGetter).MessageHandlerImpl;
Descriptor = new ActorDescriptor(actors[0]);
_batchAware = actors[0] as IBatchAware;
}
}
private static void Popping(IRingBuffer ringBuffer)
{
Console.WriteLine($"Popping thread: {Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine("Start popping");
var stopwatch = new Stopwatch();
stopwatch.Start();
uint nbOfElementsPopped = 0;
try
{
var spleepCount = 0;
while (true)
{
if (spleepCount == 5)
{
break;
}
if (ringBuffer.Size() == 0)
{
Thread.Sleep(2);
spleepCount += 1;
continue;
}
spleepCount = 0;
var r = ringBuffer.Pop();
nbOfElementsPopped += 1;
}
}
catch (EmptyRingException e)
{
Console.WriteLine(e.Message);
}
finally
{
stopwatch.Stop();
Console.WriteLine($"Popping done in {stopwatch.ElapsedMilliseconds} milliseconds");
Console.WriteLine($"Nb of element popped : {nbOfElementsPopped}");
}
}
public long WaitFor(IConsumer[] consumers, IRingBuffer <T> ringBuffer, IConsumerBarrier <T> barrier,
long sequence, long timeout)
{
long availableSequence;
if ((availableSequence = ringBuffer.Cursor) < sequence)
{
lock (_lock)
{
try
{
while ((availableSequence = ringBuffer.Cursor) < sequence)
{
if (barrier.IsAlerted())
{
throw AlertException.ALERT_EXCEPTION;
}
if (!_waithandle.WaitOne((int)timeout))
{
break;
}
}
}
catch
{
}
}
}
if (0 != consumers.Length)
{
while ((availableSequence = Util.GetMinimumSequence(consumers)) < sequence)
{
if (barrier.IsAlerted())
{
throw AlertException.ALERT_EXCEPTION;
}
}
}
return(availableSequence);
}
public long WaitFor(IConsumer[] consumers, IRingBuffer <T> ringBuffer, IConsumerBarrier <T> barrier,
long sequence, long timeout)
{
long currentTime = _timer.ElapsedMilliseconds;
long cutoff = currentTime + timeout;
long availableSequence;
if (0 == consumers.Length)
{
while ((availableSequence = ringBuffer.Cursor) < sequence)
{
if (barrier.IsAlerted())
{
throw AlertException.ALERT_EXCEPTION;
}
ThreadYield();
if (_timer.ElapsedMilliseconds > cutoff)
{
break;
}
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(consumers)) < sequence)
{
if (barrier.IsAlerted())
{
throw AlertException.ALERT_EXCEPTION;
}
ThreadYield();
if (_timer.ElapsedMilliseconds > cutoff)
{
break;
}
}
}
return(availableSequence);
}
public MessageListener(Func <IMessageReceiver> receiverFactory, IRingBuffer <TransformationItem> ring, DuplicateStore duplicates)
{
if (receiverFactory == null)
{
throw new ArgumentNullException("receiverFactory");
}
if (ring == null)
{
throw new ArgumentNullException("ring");
}
if (duplicates == null)
{
throw new ArgumentNullException("duplicates");
}
this.receiverFactory = receiverFactory;
this.ring = ring;
this.duplicates = duplicates;
}
private void Write <TMessage>(ref TMessage msg, Envelope envelope, IRingBuffer buffer)
where TMessage : struct
{
var successful = _writer.Write(ref envelope, ref msg, buffer);
if (successful == false)
{
var wait = new SpinWait();
var counter = 1;
do
{
if (counter >= _throwAfterNTrials)
{
throw new Exception("Cannot proceed with a write");
}
counter += 1;
wait.SpinOnce();
successful = _writer.Write(ref envelope, ref msg, buffer);
} while (successful == false);
}
}
public Transformer(IRepository repository, IRingBuffer <SnapshotItem> ring, ITimeoutWatcher watcher)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (ring == null)
{
throw new ArgumentNullException("ring");
}
if (watcher == null)
{
throw new ArgumentNullException("watcher");
}
this.repository = repository;
this.ring = ring;
this.watcher = watcher;
}
/// <summary>
/// This is called automatically by <seealso cref="Connect()"/> and its overloads.
/// There is no need to call it from a client application. It is responsible for providing default
/// values for options that are not individually changed through field setters.
/// </summary>
/// <returns> this Aeron.Context for method chaining. </returns>
public Context Conclude()
{
try
{
_cncFile = new FileInfo(Path.Combine(_aeronDirectoryName, CncFileDescriptor.CNC_FILE));
if (_epochClock == null)
{
_epochClock = new SystemEpochClock();
}
if (_nanoClock == null)
{
_nanoClock = new SystemNanoClock();
}
if (_idleStrategy == null)
{
_idleStrategy = new SleepingIdleStrategy(IdleSleepMs);
}
if (CncFile() != null)
{
_cncByteBuffer = IoUtil.MapExistingFile(CncFile().FullName);
_cncMetaDataBuffer = CncFileDescriptor.CreateMetaDataBuffer(_cncByteBuffer);
var cncVersion = _cncMetaDataBuffer.GetInt(CncFileDescriptor.CncVersionOffset(0));
if (CncFileDescriptor.CNC_VERSION != cncVersion)
{
throw new InvalidOperationException(
"aeron cnc file version not understood: version=" + cncVersion);
}
}
if (_toClientBuffer == null)
{
var receiver =
new BroadcastReceiver(CncFileDescriptor.CreateToClientsBuffer(_cncByteBuffer,
_cncMetaDataBuffer));
_toClientBuffer = new CopyBroadcastReceiver(receiver);
}
if (_toDriverBuffer == null)
{
_toDriverBuffer =
new ManyToOneRingBuffer(CncFileDescriptor.CreateToDriverBuffer(_cncByteBuffer,
_cncMetaDataBuffer));
}
if (CountersMetaDataBuffer() == null)
{
CountersMetaDataBuffer(CncFileDescriptor.CreateCountersMetaDataBuffer(_cncByteBuffer,
_cncMetaDataBuffer));
}
if (CountersValuesBuffer() == null)
{
CountersValuesBuffer(CncFileDescriptor.CreateCountersValuesBuffer(_cncByteBuffer,
_cncMetaDataBuffer));
}
_interServiceTimeout = CncFileDescriptor.ClientLivenessTimeout(_cncMetaDataBuffer);
if (_logBuffersFactory == null)
{
_logBuffersFactory = new MappedLogBuffersFactory();
}
if (_errorHandler == null)
{
_errorHandler = DEFAULT_ERROR_HANDLER;
}
if (_availableImageHandler == null)
{
_availableImageHandler = image => { };
}
if (_unavailableImageHandler == null)
{
_unavailableImageHandler = image => { };
}
}
catch (
Exception ex)
{
Console.WriteLine("***");
Console.WriteLine("***");
Console.WriteLine("Failed to connect to the Media Driver - is it currently running?");
Console.WriteLine("***");
Console.WriteLine("***");
throw new InvalidOperationException("Could not initialise communication buffers", ex);
}
return this;
}
/// <summary>
/// This method is used for testing and debugging.
/// </summary>
/// <param name="toDriverBuffer"> Injected RingBuffer. </param>
/// <returns> this Aeron.Context for method chaining. </returns>
public Context ToDriverBuffer(IRingBuffer toDriverBuffer)
{
_toDriverBuffer = toDriverBuffer;
return this;
}
//* Construct a {@link IConsumer} that simply tracks a {@link RingBuffer}.
public NoOpConsumer(IRingBuffer ringBuffer)
{
_ringBuffer = ringBuffer;
}
public Pipeline3StepLatencyPerfTest()
{
InitHistogram();
InitStopwatchTimeCostNs();
ringBuffer =
new RingBuffer<ValueEntry>(new ValueEntryFactory(), SIZE,
new SingleThreadedStrategy(),
new BusySpinStrategy<ValueEntry>());
stepOneConsumerBarrier = ringBuffer.CreateConsumerBarrier();
stepOneFunctionHandler = new LatencyStepHandler(FunctionStep.ONE, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepOneBatchConsumer = new BatchConsumer<ValueEntry>(stepOneConsumerBarrier, stepOneFunctionHandler);
stepTwoConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepOneBatchConsumer);
stepTwoFunctionHandler = new LatencyStepHandler(FunctionStep.TWO, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepTwoBatchConsumer = new BatchConsumer<ValueEntry>(stepTwoConsumerBarrier, stepTwoFunctionHandler);
stepThreeConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepTwoBatchConsumer);
stepThreeFunctionHandler = new LatencyStepHandler(FunctionStep.THREE, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepThreeBatchConsumer = new BatchConsumer<ValueEntry>(stepThreeConsumerBarrier, stepThreeFunctionHandler);
producerBarrier = ringBuffer.CreateProducerBarrier(stepThreeBatchConsumer);
stepOneQueue = new BlockingCollection<long>(SIZE);
stepTwoQueue = new BlockingCollection<long>(SIZE);
stepThreeQueue = new BlockingCollection<long>(SIZE);
stepOneQueueConsumer = new LatencyStepQueueConsumer(
FunctionStep.ONE, stepOneQueue, stepTwoQueue, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepTwoQueueConsumer = new LatencyStepQueueConsumer(
FunctionStep.TWO, stepTwoQueue, stepThreeQueue, _histogram, _stopwatchTimeCostNs, _stopwatch);
stepThreeQueueConsumer = new LatencyStepQueueConsumer(
FunctionStep.THREE, stepThreeQueue, null, _histogram, _stopwatchTimeCostNs, _stopwatch);
}
public void WaitForCursor(long sequence, IRingBuffer ringBuffer)
{
// no op for this class
}
