X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4576fb38f884be0a9b81db5354ddaa0d3ed5353f..4d0d81bd96d9effbd8066dd9cc8956175a4af4fb:/src/surf/surf_routing.c

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index 4206a9e8f3..983fd5f929 100644
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -54,9 +54,10 @@ static void model_none_load(void);      /* none routing model */
 static void model_none_unload(void);    /* none routing model */
 static void model_none_end(void);       /* none routing model */
 
-static void routing_full_parse_Scluster(void);  /*cluster bypass */
+static void routing_parse_Scluster(void);  /*cluster bypass */
 
-static void parse_Sconfig(void);        /*config Tag */
+static void routing_parse_Sconfig(void);        /*config Tag */
+static void routing_parse_Econfig(void);        /*config Tag */
 
 /* this lines are only for replace use like index in the model table */
 typedef enum {
@@ -146,7 +147,6 @@ static char *dst = NULL;        /* temporary store the destination name of a rou
 static char *gw_src = NULL;     /* temporary store the gateway source name of a route */
 static char *gw_dst = NULL;     /* temporary store the gateway destination name of a route */
 static xbt_dynar_t link_list = NULL;    /* temporary store of current list link of a route */
-
 /**
  * \brief Add a "host" to the network element list
  */
@@ -186,9 +186,6 @@ static void parse_S_host_lua(char *host_id)
   parse_S_host(host_id);
 }
 
-/*
- *
- */
 
 /**
  * \brief Add a "router" to the network element list
@@ -307,7 +304,12 @@ static void parse_E_link_ctn_new_elem(char *link_id)
 
 static void parse_E_link_ctn_new_elem_XML(void)
 {
-  parse_E_link_ctn_new_elem(A_surfxml_link_ctn_id);
+  if( A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_NONE)
+	  parse_E_link_ctn_new_elem(A_surfxml_link_ctn_id);
+  if( A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_UP)
+	  parse_E_link_ctn_new_elem(bprintf("%s_UP",A_surfxml_link_ctn_id));
+  if( A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_DOWN)
+	  parse_E_link_ctn_new_elem(bprintf("%s_DOWN",A_surfxml_link_ctn_id));
 }
 
 /**
@@ -315,7 +317,6 @@ static void parse_E_link_ctn_new_elem_XML(void)
  */
 static void parse_E_link_c_ctn_new_elem_lua(char *link_id)
 {
-
   parse_E_link_ctn_new_elem(link_id);
 }
 
@@ -326,8 +327,6 @@ static void parse_E_route_store_route(void)
 {
   route_t route = xbt_new0(s_route_t, 1);
   route->link_list = link_list;
-//   xbt_assert1(generic_processing_units_exist(current_routing,src),"the \"%s\" processing units gateway does not exist",src);
-//   xbt_assert1(generic_processing_units_exist(current_routing,dst),"the \"%s\" processing units gateway does not exist",dst);
   xbt_assert1(current_routing->set_route,
               "no defined method \"set_route\" in \"%s\"",
               current_routing->name);
@@ -346,10 +345,6 @@ static void parse_E_ASroute_store_route(void)
   e_route->generic_route.link_list = link_list;
   e_route->src_gateway = xbt_strdup(gw_src);
   e_route->dst_gateway = xbt_strdup(gw_dst);
-//   xbt_assert1(generic_autonomous_system_exist(current_routing,src),"the \"%s\" autonomous system does not exist",src);
-//   xbt_assert1(generic_autonomous_system_exist(current_routing,dst),"the \"%s\" autonomous system does not exist",dst);
-//   xbt_assert1(generic_processing_units_exist(current_routing,gw_src),"the \"%s\" processing units gateway does not exist",gw_src);
-//   xbt_assert1(generic_processing_units_exist(current_routing,gw_dst),"the \"%s\" processing units gateway does not exist",gw_dst);
   xbt_assert1(current_routing->set_ASroute,
               "no defined method \"set_ASroute\" in \"%s\"",
               current_routing->name);
@@ -370,10 +365,6 @@ static void parse_E_bypassRoute_store_route(void)
   e_route->generic_route.link_list = link_list;
   e_route->src_gateway = xbt_strdup(gw_src);
   e_route->dst_gateway = xbt_strdup(gw_dst);
-//   xbt_assert1(generic_autonomous_system_exist(current_routing,src),"the \"%s\" autonomous system does not exist",src);
-//   xbt_assert1(generic_autonomous_system_exist(current_routing,dst),"the \"%s\" autonomous system does not exist",dst);
-//   xbt_assert1(generic_processing_units_exist(current_routing,gw_src),"the \"%s\" processing units gateway does not exist",gw_src);
-//   xbt_assert1(generic_processing_units_exist(current_routing,gw_dst),"the \"%s\" processing units gateway does not exist",gw_dst);
   xbt_assert1(current_routing->set_bypassroute,
               "no defined method \"set_bypassroute\" in \"%s\"",
               current_routing->name);
@@ -419,7 +410,6 @@ static void parse_S_AS(char *AS_id, char *AS_routing)
   new_routing->hierarchy = SURF_ROUTING_NULL;
   new_routing->name = xbt_strdup(AS_id);
   new_routing->routing_sons = xbt_dict_new();
-  //INFO2("Routing %s for AS %s",A_surfxml_AS_routing,A_surfxml_AS_id);
 
   if (current_routing == NULL && global_routing->root == NULL) {
 
@@ -723,7 +713,8 @@ static route_extended_t _get_route(const char *src, const char *dst)
  * \param dst the destination host name
  * 
  * 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 the differents "get_route" functions in each routing component.
+ * No need to free the returned dynar. It will be freed at the next call.
  */
 static xbt_dynar_t get_route(const char *src, const char *dst)
 {
@@ -758,6 +749,23 @@ static xbt_dynar_t get_route(const char *src, const char *dst)
     return global_routing->last_route;
 }
 
+/**
+ * \brief Generic method: find a route between hosts
+ *
+ * \param src the source host name
+ * \param dst the destination host name
+ *
+ * walk through the routing components tree and find a route between hosts
+ * by calling the differents "get_route" functions in each routing component.
+ * Leaves the caller the responsability to clean the returned dynar.
+ */
+static xbt_dynar_t get_route_no_cleanup(const char *src, const char *dst)
+{
+	xbt_dynar_t d = get_route(src,dst);
+	global_routing->last_route = NULL;
+	return d;
+}
+
 /**
  * \brief Recursive function for finalize
  *
@@ -857,12 +865,13 @@ void routing_model_create(size_t size_of_links, void *loopback)
   global_routing->where_network_elements = xbt_dict_new();
   global_routing->root = NULL;
   global_routing->get_route = get_route;
+  global_routing->get_route_no_cleanup = get_route_no_cleanup;
   global_routing->get_onelink_routes = get_onelink_routes;
   global_routing->get_network_element_type = get_network_element_type;
   global_routing->finalize = finalize;
   global_routing->loopback = loopback;
   global_routing->size_of_link = size_of_links;
-  global_routing->last_route = xbt_dynar_new(size_of_links, NULL);
+  global_routing->last_route = NULL;
 
   /* no current routing at moment */
   current_routing = NULL;
@@ -892,9 +901,12 @@ void routing_model_create(size_t size_of_links, void *loopback)
   surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS_XML);
 
   surfxml_add_callback(STag_surfxml_cluster_cb_list,
-                       &routing_full_parse_Scluster);
+                       &routing_parse_Scluster);
 
