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 /**
 200  * Computes the power consumed by the host according to the current pstate and processor load
 201  *
 202  */
 203 double HostEnergy::getCurrentWattsValue(double cpu_load)
 204 {
 205         xbt_dynar_t power_range_list = power_range_watts_list;
 206         xbt_assert(power_range_watts_list, "No power range properties specified for host %s", host->getName());
 207
 208     /* retrieve the power values associated with the current pstate */
 209     xbt_dynar_t current_power_values = xbt_dynar_get_as( power_range_list,
 210       static_cast<simgrid::surf::CpuCas01*>(host->p_cpu)->getPState(),
 211       xbt_dynar_t);
 212
 213     /* min_power corresponds to the idle power (cpu load = 0) */
 214     /* max_power is the power consumed at 100% cpu load       */
 215     double min_power = xbt_dynar_get_as(current_power_values, 0, double);
 216     double max_power = xbt_dynar_get_as(current_power_values, 1, double);
 217     double power_slope = max_power - min_power;
 218
 219     double current_power = min_power + cpu_load * power_slope;
 220
 221         XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
 222     XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
 223
 224         return current_power;
 225 }
 226
 227 double HostEnergy::getConsumedEnergy()
 228 {
 229
 230         if(last_updated < surf_get_clock())
 231                 update_consumption(host, this);
 232         return total_energy;
 233
 234 }
 235
 236 xbt_dynar_t HostEnergy::getWattsRangeList()
 237 {
 238         xbt_dynar_t power_range_list;
 239         xbt_dynar_t power_tuple;
 240         int i = 0, pstate_nb=0;
 241         xbt_dynar_t current_power_values;
 242         double min_power, max_power;
 243
 244         if (host->getProperties() == NULL)
 245                 return NULL;
 246
 247         char* all_power_values_str = (char*)xbt_dict_get_or_null(host->getProperties(), "watt_per_state");
 248
 249         if (all_power_values_str == NULL)
 250                 return NULL;
 251
 252
 253         power_range_list = xbt_dynar_new(sizeof(xbt_dynar_t), NULL);
 254         xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
 255
 256         pstate_nb = xbt_dynar_length(all_power_values);
 257         for (i=0; i< pstate_nb; i++)
 258         {
 259                 /* retrieve the power values associated with the current pstate */
 260                 current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
 261                 xbt_assert(xbt_dynar_length(current_power_values) > 1,
 262                                 "Power properties incorrectly defined - could not retrieve min and max power values for host %s",
 263                                 host->getName());
 264
 265                 /* min_power corresponds to the idle power (cpu load = 0) */
 266                 /* max_power is the power consumed at 100% cpu load       */
 267                 min_power = atof(xbt_dynar_get_as(current_power_values, 0, char*));
 268                 max_power = atof(xbt_dynar_get_as(current_power_values, 1, char*));
 269
 270                 power_tuple = xbt_dynar_new(sizeof(double), NULL);
 271                 xbt_dynar_push_as(power_tuple, double, min_power);
 272                 xbt_dynar_push_as(power_tuple, double, max_power);
 273
 274                 xbt_dynar_push_as(power_range_list, xbt_dynar_t, power_tuple);
 275                 xbt_dynar_free(&current_power_values);
 276         }
 277         xbt_dynar_free(&all_power_values);
 278         return power_range_list;
 279 }
 280
 281 }
 282 }