Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
cosmetics: inline a parsing function to unclutter the routing code
[simgrid.git] / src / surf / surf_routing.cpp
index a4bbe30..5e3b5ed 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2011, 2013-2014. The SimGrid Team.
+/* Copyright (c) 2009-2011, 2013-2015. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -8,42 +8,39 @@
 #include "surf_routing_private.hpp"
 #include "surf_routing_cluster.hpp"
 #include "surf_routing_cluster_torus.hpp"
-
+#include "surf_routing_cluster_fat_tree.hpp"
 
 #include "simgrid/platf_interface.h"    // platform creation API internal interface
 #include "simgrid/sg_config.h"
 #include "storage_interface.hpp"
-
+#include "src/surf/platform.hpp"
 #include "surf/surfxml_parse_values.h"
 
+/*************
+ * Callbacks *
+ *************/
+
+namespace simgrid {
+namespace surf {
+
+simgrid::xbt::signal<void(simgrid::surf::NetCard*)> netcardCreatedCallbacks;
+simgrid::xbt::signal<void(simgrid::surf::As*)> asCreatedCallbacks;
+
+}
+}
 
 /**
  * @ingroup SURF_build_api
- * @brief A library containing all known workstations
+ * @brief A library containing all known hosts
  */
-xbt_lib_t host_lib;
+xbt_dict_t host_list;
 
-int ROUTING_HOST_LEVEL;         //Routing level
-int SURF_CPU_LEVEL;             //Surf cpu level
-int SURF_WKS_LEVEL;             //Surf workstation level
-int SIMIX_HOST_LEVEL;           //Simix host level
-int SIMIX_STORAGE_LEVEL;        //Simix storage level
-int MSG_HOST_LEVEL;             //Msg host level
-int MSG_STORAGE_LEVEL;          //Msg storage level
-int MSG_FILE_LEVEL;             //Msg file level
-int SD_HOST_LEVEL;              //Simdag host level
-int SD_STORAGE_LEVEL;           //Simdag storage level
 int COORD_HOST_LEVEL=0;         //Coordinates level
-int NS3_HOST_LEVEL;             //host node for ns3
 
-/**
- * @ingroup SURF_build_api
- * @brief A library containing all known links
- */
-xbt_lib_t link_lib;
-int SD_LINK_LEVEL;              //Simdag level
-int SURF_LINK_LEVEL;            //Surf level
-int NS3_LINK_LEVEL;             //link for ns3
+int MSG_FILE_LEVEL;             //Msg file level
+
+int SIMIX_STORAGE_LEVEL;        //Simix storage level
+int MSG_STORAGE_LEVEL;          //Msg storage level
 
 xbt_lib_t as_router_lib;
 int ROUTING_ASR_LEVEL;          //Routing level
@@ -54,28 +51,33 @@ int ROUTING_PROP_ASR_LEVEL;     //Where the properties are stored
 static xbt_dict_t random_value = NULL;
 
 
-/** @brief Retrieve a routing edge from its name
+/** @brief Retrieve a netcard from its name
  *
- * Routing edges are either CPU/workstation and routers, whatever
+ * Netcards are the thing that connect host or routers to the network
  */
-RoutingEdgePtr sg_routing_edge_by_name_or_null(const char *name) {
-  RoutingEdgePtr net_elm = (RoutingEdgePtr) xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL);
+simgrid::surf::NetCard *sg_netcard_by_name_or_null(const char *name)
+{
+  sg_host_t h = sg_host_by_name(name);
+  simgrid::surf::NetCard *net_elm = h==NULL?NULL: h->pimpl_netcard;
   if (!net_elm)
-       net_elm = (RoutingEdgePtr) xbt_lib_get_or_null(as_router_lib, name, ROUTING_ASR_LEVEL);
+    net_elm = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, name, ROUTING_ASR_LEVEL);
   return net_elm;
 }
 
 /* Global vars */
-RoutingPlatfPtr routing_platf = NULL;
-AsPtr current_routing = NULL;
+simgrid::surf::RoutingPlatf *routing_platf = NULL;
 
 /* global parse functions */
 extern xbt_dynar_t mount_list;
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf");
 
-static void routing_parse_peer(sg_platf_peer_cbarg_t peer);     /* peer bypass */
-// static void routing_parse_Srandom(void);        /* random bypass */
+/** The current AS in the parsing */
+static simgrid::surf::As *current_routing = NULL;
+simgrid::surf::As* routing_get_current()
+{
+  return current_routing;
+}
 
 static void routing_parse_postparse(void);
 
@@ -89,7 +91,7 @@ typedef enum {
   SURF_MODEL_VIVALDI,
   SURF_MODEL_CLUSTER,
   SURF_MODEL_TORUS_CLUSTER,
-
+  SURF_MODEL_FAT_TREE_CLUSTER,
 } e_routing_types;
 
 struct s_model_type routing_models[] = {
@@ -111,223 +113,57 @@ struct s_model_type routing_models[] = {
    model_vivaldi_create, NULL},
   {"Cluster", "Cluster routing",
    model_cluster_create, NULL},
-   {"Torus_Cluster", "Torus Cluster routing",
-    model_torus_cluster_create, NULL},
+  {"Torus_Cluster", "Torus Cluster routing",
+   model_torus_cluster_create, NULL},
+  {"Fat_Tree_Cluster", "Fat Tree Cluster routing",
+   model_fat_tree_cluster_create, NULL},
   {NULL, NULL, NULL, NULL}
 };
 
 /**
- * \brief Add a "host_link" to the network element list
+ * \brief Add a netcard connecting an host to the network element list
+ * FIXME: integrate into host constructor
  */
