X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/139b7601ed472e04f353815a2f39f1bc2c7a9466..f780443504c3b73f0b9d1c58c6c5a21e2affce2d:/src/surf/surf_routing.c

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index bf7d22c6b5..b053b28ea9 100644
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -62,6 +62,7 @@ static void model_none_unload(void);    /* none routing model */
 static void model_none_end(void);       /* none routing model */
 
 static void routing_parse_Scluster(void);  /*cluster bypass */
+static void routing_parse_Speer(void);  	/*peer bypass */
 
 static void routing_parse_Sconfig(void);        /*config Tag */
 static void routing_parse_Econfig(void);        /*config Tag */
@@ -103,6 +104,8 @@ struct s_model_type routing_models[] = { {"Full",
 #ifdef HAVE_PCRE_LIB
 {"RuleBased", "Rule-Based routing data (...)", model_rulebased_create,
  model_rulebased_load, model_rulebased_unload, model_rulebased_end},
+{"Vivaldi", "Vivaldi routing", model_rulebased_create,
+  model_rulebased_load, model_rulebased_unload, model_rulebased_end},
 #endif
 {NULL, NULL, NULL, NULL, NULL, NULL}
 };
@@ -157,10 +160,54 @@ static const char *dst = NULL;        /* temporary store the destination name of
 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 */
+
+static xbt_dict_t coordinates = NULL;
+
+
+static double eculidean_dist_comp(int index, xbt_dynar_t src, xbt_dynar_t dst)
+{
+	double src_coord, dst_coord;
+
+	src_coord = atof(xbt_dynar_get_as(src, index, char *));
+	dst_coord = atof(xbt_dynar_get_as(dst, index, char *));
+
+	return (src_coord-dst_coord)*(src_coord-dst_coord);
+
+}
+
+static double vivaldi_get_link_latency (routing_component_t rc,
+																				const char *src, const char *dst)
+{
+  double euclidean_dist;
+  xbt_dynar_t src_ctn, dst_ctn;
+  src_ctn = xbt_dict_get(coordinates, src);
+  dst_ctn = xbt_dict_get(coordinates, dst);
+
+  euclidean_dist = sqrt (eculidean_dist_comp(0,src_ctn,dst_ctn)+eculidean_dist_comp(1,src_ctn,dst_ctn))
+  								+fabs(atof(xbt_dynar_get_as(src_ctn, 2, char *)))+fabs(atof(xbt_dynar_get_as(dst_ctn, 2, char *)));
+
+  xbt_assert2(euclidean_dist>=0, "Euclidean Dist is less than 0\"%s\" and \"%.2f\"", src, euclidean_dist);
+
+  return euclidean_dist;
+
+  /*
+  x = atof(xbt_dynar_get_as(src_ctn, 0, char *))-atof(xbt_dynar_get_as(dst_ctn, 0, char *));
+  y = atof(xbt_dynar_get_as(src_ctn, 1, char *));
+  h = atof(xbt_dynar_get_as(ctn, 2, char *));
+  sqrt((c1->x - c2->x) * (c1->x - c2->x) + (c1->y - c2->y) * (c1->y - c2->y)) + fabs(c1->h) + fabs(c2->h);
+
+	  if (strcmp(coord,"")) {
+  	xbt_dynar_t ctn = xbt_str_split_str(coord, " ");
+  	xbt_dynar_shrink(ctn,0);
+   	xbt_dict_set (coordinates,host_id,ctn,NULL);
+  }
+	*/
+}
+
 /**
  * \brief Add a "host" to the network element list
  */
-static void parse_S_host(char *host_id)
+static void parse_S_host(const char *host_id, const char* coord)
 {
   network_element_info_t info = NULL;
   if (current_routing->hierarchy == SURF_ROUTING_NULL)
@@ -177,7 +224,24 @@ static void parse_S_host(char *host_id)
   info->rc_component = current_routing;
   info->rc_type = SURF_NETWORK_ELEMENT_HOST;
   xbt_dict_set(global_routing->where_network_elements, host_id,
-               (void *) info, NULL);
+               (void *) info, xbt_free);
+
+  if (strcmp(coord,"")) {
+  	xbt_dynar_t ctn = xbt_str_split_str(coord, " ");
+  	xbt_dynar_shrink(ctn,0);
+   	xbt_dict_set (coordinates,host_id,ctn,NULL);
+  }
+}
+
+static void parse_E_host(void)
+{
+	 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);
+		}
 }
 
 /*
@@ -185,15 +249,19 @@ static void parse_S_host(char *host_id)
  */
 static void parse_S_host_XML(void)
 {
-  parse_S_host(A_surfxml_host_id);
+	parse_S_host(A_surfxml_host_id, A_surfxml_host_coordinates);
+}
+static void parse_E_host_XML(void)
+{
+	parse_E_host();
 }
 
 /*
  * \brief Add a host to the network element list from lua script
  */
-static void parse_S_host_lua(char *host_id)
+static void parse_S_host_lua(const char *host_id, const char *coord)
 {
-  parse_S_host(host_id);
+  parse_S_host(host_id, coord);
 }
 
 
