Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
don't fail on sg_host_energy_update_all() in presence of VMs (fix #192)
[simgrid.git] / src / surf / plugins / host_energy.cpp
1 /* Copyright (c) 2010-2017. 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 "simgrid/s4u/Engine.hpp"
12
13 #include <boost/algorithm/string/classification.hpp>
14 #include <boost/algorithm/string/split.hpp>
15 #include <string>
16 #include <utility>
17 #include <vector>
18
19 /** @addtogroup plugin_energy
20
21
22 This is the energy plugin, enabling to account not only for computation time,
23 but also for the dissipated energy in the simulated platform.
24 To activate this plugin, first call sg_host_energy_plugin_init() before your #MSG_init(),
25 and then use MSG_host_get_consumed_energy() to retrieve the consumption of a given host.
26
27 When the host is on, this energy consumption naturally depends on both the
28 current CPU load and the host energy profile. According to our measurements,
29 the consumption is somehow linear in the amount of cores at full speed,
30 with an abnormality when all the cores are idle. The full details are in
31 <a href="https://hal.inria.fr/hal-01523608">our scientific paper</a> on that topic.
32
33 As a result, our energy model takes 4 parameters:
34
35   - \b Idle: instantaneous consumption (in Watt) when your host is up and running, but without anything to do.
36   - \b OneCore: instantaneous consumption (in Watt) when only one core is active, at 100%.
37   - \b AllCores: instantaneous consumption (in Watt) when all cores of the host are at 100%.
38   - \b Off: instantaneous consumption (in Watt) when the host is turned off.
39
40 Here is an example of XML declaration:
41
42 \code{.xml}
43 <host id="HostA" power="100.0Mf" cores="4">
44     <prop id="watt_per_state" value="100.0:120.0:200.0" />
45     <prop id="watt_off" value="10" />
46 </host>
47 \endcode
48
49 This example gives the following parameters: \b Off is 10 Watts; \b Idle is 100 Watts; \b OneCore is 120 Watts and \b
50 AllCores is 200 Watts.
51 This is enough to compute the consumption as a function of the amount of loaded cores:
52
53 <table>
54 <tr><th>#Cores loaded</th><th>Consumption</th><th>Explanation</th></tr>
55 <tr><td>0</td><td> 100 Watts</td><td>Idle value</td></tr>
56 <tr><td>1</td><td> 120 Watts</td><td>OneCore value</td></tr>
57 <tr><td>2</td><td> 147 Watts</td><td>linear extrapolation between OneCore and AllCores</td></tr>
58 <tr><td>3</td><td> 173 Watts</td><td>linear extrapolation between OneCore and AllCores</td></tr>
59 <tr><td>4</td><td> 200 Watts</td><td>AllCores value</td></tr>
60 </table>
61
62 ### What if a given core is only at load 50%?
63
64 This is impossible in SimGrid because we recompute everything each time
65 that the CPU starts or stops doing something. So if a core is at load 50% over
66 a period, it means that it is at load 100% half of the time and at load 0% the
67 rest of the time, and our model holds.
68
69 ### What if the host has only one core?
70
71 In this case, the parameters \b OneCore and \b AllCores are obviously the same.
72 Actually, SimGrid expect an energetic profile formated as 'Idle:Running' for mono-cores hosts.
73 If you insist on passing 3 parameters in this case, then you must have the same value for \b OneCore and \b AllCores.
74
75 \code{.xml}
76 <host id="HostC" power="100.0Mf" cores="1">
77     <prop id="watt_per_state" value="95.0:200.0" /> <!-- we may have used '95:200:200' instead -->
78     <prop id="watt_off" value="10" />
79 </host>
80 \endcode
81
82 ### How does DVFS interact with the host energy model?
83
84 If your host has several DVFS levels (several pstates), then you should
85 give the energetic profile of each pstate level:
86
87 \code{.xml}
88 <host id="HostC" power="100.0Mf,50.0Mf,20.0Mf" cores="4">
89     <prop id="watt_per_state" value="95.0:120.0:200.0, 93.0:115.0:170.0, 90.0:110.0:150.0" />
90     <prop id="watt_off" value="10" />
91 </host>
92 \endcode
93
94 This encodes the following values
95 <table>
96 <tr><th>pstate</th><th>Performance</th><th>Idle</th><th>OneCore</th><th>AllCores</th></tr>
97 <tr><td>0</td><td>100 Mflop/s</td><td>95 Watts</td><td>120 Watts</td><td>200 Watts</td></tr>
98 <tr><td>1</td><td>50 Mflop/s</td><td>93 Watts</td><td>115 Watts</td><td>170 Watts</td></tr>
99 <tr><td>2</td><td>20 Mflop/s</td><td>90 Watts</td><td>110 Watts</td><td>150 Watts</td></tr>
100 </table>
101
102 To change the pstate of a given CPU, use the following functions:
103 #MSG_host_get_nb_pstates(), simgrid#s4u#Host#setPstate(), #MSG_host_get_power_peak_at().
104
105 ### How accurate are these models?
106
107 This model cannot be more accurate than your instantiation:
108 with the default values, your result will not be accurate at all. You can still get
109 accurate energy prediction, provided that you carefully instantiate the model.
110 The first step is to ensure that your timing prediction match perfectly. But this
111 is only the first step of the path, and you really want to read
112 <a href="https://hal.inria.fr/hal-01523608">this paper</a> to see all what you need
113 to do before you can get accurate energy predictions.
114
115  */
116
117 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin");
118
119 namespace simgrid {
120 namespace energy {
121
122 class PowerRange {
123 public:
124   double idle;
125   double min;
126   double max;
127
128   PowerRange(double idle, double min, double max) : idle(idle), min(min), max(max) {}
129 };
130
131 class HostEnergy {
132 public:
133   static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
134
135   explicit HostEnergy(simgrid::s4u::Host* ptr);
136   ~HostEnergy();
137
138   double getCurrentWattsValue(double cpu_load);
139   double getConsumedEnergy();
140   double getWattMinAt(int pstate);
141   double getWattMaxAt(int pstate);
142   void update();
143
144 private:
145   void initWattsRangeList();
146   simgrid::s4u::Host* host = nullptr;
147   std::vector<PowerRange>
148       power_range_watts_list; /*< List of (min_power,max_power) pairs corresponding to each cpu pstate */
149
150   /* We need to keep track of what pstate has been used, as we will sometimes
151    * be notified only *after* a pstate has been used (but we need to update the energy consumption
152    * with the old pstate!)
153    */
154   int pstate = 0;
155
156 public:
157   double watts_off    = 0.0; /*< Consumption when the machine is turned off (shutdown) */
158   double total_energy = 0.0; /*< Total energy consumed by the host */
159   double last_updated;       /*< Timestamp of the last energy update event*/
160 };
161
162 simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
163
164 /* Computes the consumption so far.  Called lazily on need. */
165 void HostEnergy::update()
166 {
167   double start_time  = this->last_updated;
168   double finish_time = surf_get_clock();
169   double current_speed = host->speed();
170
171   if (start_time < finish_time) {
172     double cpu_load;
173     // We may have start == finish if the past consumption was updated since the simcall was started
174     // for example if 2 actors requested to update the same host's consumption in a given scheduling round.
175     //
176     // Even in this case, we need to save the pstate for the next call (after this big if),
177     // which may have changed since that recent update.
178
179     if (current_speed <= 0)
180       // Some users declare a pstate of speed 0 flops (e.g., to model boot time).
181       // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN
182       cpu_load = 1;
183     else
184       cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / current_speed;
185
186     /** Divide by the number of cores here **/
187     cpu_load /= host->pimpl_cpu->coreCount();
188
189     if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more
190       cpu_load = 1;
191
192     /* The problem with this model is that the load is always 0 or 1, never something less.
193      * Another possibility could be to model the total energy as
194      *
195      *   X/(X+Y)*W_idle + Y/(X+Y)*W_burn
196      *
197      * where X is the amount of idling cores, and Y the amount of computing cores.
198      */
199
200     double previous_energy = this->total_energy;
201
202     double instantaneous_consumption;
203     if (this->pstate == -1) // The host was off at the beginning of this time interval
204       instantaneous_consumption = this->watts_off;
205     else
206       instantaneous_consumption = this->getCurrentWattsValue(cpu_load);
207
208     double energy_this_step = instantaneous_consumption * (finish_time - start_time);
209
210     // TODO Trace: Trace energy_this_step from start_time to finish_time in host->name()
211
212     this->total_energy = previous_energy + energy_this_step;
213     this->last_updated = finish_time;
214
215     XBT_DEBUG("[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> "
216               "%.2f J",
217               host->cname(), start_time, finish_time, host->pimpl_cpu->speed_.peak, previous_energy, energy_this_step);
218   }
219
220   /* Save data for the upcoming time interval: whether it's on/off and the pstate if it's on */
221   this->pstate = host->isOn() ? host->pstate() : -1;
222 }
223
224 HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host(ptr), last_updated(surf_get_clock())
225 {
226   initWattsRangeList();
227
228   const char* off_power_str = host->property("watt_off");
229   if (off_power_str != nullptr) {
230     char* msg       = bprintf("Invalid value for property watt_off of host %s: %%s", host->cname());
231     this->watts_off = xbt_str_parse_double(off_power_str, msg);
232     xbt_free(msg);
233   }
234   /* watts_off is 0 by default */
235 }
236
237 HostEnergy::~HostEnergy() = default;
238
239 double HostEnergy::getWattMinAt(int pstate)
240 {
241   xbt_assert(not power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
242   return power_range_watts_list[pstate].min;
243 }
244
245 double HostEnergy::getWattMaxAt(int pstate)
246 {
247   xbt_assert(not power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
248   return power_range_watts_list[pstate].max;
249 }
250
251 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
252 double HostEnergy::getCurrentWattsValue(double cpu_load)
253 {
254   xbt_assert(not power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
255
256   /* min_power corresponds to the power consumed when only one core is active */
257   /* max_power is the power consumed at 100% cpu load       */
258   auto range           = power_range_watts_list.at(this->pstate);
259   double current_power = 0;
260   double min_power     = 0;
261   double max_power     = 0;
262   double power_slope   = 0;
263
264   if (cpu_load > 0) { /* Something is going on, the machine is not idle */
265     double min_power = range.min;
266     double max_power = range.max;
267
268     /**
269      * The min_power states how much we consume when only one single
270      * core is working. This means that when cpu_load == 1/coreCount, then
271      * current_power == min_power.
272      *
273      * The maximum must be reached when all cores are working (but 1 core was
274      * already accounted for by min_power)
275      * i.e., we need min_power + (maxCpuLoad-1/coreCount)*power_slope == max_power
276      * (maxCpuLoad is by definition 1)
277      */
278     double power_slope;
279     int coreCount         = host->coreCount();
280     double coreReciprocal = static_cast<double>(1) / static_cast<double>(coreCount);
281     if (coreCount > 1)
282       power_slope = (max_power - min_power) / (1 - coreReciprocal);
283     else
284       power_slope = 0; // Should be 0, since max_power == min_power (in this case)
285
286     current_power = min_power + (cpu_load - coreReciprocal) * power_slope;
287   } else { /* Our machine is idle, take the dedicated value! */
288     current_power = range.idle;
289   }
290
291   XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
292   XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
293
294   return current_power;
295 }
296
297 double HostEnergy::getConsumedEnergy()
298 {
299   if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
300     simgrid::simix::kernelImmediate(std::bind(&HostEnergy::update, this));
301
302   return total_energy;
303 }
304
305 void HostEnergy::initWattsRangeList()
306 {
307   const char* all_power_values_str = host->property("watt_per_state");
308   if (all_power_values_str == nullptr)
309     return;
310
311   std::vector<std::string> all_power_values;
312   boost::split(all_power_values, all_power_values_str, boost::is_any_of(","));
313   XBT_DEBUG("%s: profile: %s, cores: %d", host->cname(), all_power_values_str, host->coreCount());
314
315   int i = 0;
316   for (auto current_power_values_str : all_power_values) {
317     /* retrieve the power values associated with the current pstate */
318     std::vector<std::string> current_power_values;
319     boost::split(current_power_values, current_power_values_str, boost::is_any_of(":"));
320     if (host->coreCount() == 1) {
321       xbt_assert(current_power_values.size() == 2 || current_power_values.size() == 3,
322                  "Power properties incorrectly defined for host %s."
323                  "It should be 'Idle:FullSpeed' power values because you have one core only.",
324                  host->cname());
325       if (current_power_values.size() == 2) {
326         // In this case, 1core == AllCores
327         current_power_values.push_back(current_power_values.at(1));
328       } else { // size == 3
329         xbt_assert((current_power_values.at(1)) == (current_power_values.at(2)),
330                    "Power properties incorrectly defined for host %s.\n"
331                    "The energy profile of mono-cores should be formated as 'Idle:FullSpeed' only.\n"
332                    "If you go for a 'Idle:OneCore:AllCores' power profile on mono-cores, then OneCore and AllCores "
333                    "must be equal.",
334                    host->cname());
335       }
336     } else {
337       xbt_assert(current_power_values.size() == 3,
338                  "Power properties incorrectly defined for host %s."
339                  "It should be 'Idle:OneCore:AllCores' power values because you have more than one core.",
340                  host->cname());
341     }
342
343     /* min_power corresponds to the idle power (cpu load = 0) */
344     /* max_power is the power consumed at 100% cpu load       */
345     char* msg_idle = bprintf("Invalid idle value for pstate %d on host %s: %%s", i, host->cname());
346     char* msg_min  = bprintf("Invalid OneCore value for pstate %d on host %s: %%s", i, host->cname());
347     char* msg_max  = bprintf("Invalid AllCores value for pstate %d on host %s: %%s", i, host->cname());
348     PowerRange range(xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle),
349                      xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_min),
350                      xbt_str_parse_double((current_power_values.at(2)).c_str(), msg_max));
351     power_range_watts_list.push_back(range);
352     xbt_free(msg_idle);
353     xbt_free(msg_min);
354     xbt_free(msg_max);
355     i++;
356   }
357 }
358 }
359 }
360
361 using simgrid::energy::HostEnergy;
362
363 /* **************************** events  callback *************************** */
364 static void onCreation(simgrid::s4u::Host& host)
365 {
366   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
367     return;
368
369   //TODO Trace: set to zero the energy variable associated to host->name()
370
371   host.extension_set(new HostEnergy(&host));
372 }
373
374 static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf::Action::State previous)
375 {
376   for (simgrid::surf::Cpu* cpu : action->cpus()) {
377     simgrid::s4u::Host* host = cpu->getHost();
378     if (host != nullptr) {
379
380       // If it's a VM, take the corresponding PM
381       simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
382       if (vm) // If it's a VM, take the corresponding PM
383         host = vm->pimpl_vm_->getPm();
384
385       // Get the host_energy extension for the relevant host
386       HostEnergy* host_energy = host->extension<HostEnergy>();
387
388       if (host_energy->last_updated < surf_get_clock())
389         host_energy->update();
390     }
391   }
392 }
393
394 /* This callback is fired either when the host changes its state (on/off) ("onStateChange") or its speed
395  * (because the user changed the pstate, or because of external trace events) ("onSpeedChange") */
396 static void onHostChange(simgrid::s4u::Host& host)
397 {
398   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
399     return;
400
401   HostEnergy* host_energy = host.extension<HostEnergy>();
402
403   host_energy->update();
404 }
405
406 static void onHostDestruction(simgrid::s4u::Host& host)
407 {
408   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
409     return;
410
411   HostEnergy* host_energy = host.extension<HostEnergy>();
412   host_energy->update();
413   XBT_INFO("Energy consumption of host %s: %f Joules", host.cname(), host_energy->getConsumedEnergy());
414 }
415
416 static void onSimulationEnd()
417 {
418   sg_host_t* host_list     = sg_host_list();
419   int host_count           = sg_host_count();
420   double total_energy      = 0.0; // Total energy consumption (whole platform)
421   double used_hosts_energy = 0.0; // Energy consumed by hosts that computed something
422   for (int i = 0; i < host_count; i++) {
423     if (dynamic_cast<simgrid::s4u::VirtualMachine*>(host_list[i]) == nullptr) { // Ignore virtual machines
424
425       bool host_was_used = (host_list[i]->extension<HostEnergy>()->last_updated != 0);
426       double energy      = host_list[i]->extension<HostEnergy>()->getConsumedEnergy();
427       total_energy      += energy;
428       if (host_was_used)
429         used_hosts_energy += energy;
430     }
431   }
432   XBT_INFO("Total energy consumption: %f Joules (used hosts: %f Joules; unused/idle hosts: %f)",
433            total_energy, used_hosts_energy, total_energy - used_hosts_energy);
434   xbt_free(host_list);
435 }
436
437 /* **************************** Public interface *************************** */
438 SG_BEGIN_DECL()
439
440 /** \ingroup plugin_energy
441  * \brief Enable host energy plugin
442  * \details Enable energy plugin to get joules consumption of each cpu. Call this function before #MSG_init().
443  */
444 void sg_host_energy_plugin_init()
445 {
446   if (HostEnergy::EXTENSION_ID.valid())
447     return;
448
449   HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
450
451   simgrid::s4u::Host::onCreation.connect(&onCreation);
452   simgrid::s4u::Host::onStateChange.connect(&onHostChange);
453   simgrid::s4u::Host::onSpeedChange.connect(&onHostChange);
454   simgrid::s4u::Host::onDestruction.connect(&onHostDestruction);
455   simgrid::s4u::onSimulationEnd.connect(&onSimulationEnd);
456   simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
457 }
458
459 /** @ingroup plugin_energy
460  *  @brief updates the consumption of all hosts
461  *
462  * After this call, sg_host_get_consumed_energy() will not interrupt your process
463  * (until after the next clock update).
464  */
465 void sg_host_energy_update_all()
466 {
467   simgrid::simix::kernelImmediate([]() {
468     std::vector<simgrid::s4u::Host*> list;
469     simgrid::s4u::Engine::instance()->hostList(&list);
470     for (auto host : list)
471       if (dynamic_cast<simgrid::s4u::VirtualMachine*>(host) == nullptr) // Ignore virtual machines
472         host->extension<HostEnergy>()->update();
473   });
474 }
475
476 /** @ingroup plugin_energy
477  *  @brief Returns the total energy consumed by the host so far (in Joules)
478  *
479  *  Please note that since the consumption is lazily updated, it may require a simcall to update it.
480  *  The result is that the actor requesting this value will be interrupted,
481  *  the value will be updated in kernel mode before returning the control to the requesting actor.
482  */
483 double sg_host_get_consumed_energy(sg_host_t host)
484 {
485   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
486              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
487   return host->extension<HostEnergy>()->getConsumedEnergy();
488 }
489
490 /** @ingroup plugin_energy
491  *  @brief Get the amount of watt dissipated at the given pstate when the host is idling
492  */
493 double sg_host_get_wattmin_at(sg_host_t host, int pstate)
494 {
495   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
496              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
497   return host->extension<HostEnergy>()->getWattMinAt(pstate);
498 }
499 /** @ingroup plugin_energy
500  *  @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100%
501  */
502 double sg_host_get_wattmax_at(sg_host_t host, int pstate)
503 {
504   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
505              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
506   return host->extension<HostEnergy>()->getWattMaxAt(pstate);
507 }
508
509 /** @ingroup plugin_energy
510  *  @brief Returns the current consumption of the host
511  */
512 double sg_host_get_current_consumption(sg_host_t host)
513 {
514   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
515              "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
516   double cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / host->speed();
517   return host->extension<HostEnergy>()->getCurrentWattsValue(cpu_load);
518 }
519
520 SG_END_DECL()