Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
another leak dies
[simgrid.git] / src / surf / sg_platf.cpp
index 6989e52..1f6a856 100644 (file)
@@ -48,6 +48,43 @@ simgrid::xbt::signal<void(void)> on_postparse;
 
 static int surf_parse_models_setup_already_called = 0;
 
+/* Turn something like "1-4,6,9-11" into the vector {1,2,3,4,6,9,10,11} */
+static std::vector<int> *explodesRadical(const char*radicals){
+  std::vector<int> *exploded = new std::vector<int>();
+  char *groups;
+  unsigned int iter;
+
+  //Make all hosts
+  xbt_dynar_t radical_elements = xbt_str_split(radicals, ",");
+  xbt_dynar_foreach(radical_elements, iter, groups) {
+
+    xbt_dynar_t radical_ends = xbt_str_split(groups, "-");
+    int start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
+    int end=0;
+
+    switch (xbt_dynar_length(radical_ends)) {
+    case 1:
+      end = start;
+      break;
+    case 2:
+      end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
+      break;
+    default:
+      surf_parse_error("Malformed radical: %s", groups);
+      break;
+    }
+
+    for (int i = start; i <= end; i++)
+      exploded->push_back( i );
+
+    xbt_dynar_free(&radical_ends);
+  }
+  xbt_dynar_free(&radical_elements);
+
+  return exploded;
+}
+
+
 /** The current AS in the parsing */
 static simgrid::surf::AsImpl *current_routing = NULL;
 static simgrid::surf::AsImpl* routing_get_current()
@@ -97,25 +134,32 @@ void sg_platf_new_host(sg_platf_host_cbarg_t host)
     xbt_assert(COORD_HOST_LEVEL, "To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
     /* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
     xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
+    xbt_assert(xbt_dynar_length(ctn_str)==3,"Coordinates of %s must have 3 dimensions", host->id);
+
     xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
     xbt_dynar_foreach(ctn_str,cursor, str) {
       double val = xbt_str_parse_double(str, "Invalid coordinate: %s");
       xbt_dynar_push(ctn,&val);
     }
-    xbt_dynar_shrink(ctn, 0);
     xbt_dynar_free(&ctn_str);
+    xbt_dynar_shrink(ctn, 0);
     h->extension_set(COORD_HOST_LEVEL, (void *) ctn);
-    XBT_DEBUG("Having set host coordinates for '%s'",host->id);
   }
 
-  simgrid::surf::Cpu *cpu = surf_cpu_model_pm->createCpu( h,
-      host->speed_per_pstate,
-      host->core_amount);
+  simgrid::surf::Cpu *cpu = surf_cpu_model_pm->createCpu( h, host->speed_per_pstate, host->core_amount);
   if (host->state_trace)
     cpu->setStateTrace(host->state_trace);
   if (host->speed_trace)
     cpu->setSpeedTrace(host->speed_trace);
-  surf_host_model->createHost(host->id, netcard, cpu, host->properties)->attach(h);
+  surf_host_model->createHost(host->id, netcard, cpu)->attach(h);
+
+  if (host->properties) {
+    xbt_dict_cursor_t cursor=NULL;
+    char *key,*data;
+    xbt_dict_foreach(host->properties,cursor,key,data)
+      h->setProperty(key,data);
+    xbt_dict_free(&host->properties);
+  }
 
   if (host->pstate != 0)
     cpu->setPState(host->pstate);
@@ -126,9 +170,7 @@ void sg_platf_new_host(sg_platf_host_cbarg_t host)
     sg_instr_new_host(host);
 }
 
-/**
- * \brief Add a "router" to the network element list
- */
+/** @brief Add a "router" to the network element list */
 void sg_platf_new_router(sg_platf_router_cbarg_t router)
 {
   simgrid::surf::AsImpl* current_routing = routing_get_current();
@@ -147,19 +189,18 @@ void sg_platf_new_router(sg_platf_router_cbarg_t router)
     unsigned int cursor;
     char*str;
 
-    if (!COORD_ASR_LEVEL)
-      xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
+    xbt_assert(COORD_ASR_LEVEL, "To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
     /* Pre-parse the host coordinates */
     xbt_dynar_t ctn_str = xbt_str_split_str(router->coord, " ");
+    xbt_assert(xbt_dynar_length(ctn_str)==3,"Coordinates of %s must have 3 dimensions", router->id);
     xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
     xbt_dynar_foreach(ctn_str,cursor, str) {
       double val = xbt_str_parse_double(str, "Invalid coordinate: %s");
       xbt_dynar_push(ctn,&val);
     }
-    xbt_dynar_shrink(ctn, 0);
     xbt_dynar_free(&ctn_str);
+    xbt_dynar_shrink(ctn, 0);
     xbt_lib_set(as_router_lib, router->id, COORD_ASR_LEVEL, (void *) ctn);
-    XBT_DEBUG("Having set router coordinates for '%s'",router->id);
   }
 
   if (TRACE_is_enabled() && TRACE_needs_platform())
@@ -197,28 +238,13 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster)
   using simgrid::surf::AsClusterTorus;
   using simgrid::surf::AsClusterFatTree;
 
-  char *host_id, *groups, *link_id = NULL;
-  xbt_dict_t patterns = NULL;
   int rankId=0;
 
-  s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
-  s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
-
-  unsigned int iter;
-
-  if ((cluster->availability_trace && strcmp(cluster->availability_trace, ""))
-      || (cluster->state_trace && strcmp(cluster->state_trace, ""))) {
-    patterns = xbt_dict_new_homogeneous(xbt_free_f);
-    xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), NULL);
-    xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), NULL);
-    xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL);
-  }
+  s_sg_platf_link_cbarg_t link;
 