-static void parse_S_host_link(sg_platf_host_link_cbarg_t host)
+void sg_platf_new_netcard(sg_platf_host_link_cbarg_t netcard)
 {
-  RoutingEdgePtr info = static_cast<RoutingEdgePtr>(xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL));
-  xbt_assert(info, "Host '%s' not found!", host->id);
+  simgrid::surf::NetCard *info = sg_host_by_name(netcard->id)->pimpl_netcard;
+  xbt_assert(info, "Host '%s' not found!", netcard->id);
   xbt_assert(current_routing->p_modelDesc == &routing_models[SURF_MODEL_CLUSTER] ||
       current_routing->p_modelDesc == &routing_models[SURF_MODEL_VIVALDI],
       "You have to be in model Cluster to use tag host_link!");
 
   s_surf_parsing_link_up_down_t link_up_down;
-  link_up_down.link_up = xbt_lib_get_or_null(link_lib, host->link_up, SURF_LINK_LEVEL);
-  link_up_down.link_down = xbt_lib_get_or_null(link_lib, host->link_down, SURF_LINK_LEVEL);
+  link_up_down.link_up = Link::byName(netcard->link_up);
+  link_up_down.link_down = Link::byName(netcard->link_down);
 
-  xbt_assert(link_up_down.link_up, "Link '%s' not found!",host->link_up);
-  xbt_assert(link_up_down.link_down, "Link '%s' not found!",host->link_down);
+  xbt_assert(link_up_down.link_up, "Link '%s' not found!",netcard->link_up);
+  xbt_assert(link_up_down.link_down, "Link '%s' not found!",netcard->link_down);
 
   if(!current_routing->p_linkUpDownList)
     current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
 
-  // If dynar is is greater than edge id and if the host_link is already defined
+  // If dynar is is greater than netcard id and if the host_link is already defined
   if((int)xbt_dynar_length(current_routing->p_linkUpDownList) > info->getId() &&
       xbt_dynar_get_as(current_routing->p_linkUpDownList, info->getId(), void*))
-       surf_parse_error("Host_link for '%s' is already defined!",host->id);
+  surf_parse_error("Host_link for '%s' is already defined!",netcard->id);
 
   XBT_DEBUG("Push Host_link for host '%s' to position %d", info->getName(), info->getId());
   xbt_dynar_set_as(current_routing->p_linkUpDownList, info->getId(), s_surf_parsing_link_up_down_t, link_up_down);
 }
 
-/**
- * \brief Add a "host" to the network element list
- */
-static void parse_S_host(sg_platf_host_cbarg_t host)
-{
-  if (current_routing->p_hierarchy == SURF_ROUTING_NULL)
-    current_routing->p_hierarchy = SURF_ROUTING_BASE;
-  xbt_assert(!xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL),
-             "Reading a host, processing unit \"%s\" already exists", host->id);
-
-  RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(host->id),
-                                                   -1,
-                                                   SURF_NETWORK_ELEMENT_HOST,
-                                                   current_routing);
-  info->setId(current_routing->parsePU(info));
-  xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info);
-  XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->getId());
-
-  if(mount_list){
-    xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
-    mount_list = NULL;
-  }
-
-  if (host->coord && strcmp(host->coord, "")) {
-    unsigned int cursor;
-    char*str;
-
-    if (!COORD_HOST_LEVEL)
-      xbt_die ("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_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
-    xbt_dynar_foreach(ctn_str,cursor, str) {
-      double val = atof(str);
-      xbt_dynar_push(ctn,&val);
-    }
-    xbt_dynar_shrink(ctn, 0);
-    xbt_dynar_free(&ctn_str);
-    xbt_lib_set(host_lib, host->id, COORD_HOST_LEVEL, (void *) ctn);
-    XBT_DEBUG("Having set host coordinates for '%s'",host->id);
-  }
-}
-
-/**
- * \brief Add a "router" to the network element list
- */
-static void parse_S_router(sg_platf_router_cbarg_t router)
-{
-  if (current_routing->p_hierarchy == SURF_ROUTING_NULL)
-    current_routing->p_hierarchy = SURF_ROUTING_BASE;
-  xbt_assert(!xbt_lib_get_or_null(as_router_lib, router->id, ROUTING_ASR_LEVEL),
-             "Reading a router, processing unit \"%s\" already exists",
-             router->id);
-
-  RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(router->id),
-                                            -1,
-                                            SURF_NETWORK_ELEMENT_ROUTER,
-                                            current_routing);
-  info->setId(current_routing->parsePU(info));
-  xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) info);
-  XBT_DEBUG("Having set name '%s' id '%d'", router->id, info->getId());
-
-  if (router->coord && strcmp(router->coord, "")) {
-    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");
-    /* Pre-parse the host coordinates */
-    xbt_dynar_t ctn_str = xbt_str_split_str(router->coord, " ");
-    xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
-    xbt_dynar_foreach(ctn_str,cursor, str) {
-      double val = atof(str);
-      xbt_dynar_push(ctn,&val);
-    }
-    xbt_dynar_shrink(ctn, 0);
-    xbt_dynar_free(&ctn_str);
-    xbt_lib_set(as_router_lib, router->id, COORD_ASR_LEVEL, (void *) ctn);
-    XBT_DEBUG("Having set router coordinates for '%s'",router->id);
-  }
-}
-
-/**
- * \brief Store the route by calling the set_route function of the current routing component
- */
-static void parse_E_route(sg_platf_route_cbarg_t route)
-{
-  /*FIXME:REMOVE:xbt_assert(current_routing->parse_route,
-             "no defined method \"set_route\" in \"%s\"",
-             current_routing->name);*/
-
-  current_routing->parseRoute(route);
-}
-
-/**
- * \brief Store the ASroute by calling the set_ASroute function of the current routing component
- */
-static void parse_E_ASroute(sg_platf_route_cbarg_t ASroute)
-{
-  /*FIXME:REMOVE:xbt_assert(current_routing->parse_ASroute,
-             "no defined method \"set_ASroute\" in \"%s\"",
-             current_routing->name);*/
-  current_routing->parseASroute(ASroute);
-}
-
-/**
- * \brief Store the bypass route by calling the set_bypassroute function of the current routing component
- */
-static void parse_E_bypassRoute(sg_platf_route_cbarg_t route)
-{
-  /*FIXME:REMOVE:xbt_assert(current_routing->parse_bypassroute,
-             "Bypassing mechanism not implemented by routing '%s'",
-             current_routing->name);*/
-
-  current_routing->parseBypassroute(route);
-}
-
-/**
- * \brief Store the bypass route by calling the set_bypassroute function of the current routing component
- */
-static void parse_E_bypassASroute(sg_platf_route_cbarg_t ASroute)
-{
-  /*FIXME:REMOVE:xbt_assert(current_routing->parse_bypassroute,
-             "Bypassing mechanism not implemented by routing '%s'",
-             current_routing->name);*/
-  current_routing->parseBypassroute(ASroute);
-}
-
-static void routing_parse_trace(sg_platf_trace_cbarg_t trace)
+void sg_platf_new_trace(sg_platf_trace_cbarg_t trace)
 {
   tmgr_trace_t tmgr_trace;
   if (!trace->file || strcmp(trace->file, "") != 0) {
     tmgr_trace = tmgr_trace_new_from_file(trace->file);
-  } else if (strcmp(trace->pc_data, "") == 0) {
-    tmgr_trace = NULL;
   } else {
-    tmgr_trace =
-          tmgr_trace_new_from_string(trace->id, trace->pc_data,
-                                     trace->periodicity);
+    xbt_assert(strcmp(trace->pc_data, ""),
+        "Trace '%s' must have either a content, or point to a file on disk.",trace->id);
+    tmgr_trace = tmgr_trace_new_from_string(trace->id, trace->pc_data, trace->periodicity);
   }
   xbt_dict_set(traces_set_list, trace->id, (void *) tmgr_trace, NULL);
 }
 
-static void routing_parse_trace_connect(sg_platf_trace_connect_cbarg_t trace_connect)
-{
-  xbt_assert(xbt_dict_get_or_null
-              (traces_set_list, trace_connect->trace),
-              "Cannot connect trace %s to %s: trace unknown",
-              trace_connect->trace,
-              trace_connect->element);
-
-  switch (trace_connect->kind) {
-  case SURF_TRACE_CONNECT_KIND_HOST_AVAIL:
-    xbt_dict_set(trace_connect_list_host_avail,
-        trace_connect->trace,
-        xbt_strdup(trace_connect->element), NULL);
-    break;
-  case SURF_TRACE_CONNECT_KIND_POWER:
-    xbt_dict_set(trace_connect_list_power, trace_connect->trace,
-        xbt_strdup(trace_connect->element), NULL);
-    break;
-  case SURF_TRACE_CONNECT_KIND_LINK_AVAIL:
-    xbt_dict_set(trace_connect_list_link_avail,
-        trace_connect->trace,
-        xbt_strdup(trace_connect->element), NULL);
-    break;
-  case SURF_TRACE_CONNECT_KIND_BANDWIDTH:
-    xbt_dict_set(trace_connect_list_bandwidth,
-        trace_connect->trace,
-        xbt_strdup(trace_connect->element), NULL);
-    break;
-  case SURF_TRACE_CONNECT_KIND_LATENCY:
-    xbt_dict_set(trace_connect_list_latency, trace_connect->trace,
-        xbt_strdup(trace_connect->element), NULL);
-    break;
-  default:
-       surf_parse_error("Cannot connect trace %s to %s: kind of trace unknown",
-        trace_connect->trace, trace_connect->element);
-    break;
-  }
-}
-
 /**
  * \brief Make a new routing component to the platform
  *
@@ -356,26 +192,28 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS)
 
   /* search the routing model */
   switch(AS->routing){
-    case A_surfxml_AS_routing_Cluster:         model = &routing_models[SURF_MODEL_CLUSTER];break;
-    case A_surfxml_AS_routing_Cluster___torus: model = &routing_models[SURF_MODEL_TORUS_CLUSTER];break;
-    case A_surfxml_AS_routing_Dijkstra:        model = &routing_models[SURF_MODEL_DIJKSTRA];break;
-    case A_surfxml_AS_routing_DijkstraCache:   model = &routing_models[SURF_MODEL_DIJKSTRACACHE];break;
-    case A_surfxml_AS_routing_Floyd:           model = &routing_models[SURF_MODEL_FLOYD];break;
-    case A_surfxml_AS_routing_Full:            model = &routing_models[SURF_MODEL_FULL];break;
-    case A_surfxml_AS_routing_None:            model = &routing_models[SURF_MODEL_NONE];break;
-    case A_surfxml_AS_routing_Vivaldi:         model = &routing_models[SURF_MODEL_VIVALDI];break;
+    case A_surfxml_AS_routing_Cluster:               model = &routing_models[SURF_MODEL_CLUSTER];break;
+    case A_surfxml_AS_routing_Cluster___torus:       model = &routing_models[SURF_MODEL_TORUS_CLUSTER];break;
+    case A_surfxml_AS_routing_Cluster___fat___tree:  model = &routing_models[SURF_MODEL_FAT_TREE_CLUSTER];break;
+    case A_surfxml_AS_routing_Dijkstra:              model = &routing_models[SURF_MODEL_DIJKSTRA];break;
+    case A_surfxml_AS_routing_DijkstraCache:         model = &routing_models[SURF_MODEL_DIJKSTRACACHE];break;
+    case A_surfxml_AS_routing_Floyd:                 model = &routing_models[SURF_MODEL_FLOYD];break;
+    case A_surfxml_AS_routing_Full:                  model = &routing_models[SURF_MODEL_FULL];break;
+    case A_surfxml_AS_routing_None:                  model = &routing_models[SURF_MODEL_NONE];break;
+    case A_surfxml_AS_routing_Vivaldi:               model = &routing_models[SURF_MODEL_VIVALDI];break;
     default: xbt_die("Not a valid model!!!");
     break;
   }
 
   /* make a new routing component */
