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