public override long RunPass()
        {
            _disruptor.start();

            const int batchSize = 10;
            var batchDescriptor = _ringBuffer.NewBatchDescriptor(batchSize);

            var sw = Stopwatch.StartNew();

            Task.Factory.StartNew(
                () =>
                    {
                        long offset = 0;
                        for (long i = 0; i < Iterations; i += batchSize)
                        {
                            _ringBuffer.next(batchDescriptor);
                            for (long sequence = batchDescriptor.Start; sequence <= batchDescriptor.End; sequence++)
                            {
                                _ringBuffer[sequence].Value = offset++;
                            }
                            _ringBuffer.publish(batchDescriptor);
                        }
                    }, CancellationToken.None, TaskCreationOptions.None, _scheduler);

            _mru.WaitOne();

            long opsPerSecond = (Iterations * 1000L) / sw.ElapsedMilliseconds;
            _disruptor.Shutdown();
            _scheduler.Dispose();

            Assert.AreEqual(ExpectedResult, _eventHandler.Value);

            return opsPerSecond;
        }
        public override long RunPass()
        {
            _disruptor.start();

            const int batchSize       = 10;
            var       batchDescriptor = _ringBuffer.newBatchDescriptor(batchSize);

            var sw = Stopwatch.StartNew();

            long offset = 0;

            for (long i = 0; i < Iterations; i += batchSize)
            {
                _ringBuffer.next(batchDescriptor);
                for (long sequence = batchDescriptor.Start; sequence <= batchDescriptor.End; sequence++)
                {
                    _ringBuffer[sequence].Value = offset++;
                }
                _ringBuffer.publish(batchDescriptor);
            }

            _mru.WaitOne();

            long opsPerSecond = (Iterations * 1000L) / sw.ElapsedMilliseconds;

            _disruptor.Shutdown();

            Assert.AreEqual(ExpectedResult, _eventHandler.Value);

            return(opsPerSecond);
        }
Beispiel #3
0
        public void shouldPreventPublishersOvertakingEventProcessorWrapPoint()
        {
            int ringBufferSize = 4;
            CountDownLatch latch = new CountDownLatch(ringBufferSize);
            AtomicBoolean publisherComplete = new AtomicBoolean(false);
            RingBuffer<StubEvent> ringBuffer = new RingBuffer<StubEvent>(StubEvent.EVENT_FACTORY, ringBufferSize);
            TestEventProcessor processor = new TestEventProcessor(ringBuffer.newBarrier());
            ringBuffer.setGatingSequences(processor.getSequence());

            Thread thread = new Thread(() =>
            {
                {
                    for (int i = 0; i <= ringBufferSize; i++)
                    {
                        long sequence = ringBuffer.next();
                        StubEvent @event = ringBuffer.get(sequence);
                        @event.setValue(i);
                        ringBuffer.publish(sequence);
                        latch.countDown();
                    }

                    publisherComplete.set(true);
                }
            });

            thread.Start();

            latch.await();
            assertEquals(ringBuffer.getCursor(), ringBufferSize - 1);
            Assert.IsFalse(publisherComplete.get());

            processor.run();
            thread.Join();

            Assert.IsTrue(publisherComplete.get());
        }