Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[sonar] Constify pointer and reference local variables in src/s4u/.
[simgrid.git] / src / s4u / s4u_Engine.cpp
1 /* s4u::Engine Simulation Engine and global functions. */
2
3 /* Copyright (c) 2006-2019. The SimGrid Team. All rights reserved.          */
4
5 /* This program is free software; you can redistribute it and/or modify it
6  * under the terms of the license (GNU LGPL) which comes with this package. */
7
8 #include "mc/mc.h"
9 #include "simgrid/kernel/routing/NetPoint.hpp"
10 #include "simgrid/kernel/routing/NetZoneImpl.hpp"
11 #include "simgrid/s4u/Disk.hpp"
12 #include "simgrid/s4u/Engine.hpp"
13 #include "simgrid/s4u/Host.hpp"
14 #include "simgrid/s4u/Mailbox.hpp"
15 #include "simgrid/s4u/NetZone.hpp"
16 #include "simgrid/s4u/Storage.hpp"
17 #include "simgrid/simix.h"
18 #include "src/instr/instr_private.hpp"
19 #include "src/kernel/EngineImpl.hpp"
20 #include "src/simix/smx_private.hpp" // For access to simix_global->process_list
21 #include "src/surf/StorageImpl.hpp"
22 #include "src/surf/network_interface.hpp"
23 #include "surf/surf.hpp" // routing_platf. FIXME:KILLME. SOON
24 #include <simgrid/Exception.hpp>
25
26 #include <string>
27
28 XBT_LOG_NEW_CATEGORY(s4u, "Log channels of the S4U (Simgrid for you) interface");
29 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_engine, s4u, "Logging specific to S4U (engine)");
30
31 namespace simgrid {
32 namespace s4u {
33 xbt::signal<void()> Engine::on_platform_creation;
34 xbt::signal<void()> Engine::on_platform_created;
35 xbt::signal<void()> Engine::on_simulation_end;
36 xbt::signal<void(double)> Engine::on_time_advance;
37 xbt::signal<void(void)> Engine::on_deadlock;
38
39 Engine* Engine::instance_ = nullptr; /* That singleton is awful, but I don't see no other solution right now. */
40
41 Engine::Engine(int* argc, char** argv) : pimpl(new kernel::EngineImpl())
42 {
43   xbt_assert(Engine::instance_ == nullptr, "It is currently forbidden to create more than one instance of s4u::Engine");
44   TRACE_global_init();
45   SIMIX_global_init(argc, argv);
46
47   Engine::instance_ = this;
48 }
49
50 Engine::~Engine()
51 {
52   delete pimpl;
53   Engine::instance_ = nullptr;
54 }
55
56 /** @brief Retrieve the engine singleton */
57 Engine* Engine::get_instance()
58 {
59   if (Engine::instance_ == nullptr) {
60     auto e = new Engine(0, nullptr);
61     xbt_assert(Engine::instance_ == e);
62   }
63   return Engine::instance_;
64 }
65
66 void Engine::shutdown()
67 {
68   delete Engine::instance_;
69   Engine::instance_ = nullptr;
70 }
71
72 double Engine::get_clock()
73 {
74   return SIMIX_get_clock();
75 }
76
77 /**
78  * Creates a new platform, including hosts, links, and the routing table.
79  *
80  * \rst
81  * See also: :ref:`platform`.
82  * \endrst
83  */
84 void Engine::load_platform(const std::string& platf)
85 {
86   double start = xbt_os_time();
87   parse_platform_file(platf);
88
89   double end = xbt_os_time();
90   XBT_DEBUG("PARSE TIME: %g", (end - start));
91 }
92
93 /** Registers the main function of an actor that will be launched from the deployment file */
94 void Engine::register_function(const std::string& name, int (*code)(int, char**))
95 {
96   pimpl->register_function(name, code);
97 }
98
99 /** Registers the main function of an actor that will be launched from the deployment file */
100 void Engine::register_function(const std::string& name, void (*code)(std::vector<std::string>))
101 {
102   pimpl->register_function(name, code);
103 }
104 /** Registers a function as the default main function of actors
105  *
106  * It will be used as fallback when the function requested from the deployment file was not registered.
107  * It is used for trace-based simulations (see examples/s4u/replay-comms and similar).
108  */
109 void Engine::register_default(int (*code)(int, char**))
110 {
111   pimpl->register_default(code);
112 }
113
114 /** Load a deployment file and launch the actors that it contains
115  *
116  * \rst
117  * See also: :ref:`deploy`.
118  * \endrst
119  */
120 void Engine::load_deployment(const std::string& deploy)
121 {
122   pimpl->load_deployment(deploy);
123 }
124
125 /** Returns the amount of hosts in the platform */
126 size_t Engine::get_host_count()
127 {
128   return pimpl->hosts_.size();
129 }
130
131 std::vector<Host*> Engine::get_all_hosts()
132 {
133   std::vector<Host*> res;
134   for (auto const& kv : pimpl->hosts_)
135     res.push_back(kv.second);
136   return res;
137 }
138
139 std::vector<Host*> Engine::get_filtered_hosts(const std::function<bool(Host*)>& filter)
140 {
141   std::vector<Host*> hosts;
142   for (auto const& kv : pimpl->hosts_) {
143     if (filter(kv.second))
144       hosts.push_back(kv.second);
145   }
146
147   return hosts;
148 }
149
150 void Engine::host_register(const std::string& name, Host* host)
151 {
152   pimpl->hosts_[name] = host;
153 }
154
155 void Engine::host_unregister(const std::string& name)
156 {
157   pimpl->hosts_.erase(name);
158 }
159
160 /** @brief Find a host from its name.
161  *
162  *  @throw std::invalid_argument if the searched host does not exist.
163  */
164 Host* Engine::host_by_name(const std::string& name)
165 {
166   if (pimpl->hosts_.find(name) == pimpl->hosts_.end())
167     throw std::invalid_argument(std::string("Host not found: '") + name + std::string("'"));
168   return pimpl->hosts_.at(name);
169 }
170
171 /** @brief Find a host from its name (or nullptr if that host does not exist) */
172 Host* Engine::host_by_name_or_null(const std::string& name)
173 {
174   auto host = pimpl->hosts_.find(name);
175   return host == pimpl->hosts_.end() ? nullptr : host->second;
176 }
177
178 /** @brief Find a link from its name.
179  *
180  *  @throw std::invalid_argument if the searched link does not exist.
181  */
182 Link* Engine::link_by_name(const std::string& name)
183 {
184   if (pimpl->links_.find(name) == pimpl->links_.end())
185     throw std::invalid_argument(std::string("Link not found: ") + name);
186
187   return pimpl->links_.at(name)->get_iface();
188 }
189
190 /** @brief Find an link from its name (or nullptr if that link does not exist) */
191 Link* Engine::link_by_name_or_null(const std::string& name)
192 {
193   auto link = pimpl->links_.find(name);
194   return link == pimpl->links_.end() ? nullptr : link->second->get_iface();
195 }
196
197 void Engine::link_register(const std::string& name, Link* link)
198 {
199   pimpl->links_[name] = link->get_impl();
200 }
201
202 void Engine::link_unregister(const std::string& name)
203 {
204   pimpl->links_.erase(name);
205 }
206
207 /** @brief Returns the amount of storages in the platform */
208 size_t Engine::get_storage_count()
209 {
210   return pimpl->storages_.size();
211 }
212
213 /** @brief Returns the list of all storages found in the platform */
214 std::vector<Storage*> Engine::get_all_storages()
215 {
216   std::vector<Storage*> res;
217   for (auto const& kv : pimpl->storages_)
218     res.push_back(kv.second->get_iface());
219   return res;
220 }
221
222 /** @brief Find a storage from its name.
223  *
224  *  @throw std::invalid_argument if the searched storage does not exist.
225  */
226 Storage* Engine::storage_by_name(const std::string& name)
227 {
228   if (pimpl->storages_.find(name) == pimpl->storages_.end())
229     throw std::invalid_argument(std::string("Storage not found: ") + name);
230
231   return pimpl->storages_.at(name)->get_iface();
232 }
233
234 /** @brief Find a storage from its name (or nullptr if that storage does not exist) */
235 Storage* Engine::storage_by_name_or_null(const std::string& name)
236 {
237   auto storage = pimpl->storages_.find(name);
238   return storage == pimpl->storages_.end() ? nullptr : storage->second->get_iface();
239 }
240
241 void Engine::storage_register(const std::string& name, Storage* storage)
242 {
243   pimpl->storages_[name] = storage->get_impl();
244 }
245
246 void Engine::storage_unregister(const std::string& name)
247 {
248   pimpl->storages_.erase(name);
249 }
250
251 /** @brief Returns the amount of links in the platform */
252 size_t Engine::get_link_count()
253 {
254   return pimpl->links_.size();
255 }
256
257 /** @brief Returns the list of all links found in the platform */
258 std::vector<Link*> Engine::get_all_links()
259 {
260   std::vector<Link*> res;
261   for (auto const& kv : pimpl->links_)
262     res.push_back(kv.second->get_iface());
263   return res;
264 }
265
266 std::vector<Link*> Engine::get_filtered_links(const std::function<bool(Link*)>& filter)
267 {
268   std::vector<Link*> filtered_list;
269   for (auto const& kv : pimpl->links_) {
270     Link* l = kv.second->get_iface();
271     if (filter(l))
272       filtered_list.push_back(l);
273   }
274   return filtered_list;
275 }
276
277 size_t Engine::get_actor_count()
278 {
279   return simix_global->process_list.size();
280 }
281
282 std::vector<ActorPtr> Engine::get_all_actors()
283 {
284   std::vector<ActorPtr> actor_list;
285   actor_list.push_back(simgrid::s4u::Actor::self());
286   for (auto const& kv : simix_global->process_list) {
287     actor_list.push_back(kv.second->iface());
288   }
289   return actor_list;
290 }
291
292 std::vector<ActorPtr> Engine::get_filtered_actors(const std::function<bool(ActorPtr)>& filter)
293 {
294   std::vector<ActorPtr> actor_list;
295   for (auto const& kv : simix_global->process_list) {
296     if (filter(kv.second->iface()))
297       actor_list.push_back(kv.second->iface());
298   }
299   return actor_list;
300 }
301
302 void Engine::run()
303 {
304   /* Clean IO before the run */
305   fflush(stdout);
306   fflush(stderr);
307
308   if (MC_is_active()) {
309     MC_run();
310   } else {
311     SIMIX_run();
312   }
313 }
314
315 /** @brief Retrieve the root netzone, containing all others */
316 s4u::NetZone* Engine::get_netzone_root()
317 {
318   return pimpl->netzone_root_->get_iface();
319 }
320 /** @brief Set the root netzone, containing all others. Once set, it cannot be changed. */
321 void Engine::set_netzone_root(s4u::NetZone* netzone)
322 {
323   xbt_assert(pimpl->netzone_root_ == nullptr, "The root NetZone cannot be changed once set");
324   pimpl->netzone_root_ = netzone->get_impl();
325 }
326
327 static NetZone* netzone_by_name_recursive(NetZone* current, const std::string& name)
328 {
329   if (current->get_name() == name)
330     return current;
331
332   for (auto const& elem : current->get_children()) {
333     NetZone* tmp = netzone_by_name_recursive(elem, name);
334     if (tmp != nullptr) {
335       return tmp;
336     }
337   }
338   return nullptr;
339 }
340
341 /** @brief Retrieve the NetZone of the given name (or nullptr if not found) */
342 NetZone* Engine::netzone_by_name_or_null(const std::string& name)
343 {
344   return netzone_by_name_recursive(get_netzone_root(), name);
345 }
346
347 /** @brief Retrieve the netpoint of the given name (or nullptr if not found) */
348 kernel::routing::NetPoint* Engine::netpoint_by_name_or_null(const std::string& name)
349 {
350   auto netp = pimpl->netpoints_.find(name);
351   return netp == pimpl->netpoints_.end() ? nullptr : netp->second;
352 }
353
354 std::vector<kernel::routing::NetPoint*> Engine::get_all_netpoints()
355 {
356   std::vector<kernel::routing::NetPoint*> res;
357   for (auto const& kv : pimpl->netpoints_)
358     res.push_back(kv.second);
359   return res;
360 }
361
362 /** @brief Register a new netpoint to the system */
363 void Engine::netpoint_register(kernel::routing::NetPoint* point)
364 {
365   // simgrid::kernel::actor::simcall([&]{ FIXME: this segfaults in set_thread
366   pimpl->netpoints_[point->get_name()] = point;
367   // });
368 }
369
370 /** @brief Unregister a given netpoint */
371 void Engine::netpoint_unregister(kernel::routing::NetPoint* point)
372 {
373   kernel::actor::simcall([this, point] {
374     pimpl->netpoints_.erase(point->get_name());
375     delete point;
376   });
377 }
378
379 bool Engine::is_initialized()
380 {
381   return Engine::instance_ != nullptr;
382 }
383 void Engine::set_config(const std::string& str)
384 {
385   config::set_parse(str);
386 }
387 } // namespace s4u
388 } // namespace simgrid
389
390 /* **************************** Public C interface *************************** */
391 void simgrid_init(int* argc, char** argv)
392 {
393   simgrid::s4u::Engine e(argc, argv);
394 }
395 void simgrid_load_platform(const char* file)
396 {
397   simgrid::s4u::Engine::get_instance()->load_platform(file);
398 }
399
400 void simgrid_load_deployment(const char* file)
401 {
402   simgrid::s4u::Engine::get_instance()->load_deployment(file);
403 }
404 void simgrid_run()
405 {
406   simgrid::s4u::Engine::get_instance()->run();
407 }
408 void simgrid_register_function(const char* name, int (*code)(int, char**))
409 {
410   simgrid::s4u::Engine::get_instance()->register_function(name, code);
411 }
412 void simgrid_register_default(int (*code)(int, char**))
413 {
414   simgrid::s4u::Engine::get_instance()->register_default(code);
415 }
416 double simgrid_get_clock()
417 {
418   return simgrid::s4u::Engine::get_clock();
419 }
420 int simgrid_get_actor_count()
421 {
422   return simgrid::s4u::Engine::get_instance()->get_actor_count();
423 }