X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/16f1630ae434e729cbe0b24fe2f19c8f67f774cd..d105f94a1512ae0528178dc4292b7d421ae3c039:/src/s4u/s4u_Engine.cpp diff --git a/src/s4u/s4u_Engine.cpp b/src/s4u/s4u_Engine.cpp index ba96fac442..7f74eefa41 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-2021. 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. */ @@ -13,20 +13,24 @@ #include "simgrid/s4u/Host.hpp" #include "simgrid/s4u/Mailbox.hpp" #include "simgrid/s4u/NetZone.hpp" -#include "simgrid/s4u/Storage.hpp" #include "simgrid/simix.h" #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/kernel/activity/CommImpl.hpp" +#include "src/kernel/actor/ActorImpl.hpp" +#include "src/mc/mc_replay.hpp" #include "src/surf/network_interface.hpp" #include "surf/surf.hpp" // routing_platf. FIXME:KILLME. SOON #include +#include #include XBT_LOG_NEW_CATEGORY(s4u, "Log channels of the S4U (Simgrid for you) interface"); XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_engine, s4u, "Logging specific to S4U (engine)"); +static simgrid::kernel::actor::ActorCode maestro_code; + namespace simgrid { namespace s4u { xbt::signal Engine::on_platform_creation; @@ -35,28 +39,46 @@ 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. */ +Engine* Engine::instance_ = nullptr; /* This singleton is awful, but I don't see no other solution right now. */ -Engine::Engine(int* argc, char** argv) : pimpl(new kernel::EngineImpl()) +void Engine::initialize(int* argc, char** argv) { xbt_assert(Engine::instance_ == nullptr, "It is currently forbidden to create more than one instance of s4u::Engine"); - TRACE_global_init(); - SIMIX_global_init(argc, argv); - Engine::instance_ = this; + instr::init(); + pimpl->initialize(argc, argv); + // Either create a new context with maestro or create + // a context object with the current context maestro): + kernel::actor::create_maestro(maestro_code); +} + +Engine::Engine(std::string name) : pimpl(new kernel::EngineImpl()) +{ + int argc = 1; + char* argv = &name[0]; + initialize(&argc, &argv); +} + +Engine::Engine(int* argc, char** argv) : pimpl(new kernel::EngineImpl()) +{ + initialize(argc, argv); } Engine::~Engine() { - delete pimpl; + pimpl->shutdown(); Engine::instance_ = nullptr; } /** @brief Retrieve the engine singleton */ Engine* Engine::get_instance() +{ + return get_instance(nullptr, nullptr); +} +Engine* Engine::get_instance(int* argc, char** argv) { if (Engine::instance_ == nullptr) { - auto e = new Engine(0, nullptr); + auto e = new Engine(argc, argv); xbt_assert(Engine::instance_ == e); } return Engine::instance_; @@ -65,70 +87,106 @@ Engine* Engine::get_instance() void Engine::shutdown() { delete Engine::instance_; - Engine::instance_ = nullptr; } double Engine::get_clock() { - return SIMIX_get_clock(); + if (MC_is_active() || MC_record_replay_is_active()) { + return MC_process_clock_get(kernel::actor::ActorImpl::self()); + } else { + return surf_get_clock(); + } +} + +void Engine::add_model(std::shared_ptr model, + const std::vector& dependencies) +{ + kernel::actor::simcall([this, &model, &dependencies] { pimpl->add_model(std::move(model), dependencies); }); +} + +const std::vector& Engine::get_all_models() const +{ + return pimpl->get_all_models(); } /** * Creates a new platform, including hosts, links, and the routing table. * - * \rst + * @beginrst * See also: :ref:`platform`. - * \endrst + * @endrst */ -void Engine::load_platform(const std::string& platf) +void Engine::load_platform(const std::string& platf) const { - 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()); - } + pimpl->load_platform(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**)) // XBT_ATTRIB_DEPRECATED_v330 +{ + kernel::actor::ActorCodeFactory code_factory = [code](std::vector args) { + return xbt::wrap_main(code, std::move(args)); + }; + register_function(name, code_factory); +} +void Engine::register_default(int (*code)(int, char**)) // XBT_ATTRIB_DEPRECATED_v330 +{ + 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, int (*code)(int, char**)) +void Engine::register_function(const std::string& name, const std::function& code) { - SIMIX_function_register(name, code); + kernel::actor::ActorCodeFactory code_factory = [code](std::vector args) { + return xbt::wrap_main(code, std::move(args)); + }; + register_function(name, 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)) +void Engine::register_function(const std::string& name, const std::function)>& code) { - SIMIX_function_register(name, code); + kernel::actor::ActorCodeFactory code_factory = [code{code}](std::vector args) mutable { + return std::bind(std::move(code), std::move(args)); + }; + register_function(name, 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). + * It is used for trace-based simulations (see examples/cpp/replay-comms and similar). */ -void Engine::register_default(int (*code)(int, char**)) +void Engine::register_default(const std::function& code) +{ + register_default([code](std::vector 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) { - 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 + * @beginrst * See also: :ref:`deploy`. - * \endrst + * @endrst */ -void Engine::load_deployment(const std::string& deploy) +void Engine::load_deployment(const std::string& deploy) const { - SIMIX_launch_application(deploy); + 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 Engine::get_all_hosts() +std::vector Engine::get_all_hosts() const { std::vector res; for (auto const& kv : pimpl->hosts_) @@ -136,7 +194,7 @@ std::vector Engine::get_all_hosts() return res; } -std::vector Engine::get_filtered_hosts(const std::function& filter) +std::vector Engine::get_filtered_hosts(const std::function& filter) const { std::vector hosts; for (auto const& kv : pimpl->hosts_) { @@ -161,15 +219,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; @@ -179,126 +238,112 @@ 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) -{ - if (pimpl->links_.find(name) == pimpl->links_.end()) - throw std::invalid_argument(std::string("Link not found: ") + name); - - return pimpl->links_.at(name); -} - -/** @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(const std::string& name) const { auto link = pimpl->links_.find(name); - return link == pimpl->links_.end() ? nullptr : link->second; -} - -void Engine::link_register(const std::string& name, Link* link) -{ - pimpl->links_[name] = link; -} - -void Engine::link_unregister(const std::string& name) -{ - pimpl->links_.erase(name); -} - -/** @brief Returns the amount of storages in the platform */ -size_t Engine::get_storage_count() -{ - return pimpl->storages_.size(); + if (link == pimpl->links_.end()) + throw std::invalid_argument(std::string("Link not found: ") + name); + return link->second->get_iface(); } -/** @brief Returns the list of all storages found in the platform */ -std::vector Engine::get_all_storages() +SplitDuplexLink* Engine::split_duplex_link_by_name(const std::string& name) const { - std::vector res; - for (auto const& kv : pimpl->storages_) - res.push_back(kv.second); - return res; + auto link = pimpl->split_duplex_links_.find(name); + if (link == pimpl->split_duplex_links_.end()) + throw std::invalid_argument(std::string("Link not found: ") + name); + return link->second->get_iface(); } -/** @brief Find a storage from its name. - * - * @throw std::invalid_argument if the searched storage does not exist. - */ -Storage* Engine::storage_by_name(const std::string& name) +/** @brief Find a link from its name (or nullptr if that link does not exist) */ +Link* Engine::link_by_name_or_null(const std::string& name) const { - if (pimpl->storages_.find(name) == pimpl->storages_.end()) - throw std::invalid_argument(std::string("Storage not found: ") + name); - - return pimpl->storages_.at(name); + auto link = pimpl->links_.find(name); + return link == pimpl->links_.end() ? nullptr : link->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) +/** @brief Find a mailox from its name or create one if it does not exist) */ +Mailbox* Engine::mailbox_by_name_or_create(const std::string& name) const { - auto storage = pimpl->storages_.find(name); - return storage == pimpl->storages_.end() ? nullptr : storage->second; + /* two actors may have pushed the same mbox_create simcall at the same time */ + kernel::activity::MailboxImpl* mbox = kernel::actor::simcall([&name, this] { + auto m = pimpl->mailboxes_.emplace(name, nullptr); + if (m.second) { + m.first->second = new kernel::activity::MailboxImpl(name); + XBT_DEBUG("Creating a mailbox at %p with name %s", m.first->second, name.c_str()); + } + return m.first->second; + }); + return mbox->get_iface(); } -void Engine::storage_register(const std::string& name, Storage* storage) +void Engine::link_register(const std::string& name, const Link* link) { - pimpl->storages_[name] = storage; + pimpl->links_[name] = link->get_impl(); } -void Engine::storage_unregister(const std::string& name) +void Engine::link_unregister(const std::string& name) { - pimpl->storages_.erase(name); + pimpl->links_.erase(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 Engine::get_all_links() +std::vector Engine::get_all_links() const { 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 Engine::get_filtered_links(const std::function& filter) const { 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; } -size_t Engine::get_actor_count() +size_t Engine::get_actor_count() const { - return simix_global->process_list.size(); + return pimpl->get_actor_count(); } -std::vector Engine::get_all_actors() +std::vector Engine::get_all_actors() const { std::vector actor_list; - actor_list.push_back(simgrid::s4u::Actor::self()); - for (auto& kv : simix_global->process_list) { - actor_list.push_back(kv.second->iface()); + for (auto const& kv : pimpl->get_actor_list()) { + actor_list.push_back(kv.second->get_iface()); } return actor_list; } -std::vector Engine::get_filtered_actors(const std::function& filter) +std::vector Engine::get_filtered_actors(const std::function& filter) const { std::vector actor_list; - for (auto& kv : simix_global->process_list) { - if (filter(kv.second->iface())) - actor_list.push_back(kv.second->iface()); + for (auto const& kv : pimpl->get_actor_list()) { + if (filter(kv.second->get_iface())) + actor_list.push_back(kv.second->get_iface()); } return actor_list; } -void Engine::run() +void Engine::run() const { + /* sealing resources before run: links */ + for (auto* link : get_all_links()) + link->seal(); + /* seal netzone root, recursively seal children netzones, hosts and disks */ + get_netzone_root()->seal(); + /* Clean IO before the run */ fflush(stdout); fflush(stderr); @@ -306,17 +351,19 @@ void Engine::run() if (MC_is_active()) { MC_run(); } else { - SIMIX_run(); + pimpl->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(); + if (pimpl->netzone_root_) + return pimpl->netzone_root_->get_iface(); + return nullptr; } /** @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(); @@ -337,19 +384,28 @@ 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 Engine::get_all_netpoints() +kernel::routing::NetPoint* Engine::netpoint_by_name(const std::string& name) const +{ + auto netp = netpoint_by_name_or_null(name); + if (netp == nullptr) { + throw std::invalid_argument(std::string("Netpoint not found: %s") + name); + } + return netp; +} + +std::vector Engine::get_all_netpoints() const { std::vector res; for (auto const& kv : pimpl->netpoints_) @@ -360,9 +416,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 */ @@ -382,13 +436,40 @@ 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); +} + +Engine* Engine::set_default_comm_data_copy_callback(void (*callback)(kernel::activity::CommImpl*, void*, size_t)) +{ + kernel::activity::CommImpl::set_copy_data_callback(callback); + return this; +} } // namespace s4u } // namespace simgrid +double SIMIX_get_clock() // XBT_ATTRIB_DEPRECATED_v332 +{ + return simgrid::s4u::Engine::get_clock(); +} + /* **************************** Public C interface *************************** */ void simgrid_init(int* argc, char** argv) { - simgrid::s4u::Engine e(argc, argv); + static simgrid::s4u::Engine e(argc, argv); } void simgrid_load_platform(const char* file) { @@ -403,11 +484,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); } @@ -415,7 +496,21 @@ 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(); } + +void simgrid_set_maestro(void (*code)(void*), void* data) +{ +#ifdef _WIN32 + XBT_WARN("simgrid_set_maestro is believed to not work on windows. Please help us investigating this issue if " + "you need that feature"); +#endif + maestro_code = std::bind(code, data); +} +void SIMIX_set_maestro(void (*code)(void*), void* data) // XBT_ATTRIB_DEPRECATED_v333 +{ + simgrid_set_maestro(code, data); +}