////////// private Stopwatch sw = new Stopwatch();
/// <summary>
/// Handler for DataReceived event of serial port, stores received bytes to ring buffer
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Port_DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
{
////////// sw.Start();
int n_bytes = Port.BytesToRead;
#if true
for (int i = 0; i < n_bytes; i++)
{
int value = Port.ReadByte();
if (value != -1)
{
Buffer.Enqueue(Convert.ToByte(value));
}
}
#endif
#if false
byte[] buffer = new byte[n_bytes];
Port.Read(buffer, 0, n_bytes);
foreach (byte b in buffer)
{
Buffer.Enqueue(b);
}
TimeSpan ms = sw.Elapsed;
Debug.WriteLine(n_bytes.ToString());
Debug.WriteLine(ms);
#endif
////////// sw.Reset();
}
public void CorrectAddElementAndRemoveWhenNotExeeded()
{
var buffer = new RingBuffer <int>(3);
buffer.Enqueue(10);
buffer.Enqueue(11);
Assert.Equal(10, buffer.Dequeue());
Assert.Equal(11, buffer.Dequeue());
}
public void CorrectAddAndRemoveWhenNotExceeded()
{
RingBuffer <int> buffer = new RingBuffer <int>(3);
buffer.Enqueue(7);
buffer.Enqueue(8);
Assert.AreEqual(7, buffer.Dequeue());
Assert.AreEqual(8, buffer.Dequeue());
}
public void TearDown()
{
if (State == ClientState.Connected)
{
_requests.Enqueue(NetworkThreadRequest.Disconnect);
}
Thread.Sleep(20);
_networkThread.Abort();
}
public void WhenRingBufferHasBeenClearedIsEmptyFlagShouldBeSetToTrue()
{
var buffer = new RingBuffer <int>(2);
buffer.Enqueue(2);
buffer.Enqueue(1);
buffer.Clear();
Assert.Equal(buffer.IsEmpty, true);
}
public void WhenClearedSetIsEmptyFlagToTrue()
{
RingBuffer <int> buffer = new RingBuffer <int>(3);
buffer.Enqueue(7);
buffer.Enqueue(8);
buffer.Enqueue(9);
buffer.Clear();
Assert.AreEqual(true, buffer.IsEmpty);
}
public void ReceiveLastElementWithoutRemovingItFromQueue()
{
RingBuffer <int> buffer = new RingBuffer <int>(3);
buffer.Enqueue(7);
buffer.Enqueue(8);
var firstElement = buffer.LastElement;
Assert.AreEqual(firstElement, buffer.LastElement);
}
public void PoliteReciveLastElementShouldNotRemoveItFromQueueAndMoveReadPointer()
{
var buffer = new RingBuffer <int>(3);
buffer.Enqueue(1);
buffer.Enqueue(2);
var firstElement = buffer.LastElement;
var secondElement = buffer.LastElement;
Assert.Equal(firstElement, secondElement);
}
public void AddingMultipleElementsShouldNotRisedArgumentOutOfRangeException()
{
var buffer = new RingBuffer <int>(3);
buffer.Enqueue(1);
buffer.Enqueue(2);
buffer.Enqueue(3);
var ex = Record.Exception(() => buffer.Enqueue(4));
Assert.Null(ex);
}
public void OverIncrementStartPointerShouldOverrightFirstValue()
{
var buffer = new RingBuffer <int>(3);
buffer.Enqueue(10);
buffer.Enqueue(11);
buffer.Enqueue(12);
buffer.Enqueue(14);
var element = buffer.Dequeue();
Assert.Equal(element, 12);
}
public void StartServer(Address address)
{
if (State != ServerState.Stopped)
{
return;
}
Logger.I.Log(this, $"Starting server on {address.GetIP()}:{address.Port}");
State = ServerState.Starting;
_address = address;
_requests.Enqueue(NetworkThreadRequest.Start);
}
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 void Send(byte[] data, bool isReliable = false)
{
byte[] fixedData = new byte[data.Length + 1];
unsafe
{
fixed(byte *dest = fixedData)
{
*dest = (byte)data.Length;
fixed(byte *src = data)
{
Memory.MemoryCopy((void *)(dest + 1), (void *)src, data.Length);
}
}
}
PacketFlags pf = PacketFlags.None;
if (isReliable == true)
{
pf = PacketFlags.Reliable;
}
Packet p = default(Packet);
p.Create(fixedData, 0, fixedData.Length, pf);
OutgoingPacket packet = new OutgoingPacket();
packet.packet = p;
outgoingPackets.Enqueue(packet);
}
//Puts incoming packets into a buffer that is read by OSCController
void OnPacketReceived(OSCServer server, OSCPacket packet)
{
if (packet.Address == "/tracking")
{
_inputBuffer.Enqueue(packet);
}
}
public void PushAudioFrame(float[] pcm)
{
lock (_ringBuffer)
{
_ringBuffer.Enqueue(pcm);
}
}
private Thread LogicThread()
{
return(new Thread(() =>
{
while (m_logicThreadActive)
{
GameCommand command = null;
Event netEvent;
// --> to network thread
while (m_commandQueue.TryDequeue(out command))
{
m_functionQueue.Enqueue(command);
}
// --> to game thread
while (m_transportEventQueue.TryDequeue(out netEvent))
{
switch (netEvent.Type)
{
case EventType.None:
break;
default:
m_logicEventQueue.Enqueue(netEvent);
break;
}
}
}
}));
}
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));
}
protected override void Append(LoggingEvent loggingEvent)
{
if (FilterEvent(loggingEvent))
{
pendingAppends.Enqueue(loggingEvent);
}
}
/*
* Function: RecieveFromServer
* ----------------------------
* Recieves data from the server, and pushes into a queue for it to be processed later
*
*/
public void RecieveFromServer()
{
try
{
NetworkStream serverStream = socket.GetStream();
while (!exchangeStopRequested)
{
byte[] inStream = new byte[(int)socket.ReceiveBufferSize];
serverStream.Read(inStream, 0, (int)socket.ReceiveBufferSize);
string dataFromServer = System.Text.Encoding.ASCII.GetString(inStream);
foreach (string mess in dataFromServer.Split(new[] { "\r\n", "\r", "\n" },
StringSplitOptions.None))
{
if (!(mess.Length >= 65500))
{
receivedQueue.Enqueue(mess);
}
}
//if (!(dataFromServer.Length >= 65520)) receivedQueue.Enqueue(dataFromServer);
}
}
catch (Exception e)
{
errorStatus = e.ToString();
}
}
void ReceivePointCloud(PointCloud cloud)
{
lock (_lock)
{
buf.Enqueue(cloud);
}
}
public void Poll()
{
//while (true)
//{
bool polled = false;
while (!polled)
{
if (host.CheckEvents(out netEvent) <= 0)
{
if (host.Service(0, out netEvent) <= 0)
{
break;
}
polled = true;
}
switch (netEvent.Type)
{
case ENet.EventType.Connect:
OnConnected();
break;
case ENet.EventType.Receive:
byte[] buffer = new byte[netEvent.Packet.Length];
netEvent.Packet.CopyTo(buffer);
IncomingPacket ip = new IncomingPacket();
ip.data = buffer;
ip.length = netEvent.Packet.Length;
incomingPackets.Enqueue(ip);
netEvent.Packet.Dispose();
break;
case ENet.EventType.Disconnect:
networkThread.Abort();
receiveThread.Abort();
OnDisconnected();
break;
}
}
OutgoingPacket outgoingPacket;
for (int i = 0; i < outgoingPackets.Count; i++)
{
outgoingPackets.TryDequeue(out outgoingPacket);
peer.Send(0, ref outgoingPacket.packet);
}
//}
}
public void StopServer()
{
if (State != ServerState.Working)
{
return;
}
Logger.I.Log(this, "Stopping server");
State = ServerState.Stopping;
_connectionsGroup.GetEntities(_connectionsBuffer);
foreach (var e in _connectionsBuffer)
{
_disconnectData.Enqueue(new DisconnectData {
Peer = e.connectionPeer.Value
});
e.isDestroyed = true;
}
_requests.Enqueue(NetworkThreadRequest.Stop);
}
public void WriteMessage(string message, LogMessageType type, Exception exception)
{
var lg = m_operationfile;
if (lg != null && type >= m_operationloglevel)
{
try
{
lg.WriteMessage(message, type, exception);
}
catch
{
}
}
if (m_serverfile != null && type >= m_serverloglevel)
{
try
{
m_serverfile.WriteMessage(message, type, exception);
}
catch
{
}
}
if (m_anytimeouts)
{
lock (m_lock)
{
var i = 0;
var q = GetActiveTimeouts();
if (q.Length == 0)
{
UpdateLogLevel();
m_anytimeouts = false;
if (m_buffer == null || m_buffer.Size != INACTIVE_SIZE)
{
m_buffer = new RingBuffer <LogEntry>(INACTIVE_SIZE, m_buffer);
}
}
else
{
var level = (LogMessageType)q.Max();
if (type >= level && m_buffer != null)
{
m_buffer.Enqueue(new LogEntry(message, type, exception));
}
}
}
}
}
/// <summary>
/// Adds a sample to this container.
/// </summary>
/// <param name="value"></param>
public void Enqueue(long value)
{
var previous = _ringBuffer.Enqueue(value);
if (_count < _ringBuffer.Length)
{
++_count;
}
_sum -= previous;
_sum += value;
_average = 1.0 * _sum / _count;
}
public void PerfTest()
{
RingBuffer<string> ringBuffer = new RingBuffer<string>(1000);
Stopwatch ringWatch = new Stopwatch();
ringWatch.Start();
for (int i = 0; i < 1000000; i++)
{
ringBuffer.Enqueue("StringOfFun");
}
ringWatch.Stop();
Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(100));
}
public void PerfTestThreadsWithDequeues()
{
RingBuffer <string> ringBuffer = new RingBuffer <string>(1000);
Stopwatch ringWatch = new Stopwatch();
List <Task> ringTasks = new List <Task>();
CancellationTokenSource cancelationTokenSource = new CancellationTokenSource();
CancellationToken cancelationToken = cancelationTokenSource.Token;
for (int t = 0; t < 10; t++)
{
ringTasks.Add(new Task(() =>
{
for (int i = 0; i < 1000000; i++)
{
ringBuffer.Enqueue("StringOfFun");
}
}, cancelationToken));
}
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());
var allTasks = ringTasks.ToArray();
Task.WaitAny(allTasks);
ringWatch.Stop();
//Cancel tasks to avoid System.AppDominUnloadException which is caused when the domain is unloaded
//and threads created in the domain are not stopped.
//Do this before assertions because they may throw an exception causing the thread cancellation to not happen.
cancelationTokenSource.Cancel();
try
{
Task.WaitAll(allTasks);
}
catch (AggregateException)
{
//Don't care about cancellation Exceptions.
}
ringTasks.ForEach(t => t.Dispose());
Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(800));
}
public void PerfTest()
{
RingBuffer <string> ringBuffer = new RingBuffer <string>(1000);
Stopwatch ringWatch = new Stopwatch();
ringWatch.Start();
for (int i = 0; i < 1000000; i++)
{
ringBuffer.Enqueue("StringOfFun");
}
ringWatch.Stop();
Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(150));
}
private void queueWorker()
{
while (running)
{
// Debug.Log ("Here");
float newEmg = myEmg.getOneSample();
// Debug.Log ("Here2");
Queue.Enqueue(newEmg);
}
}
public void PerfTestThreadsWithDequeues()
{
RingBuffer<string> ringBuffer = new RingBuffer<string>(1000);
Stopwatch ringWatch = new Stopwatch();
List<Task> ringTasks = new List<Task>();
CancellationTokenSource cancelationTokenSource = new CancellationTokenSource();
CancellationToken cancelationToken = cancelationTokenSource.Token;
for (int t = 0; t < 10; t++)
{
ringTasks.Add(new Task(() =>
{
for (int i = 0; i < 1000000; i++)
{
ringBuffer.Enqueue("StringOfFun");
}
}, cancelationToken));
}
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());
var allTasks = ringTasks.ToArray();
Task.WaitAny(allTasks);
ringWatch.Stop();
//Cancel tasks to avoid System.AppDominUnloadException which is caused when the domain is unloaded
//and threads created in the domain are not stopped.
//Do this before assertions because they may throw an exception causing the thread cancellation to not happen.
cancelationTokenSource.Cancel();
try
{
Task.WaitAll(allTasks);
}
catch (AggregateException)
{
//Don't care about cancellation Exceptions.
}
ringTasks.ForEach(t => t.Dispose());
Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(800));
}
public void WhenRingSizeLimitIsHit_ItemsAreDequeued()
{
// Arrange
const int limit = 2;
object object1 = "one";
object object2 = "two";
object object3 = "three";
RingBuffer <object> queue = new RingBuffer <object>(limit);
// Act
queue.Enqueue(object1);
queue.Enqueue(object2);
queue.Enqueue(object3);
// Assert
object value;
queue.TryDequeue(out value);
Assert.That(value, Is.EqualTo(object2));
queue.TryDequeue(out value);
Assert.That(value, Is.EqualTo(object3));
queue.TryDequeue(out value);
Assert.That(value, Is.Null);
}
public override void Write(byte[] buffer, int offset, int count)
{
if (m_WriteBuffer.CapacityAvailable >= count)
{
m_WriteBuffer.Enqueue(buffer, offset, count);
return;
}
using (NetworkConnection im = new NetworkConnection(FullName, m_Credentials))
{
byte[] tmp = new byte[m_WriteBuffer.Length];
m_WriteBuffer.Dequeue(tmp, 0, tmp.Length);
Underlying.Write(tmp, 0, tmp.Length);
Underlying.Write(buffer, 0, count);
}
}
private void Update()
{
_currentLocalTime = GetLocalTime() - _offsetTime;
while (_eventsToHandle.TryDequeue(out var @event))
{
switch (@event.Type)
{
case EventType.Connect:
OnConnected(@event.Peer);
break;
case EventType.Disconnect:
OnDisconnected(@event.Peer);
break;
case EventType.Receive:
unsafe
{
var packet = @event.Packet;
var span = new ReadOnlySpan <float>(packet.Data.ToPointer(), 1);
var time = span[0];
fixed(byte *destination = &_bytes[0])
{
var responseSpan = new Span <float>(destination, 2);
responseSpan[0] = time;
responseSpan[1] = _currentLocalTime;
}
var newPacket = new Packet();
newPacket.Create(_bytes, 8, PacketFlags.None);
_sendData.Enqueue(new SendData {
Packet = newPacket, Peer = _client
});
packet.Dispose();
break;
}
case EventType.Timeout:
OnDisconnected(@event.Peer);
break;
}
}
}
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 WhenRingSizeLimitIsHit_ItemsAreDequeued()
{
// Arrange
const int limit = 2;
object object1 = "one";
object object2 = "two";
object object3 = "three";
RingBuffer<object> queue = new RingBuffer<object>(limit);
// Act
queue.Enqueue(object1);
queue.Enqueue(object2);
queue.Enqueue(object3);
// Assert
object value;
queue.TryDequeue(out value);
Assert.That(value, Is.EqualTo(object2));
queue.TryDequeue(out value);
Assert.That(value, Is.EqualTo(object3));
queue.TryDequeue(out value);
Assert.That(value, Is.Null);
}
