X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1386d9951c6653d682ba02d5ed9155485acf4f64..c97656604936a7d3000ee3c98e0926b80f6f2150:/src/s4u/s4u_Engine.cpp diff --git a/src/s4u/s4u_Engine.cpp b/src/s4u/s4u_Engine.cpp index c92bdaa769..bf7f744460 100644 --- a/src/s4u/s4u_Engine.cpp +++ b/src/s4u/s4u_Engine.cpp @@ -1,6 +1,6 @@ /* s4u::Engine Simulation Engine and global functions. */ -/* Copyright (c) 2006-2019. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2006-2020. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -18,6 +18,7 @@ #include "src/instr/instr_private.hpp" #include "src/kernel/EngineImpl.hpp" #include "src/simix/smx_private.hpp" // For access to simix_global->process_list +#include "src/surf/StorageImpl.hpp" #include "src/surf/network_interface.hpp" #include "surf/surf.hpp" // routing_platf. FIXME:KILLME. SOON #include @@ -29,11 +30,11 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_engine, s4u, "Logging specific to S4U (engin namespace simgrid { namespace s4u { -xbt::signal on_platform_creation; -xbt::signal on_platform_created; -xbt::signal on_simulation_end; -xbt::signal on_time_advance; -xbt::signal on_deadlock; +xbt::signal Engine::on_platform_creation; +xbt::signal Engine::on_platform_created; +xbt::signal Engine::on_simulation_end; +xbt::signal Engine::on_time_advance; +xbt::signal Engine::on_deadlock; Engine* Engine::instance_ = nullptr; /* That singleton is awful, but I don't see no other solution right now. */ @@ -74,47 +75,73 @@ double Engine::get_clock() } /** - * @brief A platform loader. + * Creates a new platform, including hosts, links, and the routing table. * - * Creates a new platform, including hosts, links, and the routing_table. - * @param platf a filename of the XML description of a platform. This file follows this DTD : - * - * @include src/surf/xml/simgrid.dtd - * - * Here is a small example of such a platform - * - * @include examples/platforms/small_platform.xml + * \rst + * See also: :ref:`platform`. + * \endrst */ void Engine::load_platform(const std::string& platf) { double start = xbt_os_time(); - try { - parse_platform_file(platf); - } catch (const Exception& e) { - xbt_die("Error while loading %s: %s", platf.c_str(), e.what()); - } + parse_platform_file(platf); double end = xbt_os_time(); XBT_DEBUG("PARSE TIME: %g", (end - start)); } -void Engine::register_function(const std::string& name, int (*code)(int, char**)) +void Engine::register_function(const std::string& name, int (*code)(int, char**)) // deprecated +{ + register_function(name, [code](std::vector args) { return xbt::wrap_main(code, std::move(args)); }); +} +void Engine::register_default(int (*code)(int, char**)) // deprecated { - SIMIX_function_register(name, code); + register_default([code](std::vector 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**)) +{ + register_function(name, [code](std::vector 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)(std::vector)) { - SIMIX_function_register(name, code); + register_function(name, + [code](std::vector args) { return std::bind(std::move(code), std::move(args)); }); +} +/** 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**)) +{ + register_default([code](std::vector args) { return xbt::wrap_main(code, std::move(args)); }); } -void Engine::register_default(int (*code)(int, char**)) +void Engine::register_default(kernel::actor::ActorCodeFactory code) +{ + simgrid::kernel::actor::simcall([this, code]() { pimpl->register_default(code); }); +} + +void Engine::register_function(const std::string& name, kernel::actor::ActorCodeFactory code) { - SIMIX_function_register_default(code); + simgrid::kernel::actor::simcall([this, name, code]() { pimpl->register_function(name, code); }); } + +/** Load a deployment file and launch the actors that it contains + * + * \rst + * See also: :ref:`deploy`. + * \endrst + */ void Engine::load_deployment(const std::string& deploy) { - SIMIX_launch_application(deploy); + pimpl->load_deployment(deploy); } -/** @brief Returns the amount of hosts in the platform */ + +/** Returns the amount of hosts in the platform */ size_t Engine::get_host_count() { return pimpl->hosts_.size(); @@ -176,19 +203,19 @@ Link* Engine::link_by_name(const std::string& name) if (pimpl->links_.find(name) == pimpl->links_.end()) throw std::invalid_argument(std::string("Link not found: ") + name); - return pimpl->links_.at(name); + return pimpl->links_.at(name)->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) { auto link = pimpl->links_.find(name); - return link == pimpl->links_.end() ? nullptr : link->second; + return link == pimpl->links_.end() ? nullptr : link->second->get_iface(); } -void Engine::link_register(const std::string& name, Link* link) +void Engine::link_register(const std::string& name, const Link* link) { - pimpl->links_[name] = link; + pimpl->links_[name] = link->get_impl(); } void Engine::link_unregister(const std::string& name) @@ -207,29 +234,10 @@ std::vector Engine::get_all_storages() { std::vector res; for (auto const& kv : pimpl->storages_) - res.push_back(kv.second); + res.push_back(kv.second->get_iface()); return res; } -/** @brief Find a disk from its name. - * - * @throw std::invalid_argument if the searched disk does not exist. - */ -Disk* Engine::disk_by_name(const std::string& name) -{ - if (pimpl->disks_.find(name) == pimpl->disks_.end()) - throw std::invalid_argument(std::string("Disk not found: ") + name); - - return pimpl->disks_.at(name); -} - -/** @brief Find a disk from its name (or nullptr if that disk does not exist) */ -Disk* Engine::disk_by_name_or_null(const std::string& name) -{ - auto disk = pimpl->disks_.find(name); - return disk == pimpl->disks_.end() ? nullptr : disk->second; -} - /** @brief Find a storage from its name. * * @throw std::invalid_argument if the searched storage does not exist. @@ -239,19 +247,19 @@ Storage* Engine::storage_by_name(const std::string& name) if (pimpl->storages_.find(name) == pimpl->storages_.end()) throw std::invalid_argument(std::string("Storage not found: ") + name); - return pimpl->storages_.at(name); + return pimpl->storages_.at(name)->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) { auto storage = pimpl->storages_.find(name); - return storage == pimpl->storages_.end() ? nullptr : storage->second; + return storage == pimpl->storages_.end() ? nullptr : storage->second->get_iface(); } -void Engine::storage_register(const std::string& name, Storage* storage) +void Engine::storage_register(const std::string& name, const Storage* storage) { - pimpl->storages_[name] = storage; + pimpl->storages_[name] = storage->get_impl(); } void Engine::storage_unregister(const std::string& name) @@ -259,16 +267,6 @@ void Engine::storage_unregister(const std::string& name) pimpl->storages_.erase(name); } -void Engine::disk_register(const std::string& name, Disk* disk) -{ - pimpl->disks_[name] = disk; -} - -void Engine::disk_unregister(const std::string& name) -{ - pimpl->disks_.erase(name); -} - /** @brief Returns the amount of links in the platform */ size_t Engine::get_link_count() { @@ -280,16 +278,18 @@ std::vector Engine::get_all_links() { std::vector res; for (auto const& kv : pimpl->links_) - res.push_back(kv.second); + res.push_back(kv.second->get_iface()); return res; } std::vector Engine::get_filtered_links(const std::function& filter) { std::vector filtered_list; - for (auto const& kv : pimpl->links_) - if (filter(kv.second)) - filtered_list.push_back(kv.second); + for (auto const& kv : pimpl->links_) { + Link* l = kv.second->get_iface(); + if (filter(l)) + filtered_list.push_back(l); + } return filtered_list; } @@ -302,7 +302,7 @@ std::vector Engine::get_all_actors() { std::vector actor_list; actor_list.push_back(simgrid::s4u::Actor::self()); - for (auto& kv : simix_global->process_list) { + for (auto const& kv : simix_global->process_list) { actor_list.push_back(kv.second->iface()); } return actor_list; @@ -311,7 +311,7 @@ std::vector Engine::get_all_actors() std::vector Engine::get_filtered_actors(const std::function& filter) { std::vector actor_list; - for (auto& kv : simix_global->process_list) { + for (auto const& kv : simix_global->process_list) { if (filter(kv.second->iface())) actor_list.push_back(kv.second->iface()); } @@ -337,7 +337,7 @@ s4u::NetZone* Engine::get_netzone_root() return pimpl->netzone_root_->get_iface(); } /** @brief Set the root netzone, containing all others. Once set, it cannot be changed. */ -void Engine::set_netzone_root(s4u::NetZone* netzone) +void Engine::set_netzone_root(const s4u::NetZone* netzone) { xbt_assert(pimpl->netzone_root_ == nullptr, "The root NetZone cannot be changed once set"); pimpl->netzone_root_ = netzone->get_impl(); @@ -381,9 +381,7 @@ std::vector Engine::get_all_netpoints() /** @brief Register a new netpoint to the system */ void Engine::netpoint_register(kernel::routing::NetPoint* point) { - // simgrid::kernel::actor::simcall([&]{ FIXME: this segfaults in set_thread - pimpl->netpoints_[point->get_name()] = point; - // }); + simgrid::kernel::actor::simcall([this, point] { pimpl->netpoints_[point->get_name()] = point; }); } /** @brief Unregister a given netpoint */ @@ -424,11 +422,11 @@ void simgrid_run() { simgrid::s4u::Engine::get_instance()->run(); } -void simgrid_register_function(const char* name, int (*code)(int, char**)) +void simgrid_register_function(const char* name, void (*code)(int, char**)) { simgrid::s4u::Engine::get_instance()->register_function(name, code); } -void simgrid_register_default(int (*code)(int, char**)) +void simgrid_register_default(void (*code)(int, char**)) { simgrid::s4u::Engine::get_instance()->register_default(code); } @@ -436,3 +434,7 @@ double simgrid_get_clock() { return simgrid::s4u::Engine::get_clock(); } +int simgrid_get_actor_count() +{ + return simgrid::s4u::Engine::get_instance()->get_actor_count(); +}