public void Update(float deltaTime) { // queues are swapped so that any new events added in response to an // event firing are processed in the next frame m_readIndex = (m_readIndex + 1) & 1; m_writeIndex = (m_writeIndex + 1) & 1; if (ReadQueue.Count == 0) { return; } var count = 0; m_eventDispatchTimer.Restart(); while (ReadQueue.Count > 0) { var evt = ReadQueue.First(); ReadQueue.RemoveAt(0); TriggerEvent(evt); count++; } Log.Trace("Processed {0} events in {1:F4}s", count, m_eventDispatchTimer.Elapsed.TotalSeconds); }
private void ReadMessages() { while (true) { try { var message = JsonConvert.DeserializeObject <Message>(_reader.ReadString()); ReadQueue.Add(message); if (string.Equals(message.MessageType, "TestHost.Acknowledge")) { _ackWaitHandle.Set(); ReadQueue.CompleteAdding(); break; } } catch (Exception ex) { TestHostTracing.Source.TraceEvent( TraceEventType.Error, 0, "[ReportingChannel]: Waiting for message failed {0}", ex); throw; } } }
public void Process(CancellationToken ct) { while (CanRead) { ct.ThrowIfCancellationRequested(); while (!WriteQueue.IsEmpty && !ReadQueue.IsEmpty) { if (TryWriteNext()) { ReportNextBlockProgress(); } } ReadNext(); } ReadQueue.Close(); while (TryWriteNext()) { ReportNextBlockProgress(); } Finish(); }
public void Shutdown() { Log.Trace("EventManager Shutting Down"); m_listeners.Clear(); ReadQueue.Clear(); WriteQueue.Clear(); }
/// <summary> /// Refreshes this descriptor /// </summary> /// <param name="queue"></param> public override void Refresh(ReadQueue queue) { base.Refresh(queue); var handle = queue.With<IDevice>(DeviceInstance, ObjectIdentifier); handle.Enqueue(dev => dev.DatabaseRevision, rev => this.DatabaseRevision = (byte)rev, err => this.DatabaseRevision = null); }
private void Dispose(bool dispose) { ReadQueue.Clear(); AppendQueue.Clear(); ReadQueue.Dispose(); AppendQueue.Dispose(); _disposed = true; }
/// <summary> /// Refreshes this descriptor /// </summary> /// <param name="queue"></param> public override void Refresh(ReadQueue queue) { base.Refresh(queue); var handle = queue.With <IDevice>(DeviceInstance, ObjectIdentifier); handle.Enqueue(dev => dev.DatabaseRevision, rev => this.DatabaseRevision = (byte)rev, err => this.DatabaseRevision = null); }
/// <summary> /// Data received handler. /// </summary> /// <param name="sender">[in]</param> /// <param name="args">[in]</param> private void SerialPortDataReceived(object sender, SerialDataReceivedEventArgs args) { var count = Port.BytesToRead; var bytes = new byte[count]; Port.Read(bytes, 0, count); foreach (var data in bytes) { ReadQueue.Add(data); } }
public long?Read() { if (ReadQueue.Any()) { return(ReadQueue.Dequeue()); } else { return(null); } }
/// <summary> /// 处理已经解析出来的命令。 /// </summary> private void HandleReceiveCmds() { while (ReadQueue.Count > 0) { Log(Name, string.Format("将收到得消息丢给上层处理,时间:{0}", DataTime2String(DateTime.Now))); Packet packet = ReadQueue.Dequeue() as Packet; if (packet != null) { HandleCmd(packet); } } }
void ProcessBufferedIO(bool force = false) { BufferedIO io; while (WriteQueue.Count > 0) { io = WriteQueue.Peek(); // This means we wanted to wait until all the writes had been flushed // before we attempt to generate the hash of a given piece. if (io.manager == null && io.buffer == null) { io = WriteQueue.Dequeue(); io.tcs.SetResult(true); continue; } if (!force && !WriteLimiter.TryProcess(io.count)) { break; } io = WriteQueue.Dequeue(); try { Interlocked.Add(ref pendingWrites, -io.count); Write(io.manager, io.offset, io.buffer, io.count); io.tcs.SetResult(true); } catch (Exception ex) { io.tcs.SetException(ex); } } while (ReadQueue.Count > 0) { if (!force && !ReadLimiter.TryProcess(ReadQueue.Peek().count)) { break; } io = ReadQueue.Dequeue(); try { Interlocked.Add(ref pendingReads, -io.count); var result = Read(io.manager, io.offset, io.buffer, io.count); io.tcs.SetResult(result); } catch (Exception ex) { io.tcs.SetException(ex); } } }
// dispatches all pending messages in the read queue private void DispatchMessages() { var count = 0; while (ReadQueue.Count > 0) { var msg = ReadQueue.First(); ReadQueue.RemoveAt(0); TriggerMessage(msg); count++; } Log.VerboseFmtIf(count > 0, "{0} dispatched {1} messages", Parent.FullName, count); }
public override void ReadNext() { if (fileMetadata.TryGetNextRecord(out var record)) { var block = Block.CreateBlockForDecompression(record.Start, record.Length, record.StartCompressed, record.LengthCompressed); input.Position = record.StartCompressed; input.Read(block.Content, 0, block.Size); ReadQueue.Enqueue(block); } else { _canRead = false; } }
public override void ReadNext() { var start = input.Position; var left = input.Length - input.Position; var nextBlockSize = blockSize < left ? blockSize : (int)left; var block = Block.CreateBlockForCompression(start, nextBlockSize); input.Read(block.Content, 0, nextBlockSize); ReadQueue.Enqueue(block); readBlocks++; }
internal async ReusableTask <bool> ReadAsync(ITorrentData manager, long offset, byte [] buffer, int count) { Interlocked.Add(ref pendingReads, count); await IOLoop; if (ReadLimiter.TryProcess(count)) { Interlocked.Add(ref pendingReads, -count); return(Read(manager, offset, buffer, count)); } else { var tcs = new ReusableTaskCompletionSource <bool>(); ReadQueue.Enqueue(new BufferedIO(manager, offset, buffer, count, tcs)); return(await tcs.Task); } }
public void TakeOneStep() { if (IsFinished) { return; } if (IsWaiting && ReadQueue.Any()) { IsWaiting = false; } var currentInstruction = Instructions[CurrentIndex]; Log($"{ProgramId}: {currentInstruction.GetType().Name}"); var indexBeforeChange = CurrentIndex; currentInstruction.Perform(this); if (!IsWaiting && CurrentIndex == indexBeforeChange) { CurrentIndex++; } }
public void Dispose() { // Wait for a graceful disconnect - drain the queue until we get an 'ACK' Message message; while (ReadQueue.TryTake(out message, millisecondsTimeout: 1)) { } if (_ackWaitHandle.Wait(TimeSpan.FromSeconds(10))) { TestHostTracing.Source.TraceInformation("[ReportingChannel]: Received for ack from test host"); } else { TestHostTracing.Source.TraceEvent( TraceEventType.Error, 0, "[ReportingChannel]: Timed out waiting for ack from test host"); } Socket.Dispose(); }
/// <summary> /// Refresh the descriptor /// </summary> /// <param name="queue">The read queue</param> public virtual void Refresh(ReadQueue queue) { var handle = queue.With <INamedObject>(DeviceInstance, ObjectIdentifier); handle.Enqueue(obj => obj.ObjectName, name => this.Name = name); }
public T Pop() { return(ReadQueue.Pop()); }
public T Peek() { return(ReadQueue.Peek()); }
private void FinishReadBody(IAsyncResult result) { try { var data = result.AsyncState as RsvData; if (data == null) { LogError(Name, "data = null FinishReadBody"); } else { var stream = data.Stream; var size = stream.EndRead(result); data.Offset = data.Offset + size; if (data.Offset < data.DataLength) { data.Stream.BeginRead( data.Data, data.Offset, data.DataLength - data.Offset, FinishReadBody, data); } else { TmpReadCmdNumber++; Log(Name, string.Format("接收完消息,时间:{0},第 {1} 个命令", DataTime2String(DateTime.Now), TmpReadCmdNumber)); LastServerHeartBeat = DateTime.Now; LastClientHeartBeat = DateTime.Now; var cmd = ParseCmd(data.Data); ReadQueue.Enqueue(cmd); if (TmpReadCmdNumber < MaxReadCmdNumberPerFrame) { if (Client.Available > 4) { StartReadHeader(); } else { IsReading = false; } } else { LogWarning(Name, string.Format("这一帧不再接收命令了,时间:{0}", DateTime.Now)); IsReading = false; } } } } catch (Exception exception) { LogError(Name, string.Format("{0},{1}", exception.Message, exception.StackTrace)); HasConnectedToServer = false; EventQueue.Enqueue(new Event { Type = EventType.DisConnect }); } }
/// <summary> /// Read data from SerialPort. /// </summary> /// <param name="data">[out]Data byte.</param> /// <returns>Bool - Return true for success.</returns> public bool Read(out byte data) { return(ReadQueue.Take(out data)); }