Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
8f5a2baeaac33fa40d3c8164b3c761a4a0b5fabe
[simgrid.git] / 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_interface.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 =
104                         surf_energy->find(vm->p_hostPM->extension(simgrid::surf::Host::EXTENSION_ID));
105         xbt_assert(host_energy_it != surf_energy->end(), "The host is not in surf_energy.");
106         (*surf_energy)[vm] = host_energy_it->second;
107         host_energy_it->second->ref(); // protect the HostEnergy from getting deleted too early
108     });
109
110     simgrid::surf::Host::onDestruction.connect([](simgrid::surf::Host *host) {
111         std::map<simgrid::surf::Host*, HostEnergy*>::iterator host_energy_it = surf_energy->find(host);
112         xbt_assert(host_energy_it != surf_energy->end(), "The host is not in surf_energy.");
113
114         HostEnergy *host_energy = host_energy_it->second;
115         update_consumption(host, host_energy);
116
117         if (host_energy_it->second->refcount == 1) // Don't display anything for virtual CPUs
118                 XBT_INFO("Total energy of host %s: %f Joules", host->getName(), host_energy->getConsumedEnergy());
119         host_energy_it->second->unref();
120         surf_energy->erase(host_energy_it);
121     });
122     simgrid::surf::CpuAction::onStateChange.connect([](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, 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, 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 /** @brief Computes the power consumed by the host according to the current pstate and processor load */
200 double HostEnergy::getCurrentWattsValue(double cpu_load)
201 {
202         xbt_dynar_t power_range_list = power_range_watts_list;
203         xbt_assert(power_range_watts_list, "No power range properties specified for host %s", host->getName());
204
205         int pstate = host->p_cpu->getPState();
206         xbt_assert(pstate < (int)xbt_dynar_length(power_range_list),
207                         "pstate %d >= power range amound %d",pstate,(int)xbt_dynar_length(power_range_list));
208     /* retrieve the power values associated with the current pstate */
209     xbt_dynar_t current_power_values = xbt_dynar_get_as( power_range_list, pstate, xbt_dynar_t);
210
211     /* min_power corresponds to the idle power (cpu load = 0) */
212     /* max_power is the power consumed at 100% cpu load       */
213     double min_power = xbt_dynar_get_as(current_power_values, 0, double);
214     double max_power = xbt_dynar_get_as(current_power_values, 1, double);
215     double power_slope = max_power - min_power;
216
217     double current_power = min_power + cpu_load * power_slope;
218
219         XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
220     XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
221
222         return current_power;
223 }
224
225 double HostEnergy::getConsumedEnergy()
226 {
227         if(last_updated < surf_get_clock())
228                 update_consumption(host, this);
229         return total_energy;
230 }
231
232 xbt_dynar_t HostEnergy::getWattsRangeList()
233 {
234         xbt_dynar_t power_range_list;
235         xbt_dynar_t power_tuple;
236         int i = 0, pstate_nb=0;
237         xbt_dynar_t current_power_values;
238         double min_power, max_power;
239
240         if (host->getProperties() == NULL)
241                 return NULL;
242
243         char* all_power_values_str = (char*)xbt_dict_get_or_null(host->getProperties(), "watt_per_state");
244
245         if (all_power_values_str == NULL)
246                 return NULL;
247
248
249         power_range_list = xbt_dynar_new(sizeof(xbt_dynar_t), NULL);
250         xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
251
252         pstate_nb = xbt_dynar_length(all_power_values);
253         for (i=0; i< pstate_nb; i++)
254         {
255                 /* retrieve the power values associated with the current pstate */
256                 current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
257                 xbt_assert(xbt_dynar_length(current_power_values) > 1,
258                                 "Power properties incorrectly defined - could not retrieve min and max power values for host %s",
259                                 host->getName());
260
261                 /* min_power corresponds to the idle power (cpu load = 0) */
262                 /* max_power is the power consumed at 100% cpu load       */
263                 min_power = atof(xbt_dynar_get_as(current_power_values, 0, char*));
264                 max_power = atof(xbt_dynar_get_as(current_power_values, 1, char*));
265
266                 power_tuple = xbt_dynar_new(sizeof(double), NULL);
267                 xbt_dynar_push_as(power_tuple, double, min_power);
268                 xbt_dynar_push_as(power_tuple, double, max_power);
269
270                 xbt_dynar_push_as(power_range_list, xbt_dynar_t, power_tuple);
271                 xbt_dynar_free(&current_power_values);
272         }
273         xbt_dynar_free(&all_power_values);
274         return power_range_list;
275 }
276
277 }
278 }