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