X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/62dceedf62ca9df19fd3afee1458e21d9f211c5a..1aab041889e9a68f49b95561ddb756cb1710157b:/src/s4u/s4u_Engine.cpp

diff --git a/src/s4u/s4u_Engine.cpp b/src/s4u/s4u_Engine.cpp
index 78e4b4b00e..74d0563679 100644
--- a/src/s4u/s4u_Engine.cpp
+++ b/src/s4u/s4u_Engine.cpp
@@ -23,6 +23,7 @@
 #include "surf/surf.hpp" // routing_platf. FIXME:KILLME. SOON
 #include <simgrid/Exception.hpp>
 
+#include <algorithm>
 #include <string>
 
 XBT_LOG_NEW_CATEGORY(s4u, "Log channels of the S4U (Simgrid for you) interface");
@@ -41,7 +42,7 @@ Engine* Engine::instance_ = nullptr; /* That singleton is awful, but I don't see
 Engine::Engine(int* argc, char** argv) : pimpl(new kernel::EngineImpl())
 {
   xbt_assert(Engine::instance_ == nullptr, "It is currently forbidden to create more than one instance of s4u::Engine");
-  TRACE_global_init();
+  instr::init();
   SIMIX_global_init(argc, argv);
 
   Engine::instance_ = this;
@@ -57,7 +58,7 @@ Engine::~Engine()
 Engine* Engine::get_instance()
 {
   if (Engine::instance_ == nullptr) {
-    auto e = new Engine(0, nullptr);
+    auto e = new Engine(nullptr, nullptr);
     xbt_assert(Engine::instance_ == e);
   }
   return Engine::instance_;
@@ -81,7 +82,7 @@ double Engine::get_clock()
  * See also: :ref:`platform`.
  * \endrst
  */