@@ -220,10 +288,12 @@ static void parse_S_router(void)
   info->rc_component = current_routing;
   info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
   xbt_dict_set(global_routing->where_network_elements, A_surfxml_router_id,
-               (void *) info, NULL);
-#ifdef HAVE_TRACING
-  TRACE_surf_host_declaration(A_surfxml_router_id, 0);
-#endif
+               (void *) info, xbt_free);
+  if (strcmp(A_surfxml_router_coordinates,"")) {
+    	xbt_dynar_t ctn = xbt_str_split_str(A_surfxml_router_coordinates, " ");
+    	xbt_dynar_shrink(ctn,0);
+     	xbt_dict_set (coordinates,A_surfxml_router_id,ctn,NULL);
+  }
 }
 
 /**
@@ -301,7 +371,7 @@ static void parse_S_bypassRoute_new_and_endpoints(void)
 /**
  * \brief Set a new link on the actual list of link for a route or ASroute
  */
-static void parse_E_link_ctn_new_elem(char *link_id)
+static void parse_E_link_ctn_new_elem(const char *link_id)
 {
   char *val;
   val = xbt_strdup(link_id);
@@ -314,18 +384,24 @@ static void parse_E_link_ctn_new_elem(char *link_id)
 
 static void parse_E_link_ctn_new_elem_XML(void)
 {
-  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));
+  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) {
+    char *link_id = bprintf("%s_UP", A_surfxml_link_ctn_id);
+    parse_E_link_ctn_new_elem(link_id);
+    free(link_id);
+  }
+  if (A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_DOWN) {
+    char *link_id = bprintf("%s_DOWN", A_surfxml_link_ctn_id);
+    parse_E_link_ctn_new_elem(link_id);
+    free(link_id);
+  }
 }
 
 /**
  * \brief Set a new link on the actual list of link for a route or ASroute from lua
  */
-static void parse_E_link_c_ctn_new_elem_lua(char *link_id)
+static void parse_E_link_c_ctn_new_elem_lua(const char *link_id)
 {
   parse_E_link_ctn_new_elem(link_id);
 }
@@ -421,6 +497,10 @@ static void parse_S_AS(char *AS_id, char *AS_routing)
   new_routing->name = xbt_strdup(AS_id);
   new_routing->routing_sons = xbt_dict_new();
 
