}
}
-// FIXME: The following duplicates the content of s4u::Host
-namespace simgrid {
-namespace s4u {
-extern std::map<std::string, simgrid::s4u::Host*> host_list;
-}
-}
-
static int surf_parse_models_setup_already_called = 0;
std::map<std::string, simgrid::surf::StorageType*> storage_types;
/** Module management function: frees all internal data structures */
void sg_platf_exit() {
- simgrid::surf::on_cluster.disconnect_all_slots();
- simgrid::s4u::onPlatformCreated.disconnect_all_slots();
+ simgrid::surf::on_cluster.disconnectSlots();
+ simgrid::s4u::onPlatformCreated.disconnectSlots();
/* make sure that we will reinit the models while loading the platf once reinited */
surf_parse_models_setup_already_called = 0;
ZoneCreationArgs zone;
zone.id = cluster->id;
switch (cluster->topology) {
- case SURF_CLUSTER_TORUS:
- zone.routing = A_surfxml_AS_routing_ClusterTorus;
- break;
- case SURF_CLUSTER_DRAGONFLY:
- zone.routing = A_surfxml_AS_routing_ClusterDragonfly;
- break;
- case SURF_CLUSTER_FAT_TREE:
- zone.routing = A_surfxml_AS_routing_ClusterFatTree;
- break;
- default:
- zone.routing = A_surfxml_AS_routing_Cluster;
- break;
+ case ClusterTopology::TORUS:
+ zone.routing = A_surfxml_AS_routing_ClusterTorus;
+ break;
+ case ClusterTopology::DRAGONFLY:
+ zone.routing = A_surfxml_AS_routing_ClusterDragonfly;
+ break;
+ case ClusterTopology::FAT_TREE:
+ zone.routing = A_surfxml_AS_routing_ClusterFatTree;
+ break;
+ default:
+ zone.routing = A_surfxml_AS_routing_Cluster;
+ break;
}
sg_platf_new_Zone_begin(&zone);
simgrid::kernel::routing::ClusterZone* current_as = static_cast<ClusterZone*>(routing_get_current());
XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id.c_str(), cluster->speeds.front());
s_sg_platf_host_cbarg_t host;
- memset(&host, 0, sizeof(host));
host.id = host_id.c_str();
if ((cluster->properties != nullptr) && (not cluster->properties->empty())) {
host.properties = new std::map<std::string, std::string>;
}
//call the cluster function that adds the others links
- if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
+ if (cluster->topology == ClusterTopology::FAT_TREE) {
static_cast<FatTreeZone*>(current_as)->addProcessingNode(i);
} else {
current_as->create_links_for_node(cluster, i, rankId, current_as->nodePositionWithLimiter(rankId));
for (int const& radical : *cabinet->radicals) {
std::string hostname = cabinet->prefix + std::to_string(radical) + cabinet->suffix;
s_sg_platf_host_cbarg_t host;
- memset(&host, 0, sizeof(host));
host.pstate = 0;
host.core_amount = 1;
host.id = hostname.c_str();
mount_list.insert({mount->name, simgrid::surf::StorageImpl::byName(mount->storageId.c_str())});
}
-void sg_platf_new_route(sg_platf_route_cbarg_t route)
+void sg_platf_new_route(RouteCreationArgs* route)
{
- routing_get_current()->addRoute(route);
+ routing_get_current()->addRoute(route->src, route->dst, route->gw_src, route->gw_dst, route->link_list,
+ route->symmetrical);
}
-void sg_platf_new_bypassRoute(sg_platf_route_cbarg_t bypassRoute)
+void sg_platf_new_bypassRoute(RouteCreationArgs* bypassRoute)
{
- routing_get_current()->addBypassRoute(bypassRoute);
+ routing_get_current()->addBypassRoute(bypassRoute->src, bypassRoute->dst, bypassRoute->gw_src, bypassRoute->gw_dst,
+ bypassRoute->link_list, bypassRoute->symmetrical);
}
-void sg_platf_new_process(sg_platf_process_cbarg_t process)
+void sg_platf_new_actor(ActorCreationArgs* actor)
{
- sg_host_t host = sg_host_by_name(process->host);
+ sg_host_t host = sg_host_by_name(actor->host);
if (not host) {
// The requested host does not exist. Do a nice message to the user
- std::string msg = std::string("Cannot create process '") + process->function + "': host '" + process->host +
+ std::string msg = std::string("Cannot create actor '") + actor->function + "': host '" + actor->host +
"' does not exist\nExisting hosts: '";
- for (auto const& kv : simgrid::s4u::host_list) {
- simgrid::s4u::Host* host = kv.second;
+
+ std::vector<simgrid::s4u::Host*> list;
+ simgrid::s4u::Engine::getInstance()->getHostList(&list);
+
+ for (auto const& host : list) {
msg += host->getName();
msg += "', '";
if (msg.length() > 1024) {
}
xbt_die("%s", msg.c_str());
}
- simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(process->function);
- xbt_assert(factory, "Function '%s' unknown", process->function);
-
- double start_time = process->start_time;
- double kill_time = process->kill_time;
- int auto_restart = process->on_failure == SURF_ACTOR_ON_FAILURE_DIE ? 0 : 1;
+ simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(actor->function);
+ xbt_assert(factory, "Function '%s' unknown", actor->function);
- std::vector<std::string> args(process->argv, process->argv + process->argc);
- std::function<void()> code = factory(std::move(args));
- std::shared_ptr<std::map<std::string, std::string>> properties(process->properties);
+ double start_time = actor->start_time;
+ double kill_time = actor->kill_time;
+ bool auto_restart = actor->on_failure != ActorOnFailure::DIE;
- smx_process_arg_t arg = nullptr;
+ std::string actor_name = actor->args[0];
+ std::function<void()> code = factory(std::move(actor->args));
+ std::shared_ptr<std::map<std::string, std::string>> properties(actor->properties);
- arg = new simgrid::simix::ProcessArg();
- arg->name = std::string(process->argv[0]);
- arg->code = code;
- arg->data = nullptr;
- arg->host = host;
- arg->kill_time = kill_time;
- arg->properties = properties;
+ simgrid::simix::ProcessArg* arg =
+ new simgrid::simix::ProcessArg(actor_name, code, nullptr, host, kill_time, properties, auto_restart);
host->extension<simgrid::simix::Host>()->boot_processes.push_back(arg);
if (start_time > SIMIX_get_clock()) {
- arg = new simgrid::simix::ProcessArg();
- arg->name = std::string(process->argv[0]);
- arg->code = std::move(code);
- arg->data = nullptr;
- arg->host = host;
- arg->kill_time = kill_time;
- arg->properties = properties;
+ arg = new simgrid::simix::ProcessArg(actor_name, code, nullptr, host, kill_time, properties, auto_restart);
XBT_DEBUG("Process %s@%s will be started at time %f", arg->name.c_str(), arg->host->getCname(), start_time);
SIMIX_timer_set(start_time, [arg, auto_restart]() {
/* Pick the right models for CPU, net and host, and call their model_init_preparse */
static void surf_config_models_setup()
{
- const char* host_model_name = xbt_cfg_get_string("host/model");
- const char* network_model_name = xbt_cfg_get_string("network/model");
- const char* cpu_model_name = xbt_cfg_get_string("cpu/model");
- const char* storage_model_name = xbt_cfg_get_string("storage/model");
+ std::string host_model_name = xbt_cfg_get_string("host/model");
+ std::string network_model_name = xbt_cfg_get_string("network/model");
+ std::string cpu_model_name = xbt_cfg_get_string("cpu/model");
+ std::string storage_model_name = xbt_cfg_get_string("storage/model");
/* The compound host model is needed when using non-default net/cpu models */
if ((not xbt_cfg_is_default_value("network/model") || not xbt_cfg_is_default_value("cpu/model")) &&
xbt_cfg_is_default_value("host/model")) {
host_model_name = "compound";
- xbt_cfg_set_string("host/model", host_model_name);
+ xbt_cfg_set_string("host/model", host_model_name.c_str());
}
- XBT_DEBUG("host model: %s", host_model_name);
- if (not strcmp(host_model_name, "compound")) {
- xbt_assert(cpu_model_name, "Set a cpu model to use with the 'compound' host model");
- xbt_assert(network_model_name, "Set a network model to use with the 'compound' host model");
+ XBT_DEBUG("host model: %s", host_model_name.c_str());
+ if (host_model_name == "compound") {
+ xbt_assert(not cpu_model_name.empty(), "Set a cpu model to use with the 'compound' host model");
+ xbt_assert(not network_model_name.empty(), "Set a network model to use with the 'compound' host model");
int cpu_id = find_model_description(surf_cpu_model_description, cpu_model_name);
surf_cpu_model_description[cpu_id].model_init_preparse();
