X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/loba.git/blobdiff_plain/b78d5563826957045678f4c3bcfdcef6c9bfc48d..00e9c7c4aa9f01d944398d68a05225c7782eb089:/process.h diff --git a/process.h b/process.h index 268fac9..dbf9b05 100644 --- a/process.h +++ b/process.h @@ -4,7 +4,8 @@ #define USE_UNORDERED_MAP 1 //#undef USE_UNORDERED_MAP -#include +#include +#include #ifdef USE_UNORDERED_MAP # include # define MAP_TEMPLATE std::tr1::unordered_map @@ -12,14 +13,27 @@ # include # define MAP_TEMPLATE std::map #endif +#include #include +#include #include "communicator.h" +#include "misc.h" +#include "msg_thread.h" #include "neighbor.h" +#include "options.h" class process { public: + static double get_total_load_init() { return total_load_init; } + static double get_total_load_running() { return total_load_running; } + static double get_total_load_exit() { return total_load_exit; } + process(int argc, char* argv[]); - ~process(); + virtual ~process(); + + double get_comp() const { return comp; } + double get_real_load() const { return real_load; } + int run(); protected: @@ -29,12 +43,38 @@ protected: pneigh_type pneigh; // list of pointers to neighbors that // we are free to reorder - // Returns the sum of "to_send" for all neighbors. - double sum_of_to_send() const; + // Get and set current load, which may be real load, or expected + // load if opt::bookkeeping is true. + double get_load() const; + void set_load(double load); + + // The load balancing algorithm comes here... + virtual void load_balance(); + + // Register some amount of load to send to given neighbor. + void send(neighbor& nb, double amount); + void send(neighbor* nb, double amount) { send(*nb, amount); } + + // Sort pneigh by applying comp to their loads + template + void pneigh_sort_by_load(const Compare& comp); + + // Calls neighbor::print(verbose, logp, cat) for each member of neigh. + void print_loads(bool verbose = false, + e_xbt_log_priority_t logp = xbt_log_priority_info, + xbt_log_category_t cat = _XBT_LOGV(default)) const; + + // Calls neighbor::print(verbose, logp, cat) for each member of pneigh. + void print_loads_p(bool verbose = false, + e_xbt_log_priority_t logp = xbt_log_priority_info, + xbt_log_category_t cat = _XBT_LOGV(default)) const; private: - typedef MAP_TEMPLATE rev_neigh_type; + static double total_load_init; // sum of process loads at init + static double total_load_running; // sum of loads while running + static double total_load_exit; // sum of process loads at exit + typedef MAP_TEMPLATE rev_neigh_type; neigh_type neigh; // list of neighbors (do not alter // after construction!) rev_neigh_type rev_neigh; // map m_host_t -> neighbor @@ -44,43 +84,72 @@ private: // on ctrl channel int data_close_pending; // number of "close" messages to wait // on data channel + bool close_received; // true if we received a "close" message + bool finalizing; // true when finalize() is running - unsigned iter; // counter of iterations + unsigned lb_iter; // counter of load-balancing iterations + unsigned comp_iter; // counter of computation iterations + + double comp; // total computing done so far (flops) double prev_load_broadcast; // used to ensure that we do not send // a same information messages - double load; // current load + double real_load; // current load double expected_load; // expected load in bookkeeping mode - // The load balancing algorithm comes here... - // Parameter "my_load" is the load to take into account for myself - // (may be load or expected load). - // Returns the total load sent to neighbors. - virtual double load_balance(double my_load); - - // Virtually do some computation - void compute(); - - // Send procedures, with helpers for bookkeeping mode or not - void send1_no_bookkeeping(neighbor& nb); - void send1_bookkeeping(neighbor& nb); - void send(); - - // Receive procedure: wait (or not) for a message to come. - // Returns false if some "close" message was received, returns true - // otherwise. - enum recv_wait_mode { NO_WAIT = 0, WAIT, WAIT_FOR_CLOSE }; - bool receive(recv_wait_mode wait); - - // Finalize sends a "close" message to each neighbor and wait for - // all of them to answer. - void finalize1(neighbor& nb); - void finalize(); - - // Print with given priority what we know about our neighbors' loads - void print_loads(e_xbt_log_priority_t logp = xbt_log_priority_info); + // Load-balancing loop + void load_balance_loop(); + + // Simulate computation loop + msg_thread* compute_thread; + void compute_loop(); + + bool still_running(); + + // Send procedures + void ctrl_send(neighbor& nb); + void data_send(neighbor& nb); + void ctrl_close(neighbor& nb); + void data_close(neighbor& nb); + + // Receive procedure + // Parameter "timeout" may be 0 for non-blocking operation, -1 for + // infinite waiting, or any positive timeout. + void ctrl_receive(double timeout); + void data_receive(double timeout); + void handle_message(message* msg, m_host_t from); }; +inline +double process::get_load() const +{ + if (opt::bookkeeping) + return expected_load; + else + return real_load; +} + +inline +void process::set_load(double load) +{ + if (opt::bookkeeping) + expected_load = load; + else + real_load = load; +} + +template +void process::pneigh_sort_by_load(const Compare& comp) +{ + using std::tr1::bind; + using std::tr1::placeholders::_1; + using std::tr1::placeholders::_2; + std::sort(pneigh.begin(), pneigh.end(), + bind(comp, + bind(&neighbor::get_load, _1), + bind(&neighbor::get_load, _2))); +} + #endif // !PROCESS_H // Local variables: