Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
remove some direct accesses to pimpl_cpu
[simgrid.git] / src / plugins / host_energy.cpp
1 /* Copyright (c) 2010-2019. 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/s4u/Engine.hpp"
8 #include "simgrid/s4u/Exec.hpp"
9 #include "src/include/surf/surf.hpp"
10 #include "src/kernel/activity/ExecImpl.hpp"
11 #include "src/plugins/vm/VirtualMachineImpl.hpp"
12 #include "src/surf/cpu_interface.hpp"
13
14 #include <boost/algorithm/string/classification.hpp>
15 #include <boost/algorithm/string/split.hpp>
16
17 SIMGRID_REGISTER_PLUGIN(host_energy, "Cpu energy consumption.", &sg_host_energy_plugin_init)
18
19 /** @defgroup plugin_host_energy
20
21   @rst
22 This is the energy plugin, enabling to account not only for computation time, but also for the dissipated energy in the
23 simulated platform.
24 To activate this plugin, first call :cpp:func:`sg_host_energy_plugin_init()` before your :cpp:func:`MSG_init()`, and then use
25 :cpp:func:`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 current CPU load and the host energy profile.
28 According to our measurements, the consumption is somehow linear in the amount of cores at full speed, with an
29 abnormality when all the cores are idle. The full details are in `our scientific paper <https://hal.inria.fr/hal-01523608>`_
30 on that topic.
31
32 As a result, our energy model takes 4 parameters:
33
34   - ``Idle`` wattage (i.e., instantaneous consumption in Watt) when your host is up and running, but without anything to do.
35   - ``Epsilon`` wattage when all cores are at 0 or epsilon%, but not in Idle state.
36   - ``AllCores`` wattage when all cores of the host are at 100%.
37   - ``Off`` wattage when the host is turned off.
38
39 Here is an example of XML declaration:
40
41 .. code-block:: xml
42
43    <host id="HostA" speed="100.0Mf" core="4">
44        <prop id="wattage_per_state" value="100.0:120.0:200.0" />
45        <prop id="wattage_off" value="10" />
46    </host>
47
48 If only two values are given, ``Idle`` is used for the missing ``Epsilon`` value.
49
50 This example gives the following parameters: ``Off`` is 10 Watts; ``Idle`` is 100 Watts; ``Epsilon`` is 120 Watts and
51 ``AllCores`` is 200 Watts.
52 This is enough to compute the wattage as a function of the amount of loaded cores:
53
54 .. raw:: html
55
56    <table border="1">
57    <tr><th>#Cores loaded</th><th>Wattage</th><th>Explanation</th></tr>
58    <tr><td>0 (idle)</td><td> 100 Watts&nbsp;</td><td> Idle value</td></tr>
59    <tr><td>0 (not idle)</td><td> 120 Watts</td><td> Epsilon value</td></tr>
60    <tr><td>1</td><td> 140 Watts</td><td> Linear extrapolation between Epsilon and AllCores</td></tr>
61    <tr><td>2</td><td> 160 Watts</td><td> Linear extrapolation between Epsilon and AllCores</td></tr>
62    <tr><td>3</td><td> 180 Watts</td><td> Linear extrapolation between Epsilon and AllCores</td></tr>
63    <tr><td>4</td><td> 200 Watts</td><td> AllCores value</td></tr>
64    </table>
65
66
67 .. raw:: html
68
69    <h4>How does DVFS interact with the host energy model?</h4>
70
71 If your host has several DVFS levels (several pstates), then you should give the energetic profile of each pstate level:
72
73 .. code-block:: xml
74
75    <host id="HostC" speed="100.0Mf,50.0Mf,20.0Mf" core="4">
76        <prop id="wattage_per_state"
77              value="95.0:120.0:200.0, 93.0:115.0:170.0, 90.0:110.0:150.0" />
78        <prop id="wattage_off" value="10" />
79    </host>
80
81 This encodes the following values:
82
83 .. raw:: html
84
85    <table border="1">
86    <tr><th>pstate</th><th>Performance</th><th>Idle</th><th>Epsilon</th><th>AllCores</th></tr>
87    <tr><td>0</td><td>100 Mflop/s</td><td>95 Watts</td><td>120 Watts</td><td>200 Watts</td></tr>
88    <tr><td>1</td><td>50 Mflop/s</td><td>93 Watts</td><td>115 Watts</td><td>170 Watts</td></tr>
89    <tr><td>2</td><td>20 Mflop/s</td><td>90 Watts</td><td>110 Watts</td><td>150 Watts</td></tr>
90    </table>
91
92 To change the pstate of a given CPU, use the following functions:
93 :cpp:func:`MSG_host_get_nb_pstates()`, :cpp:func:`simgrid::s4u::Host::set_pstate()`, :cpp:func:`MSG_host_get_power_peak_at()`.
94
95 .. raw:: html
96
97    <h4>How accurate are these models?</h4>
98
99 This model cannot be more accurate than your instantiation: with the default values, your result will not be accurate at
100 all. You can still get accurate energy prediction, provided that you carefully instantiate the model.
101 The first step is to ensure that your timing prediction match perfectly. But this is only the first step of the path,
102 and you really want to read `this paper <https://hal.inria.fr/hal-01523608>`_ to see all what you need to do
103 before you can get accurate energy predictions.
104
105   @endrst
106  */
107
108 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin");
109
110 // Forwards declaration needed to make this function a friend (because friends have external linkage by default)
111 static void on_simulation_end();
112
113 namespace simgrid {
114 namespace plugin {
115
116 class PowerRange {
117 public:
118   double idle_;
119   double epsilon_;
120   double max_;
121   double slope_;
122
123   PowerRange(double idle, double epsilon, double max) : idle_(idle), epsilon_(epsilon), max_(max), slope_(max-epsilon) {}
124 };
125
126 class HostEnergy {
127   friend void ::on_simulation_end(); // For access to host_was_used_
128 public:
129   static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
130
131   explicit HostEnergy(simgrid::s4u::Host* ptr);
132   ~HostEnergy();
133
134   double get_current_watts_value();
135   double get_current_watts_value(double cpu_load);
136   double get_consumed_energy();
137   double get_watt_idle_at(int pstate);
138   double get_watt_min_at(int pstate);
139   double get_watt_max_at(int pstate);
140   double get_power_range_slope_at(int pstate);
141   void update();
142
143 private:
144   void init_watts_range_list();
145   simgrid::s4u::Host* host_ = nullptr;
146   /*< List of (idle_power, epsilon_power, max_power) tuple corresponding to each cpu pstate */
147   std::vector<PowerRange> power_range_watts_list_;
148
149   /* We need to keep track of what pstate has been used, as we will sometimes be notified only *after* a pstate has been
150    * used (but we need to update the energy consumption with the old pstate!)
151    */
152   int pstate_           = 0;
153   const int pstate_off_ = -1;
154
155   /* Only used to split total energy into unused/used hosts.
156    * If you want to get this info for something else, rather use the host_load plugin
157    */
158   bool host_was_used_  = false;
159 public:
160   double watts_off_    = 0.0; /*< Consumption when the machine is turned off (shutdown) */
161   double total_energy_ = 0.0; /*< Total energy consumed by the host */
162   double last_updated_;       /*< Timestamp of the last energy update event*/
163 };
164
165 simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
166
167 /* Computes the consumption so far. Called lazily on need. */
168 void HostEnergy::update()
169 {
170   double start_time  = this->last_updated_;
171   double finish_time = surf_get_clock();
172   //
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 if),
177   // which may have changed since that recent update.
178   if (start_time < finish_time) {
179     double previous_energy = this->total_energy_;
180
181     double instantaneous_power_consumption = this->get_current_watts_value();
182
183     double energy_this_step = instantaneous_power_consumption * (finish_time - start_time);
184
185     // TODO Trace: Trace energy_this_step from start_time to finish_time in host->getName()
186
187     this->total_energy_ = previous_energy + energy_this_step;
188     this->last_updated_ = finish_time;
189
190     XBT_DEBUG("[update_energy of %s] period=[%.8f-%.8f]; current speed=%.2E flop/s (pstate %i); total consumption "
191               "before: %.8f J -> added now: %.8f J",
192               host_->get_cname(), start_time, finish_time, host_->get_pstate_speed(this->pstate_), this->pstate_,
193               previous_energy, energy_this_step);
194   }
195
196   /* Save data for the upcoming time interval: whether it's on/off and the pstate if it's on */
197   this->pstate_ = host_->is_on() ? host_->get_pstate() : pstate_off_;
198 }
199
200 HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host_(ptr), last_updated_(surf_get_clock())
201 {
202   init_watts_range_list();
203
204   const char* off_power_str = host_->get_property("wattage_off");
205   if (off_power_str == nullptr) {
206     off_power_str = host_->get_property("watt_off");
207
208     static bool warned = false;
209     if (off_power_str != nullptr && not warned) {
210       warned = true;
211       XBT_WARN("Please use 'wattage_off' instead of 'watt_off' to define the idle wattage of hosts in your XML.");
212     }
213   }
214   if (off_power_str != nullptr) {
215     try {
216       this->watts_off_ = std::stod(std::string(off_power_str));
217     } catch (const std::invalid_argument&) {
218       throw std::invalid_argument(std::string("Invalid value for property wattage_off of host ") + host_->get_cname() +
219                                   ": " + off_power_str);
220     }
221   }
222   /* watts_off is 0 by default */
223 }
224
225 HostEnergy::~HostEnergy() = default;
226
227 double HostEnergy::get_watt_idle_at(int pstate)
228 {
229   xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s",
230              host_->get_cname());
231   return power_range_watts_list_[pstate].idle_;
232 }
233
234 double HostEnergy::get_watt_min_at(int pstate)
235 {
236   xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s",
237              host_->get_cname());
238   return power_range_watts_list_[pstate].epsilon_;
239 }
240
241 double HostEnergy::get_watt_max_at(int pstate)
242 {
243   xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s",
244              host_->get_cname());
245   return power_range_watts_list_[pstate].max_;
246 }
247
248 double HostEnergy::get_power_range_slope_at(int pstate)
249 {
250   xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s",
251              host_->get_cname());
252   return power_range_watts_list_[pstate].slope_;
253 }
254
255 /** @brief Computes the power consumed by the host according to the current situation
256  *
257  * - If the host is off, that's the watts_off value
258  * - if it's on, take the current pstate and the current processor load into account */
259 double HostEnergy::get_current_watts_value()
260 {
261   if (this->pstate_ == pstate_off_) // The host is off (or was off at the beginning of this time interval)
262     return this->watts_off_;
263
264   double current_speed = host_->get_pstate_speed(this->pstate_);
265
266   double cpu_load;
267
268   if (current_speed <= 0)
269     // Some users declare a pstate of speed 0 flops (e.g., to model boot time).
270     // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN
271     cpu_load = 1;
272   else {
273     cpu_load = host_->get_load() / current_speed;
274
275     /* Divide by the number of cores here to have a value between 0 and 1 */
276     cpu_load /= host_->get_core_count();
277
278     if (cpu_load > 1) // This condition is true for energy_ptask on 32 bits, even if cpu_load is displayed as 1.000000
279       cpu_load = 1;   // That may be an harmless rounding error?
280     if (cpu_load > 0)
281       host_was_used_ = true;
282   }
283
284   return get_current_watts_value(cpu_load);
285 }
286
287 /** @brief Computes the power that the host would consume at the provided processor load
288  *
289  * Whether the host is ON or OFF is not taken into account.
290  */
291 double HostEnergy::get_current_watts_value(double cpu_load)
292 {
293   xbt_assert(not power_range_watts_list_.empty(), "No power range properties specified for host %s",
294              host_->get_cname());
295
296   /* Return watts_off if pstate == pstate_off (ie, if the host is off) */
297   if (this->pstate_ == pstate_off_) {
298     return watts_off_;
299   }
300
301   PowerRange power_range = power_range_watts_list_.at(this->pstate_);
302   double current_power;
303
304   if (cpu_load > 0)
305   {
306       /**
307        * Something is going on, the host is not idle.
308        *
309        * The power consumption follows the regular model:
310        * P(cpu_load) = Pstatic + Pdynamic * cpu_load
311        * where Pstatic = power_range.epsilon_ and Pdynamic = power_range.slope_
312        * and the cpu_load is a value between 0 and 1.
313        */
314       current_power = power_range.epsilon_ + cpu_load * power_range.slope_;
315   }
316   else
317   {
318       /* The host is idle, take the dedicated value! */
319       current_power = power_range.idle_;
320   }
321
322   XBT_DEBUG("[get_current_watts] pstate=%i, epsilon_power=%f, max_power=%f, slope=%f", this->pstate_, power_range.epsilon_,
323             power_range.max_, power_range.slope_);
324   XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
325
326   return current_power;
327 }
328
329 double HostEnergy::get_consumed_energy()
330 {
331   if (last_updated_ < surf_get_clock()) // We need to simcall this as it modifies the environment
332     simgrid::kernel::actor::simcall(std::bind(&HostEnergy::update, this));
333
334   return total_energy_;
335 }
336
337 void HostEnergy::init_watts_range_list()
338 {
339   const char* old_prop = host_->get_property("watt_per_state");
340   if (old_prop != nullptr) {
341     std::vector<std::string> all_power_values;
342     boost::split(all_power_values, old_prop, boost::is_any_of(","));
343
344     xbt_assert(all_power_values.size() == (unsigned)host_->get_pstate_count(),
345                "Invalid XML file. Found %zu energetic profiles for %d pstates", all_power_values.size(),
346                host_->get_pstate_count());
347
348     // XBT_ATTRIB_DEPRECATED_v328: putting this macro name here so that we find it during the deprecation cleanups
349     std::string msg = std::string("DEPRECATION WARNING: Property 'watt_per_state' will only work until v3.28.\n");
350     msg += std::string("The old syntax 'Idle:OneCore:AllCores' must be converted into 'Idle:Epsilon:AllCores' to "
351                        "properly model the consumption of non-whole tasks on mono-core hosts. Here are the values to "
352                        "use for host '") +
353            host_->get_cname() + "' in your XML file:\n";
354     msg += "     <prop id=\"wattage_per_state\" value=\"";
355     for (auto const& current_power_values_str : all_power_values) {
356       std::vector<std::string> current_power_values;
357       boost::split(current_power_values, current_power_values_str, boost::is_any_of(":"));
358       double p_idle = xbt_str_parse_double((current_power_values.at(0)).c_str(),
359                                            "Invalid obsolete XML file. Fix your watt_per_state property.");
360       double p_full;
361       double p_epsilon;
362
363       if (current_power_values.size() == 3) {
364         double p_one_core = xbt_str_parse_double((current_power_values.at(1)).c_str(),
365                                                  "Invalid obsolete XML file. Fix your watt_per_state property.");
366         p_full     = xbt_str_parse_double((current_power_values.at(2)).c_str(),
367                                       "Invalid obsolete XML file. Fix your watt_per_state property.");
368         if (host_->get_core_count() == 1) {
369           p_epsilon = p_full;
370         } else {
371           p_epsilon = p_one_core - ((p_full - p_one_core) / (host_->get_core_count() - 1));
372         }
373       } else { // consuption given with idle and full only
374         p_full = xbt_str_parse_double((current_power_values.at(1)).c_str(),
375                                       "Invalid obsolete XML file. Fix your watt_per_state property.");
376         if (host_->get_core_count() == 1) {
377           p_epsilon = p_full;
378         } else {
379           p_epsilon = p_idle;
380         }
381       }
382
383       PowerRange range(p_idle, p_epsilon, p_full);
384       power_range_watts_list_.push_back(range);
385
386       msg += std::to_string(p_idle) + ":" + std::to_string(p_epsilon) + ":" + std::to_string(p_full);
387       msg += ",";
388     }
389     msg.pop_back(); // Remove the extraneous ','
390     msg += "\" />";
391     XBT_WARN("%s", msg.c_str());
392     return;
393   }
394
395   const char* all_power_values_str = host_->get_property("wattage_per_state");
396   if (all_power_values_str == nullptr) {
397     /* If no power values are given, we assume it's 0 everywhere */
398     XBT_DEBUG("No energetic profiles given for host %s, using 0 W by default.", host_->get_cname());
399     for (int i = 0; i < host_->get_pstate_count(); ++i) {
400         PowerRange range(0,0,0);
401         power_range_watts_list_.push_back(range);
402     }
403     return;
404   }
405
406   std::vector<std::string> all_power_values;
407   boost::split(all_power_values, all_power_values_str, boost::is_any_of(","));
408   XBT_DEBUG("%s: power properties: %s", host_->get_cname(), all_power_values_str);
409
410   xbt_assert(all_power_values.size() == (unsigned)host_->get_pstate_count(),
411              "Invalid XML file. Found %zu energetic profiles for %d pstates", all_power_values.size(),
412              host_->get_pstate_count());
413
414   int i = 0;
415   for (auto const& current_power_values_str : all_power_values) {
416     /* retrieve the power values associated with the pstate i */
417     std::vector<std::string> current_power_values;
418     boost::split(current_power_values, current_power_values_str, boost::is_any_of(":"));
419
420     xbt_assert(current_power_values.size() == 2 || current_power_values.size() == 3,
421                "Power properties incorrectly defined for host %s."
422                "It should be 'Idle:AllCores' (or 'Idle:Epsilon:AllCores') power values.",
423                host_->get_cname());
424
425     double idle_power;
426     double epsilon_power;
427     double max_power;
428
429     char* msg_idle    = bprintf("Invalid Idle value for pstate %d on host %s: %%s", i, host_->get_cname());
430     char* msg_epsilon = bprintf("Invalid Epsilon value for pstate %d on host %s: %%s", i, host_->get_cname());
431     char* msg_max     = bprintf("Invalid AllCores value for pstate %d on host %s: %%s", i, host_->get_cname());
432
433     idle_power = xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle);
434     if (current_power_values.size() == 2) { // Case: Idle:AllCores
435       epsilon_power = xbt_str_parse_double((current_power_values.at(0)).c_str(), msg_idle);
436       max_power     = xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_max);
437     } else { // Case: Idle:Epsilon:AllCores
438       epsilon_power = xbt_str_parse_double((current_power_values.at(1)).c_str(), msg_epsilon);
439       max_power     = xbt_str_parse_double((current_power_values.at(2)).c_str(), msg_max);
440     }
441
442     XBT_DEBUG("Creating PowerRange for host %s. Idle:%f, Epsilon:%f, AllCores:%f.", host_->get_cname(), idle_power, epsilon_power, max_power);
443
444     PowerRange range(idle_power, epsilon_power, max_power);
445     power_range_watts_list_.push_back(range);
446     xbt_free(msg_idle);
447     xbt_free(msg_epsilon);
448     xbt_free(msg_max);
449     ++i;
450   }
451 }
452 } // namespace plugin
453 } // namespace simgrid
454
455 using simgrid::plugin::HostEnergy;
456
457 /* **************************** events  callback *************************** */
458 static void on_creation(simgrid::s4u::Host& host)
459 {
460   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
461     return;
462
463   // TODO Trace: set to zero the energy variable associated to host->getName()
464
465   host.extension_set(new HostEnergy(&host));
466 }
467
468 static void on_action_state_change(simgrid::kernel::resource::CpuAction const& action,
469                                    simgrid::kernel::resource::Action::State /*previous*/)
470 {
471   for (simgrid::kernel::resource::Cpu* const& cpu : action.cpus()) {
472     simgrid::s4u::Host* host = cpu->get_host();
473     if (host != nullptr) {
474
475       // If it's a VM, take the corresponding PM
476       simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
477       if (vm) // If it's a VM, take the corresponding PM
478         host = vm->get_pm();
479
480       // Get the host_energy extension for the relevant host
481       HostEnergy* host_energy = host->extension<HostEnergy>();
482
483       if (host_energy->last_updated_ < surf_get_clock())
484         host_energy->update();
485     }
486   }
487 }
488
489 /* This callback is fired either when the host changes its state (on/off) ("onStateChange") or its speed
490  * (because the user changed the pstate, or because of external trace events) ("onSpeedChange") */
491 static void on_host_change(simgrid::s4u::Host const& host)
492 {
493   if (dynamic_cast<simgrid::s4u::VirtualMachine const*>(&host)) // Ignore virtual machines
494     return;
495
496   HostEnergy* host_energy = host.extension<HostEnergy>();
497
498   host_energy->update();
499 }
500
501 static void on_host_destruction(simgrid::s4u::Host const& host)
502 {
503   if (dynamic_cast<simgrid::s4u::VirtualMachine const*>(&host)) // Ignore virtual machines
504     return;
505
506   XBT_INFO("Energy consumption of host %s: %f Joules", host.get_cname(),
507            host.extension<HostEnergy>()->get_consumed_energy());
508 }
509
510 static void on_simulation_end()
511 {
512   std::vector<simgrid::s4u::Host*> hosts = simgrid::s4u::Engine::get_instance()->get_all_hosts();
513
514   double total_energy      = 0.0; // Total energy consumption (whole platform)
515   double used_hosts_energy = 0.0; // Energy consumed by hosts that computed something
516   for (size_t i = 0; i < hosts.size(); i++) {
517     if (dynamic_cast<simgrid::s4u::VirtualMachine*>(hosts[i]) == nullptr) { // Ignore virtual machines
518
519       double energy      = hosts[i]->extension<HostEnergy>()->get_consumed_energy();
520       total_energy += energy;
521       if (hosts[i]->extension<HostEnergy>()->host_was_used_)
522         used_hosts_energy += energy;
523     }
524   }
525   XBT_INFO("Total energy consumption: %f Joules (used hosts: %f Joules; unused/idle hosts: %f)", total_energy,
526            used_hosts_energy, total_energy - used_hosts_energy);
527 }
528
529 /* **************************** Public interface *************************** */
530
531 /** @ingroup plugin_host_energy
532  * @brief Enable host energy plugin
533  * @details Enable energy plugin to get joules consumption of each cpu. Call this function before #MSG_init().
534  */
535 void sg_host_energy_plugin_init()
536 {
537   if (HostEnergy::EXTENSION_ID.valid())
538     return;
539
540   HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
541
542   simgrid::s4u::Host::on_creation.connect(&on_creation);
543   simgrid::s4u::Host::on_state_change.connect(&on_host_change);
544   simgrid::s4u::Host::on_speed_change.connect(&on_host_change);
545   simgrid::s4u::Host::on_destruction.connect(&on_host_destruction);
546   simgrid::s4u::Engine::on_simulation_end.connect(&on_simulation_end);
547   simgrid::kernel::resource::CpuAction::on_state_change.connect(&on_action_state_change);
548   // We may only have one actor on a node. If that actor executes something like
549   //   compute -> recv -> compute
550   // the recv operation will not trigger a "CpuAction::on_state_change". This means
551   // that the next trigger would be the 2nd compute, hence ignoring the idle time
552   // during the recv call. By updating at the beginning of a compute, we can
553   // fix that. (If the cpu is not idle, this is not required.)
554   simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::Actor const&, simgrid::s4u::Exec const& activity) {
555     if (activity.get_host_number() == 1) { // We only run on one host
556       simgrid::s4u::Host* host         = activity.get_host();
557       simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
558       if (vm != nullptr)
559         host = vm->get_pm();
560       xbt_assert(host != nullptr);
561       host->extension<HostEnergy>()->update();
562     }
563   });
564 }
565
566 /** @ingroup plugin_host_energy
567  *  @brief updates the consumption of all hosts
568  *
569  * After this call, sg_host_get_consumed_energy() will not interrupt your process
570  * (until after the next clock update).
571  */
572 void sg_host_energy_update_all()
573 {
574   simgrid::kernel::actor::simcall([]() {
575     std::vector<simgrid::s4u::Host*> list = simgrid::s4u::Engine::get_instance()->get_all_hosts();
576     for (auto const& host : list)
577       if (dynamic_cast<simgrid::s4u::VirtualMachine*>(host) == nullptr) { // Ignore virtual machines
578         xbt_assert(host != nullptr);
579         host->extension<HostEnergy>()->update();
580       }
581   });
582 }
583
584 /** @ingroup plugin_host_energy
585  *  @brief Returns the total energy consumed by the host so far (in Joules)
586  *
587  *  Please note that since the consumption is lazily updated, it may require a simcall to update it.
588  *  The result is that the actor requesting this value will be interrupted,
589  *  the value will be updated in kernel mode before returning the control to the requesting actor.
590  */
591 double sg_host_get_consumed_energy(sg_host_t host)
592 {
593   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
594              "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
595   return host->extension<HostEnergy>()->get_consumed_energy();
596 }
597
598 /** @ingroup plugin_host_energy
599  *  @brief Get the amount of watt dissipated when the host is idling
600  */
601 double sg_host_get_idle_consumption(sg_host_t host)
602 {
603   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
604              "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
605   return host->extension<HostEnergy>()->get_watt_idle_at(0);
606 }
607
608 /** @ingroup plugin_host_energy
609  *  @brief Get the amount of watt dissipated at the given pstate when the host is idling
610  */
611 double sg_host_get_idle_consumption_at(sg_host_t host, int pstate)
612 {
613   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
614              "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
615   return host->extension<HostEnergy>()->get_watt_idle_at(pstate);
616 }
617
618 /** @ingroup plugin_host_energy
619  *  @brief Get the amount of watt dissipated at the given pstate when the host is at 0 or epsilon% CPU usage.
620  */
621 double sg_host_get_wattmin_at(sg_host_t host, int pstate)
622 {
623   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
624              "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
625   return host->extension<HostEnergy>()->get_watt_min_at(pstate);
626 }
627 /** @ingroup plugin_host_energy
628  *  @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100%
629  */
630 double sg_host_get_wattmax_at(sg_host_t host, int pstate)
631 {
632   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
633              "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
634   return host->extension<HostEnergy>()->get_watt_max_at(pstate);
635 }
636 /** @ingroup plugin_host_energy
637  *  @brief  Returns the power slope at the given pstate
638  */
639 double sg_host_get_power_range_slope_at(sg_host_t host, int pstate)
640 {
641   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
642              "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
643   return host->extension<HostEnergy>()->get_power_range_slope_at(pstate);
644 }
645 /** @ingroup plugin_host_energy
646  *  @brief Returns the current consumption of the host
647  */
648 double sg_host_get_current_consumption(sg_host_t host)
649 {
650   xbt_assert(HostEnergy::EXTENSION_ID.valid(),
651              "The Energy plugin is not active. Please call sg_host_energy_plugin_init() during initialization.");
652   return host->extension<HostEnergy>()->get_current_watts_value();
653 }