another bunch of codefactor style issues

[simgrid.git] / src / plugins / host_energy.cpp

diff --git a/src/plugins/host_energy.cpp b/src/plugins/host_energy.cpp
index b596892..c7ea340 100644 (file)
--- 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. */
 
 /* 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 "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
 
 
 /** @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
 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 {
 };
 
 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_
   friend void ::on_simulation_end(); // For access to host_was_used_

+

 public:
   static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
 
 public:
   static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
 


@@ -140,23 +158,6 @@ public:
   double get_power_range_slope_at(int pstate);
   void update();
 
   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*/
   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;
 
     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 */
   }
 
   /* 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();
 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");
 
   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 && 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());
 {
   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_;
 }
 
   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)
 {
 
 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
 }
 
 /** @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 {
     // 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 */
 
     /* 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?
 
     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(),
     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 '") +
     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.");
       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) {
       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) {
         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 {
           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) {
         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;
   }
     XBT_WARN("%s", msg.c_str());
     return;
   }

+

   const char* all_power_values_str = host_->get_property("wattage_per_state");
   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;
     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(),
 
   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 %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) {
 
   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<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
     return;
 
   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));
 }
 
   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) {
   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
       // 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


@@ -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<simgrid::s4u::VirtualMachine*>(hosts[i]) == nullptr) { // Ignore virtual machines
   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_)
       double energy      = hosts[i]->extension<HostEnergy>()->get_consumed_energy();
       total_energy += energy;
       if (hosts[i]->extension<HostEnergy>()->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)
  *
 /** @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)
 {
  */
 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();
 }
 
   return host->extension<HostEnergy>()->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<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
  */
 /** @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<HostEnergy>()->get_watt_idle_at(pstate);
 }
 
 /** @ingroup plugin_host_energy
   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 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)
 {
  */
 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
   return host->extension<HostEnergy>()->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)
 {
  */
 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
   return host->extension<HostEnergy>()->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)
 {
  */
 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
   return host->extension<HostEnergy>()->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)
 {
  */
 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();
 }
   return host->extension<HostEnergy>()->get_current_watts_value();
 }