Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
boostify parsers
[simgrid.git] / src / surf / plugins / host_energy.cpp
1 /* Copyright (c) 2010, 2012-2016. The SimGrid Team. All rights reserved.    */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "simgrid/plugins/energy.h"
7 #include "simgrid/simix.hpp"
8 #include "src/plugins/vm/VirtualMachineImpl.hpp"
9 #include "src/surf/cpu_interface.hpp"
10
11 #include <boost/algorithm/string/classification.hpp>
12 #include <boost/algorithm/string/split.hpp>
13 #include <simgrid/s4u/engine.hpp>
14 #include <string>
15 #include <utility>
16 #include <vector>
17
18 /** @addtogroup SURF_plugin_energy
19
20
21 This is the energy plugin, enabling to account not only for computation time,
22 but also for the dissipated energy in the simulated platform.
23
24 The energy consumption of a CPU depends directly of its current load. Specify that consumption in your platform file as
25 follows:
26
27 \verbatim
28 <host id="HostA" power="100.0Mf" cores="8">
29     <prop id="watt_per_state" value="100.0:120.0:200.0" />
30     <prop id="watt_off" value="10" />
31 </host>
32 \endverbatim
33
34 The first property means that when your host is up and running, but without anything to do, it will dissipate 100 Watts.
35 If only one care is active, it will dissipate 120 Watts. If it's fully loaded, it will dissipate 200 Watts. If its load is at 50%, then it will dissipate 153.33 Watts.
36 The second property means that when your host is turned off, it will dissipate only 10 Watts (please note that these
37 values are arbitrary).
38
39 If your CPU is using pstates, then you can provide one consumption interval per pstate.
40
41 \verbatim
42 <host id="HostB" power="100.0Mf,50.0Mf,20.0Mf" pstate="0" >
43     <prop id="watt_per_state" value="95.0:120.0:200.0, 93.0:115.0:170.0, 90.0:110.0:150.0" />
44     <prop id="watt_off" value="10" />
45 </host>
46 \endverbatim
47
48 That host has 3 levels of performance with the following performance: 100 Mflop/s, 50 Mflop/s or 20 Mflop/s.
49 It starts at pstate 0 (ie, at 100 Mflop/s). In this case, you have to specify one interval per pstate in the
50 watt_per_state property.
51 In this example, the idle consumption is 95 Watts, 93 Watts and 90 Watts in each pstate while the CPU burn consumption
52 are at 200 Watts, 170 Watts, and 150 Watts respectively. If only one core is active, this machine consumes 120 / 115 / 110 watts.
53
54 To change the pstate of a given CPU, use the following functions:
55 #MSG_host_get_nb_pstates(), simgrid#s4u#Host#setPstate(), #MSG_host_get_power_peak_at().
56
57 To simulate the energy-related elements, first call the simgrid#energy#sg_energy_plugin_init() before your #MSG_init(),
58 and then use the following function to retrieve the consumption of a given host: MSG_host_get_consumed_energy().
59  */
60
61 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin");
62
63 namespace simgrid {
64 namespace energy {
65
66 class PowerRange {
67 public:
68   double idle;
69   double min;
70   double max;
71
72   PowerRange(double idle, double min, double max) : idle(idle), min(min), max(max) {}
73 };
74
75 class HostEnergy {
76 public:
77   static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
78
79   explicit HostEnergy(simgrid::s4u::Host* ptr);
80   ~HostEnergy();
81
82   double getCurrentWattsValue(double cpu_load);
83   double getConsumedEnergy();
84   double getWattMinAt(int pstate);
85   double getWattMaxAt(int pstate);
86   void update();
87
88 private:
89   void initWattsRangeList();
90   simgrid::s4u::Host* host = nullptr;
91   std::vector<PowerRange>
92       power_range_watts_list; /*< List of (min_power,max_power) pairs corresponding to each cpu pstate */
93 public:
94   double watts_off    = 0.0; /*< Consumption when the machine is turned off (shutdown) */
95   double total_energy = 0.0; /*< Total energy consumed by the host */
96   double last_updated;       /*< Timestamp of the last energy update event*/
97 };
98
99 simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
100
101 /* Computes the consumption so far.  Called lazily on need. */
102 void HostEnergy::update()
103 {
104   double start_time  = this->last_updated;
105   double finish_time = surf_get_clock();
106   double cpu_load;
107   if (host->pimpl_cpu->getPstateSpeedCurrent() <= 0)
108     // Some users declare a pstate of speed 0 flops (e.g., to model boot time).
109     // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN
110     cpu_load = 1;
111   else
112     cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / host->pimpl_cpu->getPstateSpeedCurrent();
113
114   /** Divide by the number of cores here **/
115   cpu_load /= host->pimpl_cpu->coreCount();
116
117   if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more
118     cpu_load = 1;
119
120   /* The problem with this model is that the load is always 0 or 1, never something less.
121    * Another possibility could be to model the total energy as
122    *
123    *   X/(X+Y)*W_idle + Y/(X+Y)*W_burn
124    *
125    * where X is the amount of idling cores, and Y the amount of computing cores.
126    */
127
128   double previous_energy = this->total_energy;
129
130   double instantaneous_consumption;
131   if (host->isOff())
132     instantaneous_consumption = this->watts_off;
133   else
134     instantaneous_consumption = this->getCurrentWattsValue(cpu_load);
135
136   double energy_this_step = instantaneous_consumption * (finish_time - start_time);
137
138   this->total_energy = previous_energy + energy_this_step;
139   this->last_updated = finish_time;
140
141   XBT_DEBUG(
142       "[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> %.2f J",
143       host->cname(), start_time, finish_time, host->pimpl_cpu->speed_.peak, previous_energy, energy_this_step);
144 }
145
146 HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host(ptr), last_updated(surf_get_clock())
147 {
148   initWattsRangeList();
149
150   const char* off_power_str = host->property("watt_off");
151   if (off_power_str != nullptr) {
152     char* msg       = bprintf("Invalid value for property watt_off of host %s: %%s", host->cname());
153     this->watts_off = xbt_str_parse_double(off_power_str, msg);
154     xbt_free(msg);
155   }
156   /* watts_off is 0 by default */
157 }
158
159 HostEnergy::~HostEnergy() = default;
160
161 double HostEnergy::getWattMinAt(int pstate)
162 {
163   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
164   return power_range_watts_list[pstate].min;
165 }
166
167 double HostEnergy::getWattMaxAt(int pstate)
168 {
169   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
170   return power_range_watts_list[pstate].max;
171 }
172
173 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
174 double HostEnergy::getCurrentWattsValue(double cpu_load)
175 {
176   xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
177
178   /* min_power corresponds to the power consumed when only one core is active */
179   /* max_power is the power consumed at 100% cpu load       */
180   auto range           = power_range_watts_list.at(host->pstate());
181   double current_power = 0;
182   double min_power     = 0;
183   double max_power     = 0;
184   double power_slope   = 0;
185
186   if (cpu_load > 0) { /* Something is going on, the machine is not idle */
187     double min_power = range.min;
188     double max_power = range.max;
189
190     /**
191      * The min_power states how much we consume when only one single
192      * core is working. This means that when cpu_load == 1/coreCount, then
193      * current_power == min_power.
194      *
195      * The maximum must be reached when all cores are working (but 1 core was
196      * already accounted for by min_power)
197      * i.e., we need min_power + (maxCpuLoad-1/coreCount)*power_slope == max_power
198      * (maxCpuLoad is by definition 1)
199      */
200     double power_slope;
201     int coreCount         = host->coreCount();
202     double coreReciprocal = static_cast<double>(1) / static_cast<double>(coreCount);
203     if (coreCount > 1)
204       power_slope = (max_power - min_power) / (1 - coreReciprocal);
205     else
206       power_slope = 0; // Should be 0, since max_power == min_power (in this case)
207
208     current_power = min_power + (cpu_load - coreReciprocal) * power_slope;
209   } else { /* Our machine is idle, take the dedicated value! */
210     current_power = range.idle;
211   }
212
213   XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
214   XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
215
216   return current_power;
217 }
218
219 double HostEnergy::getConsumedEnergy()
220 {
221   if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
222     simgrid::simix::kernelImmediate(std::bind(&HostEnergy::update, this));
223
224   return total_energy;
225 }
226
227 void HostEnergy::initWattsRangeList()
228 {
229   const char* all_power_values_str = host->property("watt_per_state");
230   if (all_power_values_str == nullptr)
231     return;
232
233   std::vector<std::string> all_power_values;
234   boost::split(all_power_values, all_power_values_str, boost::is_any_of(","));
235
236   int i = 0;
237   for (auto current_power_values_str : all_power_values) {
238     /* retrieve the power values associated with the current pstate */
239     std::vector<std::string> current_power_values;
240     boost::split(current_power_values, current_power_values_str, boost::is_any_of(":"));
241     xbt_assert(current_power_values.size() == 3, "Power properties incorrectly defined - "
242                                                  "could not retrieve idle, min and max power values for host %s",
243                host->cname());
244
245     /* min_power corresponds to the idle power (cpu load = 0) */
246     /* max_power is the power consumed at 100% cpu load       */
247     char* msg_idle = bprintf("Invalid idle value for pstate %d on host %s: %%s", i, host->cname());
248     char* msg_min  = bprintf("Invalid min value for pstate %d on host %s: %%s", i, host->cname());
249     char* msg_max  = bprintf("Invalid max value for pstate %d on host %s: %%s", i, host->cname());
250     PowerRange range(xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle),
251                      xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_min),
252                      xbt_str_parse_double((current_power_values.at(2)).c_str(), msg_max));
253     power_range_watts_list.push_back(range);
254     xbt_free(msg_idle);
255     xbt_free(msg_min);
256     xbt_free(msg_max);
257     i++;
258   }
259 }
260 }
261 }
262
263 using simgrid::energy::HostEnergy;
264
265 /* **************************** events  callback *************************** */
266 static void onCreation(simgrid::s4u::Host& host)
267 {
268   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
269     return;
270   host.extension_set(new HostEnergy(&host));
271 }
272
273 static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf::Action::State previous)
274 {
275   for (simgrid::surf::Cpu* cpu : action->cpus()) {
276     simgrid::s4u::Host* host = cpu->getHost();
277     if (host == nullptr)
278       continue;
279
280     // If it's a VM, take the corresponding PM
281     simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
282     if (vm) // If it's a VM, take the corresponding PM
283       host = vm->pimpl_vm_->getPm();
284
285     // Get the host_energy extension for the relevant host
286     HostEnergy* host_energy = host->extension<HostEnergy>();
287
288     if (host_energy->last_updated < surf_get_clock())
289       host_energy->update();
290   }
291 }
292
293 /* This callback is fired either when the host change its state (on/off) or its speed
294  * (because the user changed the pstate, or because of external trace events) */
295 static void onHostChange(simgrid::s4u::Host& host)
296 {
297   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
298     return;
299
300   HostEnergy* host_energy = host.extension<HostEnergy>();
301
302   if (host_energy->last_updated < surf_get_clock())
303     host_energy->update();
304 }
305
306 static void onHostDestruction(simgrid::s4u::Host& host)
307 {
308   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
309     return;
310
311   HostEnergy* host_energy = host.extension<HostEnergy>();
312   host_energy->update();
313   XBT_INFO("Total energy of host %s: %f Joules", host.cname(), host_energy->getConsumedEnergy());
314 }
315
316 static void onSimulationEnd()
317 {
318   sg_host_t* host_list     = sg_host_list();
319   int host_count           = sg_host_count();
320   double total_energy      = 0.0; // Total energy consumption (whole plattform)
321   double used_hosts_energy = 0.0; // Energy consumed by hosts that computed something
322   for (int i = 0; i < host_count; i++) {
323     bool host_was_used = (host_list[i]->extension<HostEnergy>()->last_updated != 0);
324     double energy      = 0.0;
325     energy             = host_list[i]->extension<HostEnergy>()->getConsumedEnergy();
326     total_energy      += energy;
327     if (host_was_used)
328       used_hosts_energy += energy;
329   }
330   XBT_INFO("Summed energy consumption: %f Joules; used hosts consumed: %f Joules; unused (idle) hosts consumed: %f",
331            total_energy, used_hosts_energy, total_energy - used_hosts_energy);
332 }
333
334 /* **************************** Public interface *************************** */
335 SG_BEGIN_DECL()
336
337 /** \ingroup SURF_plugin_energy
338  * \brief Enable host energy plugin
339  * \details Enable energy plugin to get joules consumption of each cpu. Call this function before #MSG_init().
340  */
341 void sg_host_energy_plugin_init()
342 {
343   if (HostEnergy::EXTENSION_ID.valid())
344     return;
345
346   HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
347
348   simgrid::s4u::Host::onCreation.connect(&onCreation);
349   simgrid::s4u::Host::onStateChange.connect(&onHostChange);
350   simgrid::s4u::Host::onSpeedChange.connect(&onHostChange);
351   simgrid::s4u::Host::onDestruction.connect(&onHostDestruction);
352   simgrid::s4u::onSimulationEnd.connect(&onSimulationEnd);
353   simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
354 }
355
356 /** @brief Returns the total energy consumed by the host so far (in Joules)
357  *
358  *  See also @ref SURF_plugin_energy.
359  */
360 double sg_host_get_consumed_energy(sg_host_t host)
361 {
362   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
363              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
364   return host->extension<HostEnergy>()->getConsumedEnergy();
365 }
366
367 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
368 double sg_host_get_wattmin_at(sg_host_t host, int pstate)
369 {
370   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
371              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
372   return host->extension<HostEnergy>()->getWattMinAt(pstate);
373 }
374 /** @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
375 double sg_host_get_wattmax_at(sg_host_t host, int pstate)
376 {
377   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
378              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
379   return host->extension<HostEnergy>()->getWattMaxAt(pstate);
380 }
381
382 SG_END_DECL()