src/surf/plugins/host_energy.cpp

   1 /* Copyright (c) 2010, 2012-2016. The SimGrid Team. All rights reserved.    */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "simgrid/plugins/energy.h"
   7 #include "simgrid/simix.hpp"
   8 #include "src/plugins/vm/VirtualMachineImpl.hpp"
   9 #include "src/surf/cpu_interface.hpp"
  10 #include <utility>
  11
  12 /** @addtogroup SURF_plugin_energy
  13
  14
  15 This is the energy plugin, enabling to account not only for computation time,
  16 but also for the dissipated energy in the simulated platform.
  17
  18 The energy consumption of a CPU depends directly of its current load. Specify that consumption in your platform file as
  19 follows:
  20
  21 \verbatim
  22 <host id="HostA" power="100.0Mf" >
  23     <prop id="watt_per_state" value="100.0:200.0" />
  24     <prop id="watt_off" value="10" />
  25 </host>
  26 \endverbatim
  27
  28 The first property means that when your host is up and running, but without anything to do, it will dissipate 100 Watts.
  29 If it's fully loaded, it will dissipate 200 Watts. If its load is at 50%, then it will dissipate 150 Watts.
  30 The second property means that when your host is turned off, it will dissipate only 10 Watts (please note that these
  31 values are arbitrary).
  32
  33 If your CPU is using pstates, then you can provide one consumption interval per pstate.
  34
  35 \verbatim
  36 <host id="HostB" power="100.0Mf,50.0Mf,20.0Mf" pstate="0" >
  37     <prop id="watt_per_state" value="95.0:200.0, 93.0:170.0, 90.0:150.0" />
  38     <prop id="watt_off" value="10" />
  39 </host>
  40 \endverbatim
  41
  42 That host has 3 levels of performance with the following performance: 100 Mflop/s, 50 Mflop/s or 20 Mflop/s.
  43 It starts at pstate 0 (ie, at 100 Mflop/s). In this case, you have to specify one interval per pstate in the
  44 watt_per_state property.
  45 In this example, the idle consumption is 95 Watts, 93 Watts and 90 Watts in each pstate while the CPU burn consumption
  46 are at 200 Watts, 170 Watts, and 150 Watts respectively.
  47
  48 To change the pstate of a given CPU, use the following functions:
  49 #MSG_host_get_nb_pstates(), simgrid#s4u#Host#setPstate(), #MSG_host_get_power_peak_at().
  50
  51 To simulate the energy-related elements, first call the simgrid#energy#sg_energy_plugin_init() before your #MSG_init(),
  52 and then use the following function to retrieve the consumption of a given host: MSG_host_get_consumed_energy().
  53  */
  54
  55 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin");
  56
  57 namespace simgrid {
  58 namespace energy {
  59
  60 class XBT_PRIVATE HostEnergy;
  61
  62 class PowerRange {
  63 public:
  64   double idle;
  65   double min;
  66   double max;
  67
  68   PowerRange(double idle, double min, double max) : idle(idle), min(min), max(max) {}
  69 };
  70
  71 class HostEnergy {
  72 public:
  73   static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
  74
  75   explicit HostEnergy(simgrid::s4u::Host* ptr);
  76   ~HostEnergy();
  77
  78   double getCurrentWattsValue(double cpu_load);
  79   double getConsumedEnergy();
  80   double getWattMinAt(int pstate);
  81   double getWattMaxAt(int pstate);
  82   void update();
  83
  84 private:
  85   void initWattsRangeList();
  86   simgrid::s4u::Host* host = nullptr;
  87   std::vector<PowerRange>
  88       power_range_watts_list; /*< List of (min_power,max_power) pairs corresponding to each cpu pstate */
  89 public:
  90   double watts_off    = 0.0; /*< Consumption when the machine is turned off (shutdown) */
  91   double total_energy = 0.0; /*< Total energy consumed by the host */
  92   double last_updated;       /*< Timestamp of the last energy update event*/
  93 };
  94
  95 simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
  96
  97 /* Computes the consumption so far.  Called lazily on need. */
  98 void HostEnergy::update()
  99 {
 100   double start_time  = this->last_updated;
 101   double finish_time = surf_get_clock();
 102   double cpu_load;
 103   if (host->pimpl_cpu->getPstateSpeedCurrent() <= 0)
 104     // Some users declare a pstate of speed 0 flops (e.g., to model boot time).
 105     // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN
 106     cpu_load = 1;
 107   else
 108     cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / host->pimpl_cpu->getPstateSpeedCurrent();
 109
 110   /** Divide by the number of cores here **/
 111   cpu_load /= host->pimpl_cpu->coreCount();
 112
 113   if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more
 114     cpu_load = 1;
 115
 116   /* The problem with this model is that the load is always 0 or 1, never something less.
 117    * Another possibility could be to model the total energy as
 118    *
 119    *   X/(X+Y)*W_idle + Y/(X+Y)*W_burn
 120    *
 121    * where X is the amount of idling cores, and Y the amount of computing cores.
 122    */
 123
 124   double previous_energy = this->total_energy;
 125
 126   double instantaneous_consumption;
 127   if (host->isOff())
 128     instantaneous_consumption = this->watts_off;
 129   else
 130     instantaneous_consumption = this->getCurrentWattsValue(cpu_load);
 131
 132   double energy_this_step = instantaneous_consumption * (finish_time - start_time);
 133
 134   this->total_energy = previous_energy + energy_this_step;
 135   this->last_updated = finish_time;
 136
 137   XBT_DEBUG(
 138       "[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> %.2f J",
 139       host->cname(), start_time, finish_time, host->pimpl_cpu->speed_.peak, previous_energy, energy_this_step);
 140 }
 141
 142 HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host(ptr), last_updated(surf_get_clock())
 143 {
 144   initWattsRangeList();
 145
 146   const char* off_power_str = host->property("watt_off");
 147   if (off_power_str != nullptr) {
 148     char* msg       = bprintf("Invalid value for property watt_off of host %s: %%s", host->cname());
 149     this->watts_off = xbt_str_parse_double(off_power_str, msg);
 150     xbt_free(msg);
 151   }
 152   /* watts_off is 0 by default */
 153 }
 154
 155 HostEnergy::~HostEnergy() = default;
 156
 157 double HostEnergy::getWattMinAt(int pstate)
 158 {
 159   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
 160   return power_range_watts_list[pstate].min;
 161 }
 162
 163 double HostEnergy::getWattMaxAt(int pstate)
 164 {
 165   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
 166   return power_range_watts_list[pstate].max;
 167 }
 168
 169 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
 170 double HostEnergy::getCurrentWattsValue(double cpu_load)
 171 {
 172   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
 173
 174   /* min_power corresponds to the idle power (cpu load = 0) */
 175   /* max_power is the power consumed at 100% cpu load       */
 176   auto range           = power_range_watts_list.at(host->pstate());
 177   double current_power = 0;
 178   double min_power     = 0;
 179   double max_power     = 0;
 180   double power_slope   = 0;
 181
 182   if (cpu_load > 0) { /* Something is going on, the machine is not idle */
 183     double min_power = range.min;
 184     double max_power = range.max;
 185
 186     /**
 187      * The min_power states how much we consume when only one single
 188      * core is working. This means that when cpu_load == 1/coreCount, then
 189      * current_power == min_power.
 190      *
 191      * The maximum must be reached when all cores are working (but 1 core was
 192      * already accounted for by min_power)
 193      * i.e., we need min_power + (maxCpuLoad-1/coreCount)*power_slope == max_power
 194      * (maxCpuLoad is by definition 1)
 195      */
 196     double power_slope;
 197     int coreCount         = host->coreCount();
 198     double coreReciprocal = static_cast<double>(1) / static_cast<double>(coreCount);
 199     if (coreCount > 1)
 200       power_slope = (max_power - min_power) / (1 - coreReciprocal);
 201     else
 202       power_slope = 0; // Should be 0, since max_power == min_power (in this case)
 203
 204     current_power = min_power + (cpu_load - coreReciprocal) * power_slope;
 205   } else { /* Our machine is idle, take the dedicated value! */
 206     current_power = range.idle;
 207   }
 208
 209   XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
 210   XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
 211
 212   return current_power;
 213 }
 214
 215 double HostEnergy::getConsumedEnergy()
 216 {
 217   if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
 218     simgrid::simix::kernelImmediate(std::bind(&HostEnergy::update, this));
 219
 220   return total_energy;
 221 }
 222
 223 void HostEnergy::initWattsRangeList()
 224 {
 225   const char* all_power_values_str = host->property("watt_per_state");
 226   if (all_power_values_str == nullptr)
 227     return;
 228
 229   xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
 230   int pstate_nb                = xbt_dynar_length(all_power_values);
 231
 232   for (int i = 0; i < pstate_nb; i++) {
 233     /* retrieve the power values associated with the current pstate */
 234     xbt_dynar_t current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
 235     xbt_assert(xbt_dynar_length(current_power_values) == 3,
 236                "Power properties incorrectly defined - could not retrieve idle, min and max power values for host %s",
 237                host->cname());
 238
 239     /* min_power corresponds to the idle power (cpu load = 0) */
 240     /* max_power is the power consumed at 100% cpu load       */
 241     char* msg_idle = bprintf("Invalid idle value for pstate %d on host %s: %%s", i, host->cname());
 242     char* msg_min  = bprintf("Invalid min value for pstate %d on host %s: %%s", i, host->cname());
 243     char* msg_max  = bprintf("Invalid max value for pstate %d on host %s: %%s", i, host->cname());
 244     PowerRange range(xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 0, char*), msg_idle),
 245                      xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 1, char*), msg_min),
 246                      xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 2, char*), msg_max));
 247     power_range_watts_list.push_back(range);
 248     xbt_free(msg_idle);
 249     xbt_free(msg_min);
 250     xbt_free(msg_max);
 251
 252     xbt_dynar_free(&current_power_values);
 253   }
 254   xbt_dynar_free(&all_power_values);
 255 }
 256 }
 257 }
 258
 259 using simgrid::energy::HostEnergy;
 260
 261 /* **************************** events  callback *************************** */
 262 static void onCreation(simgrid::s4u::Host& host)
 263 {
 264   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
 265     return;
 266   host.extension_set(new HostEnergy(&host));
 267 }
 268
 269 static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf::Action::State previous)
 270 {
 271   for (simgrid::surf::Cpu* cpu : action->cpus()) {
 272     simgrid::s4u::Host* host = cpu->getHost();
 273     if (host == nullptr)
 274       continue;
 275
 276     // If it's a VM, take the corresponding PM
 277     simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
 278     if (vm) // If it's a VM, take the corresponding PM
 279       host = vm->pimpl_vm_->getPm();
 280
 281     // Get the host_energy extension for the relevant host
 282     HostEnergy* host_energy = host->extension<HostEnergy>();
 283
 284     if (host_energy->last_updated < surf_get_clock())
 285       host_energy->update();
 286   }
 287 }
 288
 289 static void onHostStateChange(simgrid::s4u::Host& host)
 290 {
 291   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
 292     return;
 293
 294   HostEnergy* host_energy = host.extension<HostEnergy>();
 295
 296   if (host_energy->last_updated < surf_get_clock())
 297     host_energy->update();
 298 }
 299
 300 static void onHostDestruction(simgrid::s4u::Host& host)
 301 {
 302   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
 303     return;
 304
 305   HostEnergy* host_energy = host.extension<HostEnergy>();
 306   host_energy->update();
 307   XBT_INFO("Total energy of host %s: %f Joules", host.cname(), host_energy->getConsumedEnergy());
 308 }
 309
 310 /* **************************** Public interface *************************** */
 311 /** \ingroup SURF_plugin_energy
 312  * \brief Enable energy plugin
 313  * \details Enable energy plugin to get joules consumption of each cpu. You should call this function before
 314  * #MSG_init().
 315  */
 316 void sg_host_energy_plugin_init()
 317 {
 318   if (HostEnergy::EXTENSION_ID.valid())
 319     return;
 320
 321   HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
 322
 323   simgrid::s4u::Host::onCreation.connect(&onCreation);
 324   simgrid::s4u::Host::onStateChange.connect(&onHostStateChange);
 325   simgrid::s4u::Host::onDestruction.connect(&onHostDestruction);
 326   simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
 327 }
 328
 329 /** @brief Returns the total energy consumed by the host so far (in Joules)
 330  *
 331  *  See also @ref SURF_plugin_energy.
 332  */
 333 double sg_host_get_consumed_energy(sg_host_t host)
 334 {
 335   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 336              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
 337   return host->extension<HostEnergy>()->getConsumedEnergy();
 338 }
 339
 340 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
 341 double sg_host_get_wattmin_at(sg_host_t host, int pstate)
 342 {
 343   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 344              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
 345   return host->extension<HostEnergy>()->getWattMinAt(pstate);
 346 }
 347 /** @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
 348 double sg_host_get_wattmax_at(sg_host_t host, int pstate)
 349 {
 350   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 351              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
 352   return host->extension<HostEnergy>()->getWattMaxAt(pstate);
 353 }