1 /* Copyright (c) 2010, 2012-2016. The SimGrid Team. All rights reserved. */
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. */
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"
12 /** @addtogroup SURF_plugin_energy
15 This is the energy plugin, enabling to account not only for computation time,
16 but also for the dissipated energy in the simulated platform.
18 The energy consumption of a CPU depends directly of its current load. Specify that consumption in your platform file as
22 <host id="HostA" power="100.0Mf" >
23 <prop id="watt_per_state" value="100.0:200.0" />
24 <prop id="watt_off" value="10" />
28 The first property means that when your host is up and running, but without anything to do, it will dissipate 100 Watts.
29 If it's fully loaded, it will dissipate 200 Watts. If its load is at 50%, then it will dissipate 150 Watts.
30 The second property means that when your host is turned off, it will dissipate only 10 Watts (please note that these
31 values are arbitrary).
33 If your CPU is using pstates, then you can provide one consumption interval per pstate.
36 <host id="HostB" power="100.0Mf,50.0Mf,20.0Mf" pstate="0" >
37 <prop id="watt_per_state" value="95.0:200.0, 93.0:170.0, 90.0:150.0" />
38 <prop id="watt_off" value="10" />
42 That host has 3 levels of performance with the following performance: 100 Mflop/s, 50 Mflop/s or 20 Mflop/s.
43 It starts at pstate 0 (ie, at 100 Mflop/s). In this case, you have to specify one interval per pstate in the
44 watt_per_state property.
45 In this example, the idle consumption is 95 Watts, 93 Watts and 90 Watts in each pstate while the CPU burn consumption
46 are at 200 Watts, 170 Watts, and 150 Watts respectively.
48 To change the pstate of a given CPU, use the following functions:
49 #MSG_host_get_nb_pstates(), simgrid#s4u#Host#setPstate(), #MSG_host_get_power_peak_at().
51 To simulate the energy-related elements, first call the simgrid#energy#sg_energy_plugin_init() before your #MSG_init(),
52 and then use the following function to retrieve the consumption of a given host: MSG_host_get_consumed_energy().
55 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf, "Logging specific to the SURF energy plugin");
66 PowerRange(double idle, double min, double max) : idle(idle), min(min), max(max) {}
71 static simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> EXTENSION_ID;
73 explicit HostEnergy(simgrid::s4u::Host* ptr);
76 double getCurrentWattsValue(double cpu_load);
77 double getConsumedEnergy();
78 double getWattMinAt(int pstate);
79 double getWattMaxAt(int pstate);
83 void initWattsRangeList();
84 simgrid::s4u::Host* host = nullptr;
85 std::vector<PowerRange>
86 power_range_watts_list; /*< List of (min_power,max_power) pairs corresponding to each cpu pstate */
88 double watts_off = 0.0; /*< Consumption when the machine is turned off (shutdown) */
89 double total_energy = 0.0; /*< Total energy consumed by the host */
90 double last_updated; /*< Timestamp of the last energy update event*/
93 simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
95 /* Computes the consumption so far. Called lazily on need. */
96 void HostEnergy::update()
98 double start_time = this->last_updated;
99 double finish_time = surf_get_clock();
101 if (host->pimpl_cpu->getPstateSpeedCurrent() <= 0)
102 // Some users declare a pstate of speed 0 flops (e.g., to model boot time).
103 // We consider that the machine is then fully loaded. That's arbitrary but it avoids a NaN
106 cpu_load = lmm_constraint_get_usage(host->pimpl_cpu->constraint()) / host->pimpl_cpu->getPstateSpeedCurrent();
108 /** Divide by the number of cores here **/
109 cpu_load /= host->pimpl_cpu->coreCount();
111 if (cpu_load > 1) // A machine with a load > 1 consumes as much as a fully loaded machine, not more
114 /* The problem with this model is that the load is always 0 or 1, never something less.
115 * Another possibility could be to model the total energy as
117 * X/(X+Y)*W_idle + Y/(X+Y)*W_burn
119 * where X is the amount of idling cores, and Y the amount of computing cores.
122 double previous_energy = this->total_energy;
124 double instantaneous_consumption;
126 instantaneous_consumption = this->watts_off;
128 instantaneous_consumption = this->getCurrentWattsValue(cpu_load);
130 double energy_this_step = instantaneous_consumption * (finish_time - start_time);
132 this->total_energy = previous_energy + energy_this_step;
133 this->last_updated = finish_time;
136 "[update_energy of %s] period=[%.2f-%.2f]; current power peak=%.0E flop/s; consumption change: %.2f J -> %.2f J",
137 host->cname(), start_time, finish_time, host->pimpl_cpu->speed_.peak, previous_energy, energy_this_step);
140 HostEnergy::HostEnergy(simgrid::s4u::Host* ptr) : host(ptr), last_updated(surf_get_clock())
142 initWattsRangeList();
144 const char* off_power_str = host->property("watt_off");
145 if (off_power_str != nullptr) {
146 char* msg = bprintf("Invalid value for property watt_off of host %s: %%s", host->cname());
147 this->watts_off = xbt_str_parse_double(off_power_str, msg);
150 /* watts_off is 0 by default */
153 HostEnergy::~HostEnergy() = default;
155 double HostEnergy::getWattMinAt(int pstate)
157 xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
158 return power_range_watts_list[pstate].min;
161 double HostEnergy::getWattMaxAt(int pstate)
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].max;
167 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
168 double HostEnergy::getCurrentWattsValue(double cpu_load)
170 xbt_assert(!power_range_watts_list.empty(), "No power range properties specified for host %s", host->cname());
172 /* min_power corresponds to the idle power (cpu load = 0) */
173 /* max_power is the power consumed at 100% cpu load */
174 auto range = power_range_watts_list.at(host->pstate());
175 double current_power = 0;
176 double min_power = 0;
177 double max_power = 0;
178 double power_slope = 0;
180 if (cpu_load > 0) { /* Something is going on, the machine is not idle */
181 double min_power = range.min;
182 double max_power = range.max;
185 * The min_power states how much we consume when only one single
186 * core is working. This means that when cpu_load == 1/coreCount, then
187 * current_power == min_power.
189 * The maximum must be reached when all cores are working (but 1 core was
190 * already accounted for by min_power)
191 * i.e., we need min_power + (maxCpuLoad-1/coreCount)*power_slope == max_power
192 * (maxCpuLoad is by definition 1)
195 int coreCount = host->coreCount();
196 double coreReciprocal = static_cast<double>(1) / static_cast<double>(coreCount);
198 power_slope = (max_power - min_power) / (1 - coreReciprocal);
200 power_slope = 0; // Should be 0, since max_power == min_power (in this case)
202 current_power = min_power + (cpu_load - coreReciprocal) * power_slope;
203 } else { /* Our machine is idle, take the dedicated value! */
204 current_power = range.idle;
207 XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
208 XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
210 return current_power;
213 double HostEnergy::getConsumedEnergy()
215 if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
216 simgrid::simix::kernelImmediate(std::bind(&HostEnergy::update, this));
221 void HostEnergy::initWattsRangeList()
223 const char* all_power_values_str = host->property("watt_per_state");
224 if (all_power_values_str == nullptr)
227 xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
228 int pstate_nb = xbt_dynar_length(all_power_values);
230 for (int i = 0; i < pstate_nb; i++) {
231 /* retrieve the power values associated with the current pstate */
232 xbt_dynar_t current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
233 xbt_assert(xbt_dynar_length(current_power_values) == 3,
234 "Power properties incorrectly defined - could not retrieve idle, min and max power values for host %s",
237 /* min_power corresponds to the idle power (cpu load = 0) */
238 /* max_power is the power consumed at 100% cpu load */
239 char* msg_idle = bprintf("Invalid idle value for pstate %d on host %s: %%s", i, host->cname());
240 char* msg_min = bprintf("Invalid min value for pstate %d on host %s: %%s", i, host->cname());
241 char* msg_max = bprintf("Invalid max value for pstate %d on host %s: %%s", i, host->cname());
242 PowerRange range(xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 0, char*), msg_idle),
243 xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 1, char*), msg_min),
244 xbt_str_parse_double(xbt_dynar_get_as(current_power_values, 2, char*), msg_max));
245 power_range_watts_list.push_back(range);
250 xbt_dynar_free(¤t_power_values);
252 xbt_dynar_free(&all_power_values);
257 using simgrid::energy::HostEnergy;
259 /* **************************** events callback *************************** */
260 static void onCreation(simgrid::s4u::Host& host)
262 if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
264 host.extension_set(new HostEnergy(&host));
267 static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf::Action::State previous)
269 for (simgrid::surf::Cpu* cpu : action->cpus()) {
270 simgrid::s4u::Host* host = cpu->getHost();
274 // If it's a VM, take the corresponding PM
275 simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
276 if (vm) // If it's a VM, take the corresponding PM
277 host = vm->pimpl_vm_->getPm();
279 // Get the host_energy extension for the relevant host
280 HostEnergy* host_energy = host->extension<HostEnergy>();
282 if (host_energy->last_updated < surf_get_clock())
283 host_energy->update();
287 /* This callback is fired either when the host change its state (on/off) or its speed
288 * (because the user changed the pstate, or because of external trace events) */
289 static void onHostChange(simgrid::s4u::Host& host)
291 if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
294 HostEnergy* host_energy = host.extension<HostEnergy>();
296 if (host_energy->last_updated < surf_get_clock())
297 host_energy->update();
300 static void onHostDestruction(simgrid::s4u::Host& host)
302 if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
305 HostEnergy* host_energy = host.extension<HostEnergy>();
306 host_energy->update();
307 XBT_INFO("Total energy of host %s: %f Joules", host.cname(), host_energy->getConsumedEnergy());
310 /* **************************** Public interface *************************** */
311 /** \ingroup SURF_plugin_energy
312 * \brief Enable host energy plugin
313 * \details Enable energy plugin to get joules consumption of each cpu. Call this function before #MSG_init().
315 void sg_host_energy_plugin_init()
317 if (HostEnergy::EXTENSION_ID.valid())
320 HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
322 simgrid::s4u::Host::onCreation.connect(&onCreation);
323 simgrid::s4u::Host::onStateChange.connect(&onHostChange);
324 simgrid::s4u::Host::onSpeedChange.connect(&onHostChange);
325 simgrid::s4u::Host::onDestruction.connect(&onHostDestruction);
326 simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
329 /** @brief Returns the total energy consumed by the host so far (in Joules)
331 * See also @ref SURF_plugin_energy.
333 double sg_host_get_consumed_energy(sg_host_t host)
335 xbt_assert(HostEnergy::EXTENSION_ID.valid(),
336 "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
337 return host->extension<HostEnergy>()->getConsumedEnergy();
340 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
341 double sg_host_get_wattmin_at(sg_host_t host, int pstate)
343 xbt_assert(HostEnergy::EXTENSION_ID.valid(),
344 "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
345 return host->extension<HostEnergy>()->getWattMinAt(pstate);
347 /** @brief Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
348 double sg_host_get_wattmax_at(sg_host_t host, int pstate)
350 xbt_assert(HostEnergy::EXTENSION_ID.valid(),
351 "The Energy plugin is not active. Please call sg_energy_plugin_init() during initialization.");
352 return host->extension<HostEnergy>()->getWattMaxAt(pstate);