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::s4u::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::s4u::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->name().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->name().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->name().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->name().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::s4u::Host& host) {
 197   simgrid::surf::Host* surf_host = host.extension<simgrid::surf::Host>();
 198   if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host)) // Ignore virtual machines
 199     return;
 200   host.extension_set(new HostEnergy(&host));
 201 }
 202
 203 static void onActionStateChange(simgrid::surf::CpuAction *action,
 204     e_surf_action_state_t old, e_surf_action_state_t cur) {
 205   const char *name = getActionCpu(action)->getName();
 206   simgrid::surf::Host *host = sg_host_by_name(name)->extension<simgrid::surf::Host>();
 207   simgrid::surf::VirtualMachine *vm = dynamic_cast<simgrid::surf::VirtualMachine*>(host);
 208   if (vm) // If it's a VM, take the corresponding PM
 209     host = vm->getPm()->extension<simgrid::surf::Host>();
 210
 211   HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
 212
 213   if(host_energy->last_updated < surf_get_clock())
 214     host_energy->update();
 215 }
 216
 217 static void onHostStateChange(simgrid::s4u::Host &host) {
 218   simgrid::surf::Host* surf_host = host.extension<simgrid::surf::Host>();
 219   if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host)) // Ignore virtual machines
 220     return;
 221
 222   HostEnergy *host_energy = host.extension<HostEnergy>();
 223
 224   if(host_energy->last_updated < surf_get_clock())
 225     host_energy->update();
 226 }
 227
 228 static void onHostDestruction(simgrid::s4u::Host& host) {
 229   // Ignore virtual machines
 230   simgrid::surf::Host* surf_host = host.extension<simgrid::surf::Host>();
 231   if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host))
 232     return;
 233   HostEnergy *host_energy = host.extension<HostEnergy>();
 234   host_energy->update();
 235   XBT_INFO("Total energy of host %s: %f Joules",
 236     host.name().c_str(), host_energy->getConsumedEnergy());
 237 }
 238
 239 /* **************************** Public interface *************************** */
 240 /** \ingroup SURF_plugin_energy
 241  * \brief Enable energy plugin
 242  * \details Enable energy plugin to get joules consumption of each cpu. You should call this function before #MSG_init().
 243  */
 244 void sg_energy_plugin_init(void)
 245 {
 246   if (HostEnergy::EXTENSION_ID.valid())
 247     return;
 248
 249   HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
 250
 251   simgrid::s4u::Host::onCreation.connect(&onCreation);
 252   simgrid::s4u::Host::onStateChange.connect(&onHostStateChange);
 253   simgrid::s4u::Host::onDestruction.connect(&onHostDestruction);
 254   simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
 255 }
 256
 257 /** @brief Returns the total energy consumed by the host so far (in Joules)
 258  *
 259  *  See also @ref SURF_plugin_energy.
 260  */
 261 double sg_host_get_consumed_energy(sg_host_t host) {
 262   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 263     "The Energy plugin is not active. "
 264     "Please call sg_energy_plugin_init() during initialization.");
 265   return host->extension<HostEnergy>()->getConsumedEnergy();
 266 }
 267
 268 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
 269 double sg_host_get_wattmin_at(sg_host_t host, int pstate) {
 270   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 271     "The Energy plugin is not active. "
 272     "Please call sg_energy_plugin_init() during initialization.");
 273   return host->extension<HostEnergy>()->getWattMinAt(pstate);
 274 }
 275 /** @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
 276 double sg_host_get_wattmax_at(sg_host_t host, int pstate) {
 277   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 278     "The Energy plugin is not active. "
 279     "Please call sg_energy_plugin_init() during initialization.");
 280   return host->extension<HostEnergy>()->getWattMaxAt(pstate);
 281 }