X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f47deaf4eadbed4cf8c31d97100d444cc978799f..8fb62dc5a69cd10bc48dae3c6e7ecf54b11ba378:/src/smpi/plugins/sampi_loadbalancer.cpp diff --git a/src/smpi/plugins/sampi_loadbalancer.cpp b/src/smpi/plugins/sampi_loadbalancer.cpp index a9f81ac230..c989c3e419 100644 --- a/src/smpi/plugins/sampi_loadbalancer.cpp +++ b/src/smpi/plugins/sampi_loadbalancer.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2018. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2018-2020. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -9,11 +9,13 @@ #include #include #include +#include +#include #include #include "src/kernel/activity/ExecImpl.hpp" -#include "src/simix/ActorImpl.hpp" -#include +#include "src/kernel/actor/ActorImpl.hpp" +#include "src/smpi/plugins/load_balancer/load_balancer.hpp" // This is not yet ready to be public XBT_LOG_NEW_DEFAULT_SUBCATEGORY(plugin_load_balancer, smpi, "Logging specific to the SMPI load balancing plugin"); @@ -27,10 +29,10 @@ namespace plugin { static simgrid::plugin::loadbalancer::LoadBalancer lb; -class MigrateParser : public simgrid::smpi::replay::ActionArgParser { +class MigrateParser : public replay::ActionArgParser { public: double memory_consumption; - void parse(simgrid::xbt::ReplayAction& action, std::string name) + void parse(xbt::ReplayAction& action, const std::string&) { // The only parameter is the amount of memory used by the current process. CHECK_ACTION_PARAMS(action, 1, 0); @@ -38,24 +40,25 @@ public: } }; -/* This function simulates what happens when the original application calls - * (A)MPI_Migrate. It executes the load balancing heuristics, makes the necessary - * migrations and updates the task mapping in the load balancer. +/* This function simulates what happens when the original application calls (A)MPI_Migrate. It executes the load + * balancing heuristics, makes the necessary migrations and updates the task mapping in the load balancer. */ -class MigrateAction : public simgrid::smpi::replay::ReplayAction { +class MigrateAction : public replay::ReplayAction { public: explicit MigrateAction() : ReplayAction("Migrate") {} - void kernel(simgrid::xbt::ReplayAction& action) + void kernel(xbt::ReplayAction&) { - static std::map migration_call_counter; - static simgrid::s4u::Barrier smpilb_bar(smpi_process_count()); - simgrid::s4u::Host* cur_host = simgrid::s4u::this_actor::get_host(); - simgrid::s4u::Host* migrate_to_host; + static std::map migration_call_counter; + static s4u::Barrier smpilb_bar(smpi_get_universe_size()); + s4u::Host* cur_host = s4u::this_actor::get_host(); + s4u::Host* migrate_to_host; - TRACE_migration_call(my_proc_id, NULL); + TRACE_migration_call(get_pid(), nullptr); - migration_call_counter[simgrid::s4u::Actor::self()]++; - if ((migration_call_counter[simgrid::s4u::Actor::self()] % simgrid::config::get_value(cfg_migration_frequency.get_name())) != 0) { + // We only migrate every "cfg_migration_frequency"-times, not at every call + migration_call_counter[s4u::Actor::self()]++; + if ((migration_call_counter[s4u::Actor::self()] % config::get_value(cfg_migration_frequency.get_name())) != + 0) { return; } @@ -65,8 +68,8 @@ public: static bool was_executed = false; if (not was_executed) { was_executed = true; + XBT_DEBUG("Process %li runs the load balancer", get_pid()); smpi_bench_begin(); - XBT_INFO("RUNNING THE LB"); lb.run(); smpi_bench_end(); } @@ -75,22 +78,22 @@ public: smpilb_bar.wait(); was_executed = false; // Must stay behind this barrier so that all processes have passed the if clause - migrate_to_host = lb.get_mapping(); + migrate_to_host = lb.get_mapping(simgrid::s4u::Actor::self()); if (cur_host != migrate_to_host) { // Origin and dest are not the same -> migrate - sg_host_t migration_hosts[2] = {cur_host, migrate_to_host}; - // Changing this to double[2] ... will cause trouble with parallel_execute, because that fct is trying to call free(). - double* comp_amount = new double[2]{0, 0}; - double* comm_amount = new double[4]{0, std::max(args.memory_consumption, 1.0), 0, 0}; + std::vector migration_hosts = {cur_host, migrate_to_host}; + std::vector comp_amount = {0, 0}; + std::vector comm_amount = {0, /*must not be 0*/ std::max(get_args().memory_consumption, 1.0), 0, 0}; xbt_os_timer_t timer = smpi_process()->timer(); xbt_os_threadtimer_start(timer); - simgrid::s4u::this_actor::parallel_execute(2, migration_hosts, comp_amount, comm_amount, -1.0); + s4u::this_actor::parallel_execute(migration_hosts, comp_amount, comm_amount); xbt_os_threadtimer_stop(timer); smpi_execute(xbt_os_timer_elapsed(timer)); // Update the process and host mapping in SimGrid. - TRACE_smpi_process_change_host(my_proc_id, migrate_to_host); - simgrid::s4u::this_actor::migrate(migrate_to_host); + XBT_DEBUG("Migrating process %li from %s to %s", get_pid(), cur_host->get_cname(), migrate_to_host->get_cname()); + TRACE_smpi_process_change_host(get_pid(), migrate_to_host); + s4u::this_actor::set_host(migrate_to_host); } smpilb_bar.wait(); @@ -104,23 +107,24 @@ public: ******************************************************************************/ // FIXME Move declaration -XBT_PRIVATE void action_iteration_in(simgrid::xbt::ReplayAction& action); -void action_iteration_in(simgrid::xbt::ReplayAction& action) +XBT_PRIVATE void action_iteration_in(xbt::ReplayAction& action); +void action_iteration_in(xbt::ReplayAction& action) { CHECK_ACTION_PARAMS(action, 0, 0) - TRACE_Iteration_in(simgrid::s4u::this_actor::get_pid(), nullptr); + TRACE_Iteration_in(s4u::this_actor::get_pid(), nullptr); + smpi::plugin::ampi::on_iteration_in(*MPI_COMM_WORLD->group()->actor(std::stol(action[0]))); } -// FIXME Move declaration -XBT_PRIVATE void action_iteration_out(simgrid::xbt::ReplayAction& action); -void action_iteration_out(simgrid::xbt::ReplayAction& action) +XBT_PRIVATE void action_iteration_out(xbt::ReplayAction& action); +void action_iteration_out(xbt::ReplayAction& action) { CHECK_ACTION_PARAMS(action, 0, 0) - TRACE_Iteration_out(simgrid::s4u::this_actor::get_pid(), nullptr); -} -} -} + TRACE_Iteration_out(s4u::this_actor::get_pid(), nullptr); + ampi::on_iteration_out(*MPI_COMM_WORLD->group()->actor(std::stol(action[0]))); } +} // namespace plugin +} // namespace smpi +} // namespace simgrid /** @ingroup plugin_loadbalancer * @brief Initializes the load balancer plugin @@ -132,8 +136,8 @@ void sg_load_balancer_plugin_init() static bool done = false; if (!done) { done = true; - simgrid::kernel::activity::ExecImpl::on_completion.connect([](simgrid::kernel::activity::ExecImplPtr activity){ - simgrid::smpi::plugin::lb.record_actor_computation(activity->simcalls_.front()->issuer->iface(), activity->surf_action_->get_cost()); + simgrid::s4u::Exec::on_completion.connect([](simgrid::s4u::Actor const& actor, simgrid::s4u::Exec const& exec) { + simgrid::smpi::plugin::lb.record_actor_computation(actor, exec.get_cost()); }); xbt_replay_action_register(