-  /* Parse the topology attributes.
-   * Nothing to do in a vanilla cluster, but that's another story for torus and flat_trees */
-  s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER;
+  // What an inventive way of initializing the AS that I have as ancestor :-(
+  s_sg_platf_AS_cbarg_t AS;
   AS.id = cluster->id;
-
   switch (cluster->topology) {
   case SURF_CLUSTER_TORUS:
     AS.routing = A_surfxml_AS_routing_ClusterTorus;
@@ -230,208 +256,138 @@ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster)
     AS.routing = A_surfxml_AS_routing_Cluster;
     break;
   }
-
-  // What an inventive way of initializing the AS that I have as ancestor :-(
   sg_platf_new_AS_begin(&AS);
-  simgrid::surf::AsImpl *current_routing = routing_get_current();
-  static_cast<AsCluster*>(current_routing)->parse_specific_arguments(cluster);
+  simgrid::surf::AsCluster *current_as = static_cast<AsCluster*>(routing_get_current());
+  current_as->parse_specific_arguments(cluster);
 
   if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
-      ((AsCluster*)current_routing)->nb_links_per_node_++;
-      ((AsCluster*)current_routing)->has_loopback_=1;
+    current_as->nb_links_per_node_++;
+    current_as->has_loopback_ = 1;
   }
 
   if(cluster->limiter_link!=0){
-      ((AsCluster*)current_routing)->nb_links_per_node_++;
-      ((AsCluster*)current_routing)->has_limiter_=1;
+    current_as->nb_links_per_node_++;
+    current_as->has_limiter_ = 1;
   }
 
+  std::vector<int> *radicals = explodesRadical(cluster->radical);
+  for (int i : *radicals) {
+    char * host_id = bprintf("%s%d%s", cluster->prefix, i, cluster->suffix);
+    char * link_id = bprintf("%s_link_%d", cluster->id, i);
 
-  //Make all hosts
-  xbt_dynar_t radical_elements = xbt_str_split(cluster->radical, ",");
-  xbt_dynar_foreach(radical_elements, iter, groups) {
-
-    xbt_dynar_t radical_ends = xbt_str_split(groups, "-");
-    int start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
-    int end;
-
-    switch (xbt_dynar_length(radical_ends)) {
-    case 1:
-      end = start;
-      break;
-    case 2:
-      end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
-      break;
-    default:
-      surf_parse_error("Malformed radical");
-      break;
-    }
-    for (int i = start; i <= end; i++) {
-      host_id = bprintf("%s%d%s", cluster->prefix, i, cluster->suffix);
-      link_id = bprintf("%s_link_%d", cluster->id, i);
-
-      XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, cluster->speed);
-
-      memset(&host, 0, sizeof(host));
-      host.id = host_id;
-      if ((cluster->properties != NULL) && (!xbt_dict_is_empty(cluster->properties))) {
-        xbt_dict_cursor_t cursor=NULL;
-        char *key,*data;
-        host.properties = xbt_dict_new();
-
-        xbt_dict_foreach(cluster->properties,cursor,key,data) {
-          xbt_dict_set(host.properties, key, xbt_strdup(data),free);
-        }
-      }
-      if (cluster->availability_trace && strcmp(cluster->availability_trace, "")) {
-        xbt_dict_set(patterns, "radical", bprintf("%d", i), NULL);
-        char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns);
-        XBT_DEBUG("\tavailability_file=\"%s\"", avail_file);
-        if (avail_file && avail_file[0])
-          host.speed_trace = tmgr_trace_new_from_file(avail_file);
-        xbt_free(avail_file);
-      } else {
-        XBT_DEBUG("\tavailability_file=\"\"");
-      }
-
-      if (cluster->state_trace && strcmp(cluster->state_trace, "")) {
-        char *avail_file = xbt_str_varsubst(cluster->state_trace, patterns);
-        XBT_DEBUG("\tstate_file=\"%s\"", avail_file);
-        if (avail_file && avail_file[0])
-          host.state_trace = tmgr_trace_new_from_file(avail_file);
-        xbt_free(avail_file);
-      } else {
-        XBT_DEBUG("\tstate_file=\"\"");
-      }
+    XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, cluster->speed);
 
-      host.speed_per_pstate = xbt_dynar_new(sizeof(double), NULL);
-      xbt_dynar_push(host.speed_per_pstate,&cluster->speed);
-      host.pstate = 0;
-
-      //host.power_peak = cluster->power;
-      host.core_amount = cluster->core_amount;
-      host.coord = "";
-      sg_platf_new_host(&host);
-      xbt_dynar_free(&host.speed_per_pstate);
-      XBT_DEBUG("</host>");
-
-      XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,
-                cluster->bw, cluster->lat);
-
-
-      s_surf_parsing_link_up_down_t info_lim, info_loop;
-      // All links are saved in a matrix;
-      // every row describes a single node; every node
-      // may have multiple links.
-      // the first column may store a link from x to x if p_has_loopback is set
-      // the second column may store a limiter link if p_has_limiter is set
-      // other columns are to store one or more link for the node
-
-      //add a loopback link
-      if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
-        char *tmp_link = bprintf("%s_loopback", link_id);
-        XBT_DEBUG("<loopback\tid=\"%s\"\tbw=\"%f\"/>", tmp_link,
-                cluster->limiter_link);
-
-
-        memset(&link, 0, sizeof(link));
-        link.id        = tmp_link;
-        link.bandwidth = cluster->loopback_bw;
-        link.latency   = cluster->loopback_lat;
-        link.policy    = SURF_LINK_FATPIPE;
-        sg_platf_new_link(&link);
-        info_loop.link_up   = Link::byName(tmp_link);
-        info_loop.link_down = info_loop.link_up;
-        free(tmp_link);
-        auto as_cluster = static_cast<AsCluster*>(current_routing);
-        xbt_dynar_set(as_cluster->upDownLinks_, rankId*as_cluster->nb_links_per_node_, &info_loop);
+    s_sg_platf_host_cbarg_t host;
+    memset(&host, 0, sizeof(host));
+    host.id = host_id;
+    if ((cluster->properties != NULL) && (!xbt_dict_is_empty(cluster->properties))) {
+      xbt_dict_cursor_t cursor=NULL;
+      char *key,*data;
+      host.properties = xbt_dict_new();
+
+      xbt_dict_foreach(cluster->properties,cursor,key,data) {
+        xbt_dict_set(host.properties, key, xbt_strdup(data),free);
       }
+    }
 
-      //add a limiter link (shared link to account for maximal bandwidth of the node)
-      if(cluster->limiter_link!=0){
-        char *tmp_link = bprintf("%s_limiter", link_id);
-        XBT_DEBUG("<limiter\tid=\"%s\"\tbw=\"%f\"/>", tmp_link,
-                cluster->limiter_link);
-
-
-        memset(&link, 0, sizeof(link));
-        link.id = tmp_link;
-        link.bandwidth = cluster->limiter_link;
-        link.latency = 0;
-        link.policy = SURF_LINK_SHARED;
-        sg_platf_new_link(&link);
-        info_lim.link_up = Link::byName(tmp_link);
-        info_lim.link_down = info_lim.link_up;
-        free(tmp_link);
-        auto as_cluster = static_cast<AsCluster*>(current_routing);
-        xbt_dynar_set(as_cluster->upDownLinks_, rankId*(as_cluster)->nb_links_per_node_ + as_cluster->has_loopback_ , &info_lim);
-
-      }
+    host.speed_per_pstate = xbt_dynar_new(sizeof(double), NULL);
+    xbt_dynar_push(host.speed_per_pstate,&cluster->speed);
+    host.pstate = 0;
+    host.core_amount = cluster->core_amount;
+    host.coord = "";
+    sg_platf_new_host(&host);
+    xbt_dynar_free(&host.speed_per_pstate);
+    XBT_DEBUG("</host>");
+
+    XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id, cluster->bw, cluster->lat);
+
+    s_surf_parsing_link_up_down_t info_lim, info_loop;
+    // All links are saved in a matrix;
+    // every row describes a single node; every node
+    // may have multiple links.
+    // the first column may store a link from x to x if p_has_loopback is set
+    // the second column may store a limiter link if p_has_limiter is set
+    // other columns are to store one or more link for the node
+
+    //add a loopback link
+    if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
+      char *tmp_link = bprintf("%s_loopback", link_id);
+      XBT_DEBUG("<loopback\tid=\"%s\"\tbw=\"%f\"/>", tmp_link, cluster->limiter_link);
+
+      memset(&link, 0, sizeof(link));
+      link.id        = tmp_link;
+      link.bandwidth = cluster->loopback_bw;
+      link.latency   = cluster->loopback_lat;
+      link.policy    = SURF_LINK_FATPIPE;
+      sg_platf_new_link(&link);
+      info_loop.link_up = info_loop.link_down = Link::byName(tmp_link);
+      free(tmp_link);
+      auto as_cluster = static_cast<AsCluster*>(current_as);
+      xbt_dynar_set(as_cluster->privateLinks_, rankId*as_cluster->nb_links_per_node_, &info_loop);
+    }
 
+    //add a limiter link (shared link to account for maximal bandwidth of the node)
+    if(cluster->limiter_link!=0){
+      char *tmp_link = bprintf("%s_limiter", link_id);
+      XBT_DEBUG("<limiter\tid=\"%s\"\tbw=\"%f\"/>", tmp_link, cluster->limiter_link);
 
-      //call the cluster function that adds the others links
-      if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
-        ((AsClusterFatTree*) current_routing)->addProcessingNode(i);
-      }
-      else {
-      static_cast<AsCluster*>(current_routing)->create_links_for_node(cluster, i, rankId, rankId*
-          static_cast<AsCluster*>(current_routing)->nb_links_per_node_
-          + static_cast<AsCluster*>(current_routing)->has_loopback_
-          + static_cast<AsCluster*>(current_routing)->has_limiter_ );
-      }
-      xbt_free(link_id);
-      xbt_free(host_id);
-      rankId++;
+      memset(&link, 0, sizeof(link));
+      link.id = tmp_link;
+      link.bandwidth = cluster->limiter_link;
+      link.latency = 0;
+      link.policy = SURF_LINK_SHARED;
+      sg_platf_new_link(&link);
+      info_lim.link_up = info_lim.link_down = Link::byName(tmp_link);
+      free(tmp_link);
+      xbt_dynar_set(current_as->privateLinks_, rankId * current_as->nb_links_per_node_ + current_as->has_loopback_ , &info_lim);
     }
 
-    xbt_dynar_free(&radical_ends);
+    //call the cluster function that adds the others links
+    if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
+      ((AsClusterFatTree*) current_as)->addProcessingNode(i);
+    }
+    else {
+      current_as->create_links_for_node(cluster, i, rankId,
+          rankId*current_as->nb_links_per_node_ + current_as->has_loopback_ + current_as->has_limiter_ );
+    }
+    xbt_free(link_id);
+    xbt_free(host_id);
+    rankId++;
   }
-  xbt_dynar_free(&radical_elements);
+  delete radicals;
 
-  // For fat trees, the links must be created once all nodes have been added
-  if(cluster->topology == SURF_CLUSTER_FAT_TREE) {
-    static_cast<simgrid::surf::AsClusterFatTree*>(current_routing)->create_links();
-  }
   // Add a router. It is magically used thanks to the way in which surf_routing_cluster is written,
   // and it's very useful to connect clusters together
   XBT_DEBUG(" ");
   XBT_DEBUG("<router id=\"%s\"/>", cluster->router_id);
   char *newid = NULL;
