X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/cc8d2ce4d1db8900ad36293537ce7a0f7091cc3f..101c8b10d9965e115c9ff5c28954750a065cf155:/src/plugins/host_energy.cpp diff --git a/src/plugins/host_energy.cpp b/src/plugins/host_energy.cpp index b5968923e6..c7ea34026a 100644 --- a/src/plugins/host_energy.cpp +++ b/src/plugins/host_energy.cpp @@ -3,6 +3,7 @@ /* 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" @@ -18,7 +19,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 @@ -124,7 +125,24 @@ public: }; 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_; + + /* 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!) + */ + int pstate_ = 0; + const int pstate_off_ = -1; + + /* 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 + */ + bool host_was_used_ = false; + + void init_watts_range_list(); friend void ::on_simulation_end(); // For access to host_was_used_ + public: static simgrid::xbt::Extension EXTENSION_ID; @@ -140,23 +158,6 @@ public: double get_power_range_slope_at(int pstate); void update(); -private: - void init_watts_range_list(); - 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_; - - /* 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!) - */ - int pstate_ = 0; - const int pstate_off_ = -1; - - /* 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 - */ - bool host_was_used_ = false; -public: 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_; /*< Timestamp of the last energy update event*/ @@ -187,9 +188,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 +201,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."); @@ -226,7 +229,6 @@ 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_[pstate].idle_; } @@ -246,9 +248,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 +271,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? @@ -341,10 +343,11 @@ void HostEnergy::init_watts_range_list() 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 %lu energetic profiles for %d pstates", - all_power_values.size(), host_->get_pstate_count()); + "Invalid XML file. Found %zu energetic profiles for %d pstates", all_power_values.size(), + host_->get_pstate_count()); - std::string msg = std::string("DEPRECATION WARNING: Property 'watt_per_state' will not work after v3.28.\n"); + // 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 '") + @@ -355,15 +358,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_idle = xbt_str_parse_double((current_power_values.at(0)).c_str(), - "Invalid obsolete XML file. Fix your watt_per_state property."); - 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) { @@ -371,9 +371,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 - p_idle = xbt_str_parse_double((current_power_values.at(0)).c_str(), - "Invalid obsolete XML file. Fix your watt_per_state property."); + } 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) { @@ -394,17 +392,25 @@ 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 %lu energetic profiles for %d pstates", - all_power_values.size(), 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) { @@ -455,7 +461,7 @@ static void on_creation(simgrid::s4u::Host& host) if (dynamic_cast(&host)) // Ignore virtual machines return; - // TODO Trace: set to zero the energy variable associated to host->getName() + // TODO Trace: set to zero the energy variable associated to host->get_name() host.extension_set(new HostEnergy(&host)); } @@ -466,7 +472,6 @@ static void on_action_state_change(simgrid::kernel::resource::CpuAction const& a for (simgrid::kernel::resource::Cpu* const& cpu : action.cpus()) { simgrid::s4u::Host* host = cpu->get_host(); if (host != nullptr) { - // If it's a VM, take the corresponding PM simgrid::s4u::VirtualMachine* vm = dynamic_cast(host); if (vm) // If it's a VM, take the corresponding PM @@ -510,7 +515,6 @@ static void on_simulation_end() double used_hosts_energy = 0.0; // Energy consumed by hosts that computed something for (size_t i = 0; i < hosts.size(); i++) { if (dynamic_cast(hosts[i]) == nullptr) { // Ignore virtual machines - double energy = hosts[i]->extension()->get_consumed_energy(); total_energy += energy; if (hosts[i]->extension()->host_was_used_) @@ -576,6 +580,13 @@ void sg_host_energy_update_all() }); } +static void ensure_plugin_inited() +{ + if (not HostEnergy::EXTENSION_ID.valid()) + throw simgrid::xbt::InitializationError("The Energy plugin is not active. Please call sg_host_energy_plugin_init() " + "before calling any function related to that plugin."); +} + /** @ingroup plugin_host_energy * @brief Returns the total energy consumed by the host so far (in Joules) * @@ -585,28 +596,34 @@ void sg_host_energy_update_all() */ double sg_host_get_consumed_energy(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."); + ensure_plugin_inited(); return host->extension()->get_consumed_energy(); } +/** @ingroup plugin_host_energy + * @brief Get the amount of watt dissipated when the host is idling + */ +double sg_host_get_idle_consumption(sg_host_t host) +{ + ensure_plugin_inited(); + 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_wattidle_at(sg_host_t host, int pstate) +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."); + ensure_plugin_inited(); 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 idling + * @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(), - "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization."); + ensure_plugin_inited(); return host->extension()->get_watt_min_at(pstate); } /** @ingroup plugin_host_energy @@ -614,8 +631,7 @@ double sg_host_get_wattmin_at(sg_host_t host, int pstate) */ double sg_host_get_wattmax_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."); + ensure_plugin_inited(); return host->extension()->get_watt_max_at(pstate); } /** @ingroup plugin_host_energy @@ -623,8 +639,7 @@ double sg_host_get_wattmax_at(sg_host_t host, int pstate) */ double sg_host_get_power_range_slope_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."); + ensure_plugin_inited(); return host->extension()->get_power_range_slope_at(pstate); } /** @ingroup plugin_host_energy @@ -632,7 +647,6 @@ double sg_host_get_power_range_slope_at(sg_host_t host, int pstate) */ double sg_host_get_current_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."); + ensure_plugin_inited(); return host->extension()->get_current_watts_value(); }