+  /* Hack for Vivaldi */
+  if(!strcmp(model->name,"Vivaldi"))
+  	new_routing->get_latency = vivaldi_get_link_latency;
+
   if (current_routing == NULL && global_routing->root == NULL) {
 
     /* it is the first one */
@@ -477,7 +557,7 @@ static void parse_S_AS_lua(char *id, char *mode)
  * When you finish to read the routing component, other structures must be created. 
  * the "end" method allow to do that for any routing model type
  */
-static void parse_E_AS(char *AS_id)
+static void parse_E_AS(const char *AS_id)
 {
 
   if (current_routing == NULL) {
@@ -492,7 +572,7 @@ static void parse_E_AS(char *AS_id)
     info->rc_component = current_routing->routing_father;
     info->rc_type = SURF_NETWORK_ELEMENT_AS;
     xbt_dict_set(global_routing->where_network_elements,
-                 current_routing->name, info, NULL);
+                 current_routing->name, info, xbt_free);
     (*(current_routing->routing->unload)) ();
     (*(current_routing->routing->end)) ();
     current_routing = current_routing->routing_father;
@@ -512,7 +592,7 @@ static void parse_E_AS_XML(void)
 /*
  * \brief Finish the creation of a new routing component from lua
  */
-static void parse_E_AS_lua(char *id)
+static void parse_E_AS_lua(const char *id)
 {
   parse_E_AS(id);
 }
@@ -681,7 +761,7 @@ static route_extended_t _get_route(const char *src, const char *dst)
                 "bad gateway for route between \"%s\" and \"%s\"", src,
                 dst);
 
-    if (src != e_route_cnt->src_gateway) {
+    if (strcmp(src, e_route_cnt->src_gateway)) {
       e_route_src = _get_route(src, e_route_cnt->src_gateway);
       xbt_assert2(e_route_src, "no route between \"%s\" and \"%s\"", src,
                   e_route_cnt->src_gateway);
@@ -694,7 +774,7 @@ static route_extended_t _get_route(const char *src, const char *dst)
       xbt_dynar_push(e_route->generic_route.link_list, &link);
     }
 
-    if (e_route_cnt->dst_gateway != dst) {
+    if (strcmp(e_route_cnt->dst_gateway, dst)) {
       e_route_dst = _get_route(e_route_cnt->dst_gateway, dst);
       xbt_assert2(e_route_dst, "no route between \"%s\" and \"%s\"",
                   e_route_cnt->dst_gateway, dst);
@@ -718,14 +798,13 @@ static route_extended_t _get_route(const char *src, const char *dst)
 
 static double _get_latency(const char *src, const char *dst)
 {
-
   double latency, latency_src, latency_dst = 0.0;
 
   DEBUG2("Solve route  \"%s\" to \"%s\"", src, dst);
 
   xbt_assert0(src && dst, "bad parameters for \"_get_route\" method");
 
-  route_extended_t e_route, e_route_cnt;
+  route_extended_t e_route_cnt;
 
   xbt_dynar_t elem_father_list = elements_father(src, dst);
 
@@ -736,12 +815,6 @@ static double _get_latency(const char *src, const char *dst)
   routing_component_t dst_father =
       xbt_dynar_get_as(elem_father_list, 2, routing_component_t);
 
-  e_route = xbt_new0(s_route_extended_t, 1);
-  e_route->src_gateway = NULL;
-  e_route->dst_gateway = NULL;
-  e_route->generic_route.link_list =
-      xbt_dynar_new(global_routing->size_of_link, NULL);
-
   if (src_father == dst_father) {       /* SURF_ROUTING_BASE */
 
     if (strcmp(src, dst)) {
@@ -771,56 +844,28 @@ static double _get_latency(const char *src, const char *dst)
                 "bad gateway for route between \"%s\" and \"%s\"", src,
                 dst);            
     latency =
-          (*(common_father->get_latency)) (common_father, src_father->name,
-                                         dst_father->name);
+          (*(common_father->get_latency)) (common_father, e_route_cnt->src_gateway,
+                                         e_route_cnt->src_gateway);
     xbt_assert2(latency>=0, "no route between \"%s\" and \"%s\"",
                 src_father->name, dst_father->name);
     
 
     if (src != e_route_cnt->src_gateway) {
-      /*
-      e_route_src = _get_route(src, e_route_cnt->src_gateway);
-      xbt_assert2(e_route_src, "no route between \"%s\" and \"%s\"", src,
-                  e_route_cnt->src_gateway);
-      xbt_dynar_foreach(e_route_src->generic_route.link_list, cpt, link) {
-        xbt_dynar_push(e_route->generic_route.link_list, &link);
-      }
-      */
+
       latency_src = _get_latency(src, e_route_cnt->src_gateway);
       xbt_assert2(latency_src>=0, "no route between \"%s\" and \"%s\"", src,
                   e_route_cnt->src_gateway);
       latency += latency_src;
     }
-    
-    /*
-    xbt_dynar_foreach(e_route_cnt->generic_route.link_list, cpt, link) {
-      xbt_dynar_push(e_route->generic_route.link_list, &link);
-    }
-	*/
-	
+
     if (e_route_cnt->dst_gateway != dst) {
-      /*
-      e_route_dst = _get_route(e_route_cnt->dst_gateway, dst);
-      xbt_assert2(e_route_dst, "no route between \"%s\" and \"%s\"",
-                  e_route_cnt->dst_gateway, dst);
-      xbt_dynar_foreach(e_route_dst->generic_route.link_list, cpt, link) {
-        xbt_dynar_push(e_route->generic_route.link_list, &link);
-      }
-      */
+    
       latency_dst = _get_latency(e_route_cnt->dst_gateway, dst);
       xbt_assert2(latency_dst>=0, "no route between \"%s\" and \"%s\"",
                   e_route_cnt->dst_gateway, dst);
       latency += latency_dst;
     }
 	
-	/*
-    e_route->src_gateway = xbt_strdup(e_route_cnt->src_gateway);
-    e_route->dst_gateway = xbt_strdup(e_route_cnt->dst_gateway);
-
-    generic_free_extended_route(e_route_src);
-    generic_free_extended_route(e_route_cnt);
-    generic_free_extended_route(e_route_dst);
-    */   
   }
 
   xbt_dynar_free(&elem_father_list);
@@ -842,14 +887,19 @@ static xbt_dynar_t get_route(const char *src, const char *dst)
 {
 
   route_extended_t e_route;
-  xbt_dynar_t elem_father_list = elements_father(src, dst);
-  routing_component_t common_father =
-      xbt_dynar_get_as(elem_father_list, 0, routing_component_t);
+  xbt_dynar_t elem_father_list = NULL;
+  routing_component_t common_father = NULL;
 
   if (strcmp(src, dst))
     e_route = _get_route(src, dst);
-  else
+  else {
+    elem_father_list = elements_father(src, dst);
+    common_father =
+        xbt_dynar_get_as(elem_father_list, 0, routing_component_t);
+
     e_route = (*(common_father->get_route)) (common_father, src, dst);
+    xbt_dynar_free(&elem_father_list);
+  }
 
   xbt_assert2(e_route, "no route between \"%s\" and \"%s\"", src, dst);
 
@@ -863,11 +913,12 @@ static xbt_dynar_t get_route(const char *src, const char *dst)
     xbt_free(e_route->dst_gateway);
 
   xbt_free(e_route);
-  xbt_dynar_free(&elem_father_list);
 
+/*
   if (xbt_dynar_length(global_routing->last_route) == 0)
     return NULL;
   else
+*/
     return global_routing->last_route;
 }
 
@@ -903,6 +954,7 @@ static double get_latency(const char *src, const char *dst)
     latency = (*(common_father->get_latency)) (common_father, src, dst);
 
   xbt_assert2(latency>=0.0, "no route between \"%s\" and \"%s\"", src, dst);
+  xbt_dynar_free(&elem_father_list);
 
   return latency;
 }
@@ -946,6 +998,7 @@ static void finalize(void)
   _finalize(global_routing->root);
   /* delete "where" dict */
   xbt_dict_free(&(global_routing->where_network_elements));
+  xbt_dict_free(&(coordinates));
   /* delete last_route */
   xbt_dynar_free(&(global_routing->last_route));
   /* delete global routing structure */
@@ -1000,7 +1053,6 @@ static e_surf_network_element_type_t get_network_element_type(const char
  */
 void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_t get_link_latency_fun)
 {
-
   /* config the uniq global routing */
   global_routing = xbt_new0(s_routing_global_t, 1);
   global_routing->where_network_elements = xbt_dict_new();
@@ -1018,8 +1070,11 @@ void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_
   /* no current routing at moment */
   current_routing = NULL;
 
+  coordinates = xbt_dict_new();
+
   /* parse generic elements */
   surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host_XML);
+  surfxml_add_callback(ETag_surfxml_host_cb_list, &parse_E_host_XML);
   surfxml_add_callback(STag_surfxml_router_cb_list, &parse_S_router);
 
   surfxml_add_callback(STag_surfxml_route_cb_list,
@@ -1045,10 +1100,20 @@ void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_
   surfxml_add_callback(STag_surfxml_cluster_cb_list,
                        &routing_parse_Scluster);
 
-  surfxml_add_callback(STag_surfxml_config_cb_list,
-					   &routing_parse_Sconfig);
-  surfxml_add_callback(ETag_surfxml_config_cb_list,
-					   &routing_parse_Econfig);
+  surfxml_add_callback(STag_surfxml_peer_cb_list,
+                         &routing_parse_Speer);
+
+#ifdef HAVE_TRACING
+  instr_routing_define_callbacks();
+#endif
+}
+
+void surf_config_add_callback(void)
+{
+	surf_parse_reset_parser();
+	surfxml_add_callback(STag_surfxml_config_cb_list, &routing_parse_Sconfig);
+	surfxml_add_callback(ETag_surfxml_config_cb_list, &routing_parse_Econfig);
+	surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties);
 }
 
 /* ************************************************************************** */
@@ -1265,8 +1330,8 @@ static void model_full_set_route(routing_component_t rc, const char *src,
 			  (void*)TO_ROUTE_FULL(*src_id, *dst_id)->generic_route.link_list,
 			  (void*)link_route_to_test,
 			  (int_f_cpvoid_cpvoid_t) surf_pointer_resource_cmp),
-			  "The route between \"%s\" and \"%s\" already exists", src,dst);
-		xbt_free(link_route_to_test);
+			  "The route between \"%s\" and \"%s\" already exists. If you are trying to define a reverse route, you must set the symmetrical=no attribute to your routes tags.", src,dst);
+		xbt_dynar_free(&link_route_to_test);
 	}
 	else
 	{
@@ -1284,10 +1349,10 @@ static void model_full_set_route(routing_component_t rc, const char *src,
 	{
 		if(route->dst_gateway && route->src_gateway)
 		{
-			char * gw_src = bprintf("%s",route->src_gateway);
-			char * gw_dst = bprintf("%s",route->dst_gateway);
-			route->src_gateway = bprintf("%s",gw_dst);
-			route->dst_gateway = bprintf("%s",gw_src);
+                  char *gw_src = xbt_strdup(route->src_gateway);
+                  char *gw_dst = xbt_strdup(route->dst_gateway);
+                  route->src_gateway = gw_dst;
+                  route->dst_gateway = gw_src;
 		}
 		if(TO_ROUTE_FULL(*dst_id, *src_id))
 		{
@@ -1306,7 +1371,7 @@ static void model_full_set_route(routing_component_t rc, const char *src,
 			      (void*)link_route_to_test,
 				  (int_f_cpvoid_cpvoid_t) surf_pointer_resource_cmp),
 				  "The route between \"%s\" and \"%s\" already exists", src,dst);
-			xbt_free(link_route_to_test);
+			xbt_dynar_free(&link_route_to_test);
 		}
 		else
 		{
@@ -1682,10 +1747,10 @@ static void model_floyd_set_route(routing_component_t rc, const char *src,
 		{
 			if(route->dst_gateway && route->src_gateway)
 			{
-				char * gw_src = bprintf("%s",route->src_gateway);
-				char * gw_dst = bprintf("%s",route->dst_gateway);
-				route->src_gateway = bprintf("%s",gw_dst);
-				route->dst_gateway = bprintf("%s",gw_src);
+                          char *gw_src = xbt_strdup(route->src_gateway);
+                          char *gw_dst = xbt_strdup(route->dst_gateway);
+                          route->src_gateway = gw_dst;
+                          route->dst_gateway = gw_src;
 			}
 
 			if(!route->dst_gateway && !route->src_gateway)
@@ -1801,9 +1866,10 @@ static void route_new_dijkstra(routing_component_dijkstra_t rc, int src_id,
                                int dst_id, route_extended_t e_route)
 {
   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
-
+  DEBUG2("Load Route from \"%d\" to \"%d\"", src_id, dst_id);
   xbt_node_t src = NULL;
   xbt_node_t dst = NULL;
+
   graph_node_map_element_t src_elm = (graph_node_map_element_t)
       xbt_dict_get_or_null_ext(routing->graph_node_map,
                                (char *) (&src_id),
@@ -1813,6 +1879,7 @@ static void route_new_dijkstra(routing_component_dijkstra_t rc, int src_id,
                                (char *) (&dst_id),
                                sizeof(int));
 
+
   if (src_elm)
     src = src_elm->node;
 
@@ -2161,11 +2228,13 @@ static void model_dijkstra_both_end(void)
   xbt_dynar_t nodes = NULL;
 
   /* Create the topology graph */
+  if(!routing->route_graph)
   routing->route_graph = xbt_graph_new_graph(1, NULL);
+  if(!routing->graph_node_map)
   routing->graph_node_map = xbt_dict_new();
 
   if (routing->cached && !routing->route_cache)
-    routing->route_cache = xbt_dict_new();
+  routing->route_cache = xbt_dict_new();
 
   /* Add the loopback if needed */
   if (current_routing->hierarchy == SURF_ROUTING_BASE)
@@ -2188,6 +2257,12 @@ static void model_dijkstra_both_set_route (routing_component_t rc, const char *s
 	src_id = xbt_dict_get_or_null(rc->to_index, src);
 	dst_id = xbt_dict_get_or_null(rc->to_index, dst);
 
+    /* Create the topology graph */
+	if(!routing->route_graph)
+	routing->route_graph = xbt_graph_new_graph(1, NULL);
+	if(!routing->graph_node_map)
+	routing->graph_node_map = xbt_dict_new();
+
 	if (routing->cached && !routing->route_cache)
 	routing->route_cache = xbt_dict_new();
 
@@ -2326,8 +2401,8 @@ static void model_rulebased_set_ASroute(routing_component_t rc,
   ruleroute_e->re_src_gateway = route->src_gateway;
   ruleroute_e->re_dst_gateway = route->dst_gateway;
   xbt_dynar_push(routing->list_ASroute, &ruleroute_e);
-  xbt_free(route->src_gateway);
-  xbt_free(route->dst_gateway);
+//  xbt_free(route->src_gateway);
+//  xbt_free(route->dst_gateway);
   xbt_free(route);
 }
 
@@ -2604,7 +2679,8 @@ static void *model_rulebased_create(void)
   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 = generic_get_bypassroute;       //rulebased_get_bypass_route;
+  new_component->generic_routing.get_latency = generic_get_link_latency;
+  new_component->generic_routing.get_bypass_route = rulebased_get_bypass_route;
   new_component->generic_routing.finalize = rulebased_finalize;
   /* initialization of internal structures */
   new_component->dict_processing_units = xbt_dict_new();
@@ -2774,16 +2850,14 @@ static void generic_set_autonomous_system(routing_component_t rc,
   xbt_dict_set(_to_index, name, id, xbt_free);
 }
 
-static int surf_pointer_resource_cmp(const void *a, const void *b) {
-	if(a == b)
-		return 0;
-	return 1;
+static int surf_pointer_resource_cmp(const void *a, const void *b)
+{
+  return a != b;
 }
 
-static int surf_link_resource_cmp(const void *a, const void *b) {
-	if( memcmp(a,b,global_routing->size_of_link) == 0 );
-		return 0;
-	return 1;
+static int surf_link_resource_cmp(const void *a, const void *b)
+{
+  return !!memcmp(a,b,global_routing->size_of_link);
 }
 
 static void generic_set_bypassroute(routing_component_t rc,
@@ -2826,6 +2900,7 @@ static double generic_get_link_latency(routing_component_t rc,
 	xbt_dynar_foreach(route->generic_route.link_list,i,link) {
 		latency += get_link_latency(link);
 	}
+	generic_free_extended_route(route);
   return latency;
 }
 
@@ -3170,20 +3245,25 @@ static void generic_src_dst_check(routing_component_t rc, const char *src,
 
 static void routing_parse_Sconfig(void)
 {
-  //TODO
-  DEBUG0("WARNING tag config not yet implemented.");
-  DEBUG1("Configuration name = %s",A_surfxml_config_id);
+  DEBUG1("START configuration name = %s",A_surfxml_config_id);
 }
 
 static void routing_parse_Econfig(void)
 {
-  //TODO
   xbt_dict_cursor_t cursor = NULL;
+  xbt_cfgelm_t variable;
   char *key;
   char *elem;
+  char *cfg;
   xbt_dict_foreach(current_property_set, cursor, key, elem) {
-	  DEBUG2("property : %s = %s",key,elem);
+	  cfg = bprintf("%s:%s",key,elem);
+	  variable = xbt_cfgelm_get(_surf_cfg_set, key, xbt_cfgelm_any);
+	  if(variable->isdefault)
+		  xbt_cfg_set_parse(_surf_cfg_set, cfg);
+	  else
+		  INFO1("The custom configuration '%s' is already define by user!",key);
 	}
+  DEBUG1("End configuration name = %s",A_surfxml_config_id);
 }
 
 static void routing_parse_Scluster(void)
@@ -3195,12 +3275,24 @@ static void routing_parse_Scluster(void)
   char *cluster_suffix = A_surfxml_cluster_suffix;
   char *cluster_radical = A_surfxml_cluster_radical;
   char *cluster_power = A_surfxml_cluster_power;
+  char *cluster_core = A_surfxml_cluster_core;
   char *cluster_bw = A_surfxml_cluster_bw;
   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 *cluster_availability_file = A_surfxml_cluster_availability_file;
+  char *cluster_state_file = A_surfxml_cluster_state_file;
   char *host_id, *groups, *link_id = NULL;
   char *router_id, *link_router, *link_backbone;
+  char *availability_file = bprintf("%s",cluster_availability_file);
+  char *state_file = bprintf("%s",cluster_state_file);
+
+  xbt_dict_t patterns = xbt_dict_new();
+  xbt_dict_set(patterns,"id",cluster_id,NULL);
+  xbt_dict_set(patterns,"prefix",cluster_prefix,NULL);
+  xbt_dict_set(patterns,"suffix",cluster_suffix,NULL);
+
+
 #ifdef HAVE_PCRE_LIB
   char *route_src_dst;
 #endif
@@ -3247,13 +3339,20 @@ static void routing_parse_Scluster(void)
 #endif
       link_id = bprintf("%s_link_%d", cluster_id, start);
 
-      DEBUG2("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, cluster_power);
+      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_core, cluster_core);
       SURFXML_BUFFER_SET(host_availability, "1.0");
-      SURFXML_BUFFER_SET(host_availability_file, "");
-      SURFXML_BUFFER_SET(host_state_file, "");
+	  xbt_dict_set(patterns,"radical",bprintf("%d",start),NULL);
+	  availability_file = bprintf("%s",cluster_availability_file);
+	  state_file = bprintf("%s",cluster_state_file);
+	  DEBUG1("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns));
+	  DEBUG1("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns));
+	  SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns));
+	  SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns));
+	  DEBUG0("</host>");
       SURFXML_START_TAG(host);
       SURFXML_END_TAG(host);
 
@@ -3273,6 +3372,8 @@ static void routing_parse_Scluster(void)
       SURFXML_START_TAG(link);
       SURFXML_END_TAG(link);
 
+      free(link_id);
+      free(host_id);
       break;
 
     case 2:
@@ -3280,7 +3381,6 @@ static void routing_parse_Scluster(void)
       surf_parse_get_int(&start,
                          xbt_dynar_get_as(radical_ends, 0, char *));
       surf_parse_get_int(&end, xbt_dynar_get_as(radical_ends, 1, char *));
-      DEBUG2("Create hosts and links from %d to %d", start, end);
       for (i = start; i <= end; i++) {
         host_id = bprintf("%s%d%s", cluster_prefix, i, cluster_suffix);
 #ifndef HAVE_PCRE_LIB
@@ -3288,13 +3388,20 @@ static void routing_parse_Scluster(void)
 #endif
         link_id = bprintf("%s_link_%d", cluster_id, i);
 
-        DEBUG2("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, cluster_power);
+        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, "");
-        SURFXML_BUFFER_SET(host_state_file, "");
+        SURFXML_BUFFER_SET(host_core, cluster_core);
+		SURFXML_BUFFER_SET(host_availability, "1.0");
+		xbt_dict_set(patterns,"radical",bprintf("%d",i),NULL);
+		availability_file = bprintf("%s",cluster_availability_file);
+		state_file = bprintf("%s",cluster_state_file);
+		DEBUG1("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns));
+		DEBUG1("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns));
+		SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns));
+		SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns));
+		DEBUG0("</host>");
         SURFXML_START_TAG(host);
         SURFXML_END_TAG(host);
 
@@ -3313,6 +3420,9 @@ static void routing_parse_Scluster(void)
         SURFXML_BUFFER_SET(link_state_file, "");
         SURFXML_START_TAG(link);
         SURFXML_END_TAG(link);
+
+        free(link_id);
+        free(host_id);
       }
       break;
 
@@ -3322,6 +3432,7 @@ static void routing_parse_Scluster(void)
 
     xbt_dynar_free(&radical_ends);
   }
+  xbt_dynar_free(&radical_elements);
 
   DEBUG0(" ");
   router_id =
@@ -3351,7 +3462,7 @@ static void routing_parse_Scluster(void)
   SURFXML_START_TAG(link);
   SURFXML_END_TAG(link);
 
-  DEBUG3("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_backbone,cluster_bw, cluster_lat);
+  DEBUG3("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_backbone,cluster_bb_bw, cluster_bb_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)
@@ -3368,15 +3479,23 @@ static void routing_parse_Scluster(void)
   DEBUG0(" ");
 
 #ifdef HAVE_PCRE_LIB
-  char *new_suffix = bprintf("%s", "");
+  char *new_suffix = xbt_strdup("");
 
   radical_elements = xbt_str_split(cluster_suffix, ".");
   xbt_dynar_foreach(radical_elements, iter, groups) {
     if (strcmp(groups, "")) {
-      new_suffix = bprintf("%s\\.%s", new_suffix, groups);
+      char *old_suffix = new_suffix;
+      new_suffix = bprintf("%s\\.%s", old_suffix, groups);
+      free(old_suffix);
     }
   }
   route_src_dst = bprintf("%s(.*)%s", cluster_prefix, new_suffix);
+  xbt_dynar_free(&radical_elements);
+  free(new_suffix);
+
+  char *pcre_link_src = bprintf("%s_link_$1src", cluster_id);
+  char *pcre_link_backbone = bprintf("%s_backbone", cluster_id);
+  char *pcre_link_dst = bprintf("%s_link_$1dst", cluster_id);
 
   DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src_dst, route_src_dst);
   DEBUG0("symmetrical=\"NO\">");
@@ -3385,22 +3504,22 @@ static void routing_parse_Scluster(void)
   A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
   SURFXML_START_TAG(route);
 
-  DEBUG1("<link_ctn\tid=\"%s_link_$1src\"/>", cluster_id);
-  SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1src", cluster_id));
+  DEBUG1("<link_ctn\tid=\"%s\"/>", pcre_link_src);
+  SURFXML_BUFFER_SET(link_ctn_id, pcre_link_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);
-  SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone", cluster_id));
+  DEBUG1("<link_ctn\tid=\"%s\"/>", pcre_link_backbone);
+  SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone);
   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);
-  SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1dst", cluster_id));
+  DEBUG1("<link_ctn\tid=\"%s\"/>", pcre_link_dst);
+  SURFXML_BUFFER_SET(link_ctn_id, pcre_link_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;}
@@ -3409,6 +3528,11 @@ static void routing_parse_Scluster(void)
 
   DEBUG0("</route>");
   SURFXML_END_TAG(route);
+
+  free(pcre_link_dst);
+  free(pcre_link_backbone);
+  free(pcre_link_src);
+  free(route_src_dst);
 #else
   for (i = 0; i <= xbt_dynar_length(tab_elements_num); i++) {
     for (j = 0; j <= xbt_dynar_length(tab_elements_num); j++) {
@@ -3480,15 +3604,171 @@ static void routing_parse_Scluster(void)
     }
   }
   xbt_dynar_free(&tab_elements_num);
+  free(router_id);
+
 #endif
 
+  free(link_backbone);
+  free(link_router);
+  xbt_dict_free(&patterns);
+  free(availability_file);
+  free(state_file);
+
+  DEBUG0("</AS>");
+  SURFXML_END_TAG(AS);
+  DEBUG0(" ");
+
+  surfxml_bufferstack_pop(1);
+}
+
+static void routing_parse_Speer(void)
+{
+  static int AX_ptr = 0;
+
+  char *peer_id = A_surfxml_peer_id;
+  char *peer_power = A_surfxml_peer_power;
+  char *peer_bw_in = A_surfxml_peer_bw_in;
+  char *peer_bw_out = A_surfxml_peer_bw_out;
+  char *peer_lat = A_surfxml_peer_lat;
+  char *peer_coord = A_surfxml_peer_coordinates;
+  char *peer_state_file = A_surfxml_peer_state_file;
+  char *peer_availability_file = A_surfxml_peer_availability_file;
+
+  char *host_id = NULL;
+  char *router_id, *link_router, *link_backbone, *link_id_up, *link_id_down;
+
+#ifdef HAVE_PCRE_LIB
+
+#endif
+
+  int peer_sharing_policy = AX_surfxml_peer_sharing_policy;
+
+#ifndef HAVE_PCRE_LIB
+  //xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL);
+  //char *route_src, *route_dst;
+  //int j;
+#endif
+
+  static unsigned int surfxml_buffer_stack_stack_ptr = 1;
+  static unsigned int surfxml_buffer_stack_stack[1024];
+
+  surfxml_buffer_stack_stack[0] = 0;
+
+  surfxml_bufferstack_push(1);
+
+  SURFXML_BUFFER_SET(AS_id, peer_id);
+#ifdef HAVE_PCRE_LIB
+  SURFXML_BUFFER_SET(AS_routing, "RuleBased");
+  DEBUG1("<AS id=\"%s\"\trouting=\"RuleBased\">", peer_id);
+#else
+  SURFXML_BUFFER_SET(AS_routing, "Full");
+  DEBUG1("<AS id=\"%s\"\trouting=\"Full\">", peer_id);
+#endif
+  SURFXML_START_TAG(AS);
+
+  DEBUG0(" ");
+  host_id = bprintf("peer_%s", peer_id);
+  router_id = bprintf("router_%s", peer_id);
+  link_id_up = bprintf("link_%s_up", peer_id);
+  link_id_down = bprintf("link_%s_down", peer_id);
+
+  link_router = bprintf("%s_link_router", peer_id);
+  link_backbone = bprintf("%s_backbone", peer_id);
+
+  DEBUG2("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, peer_power);
+  A_surfxml_host_state = A_surfxml_host_state_ON;
+  SURFXML_BUFFER_SET(host_id, host_id);
+  SURFXML_BUFFER_SET(host_power, peer_power);
+  SURFXML_BUFFER_SET(host_availability, "1.0");
+  SURFXML_BUFFER_SET(host_availability_file, peer_availability_file);
+  SURFXML_BUFFER_SET(host_state_file, peer_state_file);
+  SURFXML_START_TAG(host);
+  SURFXML_END_TAG(host);
+
+  DEBUG2("<router id=\"%s\"\tcoordinates=\"%s\"/>", router_id, peer_coord);
+  SURFXML_BUFFER_SET(router_id, router_id);
+  SURFXML_BUFFER_SET(router_coordinates, peer_coord);
+  SURFXML_START_TAG(router);
+  SURFXML_END_TAG(router);
+
+  DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_up, peer_bw_in, peer_lat);
+  A_surfxml_link_state = A_surfxml_link_state_ON;
+  A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+  if(peer_sharing_policy == A_surfxml_peer_sharing_policy_FULLDUPLEX)
+{A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
+  SURFXML_BUFFER_SET(link_id, link_id_up);
+  SURFXML_BUFFER_SET(link_bandwidth, peer_bw_in);
+  SURFXML_BUFFER_SET(link_latency, peer_lat);
+  SURFXML_BUFFER_SET(link_bandwidth_file, "");
+  SURFXML_BUFFER_SET(link_latency_file, "");
+  SURFXML_BUFFER_SET(link_state_file, "");
+  SURFXML_START_TAG(link);
+  SURFXML_END_TAG(link);
+
+  DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_down, peer_bw_out, peer_lat);
+  A_surfxml_link_state = A_surfxml_link_state_ON;
+  A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+  if(peer_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+{A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
+  SURFXML_BUFFER_SET(link_id, link_id_down);
+  SURFXML_BUFFER_SET(link_bandwidth, peer_bw_out);
+  SURFXML_BUFFER_SET(link_latency, peer_lat);
+  SURFXML_BUFFER_SET(link_bandwidth_file, "");
+  SURFXML_BUFFER_SET(link_latency_file, "");
+  SURFXML_BUFFER_SET(link_state_file, "");
+  SURFXML_START_TAG(link);
+  SURFXML_END_TAG(link);
+
+  DEBUG0(" ");
+
+  // begin here
+  DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", peer_id, router_id);
+  DEBUG0("symmetrical=\"NO\">");
+  SURFXML_BUFFER_SET(route_src, peer_id);
+  SURFXML_BUFFER_SET(route_dst, router_id);
+  A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
+  SURFXML_START_TAG(route);
+
+  DEBUG1("<link_ctn\tid=\"%s\"/>", link_id_up);
+  SURFXML_BUFFER_SET(link_ctn_id, link_id_up);
+  A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
+  if(peer_sharing_policy == A_surfxml_peer_sharing_policy_FULLDUPLEX)
+  {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
+  SURFXML_START_TAG(link_ctn);
+  SURFXML_END_TAG(link_ctn);
+
+  DEBUG0("</route>");
+  SURFXML_END_TAG(route);
+
+  //Opposite Route
+  DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", router_id, peer_id);
+  DEBUG0("symmetrical=\"NO\">");
+  SURFXML_BUFFER_SET(route_src, router_id);
+  SURFXML_BUFFER_SET(route_dst, peer_id);
+  A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
+  SURFXML_START_TAG(route);
+
+  DEBUG1("<link_ctn\tid=\"%s\"/>", link_id_down);
+  SURFXML_BUFFER_SET(link_ctn_id, link_id_down);
+  A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
+  if(peer_sharing_policy == A_surfxml_peer_sharing_policy_FULLDUPLEX)
+  {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
+  SURFXML_START_TAG(link_ctn);
+  SURFXML_END_TAG(link_ctn);
+
+  DEBUG0("</route>");
+  SURFXML_END_TAG(route);
+
   DEBUG0("</AS>");
   SURFXML_END_TAG(AS);
   DEBUG0(" ");
 
+  //xbt_dynar_free(&tab_elements_num);
+
   surfxml_bufferstack_pop(1);
 }
 
+
 /*
  * New methods to init the routing model component from the lua script
  */
@@ -3515,7 +3795,7 @@ void routing_AS_end(const char *AS_id)
 
 void routing_add_host(const char *host_id)
 {
-  parse_S_host_lua((char *) host_id);
+  parse_S_host_lua((char *) host_id, (char*)""); // FIXME propagate coordinate system to lua
 }
 
 /*