public ArchivingEngine(
string sourceRootFolder,
string targetRootFolder,
ArchivingSettings settings,
TotalStatistics statistics,
ILog log)
{
this.sourceRootFolder = sourceRootFolder;
this.targetRootFolder = targetRootFolder;
this.statistics = statistics;
this.settings = settings;
this.log = log;
queue = new RingBuffer<Processing>();
processingDistributor = new ProcessingDistributor(
sourceRootFolder,
targetRootFolder,
statistics,
queue,
log);
processingPool = new PipelinesPool(processingDistributor);
retrievingDistributor = new RetrievingDistributor(
queue,
log);
retrievingPool = new PipelinesPool(retrievingDistributor);
}
public void Initialize(RingBuffer<InboundMessageProcessingEntry> ringBuffer)
{
_ringBuffer = ringBuffer;
_ipEndPoint = _endpoint.EndPoint;
_receiver.RegisterCallback(_ipEndPoint, DoReceive);
_receiver.ListenToEndpoint(_ipEndPoint);
}
public EyeDevice(int sensorHz)
{
_exit = false;
_pendingDatum = false;
//the data history should exceed the Hz of sensors on the market; this gives 2 seconds history for a 250Hz sensor.
//A larger value could be used for historical or other vector analysis on the extended inputs.
SENSOR_DATA_HISTORY = 500;
_eyeDataBuffer = new RingBuffer<EyeDatum>(SENSOR_DATA_HISTORY);
_filter = new EyeSensorFilter();
_newDatumLock = new Object();
//the number of pending datum misses by the consumer thread
_misses = 0;
if (sensorHz >= 500)
{
Console.WriteLine("ERROR sensorHz="+sensorHz+" is to high sensitivity for sensor poll. Large (>500Hz) sensorHz values");
Console.WriteLine("may prevent sensor data from being read. Re-evaluate algorithms in EyeDevice.");
}
//_currentState must have some initial value, or readers will get null ref
_currentState = Mouse.GetState();
//Set the poll scan time. Note this math is intentionally incorrect: using 1200 instead of 1000 is intended so that the
//sensor-polling thread always runs slightly faster than the rate at which manufacturers claim for their tracker Hz.
_sensorScanTime_ms = 1200 / sensorHz;
_computationScanTime_ms = _sensorScanTime_ms;
//launch the sensor polling thread.
_pollingThread = new Thread(new ThreadStart(_pollSensor));
_pollingThread.Start();
//kick the computation thread
_computationThread = new Thread(new ThreadStart(_runComputations));
_computationThread.Start();
}
public OneToOneSequencedPollerThroughputTest()
{
_ringBuffer = RingBuffer<ValueEvent>.CreateSingleProducer(ValueEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
_poller = _ringBuffer.NewPoller();
_ringBuffer.AddGatingSequences(_poller.Sequence);
_pollRunnable = new PollRunnable(_poller);
}
public void AddItemsToBufferOfSetSize_RemovesItemsFirstAddedToBufferToFitInMoreItems()
{
var buffer = new RingBuffer<string>(2);
buffer.Add("1");
buffer.Add("2");
List<string> items = buffer.ToList();
Assert.AreEqual("1", items[0]);
Assert.AreEqual("2", items[1]);
buffer.Add("3");
items = buffer.ToList();
Assert.AreEqual("2", items[0]);
Assert.AreEqual("3", items[1]);
buffer.Add("4");
items = buffer.ToList();
Assert.AreEqual("3", items[0]);
Assert.AreEqual("4", items[1]);
buffer.Add("5");
items = buffer.ToList();
Assert.AreEqual("4", items[0]);
Assert.AreEqual("5", items[1]);
}
public void setUp()
{
ringBuffer = new RingBuffer<StubEntry>(new StubFactory(), 20, new SingleThreadedStrategy(),
new BusySpinStrategy<StubEntry>());
consumerBarrier = ringBuffer.CreateConsumerBarrier();
producerBarrier = ringBuffer.CreateProducerBarrier(new NoOpConsumer(ringBuffer));
}
public XInputDeviceManager()
{
if (InputManager.XInputUpdateRate == 0)
{
timeStep = Mathf.FloorToInt( Time.fixedDeltaTime * 1000.0f );
}
else
{
timeStep = Mathf.FloorToInt( 1.0f / InputManager.XInputUpdateRate * 1000.0f );
}
bufferSize = (int) Math.Max( InputManager.XInputBufferSize, 1 );
for (int deviceIndex = 0; deviceIndex < maxDevices; deviceIndex++)
{
gamePadState[deviceIndex] = new RingBuffer<GamePadState>( bufferSize );
}
StartWorker();
for (int deviceIndex = 0; deviceIndex < maxDevices; deviceIndex++)
{
devices.Add( new XInputDevice( deviceIndex, this ) );
}
Update( 0, 0.0f );
}
/// <summary>
/// Returns the product of the stdev of the x and y components of the previous n mouse states,
/// which makes for a very good input trigger. There are many optimizations available for this function.
///
/// The stdev strategy parameters must be based upon the physical problem of detecting clicks via a
/// concentration of points within a region. This means that the Hz rate of the sensor is an input,
/// as well as other physical characteristics of the device and its current calibration.
///
/// There need be no weighting in this function either; since we assume the user is focused on a given point, all
/// points captured within a sample of time window t are estimates of the true 'hidden' value of the current points.
/// </summary>
/// <param name="numPoints">The number of previous points to include in the stdev-xy product.</param>
/// <returns></returns>
public double StDevXyProduct(int numPoints, RingBuffer<EyeDatum> sensorData)
{
int i;
double mu_x = 0.0, mu_y = 0.0;
double var_x = 0.0, var_y = 0.0;
//get the means
for (i = 0; i < numPoints && i < sensorData.Count; i++)
{
mu_x += sensorData[i].MouseData.X;
mu_y += sensorData[i].MouseData.Y;
}
mu_x /= (double)i;
mu_y /= (double)i;
//get the variance of the x and y coordinates in this set
for (i = 0; i < numPoints && i < sensorData.Count; i++)
{
var_x += ((sensorData[i].MouseData.X - mu_x) * (sensorData[i].MouseData.X - mu_x));
var_y += ((sensorData[i].MouseData.Y - mu_y) * (sensorData[i].MouseData.Y - mu_y));
}
//optimization TODO: there is no need for expensive square-root for the trigger we're looking for;
//by laws of exponents, (x^0.5)(y^0.5) == (x*y)^0.5, and thus the sqrt is actually unnecessary for
//a trigger, since the trigger baseline can simply be squared. And also if we're careful wrt overflow.
return Math.Sqrt(var_x) * Math.Sqrt(var_y);
}
public override void ActivateOptions()
{
base.ActivateOptions();
pendingAppends = new RingBuffer<LoggingEvent>(QueueSizeLimit);
pendingAppends.BufferOverflow += OnBufferOverflow;
StartAppendTask();
}
public void PerfTestThreadsWithDequeues()
{
RingBuffer<string> ringBuffer = new RingBuffer<string>(1000);
Stopwatch ringWatch = new Stopwatch();
List<Task> ringTasks = new List<Task>();
for (int t = 0; t < 10; t++)
{
ringTasks.Add(new Task(() =>
{
for (int i = 0; i < 1000000; i++)
{
ringBuffer.Enqueue("StringOfFun");
}
}));
}
for (int t = 0; t < 10; t++)
{
ringTasks.Add(new Task(() =>
{
for (int i = 0; i < 1000000; i++)
{
string foo;
ringBuffer.TryDequeue(out foo);
}
}));
}
ringWatch.Start();
ringTasks.ForEach(t => t.Start());
Task.WaitAny(ringTasks.ToArray());
ringWatch.Stop();
Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(800));
}
public TestWaiter(Barrier barrier, ISequenceBarrier sequenceBarrier, RingBuffer<StubEvent> ringBuffer, long initialSequence, long toWaitForSequence)
{
_barrier = barrier;
_sequenceBarrier = sequenceBarrier;
_ringBuffer = ringBuffer;
_initialSequence = initialSequence;
_toWaitForSequence = toWaitForSequence;
}
public void PutIncrementsSize() {
RingBuffer<int> _buffer = new RingBuffer<int>(iterations);
for(int i = 0; i < iterations; i++) {
int _tmp = i;
_buffer.Add(_tmp);
Assert.AreEqual(i + 1, _buffer.Size, "Size is not equal to number of elements added.");
}
}
public void RetrievedInCorrectOrder() {
RingBuffer<int> _buffer = new RingBuffer<int>(iterations);
populateBuffer(iterations, _buffer);
for(int i = 0; i < iterations; i++) {
int _tmp = _buffer.Get();
Assert.AreEqual(i, _tmp, "Incorrect Sequence");
}
}
public void SetUp()
{
_sequencerMock = new Mock<ISequencer>();
_sequencer = _sequencerMock.Object;
_sequencerMock.SetupGet(x => x.BufferSize).Returns(16);
_ringBuffer = new RingBuffer<StubEvent>(StubEvent.EventFactory, _sequencer);
}
public ValuePublisher(Barrier cyclicBarrier
, RingBuffer<ValueEvent> ringBuffer
, long iterations)
{
this.cyclicBarrier = cyclicBarrier;
this.ringBuffer = ringBuffer;
this.iterations = iterations;
}
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 void GetDecrementsSize() {
RingBuffer<int> _buffer = new RingBuffer<int>(iterations);
populateBuffer(iterations, _buffer);
for(int i = iterations; i > 0; i--) {
int _tmp = _buffer.Get();
Assert.AreEqual(i-1, _buffer.Size, "Size does not reflect the correct number of removed elements.");
}
}
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 void ClearTest_notempty()
{
RingBuffer<int> rb = new RingBuffer<int>(4);
rb.Add(7);
Assert.IsFalse(rb.IsEmpty);
rb.Clear();
Assert.IsTrue(rb.IsEmpty);
}
public void Initialize(RingBuffer<InboundMessageProcessingEntry> ringBuffer)
{
_ringBuffer = ringBuffer;
foreach (IWireReceiverTransport wireReceiverTransport in _transports)
{
wireReceiverTransport.Initialize(ringBuffer);
}
}
public void IsFullTest_True()
{
RingBuffer<int> rb = new RingBuffer<int>(4);
rb.Add(1);
rb.Add(2);
rb.Add(3);
rb.Add(4);
Assert.IsTrue(rb.IsFull);
}
public ICadeDeviceManager()
{
timeStep = Mathf.FloorToInt( Time.fixedDeltaTime * 1000.0f );
bufferSize = 1;
state = new RingBuffer<ICadeState>( bufferSize );
device = new ICadeDevice( this );
devices.Add( device );
}
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 UniCast1P1CDisruptorPerfTest()
: base(100 * Million)
{
_disruptor = new Disruptor<ValueEvent>(() => new ValueEvent(),BufferSize,TaskScheduler.Default, ProducerType.SINGLE,new YieldingWaitStrategy());
_mru = new ManualResetEvent(false);
_eventHandler = new ValueAdditionEventHandler(Iterations, _mru);
_disruptor.HandleEventsWith(_eventHandler);
_ringBuffer = _disruptor.GetRingBuffer;
}
public LongArrayPublisher(Barrier cyclicBarrier,
RingBuffer<long[]> ringBuffer,
long iterations,
long arraySize)
{
this.cyclicBarrier = cyclicBarrier;
this.ringBuffer = ringBuffer;
this.iterations = iterations;
this.arraySize = arraySize;
}
public ValueBatchPublisher(Barrier cyclicBarrier
, RingBuffer<ValueEvent> ringBuffer
, long iterations
, int batchSize)
{
this.cyclicBarrier = cyclicBarrier;
this.ringBuffer = ringBuffer;
this.iterations = iterations;
this.batchSize = batchSize;
}
public void AddingToARingBufferWorks()
{
RingBuffer<int> r = new RingBuffer<int>(5);
r.Add(1);
r.Add(2);
r.Add(3);
r.Add(4);
r.Add(5);
r.Add(6);
}
public Sensor(SensorIdentification config)
{
mID = config.Id;
mMAC = config.Mac;
mPortName = config.PortName;
mData = new RingBuffer<SensorDataEntry>(HISTORY_BUFFER_SIZE);
/** Add an empty entry in case getLastEntry is called before data comes in */
mData.Add( new SensorDataEntry() );
mTimeoutWatch = new System.Diagnostics.Stopwatch();
}
public void SetUp()
{
_ringBuffer = RingBuffer<StubEvent>.CreateMultiProducer(() => new StubEvent(-1), 64);
_eventProcessorMock1 = new Mock<IEventProcessor>();
_eventProcessorMock2 = new Mock<IEventProcessor>();
_eventProcessorMock3 = new Mock<IEventProcessor>();
_ringBuffer.AddGatingSequences(new NoOpEventProcessor<StubEvent>(_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 PingPongSequencedLatencyTest_Multi()
{
var pingBuffer = RingBuffer <PerfEvent> .CreateMultiProducer(PerfEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
var pongBuffer = RingBuffer <PerfEvent> .CreateMultiProducer(PerfEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
var pingBarrier = pingBuffer.NewBarrier();
var pongBarrier = pongBuffer.NewBarrier();
_pinger = new Pinger(pingBuffer, _iterations, _pauseNanos);
_ponger = new Ponger(pongBuffer);
_pingProcessor = EventProcessorFactory.Create(pongBuffer, pongBarrier, _pinger);
_pongProcessor = EventProcessorFactory.Create(pingBuffer, pingBarrier, _ponger);
pingBuffer.AddGatingSequences(_pongProcessor.Sequence);
pongBuffer.AddGatingSequences(_pingProcessor.Sequence);
}
public void TestFullBuffer()
{
var ringBuffer = new RingBuffer(4); // 4 cap
var buffer = new byte[] { 1, 2, 3, 4, 5 };
var write = ringBuffer.Write(buffer);
Assert.AreEqual(4, write);
Assert.AreEqual(0, ringBuffer.WriteableCapacity);
Assert.AreEqual(4, ringBuffer.ReadableCapacity);
write = ringBuffer.Write(buffer);
Assert.AreEqual(0, write);
Assert.AreEqual(0, ringBuffer.WriteableCapacity);
Assert.AreEqual(4, ringBuffer.ReadableCapacity);
}
public void TestCanWrite()
{
var ringBuffer = new RingBuffer(12); // 16 cap
Assert.AreEqual(true, ringBuffer.CanWrite(15));
Assert.AreEqual(true, ringBuffer.CanWrite(16));
Assert.AreEqual(false, ringBuffer.CanWrite(17));
ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 });
Assert.AreEqual(true, ringBuffer.CanWrite(10));
Assert.AreEqual(true, ringBuffer.CanWrite(11));
Assert.AreEqual(false, ringBuffer.CanWrite(12));
ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 }, 3);
Assert.AreEqual(true, ringBuffer.CanWrite(8));
Assert.AreEqual(true, ringBuffer.CanWrite(9));
Assert.AreEqual(false, ringBuffer.CanWrite(10));
}
public SynthesisRealTime(int sampleRate, double framePeriod, int fftSize, int bufferSize, int ringBufferCapacity)
{
SampleRate = sampleRate;
FramePeriod = framePeriod * 0.001;
AudioBufferSize = bufferSize;
AudioBuffer = new double[bufferSize * 2 + fftSize];
Buffer = new RingBuffer(ringBufferCapacity);
FFTSize = fftSize;
ImpulseResponse = new double[fftSize];
DCRemover = GetDCRemover(fftSize / 2);
RefreshSynthesizer();
MinimumPhase = MinimumPhaseAnalysis.Create(fftSize);
InverseRealFFT = InverseRealFFT.Create(fftSize);
ForwardRealFFT = ForwardRealFFT.Create(fftSize);
}
public Pipeline3StepLatencyDisruptorPerfTest()
: base(2 * Million)
{
_disruptor = new Dsl.Disruptor <ValueEvent>(() => new ValueEvent(),
new SingleThreadedClaimStrategy(Size),
new YieldingWaitStrategy(),
TaskScheduler.Default);
_mru = new ManualResetEvent(false);
_stepOneFunctionEventHandler = new LatencyStepEventHandler(FunctionStep.One, Histogram, StopwatchTimestampCostInNano, TicksToNanos, Iterations, _mru);
_stepTwoFunctionEventHandler = new LatencyStepEventHandler(FunctionStep.Two, Histogram, StopwatchTimestampCostInNano, TicksToNanos, Iterations, _mru);
_stepThreeFunctionEventHandler = new LatencyStepEventHandler(FunctionStep.Three, Histogram, StopwatchTimestampCostInNano, TicksToNanos, Iterations, _mru);
_disruptor.HandleEventsWith(_stepOneFunctionEventHandler)
.Then(_stepTwoFunctionEventHandler)
.Then(_stepThreeFunctionEventHandler);
_ringBuffer = _disruptor.RingBuffer;
}
public void Put_SevenNumbers_OverwriteFirstNumber()
{
// arrange
var array = new int[6];
var circularBuffer = new RingBuffer <int>(array);
// act
circularBuffer.Put(20);
circularBuffer.Put(21);
circularBuffer.Put(22);
circularBuffer.Put(23);
circularBuffer.Put(24);
circularBuffer.Put(25);
circularBuffer.Put(99);
// assert
Assert.That(array[0], Is.EqualTo(99));
}
public async Task Key_and_value_are_read_from_batch()
{
await RingBuffer.DeleteAsync(_database, "Key_and_value_are_correct");
var ringbuffer = await RingBuffer.GetOrCreateAsync(_server, _database, "Key_and_value_are_correct", 10);
var producer = ringbuffer.CreateProducer();
for (var m = 0; m < 5; m++)
{
await producer.Publish($"key{m}", $"value{m}");
}
var message = await ringbuffer.CreateConsumer(StartFrom.Offset, 5).Skip(4).Take(1);
Assert.AreEqual("key4", message.Key);
Assert.AreEqual("value4", message.Value.ToString());
}
void StartPullAudioFrame(AudioSource aud, string clipName)
{
_audioRawDataManager = AudioRawDataManager.GetInstance(mRtcEngine);
var bufferLength = SAMPLE_RATE / PULL_FREQ_PER_SEC * CHANNEL * 1000; // 10-sec-length buffer
audioBuffer = new RingBuffer <float>(bufferLength);
_pullAudioFrameThread = new Thread(PullAudioFrameThread);
_pullAudioFrameThread.Start();
_audioClip = AudioClip.Create(clipName,
SAMPLE_RATE / PULL_FREQ_PER_SEC * CHANNEL, CHANNEL, SAMPLE_RATE, true,
OnAudioRead);
aud.clip = _audioClip;
aud.loop = true;
aud.Play();
}
public void ShouldAddWhileRunning()
{
var ringBuffer = RingBuffer <TestEvent> .CreateSingleProducer(() => new TestEvent(), 32);
var sequenceThree = new Sequence(3L);
var sequenceSeven = new Sequence(7L);
var sequenceGroup = new SequenceGroup();
sequenceGroup.Add(sequenceSeven);
for (var i = 0; i < 11; i++)
{
ringBuffer.Publish(ringBuffer.Next());
}
sequenceGroup.AddWhileRunning(ringBuffer, sequenceThree);
Assert.That(sequenceThree.Value, Is.EqualTo(10L));
}
public DiamondPath1P3CDisruptorWithAffinityPerfTest()
: base(100 * Million)
{
_scheduler = new RoundRobinThreadAffinedTaskScheduler(4);
_disruptor = new Disruptor <FizzBuzzEvent>(() => new FizzBuzzEvent(),
new SingleThreadedClaimStrategy(Size),
new YieldingWaitStrategy(),
_scheduler);
_mru = new ManualResetEvent(false);
_fizzEventHandler = new FizzBuzzEventHandler(FizzBuzzStep.Fizz, Iterations, _mru);
_buzzEventHandler = new FizzBuzzEventHandler(FizzBuzzStep.Buzz, Iterations, _mru);
_fizzBuzzEventHandler = new FizzBuzzEventHandler(FizzBuzzStep.FizzBuzz, Iterations, _mru);
_disruptor.HandleEventsWith(_fizzEventHandler, _buzzEventHandler)
.Then(_fizzBuzzEventHandler);
_ringBuffer = _disruptor.RingBuffer;
}
public void Process(RingBuffer <StrokePoint> data, RingBuffer <int> indices)
{
float maxThickness = data.GetLatest().thickness;
for (int i = 1; i < data.Count - 1; i++)
{
var prevStroke = data.Get(i - 1);
var currStroke = data.Get(i);
var nextStroke = data.Get(i + 1);
float thickness = maxThickness;
thickness = Mathf.Min(thickness, getMaxThickness(currStroke, prevStroke));
thickness = Mathf.Min(thickness, getMaxThickness(currStroke, nextStroke));
currStroke.thickness = thickness;
data.Set(i, currStroke);
}
}
public async Task Consumer_should_get_all_messages_if_requesting_more_than_available()
{
await RingBuffer.DeleteAsync(_database, "Consumer_should_get_all_messages_if_requesting_more_than_available");
var ringbuffer = await RingBuffer.GetOrCreateAsync(_server, _database, "Consumer_should_get_all_messages_if_requesting_more_than_available", 10);
var producer = ringbuffer.CreateProducer();
for (var i = 0; i < 3; i++)
{
await producer.Publish("key", "value");
}
var consumer = ringbuffer.CreateConsumer(StartFrom.Offset, 5);
var message = await consumer.Take(1);
Assert.AreEqual(0, message.MessageId);
}
public PingPongSequencedLatencyTest()
{
_pingBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
_pongBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
_pingBarrier = _pingBuffer.NewBarrier();
_pongBarrier = _pongBuffer.NewBarrier();
_pinger = new Pinger(_pingBuffer, _iterations, _pauseNanos);
_ponger = new Ponger(_pongBuffer);
_pingProcessor = BatchEventProcessorFactory.Create(_pongBuffer, _pongBarrier, _pinger);
_pongProcessor = BatchEventProcessorFactory.Create(_pingBuffer, _pingBarrier, _ponger);
_pingBuffer.AddGatingSequences(_pongProcessor.Sequence);
_pongBuffer.AddGatingSequences(_pingProcessor.Sequence);
}
private void connect()
{
bool error = false;
if (cmbPortName.SelectedIndex != -1 & cmbBaudRate.SelectedIndex != -1 & cmbParity.SelectedIndex != -1 & cmbDataBits.SelectedIndex != -1 & cmbStopBits.SelectedIndex != -1)
{
ComPort.PortName = cmbPortName.Text;
ComPort.BaudRate = int.Parse(cmbBaudRate.Text);
ComPort.Parity = (Parity)Enum.Parse(typeof(Parity), cmbParity.Text);
ComPort.DataBits = int.Parse(cmbDataBits.Text);
ComPort.StopBits = (StopBits)Enum.Parse(typeof(StopBits), cmbStopBits.Text);
//ComPort.Encoding= Encoding.GetEncoding(28591);
//ComPort.Encoding = new UTF8Encoding(true, true);
rxbuffer = new RingBuffer <byte>(ComPort.ReadBufferSize);
txbuffer = new RingBuffer <byte>(ComPort.WriteBufferSize);
try
{
ComPort.Open();
ComPort.DataReceived += SerialPortDataReceived;
}
catch (UnauthorizedAccessException) { error = true; }
catch (System.IO.IOException) { error = true; }
catch (ArgumentException) { error = true; }
if (error)
{
MessageBox.Show(this, "Could not open the COM port.", "COM Port unavailable", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
}
else
{
MessageBox.Show("Please select all the Serial Port Settings", "Serial Port Interface", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
if (ComPort.IsOpen)
{
btnConnect.Text = "Disconnect";
btnSend.Enabled = true;
if (!rdText.Checked & !rdHex.Checked)
{
rdText.Checked = true;
}
groupBox1.Enabled = false;
}
}
public Sequencer3P1CDisruptorPerfTest()
: base(20 * Million)
{
_disruptor = new Disruptor <ValueEvent>(() => new ValueEvent(),
new MultiThreadedLowContentionClaimStrategy(Size),
new YieldingWaitStrategy(),
TaskScheduler.Default);
_mru = new ManualResetEvent(false);
_eventHandler = new ValueAdditionEventHandler(Iterations * NumProducers, _mru);
_disruptor.HandleEventsWith(_eventHandler);
_valueProducers = new ValueProducer[NumProducers];
_ringBuffer = _disruptor.RingBuffer;
for (int i = 0; i < NumProducers; i++)
{
_valueProducers[i] = new ValueProducer(_testStartBarrier, _ringBuffer, Iterations);
}
}
// Returns average millisecs from the given tick buffer
static private double AvgMillisecs(RingBuffer <ulong> inTickBuffer)
{
int count = inTickBuffer.Count;
if (count <= 1)
{
return(-1);
}
ulong accum = 0;
for (int i = count - 1; i >= 0; --i)
{
accum += inTickBuffer[i];
}
double avgTicks = (double)accum / count;
return((avgTicks / Stopwatch.Frequency) * 1000);
}
public void Dispose()
{
try
{
if (_disruptor != null)
{
_disruptor.Shutdown(new TimeSpan(10));
}
}
catch (Exception ex)
{
LogTo.Error(ex.ToString());
}
finally
{
_disruptor = null;
_ringBuffer = null;
}
}
private int GetRingbufferAvailablePercentage()
{
var tenPercent = RingBuffer.BufferSize / 10;
if (!RingBuffer.HasAvailableCapacity(0))
{
return(0);
}
for (int i = 1; i < 10; i++)
{
if (!RingBuffer.HasAvailableCapacity(tenPercent * i))
{
return(10 * i);
}
}
return(100);
}
public void PutTest_AddedMoreThanCapacity_Sussess()
{
string[] data = new string[] { "string1", "string2", "string3", "string4", "string5" };
RingBuffer <string> testSubject = new RingBuffer <string>(data.Length - 1);
foreach (string str in data)
{
testSubject.Put(str);
}
var bufferContent = testSubject.GetData();
foreach (string str in bufferContent)
{
Debug.Write($"{str} ");
}
Assert.IsTrue(bufferContent.First() == data.Last());
}
public void RemoveAfter()
{
var target = new RingBuffer <int> {
10, 20, 30, 40
};
target.RemoveAfter(target.BottomIndex);
Assert.AreEqual(3, target.Count);
Assert.AreEqual(10, target[target.TopIndex]);
Assert.AreEqual(20, target[target.TopIndex.Next]);
Assert.AreEqual(30, target[target.TopIndex.Next.Next]);
target.RemoveAfter(target.BottomIndex.Previous);
Assert.AreEqual(1, target.Count);
Assert.AreEqual(10, target[target.TopIndex]);
target.Add(100);
target.Add(200);
target.RemoveAfter(target.TopIndex);
Assert.AreEqual(0, target.Count);
}
public void AssertThat_AddingArrayToRingBuffer_Wraps()
{
var r = new RingBuffer <int>(5)
{
//Add some initial data
1,
2,
3,
//Add some data which will fall off the end
new int[] { 4, 5, 6, 7 }
};
Assert.AreEqual(3, r[0]);
Assert.AreEqual(4, r[1]);
Assert.AreEqual(5, r[2]);
Assert.AreEqual(6, r[3]);
Assert.AreEqual(7, r[4]);
}
public LogView(Entity entity)
{
int nLabels = Constants.nLogLabel;
this.layout = Layouts.logLayout();
this.logger = new RlLogger();
this.labels = new RingBuffer <TextComponent>(nLabels);
this.entity = entity.SetLocalPosition(this.layout.offset);
for (int i = 0; i < nLabels; i++)
{
this.labels[i] = this.entity
.add(new TextComponent())
.zCx(Layers.Screen, Depths.Log);
}
this.forceLayout();
}
public void RemovingElementInTheMiddleWhileSplitSecond()
{
var rb = new RingBuffer <int>(4)
{
1, 2, 3, 4
};
rb.RemoveFront();
rb.RemoveFront();
rb.AddBack(5);
rb.AddBack(6);
rb.RemoveAt(2);
Assert.Equal(3, rb.Count);
Assert.Equal(3, rb[0]);
Assert.Equal(4, rb[1]);
Assert.Equal(6, rb[2]);
}
public void ShouldNotPublishEventsThreeArgIfBatchIsLargerThanRingBuffer()
{
var ringBuffer = RingBuffer <object[]> .CreateSingleProducer(() => new object[1], 4);
IEventTranslatorThreeArg <object[], string, string, string> translator = new ThreeArgEventTranslator();
try
{
Assert.Throws <ArgumentException>(() => ringBuffer.TryPublishEvents(
translator,
new[] { "Foo", "Foo", "Foo", "Foo", "Foo" },
new[] { "Bar", "Bar", "Bar", "Bar", "Bar" },
new[] { "Baz", "Baz", "Baz", "Baz", "Baz" }));
}
finally
{
AssertEmptyRingBuffer(ringBuffer);
}
}
public Session(Socket socket, int buffersize, bool enableMultiBytes)
{
this.socket = socket;
this.buffersize = buffersize;
this.enableMultiBytes = enableMultiBytes;
IP = socket.RemoteEndPoint.ToString();
buffer = new byte[buffersize];
queue = new RingBuffer();
if (socket.Connected)
{
try
{
IsClosed = false;
socket.BeginReceive(buffer, 0, buffersize, 0, new AsyncCallback(OnReceived), null);
}
catch (Exception e) { ErrorOccurred?.Invoke(e); }
}
}
public MultiCast1P3CDisruptorPerfTest()
: base(100 * Million)
{
_disruptor = new Disruptor <ValueEvent>(() => new ValueEvent()
, Size
, TaskScheduler.Default
, ProducerType.MULTI
, new YieldingWaitStrategy()
);
_latch = new CountdownEvent(3);
_handler1 = new ValueMutationEventHandler(Operation.Addition, Iterations, _latch);
_handler2 = new ValueMutationEventHandler(Operation.Substraction, Iterations, _latch);
_handler3 = new ValueMutationEventHandler(Operation.And, Iterations, _latch);
_disruptor.HandleEventsWith(_handler1, _handler2, _handler3);
_ringBuffer = _disruptor.GetRingBuffer;
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs args, MessageFlags flags)
{
if (args.SenderNickname == ConnectionManager.MyNickname)
{
return;
}
if (!flags.HasFlag(MessageFlags.UserBanned))
{
HandlePotentialDemoderation(args.Channel, args.SenderNickname, args.Message);
}
if (args.Message.StartsWith(ConnectionManager.CommandManager.Config.CommandPrefix))
{
if (args.Message.TrimEnd().IndexOf(' ') == -1)
{
// starts with a command character and has no spaces
// do not consider this message relevant
return;
}
}
using (var ctx = GetNewContext())
{
if (IsImmune(ctx, args.Channel, args.SenderNickname))
{
return;
}
}
RingBuffer <ChannelMessage> messages = GetOrCreateValue(
ChannelsMessages, args.Channel, chan => new RingBuffer <ChannelMessage>(Config.BacklogSize)
);
messages.Add(new ChannelMessage
{
Nickname = args.SenderNickname,
Username = ConnectionManager.RegisteredNameForNick(args.SenderNickname),
Body = args.Message,
Sanctioned = false
});
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
public void init(string lrsURL, string lrsUser, string lrsPassword, string standardsConfigDefault, string standardsConfigUser, int queueDepth = 1000)
{
// lrs init
this.lrsEndpoint = this.gameObject.AddComponent <RemoteLRSAsync>();
this.lrsEndpoint.initLRS(lrsURL, lrsUser, lrsPassword);
// queue init
this.gblQueue = new RingBuffer <QueuedStatement>(queueDepth);
this.gblReadyToSend = true;
// load the educational standard defaults from: Resources/Data/GBLxAPI_Standards_Default.json
this.standardsJson = null;
try {
string jsonTextDefault = Resources.Load <TextAsset>(standardsConfigDefault).text;
this.standardsJson = JObject.Parse(jsonTextDefault);
}
catch {
Debug.LogError("Missing GBLxAPI default vocabulary! Learning standards cannot be tracked without this file. Run Vocabulary/GBL_Json_Parser.py and ensure that the resulting GBLxAPI_Vocab_Default.json file is moved to the Assets/Resources/Data folder.");
}
// load the user configured standards from: Resources/Data/GBLxAPI_Standards_User.json
JObject standardsJsonUser = null;
try {
string jsonTextUser = Resources.Load <TextAsset>(standardsConfigUser).text;
standardsJsonUser = JObject.Parse(jsonTextUser);
}
catch {
Debug.LogWarning("Missing GBLxAPI vocabulary user overrides. Default vocabulary will be used for learning tracking. To implement user overrides, run Vocabulary/GBL_Json_Parser.py and ensure that the resulting GBLxAPI_Vocab_User.json file is moved to the Assets/Resources/Data folder.");
}
// Merge the two json files, letting the user config overwrite the defaults
if (this.standardsJson != null && standardsJsonUser != null)
{
this.standardsJson.Merge(standardsJsonUser);
}
// reset duration tracking slots
this.ResetDurationSlots();
this.isInit = true;
}
unsafe void PullAudioFrameThread()
{
int sampleRate = _sampleRate;
int channels = _channelCount;
var frameType = AUDIO_FRAME_TYPE.FRAME_TYPE_PCM16;
var bytesPerSample = 2; // PCM16
var samplesPerChannel = (int)(sampleRate * _frameDurationMs / 1000.0f);
var frameBufferPointer = Marshal.AllocHGlobal(samplesPerChannel * channels * bytesPerSample);
var pcmBuffer = new float[samplesPerChannel * channels];
_ringBuffer = new RingBuffer <float>(samplesPerChannel * channels * 4); // 4[frames]
var tic = new TimeSpan(DateTime.Now.Ticks);
while (_pullAudioFrame)
{
var toc = new TimeSpan(DateTime.Now.Ticks);
if (toc.Subtract(tic).Duration().Milliseconds >= _frameDurationMs)
{
tic = new TimeSpan(DateTime.Now.Ticks);
_audioRawDataManager.PullAudioFrame(frameBufferPointer, (int)frameType, samplesPerChannel, bytesPerSample, channels, sampleRate, 0, 0);
var span = new ReadOnlySpan <Byte>((void *)frameBufferPointer, samplesPerChannel * channels * bytesPerSample);
// Convert 16bit PCM data bytes to 32bit float PCM data.
for (var i = 0; i < pcmBuffer.Length; i++)
{
pcmBuffer[i] = ConvertBytesToInt16(span.Slice(2 * i)) / 32768f; // The maximum absolute value of Int16 is 32768.
}
lock (_ringBuffer)
{
_ringBuffer.Enqueue(pcmBuffer);
}
}
}
Marshal.FreeHGlobal(frameBufferPointer);
}
public void RemoveTest()
{
foreach (var size in _bufferSizes)
{
Console.WriteLine($"Testing buffer removal for buffer size {size}");
try
{
var buffer = new RingBuffer(size);
FillBufferWithFakeData(buffer, 1316, size);
var data = new byte[1316];
int dataLen;
ulong tstamp;
for (var j = 0; j < size; j++)
{
buffer.Remove(ref data, out dataLen, out tstamp);
if (data[0] != j % 256)
{
Assert.Fail($"Unexpected value after pushing first data through RingBuffer (expected {j % 256}, got {data[0]})");
}
}
const int addCount = 4;
FillBufferWithFakeData(buffer, 1, addCount);
for (var j = 0; j < addCount; j++)
{
buffer.Remove(ref data, out dataLen, out tstamp);
if (data[0] != j)
{
Assert.Fail($"Unexpected value after pushing second data through RingBuffer (expected {j}, got {data[0]}");
}
}
}
catch (Exception ex)
{
Assert.Fail($"Failed AddTest with buffer size {size} - {ex.Message}");
}
}
}