-  surfxml_add_callback(STag_surfxml_config_cb_list, &parse_Sconfig);
+  surfxml_add_callback(STag_surfxml_config_cb_list,
+					   &routing_parse_Sconfig);
+  surfxml_add_callback(ETag_surfxml_config_cb_list,
+					   &routing_parse_Econfig);
 }
 
 /* ************************************************************************** */
@@ -906,9 +918,6 @@ void routing_model_create(size_t size_of_links, void *loopback)
 
 typedef struct {
   s_routing_component_t generic_routing;
-  xbt_dict_t parse_routes;      /* store data during the parse process */
-  xbt_dict_t to_index;          /* char* -> network_element_t */
-  xbt_dict_t bypassRoutes;
   route_extended_t *routing_table;
 } s_routing_component_full_t, *routing_component_full_t;
 
@@ -918,13 +927,13 @@ static xbt_dynar_t full_get_onelink_routes(routing_component_t rc)
   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
 
   routing_component_full_t routing = (routing_component_full_t) rc;
-  int table_size = xbt_dict_length(routing->to_index);
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
   xbt_dict_cursor_t c1 = NULL, c2 = NULL;
   char *k1, *d1, *k2, *d2;
-  xbt_dict_foreach(routing->to_index, c1, k1, d1) {
-    xbt_dict_foreach(routing->to_index, c2, k2, d2) {
-      int *src_id = xbt_dict_get_or_null(routing->to_index, k1);
-      int *dst_id = xbt_dict_get_or_null(routing->to_index, k2);
+  xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
+    xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
+      int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k1);
+      int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k2);
       xbt_assert2(src_id
                   && dst_id,
                   "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
@@ -963,11 +972,11 @@ static route_extended_t full_get_route(routing_component_t rc,
 
   /* set utils vars */
   routing_component_full_t routing = (routing_component_full_t) rc;
-  int table_size = xbt_dict_length(routing->to_index);
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
 
   generic_src_dst_check(rc, src, dst);
-  int *src_id = xbt_dict_get_or_null(routing->to_index, src);
-  int *dst_id = xbt_dict_get_or_null(routing->to_index, dst);
+  int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
+  int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
   xbt_assert2(src_id
               && dst_id,
               "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
@@ -996,7 +1005,7 @@ static route_extended_t full_get_route(routing_component_t rc,
 static void full_finalize(routing_component_t rc)
 {
   routing_component_full_t routing = (routing_component_full_t) rc;
-  int table_size = xbt_dict_length(routing->to_index);
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
   int i, j;
   if (routing) {
     /* Delete routing table */
@@ -1005,9 +1014,9 @@ static void full_finalize(routing_component_t rc)
         generic_free_extended_route(TO_ROUTE_FULL(i, j));
     xbt_free(routing->routing_table);
     /* Delete bypass dict */
-    xbt_dict_free(&routing->bypassRoutes);
+    xbt_dict_free(&rc->bypassRoutes);
     /* Delete index dict */
-    xbt_dict_free(&(routing->to_index));
+    xbt_dict_free(&rc->to_index);
     /* Delete structure */
     xbt_free(rc);
   }
@@ -1032,9 +1041,8 @@ static void *model_full_create(void)
   new_component->generic_routing.get_bypass_route =
       generic_get_bypassroute;
   new_component->generic_routing.finalize = full_finalize;
-  new_component->to_index = xbt_dict_new();
-  new_component->bypassRoutes = xbt_dict_new();
-  new_component->parse_routes = xbt_dict_new();
+  new_component->generic_routing.to_index = xbt_dict_new();
+  new_component->generic_routing.bypassRoutes = xbt_dict_new();
   return new_component;
 }
 
@@ -1050,47 +1058,21 @@ static void model_full_unload(void)
 
 static void model_full_end(void)
 {
-
-  char *key, *end;
-  const char *sep = "#";
-  int src_id, dst_id;
   unsigned int i, j;
-  route_t route;
   route_extended_t e_route;
-  void *data;
-
-  xbt_dict_cursor_t cursor = NULL;
-  xbt_dynar_t keys = NULL;
 
   /* set utils vars */
   routing_component_full_t routing =
       ((routing_component_full_t) current_routing);
-  int table_size = xbt_dict_length(routing->to_index);
-
-  /* Create the routing table */
-  routing->routing_table =
-      xbt_new0(route_extended_t, table_size * table_size);
-
-  /* Put the routes in position */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
-    keys = xbt_str_split_str(key, sep);
-    src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 10);
-    dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 10);
-    TO_ROUTE_FULL(src_id, dst_id) =
-        generic_new_extended_route(current_routing->hierarchy, data, 1);
-    xbt_dynar_free(&keys);
-  }
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
 
-  /* delete the parse table */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
-    route = (route_t) data;
-    xbt_dynar_free(&(route->link_list));
-    xbt_free(data);
+  /* Create table if necessary */
+  if(!routing->routing_table)
+  {
+	  routing->routing_table =
+		  xbt_new0(route_extended_t, table_size * table_size);
   }
 
-  /* delete parse dict */
-  xbt_dict_free(&(routing->parse_routes));
-
   /* Add the loopback if needed */
   if (current_routing->hierarchy == SURF_ROUTING_BASE) {
     for (i = 0; i < table_size; i++) {
@@ -1129,10 +1111,6 @@ typedef struct {
   /* vars for calculate the floyd algorith. */
   int *predecessor_table;
   route_extended_t *link_table; /* char* -> int* */
-  xbt_dict_t to_index;
-  xbt_dict_t bypassRoutes;
-  /* store data during the parse process */
-  xbt_dict_t parse_routes;
 } s_routing_component_floyd_t, *routing_component_floyd_t;
 
 static route_extended_t floyd_get_route(routing_component_t rc,
@@ -1144,11 +1122,11 @@ static xbt_dynar_t floyd_get_onelink_routes(routing_component_t rc)
   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
 
   routing_component_floyd_t routing = (routing_component_floyd_t) rc;
-  //int table_size = xbt_dict_length(routing->to_index);
+  //size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
   xbt_dict_cursor_t c1 = NULL, c2 = NULL;
   char *k1, *d1, *k2, *d2;
-  xbt_dict_foreach(routing->to_index, c1, k1, d1) {
-    xbt_dict_foreach(routing->to_index, c2, k2, d2) {
+  xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
+    xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
       route_extended_t route = floyd_get_route(rc, k1, k2);
       if (route) {
         if (xbt_dynar_length(route->generic_route.link_list) == 1) {
@@ -1183,11 +1161,11 @@ static route_extended_t floyd_get_route(routing_component_t rc,
 
   /* set utils vars */
   routing_component_floyd_t routing = (routing_component_floyd_t) rc;
-  int table_size = xbt_dict_length(routing->to_index);
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
 
   generic_src_dst_check(rc, src, dst);
-  int *src_id = xbt_dict_get_or_null(routing->to_index, src);
-  int *dst_id = xbt_dict_get_or_null(routing->to_index, dst);
+  int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
+  int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
   xbt_assert2(src_id
               && dst_id,
               "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
@@ -1264,18 +1242,19 @@ static route_extended_t floyd_get_route(routing_component_t rc,
 static void floyd_finalize(routing_component_t rc)
 {
   routing_component_floyd_t routing = (routing_component_floyd_t) rc;
-  int i, j, table_size;
+  int i, j;
+  size_t table_size;
   if (routing) {
-    table_size = xbt_dict_length(routing->to_index);
+    table_size = xbt_dict_length(routing->generic_routing.to_index);
     /* Delete link_table */
     for (i = 0; i < table_size; i++)
       for (j = 0; j < table_size; j++)
         generic_free_extended_route(TO_FLOYD_LINK(i, j));
     xbt_free(routing->link_table);
     /* Delete bypass dict */
-    xbt_dict_free(&routing->bypassRoutes);
+    xbt_dict_free(&routing->generic_routing.bypassRoutes);
     /* Delete index dict */
-    xbt_dict_free(&(routing->to_index));
+    xbt_dict_free(&(routing->generic_routing.to_index));
     /* Delete dictionary index dict, predecessor and links table */
     xbt_free(routing->predecessor_table);
     /* Delete structure */
@@ -1300,9 +1279,9 @@ static void *model_floyd_create(void)
   new_component->generic_routing.get_bypass_route =
       generic_get_bypassroute;
   new_component->generic_routing.finalize = floyd_finalize;
-  new_component->to_index = xbt_dict_new();
-  new_component->bypassRoutes = xbt_dict_new();
-  new_component->parse_routes = xbt_dict_new();
+  new_component->generic_routing.to_index = xbt_dict_new();
+  new_component->generic_routing.bypassRoutes = xbt_dict_new();
+  new_component->generic_routing.parse_routes = xbt_dict_new();
   return new_component;
 }
 
@@ -1330,7 +1309,7 @@ static void model_floyd_end(void)
   unsigned int i, j, a, b, c;
 
   /* set the size of inicial table */
-  int table_size = xbt_dict_length(routing->to_index);
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
 
   /* Create Cost, Predecessor and Link tables */
   cost_table = xbt_new0(double, table_size * table_size);       /* link cost from host to host */
@@ -1346,7 +1325,7 @@ static void model_floyd_end(void)
     }
 
   /* Put the routes in position */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
+  xbt_dict_foreach(routing->generic_routing.parse_routes, cursor, key, data) {
     keys = xbt_str_split_str(key, sep);
     src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 10);
     dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 10);
@@ -1394,14 +1373,14 @@ static void model_floyd_end(void)
   }
 
   /* delete the parse table */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
+  xbt_dict_foreach(routing->generic_routing.parse_routes, cursor, key, data) {
     route_t route = (route_t) data;
     xbt_dynar_free(&(route->link_list));
     xbt_free(data);
   }
 
   /* delete parse dict */
-  xbt_dict_free(&(routing->parse_routes));
+  xbt_dict_free(&(routing->generic_routing.parse_routes));
 
   /* cleanup */
   xbt_free(cost_table);
@@ -1412,13 +1391,10 @@ static void model_floyd_end(void)
 
 typedef struct {
   s_routing_component_t generic_routing;
-  xbt_dict_t to_index;
-  xbt_dict_t bypassRoutes;
   xbt_graph_t route_graph;      /* xbt_graph */
   xbt_dict_t graph_node_map;    /* map */
   xbt_dict_t route_cache;       /* use in cache mode */
   int cached;
-  xbt_dict_t parse_routes;
 } s_routing_component_dijkstra_t, *routing_component_dijkstra_t;
 
 
@@ -1597,8 +1573,8 @@ static route_extended_t dijkstra_get_route(routing_component_t rc,
   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
 
   generic_src_dst_check(rc, src, dst);
-  int *src_id = xbt_dict_get_or_null(routing->to_index, src);
-  int *dst_id = xbt_dict_get_or_null(routing->to_index, dst);
+  int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
+  int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
   xbt_assert2(src_id
               && dst_id,
               "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
@@ -1804,9 +1780,9 @@ static void dijkstra_finalize(routing_component_t rc)
     if (routing->cached)
       xbt_dict_free(&routing->route_cache);
     /* Delete bypass dict */
-    xbt_dict_free(&routing->bypassRoutes);
+    xbt_dict_free(&routing->generic_routing.bypassRoutes);
     /* Delete index dict */
-    xbt_dict_free(&(routing->to_index));
+    xbt_dict_free(&(routing->generic_routing.to_index));
     /* Delete structure */
     xbt_free(routing);
   }
@@ -1832,9 +1808,9 @@ static void *model_dijkstra_both_create(int cached)
       generic_get_bypassroute;
   new_component->generic_routing.finalize = dijkstra_finalize;
   new_component->cached = cached;
-  new_component->to_index = xbt_dict_new();
-  new_component->bypassRoutes = xbt_dict_new();
-  new_component->parse_routes = xbt_dict_new();
+  new_component->generic_routing.to_index = xbt_dict_new();
+  new_component->generic_routing.bypassRoutes = xbt_dict_new();
+  new_component->generic_routing.parse_routes = xbt_dict_new();
   return new_component;
 }
 
@@ -1880,7 +1856,7 @@ static void model_dijkstra_both_end(void)
     routing->route_cache = xbt_dict_new();
 
   /* Put the routes in position */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
+  xbt_dict_foreach(routing->generic_routing.parse_routes, cursor, key, data) {
     keys = xbt_str_split_str(key, sep);
     src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 10);
     dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 10);
@@ -1891,14 +1867,14 @@ static void model_dijkstra_both_end(void)
   }
 
   /* delete the parse table */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
+  xbt_dict_foreach(routing->generic_routing.parse_routes, cursor, key, data) {
     route = (route_t) data;
     xbt_dynar_free(&(route->link_list));
     xbt_free(data);
   }
 
   /* delete parse dict */
-  xbt_dict_free(&(routing->parse_routes));
+  xbt_dict_free(&(routing->generic_routing.parse_routes));
 
   /* Add the loopback if needed */
   if (current_routing->hierarchy == SURF_ROUTING_BASE)
@@ -2309,18 +2285,15 @@ static void *model_rulebased_create(void)
       model_rulebased_set_autonomous_system;
   new_component->generic_routing.set_route = model_rulebased_set_route;
   new_component->generic_routing.set_ASroute = model_rulebased_set_ASroute;
-  new_component->generic_routing.set_bypassroute =
-      model_rulebased_set_bypassroute;
-  new_component->generic_routing.get_onelink_routes =
-      rulebased_get_onelink_routes;
+  new_component->generic_routing.set_bypassroute = model_rulebased_set_bypassroute;
+  new_component->generic_routing.get_onelink_routes = rulebased_get_onelink_routes;
   new_component->generic_routing.get_route = rulebased_get_route;
-  new_component->generic_routing.get_bypass_route = NULL;       //rulebased_get_bypass_route;
+  new_component->generic_routing.get_bypass_route = generic_get_bypassroute;       //rulebased_get_bypass_route;
   new_component->generic_routing.finalize = rulebased_finalize;
   /* initialization of internal structures */
   new_component->dict_processing_units = xbt_dict_new();
   new_component->dict_autonomous_systems = xbt_dict_new();
-  new_component->list_route =
-      xbt_dynar_new(sizeof(rule_route_t), &rule_route_free);
+  new_component->list_route = xbt_dynar_new(sizeof(rule_route_t), &rule_route_free);
   new_component->list_ASroute =
       xbt_dynar_new(sizeof(rule_route_extended_t),
                     &rule_route_extended_free);
@@ -2467,21 +2440,9 @@ static void generic_set_processing_unit(routing_component_t rc,
                                         const char *name)
 {
   DEBUG1("Load process unit \"%s\"", name);
-  model_type_t modeltype = rc->routing;
   int *id = xbt_new0(int, 1);
   xbt_dict_t _to_index;
-  if (modeltype == &routing_models[SURF_MODEL_FULL])
-    _to_index = ((routing_component_full_t) rc)->to_index;
-
-  else if (modeltype == &routing_models[SURF_MODEL_FLOYD])
-    _to_index = ((routing_component_floyd_t) rc)->to_index;
-
-  else if (modeltype == &routing_models[SURF_MODEL_DIJKSTRA] ||
-           modeltype == &routing_models[SURF_MODEL_DIJKSTRACACHE])
-    _to_index = ((routing_component_dijkstra_t) rc)->to_index;
-
-  else
-    xbt_die("\"generic_set_processing_unit\" not supported");
+  _to_index = current_routing->to_index;
   *id = xbt_dict_length(_to_index);
   xbt_dict_set(_to_index, name, id, xbt_free);
 }
@@ -2490,21 +2451,9 @@ static void generic_set_autonomous_system(routing_component_t rc,
                                           const char *name)
 {
   DEBUG1("Load Autonomous system \"%s\"", name);
-  model_type_t modeltype = rc->routing;
   int *id = xbt_new0(int, 1);
   xbt_dict_t _to_index;
-  if (modeltype == &routing_models[SURF_MODEL_FULL])
-    _to_index = ((routing_component_full_t) rc)->to_index;
-
-  else if (modeltype == &routing_models[SURF_MODEL_FLOYD])
-    _to_index = ((routing_component_floyd_t) rc)->to_index;
-
-  else if (modeltype == &routing_models[SURF_MODEL_DIJKSTRA] ||
-           modeltype == &routing_models[SURF_MODEL_DIJKSTRACACHE])
-    _to_index = ((routing_component_dijkstra_t) rc)->to_index;
-
-  else
-    xbt_die("\"generic_set_autonomous_system\" not supported");
+  _to_index = current_routing->to_index;
   *id = xbt_dict_length(_to_index);
   xbt_dict_set(_to_index, name, id, xbt_free);
 }
@@ -2513,44 +2462,88 @@ static void generic_set_route(routing_component_t rc, const char *src,
                               const char *dst, route_t route)
 {
   DEBUG2("Load Route from \"%s\" to \"%s\"", src, dst);
-  model_type_t modeltype = rc->routing;
   xbt_dict_t _parse_routes;
   xbt_dict_t _to_index;
   char *route_name;
   int *src_id, *dst_id;
+  unsigned long nb_links = xbt_dynar_length(route->link_list);
 
-  if (modeltype == &routing_models[SURF_MODEL_FULL]) {
-    _parse_routes = ((routing_component_full_t) rc)->parse_routes;
-    _to_index = ((routing_component_full_t) rc)->to_index;
-
-  } else if (modeltype == &routing_models[SURF_MODEL_FLOYD]) {
-    _parse_routes = ((routing_component_floyd_t) rc)->parse_routes;
-    _to_index = ((routing_component_floyd_t) rc)->to_index;
-
-  } else if (modeltype == &routing_models[SURF_MODEL_DIJKSTRA] ||
-             modeltype == &routing_models[SURF_MODEL_DIJKSTRACACHE]) {
-    _parse_routes = ((routing_component_dijkstra_t) rc)->parse_routes;
-    _to_index = ((routing_component_dijkstra_t) rc)->to_index;
-
-  } else
-    xbt_die("\"generic_set_route\" not supported");
-
+  _to_index = current_routing->to_index;
+  _parse_routes = current_routing->parse_routes;
   src_id = xbt_dict_get_or_null(_to_index, src);
   dst_id = xbt_dict_get_or_null(_to_index, dst);
+  routing_component_full_t routing = ((routing_component_full_t) current_routing);
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+  route_t route_to_test;
 
   xbt_assert2(src_id
               && dst_id, "Network elements %s or %s not found", src, dst);
-  route_name = bprintf("%d#%d", *src_id, *dst_id);
 
   xbt_assert2(xbt_dynar_length(route->link_list) > 0,
               "Invalid count of links, must be greater than zero (%s,%s)",
               src, dst);
-  xbt_assert2(!xbt_dict_get_or_null(_parse_routes, route_name),
-              "The route between \"%s\" and \"%s\" already exist", src,
-              dst);
 
-  xbt_dict_set(_parse_routes, route_name, route, NULL);
-  xbt_free(route_name);
+  if(!strcmp(rc->routing->name,"Full"))
+  {
+	  /* Create the routing table */
+	  if(!routing->routing_table)
+		  routing->routing_table = xbt_new0(route_extended_t, table_size * table_size);
+
+	  route_to_test = &(TO_ROUTE_FULL(*src_id, *dst_id))->generic_route;
+  }
+  else
+	  route_to_test = xbt_dict_get_or_null(_parse_routes, route_name);
+
+  if(route_to_test)
+  xbt_assert2(!xbt_dynar_compare(
+		  (void*)route->link_list,
+		  (void*)route_to_test->link_list,
+		  (int_f_cpvoid_cpvoid_t) strcmp),
+	  "The route between \"%s\" and \"%s\" already exist", src,dst);
+
+  if(!strcmp(rc->routing->name,"Full"))
+  {
+	  TO_ROUTE_FULL(*src_id, *dst_id) =
+	        generic_new_extended_route(current_routing->hierarchy, route, 1);
+  }
+  else
+  {
+	  route_name = bprintf("%d#%d", *src_id, *dst_id);
+	  xbt_dict_set(_parse_routes, route_name, route, NULL);
+	  xbt_free(route_name);
+  }
+
+  if(A_surfxml_route_symetrical == A_surfxml_route_symetrical_YES)
+  {
+	  int i;
+	  route_t route_sym = xbt_new0(s_route_t, 1);
+	  route_sym->link_list = xbt_dynar_new(sizeof(char *),NULL);
+	  for(i=nb_links ; i>0 ; i--)
+	  {
+		 char *link_name = xbt_new0(char,strlen(xbt_dynar_get_as(route->link_list, i-1, char *)));
+		 link_name = xbt_strdup(xbt_dynar_get_as(route->link_list, i-1, char *));
+		 xbt_dynar_push_as(route_sym->link_list ,char *, link_name);
+	  }
+	  DEBUG2("Load Route from \"%s\" to \"%s\"", dst, src);
+
+	  if(!strcmp(rc->routing->name,"Full"))
+	  {
+		  TO_ROUTE_FULL(*dst_id, *src_id) =
+				generic_new_extended_route(current_routing->hierarchy, route_sym, 1);
+	  }
+	  else
+	  {
+		  route_to_test = xbt_dict_get_or_null(_parse_routes, bprintf("%d#%d",*dst_id, *src_id));
+		  if(route_to_test)
+		  xbt_assert2(!xbt_dynar_compare(
+				  (void*)route_sym->link_list,
+				  (void*)route_to_test->link_list,
+				  (int_f_cpvoid_cpvoid_t) strcmp),
+			  "The route between \"%s\" and \"%s\" already exist", dst,src);
+
+		  xbt_dict_set(_parse_routes, bprintf("%d#%d",*dst_id, *src_id), route_sym, NULL);
+	  }
+  }
 }
 
 static void generic_set_ASroute(routing_component_t rc, const char *src,
@@ -2558,44 +2551,95 @@ static void generic_set_ASroute(routing_component_t rc, const char *src,
 {
   DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
          e_route->src_gateway, dst, e_route->dst_gateway);
-  model_type_t modeltype = rc->routing;
+
   xbt_dict_t _parse_routes;
   xbt_dict_t _to_index;
   char *route_name;
   int *src_id, *dst_id;
-
-  if (modeltype == &routing_models[SURF_MODEL_FULL]) {
-    _parse_routes = ((routing_component_full_t) rc)->parse_routes;
-    _to_index = ((routing_component_full_t) rc)->to_index;
-
-  } else if (modeltype == &routing_models[SURF_MODEL_FLOYD]) {
-    _parse_routes = ((routing_component_floyd_t) rc)->parse_routes;
-    _to_index = ((routing_component_floyd_t) rc)->to_index;
-
-  } else if (modeltype == &routing_models[SURF_MODEL_DIJKSTRA] ||
-             modeltype == &routing_models[SURF_MODEL_DIJKSTRACACHE]) {
-    _parse_routes = ((routing_component_dijkstra_t) rc)->parse_routes;
-    _to_index = ((routing_component_dijkstra_t) rc)->to_index;
-
-  } else
-    xbt_die("\"generic_set_route\" not supported");
+  _to_index = current_routing->to_index;
+  _parse_routes = current_routing->parse_routes;
 
   src_id = xbt_dict_get_or_null(_to_index, src);
   dst_id = xbt_dict_get_or_null(_to_index, dst);
+  routing_component_full_t routing = ((routing_component_full_t) current_routing);
+  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+  route_t route_to_test;
 
   xbt_assert2(src_id
               && dst_id, "Network elements %s or %s not found", src, dst);
-  route_name = bprintf("%d#%d", *src_id, *dst_id);
 
   xbt_assert2(xbt_dynar_length(e_route->generic_route.link_list) > 0,
               "Invalid count of links, must be greater than zero (%s,%s)",
               src, dst);
-  xbt_assert4(!xbt_dict_get_or_null(_parse_routes, route_name),
-              "The route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exist",
-              src, e_route->src_gateway, dst, e_route->dst_gateway);
 
+  if(!strcmp(rc->routing->name,"Full"))
+  {
+	  /* Create the routing table */
+	  if(!routing->routing_table)
+		  routing->routing_table =  xbt_new0(route_extended_t, table_size * table_size);
+
+	  route_to_test = &((route_extended_t)(TO_ROUTE_FULL(*src_id, *dst_id)))->generic_route;
+  }
+  else
+	  route_to_test = xbt_dict_get_or_null(_parse_routes, route_name);
+
+  if(route_to_test)
+  xbt_assert4(!xbt_dynar_compare(
+		  (void*) (&e_route->generic_route)->link_list,
+		  (void*) route_to_test->link_list,
+		  (int_f_cpvoid_cpvoid_t) strcmp),
+		  "The route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exist",
+		                src, e_route->src_gateway, dst, e_route->dst_gateway);
+
+  if(!strcmp(rc->routing->name,"Full"))
+  {
+	  TO_ROUTE_FULL(*src_id, *dst_id) =
+			  generic_new_extended_route(current_routing->hierarchy, &(e_route->generic_route), 1);
+  }
+  else
+  {
+  route_name = bprintf("%d#%d", *src_id, *dst_id);
   xbt_dict_set(_parse_routes, route_name, e_route, NULL);
   xbt_free(route_name);
+  }
+
+  unsigned long nb_links = xbt_dynar_length(e_route->generic_route.link_list);
+
+  if(A_surfxml_ASroute_symetrical == A_surfxml_ASroute_symetrical_YES)
+  {
+	  int i;
+	  route_extended_t route_sym = xbt_new0(s_route_extended_t, 1);
+	  route_sym->generic_route.link_list = xbt_dynar_new(sizeof(char *),NULL);
+	  for(i=nb_links ; i>0 ; i--)
+	  {
+		 char *link_name = xbt_new0(char,strlen(xbt_dynar_get_as(e_route->generic_route.link_list, i-1, char *)));
+		 link_name = bprintf("%s",xbt_dynar_get_as(e_route->generic_route.link_list, i-1, char *));
+		 xbt_dynar_push_as(route_sym->generic_route.link_list ,char *, link_name);
+	  }
+	  route_sym->src_gateway = xbt_new0( char,strlen(e_route->dst_gateway) );
+	  route_sym->src_gateway = bprintf("%s",e_route->dst_gateway);
+	  route_sym->dst_gateway = xbt_new0( char,strlen(e_route->src_gateway) );
+	  route_sym->dst_gateway = bprintf("%s",e_route->src_gateway);
+	  DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",dst, route_sym->src_gateway,src,route_sym->dst_gateway);
+
+	  if(!strcmp(rc->routing->name,"Full"))
+	  {
+		  TO_ROUTE_FULL(*dst_id, *src_id) =
+				generic_new_extended_route(current_routing->hierarchy, &(route_sym->generic_route), 1);
+	  }
+	  else
+	  {
+		  route_to_test = xbt_dict_get_or_null(_parse_routes, bprintf("%d#%d", *dst_id, *src_id));
+		  if(route_to_test)
+		  xbt_assert4(!xbt_dynar_compare(
+				  (void*) (&route_sym->generic_route)->link_list,
+				  (void*) route_to_test->link_list,
+				  (int_f_cpvoid_cpvoid_t) strcmp),
+				  "The route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exist",
+								  dst, route_sym->src_gateway, src, route_sym->dst_gateway);
+		  xbt_dict_set(_parse_routes, bprintf("%d#%d", *dst_id, *src_id), route_sym, NULL);
+	  }
+   }
 }
 
 static void generic_set_bypassroute(routing_component_t rc,
@@ -2603,18 +2647,9 @@ static void generic_set_bypassroute(routing_component_t rc,
                                     route_extended_t e_route)
 {
   DEBUG2("Load bypassRoute from \"%s\" to \"%s\"", src, dst);
-  model_type_t modeltype = rc->routing;
-  xbt_dict_t dict_bypassRoutes;
+  xbt_dict_t dict_bypassRoutes = rc->bypassRoutes;
   char *route_name;
-  if (modeltype == &routing_models[SURF_MODEL_FULL]) {
-    dict_bypassRoutes = ((routing_component_full_t) rc)->bypassRoutes;
-  } else if (modeltype == &routing_models[SURF_MODEL_FLOYD]) {
-    dict_bypassRoutes = ((routing_component_floyd_t) rc)->bypassRoutes;
-  } else if (modeltype == &routing_models[SURF_MODEL_DIJKSTRA] ||
-             modeltype == &routing_models[SURF_MODEL_DIJKSTRACACHE]) {
-    dict_bypassRoutes = ((routing_component_dijkstra_t) rc)->bypassRoutes;
-  } else
-    xbt_die("\"generic_set_bypassroute\" not supported");
+
   route_name = bprintf("%s#%s", src, dst);
   xbt_assert2(xbt_dynar_length(e_route->generic_route.link_list) > 0,
               "Invalid count of links, must be greater than zero (%s,%s)",
@@ -2645,20 +2680,7 @@ static route_extended_t generic_get_bypassroute(routing_component_t rc,
                                                 const char *src,
                                                 const char *dst)
 {
-  model_type_t modeltype = rc->routing;
-  xbt_dict_t dict_bypassRoutes;
-
-  if (modeltype == &routing_models[SURF_MODEL_FULL]) {
-    dict_bypassRoutes = ((routing_component_full_t) rc)->bypassRoutes;
-  } else if (modeltype == &routing_models[SURF_MODEL_FLOYD]) {
-    dict_bypassRoutes = ((routing_component_floyd_t) rc)->bypassRoutes;
-  } else if (modeltype == &routing_models[SURF_MODEL_DIJKSTRA] ||
-             modeltype == &routing_models[SURF_MODEL_DIJKSTRACACHE]) {
-    dict_bypassRoutes = ((routing_component_dijkstra_t) rc)->bypassRoutes;
-  } else
-    xbt_die("\"generic_get_bypassroute\" not supported");
-
-
+  xbt_dict_t dict_bypassRoutes = rc->bypassRoutes;
   routing_component_t src_as, dst_as;
   int index_src, index_dst;
   xbt_dynar_t path_src = NULL;
@@ -2799,7 +2821,7 @@ generic_new_extended_route(e_surf_routing_hierarchy_t hierarchy,
   route_extended_t e_route, new_e_route;
   route_t route;
   unsigned int cpt;
-  xbt_dynar_t links, links_id;
+  xbt_dynar_t links = NULL, links_id = NULL;
 
   new_e_route = xbt_new0(s_route_extended_t, 1);
   new_e_route->generic_route.link_list =
@@ -2950,13 +2972,25 @@ static void generic_src_dst_check(routing_component_t rc, const char *src,
               rc->name, dst_as->name);
 }
 
-static void parse_Sconfig(void)
+static void routing_parse_Sconfig(void)
 {
   //TODO
   DEBUG0("WARNING tag config not yet implemented.");
+  DEBUG1("Configuration name = %s",A_surfxml_config_id);
+}
+
+static void routing_parse_Econfig(void)
+{
+  //TODO
+  xbt_dict_cursor_t cursor = NULL;
+  char *key;
+  char *elem;
+  xbt_dict_foreach(current_property_set, cursor, key, elem) {
+	  DEBUG2("property : %s = %s",key,elem);
+	}
 }
 
-static void routing_full_parse_Scluster(void)
+static void routing_parse_Scluster(void)
 {
   static int AX_ptr = 0;
 
@@ -2969,12 +3003,15 @@ static void routing_full_parse_Scluster(void)
   char *cluster_lat = A_surfxml_cluster_lat;
   char *cluster_bb_bw = A_surfxml_cluster_bb_bw;
   char *cluster_bb_lat = A_surfxml_cluster_bb_lat;
-  char *host_id, *groups, *link_id;
+  char *host_id, *groups, *link_id = NULL;
   char *router_id, *link_router, *link_backbone, *route_src_dst;
   unsigned int iter;
   int start, end, i;
   xbt_dynar_t radical_elements;
   xbt_dynar_t radical_ends;
+  int cluster_sharing_policy = AX_surfxml_cluster_sharing_policy;
+  int cluster_bb_sharing_policy = AX_surfxml_cluster_bb_sharing_policy;
+
 #ifndef HAVE_PCRE_LIB
   xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL);
   char *route_src, *route_dst;
@@ -3012,25 +3049,28 @@ static void routing_full_parse_Scluster(void)
       link_id = bprintf("%s_link_%d", cluster_id, start);
 
       DEBUG2("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, cluster_power);
+      A_surfxml_host_state = A_surfxml_host_state_ON;
       SURFXML_BUFFER_SET(host_id, host_id);
       SURFXML_BUFFER_SET(host_power, cluster_power);
       SURFXML_BUFFER_SET(host_availability, "1.0");
       SURFXML_BUFFER_SET(host_availability_file, "");
-      A_surfxml_host_state = A_surfxml_host_state_ON;
       SURFXML_BUFFER_SET(host_state_file, "");
       SURFXML_START_TAG(host);
       SURFXML_END_TAG(host);
 
-      DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,
-             cluster_bw, cluster_lat);
+      DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,cluster_bw, cluster_lat);
+      A_surfxml_link_state = A_surfxml_link_state_ON;
+      A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+      if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+	  {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
+      if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
+	  {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
       SURFXML_BUFFER_SET(link_id, link_id);
       SURFXML_BUFFER_SET(link_bandwidth, cluster_bw);
       SURFXML_BUFFER_SET(link_latency, cluster_lat);
       SURFXML_BUFFER_SET(link_bandwidth_file, "");
       SURFXML_BUFFER_SET(link_latency_file, "");
-      A_surfxml_link_state = A_surfxml_link_state_ON;
       SURFXML_BUFFER_SET(link_state_file, "");
-      A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
       SURFXML_START_TAG(link);
       SURFXML_END_TAG(link);
 
@@ -3050,26 +3090,28 @@ static void routing_full_parse_Scluster(void)
         link_id = bprintf("%s_link_%d", cluster_id, i);
 
         DEBUG2("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, cluster_power);
+        A_surfxml_host_state = A_surfxml_host_state_ON;
         SURFXML_BUFFER_SET(host_id, host_id);
         SURFXML_BUFFER_SET(host_power, cluster_power);
         SURFXML_BUFFER_SET(host_availability, "1.0");
         SURFXML_BUFFER_SET(host_availability_file, "");
-        A_surfxml_host_state = A_surfxml_host_state_ON;
         SURFXML_BUFFER_SET(host_state_file, "");
         SURFXML_START_TAG(host);
         SURFXML_END_TAG(host);
 
-        DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,
-               cluster_bw, cluster_lat);
+        DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,cluster_bw, cluster_lat);
+        A_surfxml_link_state = A_surfxml_link_state_ON;
+        A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+        if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+  	    {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
+        if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
+  	    {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
         SURFXML_BUFFER_SET(link_id, link_id);
         SURFXML_BUFFER_SET(link_bandwidth, cluster_bw);
         SURFXML_BUFFER_SET(link_latency, cluster_lat);
         SURFXML_BUFFER_SET(link_bandwidth_file, "");
         SURFXML_BUFFER_SET(link_latency_file, "");
-        A_surfxml_link_state = A_surfxml_link_state_ON;
         SURFXML_BUFFER_SET(link_state_file, "");
-        A_surfxml_link_sharing_policy =
-            A_surfxml_link_sharing_policy_SHARED;
         SURFXML_START_TAG(link);
         SURFXML_END_TAG(link);
       }
@@ -3094,29 +3136,33 @@ static void routing_full_parse_Scluster(void)
   SURFXML_START_TAG(router);
   SURFXML_END_TAG(router);
 
-  DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_router,
-         cluster_bw, cluster_lat);
+  DEBUG3("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_router,cluster_bw, cluster_lat);
+  A_surfxml_link_state = A_surfxml_link_state_ON;
+  A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+  if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+  {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
+  if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
+  {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
   SURFXML_BUFFER_SET(link_id, link_router);
   SURFXML_BUFFER_SET(link_bandwidth, cluster_bw);
   SURFXML_BUFFER_SET(link_latency, cluster_lat);
   SURFXML_BUFFER_SET(link_bandwidth_file, "");
   SURFXML_BUFFER_SET(link_latency_file, "");
-  A_surfxml_link_state = A_surfxml_link_state_ON;
   SURFXML_BUFFER_SET(link_state_file, "");
-  A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
   SURFXML_START_TAG(link);
   SURFXML_END_TAG(link);
 
-  DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_backbone,
-         cluster_bb_bw, cluster_bb_lat);
+  DEBUG3("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_backbone,cluster_bw, cluster_lat);
+  A_surfxml_link_state = A_surfxml_link_state_ON;
+  A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+  if(cluster_bb_sharing_policy == A_surfxml_cluster_bb_sharing_policy_FATPIPE)
+  {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
   SURFXML_BUFFER_SET(link_id, link_backbone);
   SURFXML_BUFFER_SET(link_bandwidth, cluster_bb_bw);
   SURFXML_BUFFER_SET(link_latency, cluster_bb_lat);
   SURFXML_BUFFER_SET(link_bandwidth_file, "");
   SURFXML_BUFFER_SET(link_latency_file, "");
-  A_surfxml_link_state = A_surfxml_link_state_ON;
   SURFXML_BUFFER_SET(link_state_file, "");
-  A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
   SURFXML_START_TAG(link);
   SURFXML_END_TAG(link);
 
@@ -3134,23 +3180,32 @@ static void routing_full_parse_Scluster(void)
 
 #ifdef HAVE_PCRE_LIB
 
-  DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\">", route_src_dst, route_src_dst);
+  DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src_dst, route_src_dst);
+  DEBUG0("symetrical=\"NO\">");
   SURFXML_BUFFER_SET(route_src, route_src_dst);
   SURFXML_BUFFER_SET(route_dst, route_src_dst);
+  A_surfxml_route_symetrical = A_surfxml_route_symetrical_NO;
   SURFXML_START_TAG(route);
 
-  DEBUG1("<link:ctn\tid=\"%s_link_$1src\"/>", cluster_id);
+  DEBUG1("<link_ctn\tid=\"%s_link_$1src\"/>", cluster_id);
   SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1src", cluster_id));
+  A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
+  if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+  {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
   SURFXML_START_TAG(link_ctn);
   SURFXML_END_TAG(link_ctn);
 
-  DEBUG1("<link:ctn\tid=\"%s_backbone\"/>", cluster_id);
+  DEBUG1("<link_ctn\tid=\"%s_backbone\"/>", cluster_id);
   SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone", cluster_id));
+  A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
   SURFXML_START_TAG(link_ctn);
   SURFXML_END_TAG(link_ctn);
 
-  DEBUG1("<link:ctn\tid=\"%s_link_$1dst\"/>", cluster_id);
+  DEBUG1("<link_ctn\tid=\"%s_link_$1dst\"/>", cluster_id);
   SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1dst", cluster_id));
+  A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
+  if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+  {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
   SURFXML_START_TAG(link_ctn);
   SURFXML_END_TAG(link_ctn);
 
@@ -3177,9 +3232,11 @@ static void routing_full_parse_Scluster(void)
                     cluster_suffix);
       }
 
-      DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\">", route_src, route_dst);
+      DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src, route_dst);
+      DEBUG0("symetrical=\"NO\">");
       SURFXML_BUFFER_SET(route_src, route_src);
       SURFXML_BUFFER_SET(route_dst, route_dst);
+      A_surfxml_route_symetrical = A_surfxml_route_symetrical_NO;
       SURFXML_START_TAG(route);
 
       if (i == xbt_dynar_length(tab_elements_num)) {
@@ -3198,18 +3255,25 @@ static void routing_full_parse_Scluster(void)
                     xbt_dynar_get_as(tab_elements_num, j, int));
       }
 
-      DEBUG1("<link:ctn\tid=\"%s\"/>", route_src);
+      DEBUG1("<link_ctn\tid=\"%s\"/>", route_src);
       SURFXML_BUFFER_SET(link_ctn_id, route_src);
+      A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
+      if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+      {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
       SURFXML_START_TAG(link_ctn);
       SURFXML_END_TAG(link_ctn);
 
-      DEBUG1("<link:ctn\tid=\"%s_backbone\"/>", cluster_id);
+      DEBUG1("<link_ctn\tid=\"%s_backbone\"/>", cluster_id);
       SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone", cluster_id));
+      A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
       SURFXML_START_TAG(link_ctn);
       SURFXML_END_TAG(link_ctn);
 
-      DEBUG1("<link:ctn\tid=\"%s\"/>", route_dst);
+      DEBUG1("<link_ctn\tid=\"%s\"/>", route_dst);
       SURFXML_BUFFER_SET(link_ctn_id, route_dst);
+      A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
+      if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+      {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
       SURFXML_START_TAG(link_ctn);
       SURFXML_END_TAG(link_ctn);