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
  33 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
  46 watt_per_state property.
  47 In this example, the idle consumption is 95 Watts, 93 Watts and 90 Watts in each pstate while the CPU burn consumption
  48 are at 200 Watts, 170 Watts, and 150 Watts respectively.
  49
  50 To change the pstate of a given CPU, use the following functions:
  51 #MSG_host_get_nb_pstates(), simgrid#s4u#Host#set_pstate(), #MSG_host_get_power_peak_at().
  52
  53 To simulate the energy-related elements, first call the simgrid#energy#sg_energy_plugin_init() before your #MSG_init(),
  54 and then use the following function to retrieve the consumption of a given host: MSG_host_get_consumed_energy().
  55  */
  56
  57 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin");
  58
  59 using simgrid::energy::HostEnergy;
  60
  61 namespace simgrid {
  62 namespace energy {
  63
  64 simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
  65
  66 /* Computes the consumption so far.  Called lazily on need. */
  67 void HostEnergy::update()
  68 {
  69   simgrid::surf::HostImpl* surf_host = host->extension<simgrid::surf::HostImpl>();
  70   double start_time = this->last_updated;
  71   double finish_time = surf_get_clock();
  72   double cpu_load;
  73   if (surf_host->p_cpu->speed_.peak <= 0)
  74     // Some users declare a pstate of speed 0 flops (e.g., to model boot time).
  75     // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN
  76     cpu_load = 1;
  77   else
  78     cpu_load = lmm_constraint_get_usage(surf_host->p_cpu->getConstraint()) / surf_host->p_cpu->speed_.peak;
  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->speed_.peak, previous_energy, energy_this_step);
  98 }
  99
 100 HostEnergy::HostEnergy(simgrid::s4u::Host *ptr) : 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 HostEnergy::~HostEnergy()=default;
 117
 118 double HostEnergy::getWattMinAt(int pstate)
 119 {
 120   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->name().c_str());
 121   return power_range_watts_list[pstate].first;
 122 }
 123
 124 double HostEnergy::getWattMaxAt(int pstate)
 125 {
 126   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->name().c_str());
 127   return power_range_watts_list[pstate].second;
 128 }
 129
 130 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
 131 double HostEnergy::getCurrentWattsValue(double cpu_load)
 132 {
 133   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->name().c_str());
 134
 135   /* min_power corresponds to the idle power (cpu load = 0) */
 136   /* max_power is the power consumed at 100% cpu load       */
 137   auto range = power_range_watts_list.at(host->pstate());
 138   double min_power = range.first;
 139   double max_power = range.second;
 140   double power_slope = max_power - min_power;
 141   double current_power = min_power + cpu_load * power_slope;
 142
 143   XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
 144   XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
 145
 146   return current_power;
 147 }
 148
 149 double HostEnergy::getConsumedEnergy()
 150 {
 151   if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
 152     simgrid::simix::kernelImmediate(std::bind(&HostEnergy::update, this));
 153
 154   return total_energy;
 155 }
 156
 157 void HostEnergy::initWattsRangeList()
 158 {
 159   if (host->properties() == nullptr)
 160     return;
 161   char* all_power_values_str = static_cast<char*>(xbt_dict_get_or_null(host->properties(), "watt_per_state"));
 162   if (all_power_values_str == nullptr)
 163     return;
 164
 165   xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
 166   int pstate_nb = xbt_dynar_length(all_power_values);
 167
 168   for (int i=0; i< pstate_nb; i++) {
 169     /* retrieve the power values associated with the current pstate */
 170     xbt_dynar_t current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
 171     xbt_assert(xbt_dynar_length(current_power_values) > 1,
 172         "Power properties incorrectly defined - could not retrieve min and max power values for host %s",
 173         host->name().c_str());
 174
 175     /* min_power corresponds to the idle power (cpu load = 0) */
 176     /* max_power is the power consumed at 100% cpu load       */
 177     char *msg_min = bprintf("Invalid min value for pstate %d on host %s: %%s", i, host->name().c_str());
 178     char *msg_max = bprintf("Invalid min value for pstate %d on host %s: %%s", i, host->name().c_str());
 179     power_range_watts_list.push_back(power_range(
 180       xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 0, char*), msg_min),
 181       xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 1, char*), msg_max)
 182     ));
 183     xbt_free(msg_min);
 184     xbt_free(msg_max);
 185
 186     xbt_dynar_free(&current_power_values);
 187   }
 188   xbt_dynar_free(&all_power_values);
 189 }
 190
 191 }
 192 }
 193
 194 /* **************************** events  callback *************************** */
 195 static void onCreation(simgrid::s4u::Host& host) {
 196   simgrid::surf::HostImpl* surf_host = host.extension<simgrid::surf::HostImpl>();
 197   if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host)) // Ignore virtual machines
 198     return;
 199   host.extension_set(new HostEnergy(&host));
 200 }
 201
 202 static void onActionStateChange(simgrid::surf::CpuAction *action, simgrid::surf::Action::State previous) {
 203   for(simgrid::surf::Cpu* cpu : action->cpus()) {
 204     const char *name = cpu->getName();
 205     sg_host_t sghost = sg_host_by_name(name);
 206     if(sghost == nullptr)
 207       continue;
 208     simgrid::surf::HostImpl *host = sghost->extension<simgrid::surf::HostImpl>();
 209     simgrid::surf::VirtualMachine *vm = dynamic_cast<simgrid::surf::VirtualMachine*>(host);
 210     if (vm) // If it's a VM, take the corresponding PM
 211       host = vm->getPm()->extension<simgrid::surf::HostImpl>();
 212
 213     HostEnergy *host_energy = host->piface->extension<HostEnergy>();
 214
 215     if(host_energy->last_updated < surf_get_clock())
 216       host_energy->update();
 217   }
 218 }
 219
 220 static void onHostStateChange(simgrid::s4u::Host &host) {
 221   simgrid::surf::HostImpl* surf_host = host.extension<simgrid::surf::HostImpl>();
 222   if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host)) // Ignore virtual machines
 223     return;
 224
 225   HostEnergy *host_energy = host.extension<HostEnergy>();
 226
 227   if(host_energy->last_updated < surf_get_clock())
 228     host_energy->update();
 229 }
 230
 231 static void onHostDestruction(simgrid::s4u::Host& host) {
 232   // Ignore virtual machines
 233   simgrid::surf::HostImpl* surf_host = host.extension<simgrid::surf::HostImpl>();
 234   if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host))
 235     return;
 236   HostEnergy *host_energy = host.extension<HostEnergy>();
 237   host_energy->update();
 238   XBT_INFO("Total energy of host %s: %f Joules", host.name().c_str(), host_energy->getConsumedEnergy());
 239 }
 240
 241 /* **************************** Public interface *************************** */
 242 /** \ingroup SURF_plugin_energy
 243  * \brief Enable energy plugin
 244  * \details Enable energy plugin to get joules consumption of each cpu. You should call this function before #MSG_init().
 245  */
 246 void sg_energy_plugin_init()
 247 {
 248   if (HostEnergy::EXTENSION_ID.valid())
 249     return;
 250
 251   HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
 252
 253   simgrid::s4u::Host::onCreation.connect(&onCreation);
 254   simgrid::s4u::Host::onStateChange.connect(&onHostStateChange);
 255   simgrid::s4u::Host::onDestruction.connect(&onHostDestruction);
 256   simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
 257 }
 258
 259 /** @brief Returns the total energy consumed by the host so far (in Joules)
 260  *
 261  *  See also @ref SURF_plugin_energy.
 262  */
 263 double sg_host_get_consumed_energy(sg_host_t host) {
 264   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 265     "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
 266   return host->extension<HostEnergy>()->getConsumedEnergy();
 267 }
 268
 269 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
 270 double sg_host_get_wattmin_at(sg_host_t host, int pstate) {
 271   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 272     "The Energy plugin is not active. 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. Please call sg_energy_plugin_init() during initialization.");
 279   return host->extension<HostEnergy>()->getWattMaxAt(pstate);
 280 }