-void Engine::load_platform(const std::string& platf)
+void Engine::load_platform(const std::string& platf) const
 {
   double start = xbt_os_time();
   parse_platform_file(platf);
@@ -92,32 +93,50 @@ void Engine::load_platform(const std::string& platf)
 
 void Engine::register_function(const std::string& name, int (*code)(int, char**)) // deprecated
 {
-  pimpl->register_function(name, code);
+  kernel::actor::ActorCodeFactory code_factory = [code](std::vector<std::string> args) {
+    return xbt::wrap_main(code, std::move(args));
+  };
+  register_function(name, std::move(code_factory));
 }
 void Engine::register_default(int (*code)(int, char**)) // deprecated
 {
-  pimpl->register_default(code);
+  register_default([code](std::vector<std::string> args) { return xbt::wrap_main(code, std::move(args)); });
 }
 
 /** Registers the main function of an actor that will be launched from the deployment file */
-void Engine::register_function(const std::string& name, void (*code)(int, char**))
+void Engine::register_function(const std::string& name, const std::function<void(int, char**)>& code)
 {
-  pimpl->register_function(name, code);
+  kernel::actor::ActorCodeFactory code_factory = [code](std::vector<std::string> args) {
+    return xbt::wrap_main(code, std::move(args));
+  };
+  register_function(name, std::move(code_factory));
 }
 
 /** Registers the main function of an actor that will be launched from the deployment file */
-void Engine::register_function(const std::string& name, void (*code)(std::vector<std::string>))
+void Engine::register_function(const std::string& name, const std::function<void(std::vector<std::string>)>& code)
 {
-  pimpl->register_function(name, code);
+  kernel::actor::ActorCodeFactory code_factory = [code](std::vector<std::string> args) {
+    return std::bind(std::move(code), std::move(args));
+  };
+  register_function(name, std::move(code_factory));
 }
 /** Registers a function as the default main function of actors
  *
  * It will be used as fallback when the function requested from the deployment file was not registered.
  * It is used for trace-based simulations (see examples/s4u/replay-comms and similar).
  */
-void Engine::register_default(void (*code)(int, char**))
+void Engine::register_default(const std::function<void(int, char**)>& code)
 {
-  pimpl->register_default(code);
+  register_default([code](std::vector<std::string> args) { return xbt::wrap_main(code, std::move(args)); });
+}
+void Engine::register_default(const kernel::actor::ActorCodeFactory& code)
+{
+  simgrid::kernel::actor::simcall([this, &code]() { pimpl->register_default(code); });
+}
+
+void Engine::register_function(const std::string& name, const kernel::actor::ActorCodeFactory& code)
+{
+  simgrid::kernel::actor::simcall([this, name, &code]() { pimpl->register_function(name, code); });
 }
 
 /** Load a deployment file and launch the actors that it contains
@@ -126,18 +145,18 @@ void Engine::register_default(void (*code)(int, char**))
  * See also: :ref:`deploy`.
  * \endrst
  */
-void Engine::load_deployment(const std::string& deploy)
+void Engine::load_deployment(const std::string& deploy) const
 {
   pimpl->load_deployment(deploy);
 }
 
 /** Returns the amount of hosts in the platform */
-size_t Engine::get_host_count()
+size_t Engine::get_host_count() const
 {
   return pimpl->hosts_.size();
 }
 
-std::vector<Host*> Engine::get_all_hosts()
+std::vector<Host*> Engine::get_all_hosts() const
 {
   std::vector<Host*> res;
   for (auto const& kv : pimpl->hosts_)
@@ -145,7 +164,7 @@ std::vector<Host*> Engine::get_all_hosts()
   return res;
 }
 
-std::vector<Host*> Engine::get_filtered_hosts(const std::function<bool(Host*)>& filter)
+std::vector<Host*> Engine::get_filtered_hosts(const std::function<bool(Host*)>& filter) const
 {
   std::vector<Host*> hosts;
   for (auto const& kv : pimpl->hosts_) {
@@ -170,15 +189,16 @@ void Engine::host_unregister(const std::string& name)
  *
  *  @throw std::invalid_argument if the searched host does not exist.
  */
-Host* Engine::host_by_name(const std::string& name)
+Host* Engine::host_by_name(const std::string& name) const
 {
-  if (pimpl->hosts_.find(name) == pimpl->hosts_.end())
+  auto host = pimpl->hosts_.find(name);
+  if (host == pimpl->hosts_.end())
     throw std::invalid_argument(std::string("Host not found: '") + name + std::string("'"));
-  return pimpl->hosts_.at(name);
+  return host->second;
 }
 
 /** @brief Find a host from its name (or nullptr if that host does not exist) */
-Host* Engine::host_by_name_or_null(const std::string& name)
+Host* Engine::host_by_name_or_null(const std::string& name) const
 {
   auto host = pimpl->hosts_.find(name);
   return host == pimpl->hosts_.end() ? nullptr : host->second;
@@ -188,16 +208,16 @@ Host* Engine::host_by_name_or_null(const std::string& name)
  *
  *  @throw std::invalid_argument if the searched link does not exist.
  */
-Link* Engine::link_by_name(const std::string& name)
+Link* Engine::link_by_name(const std::string& name) const
 {
-  if (pimpl->links_.find(name) == pimpl->links_.end())
+  auto link = pimpl->links_.find(name);
+  if (link == pimpl->links_.end())
     throw std::invalid_argument(std::string("Link not found: ") + name);
-
-  return pimpl->links_.at(name)->get_iface();
+  return link->second->get_iface();
 }
 
 /** @brief Find an link from its name (or nullptr if that link does not exist) */
-Link* Engine::link_by_name_or_null(const std::string& name)
+Link* Engine::link_by_name_or_null(const std::string& name) const
 {
   auto link = pimpl->links_.find(name);
   return link == pimpl->links_.end() ? nullptr : link->second->get_iface();
@@ -214,13 +234,13 @@ void Engine::link_unregister(const std::string& name)
 }
 
 /** @brief Returns the amount of storages in the platform */
-size_t Engine::get_storage_count()
+size_t Engine::get_storage_count() const
 {
   return pimpl->storages_.size();
 }
 
 /** @brief Returns the list of all storages found in the platform */
-std::vector<Storage*> Engine::get_all_storages()
+std::vector<Storage*> Engine::get_all_storages() const
 {
   std::vector<Storage*> res;
   for (auto const& kv : pimpl->storages_)
@@ -232,16 +252,16 @@ std::vector<Storage*> Engine::get_all_storages()
  *
  *  @throw std::invalid_argument if the searched storage does not exist.
  */
-Storage* Engine::storage_by_name(const std::string& name)
+Storage* Engine::storage_by_name(const std::string& name) const
 {
-  if (pimpl->storages_.find(name) == pimpl->storages_.end())
+  auto storage = pimpl->storages_.find(name);
+  if (storage == pimpl->storages_.end())
     throw std::invalid_argument(std::string("Storage not found: ") + name);
-
-  return pimpl->storages_.at(name)->get_iface();
+  return storage->second->get_iface();
 }
 
 /** @brief Find a storage from its name (or nullptr if that storage does not exist) */
-Storage* Engine::storage_by_name_or_null(const std::string& name)
+Storage* Engine::storage_by_name_or_null(const std::string& name) const
 {
   auto storage = pimpl->storages_.find(name);
   return storage == pimpl->storages_.end() ? nullptr : storage->second->get_iface();
@@ -258,13 +278,13 @@ void Engine::storage_unregister(const std::string& name)
 }
 
 /** @brief Returns the amount of links in the platform */
-size_t Engine::get_link_count()
+size_t Engine::get_link_count() const
 {
   return pimpl->links_.size();
 }
 
 /** @brief Returns the list of all links found in the platform */
-std::vector<Link*> Engine::get_all_links()
+std::vector<Link*> Engine::get_all_links() const
 {
   std::vector<Link*> res;
   for (auto const& kv : pimpl->links_)
@@ -272,7 +292,7 @@ std::vector<Link*> Engine::get_all_links()
   return res;
 }
 
-std::vector<Link*> Engine::get_filtered_links(const std::function<bool(Link*)>& filter)
+std::vector<Link*> Engine::get_filtered_links(const std::function<bool(Link*)>& filter) const
 {
   std::vector<Link*> filtered_list;
   for (auto const& kv : pimpl->links_) {
@@ -283,22 +303,21 @@ std::vector<Link*> Engine::get_filtered_links(const std::function<bool(Link*)>&
   return filtered_list;
 }
 
-size_t Engine::get_actor_count()
+size_t Engine::get_actor_count() const
 {
   return simix_global->process_list.size();
 }
 
-std::vector<ActorPtr> Engine::get_all_actors()
+std::vector<ActorPtr> Engine::get_all_actors() const
 {
   std::vector<ActorPtr> actor_list;
-  actor_list.push_back(simgrid::s4u::Actor::self());
   for (auto const& kv : simix_global->process_list) {
     actor_list.push_back(kv.second->iface());
   }
   return actor_list;
 }
 
-std::vector<ActorPtr> Engine::get_filtered_actors(const std::function<bool(ActorPtr)>& filter)
+std::vector<ActorPtr> Engine::get_filtered_actors(const std::function<bool(ActorPtr)>& filter) const
 {
   std::vector<ActorPtr> actor_list;
   for (auto const& kv : simix_global->process_list) {
@@ -308,7 +327,7 @@ std::vector<ActorPtr> Engine::get_filtered_actors(const std::function<bool(Actor
   return actor_list;
 }
 
-void Engine::run()
+void Engine::run() const
 {
   /* Clean IO before the run */
   fflush(stdout);
@@ -322,7 +341,7 @@ void Engine::run()
 }
 
 /** @brief Retrieve the root netzone, containing all others */
-s4u::NetZone* Engine::get_netzone_root()
+s4u::NetZone* Engine::get_netzone_root() const
 {
   return pimpl->netzone_root_->get_iface();
 }
@@ -348,19 +367,19 @@ static NetZone* netzone_by_name_recursive(NetZone* current, const std::string& n
 }
 
 /** @brief Retrieve the NetZone of the given name (or nullptr if not found) */
-NetZone* Engine::netzone_by_name_or_null(const std::string& name)
+NetZone* Engine::netzone_by_name_or_null(const std::string& name) const
 {
   return netzone_by_name_recursive(get_netzone_root(), name);
 }
 
 /** @brief Retrieve the netpoint of the given name (or nullptr if not found) */
-kernel::routing::NetPoint* Engine::netpoint_by_name_or_null(const std::string& name)
+kernel::routing::NetPoint* Engine::netpoint_by_name_or_null(const std::string& name) const
 {
   auto netp = pimpl->netpoints_.find(name);
   return netp == pimpl->netpoints_.end() ? nullptr : netp->second;
 }
 
-std::vector<kernel::routing::NetPoint*> Engine::get_all_netpoints()
+std::vector<kernel::routing::NetPoint*> Engine::get_all_netpoints() const
 {
   std::vector<kernel::routing::NetPoint*> res;
   for (auto const& kv : pimpl->netpoints_)
@@ -391,6 +410,23 @@ void Engine::set_config(const std::string& str)
 {
   config::set_parse(str);
 }
+void Engine::set_config(const std::string& name, int value)
+{
+  config::set_value(name.c_str(), value);
+}
+void Engine::set_config(const std::string& name, double value)
+{
+  config::set_value(name.c_str(), value);
+}
+void Engine::set_config(const std::string& name, bool value)
+{
+  config::set_value(name.c_str(), value);
+}
+void Engine::set_config(const std::string& name, const std::string& value)
+{
+  config::set_value(name.c_str(), value);
+}
+
 } // namespace s4u
 } // namespace simgrid
 
@@ -424,7 +460,8 @@ double simgrid_get_clock()
 {
   return simgrid::s4u::Engine::get_clock();
 }
-int simgrid_get_actor_count()
+
+int simgrid_get_actor_count() // XBT_ATTRIB_DEPRECATED_v330
 {
   return simgrid::s4u::Engine::get_instance()->get_actor_count();
 }