/* 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"
/** @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
};
class HostEnergy {
+ simgrid::s4u::Host* host_ = nullptr;
+ /*< List of (idle_power, epsilon_power, max_power) tuple corresponding to each cpu pstate */
+ std::vector<PowerRange> 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<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
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);
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<PowerRange> 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*/
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 */
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.");
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)
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
// 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?
std::vector<std::string> 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 '") +
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) {
} 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) {
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<std::string> 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 */
if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&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));
}
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<simgrid::s4u::VirtualMachine*>(host);
if (vm) // If it's a VM, take the corresponding PM
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<simgrid::s4u::VirtualMachine*>(hosts[i]) == nullptr) { // Ignore virtual machines
-
double energy = hosts[i]->extension<HostEnergy>()->get_consumed_energy();
total_energy += energy;
if (hosts[i]->extension<HostEnergy>()->host_was_used_)
});
}
+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)
*
*/
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<HostEnergy>()->get_consumed_energy();
}
*/
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<HostEnergy>()->get_idle_consumption();
+ ensure_plugin_inited();
+ return host->extension<HostEnergy>()->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)
+{
+ ensure_plugin_inited();
+ return host->extension<HostEnergy>()->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(),
- "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
+ ensure_plugin_inited();
return host->extension<HostEnergy>()->get_watt_min_at(pstate);
}
/** @ingroup plugin_host_energy
*/
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<HostEnergy>()->get_watt_max_at(pstate);
}
/** @ingroup plugin_host_energy
*/
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<HostEnergy>()->get_power_range_slope_at(pstate);
}
/** @ingroup plugin_host_energy
*/
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<HostEnergy>()->get_current_watts_value();
}