C# RingBuffer.NewBarrier方法代码示例

 public OneToOneSequencedLongArrayThroughputTest()
 {
     _ringBuffer = RingBuffer<long[]>.CreateSingleProducer(() => new long[_arraySize], _bufferSize, new YieldingWaitStrategy());
     var sequenceBarrier = _ringBuffer.NewBarrier();
     _handler = new LongArrayEventHandler();
     _batchEventProcessor = new BatchEventProcessor<long[]>(_ringBuffer, sequenceBarrier, _handler);
     _ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
 }

 public OneToOneSequencedBatchThroughputTest()
 {
     _ringBuffer = RingBuffer<ValueEvent>.CreateSingleProducer(ValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
     var sequenceBarrier = _ringBuffer.NewBarrier();
     _handler = new ValueAdditionEventHandler();
     _batchEventProcessor = new BatchEventProcessor<ValueEvent>(_ringBuffer, sequenceBarrier, _handler);
     _ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
 }

 public void Setup()
 {
     _ringBuffer = new RingBuffer<StubEvent>(()=>new StubEvent(-1), 16);
     _sequenceBarrier = _ringBuffer.NewBarrier();
     _batchHandlerMock = new Mock<IEventHandler<StubEvent>>();
     _countDownEvent = new CountdownEvent(1);
     _batchEventProcessor = new BatchEventProcessor<StubEvent>(_ringBuffer, _sequenceBarrier, _batchHandlerMock.Object);
     _ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
 }

        public OneToThreeSequencedThroughputTest()
        {
            for (long i = 0; i < _iterations; i++)
            {
                _results[0] = Operation.Addition.Op(_results[0], i);
                _results[1] = Operation.Subtraction.Op(_results[1], i);
                _results[2] = Operation.And.Op(_results[2], i);
            }

            _ringBuffer = RingBuffer<ValueEvent>.CreateSingleProducer(ValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
            var sequenceBarrier = _ringBuffer.NewBarrier();

            _handlers[0] = new ValueMutationEventHandler(Operation.Addition);
            _handlers[1] = new ValueMutationEventHandler(Operation.Subtraction);
            _handlers[2] = new ValueMutationEventHandler(Operation.And);

            for (var i = 0; i < _numEventProcessors; i++)
            {
                _batchEventProcessors[i] = new BatchEventProcessor<ValueEvent>(_ringBuffer, sequenceBarrier, _handlers[i]);
            }
            _ringBuffer.AddGatingSequences(_batchEventProcessors.Select(x => x.Sequence).ToArray());
        }

 public void Run()
 {
     _ring = new RingBuffer<ValueEvent>(() => new ValueEvent(), new MultiThreadedClaimStrategy(2048), new YieldingWaitStrategy());
     _sequenceBarrier = _ring.NewBarrier();
     _sequence = new Sequence(Sequencer.InitialCursorValue);
     _ring.SetGatingSequences(_sequence);
     var manager = new EventStoreManager();
     //manager.CompressionStrategy = new NoCompressionStrategy();
     using (var stream = new FileStream("0.event", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 1))
     {
         var file = new StreamEventFileStorage(stream);
         _writeStore = manager.AppendToStore(file);
         var consumerTask = Task.Factory.StartNew(EventConsumer,
                                                  TaskCreationOptions.LongRunning |
                                                  TaskCreationOptions.HideScheduler);
         _sw.Start();
         var tasks = new Task[ParallelTasks];
         Parallel.For(0, tasks.Length, i =>
             {
                 tasks[i] = PublishSampleEvents(RepetitionCount);
             });
         Task.WaitAll(tasks);
         _sequenceBarrier.Alert();
         consumerTask.Wait();
         _sw.Stop();
         Console.WriteLine("Write {0}ms events per second:{1:f0} total len:{2}", _sw.ElapsedMilliseconds,
                           tasks.Length * RepetitionCount / _sw.Elapsed.TotalSeconds, stream.Length);
         _sw.Restart();
         var allObserverCounter = new AllObserverCounter();
         manager.OpenReadOnlyStore(file).ReadFromStartToEnd(allObserverCounter);
         _sw.Stop();
         Console.WriteLine("Read {0}ms events per second:{1:f0} events:{2}", _sw.ElapsedMilliseconds,
                           allObserverCounter.Count / _sw.Elapsed.TotalSeconds, allObserverCounter.Count);
     }
 }

        public OnePublisherToThreeProcessorDiamondThroughputTest()
            : base(TestName, 1000L * 1000L * 100L)
        {
            ringBuffer = RingBuffer<FizzBuzzEvent>.CreateSingleProducer(() => new FizzBuzzEvent(), 1024 * 8, new YieldingWaitStrategy());
            sequenceBarrier = ringBuffer.NewBarrier();

            batchProcessorFizz = new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrier, fizzHandler);

            batchProcessorBuzz = new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrier, buzzHandler);
            sequenceBarrierFizzBuzz = ringBuffer.NewBarrier(batchProcessorFizz.Sequence, batchProcessorBuzz.Sequence);

            batchProcessorFizzBuzz = new BatchEventProcessor<FizzBuzzEvent>(ringBuffer, sequenceBarrierFizzBuzz, fizzBuzzHandler);
            ringBuffer.AddGatingSequences(batchProcessorFizzBuzz.Sequence);

        }

        public void ShouldPreventProducersOvertakingEventProcessorsWrapPoint()
        {
            const int ringBufferSize = 4;
            var mre = new ManualResetEvent(false);
            var producerComplete = false;
            var ringBuffer = new RingBuffer<StubEvent>(() => new StubEvent(-1), ringBufferSize);
            var processor = new TestEventProcessor(ringBuffer.NewBarrier());
            ringBuffer.SetGatingSequences(processor.Sequence);

            var thread = new Thread(
                () =>
                    {
                        for (int i = 0; i <= ringBufferSize; i++) // produce 5 events
                        {
                            var sequence = ringBuffer.Next();
                            StubEvent evt = ringBuffer[sequence];
                            evt.Value = i;
                            ringBuffer.Publish(sequence);

                            if (i == 3) // unblock main thread after 4th event published
                            {
                                mre.Set();
                            }
                        }

                        producerComplete = true;
                    });

            thread.Start();

            mre.WaitOne();
            Assert.AreEqual(ringBufferSize - 1, ringBuffer.Cursor);
            Assert.IsFalse(producerComplete);

            processor.Run();
            thread.Join();

            Assert.IsTrue(producerComplete);
        }

 public void SetUp()
 {
     _ringBuffer = new RingBuffer<StubEvent>(() => new StubEvent(-1), 32);
     _sequenceBarrier = _ringBuffer.NewBarrier();
     _ringBuffer.SetGatingSequences(new NoOpEventProcessor(_ringBuffer).Sequence);
 }