-  AsPtr new_as = model->create();
+  simgrid::surf::As *new_as = model->create();
 
   new_as->p_modelDesc = model;
   new_as->p_hierarchy = SURF_ROUTING_NULL;
   new_as->p_name = xbt_strdup(AS->id);
 
-  RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(new_as->p_name),
+  simgrid::surf::NetCard *info =
+    new simgrid::surf::NetCardImpl(xbt_strdup(new_as->p_name),
                                             -1,
                                             SURF_NETWORK_ELEMENT_AS,
                                             current_routing);
@@ -401,7 +239,7 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS)
     /* add to the father element list */
     info->setId(current_routing->parseAS(info));
   } else {
-    THROWF(arg_error, 0, "All defined components must be belong to a AS");
+    THROWF(arg_error, 0, "All defined components must belong to a AS");
   }
 
   xbt_lib_set(as_router_lib, info->getName(), ROUTING_ASR_LEVEL,
@@ -410,8 +248,10 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS)
 
   /* set the new current component of the tree */
   current_routing = new_as;
-  current_routing->p_netElem = info;
+  current_routing->p_netcard = info;
 
+  simgrid::surf::netcardCreatedCallbacks(info);
+  simgrid::surf::asCreatedCallbacks(new_as);
 }
 
 /**
@@ -425,7 +265,7 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS)
  * even if you add stuff to a closed AS
  *
  */