-  s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER;
+  s_sg_platf_router_cbarg_t router;
   memset(&router, 0, sizeof(router));
   router.id = cluster->router_id;
-  router.coord = "";
   if (!router.id || !strcmp(router.id, ""))
-    router.id = newid =
-        bprintf("%s%s_router%s", cluster->prefix, cluster->id,
-                cluster->suffix);
+    router.id = newid = bprintf("%s%s_router%s", cluster->prefix, cluster->id, cluster->suffix);
   sg_platf_new_router(&router);
-  ((AsCluster*)current_routing)->router_ = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL);
+  current_as->router_ = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL);
   free(newid);
 
   //Make the backbone
   if ((cluster->bb_bw != 0) || (cluster->bb_lat != 0)) {
-    char *link_backbone = bprintf("%s_backbone", cluster->id);
-    XBT_DEBUG("<link\tid=\"%s\" bw=\"%f\" lat=\"%f\"/>", link_backbone,
-              cluster->bb_bw, cluster->bb_lat);
 
     memset(&link, 0, sizeof(link));
-    link.id        = link_backbone;
+    link.id        = bprintf("%s_backbone", cluster->id);
     link.bandwidth = cluster->bb_bw;
     link.latency   = cluster->bb_lat;
     link.policy    = cluster->bb_sharing_policy;
 
+    XBT_DEBUG("<link\tid=\"%s\" bw=\"%f\" lat=\"%f\"/>", link.id, cluster->bb_bw, cluster->bb_lat);
     sg_platf_new_link(&link);
 
-    routing_cluster_add_backbone(Link::byName(link_backbone));
-
-    free(link_backbone);
+    routing_cluster_add_backbone(Link::byName(link.id));
+    free((char*)link.id);
   }
 
   XBT_DEBUG("</AS>");
-  sg_platf_new_AS_end();
-  XBT_DEBUG(" ");
-  xbt_dict_free(&patterns); // no op if it were never set
+  sg_platf_new_AS_seal();
 
   simgrid::surf::on_cluster(cluster);
 }
@@ -447,71 +403,41 @@ void routing_cluster_add_backbone(simgrid::surf::Link* bb) {
 
 void sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet)
 {
-  int start, end, i;
-  char *groups , *host_id , *link_id = NULL;
-  unsigned int iter;
-  xbt_dynar_t radical_elements;
-  xbt_dynar_t radical_ends;
+  std::vector<int> *radicals = explodesRadical(cabinet->radical);
 
-  //Make all hosts
-  radical_elements = xbt_str_split(cabinet->radical, ",");
-  xbt_dynar_foreach(radical_elements, iter, groups) {
-
-    radical_ends = xbt_str_split(groups, "-");
-    start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
-
-    switch (xbt_dynar_length(radical_ends)) {
-    case 1:
-      end = start;
-      break;
-    case 2:
-      end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
-      break;
-    default:
-      surf_parse_error("Malformed radical");
-      break;
-    }
-    s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
+  for (int radical : *radicals) {
+    char *hostname = bprintf("%s%d%s", cabinet->prefix, radical, cabinet->suffix);
+    s_sg_platf_host_cbarg_t host;
     memset(&host, 0, sizeof(host));
-    host.pstate        = 0;
-    host.core_amount   = 1;
-
-    s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
+    host.pstate           = 0;
+    host.core_amount      = 1;
+    host.id               = hostname;
+    host.speed_per_pstate = xbt_dynar_new(sizeof(double), NULL);
+    xbt_dynar_push(host.speed_per_pstate,&cabinet->speed);
+    sg_platf_new_host(&host);
+    xbt_dynar_free(&host.speed_per_pstate);
+
+    s_sg_platf_link_cbarg_t link;
     memset(&link, 0, sizeof(link));
     link.policy    = SURF_LINK_FULLDUPLEX;
     link.latency   = cabinet->lat;
     link.bandwidth = cabinet->bw;
+    link.id        = bprintf("link_%s",hostname);
+    sg_platf_new_link(&link);
+    free((char*)link.id);
 
-    s_sg_platf_host_link_cbarg_t host_link = SG_PLATF_HOST_LINK_INITIALIZER;
+    s_sg_platf_host_link_cbarg_t host_link;
     memset(&host_link, 0, sizeof(host_link));
-
-    for (i = start; i <= end; i++) {
-      host_id                      = bprintf("%s%d%s",cabinet->prefix,i,cabinet->suffix);
-      link_id                      = bprintf("link_%s%d%s",cabinet->prefix,i,cabinet->suffix);
-      host.id                      = host_id;
-      link.id                      = link_id;
-      host.speed_per_pstate = xbt_dynar_new(sizeof(double), NULL);
-      xbt_dynar_push(host.speed_per_pstate,&cabinet->speed);
-      sg_platf_new_host(&host);
-      xbt_dynar_free(&host.speed_per_pstate);
-      sg_platf_new_link(&link);
-
-      char* link_up       = bprintf("%s_UP",link_id);
-      char* link_down     = bprintf("%s_DOWN",link_id);
-      host_link.id        = host_id;
-      host_link.link_up   = link_up;
-      host_link.link_down = link_down;
-      sg_platf_new_hostlink(&host_link);
-
-      free(host_id);
-      free(link_id);
-      free(link_up);
-      free(link_down);
-    }
-
-    xbt_dynar_free(&radical_ends);
+    host_link.id        = hostname;
+    host_link.link_up   = bprintf("link_%s_UP",hostname);
+    host_link.link_down = bprintf("link_%s_DOWN",hostname);
+    sg_platf_new_hostlink(&host_link);
+    free((char*)host_link.link_up);
+    free((char*)host_link.link_down);
+
+    free(hostname);
   }
-  xbt_dynar_free(&radical_elements);
+  delete(radicals);
 }
 
 void sg_platf_new_storage(sg_platf_storage_cbarg_t storage)
@@ -721,13 +647,13 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
   XBT_DEBUG(" ");
 
   XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", peer->id);
-  s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER;
-  AS.id                    = peer->id;
-  AS.routing               = A_surfxml_AS_routing_Cluster;
+  s_sg_platf_AS_cbarg_t AS;
+  AS.id      = peer->id;
+  AS.routing = A_surfxml_AS_routing_Cluster;
   sg_platf_new_AS_begin(&AS);
 
   XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\"/>", host_id, peer->speed);
