X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fea8b2e865eef9f33d094134cd0c54c8f8cb016f..HEAD:/src/plugins/host_energy.cpp diff --git a/src/plugins/host_energy.cpp b/src/plugins/host_energy.cpp index 06086cea63..aab32cbff8 100644 --- a/src/plugins/host_energy.cpp +++ b/src/plugins/host_energy.cpp @@ -1,16 +1,19 @@ -/* Copyright (c) 2010-2020. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2023. 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. */ -#include "simgrid/Exception.hpp" -#include "simgrid/plugins/energy.h" -#include "simgrid/s4u/Engine.hpp" -#include "simgrid/s4u/Exec.hpp" -#include "src/include/surf/surf.hpp" -#include "src/kernel/activity/ExecImpl.hpp" -#include "src/plugins/vm/VirtualMachineImpl.hpp" -#include "src/surf/cpu_interface.hpp" +#include +#include +#include +#include +#include +#include +#include + +#include "src/kernel/activity/ActivityImpl.hpp" +#include "src/kernel/resource/CpuImpl.hpp" +#include "src/simgrid/module.hpp" #include #include @@ -58,14 +61,25 @@ This is enough to compute the wattage as a function of the amount of loaded core - - +
#Cores loadedWattageExplanation
0 (idle) 100 Watts  Idle value
0 (not idle) 120 Watts Epsilon value
0 (idle) 100 Watts Idle value
1 140 Watts Linear extrapolation between Epsilon and AllCores
2 160 Watts Linear extrapolation between Epsilon and AllCores
3 180 Watts Linear extrapolation between Epsilon and AllCores
4 200 Watts AllCores value
+Here is how it looks graphically: + +.. image:: img/plugin-energy.svg + :scale: 80% + :align: center + +As you can see, the ``Epsilon`` parameter allows to freely specify the slope you want, while using the 2 parameters +version of the model (with only ``Idle`` and ``AllCores``) requires that the ``Idle`` value is on the extension of the +line crossing the consumption you mesure for each core amount. Please note that specifying the consumption for each core +amount separately was not a solution because parallel tasks can use an amount of cores that is not an integer. The good +news is that it was not necessary, as our experiments (detailed in the paper) show that the proposed linear model is +sufficient to capture reality. .. raw:: html @@ -93,8 +107,8 @@ This encodes the following values: To change the pstate of a given CPU, use the following functions: -:cpp:func:`MSG_host_get_nb_pstates()`, :cpp:func:`simgrid::s4u::Host::set_pstate()`, -:cpp:func:`MSG_host_get_power_peak_at()`. +:cpp:func:`sg_host_get_nb_pstates()`, :cpp:func:`simgrid::s4u::Host::set_pstate()`, +:cpp:func:`sg_host_get_pstate_speed()`. .. raw:: html @@ -109,13 +123,12 @@ before you can get accurate energy predictions. @endrst */ -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(host_energy, kernel, "Logging specific to the host energy plugin"); // Forwards declaration needed to make this function a friend (because friends have external linkage by default) static void on_simulation_end(); -namespace simgrid { -namespace plugin { +namespace simgrid::plugin { class PowerRange { public: @@ -131,6 +144,7 @@ class HostEnergy { simgrid::s4u::Host* host_ = nullptr; /*< List of (idle_power, epsilon_power, max_power) tuple corresponding to each cpu pstate */ std::vector power_range_watts_list_; + bool has_pstate_power_values_ = false; /*< Whether power consumption values were provided for all pstates */ /* We need to keep track of what pstate has been used, as we will sometimes be notified only *after* a pstate has been * used (but we need to update the energy consumption with the old pstate!) @@ -139,7 +153,7 @@ class HostEnergy { const int pstate_off_ = -1; double watts_off_ = 0.0; /*< Consumption when the machine is turned off (shutdown) */ double total_energy_ = 0.0; /*< Total energy consumed by the host */ - double last_updated_ = surf_get_clock(); /*< Timestamp of the last energy update event*/ + double last_updated_ = simgrid::s4u::Engine::get_clock(); /*< Timestamp of the last energy update event*/ /* Only used to split total energy into unused/used hosts. * If you want to get this info for something else, rather use the host_load plugin @@ -155,6 +169,8 @@ public: explicit HostEnergy(simgrid::s4u::Host* ptr); ~HostEnergy(); + bool has_pstate_power_values() const; + double get_current_watts_value(); double get_current_watts_value(double cpu_load) const; double get_consumed_energy(); @@ -168,11 +184,16 @@ public: simgrid::xbt::Extension HostEnergy::EXTENSION_ID; +/* Returns whether power consumption values were provided for all pstates. */ +bool HostEnergy::has_pstate_power_values() const { + return has_pstate_power_values_; +} + /* Computes the consumption so far. Called lazily on need. */ void HostEnergy::update() { double start_time = last_updated_; - double finish_time = surf_get_clock(); + double finish_time = simgrid::s4u::Engine::get_clock(); // // We may have start == finish if the past consumption was updated since the simcall was started // for example if 2 actors requested to update the same host's consumption in a given scheduling round. @@ -206,21 +227,12 @@ HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host_(ptr) init_watts_range_list(); const char* off_power_str = host_->get_property("wattage_off"); - if (off_power_str == nullptr) { - off_power_str = host_->get_property("watt_off"); - - static bool warned = false; - if (off_power_str != nullptr && not warned) { - warned = true; - XBT_WARN("Please use 'wattage_off' instead of 'watt_off' to define the idle wattage of hosts in your XML."); - } - } if (off_power_str != nullptr) { try { - this->watts_off_ = std::stod(std::string(off_power_str)); + this->watts_off_ = std::stod(off_power_str); } catch (const std::invalid_argument&) { - throw std::invalid_argument(std::string("Invalid value for property wattage_off of host ") + host_->get_cname() + - ": " + off_power_str); + throw std::invalid_argument("Invalid value for property wattage_off of host " + host_->get_name() + ": " + + off_power_str); } } /* watts_off is 0 by default */ @@ -230,29 +242,29 @@ HostEnergy::~HostEnergy() = default; double HostEnergy::get_watt_idle_at(int pstate) const { - xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", - host_->get_cname()); + if (not has_pstate_power_values_) + return 0.0; return power_range_watts_list_[pstate].idle_; } double HostEnergy::get_watt_min_at(int pstate) const { - xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", - host_->get_cname()); + if (not has_pstate_power_values_) + return 0.0; return power_range_watts_list_[pstate].epsilon_; } double HostEnergy::get_watt_max_at(int pstate) const { - xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", - host_->get_cname()); + if (not has_pstate_power_values_) + return 0.0; return power_range_watts_list_[pstate].max_; } double HostEnergy::get_power_range_slope_at(int pstate) const { - xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", - host_->get_cname()); + if (not has_pstate_power_values_) + return 0.0; return power_range_watts_list_[pstate].slope_; } @@ -294,8 +306,8 @@ double HostEnergy::get_current_watts_value() */ double HostEnergy::get_current_watts_value(double cpu_load) const { - xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", - host_->get_cname()); + if (not has_pstate_power_values_) + return 0.0; /* Return watts_off if pstate == pstate_off (ie, if the host is off) */ if (this->pstate_ == pstate_off_) { @@ -332,78 +344,17 @@ double HostEnergy::get_current_watts_value(double cpu_load) const double HostEnergy::get_consumed_energy() { - if (last_updated_ < surf_get_clock()) // We need to simcall this as it modifies the environment - simgrid::kernel::actor::simcall(std::bind(&HostEnergy::update, this)); + if (last_updated_ < simgrid::s4u::Engine::get_clock()) // We need to simcall this as it modifies the environment + simgrid::kernel::actor::simcall_answered(std::bind(&HostEnergy::update, this)); return total_energy_; } void HostEnergy::init_watts_range_list() { - const char* old_prop = host_->get_property("watt_per_state"); - if (old_prop != nullptr) { - std::vector all_power_values; - boost::split(all_power_values, old_prop, boost::is_any_of(",")); - - xbt_assert(all_power_values.size() == (unsigned)host_->get_pstate_count(), - "Invalid XML file. Found %zu energetic profiles for %d pstates", all_power_values.size(), - host_->get_pstate_count()); - - // XBT_ATTRIB_DEPRECATED_v328: putting this macro name here so that we find it during the deprecation cleanups - std::string msg = "DEPRECATION WARNING: Property 'watt_per_state' will only work until v3.28.\n"; - msg += std::string("The old syntax 'Idle:OneCore:AllCores' must be converted into 'Idle:Epsilon:AllCores' to " - "properly model the consumption of non-whole tasks on mono-core hosts. Here are the values to " - "use for host '") + - host_->get_cname() + "' in your XML file:\n"; - msg += " current_power_values; - boost::split(current_power_values, current_power_values_str, boost::is_any_of(":")); - double p_idle = xbt_str_parse_double((current_power_values.at(0)).c_str(), - "Invalid obsolete XML file. Fix your watt_per_state property."); - double p_full; - double p_epsilon; - - if (current_power_values.size() == 3) { - double p_one_core = xbt_str_parse_double((current_power_values.at(1)).c_str(), - "Invalid obsolete XML file. Fix your watt_per_state property."); - p_full = xbt_str_parse_double((current_power_values.at(2)).c_str(), - "Invalid obsolete XML file. Fix your watt_per_state property."); - if (host_->get_core_count() == 1) { - p_epsilon = p_full; - } else { - p_epsilon = p_one_core - ((p_full - p_one_core) / (host_->get_core_count() - 1)); - } - } else { // consumption given with idle and full only - p_full = xbt_str_parse_double((current_power_values.at(1)).c_str(), - "Invalid obsolete XML file. Fix your watt_per_state property."); - if (host_->get_core_count() == 1) { - p_epsilon = p_full; - } else { - p_epsilon = p_idle; - } - } - - PowerRange range(p_idle, p_epsilon, p_full); - power_range_watts_list_.push_back(range); - - msg += std::to_string(p_idle) + ":" + std::to_string(p_epsilon) + ":" + std::to_string(p_full); - msg += ","; - } - msg.pop_back(); // Remove the extraneous ',' - msg += "\" />"; - XBT_WARN("%s", msg.c_str()); - return; - } - const char* all_power_values_str = host_->get_property("wattage_per_state"); if (all_power_values_str == nullptr) { - /* If no power values are given, we assume it's 0 everywhere */ - XBT_DEBUG("No energetic profiles given for host %s, using 0 W by default.", host_->get_cname()); - for (int i = 0; i < host_->get_pstate_count(); ++i) { - PowerRange range(0,0,0); - power_range_watts_list_.push_back(range); - } + XBT_WARN("No energetic profiles (wattage_per_state) given for host %s, using 0 W by default. Direct request of power/energy consumption of this host will fail.", host_->get_cname()); return; } @@ -411,8 +362,8 @@ void HostEnergy::init_watts_range_list() boost::split(all_power_values, all_power_values_str, boost::is_any_of(",")); XBT_DEBUG("%s: power properties: %s", host_->get_cname(), all_power_values_str); - xbt_assert(all_power_values.size() == (unsigned)host_->get_pstate_count(), - "Invalid XML file. Found %zu energetic profiles for %d pstates", all_power_values.size(), + xbt_assert(all_power_values.size() == host_->get_pstate_count(), + "Invalid XML file. Found %zu energetic profiles for %lu pstates", all_power_values.size(), host_->get_pstate_count()); int i = 0; @@ -430,31 +381,29 @@ void HostEnergy::init_watts_range_list() double epsilon_power; double max_power; - char* msg_idle = bprintf("Invalid Idle value for pstate %d on host %s: %%s", i, host_->get_cname()); - char* msg_epsilon = bprintf("Invalid Epsilon value for pstate %d on host %s: %%s", i, host_->get_cname()); - char* msg_max = bprintf("Invalid AllCores value for pstate %d on host %s: %%s", i, host_->get_cname()); + auto msg_idle = xbt::string_printf("Invalid Idle value for pstate %d on host %s", i, host_->get_cname()); + auto msg_epsilon = xbt::string_printf("Invalid Epsilon value for pstate %d on host %s", i, host_->get_cname()); + auto msg_max = xbt::string_printf("Invalid AllCores value for pstate %d on host %s", i, host_->get_cname()); - idle_power = xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle); + idle_power = xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle.c_str()); if (current_power_values.size() == 2) { // Case: Idle:AllCores - epsilon_power = xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle); - max_power = xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_max); + epsilon_power = xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle.c_str()); + max_power = xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_max.c_str()); } else { // Case: Idle:Epsilon:AllCores - epsilon_power = xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_epsilon); - max_power = xbt_str_parse_double((current_power_values.at(2)).c_str(), msg_max); + epsilon_power = xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_epsilon.c_str()); + max_power = xbt_str_parse_double((current_power_values.at(2)).c_str(), msg_max.c_str()); } XBT_DEBUG("Creating PowerRange for host %s. Idle:%f, Epsilon:%f, AllCores:%f.", host_->get_cname(), idle_power, epsilon_power, max_power); PowerRange range(idle_power, epsilon_power, max_power); power_range_watts_list_.push_back(range); - xbt_free(msg_idle); - xbt_free(msg_epsilon); - xbt_free(msg_max); ++i; } + + has_pstate_power_values_ = true; } -} // namespace plugin -} // namespace simgrid +} // namespace simgrid::plugin using simgrid::plugin::HostEnergy; @@ -472,18 +421,17 @@ static void on_creation(simgrid::s4u::Host& host) static void on_action_state_change(simgrid::kernel::resource::CpuAction const& action, simgrid::kernel::resource::Action::State /*previous*/) { - for (simgrid::kernel::resource::Cpu* const& cpu : action.cpus()) { - simgrid::s4u::Host* host = cpu->get_host(); + for (simgrid::kernel::resource::CpuImpl const* cpu : action.cpus()) { + simgrid::s4u::Host* host = cpu->get_iface(); if (host != nullptr) { // If it's a VM, take the corresponding PM - const simgrid::s4u::VirtualMachine* vm = dynamic_cast(host); - if (vm) // If it's a VM, take the corresponding PM + if (const auto* vm = dynamic_cast(host)) host = vm->get_pm(); // Get the host_energy extension for the relevant host auto* host_energy = host->extension(); - if (host_energy->get_last_update_time() < surf_get_clock()) + if (host_energy->get_last_update_time() < simgrid::s4u::Engine::get_clock()) host_energy->update(); } } @@ -491,14 +439,13 @@ static void on_action_state_change(simgrid::kernel::resource::CpuAction const& a /* This callback is fired either when the host changes its state (on/off) ("onStateChange") or its speed * (because the user changed the pstate, or because of external trace events) ("onSpeedChange") */ -static void on_host_change(simgrid::s4u::Host const& host) +static void on_host_change(simgrid::s4u::Host const& h) { - if (dynamic_cast(&host)) // Ignore virtual machines - return; - - auto* host_energy = host.extension(); + const auto* host = &h; + if (const auto* vm = dynamic_cast(host)) // Take the PM of virtual machines + host = vm->get_pm(); - host_energy->update(); + host->extension()->update(); } static void on_host_destruction(simgrid::s4u::Host const& host) @@ -526,6 +473,12 @@ static void on_simulation_end() used_hosts_energy, total_energy - used_hosts_energy); } +static void on_activity_suspend_resume(simgrid::s4u::Activity const& activity) +{ + if (const auto* action = dynamic_cast(activity.get_impl()->model_action_)) + on_action_state_change(*action, /*ignored*/ action->get_state()); +} + /* **************************** Public interface *************************** */ /** @ingroup plugin_host_energy @@ -539,23 +492,26 @@ void sg_host_energy_plugin_init() HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create(); - simgrid::s4u::Host::on_creation.connect(&on_creation); - simgrid::s4u::Host::on_state_change.connect(&on_host_change); - simgrid::s4u::Host::on_speed_change.connect(&on_host_change); - simgrid::s4u::Host::on_destruction.connect(&on_host_destruction); - simgrid::s4u::Engine::on_simulation_end.connect(&on_simulation_end); - simgrid::kernel::resource::CpuAction::on_state_change.connect(&on_action_state_change); + simgrid::s4u::Host::on_creation_cb(&on_creation); + simgrid::s4u::Host::on_onoff_cb(&on_host_change); + simgrid::s4u::Host::on_speed_change_cb(&on_host_change); + simgrid::s4u::Host::on_destruction_cb(&on_host_destruction); + simgrid::s4u::Host::on_exec_state_change_cb(&on_action_state_change); + simgrid::s4u::VirtualMachine::on_suspend_cb(&on_host_change); + simgrid::s4u::VirtualMachine::on_resume_cb(&on_host_change); + simgrid::s4u::Exec::on_suspend_cb(on_activity_suspend_resume); + simgrid::s4u::Exec::on_resume_cb(on_activity_suspend_resume); + simgrid::s4u::Engine::on_simulation_end_cb(&on_simulation_end); // We may only have one actor on a node. If that actor executes something like // compute -> recv -> compute - // the recv operation will not trigger a "CpuAction::on_state_change". This means + // the recv operation will not trigger a "Host::on_exec_state_change_cb". This means // that the next trigger would be the 2nd compute, hence ignoring the idle time // during the recv call. By updating at the beginning of a compute, we can // fix that. (If the cpu is not idle, this is not required.) - simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::Exec const& activity, simgrid::s4u::Actor const&) { + simgrid::s4u::Exec::on_start_cb([](simgrid::s4u::Exec const& activity) { if (activity.get_host_number() == 1) { // We only run on one host - simgrid::s4u::Host* host = activity.get_host(); - const simgrid::s4u::VirtualMachine* vm = dynamic_cast(host); - if (vm != nullptr) + simgrid::s4u::Host* host = activity.get_host(); + if (const auto* vm = dynamic_cast(host)) host = vm->get_pm(); xbt_assert(host != nullptr); host->extension()->update(); @@ -571,7 +527,7 @@ void sg_host_energy_plugin_init() */ void sg_host_energy_update_all() { - simgrid::kernel::actor::simcall([]() { + simgrid::kernel::actor::simcall_answered([]() { std::vector list = simgrid::s4u::Engine::get_instance()->get_all_hosts(); for (auto const& host : list) if (dynamic_cast(host) == nullptr) { // Ignore virtual machines @@ -598,7 +554,10 @@ static void ensure_plugin_inited() double sg_host_get_consumed_energy(const_sg_host_t host) { ensure_plugin_inited(); - return host->extension()->get_consumed_energy(); + auto* host_energy = host->extension(); + xbt_assert(host_energy->has_pstate_power_values(), "No power range properties specified for host %s", + host->get_cname()); + return host_energy->get_consumed_energy(); } /** @ingroup plugin_host_energy @@ -649,5 +608,8 @@ double sg_host_get_power_range_slope_at(const_sg_host_t host, int pstate) double sg_host_get_current_consumption(const_sg_host_t host) { ensure_plugin_inited(); - return host->extension()->get_current_watts_value(); + auto* host_energy = host->extension(); + xbt_assert(host_energy->has_pstate_power_values(), "No power range properties specified for host %s", + host->get_cname()); + return host_energy->get_current_watts_value(); }