public void SetUp()
{
if (!HighPerformance)
{
ClientSendBuffer = new ConcurrentCircularBuffer<NetworkData>(BufferSize);
ClientReceiveBuffer = new ConcurrentCircularBuffer<NetworkData>(BufferSize);
ServerReceiveBuffer = new ConcurrentCircularBuffer<NetworkData>(BufferSize);
}
ClientReceived = new AtomicCounter(0);
ServerReceived = new AtomicCounter(0);
_clientExecutor = new AssertExecutor();
_serverExecutor = new AssertExecutor();
var serverBootstrap = new ServerBootstrap()
.WorkerThreads(2)
.Executor(_serverExecutor)
.SetTransport(TransportType)
.SetEncoder(Encoder)
.SetDecoder(Decoder)
.SetAllocator(Allocator)
.SetConfig(Config)
.Build();
_server = serverBootstrap.NewConnection(Node.Loopback());
_clientConnectionFactory = new ClientBootstrap()
.Executor(_clientExecutor)
.SetTransport(TransportType)
.SetEncoder(Encoder)
.SetDecoder(Decoder)
.SetAllocator(Allocator)
.SetConfig(Config)
.Build();
}
public void ConcurrentEnqueueShouldNotLeakIndexPosition()
{
var buffer = new ConcurrentCircularBuffer <int>(10);
Parallel.For(0, 100000, i => buffer.Enqueue(i));
Assert.That(buffer.Count, Is.EqualTo(10));
}
public void SetUp()
{
ClientSendBuffer = new ConcurrentCircularBuffer <NetworkData>(BufferSize);
ClientReceiveBuffer = new ConcurrentCircularBuffer <NetworkData>(BufferSize);
_clientExecutor = new AssertExecutor();
_serverExecutor = new AssertExecutor();
var serverBootstrap = new ServerBootstrap()
.WorkerThreads(2)
.Executor(_serverExecutor)
.SetTransport(TransportType)
.SetEncoder(Encoder)
.SetDecoder(Decoder)
.SetAllocator(Allocator)
.SetConfig(Config)
.Build();
_server = serverBootstrap.NewConnection(Node.Loopback());
_clientConnectionFactory = new ClientBootstrap()
.Executor(_clientExecutor)
.SetTransport(TransportType)
.SetEncoder(Encoder)
.SetDecoder(Decoder)
.SetAllocator(Allocator)
.SetConfig(Config)
.Build();
}
public void ConcurrentEnqueueShouldNotLeakIndexPosition()
{
var buffer = new ConcurrentCircularBuffer<int>(10);
Parallel.For(0, 100000, i => buffer.Enqueue(i));
Assert.That(buffer.Count, Is.EqualTo(10));
}
public void EnqueueShouldAddToFirstSlot()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
buffer.Enqueue(1);
Assert.That(buffer.First(), Is.EqualTo(1));
}
private void ConcurrentEnqueueTestRun(int batchSize)
{
var buffer = new ConcurrentCircularBuffer <int>(10);
try
{
int index = 0;
int testSize = batchSize;
Parallel.For(0, testSize, i => buffer.Enqueue(Interlocked.Increment(ref index)));
Assert.That(buffer.Count, Is.EqualTo(10));
for (var i = testSize; i > testSize - 10; i--)
{
Assert.That(buffer.Contains(i));
}
}
catch
{
foreach (var i in buffer)
{
Console.WriteLine(i);
}
throw;
}
}
public void BufferMaxSizeShouldReportMax()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
}
public void BufferMaxSizeShouldReportMax()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
}
public void MarkDuplicateAsDuplicate()
{
var circularBuffer = new ConcurrentCircularBuffer <int>(10);
var duplicateChecker = new CircularBufferDuplicateChecker(circularBuffer);
duplicateChecker.IsDuplicate(12345);
var isDuplicate = duplicateChecker.IsDuplicate(12345);
Assert.True(isDuplicate);
}
public Logger(Action <string> Echo, IMyProgrammableBlock Me, int logSize)
{
this.Echo = Echo;
this.Me = Me;
this.Me.CustomData = "";
this.logBuffer = new ConcurrentCircularBuffer <string>(logSize);
Echo("Printing logs to CustomData of this programmable block...");
}
public void EnqueueCanBeUseFromDefferantThread()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Parallel.For(0, 1000, (i) =>
{
buffer.Enqueue(i);
Assert.That(buffer.Count, Is.LessThanOrEqualTo(2));
});
Assert.That(buffer.Count, Is.EqualTo(2));
}
public SerialWrapper(Configuration config, ConcurrentCircularBuffer <byte> dataQueue, int bufferSize = DEFAULT_BUFFER_SIZE)
{
if (bufferSize <= 0)
{
throw new ArgumentOutOfRangeException($"{nameof(bufferSize)} must be larger than zero.");
}
_bufferSize = bufferSize;
_config = config;
Buffer = dataQueue;
}
public void EnqueueCanBeUseFromDefferantThread()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Parallel.For(0, 1000, (i) =>
{
buffer.Enqueue(i);
Assert.That(buffer.Count, Is.LessThanOrEqualTo(2));
});
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void BufferShouldOnlyStoreMaxAmount()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
for (int i = 0; i < 10; i++)
{
buffer.Enqueue(i);
}
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void BufferShouldOnlyStoreMaxAmount()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
for (int i = 0; i < 10; i++)
{
buffer.Enqueue(i);
}
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void BufferShouldCountUntilMaxHitThenAlswaysShowMax()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Assert.That(buffer.Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(1));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void BufferShouldCountUntilMaxHitThenAlswaysShowMax()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Assert.That(buffer.Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(1));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void EnumerationShouldReturnOnlyRecordsWithData()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Assert.That(buffer.ToList().Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(1));
buffer.Enqueue(1);
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(2));
}
public void NotMarkNewAsDuplicate()
{
var circularBuffer = new ConcurrentCircularBuffer <int>(10);
var duplicateChecker = new CircularBufferDuplicateChecker(circularBuffer);
duplicateChecker.IsDuplicate(1);
duplicateChecker.IsDuplicate(2);
duplicateChecker.IsDuplicate(3);
duplicateChecker.IsDuplicate(4);
var isDuplicate = duplicateChecker.IsDuplicate(5);
Assert.False(isDuplicate);
}
public void EnumerationShouldReturnOnlyRecordsWithData()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Assert.That(buffer.ToList().Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(1));
buffer.Enqueue(1);
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(2));
}
public void NotMarkDuplicateAsDuplicateAfterRecordPurged()
{
var circularBuffer = new ConcurrentCircularBuffer <int>(5);
var duplicateChecker = new CircularBufferDuplicateChecker(circularBuffer);
duplicateChecker.IsDuplicate(1);
duplicateChecker.IsDuplicate(2);
duplicateChecker.IsDuplicate(3);
duplicateChecker.IsDuplicate(4);
duplicateChecker.IsDuplicate(5);
duplicateChecker.IsDuplicate(6);
var isDuplicate = duplicateChecker.IsDuplicate(1);
Assert.False(isDuplicate);
}
protected MultiNodeTest()
{
if (!HighPerformance)
{
ClientSendBuffer = new ConcurrentCircularBuffer <NetworkData>(BufferSize);
ClientReceiveBuffer = new ConcurrentCircularBuffer <NetworkData>(BufferSize);
ServerReceiveBuffer = new ConcurrentCircularBuffer <NetworkData>(BufferSize);
}
ClientReceived = new AtomicCounter(0);
ServerReceived = new AtomicCounter(0);
_clientExecutor = new AssertExecutor();
_serverExecutor = new AssertExecutor();
var serverBootstrap = new ServerBootstrap()
.WorkerThreads(2)
.Executor(_serverExecutor)
.WorkerThreads(WorkerThreads)
.SetTransport(TransportType)
.SetEncoder(Encoder)
.SetDecoder(Decoder)
.SetAllocator(Allocator)
.SetConfig(Config)
.Build();
_server = serverBootstrap.NewConnection(Node.Loopback());
_clientConnectionFactory = new ClientBootstrap()
.Executor(_clientExecutor)
.WorkerThreads(WorkerThreads)
.SetTransport(TransportType)
.SetEncoder(Encoder)
.SetDecoder(Decoder)
.SetAllocator(Allocator)
.SetConfig(Config)
.Build();
}
/// <summary> /// Returns true when a duplicate is received within the last X records. /// </summary> /// <param name="circularBuffer"></param> public CircularBufferDuplicateChecker(ConcurrentCircularBuffer <int> circularBuffer) => _circularBuffer = circularBuffer;
private void ConcurrentEnqueueTestRun(int batchSize)
{
var buffer = new ConcurrentCircularBuffer<int>(10);
try
{
int index = 0;
int testSize = batchSize;
Parallel.For(0, testSize, i => buffer.Enqueue(Interlocked.Increment(ref index)));
Assert.That(buffer.Count, Is.EqualTo(10));
for (var i = testSize; i > testSize - 10; i--)
{
Assert.That(buffer.Contains(i));
}
}
catch
{
foreach (var i in buffer)
{
Console.WriteLine(i);
}
throw;
}
}
public void EnqueueShouldAddToFirstSlot()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
buffer.Enqueue(1);
Assert.That(buffer.First(), Is.EqualTo(1));
}
public EtwListenerService(int bufferCapacity)
{
Buffer = new ConcurrentCircularBuffer<EtwRecord>(bufferCapacity);
_watch = new Stopwatch();
SessionId = Guid.NewGuid();
}
