use std::pair instead of bprintf(%s#%s)ing the keys

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

diff --git a/src/surf/surf_routing.cpp b/src/surf/surf_routing.cpp
index 073de70..eef8fe4 100644 (file)
--- a/src/surf/surf_routing.cpp
+++ b/src/surf/surf_routing.cpp
@@ -34,13 +34,19 @@ namespace surf {
   {}
   As::~As()
   {
-    xbt_dict_free(&sons_);
+    xbt_dict_cursor_t cursor = NULL;
+    char *key;
+    AS_t elem;
+    xbt_dict_foreach(children_, cursor, key, elem) {
+      delete (As*)elem;
+    }
+
+
+    xbt_dict_free(&children_);
     xbt_dynar_free(&vertices_);
     xbt_dynar_free(&upDownLinks);
-    if (nullptr != bypassRoutes_)
-      for (auto &kv : *bypassRoutes_)
-        delete kv.second;
-    delete bypassRoutes_;
+    for (auto &kv : bypassRoutes_)
+      delete kv.second;
     xbt_free(name_);
     delete netcard_;
   }
@@ -49,12 +55,64 @@ namespace surf {
     sealed_ = true;
   }
 
+  /** @brief Get the common ancestor and its first childs in each line leading to src and dst */
+  static void find_common_ancestors(NetCard *src, NetCard *dst,
+      /* OUT */ As **common_ancestor, As **src_ancestor, As **dst_ancestor)
+  {
+  #define ROUTING_HIERARCHY_MAXDEPTH 32     /* increase if it is not enough */
+    simgrid::surf::As *path_src[ROUTING_HIERARCHY_MAXDEPTH];
+    simgrid::surf::As *path_dst[ROUTING_HIERARCHY_MAXDEPTH];
+    int index_src = 0;
+    int index_dst = 0;
+    simgrid::surf::As *current_src;
+    simgrid::surf::As *current_dst;
+    simgrid::surf::As *father;
+
+    /* (1) find the path to root of src and dst*/
+    simgrid::surf::As *src_as = src->containingAS();
+    simgrid::surf::As *dst_as = dst->containingAS();
+
+    xbt_assert(src_as, "Host %s must be in an AS", src->name());
+    xbt_assert(dst_as, "Host %s must be in an AS", dst->name());
+
+    /* (2) find the path to the root routing component */
+    for (simgrid::surf::As *current = src_as; current != NULL; current = current->father_) {
+      xbt_assert(index_src < ROUTING_HIERARCHY_MAXDEPTH, "ROUTING_HIERARCHY_MAXDEPTH should be increased for element %s", src->name());
+      path_src[index_src++] = current;
+    }
+    for (simgrid::surf::As *current = dst_as; current != NULL; current = current->father_) {
+      xbt_assert(index_dst < ROUTING_HIERARCHY_MAXDEPTH,"ROUTING_HIERARCHY_MAXDEPTH should be increased for path_dst");
+      path_dst[index_dst++] = current;
+    }
+
+    /* (3) find the common father.
+     * Before that, index_src and index_dst may be different, they both point to NULL in path_src/path_dst
+     * So we move them down simultaneously as long as they point to the same content.
+     */
+    do {
+      current_src = path_src[--index_src];
+      current_dst = path_dst[--index_dst];
+    } while (index_src > 0 && index_dst > 0 && current_src == current_dst);
+
+    /* (4) if we did not find a difference (index_src or index_dst went to 0), both elements are in the same AS */
+    if (current_src == current_dst)
+      father = current_src;
+    else // we found a difference
+      father = path_src[index_src + 1];
+
+    /* (5) result generation */
+    *common_ancestor = father;    /* the common father of src and dst */
+    *src_ancestor = current_src;  /* the first different father of src */
+    *dst_ancestor = current_dst;  /* the first different father of dst */
+  #undef ROUTING_HIERARCHY_MAXDEPTH
+  }
+
+
   xbt_dynar_t As::getOneLinkRoutes() {
     return NULL;
   }
 
   int As::addComponent(NetCard *elm) {
-    XBT_DEBUG("Load component \"%s\"", elm->name());
     xbt_dynar_push_as(vertices_, NetCard*, elm);
     return xbt_dynar_length(vertices_)-1;
   }
@@ -63,84 +121,64 @@ namespace surf {
     xbt_die("AS %s does not accept new routes (wrong class).",name_);
   }
 
+  /* PRECONDITION: this is the common ancestor of src and dst */
   std::vector<Link*> *As::getBypassRoute(NetCard *src, NetCard *dst)
   {
     // If never set a bypass route return NULL without any further computations
     XBT_DEBUG("generic_get_bypassroute from %s to %s", src->name(), dst->name());
-    if (bypassRoutes_ == nullptr)
+    if (bypassRoutes_.empty())
       return nullptr;
 
     std::vector<Link*> *bypassedRoute = nullptr;
 
     if(dst->containingAS() == this && src->containingAS() == this ){
-      char *route_name = bprintf("%s#%s", src->name(), dst->name());
-      if (bypassRoutes_->find(route_name) != bypassRoutes_->end()) {
-        bypassedRoute = bypassRoutes_->at(route_name);
+      if (bypassRoutes_.find({src->name(),dst->name()}) != bypassRoutes_.end()) {
+        bypassedRoute = bypassRoutes_.at({src->name(),dst->name()});
         XBT_DEBUG("Found a bypass route with %zu links",bypassedRoute->size());
       }
-      free(route_name);
       return bypassedRoute;
     }
 
-    int index_src, index_dst;
-    As **current_src = NULL;
-    As **current_dst = NULL;
-
-    As *src_as = src->containingAS();
-    As *dst_as = dst->containingAS();
-
     /* (2) find the path to the root routing component */
-    xbt_dynar_t path_src = xbt_dynar_new(sizeof(As*), NULL);
-    As *current = src_as;
+    std::vector<As*> path_src;
+    As *current = src->containingAS();
     while (current != NULL) {
-      xbt_dynar_push(path_src, &current);
+      path_src.push_back(current);
       current = current->father_;
     }
-    xbt_dynar_t path_dst = xbt_dynar_new(sizeof(As*), NULL);
-    current = dst_as;
+
+    std::vector<As*> path_dst;
+    current = dst->containingAS();
     while (current != NULL) {
-      xbt_dynar_push(path_dst, &current);
+      path_dst.push_back(current);
       current = current->father_;
     }
 
     /* (3) find the common father */
-    index_src = path_src->used - 1;
-    index_dst = path_dst->used - 1;
-    current_src = (As **) xbt_dynar_get_ptr(path_src, index_src);
-    current_dst = (As **) xbt_dynar_get_ptr(path_dst, index_dst);
-    while (index_src >= 0 && index_dst >= 0 && *current_src == *current_dst) {
-      xbt_dynar_pop_ptr(path_src);
-      xbt_dynar_pop_ptr(path_dst);
-      index_src--;
-      index_dst--;
-      current_src = (As **) xbt_dynar_get_ptr(path_src, index_src);
-      current_dst = (As **) xbt_dynar_get_ptr(path_dst, index_dst);
+    while (path_src.size() > 1 && path_dst.size() >1
+        && path_src.at(path_src.size() -1) == path_dst.at(path_dst.size() -1)) {
+      path_src.pop_back();
+      path_dst.pop_back();
     }
 
-    int max_index_src = path_src->used - 1;
-    int max_index_dst = path_dst->used - 1;
+    int max_index_src = path_src.size() - 1;
+    int max_index_dst = path_dst.size() - 1;
 
     int max_index = std::max(max_index_src, max_index_dst);
 
     for (int max = 0; max <= max_index; max++) {
       for (int i = 0; i < max; i++) {
         if (i <= max_index_src && max <= max_index_dst) {
-          char *route_name = bprintf("%s#%s",
-              (*(As **) (xbt_dynar_get_ptr(path_src, i)))->name_,
-              (*(As **) (xbt_dynar_get_ptr(path_dst, max)))->name_);
-          if (bypassRoutes_->find(route_name) != bypassRoutes_->end())
-            bypassedRoute = bypassRoutes_->at(route_name);
-          xbt_free(route_name);
+          const std::pair<std::string, std::string> key = {path_src.at(i)->name_, path_dst.at(max)->name_};
+          if (bypassRoutes_.find(key) != bypassRoutes_.end())
+            bypassedRoute = bypassRoutes_.at(key);
         }
         if (bypassedRoute)
           break;
         if (max <= max_index_src && i <= max_index_dst) {
-          char *route_name = bprintf("%s#%s",
-              (*(As **) (xbt_dynar_get_ptr(path_src, max)))->name_,
-              (*(As **) (xbt_dynar_get_ptr(path_dst, i)))->name_);
-          if (bypassRoutes_->find(route_name) != bypassRoutes_->end())
-            bypassedRoute = bypassRoutes_->at(route_name);
-          xbt_free(route_name);
+          const std::pair<std::string, std::string> key = {path_src.at(max)->name_, path_dst.at(i)->name_};
+          if (bypassRoutes_.find(key) != bypassRoutes_.end())
+            bypassedRoute = bypassRoutes_.at(key);
         }
         if (bypassedRoute)
           break;
@@ -150,21 +188,14 @@ namespace surf {
         break;
 
       if (max <= max_index_src && max <= max_index_dst) {
-        char *route_name = bprintf("%s#%s",
-            (*(As **) (xbt_dynar_get_ptr(path_src, max)))->name_,
-            (*(As **) (xbt_dynar_get_ptr(path_dst, max)))->name_);
-
-        if (bypassRoutes_->find(route_name) != bypassRoutes_->end())
-          bypassedRoute = bypassRoutes_->at(route_name);
-        xbt_free(route_name);
+        const std::pair<std::string, std::string> key = {path_src.at(max)->name_, path_dst.at(max)->name_};
+        if (bypassRoutes_.find(key) != bypassRoutes_.end())
+          bypassedRoute = bypassRoutes_.at(key);
       }
       if (bypassedRoute)
         break;
     }
 
-    xbt_dynar_free(&path_src);
-    xbt_dynar_free(&path_dst);
-
     return bypassedRoute;
   }
 
@@ -172,41 +203,27 @@ namespace surf {
     const char *src = e_route->src;
     const char *dst = e_route->dst;
 
-    if(bypassRoutes_ == nullptr)
-      bypassRoutes_ = new std::map<std::string, std::vector<Link*>*>();
-
-    char *route_name = bprintf("%s#%s", src, dst);
-
     /* Argument validity checks */
     if (e_route->gw_dst) {
       XBT_DEBUG("Load bypassASroute from %s@%s to %s@%s",
           src, e_route->gw_src->name(), dst, e_route->gw_dst->name());
-      xbt_assert(!xbt_dynar_is_empty(e_route->link_list), "Bypass route between %s@%s and %s@%s cannot be empty.",
+      xbt_assert(!e_route->link_list->empty(), "Bypass route between %s@%s and %s@%s cannot be empty.",
           src, e_route->gw_src->name(), dst, e_route->gw_dst->name());
-      xbt_assert(bypassRoutes_->find(route_name) == bypassRoutes_->end(),
-          "The bypass route between %s@%s and %s@%s already exists.",
+      xbt_assert(bypassRoutes_.find({src,dst}) == bypassRoutes_.end(), "The bypass route between %s@%s and %s@%s already exists.",
           src, e_route->gw_src->name(), dst, e_route->gw_dst->name());
     } else {
       XBT_DEBUG("Load bypassRoute from %s to %s", src, dst);
-      xbt_assert(!xbt_dynar_is_empty(e_route->link_list),                 "Bypass route between %s and %s cannot be empty.",    src, dst);
-      xbt_assert(bypassRoutes_->find(route_name) == bypassRoutes_->end(), "The bypass route between %s and %s already exists.", src, dst);
+      xbt_assert(!e_route->link_list->empty(),                         "Bypass route between %s and %s cannot be empty.",    src, dst);
+      xbt_assert(bypassRoutes_.find({src,dst}) == bypassRoutes_.end(), "The bypass route between %s and %s already exists.", src, dst);
     }
 
-    /* Build the value that will be stored in the dict */
+    /* Build a copy that will be stored in the dict */
     std::vector<Link*> *newRoute = new std::vector<Link*>();
-    char *linkName;
-    unsigned int cpt;
-    xbt_dynar_foreach(e_route->link_list, cpt, linkName) {
-      Link *link = Link::byName(linkName);
-      if (link)
-        newRoute->push_back(link);
-      else
-        THROWF(mismatch_error, 0, "Link '%s' not found", linkName);
-    }
+    for (auto link: *e_route->link_list)
+      newRoute->push_back(link);
 
     /* Store it */
-    bypassRoutes_->insert({route_name, newRoute});
-    xbt_free(route_name);
+    bypassRoutes_.insert({{src,dst}, newRoute});
   }
 
 }} // namespace simgrid::surf
@@ -341,7 +358,7 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS)
     netcard->setId(-1);
   } else if (current_routing != NULL && routing_platf->root_ != NULL) {
 
-    xbt_assert(!xbt_dict_get_or_null(current_routing->sons_, AS->id),
+    xbt_assert(!xbt_dict_get_or_null(current_routing->children_, AS->id),
                "The AS \"%s\" already exists", AS->id);
     /* it is a part of the tree */
     new_as->father_ = current_routing;
@@ -349,8 +366,7 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS)
     if (current_routing->hierarchy_ == SURF_ROUTING_NULL)
       current_routing->hierarchy_ = SURF_ROUTING_RECURSIVE;
     /* add to the sons dictionary */
-    xbt_dict_set(current_routing->sons_, AS->id,
-                 (void *) new_as, NULL);
+    xbt_dict_set(current_routing->children_, AS->id, (void *) new_as, NULL);
     /* add to the father element list */
     netcard->setId(current_routing->addComponent(netcard));
   } else {
@@ -373,11 +389,6 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS)
  *
  * Once you've declared all the content of your AS, you have to close
  * it with this call. Your AS is not usable until you call this function.
- *
- * @fixme: this call is not as robust as wanted: bad things WILL happen
- * if you call it twice for the same AS, or if you forget calling it, or
- * even if you add stuff to a closed AS
- *
  */
 void routing_AS_end()
 {
@@ -386,99 +397,36 @@ void routing_AS_end()
   current_routing = current_routing->father_;
 }
 
-/* Aux Business methods */
-
-/**
- * \brief Get the AS father and the first elements of the chain
- *
- * \param src the source host name
- * \param dst the destination host name
- *
- * Get the common father of the to processing units, and the first different
- * father in the chain
- */
-static void elements_father(sg_netcard_t src, sg_netcard_t dst,
-                            AS_t * res_father,
-                            AS_t * res_src,
-                            AS_t * res_dst)
-{
-  xbt_assert(src && dst, "bad parameters for \"elements_father\" method");
-#define ROUTING_HIERARCHY_MAXDEPTH 16     /* increase if it is not enough */
-  simgrid::surf::As *path_src[ROUTING_HIERARCHY_MAXDEPTH];
-  simgrid::surf::As *path_dst[ROUTING_HIERARCHY_MAXDEPTH];
-  int index_src = 0;
-  int index_dst = 0;
-  simgrid::surf::As *current_src;
-  simgrid::surf::As *current_dst;
-  simgrid::surf::As *father;
-
-  /* (1) find the path to root of src and dst*/
-  simgrid::surf::As *src_as = src->containingAS();
-  simgrid::surf::As *dst_as = dst->containingAS();
-
-  xbt_assert(src_as, "Host %s must be in an AS", src->name());
-  xbt_assert(dst_as, "Host %s must be in an AS", dst->name());
-
-  /* (2) find the path to the root routing component */
-  for (simgrid::surf::As *current = src_as; current != NULL; current = current->father_) {
-    if (index_src >= ROUTING_HIERARCHY_MAXDEPTH)
-      xbt_die("ROUTING_HIERARCHY_MAXDEPTH should be increased for element %s", src->name());
-    path_src[index_src++] = current;
-  }
-  for (simgrid::surf::As *current = dst_as; current != NULL; current = current->father_) {
-    if (index_dst >= ROUTING_HIERARCHY_MAXDEPTH)
-      xbt_die("ROUTING_HIERARCHY_MAXDEPTH should be increased for path_dst");
-    path_dst[index_dst++] = current;
-  }
-
-  /* (3) find the common father */
-  do {
-    current_src = path_src[--index_src];
-    current_dst = path_dst[--index_dst];
-  } while (index_src > 0 && index_dst > 0 && current_src == current_dst);
-
-  /* (4) they are not in the same routing component, make the path */
-  if (current_src == current_dst)
-    father = current_src;
-  else
-    father = path_src[index_src + 1];
-
-  /* (5) result generation */
-  *res_father = father;         /* first the common father of src and dst */
-  *res_src = current_src;       /* second the first different father of src */
-  *res_dst = current_dst;       /* three  the first different father of dst */
-
-#undef ROUTING_HIERARCHY_MAXDEPTH
-}
+namespace simgrid {
+namespace surf {
 
 /**
- * \brief Recursive function for get_route_and_latency
+ * \brief Recursive function for getRouteAndLatency
  *
- * \param src the source host name
- * \param dst the destination host name
- * \param *route the route where the links are stored. It is either NULL or a ready to use dynar
- * \param *latency the latency, if needed
+ * \param src the source host
+ * \param dst the destination host
+ * \param links Where to store the links and the gw information
+ * \param latency If not NULL, the latency of all links will be added in it
  */
-static void _get_route_and_latency(simgrid::surf::NetCard *src, simgrid::surf::NetCard *dst,
-  xbt_dynar_t * links, double *latency)
+void As::getRouteRecursive(NetCard *src, NetCard *dst,
+    /* OUT */ std::vector<Link*> * links, double *latency)
 {
-  s_sg_platf_route_cbarg_t route = SG_PLATF_ROUTE_INITIALIZER;
+  s_sg_platf_route_cbarg_t route;
   memset(&route,0,sizeof(route));
 
-  xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method");
-  XBT_DEBUG("Solve route/latency  \"%s\" to \"%s\"", src->name(), dst->name());
+  XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src->name(), dst->name());
 
   /* Find how src and dst are interconnected */
-  simgrid::surf::As *common_father, *src_father, *dst_father;
-  elements_father(src, dst, &common_father, &src_father, &dst_father);
-  XBT_DEBUG("elements_father: common father '%s' src_father '%s' dst_father '%s'",
-      common_father->name_, src_father->name_, dst_father->name_);
+  simgrid::surf::As *common_ancestor, *src_ancestor, *dst_ancestor;
+  find_common_ancestors(src, dst, &common_ancestor, &src_ancestor, &dst_ancestor);
+  XBT_DEBUG("elements_father: common ancestor '%s' src ancestor '%s' dst ancestor '%s'",
+      common_ancestor->name_, src_ancestor->name_, dst_ancestor->name_);
 
   /* Check whether a direct bypass is defined. If so, use it and bail out */
-  std::vector<Link*> *bypassed_route = common_father->getBypassRoute(src, dst);
+  std::vector<Link*> *bypassed_route = common_ancestor->getBypassRoute(src, dst);
   if (nullptr != bypassed_route) {
     for (Link *link : *bypassed_route) {
-      xbt_dynar_push(*links,&link);
+      links->push_back(link);
       if (latency)
         *latency += link->getLatency();
     }
@@ -486,34 +434,32 @@ static void _get_route_and_latency(simgrid::surf::NetCard *src, simgrid::surf::N
   }
 
   /* If src and dst are in the same AS, life is good */
-  if (src_father == dst_father) {       /* SURF_ROUTING_BASE */
-    route.link_list = *links;
-    common_father->getRouteAndLatency(src, dst, &route, latency);
+  if (src_ancestor == dst_ancestor) {       /* SURF_ROUTING_BASE */
+    route.link_list = links;
+    common_ancestor->getRouteAndLatency(src, dst, &route, latency);
     return;
   }
 
   /* Not in the same AS, no bypass. We'll have to find our path between the ASes recursively*/
 
-  route.link_list = xbt_dynar_new(sizeof(Link*), NULL);
+  route.link_list = new std::vector<Link*>();
 
-  common_father->getRouteAndLatency(src_father->netcard_, dst_father->netcard_, &route, latency);
+  common_ancestor->getRouteAndLatency(src_ancestor->netcard_, dst_ancestor->netcard_, &route, latency);
   xbt_assert((route.gw_src != NULL) && (route.gw_dst != NULL),
       "bad gateways for route from \"%s\" to \"%s\"", src->name(), dst->name());
 
   /* If source gateway is not our source, we have to recursively find our way up to this point */
   if (src != route.gw_src)
-    _get_route_and_latency(src, route.gw_src, links, latency);
-  xbt_dynar_merge(links, &route.link_list);
+    getRouteRecursive(src, route.gw_src, links, latency);
+  for (auto link: *route.link_list)
+    links->push_back(link);
 
   /* If dest gateway is not our destination, we have to recursively find our way from this point */
   if (route.gw_dst != dst)
-    _get_route_and_latency(route.gw_dst, dst, links, latency);
+    getRouteRecursive(route.gw_dst, dst, links, latency);
 
 }
 
-namespace simgrid {
-namespace surf {
-
 /**
  * \brief Find a route between hosts
  *
@@ -528,15 +474,11 @@ namespace surf {
  * walk through the routing components tree and find a route between hosts
  * by calling each "get_route" function in each routing component.
  */
-void RoutingPlatf::getRouteAndLatency(NetCard *src, NetCard *dst, xbt_dynar_t* route, double *latency)
+void RoutingPlatf::getRouteAndLatency(NetCard *src, NetCard *dst, std::vector<Link*> * route, double *latency)
 {
   XBT_DEBUG("getRouteAndLatency from %s to %s", src->name(), dst->name());
-  if (NULL == *route) {
-    xbt_dynar_reset(routing_platf->lastRoute_);
-    *route = routing_platf->lastRoute_;
-  }
 
-  _get_route_and_latency(src, dst, route, latency);
+  As::getRouteRecursive(src, dst, route, latency);
 }
 
 static xbt_dynar_t _recursiveGetOneLinkRoutes(As *rc)
@@ -552,7 +494,7 @@ static xbt_dynar_t _recursiveGetOneLinkRoutes(As *rc)
   char *key;
   xbt_dict_cursor_t cursor = NULL;
   AS_t rc_child;
-  xbt_dict_foreach(rc->sons_, cursor, key, rc_child) {
+  xbt_dict_foreach(rc->children_, cursor, key, rc_child) {
     xbt_dynar_t onelink_child = _recursiveGetOneLinkRoutes(rc_child);
     if (onelink_child)
       xbt_dynar_merge(&ret,&onelink_child);
@@ -568,7 +510,7 @@ xbt_dynar_t RoutingPlatf::getOneLinkRoutes(){
 }
 
 /** @brief create the root AS */
-void routing_model_create( void *loopback)
+void routing_model_create(Link *loopback)
 {
   routing_platf = new simgrid::surf::RoutingPlatf(loopback);
 }
@@ -737,126 +679,6 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
   free(link_down);
 }
 
-// static void routing_parse_Srandom(void)
-// {
-//   double mean, std, min, max, seed;
-//   char *random_id = A_surfxml_random_id;
-//   char *random_radical = A_surfxml_random_radical;
-//   char *rd_name = NULL;
-//   char *rd_value;
-//   mean = surf_parse_get_double(A_surfxml_random_mean);
-//   std = surf_parse_get_double(A_surfxml_random_std___deviation);
-//   min = surf_parse_get_double(A_surfxml_random_min);
-//   max = surf_parse_get_double(A_surfxml_random_max);
-//   seed = surf_parse_get_double(A_surfxml_random_seed);
-
-//   double res = 0;
-//   int i = 0;
-//   random_data_t random = xbt_new0(s_random_data_t, 1);
-//   char *tmpbuf;
-
-//   xbt_dynar_t radical_elements;
-//   unsigned int iter;
-//   char *groups;
-//   int start, end;
-//   xbt_dynar_t radical_ends;
-
-//   switch (A_surfxml_random_generator) {
-//   case AU_surfxml_random_generator:
-//   case A_surfxml_random_generator_NONE:
-//     random->generator = NONE;
-//     break;
-//   case A_surfxml_random_generator_DRAND48:
-//     random->generator = DRAND48;
-//     break;
-//   case A_surfxml_random_generator_RAND:
-//     random->generator = RAND;
-//     break;
-//   case A_surfxml_random_generator_RNGSTREAM:
-//     random->generator = RNGSTREAM;
-//     break;
-//   default:
-//     surf_parse_error("Invalid random generator");
-//     break;
-//   }
-//   random->seed = seed;
-//   random->min = min;
-//   random->max = max;
-
-//   /* Check user stupidities */
-//   if (max < min)
-//     THROWF(arg_error, 0, "random->max < random->min (%f < %f)", max, min);
-//   if (mean < min)
-//     THROWF(arg_error, 0, "random->mean < random->min (%f < %f)", mean, min);
-//   if (mean > max)
-//     THROWF(arg_error, 0, "random->mean > random->max (%f > %f)", mean, max);
-
-//   /* normalize the mean and standard deviation before storing */
-//   random->mean = (mean - min) / (max - min);
-//   random->std = std / (max - min);
-
-//   if (random->mean * (1 - random->mean) < random->std * random->std)
-//     THROWF(arg_error, 0, "Invalid mean and standard deviation (%f and %f)",
-//            random->mean, random->std);
-
-//   XBT_DEBUG
-//       ("id = '%s' min = '%f' max = '%f' mean = '%f' std_deviatinon = '%f' generator = '%d' seed = '%ld' radical = '%s'",
-//        random_id, random->min, random->max, random->mean, random->std,
-//        (int)random->generator, random->seed, random_radical);
-
-//   if (!random_value)
-//     random_value = xbt_dict_new_homogeneous(free);
-
-//   if (!strcmp(random_radical, "")) {
-//     res = random_generate(random);
-//     rd_value = bprintf("%f", res);
-//     xbt_dict_set(random_value, random_id, rd_value, NULL);
-//   } else {
-//     radical_elements = xbt_str_split(random_radical, ",");
-//     xbt_dynar_foreach(radical_elements, iter, groups) {
-//       radical_ends = xbt_str_split(groups, "-");
-//       switch (xbt_dynar_length(radical_ends)) {
-//       case 1:
-//         xbt_assert(!xbt_dict_get_or_null(random_value, random_id),
-//                    "Custom Random '%s' already exists !", random_id);
-//         res = random_generate(random);
-//         tmpbuf =
-//             bprintf("%s%d", random_id,
-//                     atoi(xbt_dynar_getfirst_as(radical_ends, char *)));
-//         xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL);
-//         xbt_free(tmpbuf);
-//         break;
-
-//       case 2:
-//         start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
-//         end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
-//         for (i = start; i <= end; i++) {
-//           xbt_assert(!xbt_dict_get_or_null(random_value, random_id),
-//                      "Custom Random '%s' already exists !", bprintf("%s%d",
-//                                                                     random_id,
-//                                                                     i));
-//           res = random_generate(random);
-//           tmpbuf = bprintf("%s%d", random_id, i);
-//           xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL);
-//           xbt_free(tmpbuf);
-//         }
-//         break;
-//       default:
-//         XBT_CRITICAL("Malformed radical");
-//         break;
-//       }
-//       res = random_generate(random);
-//       rd_name = bprintf("%s_router", random_id);
-//       rd_value = bprintf("%f", res);
-//       xbt_dict_set(random_value, rd_name, rd_value, NULL);
-
-//       xbt_dynar_free(&radical_ends);
-//     }
-//     free(rd_name);
-//     xbt_dynar_free(&radical_elements);
-//   }
-// }
-
 static void check_disk_attachment()
 {
   xbt_lib_cursor_t cursor;
@@ -880,26 +702,6 @@ void routing_register_callbacks()
   instr_routing_define_callbacks();
 }
 
-/**
- * \brief Recursive function for finalize
- *
- * \param rc the source host name
- *
- * This fuction is call by "finalize". It allow to finalize the
- * AS or routing components. It delete all the structures.
- */
-static void finalize_rec(simgrid::surf::As *as) {
-  xbt_dict_cursor_t cursor = NULL;
-  char *key;
-  AS_t elem;
-
-  xbt_dict_foreach(as->sons_, cursor, key, elem) {
-    finalize_rec(elem);
-  }
-
-  delete as;;
-}
-
 /** \brief Frees all memory allocated by the routing module */
 void routing_exit(void) {
   delete routing_platf;
@@ -908,14 +710,13 @@ void routing_exit(void) {
 namespace simgrid {
 namespace surf {
 
-  RoutingPlatf::RoutingPlatf(void *loopback)
+  RoutingPlatf::RoutingPlatf(Link *loopback)
   : loopback_(loopback)
   {
   }
   RoutingPlatf::~RoutingPlatf()
   {
-    xbt_dynar_free(&lastRoute_);
-    finalize_rec(root_);
+    delete root_;
   }
 
 }
@@ -929,8 +730,7 @@ const char *surf_AS_get_name(simgrid::surf::As *as) {
   return as->name_;
 }
 
-static simgrid::surf::As *surf_AS_recursive_get_by_name(
-  simgrid::surf::As *current, const char * name)
+static simgrid::surf::As *surf_AS_recursive_get_by_name(simgrid::surf::As *current, const char * name)
 {
   xbt_dict_cursor_t cursor = NULL;
   char *key;
@@ -940,7 +740,7 @@ static simgrid::surf::As *surf_AS_recursive_get_by_name(
   if(!strcmp(current->name_, name))
     return current;
 
-  xbt_dict_foreach(current->sons_, cursor, key, elem) {
+  xbt_dict_foreach(current->children_, cursor, key, elem) {
     tmp = surf_AS_recursive_get_by_name(elem, name);
     if(tmp != NULL ) {
         break;
@@ -957,9 +757,9 @@ simgrid::surf::As *surf_AS_get_by_name(const char * name)
   return as;
 }
 
-xbt_dict_t surf_AS_get_routing_sons(simgrid::surf::As *as)
+xbt_dict_t surf_AS_get_children(simgrid::surf::As *as)
 {
-  return as->sons_;
+  return as->children_;
 }
 
 xbt_dynar_t surf_AS_get_hosts(simgrid::surf::As *as)