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()) // We need to simcall this as it modifies the environment
 162           simgrid::simix::kernel(std::bind(&HostEnergy::update, this));
 163
 164         return total_energy;
 165 }
 166
 167 void HostEnergy::initWattsRangeList()
 168 {
 169         if (host->getProperties() == NULL)
 170                 return;
 171         char* all_power_values_str =
 172     (char*)xbt_dict_get_or_null(host->getProperties(), "watt_per_state");
 173         if (all_power_values_str == NULL)
 174                 return;
 175
 176         xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
 177         int pstate_nb = xbt_dynar_length(all_power_values);
 178
 179         for (int i=0; i< pstate_nb; i++)
 180         {
 181                 /* retrieve the power values associated with the current pstate */
 182                 xbt_dynar_t current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
 183                 xbt_assert(xbt_dynar_length(current_power_values) > 1,
 184                                 "Power properties incorrectly defined - "
 185         "could not retrieve min and max power values for host %s",
 186                                 host->getName().c_str());
 187
 188                 /* min_power corresponds to the idle power (cpu load = 0) */
 189                 /* max_power is the power consumed at 100% cpu load       */
 190     power_range_watts_list.push_back(power_range(
 191       atof(xbt_dynar_get_as(current_power_values, 0, char*)),
 192       atof(xbt_dynar_get_as(current_power_values, 1, char*))
 193     ));
 194         }
 195         xbt_dynar_free(&all_power_values);
 196 }
 197
 198 }
 199 }
 200
 201 /* **************************** Public interface *************************** */
 202
 203 /** \ingroup SURF_plugin_energy
 204  * \brief Enable energy plugin
 205  * \details Enable energy plugin to get joules consumption of each cpu. You should call this function before #MSG_init().
 206  */
 207 void sg_energy_plugin_init(void)
 208 {
 209   if (HostEnergy::EXTENSION_ID.valid())
 210     return;
 211
 212   HostEnergy::EXTENSION_ID = simgrid::Host::extension_create<HostEnergy>();
 213
 214   /* The following attaches an anonymous function to the Host::onCreation signal */
 215   /* Search for "C++ lambda" for more information on the syntax used here */
 216   simgrid::surf::Host::onCreation.connect([](simgrid::surf::Host *host) {
 217     if (dynamic_cast<simgrid::surf::VirtualMachine*>(host)) // Ignore virtual machines
 218       return;
 219     host->p_host->extension_set(new HostEnergy(host->p_host));
 220   });
 221
 222   simgrid::surf::CpuAction::onStateChange.connect([](simgrid::surf::CpuAction *action,
 223       e_surf_action_state_t old,
 224       e_surf_action_state_t cur) {
 225     const char *name = getActionCpu(action)->getName();
 226     simgrid::surf::Host *host = sg_host_by_name(name)->extension<simgrid::surf::Host>();
 227     simgrid::surf::VirtualMachine *vm = dynamic_cast<simgrid::surf::VirtualMachine*>(host);
 228     if (vm) // If it's a VM, take the corresponding PM
 229         host = vm->getPm()->extension<simgrid::surf::Host>();
 230
 231     HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
 232
 233     if(host_energy->last_updated < surf_get_clock())
 234       host_energy->update();
 235
 236   });
 237
 238   simgrid::surf::Host::onStateChange.connect([] (simgrid::surf::Host *host) {
 239     if (dynamic_cast<simgrid::surf::VirtualMachine*>(host)) // Ignore virtual machines
 240       return;
 241
 242     HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
 243
 244     if(host_energy->last_updated < surf_get_clock())
 245       host_energy->update();
 246   });
 247 }
 248
 249 /** @brief Returns the total energy consumed by the host so far (in Joules)
 250  *
 251  *  See also @ref SURF_plugin_energy.
 252  */
 253 double sg_host_get_consumed_energy(sg_host_t host) {
 254   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 255     "The Energy plugin is not active. "
 256     "Please call sg_energy_plugin_init() during initialization.");
 257   return host->extension<HostEnergy>()->getConsumedEnergy();
 258 }
 259
 260 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
 261 double sg_host_get_wattmin_at(sg_host_t host, int pstate) {
 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>()->getWattMinAt(pstate);
 266 }
 267 /** @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
 268 double sg_host_get_wattmax_at(sg_host_t host, int pstate) {
 269   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
 270     "The Energy plugin is not active. "
 271     "Please call sg_energy_plugin_init() during initialization.");
 272   return host->extension<HostEnergy>()->getWattMaxAt(pstate);
 273 }