public EventHandlerGroup <T> CreateEventProcessors(Sequence[] barrierSequences, IEventHandler <T>[] eventHandlers) { CheckNotStarted(); var processorSequences = new Sequence[eventHandlers.Length]; var barrier = ringBuffer.NewBarrier(barrierSequences); for (int i = 0, eventHandlersLength = eventHandlers.Length; i < eventHandlersLength; i++) { IEventHandler <T> eventHandler = eventHandlers[i]; BatchEventProcessor <T> batchEventProcessor = new BatchEventProcessor <T>(ringBuffer, barrier, eventHandler); if (exceptionHandler != null) { batchEventProcessor.SetExceptionHandler(exceptionHandler); } consumerRepository.Add(batchEventProcessor, eventHandler, barrier); processorSequences[i] = batchEventProcessor.Sequence; } if (processorSequences.Length > 0) { consumerRepository.UnMarkEventProcessorsAsEndOfChain(barrierSequences); } return(new EventHandlerGroup <T>(this, consumerRepository, processorSequences)); }
public EventHandlerGroup <T> CreateEventProcessors( ISequence[] barrierSequences, IEventHandler <T>[] eventHandlers) { CheckNotStarted(); var processorSequences = new ISequence[eventHandlers.Length]; var barrier = _ringBuffer.NewBarrier(barrierSequences); for (var i = 0; i < eventHandlers.Length; i++) { var eventHandler = eventHandlers[i]; var batchEventProcessor = new BatchEventProcessor <T>(_ringBuffer, barrier, eventHandler); if (_exceptionHandler != null) { batchEventProcessor.SetExceptionHandler(_exceptionHandler); } _consumerRepository.Add(batchEventProcessor, eventHandler, barrier); processorSequences[i] = batchEventProcessor.GetSequence(); } UpdateGatingSequencesForNextInChain(barrierSequences, processorSequences); return(new EventHandlerGroup <T>(this, _consumerRepository, processorSequences)); }
internal EventHandlerGroup <T> CreateEventProcessors(ISequence[] barrierSequences, IEventHandler <T>[] eventHandlers) { CheckNotStarted(); var processorSequences = new List <ISequence>(eventHandlers.Length); var barrier = _ringBuffer.NewBarrier(barrierSequences); foreach (var eventHandler in eventHandlers) { var batchEventProcessor = new BatchEventProcessor <T>(_ringBuffer, barrier, eventHandler); if (_exceptionHandler != null) { batchEventProcessor.SetExceptionHandler(_exceptionHandler); } _consumerRepository.Add(batchEventProcessor, eventHandler, barrier); processorSequences.Add(batchEventProcessor.Sequence); } if (processorSequences.Count > 0) { _consumerRepository.UnMarkEventProcessorsAsEndOfChain(barrierSequences); } return(new EventHandlerGroup <T>(this, _consumerRepository, processorSequences)); }
public OneToThreeDiamondSequencedThroughputTest() { var sequenceBarrier = _ringBuffer.NewBarrier(); var fizzHandler = new FizzBuzzEventHandler(FizzBuzzStep.Fizz); _batchProcessorFizz = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, fizzHandler); var buzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.Buzz); _batchProcessorBuzz = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, buzzHandler); var sequenceBarrierFizzBuzz = _ringBuffer.NewBarrier(_batchProcessorFizz.Sequence, _batchProcessorBuzz.Sequence); _fizzBuzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.FizzBuzz); _batchProcessorFizzBuzz = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrierFizzBuzz, _fizzBuzzHandler); var temp = 0L; for (long i = 0; i < _iterations; i++) { var fizz = 0 == (i % 3L); var buzz = 0 == (i % 5L); if (fizz && buzz) { ++temp; } } _expectedResult = temp; _ringBuffer.AddGatingSequences(_batchProcessorFizzBuzz.Sequence); }
public OneToThreePipelineSequencedThroughputTest() : base(Test_Disruptor, ITERATIONS, 7) { ThreadPool.SetMaxThreads(NUM_EVENT_PROCESSORS, NUM_EVENT_PROCESSORS); stepOneSequenceBarrier = ringBuffer.NewBarrier(); stepOneBatchProcessor = new BatchEventProcessor <FunctionEvent>(ringBuffer, stepOneSequenceBarrier, stepOneFunctionHandler); stepTwoSequenceBarrier = ringBuffer.NewBarrier(stepOneBatchProcessor.Sequence); stepTwoBatchProcessor = new BatchEventProcessor <FunctionEvent>(ringBuffer, stepTwoSequenceBarrier, stepTwoFunctionHandler); stepThreeSequenceBarrier = ringBuffer.NewBarrier(stepTwoBatchProcessor.Sequence); stepThreeBatchProcessor = new BatchEventProcessor <FunctionEvent>(ringBuffer, stepThreeSequenceBarrier, stepThreeFunctionHandler); ringBuffer.AddGatingSequences(stepThreeBatchProcessor.Sequence); }
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 OnePublisherToThreeProcessorPipelineThroughputTest() : base(TestName, ITERATIONS) { InitResult(); stepOneSequenceBarrier = ringBuffer.NewBarrier(); stepOneBatchProcessor = new BatchEventProcessor <FunctionEvent>(ringBuffer, stepOneSequenceBarrier, stepOneFunctionHandler); stepTwoSequenceBarrier = ringBuffer.NewBarrier(stepOneBatchProcessor.Sequence); stepTwoBatchProcessor = new BatchEventProcessor <FunctionEvent>(ringBuffer, stepTwoSequenceBarrier, stepTwoFunctionHandler); stepThreeSequenceBarrier = ringBuffer.NewBarrier(stepTwoBatchProcessor.Sequence); stepThreeBatchProcessor = new BatchEventProcessor <FunctionEvent>(ringBuffer, stepThreeSequenceBarrier, stepThreeFunctionHandler); ringBuffer.AddGatingSequences(stepThreeBatchProcessor.Sequence); }
public void ShouldReportProgressByUpdatingSequenceViaCallback() { var ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(0), 16); var sequenceBarrier = ringBuffer.NewBarrier(); var handler = new TestSequenceReportingEventHandler(_callbackLatch); var batchEventProcessor = new BatchEventProcessor <StubEvent>(ringBuffer, sequenceBarrier, handler); ringBuffer.SetGatingSequences(batchEventProcessor.Sequence); var thread = new Thread(batchEventProcessor.Run) { IsBackground = true }; thread.Start(); Assert.AreEqual(-1L, batchEventProcessor.Sequence.Value); ringBuffer.Publish(ringBuffer.Next()); _callbackLatch.WaitOne(); Assert.AreEqual(0L, batchEventProcessor.Sequence.Value); _onEndOfBatchLatch.Set(); Assert.AreEqual(0L, batchEventProcessor.Sequence.Value); batchEventProcessor.Halt(); thread.Join(); }
public RingBufferTests() { _ringBuffer = RingBuffer <StubEvent> .CreateMultiProducer(() => new StubEvent(-1), 32); _sequenceBarrier = _ringBuffer.NewBarrier(); _ringBuffer.AddGatingSequences(new NoOpEventProcessor <StubEvent>(_ringBuffer).Sequence); }
private void doRun() { BatchEventProcessor <EventHolder> batchEventProcessor = new BatchEventProcessor <EventHolder>(ringBuffer, ringBuffer.NewBarrier(), eventHolderHandler); ringBuffer.AddGatingSequences(batchEventProcessor.Sequence); Thread t = new Thread(o => (o as BatchEventProcessor <EventHolder>).Run()); t.Start(batchEventProcessor); long iterations = Constants.ITERATIONS; for (long l = 0; l < iterations; l++) { SimpleEvent e = new SimpleEvent(l, l, l, l); ringBuffer.PublishEvent(new EventTranslatorOneArg(), e); } while (batchEventProcessor.Sequence.Value != iterations - 1) { Thread.Sleep(0); } batchEventProcessor.Halt(); t.Join(); }
public long Start() { OzzyLogger <IDomainModelTracing> .Log.TraceInformationalEvent("Start event loop"); if (Interlocked.CompareExchange(ref _stage, 1, 0) == 0) { var minCheckpoint = 0L; var checkpoints = _eventProcessors.Select(e => e.GetCheckpoint()).ToList(); if (checkpoints.Any()) { minCheckpoint = checkpoints.Min(); } _disruptor = new Disruptor <DomainEventEntry>(() => new DomainEventEntry(), new MultiThreadedClaimStrategy(_bufferSize), _waitStrategy ?? new BlockingWaitStrategy(), TaskScheduler.Default, minCheckpoint); _disruptor.HandleExceptionsWith(_exceptionHandler); foreach (var domainEventsProcessor in _eventProcessors) { _disruptor.HandleEventsWith(domainEventsProcessor.GetCheckpoint(), domainEventsProcessor); } _ringBuffer = _disruptor.Start(); _barrier = _ringBuffer.NewBarrier(); StartCursorSupervisor(minCheckpoint, TimeSpan.FromMilliseconds(_pollTimeout)); Interlocked.Exchange(ref _stage, 2); return(minCheckpoint); } else { throw new InvalidOperationException("Domain Manager already started"); } }
private void StartCursorSupervisor(long startCursor, TimeSpan timeout) { var start = startCursor; var barrier = _ringBuffer.NewBarrier(); _stopSupervisor = new CancellationTokenSource(); var token = _stopSupervisor.Token; _supervisorTask = Task.Factory.StartNew(() => { while (!token.IsCancellationRequested) { var seq = barrier.WaitFor(start, timeout); if (seq >= start) { start = seq + 1; } else { try { PollData(token); } catch (Exception e) { OzzyLogger <IDomainModelTracing> .Log.PollException(e); } } } }, token, TaskCreationOptions.None, TaskScheduler.Default); }
public void ShouldCallExceptionHandlerOnTimeoutException() { var waitStrategy = new TimeoutBlockingWaitStrategy(TimeSpan.FromMilliseconds(1)); var ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), new SingleProducerSequencer(16, waitStrategy)); var sequenceBarrier = ringBuffer.NewBarrier(); var exception = new TaskCompletionSource <Exception>(); var exceptionHandler = new TestExceptionHandler <StubEvent>(x => exception.TrySetResult(x.ex)); var eventHandler = new TestBatchEventHandler <StubEvent> { OnTimeoutAction = TestException.ThrowOnce() }; var eventProcessor = CreateEventProcessor(ringBuffer, sequenceBarrier, eventHandler); ringBuffer.AddGatingSequences(eventProcessor.Sequence); eventProcessor.SetExceptionHandler(exceptionHandler); var task = eventProcessor.Start(); Assert.IsTrue(exception.Task.Wait(TimeSpan.FromSeconds(2))); Assert.AreEqual(0, exceptionHandler.EventExceptionCount); Assert.AreEqual(1, exceptionHandler.TimeoutExceptionCount); Assert.AreEqual(0, exceptionHandler.BatchExceptionCount); eventProcessor.Halt(); Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(2))); }
internal EventHandlerGroup <T> CreateEventProcessors(IEventProcessor[] barrierEventProcessors, IEventHandler <T>[] eventHandlers, long startSequence = Sequencer.InitialCursorValue) { CheckNotStarted(); var createdEventProcessors = new IEventProcessor[eventHandlers.Length]; ISequenceBarrier barrier = _ringBuffer.NewBarrier(Util.GetSequencesFor(barrierEventProcessors)); for (int i = 0; i < eventHandlers.Length; i++) { var eventHandler = eventHandlers[i]; var batchEventProcessor = new BatchEventProcessor <T>(_ringBuffer, barrier, eventHandler, startSequence); if (_exceptionHandler != null) { batchEventProcessor.SetExceptionHandler(_exceptionHandler); } _eventProcessorRepository.Add(batchEventProcessor, eventHandler, barrier); createdEventProcessors[i] = batchEventProcessor; } if (createdEventProcessors.Length > 0) { _eventProcessorRepository.UnmarkEventProcessorsAsEndOfChain(barrierEventProcessors); } return(new EventHandlerGroup <T>(this, _eventProcessorRepository, createdEventProcessors)); }
public OneToThreeSequencedThroughputTest() : base(Test_Disruptor, ITERATIONS, 7) { ThreadPool.SetMaxThreads(NUM_EVENT_PROCESSORS, NUM_EVENT_PROCESSORS); for (long i = 0; i < ITERATIONS; i++) { results[0] = Operation.Addition.Op(results[0], i); results[1] = Operation.Substraction.Op(results[1], i); results[2] = Operation.And.Op(results[2], i); } sequenceBarrier = ringBuffer.NewBarrier(); handlers[0] = new ValueMutationEventHandler_v3(Operation.Addition); handlers[1] = new ValueMutationEventHandler_v3(Operation.Substraction); handlers[2] = new ValueMutationEventHandler_v3(Operation.And); batchEventProcessors[0] = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handlers[0]); batchEventProcessors[1] = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handlers[1]); batchEventProcessors[2] = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handlers[2]); ringBuffer.AddGatingSequences( batchEventProcessors[0].Sequence, batchEventProcessors[1].Sequence, batchEventProcessors[2].Sequence); }
public Ring_Buffer_Test() { _ringBuffer = RingBuffer <StubEvent> .CreateMultiProducer(StubEvent.EventFactory, 32); _barrier = _ringBuffer.NewBarrier(); _ringBuffer.AddGatingSequences(new NoOpEventProcessor <StubEvent>(_ringBuffer).GetSequence()); }
public Batch_Event_Processor_Test(ObjectContainerFixture provider) { _ringBuffer = RingBuffer <StubEvent> .CreateMultiProducer(StubEvent.EventFactory, 16); _barrier = _ringBuffer.NewBarrier(); _exceptionHandler = provider.Services.GetService <IExceptionHandler <StubEvent> >(); }
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 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 BatchEventProcessorBenchmarks() { _ringBuffer = new RingBuffer <TestEvent>(() => new TestEvent(), new SingleProducerSequencer(4096, new SpinWaitWaitStrategy())); _eventHandler = new TestEventHandler(); _sequenceBarrier = _ringBuffer.NewBarrier(); _ringBuffer.PublishEvent().Dispose(); }
public OneToOneSequencedBatchThroughputTest() : base(Test_Disruptor, ITERATIONS, 7) { ThreadPool.SetMaxThreads(4, 4); sequenceBarrier = ringBuffer.NewBarrier(); batchEventProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, handler); ringBuffer.AddGatingSequences(batchEventProcessor.Sequence); }
public OnePublisherToOneProcessorUniCastThroughputTest() : base("Disruptor", ITERATIONS) { sequenceBarrier = ringBuffer.NewBarrier(); batchEventProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, sequenceBarrier, disruptorHandler); ringBuffer.AddGatingSequences(batchEventProcessor.Sequence); //queueHandler = new ValueAdditionQueueProcessor_V3(blockQueue, ITERATIONS - 1); }
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 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 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 BatchEventProcessorBenchmarks() { _ringBuffer = new RingBuffer <TestEvent>(() => new TestEvent(), new SingleProducerSequencer(4096, new SpinWaitWaitStrategy())); _eventHandler = new TestEventHandler(); _processor = BatchEventProcessorFactory.Create(_ringBuffer, _ringBuffer.NewBarrier(), _eventHandler); _eventHandler.Processor = _processor; _eventHandler.RingBuffer = _ringBuffer; _ringBuffer.AddGatingSequences(_processor.Sequence); }
public ThrottledOnePublisherToThreeProcessorPipelineLatencyTest() //: base(TestName, ITERATIONS) { InitHistogram(); stepOneSequenceBarrier = ringBuffer.NewBarrier(); stepOneFunctionHandler = new LatencyStepEventHandler_V3(FunctionStep.One, _histogram, TicksToNanos); stepOneBatchProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, stepOneSequenceBarrier, stepOneFunctionHandler); stepTwoSequenceBarrier = ringBuffer.NewBarrier(stepOneBatchProcessor.Sequence); stepTwoFunctionHandler = new LatencyStepEventHandler_V3(FunctionStep.Two, _histogram, TicksToNanos); stepTwoBatchProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, stepTwoSequenceBarrier, stepTwoFunctionHandler); stepThreeSequenceBarrier = ringBuffer.NewBarrier(stepTwoBatchProcessor.Sequence); stepThreeFunctionHandler = new LatencyStepEventHandler_V3(FunctionStep.Three, _histogram, TicksToNanos); stepThreeBatchProcessor = new BatchEventProcessor <ValueEvent>(ringBuffer, stepThreeSequenceBarrier, stepThreeFunctionHandler); ringBuffer.AddGatingSequences(stepThreeBatchProcessor.Sequence); }
public OneToOneSequencedThroughputTest_BatchPublisher_BatchHandler() { _ringBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new YieldingWaitStrategy()); var sequenceBarrier = _ringBuffer.NewBarrier(); _handler = new AdditionBatchEventHandler(); _eventProcessor = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler); _ringBuffer.AddGatingSequences(_eventProcessor.Sequence); }
public ThreeToOneSequencedThroughputTest() { _sequenceBarrier = _ringBuffer.NewBarrier(); _batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, _sequenceBarrier, _handler); for (var i = 0; i < _numPublishers; i++) { _valuePublishers[i] = ValuePublisher; } _ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence); }
public OneToOneSequencedLongArrayThroughputTest() { _ringBuffer = RingBuffer <long[]> .CreateSingleProducer(() => new long[_arraySize], _bufferSize, new YieldingWaitStrategy()); var sequenceBarrier = _ringBuffer.NewBarrier(); _handler = new LongArrayEventHandler(); _batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler); _ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence); }
public Lifecycle_Aware_Test() { _startLatch = new CountdownEvent(1); _shutdownLatch = new CountdownEvent(1); _ringBuffer = RingBuffer <StubEvent> .CreateMultiProducer(() => new StubEvent(-1), 16); _barrier = _ringBuffer.NewBarrier(); _handler = new LifecycleAwareEventHandler(_startLatch, _shutdownLatch); _processor = new BatchEventProcessor <StubEvent>(_ringBuffer, _barrier, _handler); }
private Task <List <StubEvent> > GetMessages(long initial, long toWaitFor) { var barrier = new Barrier(2); var dependencyBarrier = _ringBuffer.NewBarrier(); var f = Task.Factory.StartNew(() => new TestWaiter(barrier, dependencyBarrier, _ringBuffer, initial, toWaitFor).Call()); barrier.SignalAndWait(); return(f); }
public OneToOneSequencedThroughputTest() { _latch = new ManualResetEvent(false); _eventHandler = new AdditionEventHandler(); _ringBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new YieldingWaitStrategy()); var sequenceBarrier = _ringBuffer.NewBarrier(); _batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _eventHandler); _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 SetUp() { _ringBuffer = new RingBuffer<StubEvent>(() => new StubEvent(-1), 32); _sequenceBarrier = _ringBuffer.NewBarrier(); _ringBuffer.SetGatingSequences(new NoOpEventProcessor(_ringBuffer).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 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 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); } }