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