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