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 }
 118
 119 double HostEnergy::getWattMinAt(int pstate)
 120 {
 121   xbt_assert(!power_range_watts_list.empty(),
 122     "No power range properties specified for host %s", host->getName().c_str());
 123   return power_range_watts_list[pstate].first;
 124 }
 125
 126 double HostEnergy::getWattMaxAt(int pstate)
 127 {
 128   xbt_assert(!power_range_watts_list.empty(),
 129     "No power range properties specified for host %s", host->getName().c_str());
 130   return power_range_watts_list[pstate].second;
 131 }
 132
 133 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
 134 double HostEnergy::getCurrentWattsValue(double cpu_load)
 135 {
 136         xbt_assert(!power_range_watts_list.empty(),
 137     "No power range properties specified for host %s", host->getName().c_str());
 138
 139   /* min_power corresponds to the idle power (cpu load = 0) */
 140   /* max_power is the power consumed at 100% cpu load       */
 141   auto range = power_range_watts_list.at(host->getPState());
 142   double min_power = range.first;
 143   double max_power = range.second;
 144   double power_slope = max_power - min_power;
 145         double current_power = min_power + cpu_load * power_slope;
 146
 147         XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
 148         XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
 149
 150         return current_power;
 151 }
 152
 153 double HostEnergy::getConsumedEnergy()
 154 {
 155         if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
 156           simgrid::simix::kernel(std::bind(&HostEnergy::update, this));
 157
 158         return total_energy;
 159 }
 160
 161 void HostEnergy::initWattsRangeList()
 162 {
 163         if (host->getProperties() == NULL)
 164                 return;
 165         char* all_power_values_str =
 166     (char*)xbt_dict_get_or_null(host->getProperties(), "watt_per_state");
 167         if (all_power_values_str == NULL)
 168                 return;
 169
 170         xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
 171         int pstate_nb = xbt_dynar_length(all_power_values);
 172
 173         for (int i=0; i< pstate_nb; i++)
 174         {
 175                 /* retrieve the power values associated with the current pstate */
 176                 xbt_dynar_t current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
 177                 xbt_assert(xbt_dynar_length(current_power_values) > 1,
 178                                 "Power properties incorrectly defined - "
 179         "could not retrieve min and max power values for host %s",
 180                                 host->getName().c_str());
 181
 182                 /* min_power corresponds to the idle power (cpu load = 0) */
 183                 /* max_power is the power consumed at 100% cpu load       */
 184     power_range_watts_list.push_back(power_range(
 185       atof(xbt_dynar_get_as(current_power_values, 0, char*)),
 186       atof(xbt_dynar_get_as(current_power_values, 1, char*))
 187     ));
 188         }
 189         xbt_dynar_free(&all_power_values);
 190 }
 191
 192 }
 193 }
 194
 195 /* **************************** events  callback *************************** */
 196 static void onCreation(simgrid::surf::Host *host) {
 197   if (dynamic_cast<simgrid::surf::VirtualMachine*>(host)) // Ignore virtual machines
 198     return;
 199   host->p_host->extension_set(new HostEnergy(host->p_host));
 200 }
 201
 202 static void onActionStateChange(simgrid::surf::CpuAction *action,
 203     e_surf_action_state_t old, e_surf_action_state_t cur) {
 204   const char *name = getActionCpu(action)->getName();
 205   simgrid::surf::Host *host = sg_host_by_name(name)->extension<simgrid::surf::Host>();
 206   simgrid::surf::VirtualMachine *vm = dynamic_cast<simgrid::surf::VirtualMachine*>(host);
 207   if (vm) // If it's a VM, take the corresponding PM
 208     host = vm->getPm()->extension<simgrid::surf::Host>();
 209
 210   HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
 211
 212   if(host_energy->last_updated < surf_get_clock())
 213     host_energy->update();
 214 }
 215
 216 static void onHostStateChange(simgrid::surf::Host *host) {
 217   if (dynamic_cast<simgrid::surf::VirtualMachine*>(host)) // Ignore virtual machines
 218     return;
 219
 220   HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
 221
 222   if(host_energy->last_updated < surf_get_clock())
 223     host_energy->update();
 224 }
 225
 226 static void onHostDestruction(simgrid::surf::Host *host) {
 227   // Ignore virtual machines
 228   if (dynamic_cast<simgrid::surf::VirtualMachine*>(host))
 229     return;
 230   HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
 231   host_energy->update();
 232   XBT_INFO("Total energy of host %s: %f Joules", host->getName(), host_energy->getConsumedEnergy());
 233 }
 234
 235 /* **************************** Public interface *************************** */
 236 /** \ingroup SURF_plugin_energy
 237  * \brief Enable energy plugin
 238  * \details Enable energy plugin to get joules consumption of each cpu. You should call this function before #MSG_init().
 239  */
 240 void sg_energy_plugin_init(void)
 241 {
 242   if (HostEnergy::EXTENSION_ID.valid())
 243     return;
 244
 245   HostEnergy::EXTENSION_ID = simgrid::Host::extension_create<HostEnergy>();
 246
 247   simgrid::surf::Host::onCreation.connect(&onCreation);
 248   simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
 249   simgrid::surf::Host::onStateChange.connect(&onHostStateChange);
 250   simgrid::surf::Host::onDestruction.connect(&onHostDestruction);
 251 }
 252
 253 /** @brief Returns the total energy consumed by the host so far (in Joules)
 254  *
 255  *  See also @ref SURF_plugin_energy.
 256  */
 257 double sg_host_get_consumed_energy(sg_host_t host) {
 258   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 259     "The Energy plugin is not active. "
 260     "Please call sg_energy_plugin_init() during initialization.");
 261   return host->extension<HostEnergy>()->getConsumedEnergy();
 262 }
 263
 264 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
 265 double sg_host_get_wattmin_at(sg_host_t host, int pstate) {
 266   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 267     "The Energy plugin is not active. "
 268     "Please call sg_energy_plugin_init() during initialization.");
 269   return host->extension<HostEnergy>()->getWattMinAt(pstate);
 270 }
 271 /** @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
 272 double sg_host_get_wattmax_at(sg_host_t host, int pstate) {
 273   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 274     "The Energy plugin is not active. "
 275     "Please call sg_energy_plugin_init() during initialization.");
 276   return host->extension<HostEnergy>()->getWattMaxAt(pstate);
 277 }