Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
sonar don't like comments ending with ';'
[simgrid.git] / src / surf / plugins / host_load.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/load.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_load
20
21 This plugin makes it very simple for users to obtain the current load for each host.
22
23 */
24
25 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_plugin_load, surf, "Logging specific to the HostLoad plugin");
26
27 namespace simgrid {
28 namespace plugin {
29
30 class HostLoad {
31 public:
32   static simgrid::xbt::Extension<simgrid::s4u::Host, HostLoad> EXTENSION_ID;
33
34   explicit HostLoad(simgrid::s4u::Host* ptr);
35   ~HostLoad();
36
37   double getCurrentLoad();
38   double getComputedFlops();
39   double getAverageLoad();
40   double getIdleTime();
41   void update();
42   void reset();
43
44 private:
45   simgrid::s4u::Host* host = nullptr;
46   double last_updated      = 0;
47   double last_reset        = 0;
48   double current_speed     = 0;
49   double current_flops     = 0;
50   double computed_flops    = 0;
51   double idle_time         = 0;
52   double theor_max_flops   = 0;
53   bool   was_prev_idle     = true; /* A host is idle at the beginning */
54 };
55
56 simgrid::xbt::Extension<simgrid::s4u::Host, HostLoad> HostLoad::EXTENSION_ID;
57
58 HostLoad::HostLoad(simgrid::s4u::Host* ptr)
59     : host(ptr)
60     , last_updated(surf_get_clock())
61     , last_reset(surf_get_clock())
62     , current_speed(host->getSpeed())
63     , current_flops(host->pimpl_cpu->constraint()->get_usage())
64     , theor_max_flops(0)
65     , was_prev_idle(current_flops == 0)
66 {
67 }
68
69 HostLoad::~HostLoad() = default;
70
71 void HostLoad::update()
72 {
73   double now = surf_get_clock();
74
75   /* Current flop per second computed by the cpu; current_flops = k * pstate_speed_in_flops, k \in {0, 1, ..., cores}
76    * number of active cores */
77   current_flops = host->pimpl_cpu->constraint()->get_usage();
78
79   /* flops == pstate_speed * cores_being_currently_used */
80   computed_flops += (now - last_updated) * current_flops;
81
82   if (was_prev_idle) {
83     idle_time += (now - last_updated);
84   }
85
86   theor_max_flops += current_speed * host->getCoreCount() * (now - last_updated);
87   current_speed    = host->getSpeed();
88   last_updated     = now;
89   was_prev_idle    = (current_flops == 0);
90 }
91
92 /**
93  * WARNING: This function does not guarantee that you have the real load at any time
94  * imagine all actions on your CPU terminate at time t. Your load is then 0. Then
95  * you query the load (still 0) and then another action starts (still at time t!).
96  * This means that the load was never really 0 (because the time didn't advance) but
97  * it will still be reported as 0.
98  *
99  * So, use at your own risk.
100  */
101 double HostLoad::getCurrentLoad()
102 {
103   // We don't need to call update() here because it is called everytime an
104   // action terminates or starts
105   // FIXME: Can this happen at the same time? stop -> call to getCurrentLoad, load = 0 -> next action starts?
106   return current_flops / static_cast<double>(host->getSpeed() * host->getCoreCount());
107 }
108
109 /**
110  * Return idle time since last reset
111  */
112 double HostLoad::getIdleTime() {
113   return idle_time;
114 }
115
116 double HostLoad::getAverageLoad()
117 {
118   if (theor_max_flops == 0) { // Avoid division by 0
119     return 0;
120   }
121
122   return computed_flops / theor_max_flops;
123 }
124
125 double HostLoad::getComputedFlops()
126 {
127   return computed_flops;
128 }
129
130 /*
131  * Resets the counters
132  */
133 void HostLoad::reset()
134 {
135   last_updated    = surf_get_clock();
136   last_reset      = surf_get_clock();
137   idle_time       = 0;
138   computed_flops  = 0;
139   theor_max_flops = 0;
140   current_flops   = host->pimpl_cpu->constraint()->get_usage();
141   current_speed   = host->getSpeed();
142   was_prev_idle   = (current_flops == 0);
143 }
144 }
145 }
146
147 using simgrid::plugin::HostLoad;
148
149 /* **************************** events  callback *************************** */
150 /* This callback is fired either when the host changes its state (on/off) or its speed
151  * (because the user changed the pstate, or because of external trace events) */
152 static void onHostChange(simgrid::s4u::Host& host)
153 {
154   if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
155     return;
156
157   host.extension<HostLoad>()->update();
158 }
159
160 /* This callback is called when an action (computation, idle, ...) terminates */
161 static void onActionStateChange(simgrid::surf::CpuAction* action, simgrid::surf::Action::State /*previous*/)
162 {
163   for (simgrid::surf::Cpu* const& cpu : action->cpus()) {
164     simgrid::s4u::Host* host = cpu->getHost();
165
166     if (dynamic_cast<simgrid::s4u::VirtualMachine*>(host)) // Ignore virtual machines
167       return;
168
169     if (host != nullptr) {
170       host->extension<HostLoad>()->update();
171     }
172   }
173 }
174
175 /* **************************** Public interface *************************** */
176 extern "C" {
177
178 /** \ingroup plugin_load
179  * \brief Initializes the HostLoad plugin
180  * \details The HostLoad plugin provides an API to get the current load of each host.
181  */
182 void sg_host_load_plugin_init()
183 {
184   if (HostLoad::EXTENSION_ID.valid())
185     return;
186
187   HostLoad::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostLoad>();
188
189   /* When attaching a callback into a signal, you can use a lambda as follows, or a regular function as done below */
190
191   simgrid::s4u::Host::onCreation.connect([](simgrid::s4u::Host& host) {
192     if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
193       return;
194     host.extension_set(new HostLoad(&host));
195   });
196
197   simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
198   simgrid::s4u::Host::onStateChange.connect(&onHostChange);
199   simgrid::s4u::Host::onSpeedChange.connect(&onHostChange);
200 }
201
202 /** @brief Returns the current load of the host passed as argument
203  *
204  *  See also @ref plugin_load
205  */
206 double sg_host_get_current_load(sg_host_t host)
207 {
208   xbt_assert(HostLoad::EXTENSION_ID.valid(),
209              "The Load plugin is not active. Please call sg_host_load_plugin_init() during initialization.");
210
211   return host->extension<HostLoad>()->getCurrentLoad();
212 }
213
214 /** @brief Returns the current load of the host passed as argument
215  *
216  *  See also @ref plugin_load
217  */
218 double sg_host_get_avg_load(sg_host_t host)
219 {
220   xbt_assert(HostLoad::EXTENSION_ID.valid(),
221              "The Load plugin is not active. Please call sg_host_load_plugin_init() during initialization.");
222
223   return host->extension<HostLoad>()->getAverageLoad();
224 }
225
226 /** @brief Returns the time this host was idle since the last reset
227  *
228  *  See also @ref plugin_load
229  */
230 double sg_host_get_idle_time(sg_host_t host)
231 {
232   xbt_assert(HostLoad::EXTENSION_ID.valid(),
233              "The Load plugin is not active. Please call sg_host_load_plugin_init() during initialization.");
234
235   return host->extension<HostLoad>()->getIdleTime();
236 }
237
238 double sg_host_get_computed_flops(sg_host_t host)
239 {
240   xbt_assert(HostLoad::EXTENSION_ID.valid(),
241              "The Load plugin is not active. Please call sg_host_load_plugin_init() during initialization.");
242
243   return host->extension<HostLoad>()->getComputedFlops();
244 }
245
246 void sg_host_load_reset(sg_host_t host)
247 {
248   xbt_assert(HostLoad::EXTENSION_ID.valid(),
249              "The Load plugin is not active. Please call sg_host_load_plugin_init() during initialization.");
250
251   host->extension<HostLoad>()->reset();
252 }
253 }