X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1abeb78cffed6f64bba4de0b20b4dea52954b19d..077cf3f1fdee123e65823b114addc247c15593df:/src/surf/surf_routing.c

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index 7d25866d47..d8f8b7cfdf 100644
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -14,32 +14,6 @@
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route,surf,"Routing part of surf");
 
-
-// FIXME: the next two lines cant be comented without fix the code in network.c file.
-routing_t used_routing = NULL;
-xbt_dict_t onelink_routes = NULL;
-// 
-// /* Prototypes of each model */
-// static void routing_model_full_create(size_t size_of_link,void *loopback);
-// // static void routing_model_floyd_create(size_t size_of_link, void*loopback);
-// // static void routing_model_dijkstra_create(size_t size_of_link, void*loopback);
-// // static void routing_model_dijkstracache_create(size_t size_of_link, void*loopback);
-// //static void routing_model_none_create(size_t size_of_link, void*loopback);
-// 
-// /* Definition of each model */
-// struct model_type {
-//   const char *name;
-//   const char *desc;
-//   void (*fun)(size_t,void*);
-// };
-// 
-// struct model_type models[] =
-// { {"Full", "Full routing data (fast, large memory requirements, fully expressive)", routing_model_full_create },
-// //   {"Floyd", "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)", routing_model_floyd_create },
-// //   {"Dijkstra", "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)", routing_model_dijkstra_create },
-// //   {"DijkstraCache", "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)", routing_model_dijkstracache_create },
-// //  {"none", "No routing (usable with Constant network only)", routing_model_none_create },
-//     {NULL,NULL,NULL}};
     
 ////////////////////////////////////////////////////////////////////////////////
 // HERE START THE NEW CODE
@@ -54,7 +28,7 @@ static void print_host(void);
 static void print_link(void);
 static void print_route(void);
 static void print_ctn(void);
-static void DEGUB_exit(void);
+static void DEBUG_exit(void);
 
 ////////////////////////////////////////////////////////////////////////////////
 // HERE START THE NEW CODE
@@ -66,44 +40,169 @@ routing_component_t current_routing = NULL;
 model_type_t current_routing_model = NULL;
 
 /* Prototypes of each model */
-static void* model_full_create(); /* create structures for full routing model */
-static void  model_full_load();   /* load parse functions for full routing model */
-static void  model_full_unload(); /* unload parse functions for full routing model */
-static void  model_full_end();    /* finalize the creation of full routing model */
+static void* model_full_create(void); /* create structures for full routing model */
+static void  model_full_load(void);   /* load parse functions for full routing model */
+static void  model_full_unload(void); /* unload parse functions for full routing model */
+static void  model_full_end(void);    /* finalize the creation of full routing model */
+
+static void* model_floyd_create(void); /* create structures for floyd routing model */
+static void  model_floyd_load(void);   /* load parse functions for floyd routing model */
+static void  model_floyd_unload(void); /* unload parse functions for floyd routing model */
+static void  model_floyd_end(void);    /* finalize the creation of floyd routing model */
+
+static void* model_dijkstra_create(void); /* create structures for dijkstra routing model */
+static void  model_dijkstra_load(void);   /* load parse functions for dijkstra routing model */
+static void  model_dijkstra_unload(void); /* unload parse functions for dijkstra routing model */
+static void  model_dijkstra_end(void);    /* finalize the creation of dijkstra routing model */
+
+static void* model_dijkstracache_create(void); /* create structures for dijkstracache routing model */
+static void  model_dijkstracache_load(void);   /* load parse functions for dijkstracache routing model */
+static void  model_dijkstracache_unload(void); /* unload parse functions for dijkstracache routing model */
+static void  model_dijkstracache_end(void);    /* finalize the creation of dijkstracache routing model */
+
+static void* model_none_create(void); /* none routing model */
+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 */
 
 /* Table of routing models */
+// typedef enum {
+//   SURF_MODEL_FULL = 0,
+//   SURF_MODEL_FLOYD,
+//   SURF_MODEL_DIJKSTRA,
+//   SURF_MODEL_DIJKSTRACACHE,
+//   SURF_MODEL_NONE
+// } e_surf_model_type_t;
+
+#define SURF_MODEL_FULL           0
+#define SURF_MODEL_FLOYD          1
+#define SURF_MODEL_DIJKSTRA       2
+#define SURF_MODEL_DIJKSTRACACHE  3
+#define SURF_MODEL_NONE           4
+
+/* must be finish with null and carefull if change de order */
 struct s_model_type routing_models[] =
-{ {"Full", "Full routing data", model_full_create, model_full_load, model_full_unload, model_full_end },  
+{ {"Full", "Full routing data (fast, large memory requirements, fully expressive)",
+  model_full_create, model_full_load, model_full_unload, model_full_end },  
+  {"Floyd", "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)",
+  model_floyd_create, model_floyd_load, model_floyd_unload, model_floyd_end },
+  {"Dijkstra", "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)",
+  model_dijkstra_create ,model_dijkstra_load, model_dijkstra_unload, model_dijkstra_end },
+  {"DijkstraCache", "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)",
+  model_dijkstracache_create, model_dijkstracache_load, model_dijkstracache_unload, model_dijkstracache_end },
+  {"none", "No routing (usable with Constant network only)",
+  model_none_create, model_none_load, model_none_unload, model_none_end },
   {NULL,NULL,NULL,NULL,NULL,NULL}};
 
-  
 /* global parse functions */
 
+static char* src = NULL;    /* temporary store the source name of a route */
+static char* dst = NULL;    /* temporary store the destination name of a route */
+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
- *
- * Allows find a "host" in any routing component
  */
-static void  parse_S_host(void) { // FIXME: if not exists
+static void  parse_S_host(void) {
+  if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_BASE;
+  xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,A_surfxml_host_id),
+      "Reading a host, processing unit \"%s\" already exist",A_surfxml_host_id);
+// FIXME: checked by parser
+//   xbt_assert1(current_routing->hierarchy==SURF_ROUTING_BASE,
+//       "Bad declaration of processing unit \"%s\"",A_surfxml_host_id);
+  (*(current_routing->set_processing_units))(current_routing,A_surfxml_host_id);
   xbt_dict_set(global_routing->where_network_elements,A_surfxml_host_id,(void*)current_routing,NULL); 
 }
 
 /**
  * \brief Add a "router" to the network element list
- *
- * Allows find a "router" in any routing component
  */
-static void parse_S_router(void) { // FIXME: if not exists
+static void parse_S_router(void) {
+  if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_BASE;
+  xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,A_surfxml_router_id),
+      "Reading a router, processing unit \"%s\" already exist",A_surfxml_router_id);
+// FIXME: checked by parser
+//   xbt_assert1(current_routing->hierarchy==SURF_ROUTING_BASE,
+//       "Bad declaration of processing unit \"%s\"",A_surfxml_host_id);
+  (*(current_routing->set_processing_units))(current_routing,A_surfxml_router_id);
   xbt_dict_set(global_routing->where_network_elements,A_surfxml_router_id,(void*)current_routing,NULL); 
 }
 
 /**
- * \brief Add a "gateway" to the network element list
- *
- * Allows find a "gateway" in any routing component
+ * \brief Set the endponints for a route
+ */
+static void parse_S_route_new_and_endpoints(void) {
+  // FIXME: checked by parser
+//   xbt_assert1(current_routing->hierarchy==SURF_ROUTING_BASE,
+//     "Bad declaration of route in \"%s\"",current_routing->name);
+  if( src != NULL && dst != NULL && link_list != NULL )
+    THROW2(arg_error,0,"Route between %s to %s can not be defined",A_surfxml_route_src,A_surfxml_route_dst);
+  src = A_surfxml_route_src;
+  dst = A_surfxml_route_dst;
+  link_list = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
+}
+
+/**
+ * \brief Set the endponints and gateways for a ASroute
+ */
+static void parse_S_ASroute_new_and_endpoints(void) {
+// FIXME: checked by parser
+//   xbt_assert1(current_routing->hierarchy==SURF_ROUTING_RECURSIVE,
+//     "Bad declaration of ASroute in \"%s\"",current_routing->name);
+  if( src != NULL && dst != NULL && link_list != NULL )
+    THROW2(arg_error,0,"Route between %s to %s can not be defined",A_surfxml_ASroute_src,A_surfxml_ASroute_dst);
+  src = A_surfxml_ASroute_src;
+  dst = A_surfxml_ASroute_dst;
+  gw_src = A_surfxml_ASroute_gw_src;
+  gw_dst = A_surfxml_ASroute_gw_dst;
+  link_list = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
+}
+
+/**
+ * \brief Set a new link on the actual list of link for a route or ASroute
  */