-  s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
+  s_sg_platf_host_cbarg_t host;
   memset(&host, 0, sizeof(host));
   host.id = host_id;
 
@@ -740,7 +666,7 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
   sg_platf_new_host(&host);
   xbt_dynar_free(&host.speed_per_pstate);
 
-  s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
+  s_sg_platf_link_cbarg_t link;
   memset(&link, 0, sizeof(link));
   link.policy  = SURF_LINK_SHARED;
   link.latency = peer->lat;
@@ -758,7 +684,7 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
   sg_platf_new_link(&link);
 
   XBT_DEBUG("<host_link\tid=\"%s\"\tup=\"%s\"\tdown=\"%s\" />", host_id,link_up,link_down);
-  s_sg_platf_host_link_cbarg_t host_link = SG_PLATF_HOST_LINK_INITIALIZER;
+  s_sg_platf_host_link_cbarg_t host_link;
   memset(&host_link, 0, sizeof(host_link));
   host_link.id        = host_id;
   host_link.link_up   = link_up;
@@ -768,7 +694,7 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
   free(link_down);
 
   XBT_DEBUG("<router id=\"%s\"/>", router_id);
-  s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER;
+  s_sg_platf_router_cbarg_t router;
   memset(&router, 0, sizeof(router));
   router.id = router_id;
   router.coord = peer->coord;
@@ -776,7 +702,7 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
   static_cast<AsCluster*>(current_routing)->router_ = static_cast<NetCard*>(xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL));
 
   XBT_DEBUG("</AS>");
-  sg_platf_new_AS_end();
+  sg_platf_new_AS_seal();
   XBT_DEBUG(" ");
 
   free(router_id);
@@ -801,22 +727,22 @@ static void surf_config_models_setup()
   int storage_id = -1;
   char *storage_model_name = NULL;
 
