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