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(); }