/* 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. */
#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");
XBT_DEBUG("PARSE TIME: %g", (end - start));
}
+void Engine::register_function(const std::string& name, int (*code)(int, char**)) // deprecated
+{
+ register_function(name, [code](std::vector<std::string> args) { return xbt::wrap_main(code, std::move(args)); });
+}
+void Engine::register_default(int (*code)(int, char**)) // deprecated
+{
+ 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, int (*code)(int, char**))
+void Engine::register_function(const std::string& name, void (*code)(int, char**))
{
- pimpl->register_function(name, code);
+ register_function(name, [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)(std::vector<std::string>))
{
- pimpl->register_function(name, code);
+ register_function(name,
+ [code](std::vector<std::string> 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(int (*code)(int, char**))
+void Engine::register_default(void (*code)(int, char**))
+{
+ 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)
{
- pimpl->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
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->get_impl();
}
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->get_impl();
}
{
std::vector<ActorPtr> 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;
std::vector<ActorPtr> Engine::get_filtered_actors(const std::function<bool(ActorPtr)>& filter)
{
std::vector<ActorPtr> 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());
}
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();
/** @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 */
{
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);
}
{
return simgrid::s4u::Engine::get_instance()->get_actor_count();
}
+
+void simgrid_get_all_hosts(size_t* host_count, sg_host_t** hosts)
+{
+ simgrid::s4u::Engine* e = simgrid::s4u::Engine::get_instance();
+ *host_count = e->get_host_count();
+ std::vector<simgrid::s4u::Host*> list = e->get_all_hosts();
+
+ auto last = std::remove_if(begin(list), end(list), [](const simgrid::s4u::Host* host) {
+ return not host || not host->get_netpoint() || not host->get_netpoint()->is_host();
+ });
+ std::sort(begin(list), last,
+ [](const simgrid::s4u::Host* a, const simgrid::s4u::Host* b) { return a->get_name() < b->get_name(); });
+
+ *hosts = static_cast<sg_host_t*>(xbt_malloc(sizeof(sg_host_t) * (*host_count)));
+ for (size_t i = 0; i < *host_count; i++)
+ (*hosts)[i] = list[i];
+}
