Factorize code.

[simgrid.git] / src / surf / sg_platf.cpp

diff --git a/src/surf/sg_platf.cpp b/src/surf/sg_platf.cpp
index 474ef71..354ba1c 100644 (file)
--- a/src/surf/sg_platf.cpp
+++ b/src/surf/sg_platf.cpp
@@ -76,7 +76,7 @@ void sg_platf_new_host(sg_platf_host_cbarg_t args)
 {
   std::map<std::string, std::string> props;
   if (args->properties) {
-    for (auto elm : *args->properties)
+    for (auto const& elm : *args->properties)
       props.insert({elm.first, elm.second});
     delete args->properties;
   }
@@ -129,14 +129,13 @@ void sg_platf_new_link(LinkCreationArgs* link)
   } else {
     names.push_back(link->id);
   }
-  for (auto link_name : names) {
+  for (auto const& link_name : names) {
     simgrid::surf::LinkImpl* l =
-        surf_network_model->createLink(link_name.c_str(), link->bandwidth, link->latency, link->policy);
+        surf_network_model->createLink(link_name, link->bandwidth, link->latency, link->policy);
 
     if (link->properties) {
-      for (auto elm : *link->properties)
+      for (auto const& elm : *link->properties)
         l->setProperty(elm.first, elm.second);
-      delete link->properties;
     }
 
     if (link->latency_trace)
@@ -146,6 +145,7 @@ void sg_platf_new_link(LinkCreationArgs* link)
     if (link->state_trace)
       l->setStateTrace(link->state_trace);
   }
+  delete link->properties;
 }
 
 void sg_platf_new_cluster(ClusterCreationArgs* cluster)
@@ -180,15 +180,15 @@ void sg_platf_new_cluster(ClusterCreationArgs* cluster)
 
   if(cluster->loopback_bw > 0 || cluster->loopback_lat > 0){
     current_as->linkCountPerNode_++;
-    current_as->hasLoopback_ = 1;
+    current_as->hasLoopback_ = true;
   }
 
   if(cluster->limiter_link > 0){
     current_as->linkCountPerNode_++;
-    current_as->hasLimiter_ = 1;
+    current_as->hasLimiter_ = true;
   }
 
-  for (int i : *cluster->radicals) {
+  for (int const& i : *cluster->radicals) {
     std::string host_id = std::string(cluster->prefix) + std::to_string(i) + cluster->suffix;
     std::string link_id = std::string(cluster->id) + "_link_" + std::to_string(i);
 
@@ -200,7 +200,7 @@ void sg_platf_new_cluster(ClusterCreationArgs* cluster)
     if ((cluster->properties != nullptr) && (not cluster->properties->empty())) {
       host.properties = new std::map<std::string, std::string>;
 
-      for (auto elm : *cluster->properties)
+      for (auto const& elm : *cluster->properties)
         host.properties->insert({elm.first, elm.second});
     }
 
@@ -236,7 +236,7 @@ void sg_platf_new_cluster(ClusterCreationArgs* cluster)
       linkDown = simgrid::surf::LinkImpl::byName(tmp_link);
 
       auto as_cluster = static_cast<ClusterZone*>(current_as);
-      as_cluster->privateLinks_.insert({rankId * as_cluster->linkCountPerNode_, {linkUp, linkDown}});
+      as_cluster->privateLinks_.insert({as_cluster->nodePosition(rankId), {linkUp, linkDown}});
     }
 
     //add a limiter link (shared link to account for maximal bandwidth of the node)
@@ -254,16 +254,14 @@ void sg_platf_new_cluster(ClusterCreationArgs* cluster)
       sg_platf_new_link(&link);
       linkDown = simgrid::surf::LinkImpl::byName(tmp_link);
       linkUp   = linkDown;
-      current_as->privateLinks_.insert(
-          {rankId * current_as->linkCountPerNode_ + current_as->hasLoopback_, {linkUp, linkDown}});
+      current_as->privateLinks_.insert({current_as->nodePositionWithLoopback(rankId), {linkUp, linkDown}});
     }
 
     //call the cluster function that adds the others links
     if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
       static_cast<FatTreeZone*>(current_as)->addProcessingNode(i);
     } else {
-      current_as->create_links_for_node(cluster, i, rankId,
-          rankId*current_as->linkCountPerNode_ + current_as->hasLoopback_ + current_as->hasLimiter_ );
+      current_as->create_links_for_node(cluster, i, rankId, current_as->nodePositionWithLimiter(rankId));
     }
     rankId++;
   }