-void routing_AS_end(sg_platf_AS_cbarg_t /*AS*/)
+void routing_AS_end()
 {
 
   if (current_routing == NULL) {
@@ -448,26 +288,26 @@ void routing_AS_end(sg_platf_AS_cbarg_t /*AS*/)
  * Get the common father of the to processing units, and the first different
  * father in the chain
  */
-static void elements_father(sg_routing_edge_t src, sg_routing_edge_t dst,
+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 ELEMENTS_FATHER_MAXDEPTH 16     /* increase if it is not enough */
-  AsPtr src_as, dst_as;
-  AsPtr path_src[ELEMENTS_FATHER_MAXDEPTH];
-  AsPtr path_dst[ELEMENTS_FATHER_MAXDEPTH];
+  simgrid::surf::As *src_as, *dst_as;
+  simgrid::surf::As *path_src[ELEMENTS_FATHER_MAXDEPTH];
+  simgrid::surf::As *path_dst[ELEMENTS_FATHER_MAXDEPTH];
   int index_src = 0;
   int index_dst = 0;
-  AsPtr current;
-  AsPtr current_src;
-  AsPtr current_dst;
-  AsPtr father;
+  simgrid::surf::As *current;
+  simgrid::surf::As *current_src;
+  simgrid::surf::As *current_dst;
+  simgrid::surf::As *father;
 
   /* (1) find the as where the src and dst are located */
-  sg_routing_edge_t src_data = src;
-  sg_routing_edge_t dst_data = dst;
+  sg_netcard_t src_data = src;
+  sg_netcard_t dst_data = dst;
   src_as = src_data->getRcComponent();
   dst_as = dst_data->getRcComponent();
 #ifndef NDEBUG
@@ -523,17 +363,18 @@ static void elements_father(sg_routing_edge_t src, sg_routing_edge_t dst,
  * This function is called by "get_route" and "get_latency". It allows to walk
  * recursively through the ASes tree.
  */
-static void _get_route_and_latency(RoutingEdgePtr src, RoutingEdgePtr dst,
-                                   xbt_dynar_t * links, double *latency)
+static void _get_route_and_latency(
+  simgrid::surf::NetCard *src, simgrid::surf::NetCard *dst,
+  xbt_dynar_t * links, double *latency)
 {
-  s_sg_platf_route_cbarg_t route;
+  s_sg_platf_route_cbarg_t route = SG_PLATF_ROUTE_INITIALIZER;
   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->getName(), dst->getName());
 
   /* Find how src and dst are interconnected */
-  AsPtr common_father, src_father, dst_father;
+  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->p_name, src_father->p_name, dst_father->p_name);
@@ -563,17 +404,17 @@ static void _get_route_and_latency(RoutingEdgePtr src, RoutingEdgePtr dst,
 
   route.link_list = xbt_dynar_new(sizeof(sg_routing_link_t), NULL);
   // Find the net_card corresponding to father
-  RoutingEdgePtr src_father_net_elm = src_father->p_netElem;
-  RoutingEdgePtr dst_father_net_elm = dst_father->p_netElem;
+  simgrid::surf::NetCard *src_father_netcard = src_father->p_netcard;
+  simgrid::surf::NetCard *dst_father_netcard = dst_father->p_netcard;
 
-  common_father->getRouteAndLatency(src_father_net_elm, dst_father_net_elm,
+  common_father->getRouteAndLatency(src_father_netcard, dst_father_netcard,
                                     &route, latency);
 
   xbt_assert((route.gw_src != NULL) && (route.gw_dst != NULL),
       "bad gateways for route from \"%s\" to \"%s\"", src->getName(), dst->getName());
 
-  sg_routing_edge_t src_gateway_net_elm = route.gw_src;
-  sg_routing_edge_t dst_gateway_net_elm = route.gw_dst;
+  sg_netcard_t src_gateway_net_elm = route.gw_src;
+  sg_netcard_t dst_gateway_net_elm = route.gw_dst;
 
   /* If source gateway is not our source, we have to recursively find our way up to this point */
   if (src != src_gateway_net_elm)
@@ -584,17 +425,18 @@ static void _get_route_and_latency(RoutingEdgePtr src, RoutingEdgePtr dst,
   if (dst_gateway_net_elm != dst)
     _get_route_and_latency(dst_gateway_net_elm, dst, links, latency);
 
-  // if vivaldi latency+=vivaldi(src_gateway,dst_gateway)
 }
 
 AS_t surf_platf_get_root(routing_platf_t platf){
   return platf->p_root;
 }
 
-e_surf_network_element_type_t surf_routing_edge_get_rc_type(sg_routing_edge_t edge){
-  return edge->getRcType();
+e_surf_network_element_type_t surf_routing_edge_get_rc_type(sg_netcard_t netcard){
+  return netcard->getRcType();
 }
 
+namespace simgrid {
+namespace surf {
 
 /**
  * \brief Find a route between hosts
@@ -608,13 +450,12 @@ e_surf_network_element_type_t surf_routing_edge_get_rc_type(sg_routing_edge_t ed
  * \pre route!=NULL
  *
  * walk through the routing components tree and find a route between hosts
- * by calling the differents "get_route" functions in each routing component.
+ * by calling each "get_route" function in each routing component.
  */
-void RoutingPlatf::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst,
-                                   xbt_dynar_t* route, double *latency)
+void RoutingPlatf::getRouteAndLatency(NetCard *src, NetCard *dst, xbt_dynar_t* route, double *latency)
 {
-  XBT_DEBUG("routing_get_route_and_latency from %s to %s", src->getName(), dst->getName());
-  if (!*route) {
+  XBT_DEBUG("getRouteAndLatency from %s to %s", src->getName(), dst->getName());
+  if (NULL == *route) {
     xbt_dynar_reset(routing_platf->p_lastRoute);
     *route = routing_platf->p_lastRoute;
   }
@@ -629,9 +470,9 @@ xbt_dynar_t RoutingPlatf::getOneLinkRoutes(){
   return recursiveGetOneLinkRoutes(p_root);
 }
 
-xbt_dynar_t RoutingPlatf::recursiveGetOneLinkRoutes(AsPtr rc)
+xbt_dynar_t RoutingPlatf::recursiveGetOneLinkRoutes(As *rc)
 {
-  xbt_dynar_t ret = xbt_dynar_new(sizeof(OnelinkPtr), xbt_free);
+  xbt_dynar_t ret = xbt_dynar_new(sizeof(Onelink*), xbt_free_f);
 
   //adding my one link routes
   xbt_dynar_t onelink_mine = rc->getOneLinkRoutes();
@@ -650,9 +491,12 @@ xbt_dynar_t RoutingPlatf::recursiveGetOneLinkRoutes(AsPtr rc)
   return ret;
 }
 
+}
+}
+
 e_surf_network_element_type_t routing_get_network_element_type(const char *name)
 {
-  RoutingEdgePtr rc = sg_routing_edge_by_name_or_null(name);
+  simgrid::surf::NetCard *rc = sg_netcard_by_name_or_null(name);
   if (rc)
     return rc->getRcType();
 
@@ -667,7 +511,7 @@ e_surf_network_element_type_t routing_get_network_element_type(const char *name)
 void routing_model_create( void *loopback)
 {
   /* config the uniq global routing */
-  routing_platf = new RoutingPlatf();
+  routing_platf = new simgrid::surf::RoutingPlatf();
   routing_platf->p_root = NULL;
   routing_platf->p_loopback = loopback;
   routing_platf->p_lastRoute = xbt_dynar_new(sizeof(sg_routing_link_t),NULL);
@@ -725,12 +569,13 @@ void routing_model_create( void *loopback)
 void routing_cluster_add_backbone(void* bb) {
   xbt_assert(current_routing->p_modelDesc == &routing_models[SURF_MODEL_CLUSTER],
         "You have to be in model Cluster to use tag backbone!");
-  xbt_assert(!surf_as_cluster_get_backbone(current_routing), "The backbone link is already defined!");
-  surf_as_cluster_set_backbone(current_routing, bb);
+  xbt_assert(!static_cast<simgrid::surf::AsCluster*>(current_routing)->p_backbone, "The backbone link is already defined!");
+  static_cast<simgrid::surf::AsCluster*>(current_routing)->p_backbone =
+    static_cast<simgrid::surf::Link*>(bb);
   XBT_DEBUG("Add a backbone to AS '%s'", current_routing->p_name);
 }
 
-static void routing_parse_cabinet(sg_platf_cabinet_cbarg_t cabinet)
+void sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet)
 {
   int start, end, i;
   char *groups , *host_id , *link_id = NULL;
@@ -756,40 +601,40 @@ static void routing_parse_cabinet(sg_platf_cabinet_cbarg_t cabinet)
       surf_parse_error("Malformed radical");
       break;
     }
-    s_sg_platf_host_cbarg_t host;
+    s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
     memset(&host, 0, sizeof(host));
-    host.initial_state = SURF_RESOURCE_ON;
-    host.pstate = 0;
-    host.power_scale = 1.0;
-    host.core_amount = 1;
+    host.initiallyOn   = 1;
+    host.pstate        = 0;
+    host.speed_scale   = 1.0;
+    host.core_amount   = 1;
 
-    s_sg_platf_link_cbarg_t link;
+    s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
     memset(&link, 0, sizeof(link));
-    link.state = SURF_RESOURCE_ON;
-    link.policy = SURF_LINK_FULLDUPLEX;
-    link.latency = cabinet->lat;
+    link.initiallyOn = 1;
+    link.policy    = SURF_LINK_FULLDUPLEX;
+    link.latency   = cabinet->lat;
     link.bandwidth = cabinet->bw;
 
-    s_sg_platf_host_link_cbarg_t host_link;
+    s_sg_platf_host_link_cbarg_t host_link = SG_PLATF_HOST_LINK_INITIALIZER;
     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;
-      xbt_dynar_t power_state_list = xbt_dynar_new(sizeof(double), NULL);
-      xbt_dynar_push(power_state_list,&cabinet->power);
-      host.power_peak = power_state_list;
+      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_peak = xbt_dynar_new(sizeof(double), NULL);
+      xbt_dynar_push(host.speed_peak,&cabinet->speed);
       sg_platf_new_host(&host);
+      xbt_dynar_free(&host.speed_peak);
       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_host_link(&host_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_netcard(&host_link);
 
       free(host_id);
       free(link_id);
@@ -802,14 +647,18 @@ static void routing_parse_cabinet(sg_platf_cabinet_cbarg_t cabinet)
   xbt_dynar_free(&radical_elements);
 }
 
-static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
+void routing_new_cluster(sg_platf_cluster_cbarg_t cluster)
 {
+  using simgrid::surf::AsCluster;
+  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;
-  s_sg_platf_link_cbarg_t link;
+  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;
   int start, end, i;
@@ -835,21 +684,29 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
     XBT_DEBUG("<AS id=\"%s\"\trouting=\"Torus_Cluster\">", cluster->id);
     AS.routing = A_surfxml_AS_routing_Cluster___torus;
     sg_platf_new_AS_begin(&AS);
-    ((AsClusterTorusPtr)current_routing)->parse_specific_arguments(cluster);
-  }else{
+    ((AsClusterTorus*)current_routing)->parse_specific_arguments(cluster);
+  }
+  else if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
+    XBT_DEBUG("<AS id=\"%s\"\trouting=\"Fat_Tree_Cluster\">", cluster->id);
+    AS.routing = A_surfxml_AS_routing_Cluster___fat___tree;
+    sg_platf_new_AS_begin(&AS);
+    ((AsClusterFatTree*)current_routing)->parse_specific_arguments(cluster);
+  }
+
+  else{
     XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", cluster->id);
     AS.routing = A_surfxml_AS_routing_Cluster;
     sg_platf_new_AS_begin(&AS);
   }
 
   if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
-      ((AsClusterPtr)current_routing)->p_nb_links_per_node++;
-      ((AsClusterPtr)current_routing)->p_has_loopback=1;
+      ((AsCluster*)current_routing)->p_nb_links_per_node++;
+      ((AsCluster*)current_routing)->p_has_loopback=1;
   }
 
   if(cluster->limiter_link!=0){
-      ((AsClusterPtr)current_routing)->p_nb_links_per_node++;
-      ((AsClusterPtr)current_routing)->p_has_limiter=1;
+      ((AsCluster*)current_routing)->p_nb_links_per_node++;
+      ((AsCluster*)current_routing)->p_has_limiter=1;
   }
 
 
@@ -880,15 +737,24 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
           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->power);
+      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);
-        host.power_trace = tmgr_trace_new_from_file(avail_file);
+        host.speed_trace = tmgr_trace_new_from_file(avail_file);
         xbt_free(avail_file);
       } else {
         XBT_DEBUG("\tavailability_file=\"\"");
@@ -903,17 +769,17 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
         XBT_DEBUG("\tstate_file=\"\"");
       }
 
-      xbt_dynar_t power_state_list = xbt_dynar_new(sizeof(double), NULL);
-      xbt_dynar_push(power_state_list,&cluster->power);
-      host.power_peak = power_state_list;
+      host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+      xbt_dynar_push(host.speed_peak,&cluster->speed);
       host.pstate = 0;
 
       //host.power_peak = cluster->power;
-      host.power_scale = 1.0;
+      host.speed_scale = 1.0;
       host.core_amount = cluster->core_amount;
-      host.initial_state = SURF_RESOURCE_ON;
+      host.initiallyOn = 1;
       host.coord = "";
       sg_platf_new_host(&host);
+      xbt_dynar_free(&host.speed_peak);
       XBT_DEBUG("</host>");
 
       XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,
@@ -936,17 +802,17 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
 
 
         memset(&link, 0, sizeof(link));
-        link.id = tmp_link;
+        link.id        = tmp_link;
         link.bandwidth = cluster->loopback_bw;
-        link.latency = cluster->loopback_lat;
-        link.state = SURF_RESOURCE_ON;
-        link.policy = SURF_LINK_FATPIPE;
+        link.latency   = cluster->loopback_lat;
+        link.initiallyOn = 1;
+        link.policy    = SURF_LINK_FATPIPE;
         sg_platf_new_link(&link);
-        info_loop.link_up =
-            xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL);
+        info_loop.link_up   = Link::byName(tmp_link);
         info_loop.link_down = info_loop.link_up;
         free(tmp_link);
-        xbt_dynar_set(current_routing->p_linkUpDownList, rankId*((AsClusterPtr)current_routing)->p_nb_links_per_node, &info_loop);
+        xbt_dynar_set(current_routing->p_linkUpDownList,
+          rankId*(static_cast<AsCluster*>(current_routing))->p_nb_links_per_node, &info_loop);
       }
 
       //add a limiter link (shared link to account for maximal bandwidth of the node)
@@ -960,27 +826,30 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
         link.id = tmp_link;
         link.bandwidth = cluster->limiter_link;
         link.latency = 0;
-        link.state = SURF_RESOURCE_ON;
+        link.initiallyOn = 1;
         link.policy = SURF_LINK_SHARED;
         sg_platf_new_link(&link);
-        info_lim.link_up =
-            xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL);
+        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(current_routing->p_linkUpDownList,
-            rankId*((AsClusterPtr)current_routing)->p_nb_links_per_node + ((AsClusterPtr)current_routing)->p_has_loopback ,
+            rankId*(as_cluster)->p_nb_links_per_node + as_cluster->p_has_loopback ,
             &info_lim);
 
       }
 
 
       //call the cluster function that adds the others links
