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 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()
 {
     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);
		}
Beispiel #5
0
        private void InitDisruptorObjects()
        {
            ringBuffer = new RingBuffer <FunctionEntry>(new FunctionEntryFactory(), SIZE,
                                                        new SingleThreadedStrategy(),
                                                        new YieldingStrategy <FunctionEntry>());

            stepOneConsumerBarrier = ringBuffer.CreateConsumerBarrier();
            stepOneFunctionHandler = new FunctionHandler(FunctionStep.ONE);
            stepOneBatchConsumer   = new BatchConsumer <FunctionEntry>(stepOneConsumerBarrier, stepOneFunctionHandler);

            stepTwoConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepOneBatchConsumer);
            stepTwoFunctionHandler = new FunctionHandler(FunctionStep.TWO);
            stepTwoBatchConsumer   = new BatchConsumer <FunctionEntry>(stepTwoConsumerBarrier, stepTwoFunctionHandler);

            stepThreeConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepTwoBatchConsumer);
            stepThreeFunctionHandler = new FunctionHandler(FunctionStep.THREE);
            stepThreeBatchConsumer   = new BatchConsumer <FunctionEntry>(stepThreeConsumerBarrier, stepThreeFunctionHandler);

            producerBarrier = ringBuffer.CreateProducerBarrier(stepThreeBatchConsumer);
        }
        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));
		}
        private Task <List <StubEntry> > GetMessages(long initial, long toWaitFor)
        {
            var latch           = new AutoResetEvent(false);
            var consumerBarrier = ringBuffer.CreateConsumerBarrier();

            Task <List <StubEntry> > f = new Task <List <StubEntry> >(
                new TestWaiter(latch, consumerBarrier, initial, toWaitFor).Call);

            f.Start();

            Assert.IsTrue(latch.WaitOne(TimeSpan.FromSeconds(1)));

            return(f);
        }
	    private void InitDisruptorObjects()
	    {
	    	ringBuffer = new RingBuffer<FunctionEntry>(new FunctionEntryFactory(), SIZE,
	    	                                           new SingleThreadedStrategy(),
	    	                                           new YieldingStrategy<FunctionEntry>());
		
		    stepOneConsumerBarrier = ringBuffer.CreateConsumerBarrier();
		    stepOneFunctionHandler = new FunctionHandler(FunctionStep.ONE);
		    stepOneBatchConsumer = new BatchConsumer<FunctionEntry>(stepOneConsumerBarrier, stepOneFunctionHandler);
		
		    stepTwoConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepOneBatchConsumer);
		    stepTwoFunctionHandler = new FunctionHandler(FunctionStep.TWO);
		    stepTwoBatchConsumer = new BatchConsumer<FunctionEntry>(stepTwoConsumerBarrier, stepTwoFunctionHandler);
		
		    stepThreeConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepTwoBatchConsumer);
		    stepThreeFunctionHandler = new FunctionHandler(FunctionStep.THREE);
		    stepThreeBatchConsumer = new BatchConsumer<FunctionEntry>(stepThreeConsumerBarrier, stepThreeFunctionHandler);
		
		    producerBarrier = ringBuffer.CreateProducerBarrier(stepThreeBatchConsumer);	    	
	    }