@@ -274,7 +272,7 @@ void sg_platf_new_cluster(ClusterCreationArgs* cluster)
   XBT_DEBUG("<router id=\"%s\"/>", cluster->router_id.c_str());
   if (cluster->router_id.empty()) {
     std::string newid   = std::string(cluster->prefix) + cluster->id + "_router" + cluster->suffix;
-    current_as->router_ = sg_platf_new_router(newid.c_str(), NULL);
+    current_as->router_ = sg_platf_new_router(newid, NULL);
   } else {
     current_as->router_ = sg_platf_new_router(cluster->router_id, NULL);
   }
@@ -315,7 +313,7 @@ void routing_cluster_add_backbone(simgrid::surf::LinkImpl* bb)
 
 void sg_platf_new_cabinet(CabinetCreationArgs* cabinet)
 {
-  for (int radical : *cabinet->radicals) {
+  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));
@@ -375,7 +373,7 @@ void sg_platf_new_storage(StorageCreationArgs* storage)
   auto s = surf_storage_model->createStorage(storage->id, stype->id, storage->content, storage->attach);
 
   if (storage->properties) {
-    for (auto elm : *storage->properties)
+    for (auto const& elm : *storage->properties)
       s->setProperty(elm.first, elm.second);
     delete storage->properties;
   }
@@ -425,7 +423,7 @@ void sg_platf_new_process(sg_platf_process_cbarg_t process)
     // 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 +
                       "' does not exist\nExisting hosts: '";
-    for (auto kv : simgrid::s4u::host_list) {
+    for (auto const& kv : simgrid::s4u::host_list) {
       simgrid::s4u::Host* host = kv.second;
       msg += host->getName();
       msg += "', '";
@@ -446,6 +444,7 @@ void sg_platf_new_process(sg_platf_process_cbarg_t process)
 
   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);
 
   smx_process_arg_t arg = nullptr;
 
@@ -455,7 +454,7 @@ void sg_platf_new_process(sg_platf_process_cbarg_t process)
   arg->data = nullptr;
   arg->host = host;
   arg->kill_time = kill_time;
-  arg->properties = process->properties;
+  arg->properties = properties;
 
   host->extension<simgrid::simix::Host>()->boot_processes.push_back(arg);
 
@@ -467,12 +466,12 @@ void sg_platf_new_process(sg_platf_process_cbarg_t process)
     arg->data = nullptr;
     arg->host = host;
     arg->kill_time = kill_time;
-    arg->properties = process->properties;
+    arg->properties = properties;
 
     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]() {
       smx_actor_t actor = simix_global->create_process_function(arg->name.c_str(), std::move(arg->code), arg->data,
-                                                                arg->host, arg->properties, nullptr);
+                                                                arg->host, arg->properties.get(), nullptr);
       if (arg->kill_time >= 0)
         simcall_process_set_kill_time(actor, arg->kill_time);
       if (auto_restart)
@@ -483,7 +482,7 @@ void sg_platf_new_process(sg_platf_process_cbarg_t process)
     XBT_DEBUG("Starting Process %s(%s) right now", arg->name.c_str(), host->getCname());
 
     smx_actor_t actor = simix_global->create_process_function(arg->name.c_str(), std::move(code), nullptr, host,
-                                                              arg->properties, nullptr);
+                                                              arg->properties.get(), nullptr);
 
     /* The actor creation will fail if the host is currently dead, but that's fine */
     if (actor != nullptr) {
@@ -493,7 +492,6 @@ void sg_platf_new_process(sg_platf_process_cbarg_t process)
         SIMIX_process_auto_restart_set(actor, auto_restart);
     }
   }
-  current_property_set = nullptr;
 }
 
 void sg_platf_new_peer(PeerCreationArgs* peer)