X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e6425c886387618b973673bdf1ad95edf921b6ef..0de7df8a3bc351fdff4c4a3e106608b15c842143:/src/surf/surf_routing.c

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index e4599950e4..b0f6d7ed45 100644
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -18,6 +18,7 @@
 #include "xbt/config.h"
 #include "xbt/graph.h"
 #include "xbt/set.h"
+#include "surf/surfxml_parse.h"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf");
 
@@ -175,8 +176,7 @@ static double eculidean_dist_comp(int index, xbt_dynar_t src, xbt_dynar_t dst)
 
 }
 
-static double vivaldi_get_link_latency (routing_component_t rc,
-																				const char *src, const char *dst)
+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;
@@ -207,7 +207,7 @@ static double vivaldi_get_link_latency (routing_component_t rc,
 /**
  * \brief Add a "host" to the network element list
  */
-static void parse_S_host(char *host_id, char* coord)
+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)
@@ -224,7 +224,7 @@ static void parse_S_host(char *host_id, char* coord)
   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, " ");
@@ -233,6 +233,17 @@ static void parse_S_host(char *host_id, char* coord)
   }
 }
 
+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);
+		}
+}
+
 /*
  * \brief Add a host to the network element list from XML
  */
@@ -240,11 +251,15 @@ static void parse_S_host_XML(void)
 {
 	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, char *coord)
+static void parse_S_host_lua(const char *host_id, const char *coord)
 {
   parse_S_host(host_id, coord);
 }
@@ -273,10 +288,7 @@ 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);
@@ -359,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);
@@ -389,7 +401,7 @@ static void parse_E_link_ctn_new_elem_XML(void)
 /**
  * \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);
 }
@@ -528,6 +540,13 @@ static void parse_S_AS(char *AS_id, char *AS_routing)
 static void parse_S_AS_XML(void)
 {
   parse_S_AS(A_surfxml_AS_id, A_surfxml_AS_routing);
+
+  if (strcmp(A_surfxml_AS_coordinates,"")) {
+	DEBUG2("%s coordinates : %s",A_surfxml_AS_id,A_surfxml_AS_coordinates);
+  	xbt_dynar_t ctn = xbt_str_split_str(A_surfxml_AS_coordinates, " ");
+  	xbt_dynar_shrink(ctn,0);
+   	xbt_dict_set (coordinates,A_surfxml_AS_id,ctn,NULL);
+  }
 }
 
 /*
@@ -545,7 +564,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) {
@@ -560,7 +579,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;
@@ -580,13 +599,31 @@ 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);
 }
 
 /* Aux Business methods */
 
+/**
+ * \brief Get the AS name of the element
+ *
+ * \param name the host name
+ *
+ */
+static char* elements_As_name(const char *name)
+{
+  routing_component_t as_comp;
+
+  /* (1) find the as where the host is located */
+  as_comp = ((network_element_info_t)
+            xbt_dict_get_or_null(global_routing->where_network_elements,
+                                 name))->rc_component;
+  return as_comp->name;
+}
+
+
 /**
  * \brief Get the AS father and the first elements of the chain
  *
@@ -749,7 +786,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);
@@ -762,7 +799,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);
@@ -789,10 +826,9 @@ 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);
 
@@ -803,12 +839,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)) {
@@ -819,7 +849,6 @@ static double _get_latency(const char *src, const char *dst)
      } else latency = 0;
   } else {                      /* SURF_ROUTING_RECURSIVE */
      route_extended_t e_route_bypass = NULL;
-
     if (common_father->get_bypass_route)
       e_route_bypass =
           (*(common_father->get_bypass_route)) (common_father, src, dst);
@@ -838,8 +867,9 @@ 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, e_route_cnt->src_gateway,
-                                         e_route_cnt->src_gateway);
+          (*(common_father->get_latency)) (common_father, elements_As_name(src),
+        		  elements_As_name(dst));
+
     xbt_assert2(latency>=0, "no route between \"%s\" and \"%s\"",
                 src_father->name, dst_father->name);
     
@@ -881,14 +911,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);
 
@@ -902,7 +937,6 @@ 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)
@@ -944,6 +978,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;
 }
@@ -1042,7 +1077,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();
@@ -1064,6 +1098,7 @@ void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_
 
   /* 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,
@@ -1092,10 +1127,24 @@ void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_
   surfxml_add_callback(STag_surfxml_peer_cb_list,
                          &routing_parse_Speer);
 
-  surfxml_add_callback(STag_surfxml_config_cb_list,
-					   &routing_parse_Sconfig);
-  surfxml_add_callback(ETag_surfxml_config_cb_list,
-					   &routing_parse_Econfig);
+#ifdef HAVE_TRACING
+  instr_routing_define_callbacks();
+#endif
+}
+
+void surf_parse_add_callback_config(void)
+{
+	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);
+	surfxml_add_callback(STag_surfxml_AS_cb_list, &surf_parse_models_setup);
+}
+
+void surf_parse_models_setup()
+{
+	surfxml_del_callback(STag_surfxml_AS_cb_list, surf_parse_models_setup);
+	surf_config_models_setup(platform_filename);
+	free(platform_filename);
 }
 
 /* ************************************************************************** */
@@ -1233,6 +1282,7 @@ static void *model_full_create(void)
   new_component->generic_routing.finalize = full_finalize;
   new_component->generic_routing.to_index = xbt_dict_new();
   new_component->generic_routing.bypassRoutes = xbt_dict_new();
+  new_component->generic_routing.get_network_element_type = get_network_element_type;
   return new_component;
 }
 
@@ -1312,8 +1362,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
 	{
@@ -1353,7 +1403,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
 		{
@@ -1555,6 +1605,7 @@ static void *model_floyd_create(void)
   new_component->generic_routing.finalize = floyd_finalize;
   new_component->generic_routing.to_index = xbt_dict_new();
   new_component->generic_routing.bypassRoutes = xbt_dict_new();
+  new_component->generic_routing.get_network_element_type = get_network_element_type;
   return new_component;
 }
 
@@ -1848,9 +1899,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),
@@ -1860,6 +1912,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;
 
@@ -2175,6 +2228,7 @@ static void *model_dijkstra_both_create(int cached)
   new_component->cached = cached;
   new_component->generic_routing.to_index = xbt_dict_new();
   new_component->generic_routing.bypassRoutes = xbt_dict_new();
+  new_component->generic_routing.get_network_element_type = get_network_element_type;
   return new_component;
 }
 
@@ -2208,11 +2262,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)
@@ -2235,6 +2291,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();
 
@@ -2654,6 +2716,7 @@ static void *model_rulebased_create(void)
   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;
+  new_component->generic_routing.get_network_element_type = get_network_element_type;
   /* initialization of internal structures */
   new_component->dict_processing_units = xbt_dict_new();
   new_component->dict_autonomous_systems = xbt_dict_new();
@@ -2872,6 +2935,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;
 }
 
@@ -3216,20 +3280,23 @@ 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;
   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);
+	  if(xbt_cfg_is_default_value(_surf_cfg_set, key))
+		  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)
@@ -3241,12 +3308,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
@@ -3293,13 +3372,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);
 
@@ -3328,7 +3414,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
@@ -3336,13 +3421,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);
 
@@ -3403,7 +3495,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)
@@ -3551,6 +3643,9 @@ static void routing_parse_Scluster(void)
 
   free(link_backbone);
   free(link_router);
+  xbt_dict_free(&patterns);
+  free(availability_file);
+  free(state_file);
 
   DEBUG0("</AS>");
   SURFXML_END_TAG(AS);
@@ -3569,6 +3664,8 @@ static void routing_parse_Speer(void)
   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;
@@ -3593,6 +3690,7 @@ static void routing_parse_Speer(void)
   surfxml_bufferstack_push(1);
 
   SURFXML_BUFFER_SET(AS_id, peer_id);
+  SURFXML_BUFFER_SET(AS_coordinates, peer_coord);
 #ifdef HAVE_PCRE_LIB
   SURFXML_BUFFER_SET(AS_routing, "RuleBased");
   DEBUG1("<AS id=\"%s\"\trouting=\"RuleBased\">", peer_id);
@@ -3616,8 +3714,8 @@ static void routing_parse_Speer(void)
   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, "");
-  SURFXML_BUFFER_SET(host_state_file, "");
+  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);