/// <summary>
/// Called from Frame Sequencer clocks
/// </summary>
public void FreqTimerStep( )
{
m_timer -= 4;
if (m_timer <= 0)
{
// Note: shifts of 14 and 15 have no operation
if (m_shiftFreq < 14)
{
int result = (m_linearShiftReg & 0x1) ^ ((m_linearShiftReg >> 1) & 0x1);
m_linearShiftReg >>= 1;
m_linearShiftReg |= result << 14;
if (m_stepsMode == 1)
{
m_linearShiftReg &= ~0x40; // clear bit 6
m_linearShiftReg |= result << 6;
}
}
// Reload Frequency
m_timer += CalcFrequency();
}
// Update filter buffer
m_samplesToFilterL.Dequeue();
m_samplesToFilterL.Enqueue(SampleL());
m_samplesToFilterR.Dequeue();
m_samplesToFilterR.Enqueue(SampleR());
}
public void TestForSeveralEnqueuesAndDequeues()
{
CircularBuffer <int> testData = new CircularBuffer <int>(5);
int item1 = 6;
int item2 = 8;
int item3 = 10;
int item4 = 15;
int item5 = 22;
int item6 = 25;
int item7 = 33;
testData.Enqueue(item1);
testData.Enqueue(item2);
testData.Enqueue(item3);
testData.Enqueue(item4);
testData.Enqueue(item5);
testData.Dequeue();
testData.Dequeue();
testData.Enqueue(item6);
testData.Enqueue(item7);
int actual = testData.Dequeue();
int expected = 10;
Assert.Equal(expected, actual);
}
public void RemoveAtTest()
{
var buffer = new CircularBuffer <long>(5);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(default(long), buffer.Enqueue(4));
Assert.AreEqual(default(long), buffer.Enqueue(5));
buffer.RemoveAt(buffer.IndexOf(2));
buffer.RemoveAt(buffer.IndexOf(4));
Assert.AreEqual(3, buffer.Count);
Assert.AreEqual(1, buffer.Dequeue());
Assert.AreEqual(3, buffer.Dequeue());
Assert.AreEqual(5, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(default(long), buffer.Enqueue(4));
Assert.AreEqual(default(long), buffer.Enqueue(5));
buffer.RemoveAt(buffer.IndexOf(1));
buffer.RemoveAt(buffer.IndexOf(3));
buffer.RemoveAt(buffer.IndexOf(5));
Assert.AreEqual(2, buffer.Count);
Assert.AreEqual(2, buffer.Dequeue());
Assert.AreEqual(4, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
}
public void TestUnderwrite()
{
var buffer = new CircularBuffer<long>(5);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(3, buffer.Count);
Assert.AreEqual(1, buffer.Dequeue());
Assert.AreEqual(2, buffer.Dequeue());
Assert.AreEqual(3, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
}
public void UnderwriteTest()
{
var buffer = new CircularBuffer <long>(5);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(3, buffer.Count);
Assert.AreEqual(1, buffer.Dequeue());
Assert.AreEqual(2, buffer.Dequeue());
Assert.AreEqual(3, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
}
public void TestDecreaseCapacityWhenFull()
{
var buffer = new CircularBuffer<long>(3);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(3, buffer.Count);
buffer.Capacity = 2;
Assert.AreEqual(2, buffer.Count);
Assert.AreEqual(1, buffer.Dequeue());
Assert.AreEqual(2, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
}
public void DecreaseCapacityWhenFullTest()
{
var buffer = new CircularBuffer <long>(3);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(3, buffer.Count);
buffer.Capacity = 2;
Assert.AreEqual(2, buffer.Count);
Assert.AreEqual(1, buffer.Dequeue());
Assert.AreEqual(2, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
}
public void OverwriteQueue()
{
CircularBuffer <float> queue = new CircularBuffer <float>(5);
float[] values = new float[5];
int i = 0;
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(5);
queue.Enqueue(6);
queue.Enqueue(7);
while (!queue.IsEmpty)
{
values[i] = queue.Dequeue();
i++;
}
Assert.AreEqual(values[0], 3);
Assert.AreEqual(values[1], 4);
Assert.AreEqual(values[2], 5);
Assert.AreEqual(values[3], 6);
Assert.AreEqual(values[4], 7);
}
void Plot_Dados(object status)
{
while (Loopear)
{
if (!circularBuffer.IsEmpty)
{
int N_amostras = circularBuffer.SamplesToRead;
for (int i = 0; i < N_amostras; i++)
{
Tempo += (1 / Fa);
//Console.WriteLine(circularBuffer.Dequeue());
this.chartSinal.Invoke(new Action(() =>
{
chartSinal.Series[0].Points.AddXY(Tempo, circularBuffer.Dequeue());
if (Tempo > chartSinal.ChartAreas[0].AxisX.Maximum)
{
//chartSinal.Series[0].Points.RemoveAt(0);
//chartSinal.ChartAreas[0].AxisX.Maximum += (1 / Fa);
chartSinal.ChartAreas[0].AxisX.Minimum = chartSinal.ChartAreas[0].AxisX.Maximum;
chartSinal.ChartAreas[0].AxisX.Maximum += T_Janela;
}
}));
}
}
}
}
/// <summary>
/// Get data from quat after processing
/// </summary>
/// <returns></returns>
public double[] HandleQuat()
{
double[] quat = new double[4];
quat = ConvertToDouble(circularBufferQ.Dequeue());
//double[] ang = toEuler(quat); //get values in angle
return(quat);
}
private double processRate(int size, string queue)
{
CircularBuffer <IMessage> buffer = new CircularBuffer <IMessage>(100);
IMessageListener listener = new SyncListener(buffer);
string localQueue = "queue-" + UUID.RandomUuid();
Session.QueueDeclare(localQueue, null, null, Option.AUTO_DELETE);
Session.ExchangeBind(localQueue, "amq.direct", queue);
Session.AttachMessageListener(listener, localQueue);
Session.MessageSubscribe(localQueue);
double rate = 0;
RangeSet range = new RangeSet();
for (int i = 0; i < size; ++i)
{
IMessage m = buffer.Dequeue();
range.Add(m.Id);
BinaryReader reader = new BinaryReader(m.Body, Encoding.UTF8);
byte[] body = new byte[m.Body.Length - m.Body.Position];
reader.Read(body, 0, body.Length);
rate += BitConverter.ToDouble(body, 0);
}
Session.MessageAccept(range);
return(rate);
}
public T Get()
{
if (_availables.Count == 0)
{
Reclaim();
Debug.WriteLine("Everything is given out, reclaiming. Perhaps raise capacity!");
}
return(_availables.Dequeue());
}
void Update()
{
if (!isLocalPlayer)
{
return;
}
playbackDelay += Time.deltaTime;
if (isTransmitting)
{
int currentPos = Microphone.GetPosition(null);
int diff = currentPos - lastPos;
int partitionSize = recordFrequency / cBuffer.BufferLength;
if (currentPos < lastPos)
{
diff = recordFrequency - lastPos + currentPos - 1;
}
if (diff >= partitionSize)
{
sampleBuffer = new float[diff * aud.clip.channels];
aud.clip.GetData(sampleBuffer, lastPos);
cBuffer.Enqueue(sampleBuffer);
lastPos = currentPos;
}
if (!cBuffer.IsEmpty)
{
if (playbackDelay >= 0.05f)
{
byte[] sampleBytes = new byte[sampleBuffer.Length * 4];
sampleBytes = VoiceUtils.Compress(cBuffer.Dequeue());
CmdStopRecording(sampleBytes);
playbackDelay = 0;
}
}
}
if (Input.GetKeyDown(KeyCode.O))
{
Debug.Log("Recording started.");
StartRecording();
}
if (Input.GetKeyDown(KeyCode.P))
{
Microphone.End(null);
Debug.Log("Recording ended.");
isTransmitting = false;
}
}
public void DequeueFromEmpty()
{
CircularBuffer <float> queue = new CircularBuffer <float>(5);
try {
queue.Dequeue();
} catch (Exception error) {
Assert.AreEqual(error.Message, "Queue is empty.");
}
}
public void EmptyQueueTest()
{
CircularBuffer <int> testData = new CircularBuffer <int>(16);
//is.Count = 0;
//_rear + 1 == _front;
//testData.Count = 0;
//var actual = testData.Dequeue();
//var expected = "The buffer is empty";
Assert.Throws <InvalidOperationException>(() => testData.Dequeue());
}
public void EnqueueItemDequeueItem()
{
CircularBuffer <int> testData = new CircularBuffer <int>(16);
int item = 5;
testData.Enqueue(item);
int actual = testData.Dequeue();
int expected = 5;
Assert.Equal(expected, actual);
}
/// <summary>
/// Restores the results of the previous scan.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown if no previous results are present.</exception>
public void UndoLastScan()
{
if (!CanUndoLastScan)
{
throw new InvalidOperationException();
}
var store = stores.Dequeue();
store?.Dispose();
}
public void EnqueueFiveDequeueThreeItemsReturnValue()
{
CircularBuffer <int> testData = new CircularBuffer <int>(6);
int item1 = 6;
int item2 = 8;
int item3 = 10;
int item4 = 15;
int item5 = 22;
testData.Enqueue(item1);
testData.Enqueue(item2);
testData.Enqueue(item3);
testData.Enqueue(item4);
testData.Enqueue(item5);
testData.Dequeue();
testData.Dequeue();
int actual = testData.Dequeue();
int expected = 10;
Assert.Equal(expected, actual);
}
void Update()
{
var now = Time.time;
var earliestTInGraph = now - GraphWidthInSeconds;
_drawPoints.Clear();
_drawPoints.Add(FloatsToGraphVector(0, _earliestShownValue));
bool firstvalueFound = false;
int dequeueCount = 0;
for (int i = 0; i < DataPoints.Count; i++)
{
var point = DataPoints[i];
if (point.TimeStamp < earliestTInGraph)
{
dequeueCount++; // Out of range
continue;
}
if (!firstvalueFound && i - 1 >= 0)
{
firstvalueFound = true;
var prevPoint = DataPoints[i - 1];
var normNow = Mathf.InverseLerp(prevPoint.TimeStamp, point.TimeStamp, now);
_earliestShownValue = Mathf.Lerp(prevPoint.Value, point.Value, normNow);
_drawPoints[0] = FloatsToGraphVector(0, _earliestShownValue);
}
var normTime = (point.TimeStamp - earliestTInGraph) / (now - earliestTInGraph);
var normValue = point.Value;
_drawPoints.Add(FloatsToGraphVector(normTime, normValue));
if (i + 1 == DataPoints.Count)
{
_lastValue = point.Value;
}
}
for (int i = 0; i < dequeueCount; i++)
{
DataPoints.Dequeue();
}
var currentTimePoint = FloatsToGraphVector(1, _lastValue);
_drawPoints.Add(currentTimePoint);
// Copy to a cached array to prevent gc.
_drawPoints.CopyTo(_drawArray);
Renderer.positionCount = _drawPoints.Count;
// Positions > positionCount are simply not used.
Renderer.SetPositions(_drawArray);
}
public Property CircularBuffer_dequeue_after_enqueue_should_return_original_item(CircularBuffer <int> buffer,
int[] itemsToAdd)
{
for (var i = 0; i < itemsToAdd.Length; i++)
{
buffer.Enqueue(itemsToAdd[i]);
var dequeue = buffer.Dequeue();
if (dequeue != itemsToAdd[i])
{
return(false.When(buffer.Capacity > 0).Label($"Failed with {buffer}"));
}
}
return(true.ToProperty());
}
private void process(int size, string queue)
{
CircularBuffer <IMessage> buffer = new CircularBuffer <IMessage>(100);
IMessageListener listener = new SyncListener(buffer);
string localQueue = "queue-" + UUID.RandomUuid();
Session.QueueDeclare(localQueue, null, null, Option.AUTO_DELETE);
Session.ExchangeBind(localQueue, "amq.direct", queue);
Session.AttachMessageListener(listener, localQueue);
Session.MessageSubscribe(localQueue);
for (int i = 0; i < size; ++i)
{
buffer.Dequeue();
}
}
//清空缓存中的消息，必须在当前帧进行处理，超过当前帧可能会造成下一帧的数据错误
public void FlushPacketQueue()
{
int time = CDataModel.InputEvent.Milliseconds();
while (!sendPacketQueue.IsEmpty)
{
var packet = sendPacketQueue.Peek();
if (packet.release >= time) //延迟操作
{
break;
}
sendPacketQueue.Dequeue();
updSocket.SendMsg(packet.packet.Data, packet.packet.CurSize, packet.to);
}
}
public void EnqueueThreeDequeueOneReturnValue()
{
CircularBuffer <int> testData = new CircularBuffer <int>(16);
int item1 = 6;
int item2 = 8;
int item3 = 22;
testData.Enqueue(item1);
testData.Enqueue(item2);
testData.Enqueue(item3);
int actual = testData.Dequeue();
int expected = 6;
Assert.Equal(expected, actual);
}
public bool Dequeue(out T item)
{
if (queue.Count > 0)
{
lock (queue) {
if (queue.Count > 0)
{
item = queue.Dequeue();
return(true);
}
}
}
item = default(T);
return(false);
}
public void DequeueThreeFloats()
{
CircularBuffer <float> queue = new CircularBuffer <float>(5);
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
while (!queue.IsEmpty)
{
queue.Dequeue();
}
Assert.AreEqual(queue.Length, 0);
}
public void setHeaders()
{
_log.Debug("Running: setHeaders");
IClientSession ssn = Client.CreateSession(0);
ssn.QueueDeclare("queue1");
ssn.ExchangeBind("queue1", "amq.direct", "queue1");
ssn.Sync();
CircularBuffer<IMessage> buff = new CircularBuffer<IMessage>(10);
SyncListener listener = new SyncListener(ssn, buff);
ssn.AttachMessageListener(listener, "queue1");
ssn.MessageSubscribe("queue1");
IMessage message = new org.apache.qpid.client.Message();
message.DeliveryProperties.SetRoutingKey("queue1");
const long someLong = 14444444;
message.ApplicationHeaders.Add("someLong", someLong);
const int someInt = 14;
message.ApplicationHeaders.Add("soneInt", someInt);
const float someFloat = 14.001F;
message.ApplicationHeaders.Add("soneFloat", someFloat);
const double someDouble = 14.5555555;
message.ApplicationHeaders.Add("someDouble", someDouble);
const byte someByte = 2;
message.ApplicationHeaders.Add("someByte", someByte);
const string someString = "someString";
message.ApplicationHeaders.Add("someString", someString);
const char someChar = 'a';
message.ApplicationHeaders.Add("someChar", someChar);
const Boolean someBoolean = true;
message.ApplicationHeaders.Add("someBoolean", someBoolean);
// transfer the message
ssn.MessageTransfer("amq.direct", message);
// get the message and check the headers
IMessage messageBack = buff.Dequeue();
Assert.IsTrue(((string) messageBack.ApplicationHeaders["someString"]).Equals(someString));
Assert.IsTrue(((char)messageBack.ApplicationHeaders["someChar"]).Equals(someChar));
Assert.IsTrue((long)messageBack.ApplicationHeaders["someLong"] == someLong);
Assert.IsTrue((int)messageBack.ApplicationHeaders["soneInt"] == someInt);
Assert.IsTrue((double)messageBack.ApplicationHeaders["someDouble"] == someDouble);
Assert.IsTrue((byte) messageBack.ApplicationHeaders["someByte"] == someByte);
Assert.IsTrue((Boolean)messageBack.ApplicationHeaders["someBoolean"]);
// c# has an conversion precision issue with decimal
Assert.IsTrue((float) messageBack.ApplicationHeaders["soneFloat"] <= someFloat);
float b = (float) messageBack.ApplicationHeaders["soneFloat"];
Assert.IsTrue(Convert.ToInt32(b) == Convert.ToInt32(someFloat));
}
public void CircularBuffer_Dequeue()
{
int[] data = { 0, 1, 2, 3 };
var buffer = new CircularBuffer<int>(data.Length);
buffer.EnqueueRange(data, 0, data.Length);
buffer.Dequeue();
Assert.AreEqual(3, buffer.Count);
Assert.AreEqual(data.Length, buffer.Capacity);
Assert.AreEqual(1, buffer.Head);
Assert.AreEqual(0, buffer.Tail);
Assert.IsTrue(buffer.Contains(1));
Assert.IsFalse(buffer.Contains(0));
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, buffer.ToArray());
}
//private void ProcessRecvData(int dataStartOffset, int totalReceivedDataSize, int alreadyProcessedDataSize, AsyncUserToken token, SocketAsyncEventArgs e)
//{
// if (ReceivedPackets)
// ReceivedPackets = false;
// if (alreadyProcessedDataSize >= totalReceivedDataSize)
// {
// return;
// }
// if (token.MessageSize == null || token.MessageID == null)
// {
// if (totalReceivedDataSize > HEADER_SIZE)
// {
// Buffer.BlockCopy(e.Buffer, dataStartOffset, _headerBuffer, 0, HEADER_SIZE);
// var messageID = _headerBuffer[0];
// var messageSize = (ushort)((_headerBuffer[2] << 8) | _headerBuffer[1]);
// token.MessageID = messageID;
// token.MessageSize = messageSize - HEADER_SIZE;
// token.DataStartOffset = dataStartOffset + HEADER_SIZE;
// ProcessRecvData(token.DataStartOffset, totalReceivedDataSize, alreadyProcessedDataSize + HEADER_SIZE, token, e);
// }
// }
// else
// {
// int messageSize = token.MessageSize.Value;
// if (totalReceivedDataSize - alreadyProcessedDataSize >= messageSize)
// {
// byte[] data = new byte[messageSize];
// Buffer.BlockCopy(e.Buffer, dataStartOffset, data, 0, messageSize);
// // process message
// Packet packet = new Packet(data, token.MessageID.Value, messageSize);
// PacketHandlers.Handlers.OnPacket(packet);
// token.DataStartOffset = dataStartOffset + messageSize;
// token.MessageID = null;
// token.MessageSize = null;
// //_pool.AddFreeSegment(data);
// ProcessRecvData(token.DataStartOffset, totalReceivedDataSize, alreadyProcessedDataSize + messageSize, token, e);
// }
// }
//}
private void HandleReceive()
{
if (!IsRunning || _buffer == null || _buffer.Length <= 0)
{
return;
}
lock (_buffer)
{
ReceivedPackets = false;
int length = _buffer.Length;
while (length > 0 && IsRunning)
{
byte id = _buffer.GetId();
int size = _buffer.GetLength();
if (size < 3)
{
NetworkManager.Disconnect(false);
break;
}
if (length < size)
{
break;
}
byte[] packet = 4096 >= size?_pool.GetFreeSegment() : new byte[size];
size = _buffer.Dequeue(packet, 0, size);
Packet p = new Packet(packet, id, size);
PacketHandlers.Handlers.OnPacket(p);
length = _buffer.Length;
if (4096 >= size)
{
_pool.AddFreeSegment(packet);
}
ReceivedPackets = true;
}
}
}
public ControllerState GetState()
{
// see if new real state came in since last check
if (_realStateUpdated)
{
var rts = _pool.Get();
rts.SetState(_sw.Elapsed, _realState.Axes, _realState.Buttons, _realState.Hats);
_q.Enqueue(rts);
_realStateUpdated = false;
}
if (Method == DelayMethod.Task)
{
return(_taskDelayedState);
}
else if (_q.Count == 0)
{
return(_lastState);
}
// find the first enqueued state that's not older than delay,
// then the previous is our candidate
TimedControllerState ret = _q.Peek();
while (_q.Count > 0 && (_sw.Elapsed - _q.Peek().Time) >= Delay)
{
ret = _q.Dequeue();
_pool.Return(ret);
}
if (ret != null && !ReferenceEquals(ret, _lastState) && (_sw.Elapsed - ret.Time) >= Delay)
{
// Debug.WriteLine("Packet dequeued @ {0}, margin {1}ms",_sw.Elapsed.TotalMilliseconds, (_sw.Elapsed - ret.Time - Delay).TotalMilliseconds);
_lastState = ret;
// found the state, everything older is useless
OnStateUpdated();
}
return(_lastState); // this can happen up to Delay time after the first input arrived*/
}
public void CircularbufferOverRunTest()
{
var v = new CircularBuffer <int>(10);
try
{
v.Dequeue();
Assert.Fail();
}
catch (InvalidOperationException)
{
}
catch (Exception)
{
Assert.Fail();
}
prepareBufferValue(v, new Queue <int>());
try
{
var hoge = v[v.Capacity];
Assert.Fail();
}
catch (IndexOutOfRangeException)
{
}
catch (Exception)
{
Assert.Fail();
}
try
{
var hoge = v[-v.Capacity - 1];
}
catch (IndexOutOfRangeException)
{
}
catch (Exception)
{
Assert.Fail();
}
}
public void BlockingEnqueue()
{
_log.Debug("Running: BlockingEnqueue");
const int size = 10;
_buf = new CircularBuffer<Object>(size);
// add size element anc check that the size +1 add blocks
for (int i = 1; i < size; i++ )
{
_buf.Enqueue(new object());
}
// check tha the buffer is now full
Thread t = new Thread(Go);
t.Start();
Thread.Sleep(100);
// the trhead t should block until an element is dequeued
Assert.IsTrue(t.ThreadState == ThreadState.WaitSleepJoin);
_buf.Dequeue();
// t should now be stopped
Thread.Sleep(100);
Assert.IsTrue(t.ThreadState == ThreadState.Stopped);
}
public void EnqueueDequeue()
{
const int size = 10;
var buff = new CircularBuffer <int>(size);
for (int i = 0; i < size; i++)
{
buff.Enqueue(i);
Assert.Equal(i + 1, buff.Length);
}
for (int i = size; i < 10_000; i++)
{
int dequeued = buff.Dequeue();
Assert.Equal(i - size, dequeued);
Assert.Equal(size - 1, buff.Length);
buff.Enqueue(i);
Assert.Equal(size, buff.Length);
}
}
public void TestForWrappingIndicesOfBuffer()
{
CircularBuffer <int> testData = new CircularBuffer <int>(5);
int item1 = 6;
int item2 = 8;
int item3 = 10;
int item4 = 15;
int item5 = 22;
int item6 = 25;
int item7 = 33;
testData.Enqueue(item1);
testData.Enqueue(item2);
testData.Enqueue(item3);
testData.Enqueue(item4);
testData.Enqueue(item5);
testData.Dequeue();
testData.Enqueue(item6);
bool actual = testData.Enqueue(item7);
Assert.False(actual);
}
private void Go()
{
while (!closed)
{
//MemoryStream st = queue.Dequeue();
byte[] st = queue.Dequeue();
if (st != null)
{
try
{
// int length = (int) st.Length;
// byte[] buf = new byte[length];
// st.Read(buf, 0, length);
bufStream.Write(st, 0, st.Length);
}
catch (Exception e)
{
closed = true;
ioTransport.Connection.On_ReceivedException(this, new ExceptionArgs(e));
}
}
}
}
public void BlockingEnqueue()
{
_log.Debug("Running: BlockingEnqueue");
const int size = 10;
_buf = new CircularBuffer <Object>(size);
// add size element anc check that the size +1 add blocks
for (int i = 1; i < size; i++)
{
_buf.Enqueue(new object());
}
// check tha the buffer is now full
Thread t = new Thread(Go);
t.Start();
Thread.Sleep(100);
// the trhead t should block until an element is dequeued
Assert.IsTrue(t.ThreadState == ThreadState.WaitSleepJoin);
_buf.Dequeue();
// t should now be stopped
Thread.Sleep(100);
Assert.IsTrue(t.ThreadState == ThreadState.Stopped);
}
public void TestRemoveAt()
{
var buffer = new CircularBuffer<long>(5);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(default(long), buffer.Enqueue(4));
Assert.AreEqual(default(long), buffer.Enqueue(5));
buffer.RemoveAt(buffer.IndexOf(2));
buffer.RemoveAt(buffer.IndexOf(4));
Assert.AreEqual(3, buffer.Count);
Assert.AreEqual(1, buffer.Dequeue());
Assert.AreEqual(3, buffer.Dequeue());
Assert.AreEqual(5, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
Assert.AreEqual(default(long), buffer.Enqueue(1));
Assert.AreEqual(default(long), buffer.Enqueue(2));
Assert.AreEqual(default(long), buffer.Enqueue(3));
Assert.AreEqual(default(long), buffer.Enqueue(4));
Assert.AreEqual(default(long), buffer.Enqueue(5));
buffer.RemoveAt(buffer.IndexOf(1));
buffer.RemoveAt(buffer.IndexOf(3));
buffer.RemoveAt(buffer.IndexOf(5));
Assert.AreEqual(2, buffer.Count);
Assert.AreEqual(2, buffer.Dequeue());
Assert.AreEqual(4, buffer.Dequeue());
Assert.AreEqual(0, buffer.Count);
}
public void CircularBuffer_DequeueWhenEmpty()
{
var buffer = new CircularBuffer<string>();
buffer.Dequeue();
}
public void UsageExample()
{
// Create a buffer with a capacity of 5 items.
var buffer = new CircularBuffer<long>(5);
// Add three.
foreach (var i in Enumerable.Range(1, 3))
buffer.Enqueue(i);
Debug.WriteLine(buffer);
// Capacity=5, Count=3, Buffer=[1,2,3]
// Add three more.
foreach (var i in Enumerable.Range(4, 3))
buffer.Enqueue(i);
Debug.WriteLine(buffer);
// Capacity=5, Count=5, Buffer=[2,3,4,5,6]
// Remove the third.
var value = buffer[3];
buffer.RemoveAt(3);
Debug.WriteLine(buffer);
// Capacity=5, Count=4, Buffer=[2,3,4,6]
// Re-insert it.
buffer.Insert(3, value);
Debug.WriteLine(buffer);
// Capacity=5, Count=5, Buffer=[2,3,4,5,6]
// Dequeue.
Debug.Print("Value = {0}", buffer.Dequeue());
// Value = 2
Debug.WriteLine(buffer);
// Capacity=5, Count=4, Buffer=[3,4,5,6]
// Increase the capacity.
buffer.Capacity = 6;
Debug.WriteLine(buffer);
// Capacity=6, Count=4, Buffer=[3,4,5,6]
// Add three more.
foreach (var i in Enumerable.Range(7, 3))
buffer.Enqueue(i);
Debug.WriteLine(buffer);
// Capacity=6, Count=6, Buffer=[4,5,6,7,8,9]
// Reduce the capacity.
buffer.Capacity = 4;
Debug.WriteLine(buffer);
// Capacity=4, Count=4, Buffer=[4,5,6,7]
// Clear the buffer.
buffer.Clear();
Debug.WriteLine(buffer);
// Capacity=4, Count=0, Buffer=[]
}
public override void Start()
{
if (Options.Tx > 0)
{
Session.TxSelect();
Session.Sync();
}
CircularBuffer<IMessage> buffer = new CircularBuffer<IMessage>(100);
// Create a listener and subscribe it to the queue named "message_queue"
IMessageListener listener = new SyncListener(buffer);
string dest = "dest" + UUID.RandomUuid();
Session.AttachMessageListener(listener, dest);
Session.MessageSubscribe(_queue, dest,
Options.Tx > 0 || Options.SubAck > 0
? MessageAcceptMode.EXPLICIT
: MessageAcceptMode.NONE,
MessageAcquireMode.PRE_ACQUIRED, null, 0, null);
// issue credits
Session.MessageSetFlowMode(dest, MessageFlowMode.WINDOW);
Session.MessageFlow(dest, MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
// Notify controller we are ready.
IMessage message = new Message();
message.DeliveryProperties.SetRoutingKey("sub_ready");
message.AppendData(Encoding.UTF8.GetBytes("ready"));
Session.MessageTransfer("amq.direct", message);
if (Options.Tx > 0)
{
Session.TxCommit();
Session.Sync();
}
for (int j = 0; j < Options.Iterations; ++j)
{
//need to allocate some more credit
Session.MessageFlow(dest, MessageCreditUnit.MESSAGE, (long)Options.SubQuota);
RangeSet range = new RangeSet();
IMessage msg;
DateTime start = DateTime.Now;
for (long i = 0; i < Options.SubQuota; ++i)
{
msg = buffer.Dequeue();
if (Options.Tx > 0 && ((i + 1)%Options.Tx == 0))
{
Session.TxCommit();
Session.Sync();
}
if (Options.IntervalSub > 0)
{
Thread.Sleep((int) Options.IntervalSub*1000);
}
range.Add(msg.Id);
}
if (Options.Tx > 0 || Options.SubAck > 0)
Session.MessageAccept(range);
range.Clear();
if (Options.Tx > 0)
{
Session.TxSelect();
Session.Sync();
}
DateTime end = DateTime.Now;
// Report to publisher.
message.DeliveryProperties.SetRoutingKey("sub_done");
message.ClearData();
message.AppendData(BitConverter.GetBytes(Options.SubQuota / end.Subtract(start).TotalMilliseconds ));
Session.MessageTransfer("amq.direct", message);
if (Options.Tx > 0)
{
Session.TxSelect();
Session.Sync();
}
}
Session.Close();
}
public override void Start()
{
byte[] data = new byte[Options.Size];
// randomly populate data
Random r = new Random(34);
r.NextBytes(data);
IMessage message = new Message();
message.AppendData(data);
message.DeliveryProperties.SetRoutingKey(_key);
if (Options.Durable)
message.DeliveryProperties.SetDeliveryMode(MessageDeliveryMode.PERSISTENT);
if (Options.Tx > 0)
{
Session.TxSelect();
Session.Sync();
}
CircularBuffer<IMessage> buffer = new CircularBuffer<IMessage>(100);
// Create a listener and subscribe it to the queue named "pub_start"
IMessageListener listener = new SyncListener(buffer);
string localQueue = "localQueue-" + UUID.RandomUuid().ToString();
Session.QueueDeclare(localQueue, null, null, Option.AUTO_DELETE);
Session.ExchangeBind(localQueue, "amq.direct", "pub_start");
Session.AttachMessageListener(listener, localQueue);
Session.MessageSubscribe(localQueue);
if (Options.Tx > 0)
{
Session.TxCommit();
Session.Sync();
}
buffer.Dequeue();
for (int j = 0; j < Options.Iterations; ++j)
{
DateTime start = DateTime.Now;
for (long i = 0; i < Options.Count; ++i)
{
Session.MessageTransfer(_exchange, message);
if (Options.SyncPub)
{
Session.Sync();
}
if (Options.Tx > 0 && (i + 1)%Options.Tx == 0)
{
Session.TxSelect();
Session.Sync();
}
if (Options.IntervalPub > 0)
{
Thread.Sleep((int) Options.IntervalSub*1000);
}
}
Session.Sync();
DateTime end = DateTime.Now;
// Report to publisher.
message.DeliveryProperties.SetRoutingKey("pub_done");
message.ClearData();
double time = end.Subtract(start).TotalMilliseconds;
byte[] rate = BitConverter.GetBytes( Options.Count / time );
message.AppendData(rate);
Session.MessageTransfer("amq.direct", message);
if (Options.Tx > 0)
{
Session.TxSelect();
Session.Sync();
}
}
Session.Close();
}
private double processRate(int size, string queue)
{
CircularBuffer<IMessage> buffer = new CircularBuffer<IMessage>(100);
IMessageListener listener = new SyncListener(buffer);
string localQueue = "queue-" + UUID.RandomUuid();
Session.QueueDeclare(localQueue, null, null, Option.AUTO_DELETE);
Session.ExchangeBind(localQueue, "amq.direct", queue);
Session.AttachMessageListener(listener, localQueue);
Session.MessageSubscribe(localQueue);
double rate = 0;
RangeSet range = new RangeSet();
for (int i = 0; i < size; ++i)
{
IMessage m = buffer.Dequeue();
range.Add(m.Id);
BinaryReader reader = new BinaryReader(m.Body, Encoding.UTF8);
byte[] body = new byte[m.Body.Length - m.Body.Position];
reader.Read(body, 0, body.Length);
rate += BitConverter.ToDouble(body,0);
}
Session.MessageAccept(range);
return rate;
}
private void process(int size, string queue)
{
CircularBuffer<IMessage> buffer = new CircularBuffer<IMessage>(100);
IMessageListener listener = new SyncListener(buffer);
string localQueue = "queue-" + UUID.RandomUuid();
Session.QueueDeclare(localQueue, null, null, Option.AUTO_DELETE);
Session.ExchangeBind(localQueue, "amq.direct", queue);
Session.AttachMessageListener(listener, localQueue);
Session.MessageSubscribe(localQueue);
for (int i = 0; i < size; ++i)
{
buffer.Dequeue();
}
}
