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 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();
}
internal void CopyToStoreEntry(TValue value)
{
ISequencingBufferEntry <TValue> storeEntry;
var sequence = _producerBarrier.NextEntry(out storeEntry);
storeEntry.CopyFrom(value);
_producerBarrier.Commit(sequence);
}
public void ShouldClaimAndGet()
{
Assert.AreEqual(-1L, ringBuffer.Cursor);
var expectedEntry = new StubEntry(2701);
StubEntry oldEntry = producerBarrier.NextEntry();
oldEntry.copy(expectedEntry);
producerBarrier.Commit(oldEntry);
long sequence = consumerBarrier.WaitFor(0);
Assert.AreEqual(0, sequence);
StubEntry entry = ringBuffer.GetEntry(sequence);
Assert.AreEqual(expectedEntry, entry);
Assert.AreEqual(0L, ringBuffer.Cursor);
}
public void ShouldCallMethodsInLifecycleOrder()
{
using (_mocks.Ordered())
{
Expect.Call(() => batchHandler.OnAvailable(ringBuffer.GetEntry(0)));
Expect.Call(() => batchHandler.OnEndOfBatch()).WhenCalled(m => _latch.Set());
Expect.Call(() => batchHandler.OnCompletion());
}
_mocks.ReplayAll();
Thread thread = new Thread(batchConsumer.Run);
thread.Start();
Assert.AreEqual(-1L, batchConsumer.Sequence);
producerBarrier.Commit(producerBarrier.NextEntry());
Assert.IsTrue(_latch.WaitOne(TimeSpan.FromSeconds(1)));
batchConsumer.Halt();
thread.Join();
_mocks.VerifyAll();
}
protected override double RunDisruptorPass(int passNumber)
{
stepThreeFunctionHandler.reset();
Task.Factory.StartNew(stepOneBatchConsumer.Run);
Task.Factory.StartNew(stepTwoBatchConsumer.Run);
Task.Factory.StartNew(stepThreeBatchConsumer.Run);
var stopwatch = new Stopwatch();
stopwatch.Start();
long operandTwo = OPERAND_TWO_INITIAL_VALUE;
for (long i = 0; i < ITERATIONS; i++)
{
FunctionEntry entry = producerBarrier.NextEntry();
entry.OperandOne = i;
entry.OperandTwo = operandTwo--;
producerBarrier.Commit(entry);
}
long expectedSequence = ringBuffer.Cursor;
while (stepThreeBatchConsumer.Sequence < expectedSequence)
{
// busy spin
}
stopwatch.Stop();
double opsPerSecond = ITERATIONS / stopwatch.Elapsed.TotalSeconds;
stepOneBatchConsumer.Halt();
stepTwoBatchConsumer.Halt();
stepThreeBatchConsumer.Halt();
Assert.AreEqual(expectedResult, stepThreeFunctionHandler.getStepThreeCounter());
return(opsPerSecond);
}
private void RunDisruptorPass()
{
var thread1 = new Thread(stepOneBatchConsumer.Run);
var thread2 = new Thread(stepTwoBatchConsumer.Run);
var thread3 = new Thread(stepThreeBatchConsumer.Run);
thread1.Start();
thread2.Start();
thread3.Start();
for (long i = 0; i < ITERATIONS; i++)
{
ValueEntry entry = producerBarrier.NextEntry();
entry.Value = _stopwatch.GetElapsedNanoSeconds();
producerBarrier.Commit(entry);
long pauseStart = _stopwatch.GetElapsedNanoSeconds();
while (PAUSE_NANOS > (_stopwatch.GetElapsedNanoSeconds() - pauseStart))
{
//Busy Spin
}
}
long expectedSequence = ringBuffer.Cursor;
while (stepThreeBatchConsumer.Sequence < expectedSequence)
{
//Busy Spin
}
stepOneBatchConsumer.Halt();
stepTwoBatchConsumer.Halt();
stepThreeBatchConsumer.Halt();
thread3.Join();
thread2.Join();
thread1.Join();
}
