communicator.h

   1 // Asynchronous communicator
   2
   3 #ifndef COMMUNICATOR_H
   4 #define COMMUNICATOR_H
   5
   6 #include <list>
   7 #include <queue>
   8 #include <string>
   9 #include <msg/msg.h>
  10 #include "hostdata.h"
  11
  12 class message {
  13 public:
  14     enum message_type { INFO, CREDIT, LOAD, CTRL_CLOSE, DATA_CLOSE };
  15
  16     message(message_type t, double a): type(t), amount(a) { }
  17
  18     message_type get_type() const       { return type;   }
  19     double get_amount() const           { return amount; }
  20
  21     std::string to_string();
  22
  23 private:
  24     message_type type;
  25     double amount;
  26 };
  27
  28 class communicator {
  29 public:
  30     communicator();
  31     ~communicator();
  32
  33     // Send a message to the "dest" mailbox
  34     void send(const char* dest, message* msg);
  35
  36     // Try to get a message.  Returns true on success.
  37     // Parameter "timeout" may be 0 for non-blocking operation, -1 for
  38     // infinite waiting, or any positive timeout.
  39     bool recv(message*& msg, m_host_t& from, double timeout);
  40
  41     // Try to flush pending sending communications.
  42     // If "wait" is true, blocks until success.
  43     void flush(bool wait);
  44
  45 private:
  46     // Myself
  47     const hostdata* host;
  48
  49     // List of pending send communications
  50     std::list<msg_comm_t> sent_comm;
  51
  52     // Queue of received messages
  53     std::queue<m_task_t> received;
  54
  55     // Control channel for receiving
  56     m_task_t    ctrl_task;          // receive buffer
  57     msg_comm_t  ctrl_comm;          // receive communication
  58
  59     // Data channel for receiving
  60     m_task_t    data_task;          // receive buffer
  61     msg_comm_t  data_comm;          // receive communication
  62
  63     const char* get_ctrl_mbox() const   { return host->get_ctrl_mbox(); }
  64     const char* get_data_mbox() const   { return host->get_data_mbox(); }
  65
  66     // Handling of receiving thread
  67     xbt_mutex_t receiver_mutex;
  68     xbt_cond_t receiver_cond;
  69     m_process_t receiver_thread;
  70     static int receiver_wrapper(int, char* []);
  71     void receiver1(msg_comm_t& comm, m_task_t& task, const char* mbox);
  72     void receiver();
  73
  74     // Used to chek if a communication is successfull before destroying it
  75     static void comm_check_n_destroy(msg_comm_t comm);
  76     // If comm is over, call comm_check_n_destroy(comm), and return true
  77     static bool comm_test_n_destroy(msg_comm_t comm);
  78 };
  79
  80 #endif // !COMMUNICATOR_H
  81
  82 // Local variables:
  83 // mode: c++
  84 // End: