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 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 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 setUp()
{
ringBuffer = new RingBuffer <StubEntry>(new StubFactory(), 20, new SingleThreadedStrategy(),
new BusySpinStrategy <StubEntry>());
consumerBarrier = ringBuffer.CreateConsumerBarrier();
producerBarrier = ringBuffer.CreateProducerBarrier(new NoOpConsumer(ringBuffer));
}
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));
}
///<summary>
/// Create a producer barrier. The barrier is set up to prevent overwriting any entry that is yet to
/// be processed by a consumer that has already been set up. As such, producer barriers should be
/// created as the last step, after all handlers have been set up.
///</summary>
///<returns>the producer barrier.</returns>
public IProducerBarrier <T> CreateProducerBarrier()
{
if (_producerBarrier == null)
{
var lastConsumersInChain = _consumerRepository.LastConsumersInChain;
var period = _entries.Length / 2;
foreach (var batchConsumer in lastConsumersInChain)
{
batchConsumer.DelaySequenceWrite(period);
}
_producerBarrier = new ProducerBarrier(this, lastConsumersInChain);
}
return(_producerBarrier);
}
internal void SetUp(Int32 size, Func <ISequencingBufferEntry <TValue> > messageStoreEntryFactory)
{
_ringBuffer = new RingBuffer <ISequencingBufferEntry <TValue> >(
messageStoreEntryFactory,
size,
ClaimStrategyFactory.ClaimStrategyOption.Multithreaded,
WaitStrategyFactory.WaitStrategyOption.Yielding);
SequentialMessageDispatch <ISequencingBufferEntry <TValue> > sequentialDispatch =
new SequentialMessageDispatch <ISequencingBufferEntry <TValue> >(
(ISequencingBufferEntry <TValue> entry) =>
{
NewEntryAdded(entry);
});
_ringBuffer.ConsumeWith(sequentialDispatch);
_producerBarrier = _ringBuffer.CreateProducerBarrier();
_ringBuffer.StartConsumers();
}
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);
}
