src/surf/plugins/energy.cpp

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