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 PowerRange {
  61 public:
  62   double idle;
  63   double min;
  64   double max;
  65
  66   PowerRange(double idle, double min, double max) : idle(idle), min(min), max(max) {}
  67 };
  68
  69 class HostEnergy {
  70 public:
  71   static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
  72
  73   explicit HostEnergy(simgrid::s4u::Host* ptr);
  74   ~HostEnergy();
  75
  76   double getCurrentWattsValue(double cpu_load);
  77   double getConsumedEnergy();
  78   double getWattMinAt(int pstate);
  79   double getWattMaxAt(int pstate);
  80   void update();
  81
  82 private:
  83   void initWattsRangeList();
  84   simgrid::s4u::Host* host = nullptr;
  85   std::vector<PowerRange>
  86       power_range_watts_list; /*< List of (min_power,max_power) pairs corresponding to each cpu pstate */
  87 public:
  88   double watts_off    = 0.0; /*< Consumption when the machine is turned off (shutdown) */
  89   double total_energy = 0.0; /*< Total energy consumed by the host */
  90   double last_updated;       /*< Timestamp of the last energy update event*/
  91 };
  92
  93 simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
  94
  95 /* Computes the consumption so far.  Called lazily on need. */
  96 void HostEnergy::update()
  97 {
  98   double start_time  = this->last_updated;
  99   double finish_time = surf_get_clock();
 100   double cpu_load;
 101   if (host->pimpl_cpu->getPstateSpeedCurrent() <= 0)
 102     // Some users declare a pstate of speed 0 flops (e.g., to model boot time).
 103     // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN
 104     cpu_load = 1;
 105   else
 106     cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / host->pimpl_cpu->getPstateSpeedCurrent();
 107
 108   /** Divide by the number of cores here **/
 109   cpu_load /= host->pimpl_cpu->coreCount();
 110
 111   if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more
 112     cpu_load = 1;
 113
 114   /* The problem with this model is that the load is always 0 or 1, never something less.
 115    * Another possibility could be to model the total energy as
 116    *
 117    *   X/(X+Y)*W_idle + Y/(X+Y)*W_burn
 118    *
 119    * where X is the amount of idling cores, and Y the amount of computing cores.
 120    */
 121
 122   double previous_energy = this->total_energy;
 123
 124   double instantaneous_consumption;
 125   if (host->isOff())
 126     instantaneous_consumption = this->watts_off;
 127   else
 128     instantaneous_consumption = this->getCurrentWattsValue(cpu_load);
 129
 130   double energy_this_step = instantaneous_consumption * (finish_time - start_time);
 131
 132   this->total_energy = previous_energy + energy_this_step;
 133   this->last_updated = finish_time;
 134
 135   XBT_DEBUG(
 136       "[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> %.2f J",
 137       host->cname(), start_time, finish_time, host->pimpl_cpu->speed_.peak, previous_energy, energy_this_step);
 138 }
 139
 140 HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host(ptr), last_updated(surf_get_clock())
 141 {
 142   initWattsRangeList();
 143
 144   const char* off_power_str = host->property("watt_off");
 145   if (off_power_str != nullptr) {
 146     char* msg       = bprintf("Invalid value for property watt_off of host %s: %%s", host->cname());
 147     this->watts_off = xbt_str_parse_double(off_power_str, msg);
 148     xbt_free(msg);
 149   }
 150   /* watts_off is 0 by default */
 151 }
 152
 153 HostEnergy::~HostEnergy() = default;
 154
 155 double HostEnergy::getWattMinAt(int pstate)
 156 {
 157   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
 158   return power_range_watts_list[pstate].min;
 159 }
 160
 161 double HostEnergy::getWattMaxAt(int pstate)
 162 {
 163   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
 164   return power_range_watts_list[pstate].max;
 165 }
 166
 167 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
 168 double HostEnergy::getCurrentWattsValue(double cpu_load)
 169 {
 170   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
 171
 172   /* min_power corresponds to the idle power (cpu load = 0) */
 173   /* max_power is the power consumed at 100% cpu load       */
 174   auto range           = power_range_watts_list.at(host->pstate());
 175   double current_power = 0;
 176   double min_power     = 0;
 177   double max_power     = 0;
 178   double power_slope   = 0;
 179
 180   if (cpu_load > 0) { /* Something is going on, the machine is not idle */
 181     double min_power = range.min;
 182     double max_power = range.max;
 183
 184     /**
 185      * The min_power states how much we consume when only one single
 186      * core is working. This means that when cpu_load == 1/coreCount, then
 187      * current_power == min_power.
 188      *
 189      * The maximum must be reached when all cores are working (but 1 core was
 190      * already accounted for by min_power)
 191      * i.e., we need min_power + (maxCpuLoad-1/coreCount)*power_slope == max_power
 192      * (maxCpuLoad is by definition 1)
 193      */
 194     double power_slope;
 195     int coreCount         = host->coreCount();
 196     double coreReciprocal = static_cast<double>(1) / static_cast<double>(coreCount);
 197     if (coreCount > 1)
 198       power_slope = (max_power - min_power) / (1 - coreReciprocal);
 199     else
 200       power_slope = 0; // Should be 0, since max_power == min_power (in this case)
 201
 202     current_power = min_power + (cpu_load - coreReciprocal) * power_slope;
 203   } else { /* Our machine is idle, take the dedicated value! */
 204     current_power = range.idle;
 205   }
 206
 207   XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
 208   XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
 209
 210   return current_power;
 211 }
 212
 213 double HostEnergy::getConsumedEnergy()
 214 {
 215   if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
 216     simgrid::simix::kernelImmediate(std::bind(&HostEnergy::update, this));
 217
 218   return total_energy;
 219 }
 220
 221 void HostEnergy::initWattsRangeList()
 222 {
 223   const char* all_power_values_str = host->property("watt_per_state");
 224   if (all_power_values_str == nullptr)
 225     return;
 226
 227   xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
 228   int pstate_nb                = xbt_dynar_length(all_power_values);
 229
 230   for (int i = 0; i < pstate_nb; i++) {
 231     /* retrieve the power values associated with the current pstate */
 232     xbt_dynar_t current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
 233     xbt_assert(xbt_dynar_length(current_power_values) == 3,
 234                "Power properties incorrectly defined - could not retrieve idle, min and max power values for host %s",
 235                host->cname());
 236
 237     /* min_power corresponds to the idle power (cpu load = 0) */
 238     /* max_power is the power consumed at 100% cpu load       */
 239     char* msg_idle = bprintf("Invalid idle value for pstate %d on host %s: %%s", i, host->cname());
 240     char* msg_min  = bprintf("Invalid min value for pstate %d on host %s: %%s", i, host->cname());
 241     char* msg_max  = bprintf("Invalid max value for pstate %d on host %s: %%s", i, host->cname());
 242     PowerRange range(xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 0, char*), msg_idle),
 243                      xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 1, char*), msg_min),
 244                      xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 2, char*), msg_max));
 245     power_range_watts_list.push_back(range);
 246     xbt_free(msg_idle);
 247     xbt_free(msg_min);
 248     xbt_free(msg_max);
 249
 250     xbt_dynar_free(&current_power_values);
 251   }
 252   xbt_dynar_free(&all_power_values);
 253 }
 254 }
 255 }
 256
 257 using simgrid::energy::HostEnergy;
 258
 259 /* **************************** events  callback *************************** */
 260 static void onCreation(simgrid::s4u::Host& host)
 261 {
 262   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
 263     return;
 264   host.extension_set(new HostEnergy(&host));
 265 }
 266
 267 static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf::Action::State previous)
 268 {
 269   for (simgrid::surf::Cpu* cpu : action->cpus()) {
 270     simgrid::s4u::Host* host = cpu->getHost();
 271     if (host == nullptr)
 272       continue;
 273
 274     // If it's a VM, take the corresponding PM
 275     simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
 276     if (vm) // If it's a VM, take the corresponding PM
 277       host = vm->pimpl_vm_->getPm();
 278
 279     // Get the host_energy extension for the relevant host
 280     HostEnergy* host_energy = host->extension<HostEnergy>();
 281
 282     if (host_energy->last_updated < surf_get_clock())
 283       host_energy->update();
 284   }
 285 }
 286
 287 /* This callback is fired either when the host change its state (on/off) or its speed
 288  * (because the user changed the pstate, or because of external trace events) */
 289 static void onHostChange(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 host energy plugin
 313  * \details Enable energy plugin to get joules consumption of each cpu. Call this function before #MSG_init().
 314  */
 315 void sg_host_energy_plugin_init()
 316 {
 317   if (HostEnergy::EXTENSION_ID.valid())
 318     return;
 319
 320   HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
 321
 322   simgrid::s4u::Host::onCreation.connect(&onCreation);
 323   simgrid::s4u::Host::onStateChange.connect(&onHostChange);
 324   simgrid::s4u::Host::onSpeedChange.connect(&onHostChange);
 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 }