X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/loba.git/blobdiff_plain/6a266736a5a4f2e30a529662180050e8bc2b1a49..635d04eb04fd9464021fcb59c4d63a2a329f0415:/process.cpp diff --git a/process.cpp b/process.cpp index fe08b33..c104ecd 100644 --- a/process.cpp +++ b/process.cpp @@ -18,6 +18,18 @@ double process::total_load_init = 0.0; double process::total_load_running = 0.0; double process::total_load_exit = 0.0; +namespace { + + void sleep_until_date(double& date, double duration = 0.0) + { + double sleep_duration = date - MSG_get_clock(); + if (sleep_duration > 0.0) + MSG_process_sleep(sleep_duration); + date = MSG_get_clock() + duration; + } + +} + process::process(int argc, char* argv[]) { if (argc < 2 || !(std::istringstream(argv[1]) >> real_load)) @@ -46,9 +58,9 @@ process::process(int argc, char* argv[]) comp_iter = lb_iter = 0; - compute_thread = new_msg_thread("compute", - std::tr1::bind(&process::compute_loop, - this)); + lb_thread = new_msg_thread("loba", + std::tr1::bind(&process::load_balance_loop, + this)); e_xbt_log_priority_t logp = xbt_log_priority_verbose; if (!LOG_ISENABLED(logp)) @@ -68,28 +80,33 @@ process::process(int argc, char* argv[]) process::~process() { - delete compute_thread; + delete lb_thread; total_load_exit += real_load; - if (opt::bookkeeping) { - XBT_INFO("Final load after %d:%d iterations: %g ; expected: %g", - lb_iter, comp_iter, real_load, expected_load); - } else { - XBT_INFO("Final load after %d iterations: %g", - lb_iter, real_load); - if (lb_iter != comp_iter) - XBT_WARN("lb_iter (%d) and comp_iter (%d) differ!", - lb_iter, comp_iter); - } + if (opt::log_rate < 0) + return; + XBT_INFO("Final load after %d:%d iterations: %g", + lb_iter, comp_iter, real_load); + XBT_VERB("Expected load was: %g", expected_load); XBT_VERB("Total computation for this process: %g", comp); } int process::run() { - XBT_INFO("Initial load: %g", real_load); + if (opt::log_rate >= 0) { + XBT_INFO("Initial load: %g", real_load); + XBT_VERB("Initial expected load: %g", expected_load); + } XBT_VERB("Starting..."); - compute_thread->start(); - load_balance_loop(); - compute_thread->wait(); + mutex.acquire(); + lb_thread->start(); + while (lb_iter <= opt::comp_iter_delay) + cond.wait(mutex); + mutex.release(); + double sleep_duration = opt::comp_time_delay - MSG_get_clock(); + if (sleep_duration > 0.0) + MSG_process_sleep(sleep_duration); + compute_loop(); + lb_thread->wait(); XBT_VERB("Done."); return 0; } @@ -99,16 +116,20 @@ void process::load_balance_loop() using std::tr1::bind; using std::tr1::placeholders::_1; + double next_iter_after_date = MSG_get_clock() + opt::min_lb_iter_duration; while (still_running()) { - ++lb_iter; + if (lb_iter == opt::comp_iter_delay) { + mutex.acquire(); + ++lb_iter; + cond.signal(); + mutex.release(); + } else { + ++lb_iter; + } if (opt::log_rate && lb_iter % opt::log_rate == 0) { - if (opt::bookkeeping) - XBT_INFO("(%u:%u) current load: %g ; expected: %g", - lb_iter, comp_iter, real_load, expected_load); - else - XBT_INFO("(%u:%u) current load: %g", - lb_iter, comp_iter, real_load); + XBT_INFO("(%u:%u) current load: %g", lb_iter, comp_iter, real_load); + XBT_VERB("... expected load: %g", expected_load); } if (get_load() > 0.0) @@ -119,10 +140,10 @@ void process::load_balance_loop() // send std::for_each(neigh.begin(), neigh.end(), bind(&process::ctrl_send, this, _1)); + prev_load_broadcast = get_load(); - // block on receiving unless there is something to compute or - // to send - ctrl_receive(opt::min_lb_iter_duration); + sleep_until_date(next_iter_after_date, opt::min_lb_iter_duration); + ctrl_receive(0.0); comm.ctrl_flush(false); } @@ -145,13 +166,13 @@ void process::compute_loop() using std::tr1::bind; using std::tr1::placeholders::_1; - double next_iter_after_date = 0.0; + double next_iter_after_date = MSG_get_clock() + opt::min_comp_iter_duration; while (still_running()) { // receive - double sleep_duration = real_load - ? std::max(MSG_get_clock() - next_iter_after_date, 0.0) - : opt::min_comp_iter_duration; - data_receive(sleep_duration); + if (real_load > 0.0) + data_receive(0.0); + else + data_receive(opt::min_comp_iter_duration); comm.data_flush(false); @@ -172,10 +193,15 @@ void process::compute_loop() comp += flops; MSG_task_destroy(task); - next_iter_after_date = MSG_get_clock() + opt::min_comp_iter_duration; + sleep_until_date(next_iter_after_date, opt::min_comp_iter_duration); } XBT_VERB("Going to finalize for %s...", __func__); + // last send, for not losing load scheduled to be sent + std::for_each(neigh.begin(), neigh.end(), + bind(&process::data_send, this, _1)); + finalizing = true; + total_load_running -= real_load; XBT_DEBUG("send DATA_CLOSE to %zu neighbor%s", neigh.size(), ESSE(neigh.size())); std::for_each(neigh.begin(), neigh.end(), @@ -219,7 +245,6 @@ bool process::still_running() opt::load_ratio_threshold) { // fixme: this check should be implemented with a distributed // algorithm, and not a shared global variable! - // fixme: should this chunk be moved before call to receive() ? XBT_VERB("No more load to balance in system."); last_status = false; } @@ -244,7 +269,8 @@ void process::send(neighbor& nb, double amount) if (_XBT_LOG_ISENABLEDV((*cat), logp)) { \ using std::tr1::bind; \ using std::tr1::placeholders::_1; \ - XBT_XCLOG(cat, logp, "Neighbor loads:"); \ + XBT_XCLOG(cat, logp, "My load: %g (real); %g (expected). " \ + "Neighbor loads:", real_load, expected_load); \ std::for_each(vec.begin(), vec.end(), \ bind(&neighbor::print, _1, verbose, logp, cat)); \ } else ((void)0) @@ -298,6 +324,7 @@ void process::data_send(neighbor& nb) } else { load_to_send = nb.get_to_send(); nb.set_to_send(0.0); + // do not update real_load here } if (load_to_send > 0.0) comm.data_send(nb.get_data_mbox(),