X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/67d3309c513219e94245694e6cfccacc19885e96..271068c7d949ed959313b055466e13539485bc2c:/src/plugins/host_energy.cpp diff --git a/src/plugins/host_energy.cpp b/src/plugins/host_energy.cpp index 323884422e..45d75ed3db 100644 --- a/src/plugins/host_energy.cpp +++ b/src/plugins/host_energy.cpp @@ -18,7 +18,7 @@ SIMGRID_REGISTER_PLUGIN(host_energy, "Cpu energy consumption.", &sg_host_energy_ /** @defgroup plugin_host_energy - @rst + @beginrst This is the energy plugin, enabling to account not only for computation time, but also for the dissipated energy in the simulated platform. To activate this plugin, first call :cpp:func:`sg_host_energy_plugin_init()` before your :cpp:func:`MSG_init()`, and then use @@ -134,7 +134,7 @@ public: double get_current_watts_value(); double get_current_watts_value(double cpu_load); double get_consumed_energy(); - double get_idle_consumption(); + double get_watt_idle_at(int pstate); double get_watt_min_at(int pstate); double get_watt_max_at(int pstate); double get_power_range_slope_at(int pstate); @@ -187,9 +187,10 @@ void HostEnergy::update() this->total_energy_ = previous_energy + energy_this_step; this->last_updated_ = finish_time; - XBT_DEBUG("[update_energy of %s] period=[%.8f-%.8f]; current speed=%.2E flop/s (pstate %i); total consumption before: %.8f J -> added now: %.8f J", - host_->get_cname(), start_time, finish_time, host_->pimpl_cpu->get_pstate_peak_speed(this->pstate_), this->pstate_, previous_energy, - energy_this_step); + XBT_DEBUG("[update_energy of %s] period=[%.8f-%.8f]; current speed=%.2E flop/s (pstate %i); total consumption " + "before: %.8f J -> added now: %.8f J", + host_->get_cname(), start_time, finish_time, host_->get_pstate_speed(this->pstate_), this->pstate_, + previous_energy, energy_this_step); } /* Save data for the upcoming time interval: whether it's on/off and the pstate if it's on */ @@ -199,11 +200,12 @@ void HostEnergy::update() HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host_(ptr), last_updated_(surf_get_clock()) { init_watts_range_list(); - static bool warned = false; 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."); @@ -222,12 +224,11 @@ HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host_(ptr), last_updated_(surf HostEnergy::~HostEnergy() = default; -double HostEnergy::get_idle_consumption() +double HostEnergy::get_watt_idle_at(int pstate) { xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", host_->get_cname()); - - return power_range_watts_list_[0].idle_; + return power_range_watts_list_[pstate].idle_; } double HostEnergy::get_watt_min_at(int pstate) @@ -246,9 +247,9 @@ double HostEnergy::get_watt_max_at(int pstate) double HostEnergy::get_power_range_slope_at(int pstate) { - xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", - host_->get_cname()); - return power_range_watts_list_[pstate].slope_; + xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s", + host_->get_cname()); + return power_range_watts_list_[pstate].slope_; } /** @brief Computes the power consumed by the host according to the current situation @@ -269,10 +270,10 @@ double HostEnergy::get_current_watts_value() // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN cpu_load = 1; else { - cpu_load = host_->pimpl_cpu->get_constraint()->get_usage() / current_speed; + cpu_load = host_->get_load() / current_speed; /* Divide by the number of cores here to have a value between 0 and 1 */ - cpu_load /= host_->pimpl_cpu->get_core_count(); + cpu_load /= host_->get_core_count(); if (cpu_load > 1) // This condition is true for energy_ptask on 32 bits, even if cpu_load is displayed as 1.000000 cpu_load = 1; // That may be an harmless rounding error? @@ -340,7 +341,12 @@ void HostEnergy::init_watts_range_list() std::vector all_power_values; boost::split(all_power_values, old_prop, boost::is_any_of(",")); - std::string msg = std::string("DEPRECATION WARNING: Property 'watt_per_state' will not work after v3.28.\n"); + 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 = std::string("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 '") + @@ -351,13 +357,12 @@ void HostEnergy::init_watts_range_list() 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_one_core; double p_full; double p_epsilon; if (current_power_values.size() == 3) { - p_one_core = xbt_str_parse_double((current_power_values.at(1)).c_str(), - "Invalid obsolete XML file. Fix your watt_per_state property."); + 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) { @@ -365,7 +370,7 @@ void HostEnergy::init_watts_range_list() } else { p_epsilon = p_one_core - ((p_full - p_one_core) / (host_->get_core_count() - 1)); } - } else { // consuption given with idle and full only + } 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) { @@ -386,14 +391,26 @@ void HostEnergy::init_watts_range_list() 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 (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); + } return; + } std::vector all_power_values; 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(), + host_->get_pstate_count()); + int i = 0; for (auto const& current_power_values_str : all_power_values) { /* retrieve the power values associated with the pstate i */ @@ -585,12 +602,22 @@ double sg_host_get_idle_consumption(sg_host_t host) { xbt_assert(HostEnergy::EXTENSION_ID.valid(), "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization."); - return host->extension()->get_idle_consumption(); + return host->extension()->get_watt_idle_at(0); } /** @ingroup plugin_host_energy * @brief Get the amount of watt dissipated at the given pstate when the host is idling */ +double sg_host_get_idle_consumption_at(sg_host_t host, int pstate) +{ + xbt_assert(HostEnergy::EXTENSION_ID.valid(), + "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization."); + return host->extension()->get_watt_idle_at(pstate); +} + +/** @ingroup plugin_host_energy + * @brief Get the amount of watt dissipated at the given pstate when the host is at 0 or epsilon% CPU usage. + */ double sg_host_get_wattmin_at(sg_host_t host, int pstate) { xbt_assert(HostEnergy::EXTENSION_ID.valid(),