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 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.SetGatingSequences(_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.SetGatingSequences(_batchEventProcessor.Sequence);
}
public void SetUp()
{
_ringBuffer = new RingBuffer<StubEvent>(()=>new StubEvent(-1), 64);
_eventProcessorMock1 = new Mock<IEventProcessor>();
_eventProcessorMock2 = new Mock<IEventProcessor>();
_eventProcessorMock3 = new Mock<IEventProcessor>();
_ringBuffer.SetGatingSequences(new NoOpEventProcessor(_ringBuffer).Sequence);
}
public void SetUp()
{
_ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), 64);
_eventProcessorMock1 = new Mock <IEventProcessor>();
_eventProcessorMock2 = new Mock <IEventProcessor>();
_eventProcessorMock3 = new Mock <IEventProcessor>();
_ringBuffer.SetGatingSequences(new NoOpEventProcessor(_ringBuffer).Sequence);
}
public void ShouldPublishEvent()
{
var ringBuffer = new RingBuffer<LongEvent>(()=>new LongEvent(0), BufferSize);
ringBuffer.SetGatingSequences(new NoOpEventProcessor(ringBuffer).Sequence);
var eventPublisher = new EventPublisher<LongEvent>(ringBuffer);
eventPublisher.PublishEvent(_translator);
eventPublisher.PublishEvent(_translator);
Assert.AreEqual(0L + ValueAdd, ringBuffer[0].Value);
Assert.AreEqual(1L + ValueAdd, ringBuffer[1].Value);
}
public void ShouldPublishEvent()
{
var ringBuffer = new RingBuffer <LongEvent>(() => new LongEvent(0), BufferSize);
ringBuffer.SetGatingSequences(new NoOpEventProcessor(ringBuffer).Sequence);
var eventPublisher = new EventPublisher <LongEvent>(ringBuffer);
eventPublisher.PublishEvent(_translator);
eventPublisher.PublishEvent(_translator);
Assert.AreEqual(0L + ValueAdd, ringBuffer[0].Value);
Assert.AreEqual(1L + ValueAdd, ringBuffer[1].Value);
}
/// <summary>
/// Starts the <see cref="IEventProcessor"/>s and returns the fully configured <see cref="RingBuffer"/>.
/// The <see cref="RingBuffer"/> is set up to prevent overwriting any entry that is yet to
/// be processed by the slowest event processor.
/// This method must only be called once after all <see cref="IEventProcessor"/>s have been added.
/// </summary>
/// <returns>the configured <see cref="RingBuffer"/>.</returns>
public RingBuffer <T> Start()
{
var gatingProcessors = _eventProcessorRepository.LastEventProcessorsInChain;
_ringBuffer.SetGatingSequences(Util.GetSequencesFor(gatingProcessors));
CheckOnlyStartedOnce();
foreach (var eventProcessorInfo in _eventProcessorRepository.EventProcessors)
{
var eventProcessor = eventProcessorInfo.EventProcessor;
Task.Factory.StartNew(eventProcessor.Run, CancellationToken.None, TaskCreationOptions.None, _taskScheduler);
}
return(_ringBuffer);
}
/// <summary>
/// Starts the <see cref="IEventProcessor"/>s and returns the fully configured <see cref="RingBuffer"/>.
/// The <see cref="RingBuffer"/> is set up to prevent overwriting any entry that is yet to
/// be processed by the slowest event processor.
/// This method must only be called once after all <see cref="IEventProcessor"/>s have been added.
/// </summary>
/// <returns>the configured <see cref="RingBuffer"/>.</returns>
public RingBuffer <T> Start()
{
var gatingProcessors = _eventProcessorRepository.LastEventProcessorsInChain;
_ringBuffer.SetGatingSequences(Util.GetSequencesFor(gatingProcessors));
CheckOnlyStartedOnce();
foreach (var eventProcessorInfo in _eventProcessorRepository.EventProcessors)
{
var eventProcessor = eventProcessorInfo.EventProcessor;
var thread = new Thread(eventProcessor.Run)
{
IsBackground = true,
};
thread.Start();
}
return(_ringBuffer);
}
public void ShouldPublishEvent()
{
const long valueAdd = 29L;
var ringBuffer = new RingBuffer<LongEvent>(()=>new LongEvent(0), 32);
ringBuffer.SetGatingSequences(new NoOpEventProcessor(ringBuffer).Sequence);
var eventPublisher = new EventPublisher<LongEvent>(ringBuffer);
Func<LongEvent, long, LongEvent> translator = (evt, seq) =>
{
evt.Value = seq + valueAdd;
return evt;
};
eventPublisher.PublishEvent(translator);
eventPublisher.PublishEvent(translator);
Assert.AreEqual(0L + valueAdd, ringBuffer[0].Value);
Assert.AreEqual(1L + valueAdd, ringBuffer[1].Value);
}
public void ShouldTryPublishEvent()
{
RingBuffer<LongEvent> ringBuffer = new RingBuffer<LongEvent>(()=>new LongEvent(0), BufferSize);
ringBuffer.SetGatingSequences(new Sequence());
EventPublisher<LongEvent> eventPublisher = new EventPublisher<LongEvent>(ringBuffer);
for (int i = 0; i < BufferSize; i++)
{
Assert.IsTrue(eventPublisher.TryPublishEvent(_translator, 1));
}
for (int i = 0; i < BufferSize; i++)
{
Assert.AreEqual(i + ValueAdd, ringBuffer[i].Value);
}
Assert.IsFalse(eventPublisher.TryPublishEvent(_translator, 1));
}
public void ShouldPublishEvent()
{
const long valueAdd = 29L;
var ringBuffer = new RingBuffer <LongEvent>(() => new LongEvent(0), 32);
ringBuffer.SetGatingSequences(new NoOpEventProcessor(ringBuffer).Sequence);
var eventPublisher = new EventPublisher <LongEvent>(ringBuffer);
Func <LongEvent, long, LongEvent> translator = (evt, seq) =>
{
evt.Value = seq + valueAdd;
return(evt);
};
eventPublisher.PublishEvent(translator);
eventPublisher.PublishEvent(translator);
Assert.AreEqual(0L + valueAdd, ringBuffer[0].Value);
Assert.AreEqual(1L + valueAdd, ringBuffer[1].Value);
}
public void ShouldTryPublishEvent()
{
RingBuffer <LongEvent> ringBuffer = new RingBuffer <LongEvent>(() => new LongEvent(0), BufferSize);
ringBuffer.SetGatingSequences(new Sequence());
EventPublisher <LongEvent> eventPublisher = new EventPublisher <LongEvent>(ringBuffer);
for (int i = 0; i < BufferSize; i++)
{
Assert.IsTrue(eventPublisher.TryPublishEvent(_translator, 1));
}
for (int i = 0; i < BufferSize; i++)
{
Assert.AreEqual(i + ValueAdd, ringBuffer[i].Value);
}
Assert.IsFalse(eventPublisher.TryPublishEvent(_translator, 1));
}
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 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 void SetUp()
{
_ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), 32);
_sequenceBarrier = _ringBuffer.NewBarrier();
_ringBuffer.SetGatingSequences(new NoOpEventProcessor(_ringBuffer).Sequence);
}
public void SetUp()
{
_ringBuffer = new RingBuffer<StubEvent>(() => new StubEvent(-1), 32);
_sequenceBarrier = _ringBuffer.NewBarrier();
_ringBuffer.SetGatingSequences(new NoOpEventProcessor(_ringBuffer).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);
}
}
public void InitRingQueue()
{
if (_disruptor == null)
{
if (PUSH_CNT <= 1)
{
_disruptor = new Dsl.Disruptor <MessageEvent>(
() => new MessageEvent(),
new SingleThreadedClaimStrategy(BUFFER_SIZE),
//new MultiThreadedClaimStrategy(BUFFER_SIZE),
//new BusySpinWaitStrategy(),
new YieldingWaitStrategy(),
//new SleepingWaitStrategy(),
TaskScheduler.Default);
}
else
{
_disruptor = new Dsl.Disruptor <MessageEvent>(
() => new MessageEvent(),
//new SingleThreadedClaimStrategy(BUFFER_SIZE),
new MultiThreadedClaimStrategy(BUFFER_SIZE),
//new BusySpinWaitStrategy(),
new YieldingWaitStrategy(),
//new BetterYieldingWaitStrategy(),
//new SleepingWaitStrategy(),
TaskScheduler.Default);
}
_latchs = new CountdownEvent(POP_CNT);
_eventHandlers = new ValueMutationEventHandler[POP_CNT];
for (int i = 0; i < POP_CNT; i++)
{
if (i == 0)
{
_eventHandlers[0] = new ValueMutationEventHandler(0, Operation.Addition, MAX_MSG_COUNT, _latchs);
}
else if (i == 1)
{
_eventHandlers[1] = new ValueMutationEventHandler(1, Operation.Substraction, MAX_MSG_COUNT, _latchs);
}
else if (i == 2)
{
_eventHandlers[2] = new ValueMutationEventHandler(2, Operation.And, MAX_MSG_COUNT, _latchs);
}
else
{
_eventHandlers[i] = new ValueMutationEventHandler(i, Operation.And, MAX_MSG_COUNT, _latchs);
}
}
_workHandlers = new CountingWorkHandler[POP_CNT];
for (int i = 0; i < POP_CNT; i++)
{
_workHandlers[i] = new CountingWorkHandler(i, POP_MSG_CNT, _counters, _latchs);
}
_workProcessors = new CountingWorkProcessor[POP_CNT];
for (int i = 0; i < POP_CNT; i++)
{
_workProcessors[i] = new CountingWorkProcessor(i, POP_MSG_CNT, _counters, _latchs);
}
//_disruptor.HandleEventsWith(_eventHandlers);
//_disruptor.HandleEventsWith(_workProcessors);
_ringBuffer = _disruptor.RingBuffer;
///*
_workerPool = new WorkerPool <MessageEvent>(_ringBuffer,
_ringBuffer.NewBarrier(),
new FatalExceptionHandler(),
_workHandlers);
//*/
///*
_ringBuffer.SetGatingSequences(_workerPool.WorkerSequences);
for (int i = 0; i < POP_CNT; i++)
{
_workHandlers[i].SetRingBuffer(_ringBuffer);
_workProcessors[i].SetRingBuffer(_ringBuffer);
}
//*/
ResetEvents();
ResetCounters();
_producerThreads = new Thread[PUSH_CNT];
for (int i = 0; i < PUSH_CNT; i++)
{
Producer producer = new Producer(i, PUSH_MSG_CNT, 0, _ringBuffer);
producer.Reset();
_producerThreads[i] = new Thread(new ThreadStart(producer.Run));
}
Thread.MemoryBarrier();
for (int i = 0; i < PUSH_CNT; i++)
{
_producerThreads[i].Start();
}
_remainCount.AtomicExchange(MAX_MSG_COUNT);
Thread.MemoryBarrier();
_workerPool.Start(TaskScheduler.Default);
//_disruptor.Start();
}
}
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()
{
_sequenceBarrier = _ringBuffer.NewBarrier();
_ringBuffer.SetGatingSequences(new NoOpEventProcessor(_ringBuffer).Sequence);
}
