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