public void Send(Command command) { bool ok; lock (m_sync) { m_commandPipe.Write(ref command, false); ok = m_commandPipe.Flush(); } if (!ok) { m_proactor.SignalMailbox(this); } }
/// <summary> /// Send a command to the given destination thread. /// </summary> public void SendCommand(int threadId, Command command) { m_slots[threadId].Send(command); }
public bool TryReceive(TimeSpan timeout, out Command command) { return m_queue.TryTake(out command, timeout); }
public void Send(Command command) { m_queue.Add(command); }
internal static void SendCommand(int slotId, Command command) { s_slots[slotId].Send(command); }
public void ProcessCommand( Command cmd) { switch (cmd.CommandType) { case CommandType.ActivateRead: ProcessActivateRead(); break; case CommandType.ActivateWrite: ProcessActivateWrite((long)cmd.Arg); break; case CommandType.Stop: ProcessStop(); break; case CommandType.Plug: ProcessPlug(); ProcessSeqnum(); break; case CommandType.Own: ProcessOwn((Own)cmd.Arg); ProcessSeqnum(); break; case CommandType.Attach: ProcessAttach((IEngine)cmd.Arg); ProcessSeqnum(); break; case CommandType.Bind: ProcessBind((Pipe)cmd.Arg); ProcessSeqnum(); break; case CommandType.Hiccup: ProcessHiccup(cmd.Arg); break; case CommandType.PipeTerm: ProcessPipeTerm(); break; case CommandType.PipeTermAck: ProcessPipeTermAck(); break; case CommandType.TermReq: ProcessTermReq((Own)cmd.Arg); break; case CommandType.Term: ProcessTerm((int)cmd.Arg); break; case CommandType.TermAck: ProcessTermAck(); break; case CommandType.Reap: ProcessReap((SocketBase)cmd.Arg); break; case CommandType.Reaped: ProcessReaped(); break; default: throw new ArgumentException(); } }
/// <summary> /// Send the given Command, on that commands Destination thread. /// </summary> /// <param name="cmd">the Command to send</param> private void SendCommand( Command cmd) { m_ctx.SendCommand(cmd.Destination.ThreadId, cmd); }
public bool TryRecv(out Command command) { return m_commandPipe.TryRead(out command); }
/// <summary> /// Receive and return a Command from the command-pipe. /// </summary> /// <param name="timeout">how long to wait for a command (in milliseconds) before returning</param> /// <param name="command"></param> public bool TryRecv(int timeout, out Command command) { // Try to get the command straight away. if (m_active) { if (m_commandPipe.TryRead(out command)) return true; // If there are no more commands available, switch into passive state. m_active = false; m_signaler.Recv(); } // Wait for signal from the command sender. if (!m_signaler.WaitEvent(timeout)) { command = default(Command); return false; } // We've got the signal. Now we can switch into active state. m_active = true; // Get a command. var ok = m_commandPipe.TryRead(out command); Debug.Assert(ok); return ok; }
/// <summary> /// Send the given Command out accross the command-pipe. /// </summary> /// <param name="cmd">the Command to send</param> public void Send(Command cmd) { bool ok; lock (m_sync) { m_commandPipe.Write(ref cmd, false); ok = m_commandPipe.Flush(); } //if (LOG.isDebugEnabled()) // LOG.debug( "{} -> {} / {} {}", new Object[] { Thread.currentThread().getName(), cmd_, cmd_.arg , !ok}); if (!ok) { m_signaler.Send(); } }
private static void SendCommand(Command command) { SocketManager.SendCommand(command.Destination.SlotId, command); }
public void Send(Command command) { // using the completion port as a queue, might not yield good performance m_completionPort.Signal(command); }