-  host_model_name = xbt_cfg_get_string(_sg_cfg_set, "host/model");
-  vm_model_name = xbt_cfg_get_string(_sg_cfg_set, "vm/model");
-  network_model_name = xbt_cfg_get_string(_sg_cfg_set, "network/model");
-  cpu_model_name = xbt_cfg_get_string(_sg_cfg_set, "cpu/model");
-  storage_model_name = xbt_cfg_get_string(_sg_cfg_set, "storage/model");
+  host_model_name    = xbt_cfg_get_string("host/model");
+  vm_model_name      = xbt_cfg_get_string("vm/model");
+  network_model_name = xbt_cfg_get_string("network/model");
+  cpu_model_name     = xbt_cfg_get_string("cpu/model");
+  storage_model_name = xbt_cfg_get_string("storage/model");
 
   /* Check whether we use a net/cpu model differing from the default ones, in which case
    * we should switch to the "compound" host model to correctly dispatch stuff to
    * the right net/cpu models.
    */
 
-  if ((!xbt_cfg_is_default_value(_sg_cfg_set, "network/model") ||
-       !xbt_cfg_is_default_value(_sg_cfg_set, "cpu/model")) &&
-      xbt_cfg_is_default_value(_sg_cfg_set, "host/model")) {
+  if ((!xbt_cfg_is_default_value("network/model") ||
+       !xbt_cfg_is_default_value("cpu/model")) &&
+      xbt_cfg_is_default_value("host/model")) {
     host_model_name = "compound";
-    xbt_cfg_set_string(_sg_cfg_set, "host/model", host_model_name);
+    xbt_cfg_set_string("host/model", host_model_name);
   }
 
   XBT_DEBUG("host model: %s", host_model_name);
@@ -863,7 +789,7 @@ static void surf_config_models_setup()
  *
  * Add a new autonomous system to the platform. Any elements (such as host,
  * router or sub-AS) added after this call and before the corresponding call
- * to sg_platf_new_AS_close() will be added to this AS.
+ * to sg_platf_new_AS_seal() will be added to this AS.
  *
  * Once this function was called, the configuration concerning the used
  * models cannot be changed anymore.
@@ -871,7 +797,7 @@ static void surf_config_models_setup()
  * @param AS_id name of this autonomous system. Must be unique in the platform
  * @param wanted_routing_type one of Full, Floyd, Dijkstra or similar. Full list in the variable routing_models, in src/surf/surf_routing.c
  */
-void sg_platf_new_AS_begin(sg_platf_AS_cbarg_t AS)
+simgrid::s4u::As * sg_platf_new_AS_begin(sg_platf_AS_cbarg_t AS)
 {
   if (!surf_parse_models_setup_already_called) {
     /* Initialize the surf models. That must be done after we got all config, and before we need the models.
@@ -937,15 +863,17 @@ void sg_platf_new_AS_begin(sg_platf_AS_cbarg_t AS)
   simgrid::surf::asCreatedCallbacks(new_as);
   if (TRACE_is_enabled())
     sg_instr_AS_begin(AS);
+
+  return new_as;
 }
 
 /**
- * \brief Specify that the current description of AS is finished
+ * \brief Specify that the description of the current AS is finished
  *
- * Once you've declared all the content of your AS, you have to close
+ * Once you've declared all the content of your AS, you have to seal
  * it with this call. Your AS is not usable until you call this function.
  */
-void sg_platf_new_AS_end()
+void sg_platf_new_AS_seal()
 {
   xbt_assert(current_routing, "Cannot seal the current AS: none under construction");
   current_routing->seal();
@@ -972,10 +900,10 @@ void sg_platf_new_hostlink(sg_platf_host_link_cbarg_t hostlink)
 
   // If dynar is is greater than netcard id and if the host_link is already defined
   auto as_cluster = static_cast<simgrid::surf::AsCluster*>(current_routing);
-  if((int)xbt_dynar_length(as_cluster->upDownLinks_) > netcard->id() &&
-      xbt_dynar_get_as(as_cluster->upDownLinks_, netcard->id(), void*))
+  if((int)xbt_dynar_length(as_cluster->privateLinks_) > netcard->id() &&
+      xbt_dynar_get_as(as_cluster->privateLinks_, netcard->id(), void*))
   surf_parse_error("Host_link for '%s' is already defined!",hostlink->id);
 
   XBT_DEBUG("Push Host_link for host '%s' to position %d", netcard->name(), netcard->id());
-  xbt_dynar_set_as(as_cluster->upDownLinks_, netcard->id(), s_surf_parsing_link_up_down_t, link_up_down);
+  xbt_dynar_set_as(as_cluster->privateLinks_, netcard->id(), s_surf_parsing_link_up_down_t, link_up_down);
 }