-static void parse_S_gateway(void) { // FIXME: if not exists
-  xbt_dict_set(global_routing->where_network_elements,A_surfxml_gateway_id,(void*)current_routing,NULL); 
+static void parse_E_link_c_ctn_new_elem(void) {
+  char *val;
+  val = xbt_strdup(A_surfxml_link_c_ctn_id);
+  xbt_dynar_push(link_list, &val);
+}
+
+/**
+ * \brief Store de route by calling the set_route function of the current routing component
+ */
+static void parse_E_route_store_route(void) {
+// FIXME: checked by parser
+//   xbt_assert1(current_routing->hierarchy==SURF_ROUTING_BASE,
+//     "Bad declaration of route in \"%s\"",current_routing->name);
+  route_t route = xbt_new(s_route_t,1);
+  route->link_list = link_list;
+  // TODO check if are correct
+  (*(current_routing->set_route))(current_routing,src,dst,route);
+  link_list = NULL;
+  src = NULL;
+  dst = NULL;
+}
+
+/**
+ * \brief Store de ASroute by calling the set_ASroute function of the current routing component
+ */
+static void parse_E_ASroute_store_route(void) {
+// FIXME: checked by parser
+//   xbt_assert1(current_routing->hierarchy==SURF_ROUTING_RECURSIVE,
+//     "Bad declaration of ASroute in \"%s\"",current_routing->name);
+  route_extended_t e_route = xbt_new(s_route_extended_t,1);
+  e_route->generic_route.link_list = link_list;
+  e_route->src_gateway = xbt_strdup(gw_src);
+  e_route->dst_gateway = xbt_strdup(gw_dst);
+  // TODO check if are correct
+  (*(current_routing->set_ASroute))(current_routing,src,dst,e_route);
+  link_list = NULL;
+  src = NULL;
+  dst = NULL;
+  gw_src = NULL;
+  gw_dst = NULL;
 }
 
 /**
@@ -127,29 +226,55 @@ static void parse_S_AS(void) {
     for (cpt=0;routing_models[cpt].name;cpt++)
       if (!strcmp(wanted,routing_models[cpt].name))
         fprintf(stderr,"   %s: %s\n",routing_models[cpt].name,routing_models[cpt].desc);
-    exit(1);
+    xbt_die(NULL);
   }
 
   /* make a new routing component */
   new_routing = (routing_component_t)(*(model->create))();
+  
+  /* FIXME: for now, if I forget to declare */  
+  xbt_assert1( new_routing->set_processing_units,
+       "Bad routing type, \"set_processing_units\" is not declared for \"%s\"",A_surfxml_AS_id);
+  xbt_assert1( new_routing->set_autonomous_system,
+       "Bad routing type, \"set_autonomous_system\" is not declared for \"%s\"",A_surfxml_AS_id);
+  xbt_assert1( new_routing->set_route,
+       "Bad routing type, \"set_route\" is not declared for \"%s\"",A_surfxml_AS_id);
+  xbt_assert1( new_routing->set_ASroute,
+       "Bad routing type, \"set_ASroute\" is not declared for \"%s\"",A_surfxml_AS_id);
+  xbt_assert1( new_routing->finalize,
+       "Bad routing type, \"finalize\" is not declared for \"%s\"",A_surfxml_AS_id);
+       
   new_routing->routing = model;
+  new_routing->hierarchy = SURF_ROUTING_NULL;
   new_routing->name = xbt_strdup(A_surfxml_AS_id);
   new_routing->routing_sons = xbt_dict_new();
-
-  if( current_routing == NULL && global_routing->root == NULL )
-  { /* it is the first one */
+  INFO2("Routing %s for AS %s",A_surfxml_AS_routing,A_surfxml_AS_id);
+  
+  if( current_routing == NULL && global_routing->root == NULL ){
+    
+    /* it is the first one */
     new_routing->routing_father = NULL;
     global_routing->root = new_routing;
-  }
-  else if( current_routing != NULL && global_routing->root != NULL )
-  {  /* it is a part of the tree */
+    
+  } else if( current_routing != NULL && global_routing->root != NULL ) { 
+    
+    xbt_assert1(!xbt_dict_get_or_null(current_routing->routing_sons,A_surfxml_AS_id),
+           "The AS \"%s\" already exist",A_surfxml_AS_id);
+     /* it is a part of the tree */
     new_routing->routing_father = current_routing;
+    /* set the father behavior */
+    if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_RECURSIVE;
+// FIXME: checked by parser
+//     xbt_assert1(current_routing->hierarchy==SURF_ROUTING_RECURSIVE,
+//       "Bad declaration of AS \"%s\"",A_surfxml_AS_id);
+    /* add to the sons dictionary */
     xbt_dict_set(current_routing->routing_sons,A_surfxml_AS_id,(void*)new_routing,NULL);
+    /* add to the father element list */
+    (*(current_routing->set_autonomous_system))(current_routing,A_surfxml_AS_id);
     /* unload the prev parse rules */
     (*(current_routing->routing->unload))();
-  }
-  else
-  {
+    
+  } else {
     THROW0(arg_error,0,"All defined components must be belong to a AS");
   }
   /* set the new parse rules */
@@ -178,17 +303,18 @@ static void parse_E_AS(void) {
 }
 
 /**
- * \brief Recursive function for add the differents AS to global dict
+ * \brief Recursive function for add the differents AS to global dict of network element
  *
  * This fuction is call by "parse_E_platform_add_parse_AS". It allow to add the 
  * AS or routing components, to the where_network_elements dictionary. In the same
  * way as "parse_S_host", "parse_S_router" and "parse_S_gateway" do.
  */
 static void _add_parse_AS(routing_component_t rc) {
+  xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,rc->name),
+     "The AS \"%s\" already exist",rc->name);
   xbt_dict_set(global_routing->where_network_elements,rc->name,rc->routing_father,NULL);
   xbt_dict_cursor_t cursor = NULL;
   char *key;
-  int *val;
   routing_component_t elem;
   xbt_dict_foreach(rc->routing_sons, cursor, key, elem) {
     _add_parse_AS(elem);
@@ -196,7 +322,7 @@ static void _add_parse_AS(routing_component_t rc) {
 }
 
 /**
- * \brief Add a "AS" to the network element list
+ * \brief Add all "AS" to the global dict of network element
  *
  * Allows find a "AS" in any routing component
  */
@@ -204,45 +330,38 @@ static void parse_E_platform_add_parse_AS(void) {
   _add_parse_AS(global_routing->root);
 }
 
-/* Global Business methods */
+/* Aux Business methods */
 
 /**
- * \brief Generic method: find a route between hosts
+ * \brief Get the AS father and the first elements of the chain
  *
  * \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
+ * Get the common father of the to processing units, and the first different 
+ * father in the chain
  */
-static xbt_dynar_t get_route(const char* src,const char* dst) {
+static xbt_dynar_t elements_father(const char* src,const char* dst) {
+  
+  xbt_assert0(src&&dst,"bad parameters for \"elements_father\" method");
+  
+  xbt_dynar_t result = xbt_dynar_new(sizeof(char*), NULL); // &xbt_free_ref
   
   routing_component_t src_as, dst_as;
   int index_src, index_dst, index_father_src, index_father_dst;
-  int *src_id, *dst_id;
   xbt_dynar_t path_src = NULL;
   xbt_dynar_t path_dst = NULL;
-  char *current_router_src, *current_router_dst;
   routing_component_t current = NULL;
-  routing_component_t* current_src_father;
-  routing_component_t* current_dst_father;
   routing_component_t* current_src = NULL;
   routing_component_t* current_dst = NULL;
-  routing_component_t* father;
-  route_extended_t tmp_route;
-  void* link;
-  route_extended_t route_center_links;
-  xbt_dynar_t path_src_links, path_dst_links, path_first, path_last;
-  int cpt;
+  routing_component_t* father = NULL;
   
-  xbt_dynar_reset(global_routing->last_route);
-  
-  /* (1) find the as-routetree where the src and dst are located */
+  /* (1) find the as where the src and dst are located */
   src_as = xbt_dict_get_or_null(global_routing->where_network_elements,src);
   dst_as = xbt_dict_get_or_null(global_routing->where_network_elements,dst); 
-  xbt_assert0(src_as != NULL && dst_as  != NULL, "Ask for route \"from\" or \"to\" no found");
+  xbt_assert2(src_as&&dst_as, "Ask for route \"from\"(%s) or \"to\"(%s) no found",src,dst);
   
-  /* (2) find the path to the root routing componen */
+  /* (2) find the path to the root routing component */
   path_src = xbt_dynar_new(sizeof(routing_component_t), NULL);
   current = src_as; 
   while( current != NULL ) {
@@ -271,97 +390,143 @@ static xbt_dynar_t get_route(const char* src,const char* dst) {
   index_dst++;
   current_src = xbt_dynar_get_ptr(path_src,index_src);
   current_dst = xbt_dynar_get_ptr(path_dst,index_dst);
+
+  /* (4) they are not in the same routing component, make the path */
+  index_father_src = index_src+1;
+  index_father_dst = index_dst+1;
+   
+  if(*current_src==*current_dst)
+    father = current_src;
+  else
+    father = xbt_dynar_get_ptr(path_src,index_father_src);
   
-  /* (4) if they are in the same routing component? */
-  if( *current_src == *current_dst ) {
+  /* (5) result generation */
+  xbt_dynar_push(result,father); // first same the father of src and dst
+  xbt_dynar_push(result,current_src); // second the first different father of src 
+  xbt_dynar_push(result,current_dst); // three  the first different father of dst
   
-    /* (5.1) belong to the same routing component */
-    tmp_route = (*(*current_src)->get_route)(*current_src,src,dst);
-    cpt = 0;
-    xbt_dynar_foreach(tmp_route->generic_route.link_list, cpt, link) {
-      xbt_dynar_push(global_routing->last_route,&link);
-    }
-      
-  } else {
+  xbt_dynar_free(&path_src);
+  xbt_dynar_free(&path_dst);
   
-    /* (5.2) they are not in the same routetree, make the path */
-    index_father_src = index_src+1;
-    index_father_dst = index_dst+1;
-    father = xbt_dynar_get_ptr(path_src,index_father_src);
-    route_center_links = (*((*father)->get_route))(*father,(*current_src)->name,(*current_dst)->name);
-    
-    /* (5.2.1) make the source path */
-    path_src_links = xbt_dynar_new(global_routing->size_of_link, NULL);
-    current_router_dst = route_center_links->src_gateway;  /* first router in the reverse path */
-    current_src_father = xbt_dynar_get_ptr(path_src,index_src);
-    index_src--;
-    for(index_src;index_src>=0;index_src--) {
-      current_src = xbt_dynar_get_ptr(path_src,index_src);
-      tmp_route = (*((*current_src_father)->get_route))(*current_src_father,(*current_src)->name,current_router_dst);
-      cpt = 0;
-      xbt_dynar_foreach(tmp_route->generic_route.link_list, cpt, link) {
-        //xbt_assert2(link!=NULL,"NULL link in the route from src %d to dst %d (5.2.1)", src, dst);
-        xbt_dynar_push(path_src_links,&link);
-      }
-      current_router_dst = tmp_route->src_gateway;
-      current_src_father = current_src;
-    }
+  return result;
+}
+
+/* Global Business methods */
+
+/**
+ * \brief Recursive function for get_route
+ *
+ * \param src the source host name 
+ * \param dst the destination host name
+ * 
+ * This fuction is call by "get_route". It allow to walk through the 
+ * routing components tree.
+ */
+static route_extended_t _get_route(const char* src,const char* dst) {
+  
+  void* link;
+  unsigned int cpt=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, e_route_src, e_route_dst;
+  
+  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);
+  routing_component_t src_father    = xbt_dynar_get_as(elem_father_list, 1, routing_component_t);
+  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 */
     
-    /* (5.2.2) make the destination path */
-    path_dst_links = xbt_dynar_new(global_routing->size_of_link, NULL);
-    current_router_src = route_center_links->dst_gateway;  /* last router in the reverse path */
-    current_dst_father = xbt_dynar_get_ptr(path_dst,index_dst);
-    index_dst--;
-    for(index_dst;index_dst>=0;index_dst--) {
-      current_dst = xbt_dynar_get_ptr(path_dst,index_dst);
-      tmp_route = (*((*current_dst_father)->get_route))(*current_dst_father,current_router_src,(*current_dst)->name);
-      cpt = 0;
-      xbt_dynar_foreach(tmp_route->generic_route.link_list, cpt, link) {
-        //xbt_assert2(link!=NULL,"NULL link in the route from src %d to dst %d (5.2.1)", src, dst);
-        xbt_dynar_push(path_dst_links,&link);
+    if( strcmp(src,dst) ){
+      e_route_cnt = (*(common_father->get_route))(common_father,src,dst);
+      xbt_dynar_foreach(e_route_cnt->generic_route.link_list, cpt, link) {
+        xbt_dynar_push(e_route->generic_route.link_list,&link);
       }
-      current_router_src = tmp_route->dst_gateway;
-      current_dst_father = current_dst;
+      xbt_dynar_free( &(e_route_cnt->generic_route.link_list) );
+      xbt_free(e_route_cnt);
     }
     
-    /* (5.2.3) the first part of the route */
-    path_first = ((*((*current_src)->get_route))(*current_src,src,current_router_dst))->generic_route.link_list;
+  } else { /* SURF_ROUTING_RECURSIVE */
     
-    /* (5.2.4) the last part of the route */
-    path_last  = ((*((*current_dst)->get_route))(*current_dst,dst,current_router_src))->generic_route.link_list;
-    
-    /* (5.2.5) make all paths together */
-    // FIXME: the paths non respect the right order
-    
-    cpt = 0;
-    xbt_dynar_foreach(path_first, cpt, link) {
-      xbt_dynar_push(global_routing->last_route,&link);
-    }
-    cpt = 0;
-    xbt_dynar_foreach(path_src_links, cpt, link) {
-      xbt_dynar_push(global_routing->last_route,&link);
-    }
-    cpt = 0;
-    xbt_dynar_foreach(route_center_links->generic_route.link_list, cpt, link) {
-      xbt_dynar_push(global_routing->last_route,&link);
-    }
-    cpt = 0;
-    xbt_dynar_foreach(path_dst_links, cpt, link) {
-      xbt_dynar_push(global_routing->last_route,&link);
-    }
-    cpt = 0;
-    xbt_dynar_foreach(path_last, cpt, link) {
-      xbt_dynar_push(global_routing->last_route,&link);
-    }
-    
-    xbt_dynar_free(&path_src_links);
-    xbt_dynar_free(&path_dst_links);
+      e_route_cnt = (*(common_father->get_route))(common_father,src_father->name,dst_father->name);
+      
+      xbt_assert2( (e_route_cnt->src_gateway==NULL) == (e_route_cnt->dst_gateway==NULL) ,
+        "bad gateway for route between \"%s\" and \"%s\"",src,dst);
+
+      if( src != e_route_cnt->src_gateway ) {
+        e_route_src = _get_route(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);
+        }
+      }
+      
+      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_dynar_foreach(e_route_dst->generic_route.link_list, cpt, link) {
+          xbt_dynar_push(e_route->generic_route.link_list,&link);
+        }
+      }
+      
+      e_route->src_gateway = e_route_cnt->src_gateway;
+      e_route->dst_gateway = e_route_cnt->dst_gateway;
+
+      xbt_dynar_free( &(e_route_src->generic_route.link_list) );
+      xbt_free(e_route_src);
+      xbt_dynar_free( &(e_route_cnt->generic_route.link_list) );
+      xbt_free(e_route_cnt);
+      xbt_dynar_free( &(e_route_dst->generic_route.link_list) );
+      xbt_free(e_route_dst);
   }
   
-  xbt_dynar_free(&path_src);
-  xbt_dynar_free(&path_dst); 
-         
-  return global_routing->last_route;
+  xbt_dynar_free(&elem_father_list);
+  
+  return e_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
+ */
+static xbt_dynar_t get_route(const char* src,const char* dst) {
+  
+  if(global_routing->last_route) xbt_dynar_free( &(global_routing->last_route) );
+  
+  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);
+  
+  if(strcmp(src,dst))
+    e_route = _get_route(src,dst);
+  else
+    e_route = (*(common_father->get_route))(common_father,src,dst);
+  
+  global_routing->last_route = e_route->generic_route.link_list;
+ 
+  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;
 }
 
 /**
@@ -380,8 +545,10 @@ static void _finalize(routing_component_t rc) {
     xbt_dict_foreach(rc->routing_sons, cursor, key, elem) {
       _finalize(elem);
     }
-    xbt_dict_free(&(rc->routing_sons));
-    xbt_free(rc->name);
+    xbt_dict_t tmp_sons = rc->routing_sons;
+    char* tmp_name = rc->name;
+    xbt_dict_free(&tmp_sons);
+    xbt_free(tmp_name);
     (*(rc->finalize))(rc);
   }
 }
@@ -426,121 +593,108 @@ void routing_model_create(size_t size_of_links, void* loopback) {
   /* parse generic elements */
   surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host);
   surfxml_add_callback(STag_surfxml_router_cb_list, &parse_S_router);
-  surfxml_add_callback(STag_surfxml_gateway_cb_list, &parse_S_gateway);
 
-  /* parse generic elements */
+  surfxml_add_callback(STag_surfxml_route_cb_list, &parse_S_route_new_and_endpoints);
+  surfxml_add_callback(STag_surfxml_ASroute_cb_list, &parse_S_ASroute_new_and_endpoints);
+  
+  surfxml_add_callback(ETag_surfxml_link_c_ctn_cb_list, &parse_E_link_c_ctn_new_elem);
+  
+  surfxml_add_callback(ETag_surfxml_route_cb_list, &parse_E_route_store_route);
+  surfxml_add_callback(ETag_surfxml_ASroute_cb_list, &parse_E_ASroute_store_route);
+  
   surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS);
   surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS);
-
+  
   /* set all the as in the global where table (recursive fuction) */
   surfxml_add_callback(ETag_surfxml_platform_cb_list, &parse_E_platform_add_parse_AS);
   
   /* DEBUG ONLY */  
-  surfxml_add_callback(ETag_surfxml_platform_cb_list, &DEGUB_exit);
-
+  //surfxml_add_callback(ETag_surfxml_platform_cb_list, &DEBUG_exit);
 }
 