-
-      ((AsClusterPtr)current_routing)->create_links_for_node(cluster, i, rankId, rankId*
-          ((AsClusterPtr)current_routing)->p_nb_links_per_node
-          + ((AsClusterPtr)current_routing)->p_has_loopback
-          + ((AsClusterPtr)current_routing)->p_has_limiter );
-
+      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)->p_nb_links_per_node
+          + static_cast<AsCluster*>(current_routing)->p_has_loopback
+          + static_cast<AsCluster*>(current_routing)->p_has_limiter );
+      }
       xbt_free(link_id);
       xbt_free(host_id);
       rankId++;
@@ -990,12 +859,16 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
   }
   xbt_dynar_free(&radical_elements);
 
+  // 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;
+  s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER;
   memset(&router, 0, sizeof(router));
   router.id = cluster->router_id;
   router.coord = "";
@@ -1004,7 +877,7 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
         bprintf("%s%s_router%s", cluster->prefix, cluster->id,
                 cluster->suffix);
   sg_platf_new_router(&router);
-  ((AsClusterPtr)current_routing)->p_router = (RoutingEdgePtr) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL);
+  ((AsCluster*)current_routing)->p_router = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL);
   free(newid);
 
   //Make the backbone
@@ -1014,15 +887,15 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
               cluster->bb_bw, cluster->bb_lat);
 
     memset(&link, 0, sizeof(link));
