public void ShouldReportProgressByUpdatingSequenceViaCallback()
{
IRingBuffer <StubEntry> ringBuffer = new RingBuffer <StubEntry>(new StubFactory(), 16);
IConsumerBarrier <StubEntry> consumerBarrier = ringBuffer.CreateConsumerBarrier();
ISequenceTrackingHandler <StubEntry> handler = new TestSequenceTrackingHandler();
var batchConsumer = new BatchConsumer <StubEntry>(consumerBarrier, handler);
IProducerBarrier <StubEntry> producerBarrier = ringBuffer.CreateProducerBarrier(batchConsumer);
var thread = new Thread(batchConsumer.Run);
thread.Start();
Assert.AreEqual(-1L, batchConsumer.Sequence);
producerBarrier.Commit(producerBarrier.NextEntry());
producerBarrier.Commit(producerBarrier.NextEntry());
Assert.IsTrue(onAvailableLatch.WaitOne(1000));
Assert.AreEqual(-1L, batchConsumer.Sequence);
producerBarrier.Commit(producerBarrier.NextEntry());
Assert.IsTrue(readyToCallbackLatch.WaitOne(1000));
Assert.AreEqual(2L, batchConsumer.Sequence);
batchConsumer.Halt();
thread.Join();
}
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 ShouldWaitForWorkCompleteWhereAllWorkersAreBlockedOnRingBuffer()
{
long expectedNumberMessages = 10;
fillRingBuffer(expectedNumberMessages);
var workers = new StubConsumer[3];
for (int i = 0, size = workers.Length; i < size; i++)
{
workers[i] = new StubConsumer(0);
workers[i].Sequence = (expectedNumberMessages - 1);
}
IConsumerBarrier consumerBarrier = ringBuffer.CreateConsumerBarrier(workers);
ThreadStart runnable = () =>
{
StubEntry entry = producerBarrier.NextEntry();
entry.Value = ((int)entry.Sequence);
producerBarrier.Commit(entry);
foreach (StubConsumer stubWorker in workers)
{
stubWorker.Sequence = (entry.Sequence);
}
};
new Thread(runnable).Start();
long expectedWorkSequence = expectedNumberMessages;
long completedWorkSequence = consumerBarrier.WaitFor(expectedNumberMessages);
Assert.IsTrue(completedWorkSequence >= expectedWorkSequence);
}
public void setUp()
{
ringBuffer = new RingBuffer <StubEntry>(new StubFactory(), 20, new SingleThreadedStrategy(),
new BusySpinStrategy <StubEntry>());
consumerBarrier = ringBuffer.CreateConsumerBarrier();
producerBarrier = ringBuffer.CreateProducerBarrier(new NoOpConsumer(ringBuffer));
}
public BatchConsumer(IConsumerBarrier <T> consumerBarrier,
IBatchHandler <T> handler)
{
_consumerBarrier = consumerBarrier;
_handler = handler;
_noSequenceTracker = 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 void setUp()
{
ringBuffer = new RingBuffer<StubEntry>(new StubFactory(), 20, new SingleThreadedStrategy(),
new BusySpinStrategy<StubEntry>());
consumerBarrier = ringBuffer.CreateConsumerBarrier();
producerBarrier = ringBuffer.CreateProducerBarrier(new NoOpConsumer(ringBuffer));
}
public void ShouldWaitForWorkCompleteWhereCompleteWorkThresholdIsBehind()
{
long expectedNumberMessages = 10;
fillRingBuffer(expectedNumberMessages);
var entryConsumers = new StubConsumer[3];
for (int i = 0, size = entryConsumers.Length; i < size; i++)
{
entryConsumers[i] = new StubConsumer(0);
entryConsumers[i].Sequence = (expectedNumberMessages - 2);
}
IConsumerBarrier consumerBarrier = ringBuffer.CreateConsumerBarrier(entryConsumers);
ThreadStart runnable = () =>
{
foreach (StubConsumer stubWorker in entryConsumers)
{
stubWorker.Sequence += 1;
}
};
new Thread(runnable).Start();
long expectedWorkSequence = expectedNumberMessages - 1;
long completedWorkSequence = consumerBarrier.WaitFor(expectedWorkSequence);
Assert.IsTrue(completedWorkSequence >= expectedWorkSequence);
}
public void Test1()
{
var testBuffer = new RingBuffer <TestClass>(new TestClassFactory(), 1000, new SingleThreadedStrategy(),
new BusySpinStrategy <TestClass>());
IConsumerBarrier <TestClass> consumerBarrier = testBuffer.CreateConsumerBarrier();
var batchConsumer = new BatchConsumer <TestClass>(consumerBarrier, new TestBatchHandler <TestClass>());
IProducerBarrier <TestClass> producerBarrier = testBuffer.CreateProducerBarrier(batchConsumer);
var thread = new Thread(batchConsumer.Run);
thread.Start();
for (int i = 0; i < 1000; i++)
{
TestClass test = producerBarrier.NextEntry();
test.Value = i;
test.Stuff = "FirstTest" + i;
producerBarrier.Commit(test);
}
Thread.Sleep(100);
batchConsumer.Halt();
thread.Join();
}
public BatchConsumer(IConsumerBarrier <T> consumerBarrier,
ISequenceTrackingHandler <T> entryHandler)
{
_consumerBarrier = consumerBarrier;
_handler = entryHandler;
_noSequenceTracker = false;
entryHandler.SetSequenceTrackerCallback(new SequenceTrackerCallback(this));
}
public TestWaiter(AutoResetEvent latch,
IConsumerBarrier <StubEntry> consumerBarrier,
long initialSequence,
long toWaitForSequence)
{
this.latch = latch;
this.initialSequence = initialSequence;
this.toWaitForSequence = toWaitForSequence;
this.consumerBarrier = consumerBarrier;
}
public void SetUp()
{
_mocks = new MockRepository();
_latch = new AutoResetEvent(false);
ringBuffer = new RingBuffer <StubEntry>(new StubFactory(), 16);
consumerBarrier = ringBuffer.CreateConsumerBarrier();
batchHandler = _mocks.DynamicMock <IBatchHandler <StubEntry> >();
batchConsumer = new BatchConsumer <StubEntry>(consumerBarrier, batchHandler);
producerBarrier = ringBuffer.CreateProducerBarrier(batchConsumer);
}
public void SetUp()
{
_mocks = new MockRepository();
_latch = new AutoResetEvent(false);
ringBuffer = new RingBuffer<StubEntry>(new StubFactory(), 16);
consumerBarrier = ringBuffer.CreateConsumerBarrier();
batchHandler = _mocks.DynamicMock<IBatchHandler<StubEntry>>();
batchConsumer = new BatchConsumer<StubEntry>(consumerBarrier, batchHandler);
producerBarrier = ringBuffer.CreateProducerBarrier(batchConsumer);
}
public void setUp()
{
_mocks = new MockRepository();
ringBuffer = new RingBuffer <StubEntry>(new StubFactory(), 64);
consumer1 = _mocks.DynamicMock <IConsumer>();
consumer2 = _mocks.DynamicMock <IConsumer>();
consumer3 = _mocks.DynamicMock <IConsumer>();
consumerBarrier = ringBuffer.CreateConsumerBarrier(consumer1, consumer2, consumer3);
producerBarrier = ringBuffer.CreateProducerBarrier(new NoOpConsumer(ringBuffer));
}
public void setUp()
{
_mocks = new MockRepository();
ringBuffer = new RingBuffer<StubEntry>(new StubFactory(), 64);
consumer1 = _mocks.DynamicMock<IConsumer>();
consumer2 = _mocks.DynamicMock<IConsumer>();
consumer3 = _mocks.DynamicMock<IConsumer>();
consumerBarrier = ringBuffer.CreateConsumerBarrier(consumer1, consumer2, consumer3);
producerBarrier = ringBuffer.CreateProducerBarrier(new NoOpConsumer(ringBuffer));
}
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 WaitForResult WaitFor <T>(IBatchConsumer[] consumers, ISequencable ringBuffer, IConsumerBarrier <T> barrier, long sequence)
{
long availableSequence;
if (0 == consumers.Length)
{
while ((availableSequence = ringBuffer.Cursor) < sequence) // volatile read
{
if (barrier.IsAlerted)
{
return(WaitForResult.AlertedResult);
}
Thread.Yield();
}
}
else
{
while ((availableSequence = consumers.GetMinimumSequence()) < sequence)
{
if (barrier.IsAlerted)
{
return(WaitForResult.AlertedResult);
}
Thread.Yield();
}
}
return(new WaitForResult(availableSequence, false));
}
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 TestWaiter(AutoResetEvent latch,
IConsumerBarrier<StubEntry> consumerBarrier,
long initialSequence,
long toWaitForSequence)
{
this.latch = latch;
this.initialSequence = initialSequence;
this.toWaitForSequence = toWaitForSequence;
this.consumerBarrier = consumerBarrier;
}
public WaitForResult WaitFor <T>(IBatchConsumer[] consumers, ISequencable ringBuffer, IConsumerBarrier <T> barrier, long sequence)
{
var availableSequence = ringBuffer.Cursor; // volatile read
if (availableSequence < sequence)
{
lock (_gate)
{
while ((availableSequence = ringBuffer.Cursor) < sequence) // volatile read
{
if (barrier.IsAlerted)
{
return(WaitForResult.AlertedResult);
}
Monitor.Wait(_gate);
}
}
}
if (0 != consumers.Length)
{
while ((availableSequence = consumers.GetMinimumSequence()) < sequence)
{
if (barrier.IsAlerted)
{
return(WaitForResult.AlertedResult);
}
}
}
return(new WaitForResult(availableSequence, false));
}
/// <summary>
/// Construct a batch consumer that will automatically track the progress by updating its sequence when
/// the <see cref="IBatchHandler{T}.OnAvailable"/> method returns.
/// </summary>
/// <param name="consumerBarrier">consumerBarrier on which it is waiting.</param>
/// <param name="handler">handler is the delegate to which <see cref="Entry{T}"/>s are dispatched.</param>
public BatchConsumer(IConsumerBarrier <T> consumerBarrier, IBatchHandler <T> handler)
{
_consumerBarrier = consumerBarrier;
_handler = handler;
}
