public void Process(RingBuffer <StrokePoint> data, RingBuffer <int> indices) { float maxThickness = data.GetLatest().thickness; for (int i = 0; i < data.Count; i++) { var currStroke = data.Get(i); float thickness = currStroke.thickness; for (int j = -NEIGHBORHOOD; j <= NEIGHBORHOOD; j++) { int index = i + j; if (index < 0 || index >= data.Count) { continue; } float percent = Mathf.Abs(j) / (NEIGHBORHOOD + 1.0f); thickness = Mathf.Min(thickness, data.Get(index).thickness + percent * maxThickness); } currStroke.thickness = thickness; data.Set(i, currStroke); } }
private Pose getAverage(int start, int end) { if (start == end) { return(buffer.Get(start)); } var sum = Vector3.zero; for (int i = start; i < end; i++) { sum += buffer.Get(i).position; } var avgPos = sum / (end - start); // Try a fractionally-slerped accumulation for "averaging" the rotations. var rot = buffer.Get(start).rotation; var div = 1 / (end - start); for (int i = start + 1; i < end; i++) { rot = Quaternion.Slerp(rot, buffer.Get(i).rotation, div); } return(new Pose(avgPos, rot)); }
private bool DidTapAir(out Vector3 tapPosition) { tapPosition = Vector3.zero; if (!_indexPosBuffer.IsFull) { return(false); } for (int k = 0; k < _heat.Length; k++) { _heat[k] = 0F; } for (int width = MIN_ANALYZE_WIDTH; width <= MAX_ANALYZE_WIDTH; width++) { for (int k = 0; k + width * 2 < _heat.Length; k++) { Vector3 p0 = _indexPosBuffer.Get(k + 0); Vector3 p1 = _indexPosBuffer.Get(k + width); Vector3 p2 = _indexPosBuffer.Get(k + width * 2); // sharpness convolution -> heat Vector3 v01 = (p1 - p0); Vector3 v12 = (p2 - p1); // Vectors must be far enough away (prevents heat on idle finger) float minMag = 0.007F; float sharpness; if (v01.magnitude < minMag && v12.magnitude < minMag) { sharpness = 0F; } else { sharpness = Vector3.Dot(v01.normalized, v12.normalized).Map(0.6F, 1F, 1F, 0F); } float a = 0.5F; for (int w = 0; w < width * 2; w++) { _heat[k + w] += sharpness * a * (w <= width * 2 ? (w / (width)) : (1 - ((w - width) / width))); // upside-down V, domain [0, width], range [0, 1] } } } int tapIndex = POSITION_BUFFER_WIDTH / 2; bool tapDetected = _heat[tapIndex] > TAP_HEAT_THRESHOLD; if (tapDetected) { tapPosition = _indexPosBuffer.Get(tapIndex); } return(tapDetected); }
public void Should_Publish_Event() { _ringBuffer.AddGatingSequences(new NoOpEventProcessor <LongEvent>(_ringBuffer).GetSequence()); _ringBuffer.PublishEvent(this); _ringBuffer.PublishEvent(this); Assert.Equal(_ringBuffer.Get(0).Value, 29L + 0); Assert.Equal(_ringBuffer.Get(1).Value, 29L + 1); }
public virtual void OnDrawRuntimeGizmos(RuntimeGizmoDrawer drawer) { if (_enableGizmos) { drawer.PushMatrix(); drawer.matrix = this.transform.localToWorldMatrix; drawer.color = Color.green; if (isActivated) { drawer.color = Color.white; } drawer.DrawWireCube(GetActivationVolumeBoxOffset(), GetActivationVolumeBoxBounds()); if (_gizmoColors == null) { _gizmoColors = new RingBuffer <Color>(4); _gizmoColors.Add(Color.red); _gizmoColors.Add(Color.yellow); _gizmoColors.Add(Color.green); _gizmoColors.Add(Color.blue); } for (int i = 0; i < _layers.Length; i++) { drawer.color = _gizmoColors.Get(i); drawer.DrawWireCube(Vector3.up * _layers[i].height, new Vector3(_xWidth - 0.2F, 0.01F, _zWidth - 0.2F)); drawer.DrawWireCube(Vector3.up * _layers[i].height, new Vector3(_xWidth - 0.4F, 0.01F, _zWidth - 0.4F)); drawer.DrawWireCube(Vector3.up * _layers[i].height, new Vector3(_xWidth - 0.6F, 0.01F, _zWidth - 0.6F)); } drawer.PopMatrix(); } }
private void AssertEmptyRingBuffer(RingBuffer <object[]> ringBuffer) { for (var i = 0; i < ringBuffer.GetBufferSize(); i++) { Assert.Null(ringBuffer.Get(i)[0]); } }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); long expectedCount = batchEventProcessor.Sequence.Value + ITERATIONS; handler.Reset(latch, ITERATIONS); Task.Factory.StartNew(() => batchEventProcessor.Run()); Stopwatch start = Stopwatch.StartNew(); RingBuffer <long[]> rb = ringBuffer; for (long i = 0; i < ITERATIONS; i++) { long next = rb.Next(); long[] @event = rb.Get(next); for (int j = 0; j < @event.Length; j++) { @event[j] = i; } rb.Publish(next); } latch.Wait(); long opsPerSecond = (ITERATIONS * ARRAY_SIZE * 1000L) / (start.ElapsedMilliseconds); waitForEventProcessorSequence(expectedCount); batchEventProcessor.Halt(); PerfTestUtil.failIf(0, handler.Value); return(opsPerSecond); }
public void Get_Number_ReturnSecondNumber() { // arrange var array = new int[6]; var circularBuffer = new RingBuffer <int>(array); // act circularBuffer.Put(20); circularBuffer.Put(21); var firstNumber = circularBuffer.Get(); var secondNumber = circularBuffer.Get(); // assert Assert.That(firstNumber, Is.EqualTo(20)); Assert.That(secondNumber, Is.EqualTo(21)); }
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 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 void Should_Publish_And_Get() { Assert.Equal(Sequence.InitialValue, _ringBuffer.GetCursor()); var expectedEvent = new StubEvent(2701); _ringBuffer.PublishEvent(StubEvent.Translator, expectedEvent.Value, expectedEvent.TestString); var sequence = _barrier.WaitFor(0L); Assert.Equal(0L, sequence); var @event = _ringBuffer.Get(sequence); Assert.Equal(expectedEvent, @event); Assert.Equal(0L, _barrier.GetCursor()); }
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); } }
private void RefreshRenderTrail() { Vector3 endPosition = _lastStrokeBuffer.GetLatest().position; for (int i = 0; i < _lastStrokeBuffer.Count; i++) { StrokePoint strokePoint = _lastStrokeBuffer.Get(i); MeshPoint point = new MeshPoint(strokePoint.position); point.Normal = strokePoint.normal; point.Color = strokePoint.color; if (i > _ribbon.Points.Count - 1) { _ribbon.Add(point, strokePoint.thickness); } else { // Offset from most recent + decay Vector3 offsetFromEndPosition = endPosition - point.Position; Vector3 targetOffset = (offsetFromEndPosition * (1 - _thicknessDecayMultiplier)); if (i > _prevDrawOffsets.Count - 1) { _prevDrawOffsets.Add(targetOffset); } point.Position = point.Position + Vector3.Slerp(_prevDrawOffsets[i], targetOffset, 0.1F); _prevDrawOffsets[i] = Vector3.Slerp(_prevDrawOffsets[i], targetOffset, 0.1F); _ribbon.Points[i] = point; // Thickness + decay int maxBufferSize = 16; //int effBufferSize = Mathf.Min(maxBufferSize, _lastStrokeBuffer.Size - 1); float thicknessCurveEvalPos = Mathf.Min(1F, (float)(_lastStrokeBuffer.Count - 1 - i) / maxBufferSize); // ([0-16]) / 8 --> 0, 1/8, 2/8, ... 1, 1, 1 float targetThickness = 0F; if (_lastStrokeBuffer.Count > 1) { targetThickness = strokePoint.thickness * previewThicknessCurve.Evaluate(thicknessCurveEvalPos) * _thicknessDecayMultiplier; } if (i > _prevDrawRadii.Count - 1) { _prevDrawRadii.Add(targetThickness); } if (_lastStrokeBuffer.Count - 1 - i < maxBufferSize) { _ribbon.Radii[i] = Mathf.Lerp(_prevDrawRadii[i], targetThickness, 0.05F); } else { _ribbon.Radii[i] = 0F; } _prevDrawRadii[i] = _ribbon.Radii[i]; } } SetMeshDataFromRibbon(_mesh, _ribbon); }
public void Get_DefaultValue_ReturnException() { // arrange var array = new int[6]; var circularBuffer = new RingBuffer <int>(array); // act // assert Assert.That(() => circularBuffer.Get(), Throws.InvalidOperationException); }
void PushAudioFrameThread() { var bytesPerSample = 2; var type = AUDIO_FRAME_TYPE.FRAME_TYPE_PCM16; var channels = CHANNEL; var samples = SAMPLE_RATE / PUSH_FREQ_PER_SEC; var samplesPerSec = SAMPLE_RATE; var buffer = new byte[samples * bytesPerSample * CHANNEL]; var freq = 1000 / PUSH_FREQ_PER_SEC; var tic = new TimeSpan(DateTime.Now.Ticks); while (_pushAudioFrameThreadSignal) { if (!_startSignal) { tic = new TimeSpan(DateTime.Now.Ticks); } var toc = new TimeSpan(DateTime.Now.Ticks); if (toc.Subtract(tic).Duration().Milliseconds >= freq) { tic = new TimeSpan(DateTime.Now.Ticks); lock (audioBuffer) { if (audioBuffer.Size > samples * bytesPerSample * CHANNEL) { for (var j = 0; j < samples * bytesPerSample * CHANNEL; j++) { buffer[j] = audioBuffer.Get(); } var audioFrame = new AudioFrame { bytesPerSample = bytesPerSample, type = type, samples = samples, samplesPerSec = samplesPerSec, channels = channels, buffer = buffer, renderTimeMs = DateTime.Now.Ticks }; mRtcEngine.PushAudioFrame(audioFrame); } else { AppendRingBuffer(); } } } } }
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 Test_Ring_Buffer() { var buffer = new RingBuffer <string>(3); buffer.Put("A"); buffer.Put("B"); Assert.AreEqual(buffer.Get().Count, 2); Assert.AreEqual(buffer.GetFirst(), "A"); Assert.AreEqual(buffer.GetLast(), "B"); buffer.Put("C"); Assert.AreEqual(buffer.Get().Count, 3); Assert.AreEqual(buffer.GetFirst(), "A"); Assert.AreEqual(buffer.GetLast(), "C"); buffer.Put("D"); Assert.AreEqual(buffer.Get().Count, 3); Assert.AreEqual(buffer.GetLast(), "D"); Assert.AreEqual(buffer.GetFirst(), "B"); }
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 bool RingBufferWithEvents(params dynamic[] events) { var len = events.Length; var actualValues = new dynamic[len]; var expectedValues = new dynamic[len]; for (var i = 0; i < len; i++) { actualValues[i] = events[i][0]; expectedValues[i] = _ringBuffer.Get(i)[0]; } return(expectedValues.SequenceEqual(actualValues)); }
protected sealed override bool TryGetNextMessage(out IMessage pMessage) { lock (_messages) { if (!_messages.IsEmpty) { pMessage = _messages.Get(); return(true); } } pMessage = default; return(false); }
public List <StubEvent> Call() { _barrier.SignalAndWait(); _sequenceBarrier.WaitFor(_toWaitForSequence); var messages = new List <StubEvent>(); for (long l = _initialSequence; l <= _toWaitForSequence; l++) { messages.Add(_ringBuffer.Get(l)); } return(messages); }
public void Process(RingBuffer <StrokePoint> data, RingBuffer <int> indices) { Debug.Log("Data size is " + data.Count); StringBuilder sb = new StringBuilder(); for (int i = 0; i < data.Count; i++) { sb.Append("Ring buffer " + i + " from end: "); sb.Append(data.GetFromEnd(i)); sb.Append(" corresponds to data index " + indices.Get(data.Count - 1 - i)); sb.Append("\n"); } Debug.Log(sb.ToString()); }
private void OnAudioRead(float[] data) { if (!_startSignal) { return; } for (var i = 0; i < data.Length; i++) { lock (audioBuffer) { data[i] = audioBuffer.Get(); readCount += 1; } } // Debug.Log("buffer length remains: {0}", writeCount - readCount); }
// shouldUpdateRenderers provides an optimization for updating multiple stroke points at once, // where it's more efficient to do the updating without rendering and then refreshing renderers // at the end. private void UpdateStroke(StrokePoint strokePoint, bool shouldUpdateRenderers = true) { _strokeBuffer.Add(strokePoint); _actualizedStrokeIdxBuffer.Add(-1); // Apply all filters in order on current stroke buffer. for (int i = 0; i < _strokeFilters.Count; i++) { _strokeFilters[i].Process(_strokeBuffer, _actualizedStrokeIdxBuffer); } if (_isActualizingStroke) { _actualizedStrokeIdxBuffer.SetLatest(_actualizedStrokeIdx++); // Output points from the buffer to the actualized stroke output. int offset = Mathf.Min(_outputBufferEndOffset, _strokeBuffer.Count - 1); for (int i = 0; i <= offset; i++) { int outputIdx = Mathf.Max(0, _outputBufferEndOffset - (_strokeBuffer.Count - 1)) + i; StrokePoint bufferStrokePoint = _strokeBuffer.Get(_strokeBuffer.Count - 1 - (Mathf.Min(_strokeBuffer.Count - 1, _outputBufferEndOffset) - i)); if (outputIdx > _strokeOutput.Count - 1) { _strokeOutput.Add(bufferStrokePoint); } else { _strokeOutput[outputIdx] = bufferStrokePoint; } } _outputBufferEndOffset += 1; // Refresh stroke renderers. if (shouldUpdateRenderers) { UpdateStrokeRenderers(); } } // Refresh stroke preview renderers. if (shouldUpdateRenderers) { UpdateStrokeBufferRenderers(); } }
public void run() { try { cyclicBarrier.SignalAndWait(); for (long i = 0; i < iterations; i++) { long sequence = ringBuffer.Next(); ValueEvent @event = ringBuffer.Get(sequence); @event.Value = (i); ringBuffer.Publish(sequence); } } catch (Exception ex) { throw; } }
protected override long RunDisruptorPass() { resetCounters(); RingBuffer <ValueEvent> ringBuffer = workerPool.start(TaskScheduler.Default); var start = Stopwatch.StartNew(); for (long i = 0; i < ITERATIONS; i++) { long sequence = ringBuffer.Next(); ringBuffer.Get(sequence).Value = i; ringBuffer.Publish(sequence); } workerPool.drainAndHalt(); long opsPerSecond = (ITERATIONS * 1000L) / start.ElapsedMilliseconds; PerfTestUtil.failIfNot(ITERATIONS, sumCounters()); return(opsPerSecond); }
public void OnDrawRuntimeGizmos(RuntimeGizmoDrawer drawer) { if (!this.enabled || !this.gameObject.activeInHierarchy || !drawDebug) { return; } drawer.color = LeapColor.purple; var poseRadius = 0.004f; if (!Application.isPlaying) { _debugPoseBuffer.Clear(); _debugPoseBuffer.Add(GetTipPose()); _debugActivatedBuffer.Clear(); _debugActivatedBuffer.Add(false); } for (int i = 0; i < _debugPoseBuffer.Count; i++) { var pose = _debugPoseBuffer.Get(i); var isActive = _debugActivatedBuffer.Get(i); var a = pose.position + pose.rotation * Vector3.right * radius; var b = pose.position - pose.rotation * Vector3.right * radius; var multiplier = 1f; if (isActive) { multiplier = 2.5f; } if (isActive || drawDebugIdlePaths || !Application.isPlaying) { drawer.DrawPose(new Pose(a, pose.rotation), poseRadius * multiplier); drawer.DrawPose(new Pose(b, pose.rotation), poseRadius * multiplier); } } }
public void run() { try { cyclicBarrier.SignalAndWait(); for (long i = 0; i < iterations; i++) { long sequence = ringBuffer.Next(); long[] @event = ringBuffer.Get(sequence); for (int j = 0; j < arraySize; j++) { @event[j] = i + j; } ringBuffer.Publish(sequence); } } catch (Exception ex) { throw; } }
protected override long RunDisruptorPass() { CountdownEvent latch = new CountdownEvent(1); //ManualResetEvent latch = new ManualResetEvent(false); long expectedCount = batchEventProcessor.Sequence.Value + ITERATIONS * BATCH_SIZE; handler.reset(latch, expectedCount); Task.Factory.StartNew(() => batchEventProcessor.Run() , CancellationToken.None , TaskCreationOptions.LongRunning , new LimitedConcurrencyLevelTaskScheduler(4)); //ThreadPool.QueueUserWorkItem(o=>batchEventProcessor.Run()); Stopwatch start = Stopwatch.StartNew(); RingBuffer <ValueEvent> rb = ringBuffer; for (long i = 0; i < ITERATIONS; i++) { long hi = rb.Next(BATCH_SIZE); long lo = hi - (BATCH_SIZE - 1); for (long l = lo; l <= hi; l++) { rb.Get(l).Value = i; } rb.Publish(lo, hi); } latch.Wait(); long opsPerSecond = (BATCH_SIZE * ITERATIONS * 1000L) / (start.ElapsedMilliseconds); waitForEventProcessorSequence(expectedCount); batchEventProcessor.Halt(); Console.WriteLine("expectedResult={0:###,###,###},realValue={1:###,###,###}", expectedResult, handler.Value); PerfTestUtil.failIfNot(expectedResult, handler.Value); return(opsPerSecond); }
private void timer2_Tick(object sender, EventArgs e) { for (int i = 0; i < rxbuffer.Size; i++) { sw_read.Write(rxbuffer.Get()); } for (int j = 0; j < txbuffer.Size; j++) { sw_write.Write(txbuffer.Get()); } if (counter != 0 & progressBar1.Maximum > counter) { progressBar1.Value = counter; } if (isTestCompleted) { timer2.Stop(); sw_read.Close(); sw_write.Close(); fs_write.Close(); fs_read.Close(); progressBar1.Value = progressBar1.Maximum; } }
public void Run() { try { cyclicBarrier.SignalAndWait(); for (long i = 0; i < iterations; i += batchSize) { long hi = ringBuffer.Next(batchSize); long lo = hi - (batchSize - 1); for (long l = lo; l <= hi; l++) { ValueEvent @event = ringBuffer.Get(l); @event.Value = (l); } ringBuffer.Publish(lo, hi); } //Console.WriteLine( "尚未到达的参与者 "+cyclicBarrier.ParticipantsRemaining+" 已到达 "+cyclicBarrier.CurrentPhaseNumber); } catch (Exception ex) { throw new ApplicationException(); } }
/// <summary> /// Get the event for a given sequence in the RingBuffer. /// </summary> /// <param name="sequence">for the event.</param> public T this[long sequence] => _ringBuffer.Get(sequence);
public void ThrowsError_GetEmpty() { RingBuffer<byte> buffer = new RingBuffer<byte>(); byte _tmp = buffer.Get(); }