-    link.id = link_backbone;
+    link.id        = link_backbone;
     link.bandwidth = cluster->bb_bw;
-    link.latency = cluster->bb_lat;
-    link.state = SURF_RESOURCE_ON;
-    link.policy = cluster->bb_sharing_policy;
+    link.latency   = cluster->bb_lat;
+    link.initiallyOn = 1;
+    link.policy    = cluster->bb_sharing_policy;
 
     sg_platf_new_link(&link);
 
-    routing_cluster_add_backbone(xbt_lib_get_or_null(link_lib, link_backbone, SURF_LINK_LEVEL));
+    routing_cluster_add_backbone(Link::byName(link_backbone));
 
     free(link_backbone);
   }
@@ -1037,8 +910,11 @@ static void routing_parse_postparse(void) {
   xbt_dict_free(&random_value);
 }
 
-static void routing_parse_peer(sg_platf_peer_cbarg_t peer)
+void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
 {
+  using simgrid::surf::NetCard;
+  using simgrid::surf::AsCluster;
+
   char *host_id = NULL;
   char *link_id = NULL;
   char *router_id = NULL;
@@ -1050,33 +926,33 @@ static void routing_parse_peer(sg_platf_peer_cbarg_t peer)
 
   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;
+  AS.id                    = peer->id;
+  AS.routing               = A_surfxml_AS_routing_Cluster;
   sg_platf_new_AS_begin(&AS);
 
   current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
 
-  XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\"/>", host_id, peer->power);
-  s_sg_platf_host_cbarg_t host;
+  XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\"/>", host_id, peer->speed);
+  s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
   memset(&host, 0, sizeof(host));
-  host.initial_state = SURF_RESOURCE_ON;
+  host.initiallyOn = 1;
   host.id = host_id;
 
-  xbt_dynar_t power_state_list = xbt_dynar_new(sizeof(double), NULL);
-  xbt_dynar_push(power_state_list,&peer->power);
-  host.power_peak = power_state_list;
+  host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+  xbt_dynar_push(host.speed_peak,&peer->speed);
   host.pstate = 0;
   //host.power_peak = peer->power;
-  host.power_scale = 1.0;
-  host.power_trace = peer->availability_trace;
+  host.speed_scale = 1.0;
+  host.speed_trace = peer->availability_trace;
   host.state_trace = peer->state_trace;
   host.core_amount = 1;
   sg_platf_new_host(&host);
+  xbt_dynar_free(&host.speed_peak);
 
-  s_sg_platf_link_cbarg_t link;
+  s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
   memset(&link, 0, sizeof(link));
-  link.state = SURF_RESOURCE_ON;
-  link.policy = SURF_LINK_SHARED;
+  link.initiallyOn = 1;
+  link.policy  = SURF_LINK_SHARED;
   link.latency = peer->lat;
 
   char* link_up = bprintf("%s_UP",link_id);
@@ -1094,20 +970,20 @@ static void routing_parse_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;
+  s_sg_platf_host_link_cbarg_t host_link = SG_PLATF_HOST_LINK_INITIALIZER;
   memset(&host_link, 0, sizeof(host_link));
-  host_link.id = host_id;
-  host_link.link_up = link_up;
-  host_link.link_down= link_down;
-  sg_platf_new_host_link(&host_link);
+  host_link.id        = host_id;
+  host_link.link_up   = link_up;
+  host_link.link_down = link_down;
+  sg_platf_new_netcard(&host_link);
 
   XBT_DEBUG("<router id=\"%s\"/>", router_id);
-  s_sg_platf_router_cbarg_t router;
+  s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER;
   memset(&router, 0, sizeof(router));
   router.id = router_id;
   router.coord = peer->coord;
   sg_platf_new_router(&router);
-  static_cast<AsClusterPtr>(current_routing)->p_router = static_cast<RoutingEdgePtr>(xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL));
+  static_cast<AsCluster*>(current_routing)->p_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();
@@ -1246,44 +1122,23 @@ static void check_disk_attachment()
   xbt_lib_cursor_t cursor;
   char *key;
   void **data;