+/* ************************************************************************** */
+/* ***************** GENERIC PARSE FUNCTIONS (declarations) ***************** */
+
+static void generic_set_processing_units(routing_component_t rc, const char* name);
+static void generic_set_autonomous_system(routing_component_t rc, const char* name);
+static void generic_set_route(routing_component_t rc, const char* src, const char* dst, route_t route);
+static void generic_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route);
+
+/* ************************************************************************** */
+/* ****************** GENERIC AUX FUNCTIONS (declarations) ****************** */
+
+static route_extended_t generic_new_extended_route(routing_component_t rc, void* data);
+
 /* ************************************************************************** */
 /* *************************** FULL ROUTING ********************************* */
 
-#define TO_ROUTE_FULL(i,j) ((routing_component_full_t)current_routing)->routing_table[(i)+(j)*xbt_dict_length(((routing_component_full_t)current_routing)->to_index)]
-#define TO_ROUTE_FULL_RC(i,j,rc) ((routing_component_full_t)rc)->routing_table[(i)+(j)*xbt_dict_length(((routing_component_full_t)rc)->to_index)]
+#define TO_ROUTE_FULL(i,j) routing->routing_table[(i)+(j)*table_size]
 
 /* Routing model structure */
 
 typedef struct {
   s_routing_component_t generic_routing;
-  xbt_dict_t to_index; /* char* -> index* */
+  xbt_dict_t parse_routes; /* store data during the parse process */
+  xbt_dict_t to_index; /* char* -> network_element_t */
   route_extended_t *routing_table;
-  xbt_dict_t parse_routes;
-} s_routing_componentl_full_t,*routing_component_full_t;
-
-/* Parse routing model functions */
-
-static char* src = NULL;    /* temporary store the source name of a route */
-static char* dst = NULL;    /* temporary store the destination name of a route */
-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 void full_parse_S_host(void) {
-  int *val = xbt_malloc(sizeof(int));
-  *val = xbt_dict_length(((routing_component_full_t)current_routing)->to_index);
-  xbt_dict_set(((routing_component_full_t)current_routing)->to_index,A_surfxml_host_id,val,xbt_free);
-}
-
-static void full_parse_S_gateway(void) {
-  int *val = xbt_malloc(sizeof(int));
-  *val = xbt_dict_length(((routing_component_full_t)current_routing)->to_index);
-  xbt_dict_set(((routing_component_full_t)current_routing)->to_index,A_surfxml_gateway_id,val,xbt_free);
-}
-
-static void full_parse_S_route_new_and_endpoints(void) {
-  if( src != NULL && dst != NULL && link_list != NULL )
-    THROW2(arg_error,0,"Route between %s to %s can not be defined",A_surfxml_route_src,A_surfxml_route_dst);
-  src = A_surfxml_route_src;
-  dst = A_surfxml_route_dst;
-  gw_src = A_surfxml_route_gw_src;
-  gw_dst = A_surfxml_route_gw_dst;
-  link_list = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
-}
-
-static void parse_E_link_c_ctn_new_elem(void) {
-  char *val;
-  val = xbt_strdup(A_surfxml_link_c_ctn_id);
-  xbt_dynar_push(link_list, &val);
-}
-
-static void full_parse_E_route_store_route(void) {
-  char *route_name;
-  route_name = bprintf("%s#%s#%s#%s",src,dst,gw_src,gw_dst);
-  // FIXME: if not exists
-  xbt_dict_set(((routing_component_full_t)current_routing)->parse_routes, route_name, link_list, NULL);
-  free(route_name);
-  src = NULL;
-  dst = NULL;
-  link_list = NULL;
-}
+} s_routing_component_full_t,*routing_component_full_t;
 
 /* Business methods */
 
 static route_extended_t full_get_route(routing_component_t rc, const char* src,const char* dst) {
+
+  routing_component_full_t routing = (routing_component_full_t)rc;
+  int table_size = xbt_dict_length(routing->to_index);
   
-  routing_component_full_t src_as, dst_as;
+  xbt_assert1(src && dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name);
+   
+  routing_component_t src_as, dst_as;
   int *src_id,*dst_id;
-  
-  // FIXME: here we can use the current_routing var.
-  
+
   src_as = xbt_dict_get_or_null(global_routing->where_network_elements,src);
   dst_as = xbt_dict_get_or_null(global_routing->where_network_elements,dst);
+   
+  xbt_assert3(src_as != NULL && dst_as  != NULL, "Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",src,dst,rc->name);
+  xbt_assert4(src_as == dst_as, "The src(%s in %s) and dst(%s in %s) are in differents AS",src,src_as->name,dst,dst_as->name);
+  xbt_assert2(rc == dst_as, "The routing component of src and dst is not the same as the network elements belong (%s==%s)",rc->name,dst_as->name);
+
+  src_id = xbt_dict_get(routing->to_index,src);
+  dst_id = xbt_dict_get(routing->to_index,dst);
+  xbt_assert2(src_id && dst_id, "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",src,dst); 
   
-  xbt_assert0(src_as != NULL && dst_as  != NULL, "Ask for route \"from\" or \"to\" no found");
- 
-  xbt_assert0(src_as == dst_as, "The src and dst are in differents AS");
-  
-  xbt_assert0((routing_component_full_t)rc == dst_as, "The routing component of src and dst is not the same as the network elements belong");
-  
-  src_id = (int*)xbt_dict_get(src_as->to_index,src);
-  dst_id = (int*)xbt_dict_get(dst_as->to_index,dst);
-  
-  xbt_assert0(src_id != NULL && dst_id  != NULL, "Ask for route \"from\" or \"to\" no found in the local table"); 
-  
-  return TO_ROUTE_FULL_RC(*src_id,*dst_id,src_as);
+  void* link;
+  unsigned int cpt=0;
+  route_extended_t new_e_route;
+  route_extended_t e_route = TO_ROUTE_FULL(*src_id,*dst_id);
+  if(e_route) {
+    new_e_route = xbt_new0(s_route_extended_t,1);
+    new_e_route->src_gateway = e_route->src_gateway;
+    new_e_route->dst_gateway = e_route->dst_gateway;
+    new_e_route->generic_route.link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
+    xbt_dynar_foreach(e_route->generic_route.link_list, cpt, link) {
+      xbt_dynar_push(new_e_route->generic_route.link_list,&link);
+    }
+  } else {
+    new_e_route = NULL;
+  }
+    return new_e_route;
 }
 
 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);
   int i,j;
   if (routing) {
-    int table_size = xbt_dict_length(routing->to_index);
     /* Delete routing table */
     for (i=0;i<table_size;i++) {
       for (j=0;j<table_size;j++) {
-        route_extended_t e_route = TO_ROUTE_FULL_RC(i,j,rc);
-        xbt_dynar_free(&(e_route->generic_route.link_list));
-        if(e_route->src_gateway) xbt_free(e_route->src_gateway);
-        if(e_route->dst_gateway) xbt_free(e_route->dst_gateway);
-        xbt_free(e_route);
+        route_extended_t e_route = TO_ROUTE_FULL(i,j);
+        if(e_route) {
+          xbt_dynar_free(&(e_route->generic_route.link_list));
+          if(e_route->src_gateway) xbt_free(e_route->src_gateway);
+          if(e_route->dst_gateway) xbt_free(e_route->dst_gateway);
+          xbt_free(e_route);
+        }
       }
     }
     xbt_free(routing->routing_table);
@@ -554,7 +708,11 @@ static void full_finalize(routing_component_t rc) {
 /* Creation routing model functions */
 
 static void* model_full_create() {
-  routing_component_full_t new_component =  xbt_new0(s_routing_componentl_full_t,1);
+  routing_component_full_t new_component =  xbt_new0(s_routing_component_full_t,1);
+  new_component->generic_routing.set_processing_units = generic_set_processing_units;
+  new_component->generic_routing.set_autonomous_system = generic_set_autonomous_system;
+  new_component->generic_routing.set_route = generic_set_route;
+  new_component->generic_routing.set_ASroute = generic_set_ASroute;
   new_component->generic_routing.get_route = full_get_route;
   new_component->generic_routing.finalize = full_finalize;
   new_component->to_index = xbt_dict_new();
@@ -563,128 +721,535 @@ static void* model_full_create() {
 }
 
 static void model_full_load() {
-  surfxml_add_callback(STag_surfxml_host_cb_list, &full_parse_S_host);
-  surfxml_add_callback(STag_surfxml_gateway_cb_list, &full_parse_S_gateway);
-  surfxml_add_callback(ETag_surfxml_link_c_ctn_cb_list, &parse_E_link_c_ctn_new_elem);
-  surfxml_add_callback(STag_surfxml_route_cb_list, &full_parse_S_route_new_and_endpoints);
-  surfxml_add_callback(ETag_surfxml_route_cb_list, &full_parse_E_route_store_route);
+ /* use "surfxml_add_callback" to add a parse function call */
 }
 
 static void model_full_unload() {
-  surfxml_del_callback(&STag_surfxml_host_cb_list, &full_parse_S_host);
-  surfxml_del_callback(&STag_surfxml_gateway_cb_list, &full_parse_S_gateway);
-  surfxml_del_callback(&ETag_surfxml_link_c_ctn_cb_list, &parse_E_link_c_ctn_new_elem);
-  surfxml_del_callback(&STag_surfxml_route_cb_list, &full_parse_S_route_new_and_endpoints);
-  surfxml_del_callback(&ETag_surfxml_route_cb_list, &full_parse_E_route_store_route);
+ /* use "surfxml_del_callback" to remove a parse function call */
 }
 
 static void  model_full_end() {
-
-  char *key, *end, *link_name, *src_name, *dst_name,  *src_gw_name, *dst_gw_name;
+  
+  char *key, *src_name, *dst_name;
   const char* sep = "#";
-  int *src_id, *dst_id, *src_gw_id, *dst_gw_id;
-  int i, j, cpt;
-  routing_component_t component;
-  xbt_dynar_t links;
+  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;
-  routing_component_full_t src_as;
-  routing_component_full_t dst_as;
   
+  /* set utils vars */
   routing_component_full_t routing = ((routing_component_full_t)current_routing);
-  
-  /* Add the AS found to local components  */
-  xbt_dict_foreach(current_routing->routing_sons, cursor, key, component) {
-    int *val = xbt_malloc(sizeof(int));
-    *val = xbt_dict_length(routing->to_index);
-    // FIXME: if exists
-    xbt_dict_set(routing->to_index,key,val,xbt_free);
-  }
-  
   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);
-  for (i=0;i<table_size;i++) {
-    for (j=0;j<table_size;j++) {
-      route_extended_t new_e_route = xbt_new0(s_route_extended_t,1);
-      new_e_route->generic_route.link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
-      new_e_route->src_gateway = NULL;
-      new_e_route->dst_gateway = NULL;
-      TO_ROUTE_FULL(i,j) = new_e_route;
-    }
-  }
   
   /* Put the routes in position */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, links) {
+  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
     
     keys = xbt_str_split_str(key, sep);
 
-    src_name    = xbt_dynar_get_as(keys, 0, char*);
-    dst_name    = xbt_dynar_get_as(keys, 1, char*);
-    src_gw_name = xbt_dynar_get_as(keys, 2, char*);
-    dst_gw_name = xbt_dynar_get_as(keys, 3, char*);
-      
+    src_name = xbt_dynar_get_as(keys, 0, char*);
+    dst_name = xbt_dynar_get_as(keys, 1, char*);
+    
     src_id = xbt_dict_get_or_null(routing->to_index, src_name);
     dst_id = xbt_dict_get_or_null(routing->to_index, dst_name);
     
     if (src_id == NULL || dst_id == NULL )
       THROW2(mismatch_error,0,"Network elements %s or %s not found", src_name, dst_name);
     
-    if( strlen(src_gw_name) != 0 ) {
-      src_as = xbt_dict_get_or_null(global_routing->where_network_elements,src_gw_name);
-      if (src_as == NULL)
-        THROW1(mismatch_error,0,"Network elements %s not found", src_gw_name);
-      src_gw_id = xbt_dict_get_or_null(src_as->to_index, src_gw_name);
-      if (src_gw_id == NULL)
-        THROW1(mismatch_error,0,"Network elements %s not found in the local tablfe", src_gw_name);
-    } else {
-      src_gw_name = NULL; // FIXME: maybe here put the same src_name.
+    TO_ROUTE_FULL(*src_id,*dst_id) = generic_new_extended_route(current_routing,data);
+
+     xbt_dynar_free(&keys);
+   }
+
+   /* 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);
+  }
+      
+  /* delete parse dict */
+  xbt_dict_free(&(routing->parse_routes));
+
+  /* Add the loopback if needed */
+  for (i = 0; i < table_size; i++) {
+    e_route = TO_ROUTE_FULL(i, i);
+    if(!e_route) { // && !xbt_dynar_length(e_route->generic_route.link_list)
+      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);
+      xbt_dynar_push(e_route->generic_route.link_list,&global_routing->loopback);
+      TO_ROUTE_FULL(i, i) = e_route;
     }
+  }
+
+  /* Shrink the dynar routes (save unused slots) */
+  for (i=0;i<table_size;i++)
+    for (j=0;j<table_size;j++)
+      if(TO_ROUTE_FULL(i,j))
+	xbt_dynar_shrink(TO_ROUTE_FULL(i,j)->generic_route.link_list,0);
+}
+
+/* ************************************************************************** */
+/* *************************** FLOYD ROUTING ******************************** */
+
+#define TO_FLOYD_COST(i,j) cost_table[(i)+(j)*table_size]
+#define TO_FLOYD_PRED(i,j) (routing->predecessor_table)[(i)+(j)*table_size]
+#define TO_FLOYD_LINK(i,j) (routing->link_table)[(i)+(j)*table_size]
+
+/* Routing model structure */
+
+typedef struct {
+  s_routing_component_t generic_routing;
+  /* vars for calculate the floyd algorith. */
+  int *predecessor_table;
+  route_extended_t *link_table; /* char* -> int* */
+  xbt_dict_t to_index;
+  /* store data during the parse process */  
+  xbt_dict_t parse_routes; 
+} s_routing_component_floyd_t,*routing_component_floyd_t;
+
+/* Business methods */
+
+static route_extended_t floyd_get_route(routing_component_t rc, const char* src,const char* dst) {
+  
+  xbt_assert1(src && dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name);
+  
+  /* set utils vars */
+  routing_component_floyd_t routing = (routing_component_floyd_t) rc;
+  int table_size = xbt_dict_length(routing->to_index);
+  
+  route_extended_t new_e_route = xbt_new0(s_route_extended_t,1);
+  new_e_route->generic_route.link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
+  new_e_route->src_gateway = NULL;
+  new_e_route->dst_gateway = NULL;
+  
+  int *src_id = xbt_dict_get(routing->to_index,src);
+  int *dst_id = xbt_dict_get(routing->to_index,dst);
+  xbt_assert2(src_id && dst_id, "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",src,dst); 
+
+  int first = 1;
+  int pred = *dst_id;
+  int prev_pred = 0;
+  char *gw_src,*gw_dst, *prev_gw_src,*prev_gw_dst, *first_gw;
+  unsigned int cpt;
+  void* link;
+  xbt_dynar_t links;
+  route_extended_t e_route_as_to_as;
+  do {
+    prev_pred = pred;
+    pred = TO_FLOYD_PRED(*src_id, pred);
+    if(pred == -1) // if no pred in route -> no route to host
+      break;      
+    xbt_assert2(TO_FLOYD_LINK(pred,prev_pred),"Invalid link for the route between \"%s\" or \"%s\"", src, dst);
+    
+    prev_gw_src = gw_src;
+    prev_gw_dst = gw_dst;
     
-    if( strlen(dst_gw_name) != 0 ) {
-      dst_as = xbt_dict_get_or_null(global_routing->where_network_elements,dst_gw_name);
-      if (dst_as == NULL)
-        THROW1(mismatch_error,0,"Network elements %s not found", dst_gw_name);
-      dst_gw_id = xbt_dict_get_or_null(dst_as->to_index, dst_gw_name);
-      if (dst_gw_id == NULL)
-        THROW1(mismatch_error,0,"Network elements %s not found in the local table", dst_gw_name);
-    } else {
-      dst_gw_name = NULL; // FIXME: maybe here put the same dst_name.
+    route_extended_t e_route = TO_FLOYD_LINK(pred,prev_pred);
+    gw_src = e_route->src_gateway;
+    gw_dst = e_route->dst_gateway;
+    
+    if(first) first_gw = gw_src;
+    
+    if(rc->hierarchy == SURF_ROUTING_RECURSIVE && !first && strcmp(prev_gw_dst,gw_src)) {
+      
+      routing_component_t src_as = xbt_dict_get_or_null(global_routing->where_network_elements,prev_gw_dst);
+      routing_component_t dst_as = xbt_dict_get_or_null(global_routing->where_network_elements,gw_src);
+      xbt_assert2(src_as==dst_as,"bad routing, differents AS gateways in route \"%s\" to \"%s\"",src,dst);
+      e_route_as_to_as = (*(src_as->get_route))(src_as,prev_gw_dst,gw_src);
+      links = e_route_as_to_as->generic_route.link_list;
+      xbt_dynar_foreach(links, cpt, link) {
+        xbt_dynar_push(new_e_route->generic_route.link_list,&link);
+      }
     }
     
-    TO_ROUTE_FULL(*src_id,*dst_id)->src_gateway = xbt_strdup(src_gw_name);
-    TO_ROUTE_FULL(*src_id,*dst_id)->dst_gateway = xbt_strdup(dst_gw_name);
+    links = e_route->generic_route.link_list;
+    xbt_dynar_foreach(links, cpt, link) {
+      xbt_dynar_push(new_e_route->generic_route.link_list,&link);
+    }
+    first=0;
     
-    xbt_dynar_foreach(links, cpt, link_name) {
-      void* link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
-      if (link)
-        xbt_dynar_push(TO_ROUTE_FULL(*src_id,*dst_id)->generic_route.link_list,&link);
-      else
-        THROW1(mismatch_error,0,"Link %s not found", link_name);
+  } while(pred != *src_id);
+  xbt_assert4(pred != -1, "no route from host %d to %d (\"%s\" to \"%s\")", *src_id, *dst_id,src,dst);
+  
+  if(rc->hierarchy == SURF_ROUTING_RECURSIVE) {
+    new_e_route->src_gateway = first_gw;
+    new_e_route->dst_gateway = gw_dst;
+  }
+  
+  return new_e_route;
+}
+
+static void floyd_finalize(routing_component_t rc) {
+   routing_component_floyd_t routing = (routing_component_floyd_t)rc;
+  int i,j,table_size;
+  if (routing) {
+    table_size = xbt_dict_length(routing->to_index);
+    /* Delete link_table */
+    for (i=0;i<table_size;i++) {
+      for (j=0;j<table_size;j++) {
+        route_extended_t e_route = TO_FLOYD_LINK(i,j);
+        if(e_route) {
+          xbt_dynar_free(&(e_route->generic_route.link_list));
+          if(e_route->src_gateway) xbt_free(e_route->src_gateway);
+          if(e_route->dst_gateway) xbt_free(e_route->dst_gateway);
+          xbt_free(e_route);
+        }
+      }
+    }
+    xbt_free(routing->link_table);
+    /* Delete index dict */
+    xbt_dict_free(&(routing->to_index));
+    /* Delete dictionary index dict, predecessor and links table */
+    xbt_free(routing->predecessor_table);
+    /* Delete structure */
+    xbt_free(rc);
+  }
+}
+
+static void* model_floyd_create(void) {
+  routing_component_floyd_t new_component = xbt_new0(s_routing_component_floyd_t,1);
+  new_component->generic_routing.set_processing_units = generic_set_processing_units;
+  new_component->generic_routing.set_autonomous_system = generic_set_autonomous_system;
+  new_component->generic_routing.set_route = generic_set_route;
+  new_component->generic_routing.set_ASroute = generic_set_ASroute;
+  new_component->generic_routing.get_route = floyd_get_route;
+  new_component->generic_routing.finalize = floyd_finalize;
+  new_component->to_index = xbt_dict_new();
+  new_component->parse_routes = xbt_dict_new();
+  return new_component;
+}
+
+static void  model_floyd_load() {
+ /* use "surfxml_add_callback" to add a parse function call */
+}
+
+static void  model_floyd_unload() {
+ /* use "surfxml_del_callback" to remove a parse function call */
+}
+
+static void  model_floyd_end() {
+  
+  routing_component_floyd_t routing = ((routing_component_floyd_t)current_routing);
+  xbt_dict_cursor_t cursor = NULL;
+  double * cost_table;
+  char *key,*data, *src_name, *dst_name;
+  const char *sep = "#";
+  xbt_dynar_t keys;
+  int *src_id, *dst_id;
+  unsigned int i,j,a,b,c;
+
+  /* set the size of inicial table */
+  int table_size = xbt_dict_length(routing->to_index);
+  
+  /* Create Cost, Predecessor and Link tables */
+  cost_table = xbt_new0(double, table_size*table_size); //link cost from host to host
+  routing->predecessor_table = xbt_new0(int, table_size*table_size); //predecessor host numbers
+  routing->link_table = xbt_new0(route_extended_t, table_size*table_size); //actual link between src and dst
+
+  /* Initialize costs and predecessors*/
+  for(i = 0; i<table_size;i++)
+    for(j = 0; j<table_size;j++) {
+        TO_FLOYD_COST(i,j) = DBL_MAX;
+        TO_FLOYD_PRED(i,j) = -1;
+        TO_FLOYD_LINK(i,j) = NULL; // FIXED DAVID
     }
 
-   // xbt_dynar_free(&links);
+   /* Put the routes in position */
+  xbt_dict_foreach(routing->parse_routes, cursor, key, data) {
+    
+    keys = xbt_str_split_str(key, sep);
+
+    src_name = xbt_dynar_get_as(keys, 0, char*);
+    dst_name = xbt_dynar_get_as(keys, 1, char*);
+    
+    src_id = xbt_dict_get_or_null(routing->to_index, src_name);
+    dst_id = xbt_dict_get_or_null(routing->to_index, dst_name);
+    
+    if (src_id == NULL || dst_id == NULL )
+      THROW2(mismatch_error,0,"Network elements %s or %s not found", src_name, dst_name);
+
+    TO_FLOYD_LINK(*src_id,*dst_id) = generic_new_extended_route(current_routing,data);
+    TO_FLOYD_PRED(*src_id,*dst_id) = *src_id;
+    
+    //link cost
+    TO_FLOYD_COST(*src_id,*dst_id) = 1; // assume 1 for now
+    
     xbt_dynar_free(&keys);
   }
- 
+
+  /* Add the loopback if needed */
+  for (i = 0; i < table_size; i++) {
+    route_extended_t e_route = TO_FLOYD_LINK(i, i);
+    if(!e_route) { // && !xbt_dynar_length(e_route->generic_route.link_list)
+      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);
+      xbt_dynar_push(e_route->generic_route.link_list,&global_routing->loopback);
+      TO_FLOYD_LINK(i,i) = e_route;
+      TO_FLOYD_PRED(i,i) = i;
+      TO_FLOYD_COST(i,i) = 1;
+    }
+  }
+
+  //Calculate path costs 
+  for(c=0;c<table_size;c++) {
+    for(a=0;a<table_size;a++) {
+      for(b=0;b<table_size;b++) {
+        if(TO_FLOYD_COST(a,c) < DBL_MAX && TO_FLOYD_COST(c,b) < DBL_MAX) {
+          if(TO_FLOYD_COST(a,b) == DBL_MAX || 
+            (TO_FLOYD_COST(a,c)+TO_FLOYD_COST(c,b) < TO_FLOYD_COST(a,b))) {
+            TO_FLOYD_COST(a,b) = TO_FLOYD_COST(a,c)+TO_FLOYD_COST(c,b);
+            TO_FLOYD_PRED(a,b) = TO_FLOYD_PRED(c,b);
+          }
+        }
+      }
+    }
+  }
+
    /* delete the parse table */
-  xbt_dict_foreach(routing->parse_routes, cursor, key, links) {
-    xbt_dynar_free(&links);
+  xbt_dict_foreach(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));
 
-  /* Add the loopback if needed */
-  for (i = 0; i < table_size; i++)
-    if (!xbt_dynar_length(TO_ROUTE_FULL(i, i)->generic_route.link_list))
-      xbt_dynar_push(TO_ROUTE_FULL(i,i)->generic_route.link_list,&global_routing->loopback);
+  //cleanup
+  free(cost_table);
+}
 
-  /* Shrink the dynar routes (save unused slots) */
-  for (i=0;i<table_size;i++)
-    for (j=0;j<table_size;j++)
-      xbt_dynar_shrink(TO_ROUTE_FULL(i,j)->generic_route.link_list,0);
+/* ************************************************************************** */
+/* ********** Dijkstra & Dijkstra Cached ROUTING **************************** */
+
+typedef struct {
+  s_routing_component_t generic_routing;
+  xbt_graph_t route_graph;
+  xbt_dict_t graph_node_map;
+  xbt_dict_t route_cache;
+  xbt_dynar_t last_route;
+  int cached;
+} s_routing_component_dijkstra_t,*routing_component_dijkstra_t;
+
+/* Parse routing model functions */
+
+/* Business methods */
+
+/* Creation routing model functions */
+
+static void* model_dijkstra_create() {
+  return NULL;
+}
+
+static void  model_dijkstra_load() {
+}
+
+static void  model_dijkstra_unload() {
+}
+
+static void  model_dijkstra_end() {
+}
+
+static void* model_dijkstracache_create() {
+  return NULL;
+}
+
+static void  model_dijkstracache_load() {
+}
+
+static void  model_dijkstracache_unload() {
+}
+
+static void  model_dijkstracache_end() {
+}
+
+
+/* ************************************************************************** */
+/* ******************************* NO ROUTING ******************************* */
+
+/* Routing model structure */
+typedef struct {
+  s_routing_component_t generic_routing;
+} s_routing_component_none_t,*routing_component_none_t;
+
+/* Business methods */
+static route_extended_t none_get_route(routing_component_t rc, const char* src,const char* dst){
+  return NULL;
+}
+static void none_finalize(routing_component_t rc) {
+  xbt_free(rc);
+}
+
+/* Creation routing model functions */
+static void* model_none_create() {
+  routing_component_none_t new_component =  xbt_new0(s_routing_component_none_t,1);
+  new_component->generic_routing.set_processing_units = NULL;
+  new_component->generic_routing.set_autonomous_system = NULL;
+  new_component->generic_routing.set_route = NULL;
+  new_component->generic_routing.set_ASroute = NULL;
+  new_component->generic_routing.get_route = none_get_route;
+  new_component->generic_routing.finalize = none_finalize;
+  return new_component;
+}
+
+static void  model_none_load() {}
+static void  model_none_unload() {}
+static void  model_none_end() {}
+
+/* ************************************************** */
+/* ********** PATERN FOR NEW ROUTING **************** */
+
+/* The minimal configuration of a new routing model need the next functions,
+ * also you need to set at the start of the file, the new model in the model
+ * list. Remember keep the null ending of the list.
+ */
+/* Routing model structure */
+typedef struct {
+  s_routing_component_t generic_routing;
+  /* things that your routing model need */
+} s_routing_component_NEW_t,*routing_component_NEW_t;
+
+/* Parse routing model functions */
+static void NEW_parse_S_host(void) {} /* example*/
+
+/* Business methods */
+static route_extended_t NEW_get_route(routing_component_t rc, const char* src,const char* dst) {return NULL;} /* mandatory */
+static void NEW_finalize(routing_component_t rc) {} /* mandatory */
+
+/* Creation routing model functions */
+static void* model_NEW_create() {return NULL;} /* mandatory */
+static void  model_NEW_load() {}   /* mandatory */
+static void  model_NEW_unload() {} /* mandatory */
+static void  model_NEW_end() {}    /* mandatory */
+
+/* ************************************************************************** */
+/* ************************* GENERIC PARSE FUNCTIONS ************************ */ 
+
+static void generic_set_processing_units(routing_component_t rc, const char* name) {
+   DEBUG1("Full - Load process unit \"%s\"",name);
+   model_type_t modeltype = rc->routing;
+   int *id = xbt_new0(int,1); // xbt_malloc(sizeof(int)); ?
+   xbt_dict_t index;
+   if(modeltype==&routing_models[SURF_MODEL_FULL])
+     index = ((routing_component_full_t)current_routing)->to_index;
+   else if(modeltype==&routing_models[SURF_MODEL_FLOYD])
+     index = ((routing_component_floyd_t)current_routing)->to_index;   
+   else xbt_die("\"generic_set_processing_units\" not support");
+   *id = xbt_dict_length(index);
+   xbt_dict_set(index,name,id,xbt_free);
+}
+
+static void generic_set_autonomous_system(routing_component_t rc, const char* name) {
+   DEBUG1("Full - Load Autonomous system \"%s\"",name);
+   model_type_t modeltype = rc->routing;
+   int *id = xbt_new0(int,1); // xbt_malloc(sizeof(int)); ?
+   xbt_dict_t index;
+   if(modeltype==&routing_models[SURF_MODEL_FULL])
+     index = ((routing_component_full_t)current_routing)->to_index;
+   else if(modeltype==&routing_models[SURF_MODEL_FLOYD])
+     index = ((routing_component_floyd_t)current_routing)->to_index;
+   else xbt_die("\"generic_set_autonomous_system\" not support");
+   *id = xbt_dict_length(index);
+   xbt_dict_set(index,name,id,xbt_free);
+}
+
+static void generic_set_route(routing_component_t rc, const char* src, const char* dst, route_t route) {
+  DEBUG2("Full - Load Route from \"%s\" to \"%s\"",src,dst);
+  model_type_t modeltype = rc->routing;
+  xbt_dict_t parseroutes;
+  if(modeltype==&routing_models[SURF_MODEL_FULL])
+    parseroutes = ((routing_component_full_t)current_routing)->parse_routes;
+  else if(modeltype==&routing_models[SURF_MODEL_FLOYD])
+    parseroutes = ((routing_component_floyd_t)current_routing)->parse_routes;
+  else xbt_die("\"generic_set_autonomous_system\" not support");
+  char *route_name;
+  route_name = bprintf("%s#%s",src,dst);
+  xbt_assert2(xbt_dynar_length(link_list)>0, "Invalid count of links, must be greater than zero (%s,%s)",src,dst);   
+  xbt_assert2(!xbt_dict_get_or_null(parseroutes,route_name),
+    "The route between \"%s\" and \"%s\" already exist",src,dst);
+  xbt_dict_set(parseroutes, route_name, route, NULL);
+  free(route_name);
+}
+
+static void generic_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) {
+  DEBUG4("Full - 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 parseroutes;
+  if(modeltype==&routing_models[SURF_MODEL_FULL])
+    parseroutes = ((routing_component_full_t)current_routing)->parse_routes;
+  else if(modeltype==&routing_models[SURF_MODEL_FLOYD])
+    parseroutes = ((routing_component_floyd_t)current_routing)->parse_routes;
+  else xbt_die("\"generic_set_autonomous_system\" not support");
+  char *route_name;
+  route_name = bprintf("%s#%s",src,dst);
+  xbt_assert2(xbt_dynar_length(link_list)>0, "Invalid count of links, must be greater than zero (%s,%s)",src,dst);   
+  xbt_assert4(!xbt_dict_get_or_null(parseroutes,route_name),
+    "The route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exist",src,e_route->src_gateway,dst,e_route->dst_gateway);
+  xbt_dict_set(parseroutes, route_name, e_route, NULL);
+  free(route_name);
+}
+
+/* ************************************************************************** */
+/* ************************* GENERIC AUX FUNCTIONS ************************** */
+
+static route_extended_t generic_new_extended_route(routing_component_t rc, void* data) {
+  
+  char *link_name;
+  route_extended_t e_route, new_e_route;
+  route_t route;
+  unsigned int cpt;
+  xbt_dynar_t links, links_id;
+  
+  new_e_route = xbt_new0(s_route_extended_t,1);
+  new_e_route->generic_route.link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
+  new_e_route->src_gateway = NULL;
+  new_e_route->dst_gateway = NULL;
+
+  xbt_assert0(rc->hierarchy == SURF_ROUTING_BASE || rc->hierarchy == SURF_ROUTING_RECURSIVE,
+      "the hierarchy type is not defined");
+  
+  if(rc->hierarchy == SURF_ROUTING_BASE ) {
+    
+    route = (route_t)data;
+    links = route->link_list;
+    
+  } else if(rc->hierarchy == SURF_ROUTING_RECURSIVE ) {
+
+    e_route = (route_extended_t)data;
+    
+    // FIXME: HERE CHECK THE GATEWAY!!!!!!!!!
+    xbt_assert0(e_route->src_gateway&&e_route->dst_gateway,"bad gateway, is null");
+    
+    links = e_route->generic_route.link_list;
+    
+    /* remeber not erase the gateway names */
+    new_e_route->src_gateway = e_route->src_gateway;
+    new_e_route->dst_gateway = e_route->dst_gateway;
+  }
+  
+  links_id = new_e_route->generic_route.link_list;
+  
+  xbt_dynar_foreach(links, cpt, link_name) {
+    
+    void* link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
+    if (link)
+      xbt_dynar_push(links_id,&link);
+    else
+      THROW1(mismatch_error,0,"Link %s not found", link_name);
+  }
+ 
+  return new_e_route;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -698,15 +1263,19 @@ static void print_tree(routing_component_t rc) {
   xbt_dict_cursor_t cursor = NULL;
   char *key;
   int *val;  
-  xbt_dict_foreach(((routing_component_full_t)rc)->to_index, cursor, key, val) {
-    printf("<%s-%d> ",key,*val);
+  if( rc->routing == &(routing_models[SURF_MODEL_FULL]) )
+  { xbt_dict_foreach(((routing_component_full_t)rc)->to_index, cursor, key, val) { printf("<%s-%d> ",key,*val); } }
+  else if( rc->routing == &(routing_models[SURF_MODEL_FLOYD]) )
+  { xbt_dict_foreach(((routing_component_floyd_t)rc)->to_index, cursor, key, val) { printf("<%s-%d> ",key,*val); } 
   }
+  else
+      xbt_assert0(0, "Invalid model for call \"print_tree\"");
   printf("\n");  
   routing_component_t elem;
   xbt_dict_foreach(rc->routing_sons, cursor, key, elem) {
     printf("<--\n");  
     print_tree(elem);
-    printf("-->\n");      
+    printf("-->\n");
   }
 }
 
@@ -715,21 +1284,19 @@ static void print_global() {
   xbt_dict_cursor_t cursor = NULL;
   char *key;
   routing_component_t elem;  
-  xbt_dict_foreach(global_routing->where_network_elements, cursor, key, elem) {
-    printf("<%s>\n",key);
-  }
+  xbt_dict_foreach(global_routing->where_network_elements, cursor, key, elem) { printf("<%s>\n",key); }
 }
 
 //...... DEBUG ONLY .... //
 static void print_AS_start(void) { printf("AS!!! %s y se rutea \"%s\"\n",A_surfxml_AS_id,A_surfxml_AS_routing); }
-static void print_AS_end(void) { printf("AS!!! %s\n",A_surfxml_AS_id); }
-static void print_host(void) { printf("host!!! %s\n",A_surfxml_host_id); }
-static void print_link(void) { printf("link!!! %s\n",A_surfxml_link_id); }
-static void print_route(void) { printf("route!!! %s a %s\n",A_surfxml_route_src,A_surfxml_route_dst); }
-static void print_ctn(void) { printf("ctn!!! %s\n",A_surfxml_link_c_ctn_id); }
+static void print_AS_end(void)   { printf("AS!!! %s\n",A_surfxml_AS_id); }
+static void print_host(void)     { printf("host!!! %s\n",A_surfxml_host_id); }
+static void print_link(void)     { printf("link!!! %s\n",A_surfxml_link_id); }
+static void print_route(void)    { printf("route!!! %s a %s\n",A_surfxml_route_src,A_surfxml_route_dst); }
+static void print_ctn(void)      { printf("ctn!!! %s\n",A_surfxml_link_c_ctn_id); }
 
 //...... DEBUG ONLY .... //
-static void DEGUB_exit(void) {
+static void DEBUG_exit(void) {
   
   printf("-------- print tree elements -----\n");
   print_tree(global_routing->root);
@@ -739,16 +1306,40 @@ static void DEGUB_exit(void) {
   print_global();
   printf("----------------------------------\n\n");
   
+//   char* names[] = { "11.A","11.B","11.C","121.A","121.B","122.A","13.A","13.B"};
+//   int i,j,total = 8;
+
+//   printf("-- print all the example routes --\n");
+//   char* names[] = { "11.A","11.B","11.C"};
+//   int i,j,total = 3;
+
+//   char* names[] = { "141.A","141.B","143.A","143.B"};
+//   int i,j,total = 4;
+
+//   char* names[] = { "142.A","142.B","142.C" };
+//   int i,j,total = 3;
+
+//   const char* names[] = { "142.A","142.B","142.C", "11.A","11.B","11.C","141.A","141.B","143.A","143.B","11.A","11.B","11.C","121.A","121.B","122.A","13.A","13.B"};
+//   int i,j,total = 3+4+8+3;
+
+   const char* names[] = { "11.A","11.B","11.C",
+                           "121.A","121.B",
+                           "122.A",
+                           "13.A","13.B",
+                           "141.A","141.B",
+                           "142.A","142.B","142.C",
+                           "143.A","143.B",
+                           "15.A","15.B","15.C"};
+   unsigned int i,j,total = 3+2+1+2+2+3+2+3;
+
   printf("-- print all the example routes --\n");
-  char* names[] = { "11.A","11.B","11.C","121.A","121.B","122.A","13.A","13.B"};
-  int i,j,total = 8;
   xbt_dynar_t links;
   void* link;
   for(i=0;i<total;i++) {
     for(j=0;j<total;j++) {
-      links = (*(global_routing->get_route))(names[i],names[j]);
       printf("route from %s to %s >>> ",names[i],names[j]);
-      int cpt=0;
+      links = (*(global_routing->get_route))(names[i],names[j]);
+      unsigned int cpt=0;
       xbt_dynar_foreach(links, cpt, link) {
         s_surf_resource_t* generic_resource = link;
         printf(" %s",generic_resource->name);
@@ -756,6 +1347,7 @@ static void DEGUB_exit(void) {
       printf("\n");
     }
   }
+  
   printf("----------------------------------\n\n");
   
   printf("---------- call finalize ---------\n");