public void ShouldNotCreateRingBufferWithInvalidEventSize(int eventSize)
{
using (var memory = UnmanagedRingBufferMemory.Allocate(1, 1))
{
Assert.Throws <ArgumentException>(() => GC.KeepAlive(new UnmanagedRingBuffer <StubUnmanagedEvent>(memory.PointerToFirstEvent, eventSize, new SingleProducerSequencer(1))));
}
}
public RingBufferReadBenchmarks()
{
_ringBuffer = new RingBuffer <Event>(() => new Event(), new SingleProducerSequencer(4096, new BusySpinWaitStrategy()));
_valueRingBuffer = new ValueRingBuffer <ValueEvent>(() => new ValueEvent(), new SingleProducerSequencer(4096, new BusySpinWaitStrategy()));
_unmanagedRingBufferMemory = UnmanagedRingBufferMemory.Allocate(4096, () => new ValueEvent());
_unmanagedRingBuffer = new UnmanagedRingBuffer <ValueEvent>(_unmanagedRingBufferMemory, ProducerType.Single, new BusySpinWaitStrategy());
}
private static IValueRingBuffer <StubUnmanagedEvent> CreateRingBuffer(int size, ProducerType producerType, List <UnmanagedRingBufferMemory> memoryList)
{
var memory = UnmanagedRingBufferMemory.Allocate(size, () => new StubUnmanagedEvent(-1));
memoryList.Add(memory);
return(new UnmanagedRingBuffer <StubUnmanagedEvent>(memory, producerType, new BlockingWaitStrategy()));
}
public void ShouldGetEventFromSequence(long sequence)
{
var index = 0;
using var memory = UnmanagedRingBufferMemory.Allocate(32, () => new StubUnmanagedEvent(index++));
var ringBuffer = new UnmanagedRingBuffer <StubUnmanagedEvent>(memory, ProducerType.Single, new BlockingWaitStrategy());
ref var evt = ref ringBuffer[sequence];
protected override IValueRingBuffer <StubUnmanagedEvent> CreateRingBuffer(int size, ProducerType producerType)
{
var memory = UnmanagedRingBufferMemory.Allocate(size, () => new StubUnmanagedEvent(-1));
_memoryList.Add(memory);
return(new UnmanagedRingBuffer <StubUnmanagedEvent>(memory, producerType, new BlockingWaitStrategy()));
}
private UnmanagedRingBuffer <T> CreateSingleProducer <T>(Func <T> eventFactory, int size)
where T : unmanaged
{
var memory = UnmanagedRingBufferMemory.Allocate(size, eventFactory);
_memoryList.Add(memory);
return(new UnmanagedRingBuffer <T>(memory, ProducerType.Single, new BlockingWaitStrategy()));
}
public OneToOneSequencedBatchUnmanagedThroughputTest()
{
_memory = UnmanagedRingBufferMemory.Allocate(_bufferSize, PerfValueEvent.Size);
_ringBuffer = new UnmanagedRingBuffer <PerfValueEvent>(_memory, ProducerType.Single, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new AdditionEventHandler();
_batchEventProcessor = BatchEventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_batchEventProcessor.Sequence);
}
public void ShouldReadValueFromPointer()
{
var index = 0;
using (var memory = UnmanagedRingBufferMemory.Allocate(2048, () => new StubUnmanagedEvent(index++)))
{
for (var i = 0; i < memory.EventCount; i++)
{
var evt = Util.ReadValue <StubUnmanagedEvent>(memory.PointerToFirstEvent, i, memory.EventSize);
Assert.AreEqual(new StubUnmanagedEvent(i), evt);
}
}
}
public void ShouldConvertMemoryToArray()
{
var index = 0;
using (var memory = UnmanagedRingBufferMemory.Allocate(32, () => new Data {
Value1 = index++
}))
{
var array = memory.ToArray <Data>();
var expectedArray = Enumerable.Range(0, 32).Select(i => new Data {
Value1 = i
}).ToArray();
Assert.AreEqual(expectedArray, array);
}
}
public unsafe void ShouldCreateMemoryFromSize()
{
using (var memory = UnmanagedRingBufferMemory.Allocate(1024, 8))
{
Assert.AreEqual(1024, memory.EventCount);
Assert.AreEqual(8, memory.EventSize);
var pointer = (Data *)memory.PointerToFirstEvent;
for (var i = 0; i < memory.EventCount; i++)
{
var data = pointer[i];
Assert.AreEqual(0, data.Value1);
Assert.AreEqual(0, data.Value2);
}
}
}
/// <summary>
/// Create a new UnmanagedDisruptor.
///
/// The <see cref="UnmanagedRingBufferMemory"/> is not owned by the disruptor and should be disposed after shutdown.
/// </summary>
/// <param name="memory">block of memory that will store the events</param>
/// <param name="producerType">the claim strategy to use for the ring buffer</param>
/// <param name="waitStrategy">the wait strategy to use for the ring buffer</param>
public UnmanagedDisruptor(UnmanagedRingBufferMemory memory, ProducerType producerType, IWaitStrategy waitStrategy)
: this(new UnmanagedRingBuffer <T>(memory, producerType, waitStrategy), TaskScheduler.Default)
{
}
public void SetUp()
{
_executor = new StubExecutor();
_memory = UnmanagedRingBufferMemory.Allocate(4, TestValueEvent.Size);
_disruptor = new UnmanagedDisruptor <TestValueEvent>(_memory.PointerToFirstEvent, _memory.EventSize, _memory.EventCount, _executor);
}
/// <summary>
/// Construct an UnmanagedRingBuffer with the full option set.
/// The <see cref="UnmanagedRingBufferMemory"/> is not owned by the ring buffer and should be disposed after shutdown.
/// </summary>
/// <param name="memory">block of memory that will store the events</param>
/// <param name="producerType">producer type to use <see cref="ProducerType" /></param>
/// <param name="waitStrategy">used to determine how to wait for new elements to become available.</param>
/// <exception cref="ArgumentException">if bufferSize is less than 1 or not a power of 2</exception>
public UnmanagedRingBuffer(UnmanagedRingBufferMemory memory, ProducerType producerType, IWaitStrategy waitStrategy)
: base(SequencerFactory.Create(producerType, memory.EventCount, waitStrategy), memory.PointerToFirstEvent, memory.EventSize)
{
}
