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