-  RoutingEdgePtr host_elm;
+  simgrid::surf::NetCard *host_elm;
   xbt_lib_foreach(storage_lib, cursor, key, data) {
     if(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL) != NULL) {
-         StoragePtr storage = static_cast<StoragePtr>(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL));
-         host_elm = sg_routing_edge_by_name_or_null(storage->p_attach);
-         if(!host_elm)
-                 surf_parse_error("Unable to attach storage %s: host %s doesn't exist.", storage->getName(), storage->p_attach);
+    simgrid::surf::Storage *storage = static_cast<simgrid::surf::Storage*>(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL));
+    host_elm = sg_netcard_by_name_or_null(storage->p_attach);
+    if(!host_elm)
+      surf_parse_error("Unable to attach storage %s: host %s doesn't exist.", storage->getName(), storage->p_attach);
     }
   }
 }
 
 void routing_register_callbacks()
 {
-  sg_platf_host_add_cb(parse_S_host);
-  sg_platf_router_add_cb(parse_S_router);
-  sg_platf_host_link_add_cb(parse_S_host_link);
-  sg_platf_route_add_cb(parse_E_route);
-  sg_platf_ASroute_add_cb(parse_E_ASroute);
-  sg_platf_bypassRoute_add_cb(parse_E_bypassRoute);
-  sg_platf_bypassASroute_add_cb(parse_E_bypassASroute);
-
-  sg_platf_cluster_add_cb(routing_parse_cluster);
-  sg_platf_cabinet_add_cb(routing_parse_cabinet);
+  simgrid::surf::on_postparse.connect(routing_parse_postparse);
+  simgrid::surf::on_postparse.connect(check_disk_attachment);
 
-  sg_platf_peer_add_cb(routing_parse_peer);
-  sg_platf_postparse_add_cb(routing_parse_postparse);
-  sg_platf_postparse_add_cb(check_disk_attachment);
-
-  /* we care about the ASes while parsing the platf. Incredible, isnt it? */
-  sg_platf_AS_end_add_cb(routing_AS_end);
-  sg_platf_AS_begin_add_cb(routing_AS_begin);
-
-  sg_platf_trace_add_cb(routing_parse_trace);
-  sg_platf_trace_connect_add_cb(routing_parse_trace_connect);
-
-#ifdef HAVE_TRACING
   instr_routing_define_callbacks();
-#endif
 }
 
 /**
@@ -1294,7 +1149,7 @@ void routing_register_callbacks()
  * This fuction is call by "finalize". It allow to finalize the
  * AS or routing components. It delete all the structures.
  */
-static void finalize_rec(AsPtr as) {
+static void finalize_rec(simgrid::surf::As *as) {
   xbt_dict_cursor_t cursor = NULL;
   char *key;
   AS_t elem;
@@ -1311,38 +1166,73 @@ void routing_exit(void) {
   delete routing_platf;
 }
 
+namespace simgrid {
+namespace surf {
+
 RoutingPlatf::~RoutingPlatf()
 {
-       xbt_dynar_free(&p_lastRoute);
-       finalize_rec(p_root);
+  xbt_dynar_free(&p_lastRoute);
+  finalize_rec(p_root);
+}
+
+}
 }
 
 AS_t surf_AS_get_routing_root() {
   return routing_platf->p_root;
 }
 
-const char *surf_AS_get_name(AsPtr as) {
+const char *surf_AS_get_name(simgrid::surf::As *as) {
   return as->p_name;
 }
 
-xbt_dict_t surf_AS_get_routing_sons(AsPtr as) {
+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;
+  AS_t elem;
+  simgrid::surf::As *tmp = NULL;
+
+  if(!strcmp(current->p_name, name))
+    return current;
+
+  xbt_dict_foreach(current->p_routingSons, cursor, key, elem) {
+    tmp = surf_AS_recursive_get_by_name(elem, name);
+    if(tmp != NULL ) {
+        break;
+    }
+  }
+  return tmp;
+}
+
+simgrid::surf::As *surf_AS_get_by_name(const char * name)
+{
+  simgrid::surf::As *as = surf_AS_recursive_get_by_name(routing_platf->p_root, name);
+  if(as == NULL)
+    XBT_WARN("Impossible to find an AS with name %s, please check your input", name);
+  return as;
+}
+
+xbt_dict_t surf_AS_get_routing_sons(simgrid::surf::As *as)
+{
   return as->p_routingSons;
 }
 
-const char *surf_AS_get_model(AsPtr as) {
+const char *surf_AS_get_model(simgrid::surf::As *as)
+{
   return as->p_modelDesc->name;
 }
 
-xbt_dynar_t surf_AS_get_hosts(AsPtr as) {
+xbt_dynar_t surf_AS_get_hosts(simgrid::surf::As *as)
+{
   xbt_dynar_t elms = as->p_indexNetworkElm;
-  sg_routing_edge_t relm;
-  xbt_dictelm_t delm;
-  int index;
   int count = xbt_dynar_length(elms);
-  xbt_dynar_t res =  xbt_dynar_new(sizeof(xbt_dictelm_t), NULL);
-  for (index = 0; index < count; index++) {
-     relm = xbt_dynar_get_as(elms, index, RoutingEdgePtr);
-     delm = xbt_lib_get_elm_or_null(host_lib, relm->getName());
+  xbt_dynar_t res =  xbt_dynar_new(sizeof(sg_host_t), NULL);
+  for (int index = 0; index < count; index++) {
+     sg_netcard_t relm =
+      xbt_dynar_get_as(elms, index, simgrid::surf::NetCard*);
+     sg_host_t delm = simgrid::s4u::Host::by_name_or_null(relm->getName());
      if (delm!=NULL) {
        xbt_dynar_push(res, &delm);
      }
@@ -1353,4 +1243,3 @@ xbt_dynar_t surf_AS_get_hosts(AsPtr as) {
 void surf_AS_get_graph(AS_t as, xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges) {
   as->getGraph(graph, nodes, edges);
 }
-