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