src/surf/surf_routing.c

   1 /* Copyright (c) 2009, 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7
   8
   9 #include <float.h>
  10 #include "gras_config.h"
  11
  12 #ifdef HAVE_PCRE_LIB
  13 #include <pcre.h>               /* regular expresion library */
  14 #endif
  15 #include "surf_private.h"
  16 #include "xbt/dynar.h"
  17 #include "xbt/str.h"
  18 #include "xbt/config.h"
  19 #include "xbt/graph.h"
  20 #include "xbt/set.h"
  21
  22 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf");
  23
  24 /* Global vars */
  25 routing_global_t global_routing = NULL;
  26 routing_component_t current_routing = NULL;
  27 model_type_t current_routing_model = NULL;
  28 static double_f_cpvoid_t get_link_latency = NULL;
  29
  30 /* Prototypes of each model */
  31 static void *model_full_create(void);   /* create structures for full routing model */
  32 static void model_full_load(void);      /* load parse functions for full routing model */
  33 static void model_full_unload(void);    /* unload parse functions for full routing model */
  34 static void model_full_end(void);       /* finalize the creation of full routing model */
  35 static void model_full_set_route(               /* Set the route and ASroute between src and dst */
  36                 routing_component_t rc, const char *src, const char *dst, name_route_extended_t route);
  37
  38 static void *model_floyd_create(void);  /* create structures for floyd routing model */
  39 static void model_floyd_load(void);     /* load parse functions for floyd routing model */
  40 static void model_floyd_unload(void);   /* unload parse functions for floyd routing model */
  41 static void model_floyd_end(void);      /* finalize the creation of floyd routing model */
  42 static void model_floyd_set_route(routing_component_t rc, const char *src,
  43         const char *dst, name_route_extended_t route);
  44
  45 static void *model_dijkstra_both_create(int cached);    /* create by calling dijkstra or dijkstracache */
  46 static void *model_dijkstra_create(void);       /* create structures for dijkstra routing model */
  47 static void *model_dijkstracache_create(void);  /* create structures for dijkstracache routing model */
  48 static void model_dijkstra_both_load(void);     /* load parse functions for dijkstra routing model */
  49 static void model_dijkstra_both_unload(void);   /* unload parse functions for dijkstra routing model */
  50 static void model_dijkstra_both_end(void);      /* finalize the creation of dijkstra routing model */
  51 static void model_dijkstra_both_set_route (routing_component_t rc, const char *src,
  52                      const char *dst, name_route_extended_t route);
  53
  54 static void *model_rulebased_create(void);      /* create structures for rulebased routing model */
  55 static void model_rulebased_load(void); /* load parse functions for rulebased routing model */
  56 static void model_rulebased_unload(void);       /* unload parse functions for rulebased routing model */
  57 static void model_rulebased_end(void);  /* finalize the creation of rulebased routing model */
  58
  59 static void *model_none_create(void);   /* none routing model */
  60 static void model_none_load(void);      /* none routing model */
  61 static void model_none_unload(void);    /* none routing model */
  62 static void model_none_end(void);       /* none routing model */
  63
  64 static void routing_parse_Scluster(void);  /*cluster bypass */
  65 static void routing_parse_Speer(void);          /*peer bypass */
  66
  67 static void routing_parse_Sconfig(void);        /*config Tag */
  68 static void routing_parse_Econfig(void);        /*config Tag */
  69
  70 /* this lines are only for replace use like index in the model table */
  71 typedef enum {
  72   SURF_MODEL_FULL = 0,
  73   SURF_MODEL_FLOYD,
  74   SURF_MODEL_DIJKSTRA,
  75   SURF_MODEL_DIJKSTRACACHE,
  76   SURF_MODEL_NONE,
  77 #ifdef HAVE_PCRE_LIB
  78   SURF_MODEL_RULEBASED
  79 #endif
  80 } e_routing_types;
  81
  82
  83 /* must be finish with null and carefull if change de order */
  84 struct s_model_type routing_models[] = { {"Full",
  85                                           "Full routing data (fast, large memory requirements, fully expressive)",
  86                                           model_full_create,
  87                                           model_full_load,
  88                                           model_full_unload,
  89                                           model_full_end},
  90 {"Floyd",
  91  "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)",
  92  model_floyd_create, model_floyd_load, model_floyd_unload,
  93  model_floyd_end},
  94 {"Dijkstra",
  95  "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)",
  96  model_dijkstra_create, model_dijkstra_both_load,
  97  model_dijkstra_both_unload, model_dijkstra_both_end},
  98 {"DijkstraCache",
  99  "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)",
 100  model_dijkstracache_create, model_dijkstra_both_load,
 101  model_dijkstra_both_unload, model_dijkstra_both_end},
 102 {"none", "No routing (usable with Constant network only)",
 103  model_none_create, model_none_load, model_none_unload, model_none_end},
 104 #ifdef HAVE_PCRE_LIB
 105 {"RuleBased", "Rule-Based routing data (...)", model_rulebased_create,
 106  model_rulebased_load, model_rulebased_unload, model_rulebased_end},
 107 {"Vivaldi", "Vivaldi routing", model_rulebased_create,
 108   model_rulebased_load, model_rulebased_unload, model_rulebased_end},
 109 #endif
 110 {NULL, NULL, NULL, NULL, NULL, NULL}
 111 };
 112
 113 /* ************************************************************************** */
 114 /* ***************** GENERIC PARSE FUNCTIONS (declarations) ***************** */
 115
 116 static void generic_set_processing_unit(routing_component_t rc,
 117                                         const char *name);
 118 static void generic_set_autonomous_system(routing_component_t rc,
 119                                           const char *name);
 120 static void generic_set_bypassroute(routing_component_t rc,
 121                                     const char *src, const char *dst,
 122                                     route_extended_t e_route);
 123
 124 static int surf_link_resource_cmp(const void *a, const void *b);
 125 static int surf_pointer_resource_cmp(const void *a, const void *b);
 126
 127 /* ************************************************************************** */
 128 /* *************** GENERIC BUSINESS METHODS (declarations) ****************** */
 129
 130 static double generic_get_link_latency(routing_component_t rc, const char *src, const char *dst);
 131 static xbt_dynar_t generic_get_onelink_routes(routing_component_t rc);
 132 static route_extended_t generic_get_bypassroute(routing_component_t rc,
 133                                                 const char *src,
 134                                                 const char *dst);
 135
 136 /* ************************************************************************** */
 137 /* ****************** GENERIC AUX FUNCTIONS (declarations) ****************** */
 138
 139 static route_extended_t
 140 generic_new_extended_route(e_surf_routing_hierarchy_t hierarchy,
 141                            void *data, int order);
 142 static route_t
 143 generic_new_route(e_surf_routing_hierarchy_t hierarchy,
 144                            void *data, int order);
 145 static void generic_free_route(route_t route);
 146 static void generic_free_extended_route(route_extended_t e_route);
 147 static routing_component_t
 148 generic_autonomous_system_exist(routing_component_t rc, char *element);
 149 static routing_component_t
 150 generic_processing_units_exist(routing_component_t rc, char *element);
 151 static void generic_src_dst_check(routing_component_t rc, const char *src,
 152                                   const char *dst);
 153
 154 /* ************************************************************************** */
 155 /* **************************** GLOBAL FUNCTIONS **************************** */
 156
 157 /* global parse functions */
 158 static const char *src = NULL;        /* temporary store the source name of a route */
 159 static const char *dst = NULL;        /* temporary store the destination name of a route */
 160 static char *gw_src = NULL;     /* temporary store the gateway source name of a route */
 161 static char *gw_dst = NULL;     /* temporary store the gateway destination name of a route */
 162 static xbt_dynar_t link_list = NULL;    /* temporary store of current list link of a route */
 163
 164 static xbt_dict_t coordinates = NULL;
 165
 166
 167 static double eculidean_dist_comp(int index, xbt_dynar_t src, xbt_dynar_t dst)
 168 {
 169         double src_coord, dst_coord;
 170
 171         src_coord = atof(xbt_dynar_get_as(src, index, char *));
 172         dst_coord = atof(xbt_dynar_get_as(dst, index, char *));
 173
 174         return (src_coord-dst_coord)*(src_coord-dst_coord);
 175
 176 }
 177
 178 static double vivaldi_get_link_latency (routing_component_t rc,
 179                                                                                                                                                                 const char *src, const char *dst)
 180 {
 181   double euclidean_dist;
 182   xbt_dynar_t src_ctn, dst_ctn;
 183   src_ctn = xbt_dict_get(coordinates, src);
 184   dst_ctn = xbt_dict_get(coordinates, dst);
 185
 186   euclidean_dist = sqrt (eculidean_dist_comp(0,src_ctn,dst_ctn)+eculidean_dist_comp(1,src_ctn,dst_ctn))
 187                                                                 +fabs(atof(xbt_dynar_get_as(src_ctn, 2, char *)))+fabs(atof(xbt_dynar_get_as(dst_ctn, 2, char *)));
 188
 189   xbt_assert2(euclidean_dist>=0, "Euclidean Dist is less than 0\"%s\" and \"%.2f\"", src, euclidean_dist);
 190
 191   return euclidean_dist;
 192
 193   /*
 194   x = atof(xbt_dynar_get_as(src_ctn, 0, char *))-atof(xbt_dynar_get_as(dst_ctn, 0, char *));
 195   y = atof(xbt_dynar_get_as(src_ctn, 1, char *));
 196   h = atof(xbt_dynar_get_as(ctn, 2, char *));
 197   sqrt((c1->x - c2->x) * (c1->x - c2->x) + (c1->y - c2->y) * (c1->y - c2->y)) + fabs(c1->h) + fabs(c2->h);
 198
 199           if (strcmp(coord,"")) {
 200         xbt_dynar_t ctn = xbt_str_split_str(coord, " ");
 201         xbt_dynar_shrink(ctn,0);
 202         xbt_dict_set (coordinates,host_id,ctn,NULL);
 203   }
 204         */
 205 }
 206
 207 /**
 208  * \brief Add a "host" to the network element list
 209  */
 210 static void parse_S_host(const char *host_id, const char* coord)
 211 {
 212   network_element_info_t info = NULL;
 213   if (current_routing->hierarchy == SURF_ROUTING_NULL)
 214     current_routing->hierarchy = SURF_ROUTING_BASE;
 215   xbt_assert1(!xbt_dict_get_or_null
 216               (global_routing->where_network_elements, host_id),
 217               "Reading a host, processing unit \"%s\" already exists",
 218               host_id);
 219   xbt_assert1(current_routing->set_processing_unit,
 220               "no defined method \"set_processing_unit\" in \"%s\"",
 221               current_routing->name);
 222   (*(current_routing->set_processing_unit)) (current_routing, host_id);
 223   info = xbt_new0(s_network_element_info_t, 1);
 224   info->rc_component = current_routing;
 225   info->rc_type = SURF_NETWORK_ELEMENT_HOST;
 226   xbt_dict_set(global_routing->where_network_elements, host_id,
 227                (void *) info, xbt_free);
 228
 229   if (strcmp(coord,"")) {
 230         xbt_dynar_t ctn = xbt_str_split_str(coord, " ");
 231         xbt_dynar_shrink(ctn,0);
 232         xbt_dict_set (coordinates,host_id,ctn,NULL);
 233   }
 234 }
 235
 236 static void parse_E_host(void)
 237 {
 238          xbt_dict_cursor_t cursor = NULL;
 239           char *key;
 240           char *elem;
 241
 242           xbt_dict_foreach(current_property_set, cursor, key, elem) {
 243                   DEBUG2("property : %s = %s",key,elem);
 244                 }
 245 }
 246
 247 /*
 248  * \brief Add a host to the network element list from XML
 249  */
 250 static void parse_S_host_XML(void)
 251 {
 252         parse_S_host(A_surfxml_host_id, A_surfxml_host_coordinates);
 253 }
 254 static void parse_E_host_XML(void)
 255 {
 256         parse_E_host();
 257 }
 258
 259 /*
 260  * \brief Add a host to the network element list from lua script
 261  */
 262 static void parse_S_host_lua(const char *host_id, const char *coord)
 263 {
 264   parse_S_host(host_id, coord);
 265 }
 266
 267
 268 /**
 269  * \brief Add a "router" to the network element list
 270  */
 271 static void parse_S_router(void)
 272 {
 273   network_element_info_t info = NULL;
 274
 275   if (current_routing->hierarchy == SURF_ROUTING_NULL)
 276     current_routing->hierarchy = SURF_ROUTING_BASE;
 277   xbt_assert1(!xbt_dict_get_or_null
 278               (global_routing->where_network_elements,
 279                A_surfxml_router_id),
 280               "Reading a router, processing unit \"%s\" already exists",
 281               A_surfxml_router_id);
 282   xbt_assert1(current_routing->set_processing_unit,
 283               "no defined method \"set_processing_unit\" in \"%s\"",
 284               current_routing->name);
 285   (*(current_routing->set_processing_unit)) (current_routing,
 286                                              A_surfxml_router_id);
 287   info = xbt_new0(s_network_element_info_t, 1);
 288   info->rc_component = current_routing;
 289   info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
 290   xbt_dict_set(global_routing->where_network_elements, A_surfxml_router_id,
 291                (void *) info, xbt_free);
 292   if (strcmp(A_surfxml_router_coordinates,"")) {
 293         xbt_dynar_t ctn = xbt_str_split_str(A_surfxml_router_coordinates, " ");
 294         xbt_dynar_shrink(ctn,0);
 295         xbt_dict_set (coordinates,A_surfxml_router_id,ctn,NULL);
 296   }
 297 }
 298
 299 /**
 300  * \brief Set the endponints for a route
 301  */
 302 static void parse_S_route_new_and_endpoints(const char *src_id, const char *dst_id)
 303 {
 304   if (src != NULL && dst != NULL && link_list != NULL)
 305     THROW2(arg_error, 0, "Route between %s to %s can not be defined",
 306            src_id, dst_id);
 307   src = src_id;
 308   dst = dst_id;
 309   xbt_assert2(strlen(src) > 0 || strlen(dst) > 0,
 310               "Some limits are null in the route between \"%s\" and \"%s\"",
 311               src, dst);
 312   link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 313 }
 314
 315 /**
 316  * \brief Set the endpoints for a route from XML
 317  */
 318 static void parse_S_route_new_and_endpoints_XML(void)
 319 {
 320   parse_S_route_new_and_endpoints(A_surfxml_route_src,
 321                                   A_surfxml_route_dst);
 322 }
 323
 324 /**
 325  * \brief Set the endpoints for a route from lua
 326  */
 327 static void parse_S_route_new_and_endpoints_lua(const char *id_src, const char *id_dst)
 328 {
 329   parse_S_route_new_and_endpoints(id_src, id_dst);
 330 }
 331
 332 /**
 333  * \brief Set the endponints and gateways for a ASroute
 334  */
 335 static void parse_S_ASroute_new_and_endpoints(void)
 336 {
 337   if (src != NULL && dst != NULL && link_list != NULL)
 338     THROW2(arg_error, 0, "Route between %s to %s can not be defined",
 339            A_surfxml_ASroute_src, A_surfxml_ASroute_dst);
 340   src = A_surfxml_ASroute_src;
 341   dst = A_surfxml_ASroute_dst;
 342   gw_src = A_surfxml_ASroute_gw_src;
 343   gw_dst = A_surfxml_ASroute_gw_dst;
 344   xbt_assert2(strlen(src) > 0 || strlen(dst) > 0 || strlen(gw_src) > 0
 345               || strlen(gw_dst) > 0,
 346               "Some limits are null in the route between \"%s\" and \"%s\"",
 347               src, dst);
 348   link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 349 }
 350
 351 /**
 352  * \brief Set the endponints for a bypassRoute
 353  */
 354 static void parse_S_bypassRoute_new_and_endpoints(void)
 355 {
 356   if (src != NULL && dst != NULL && link_list != NULL)
 357     THROW2(arg_error, 0,
 358            "Bypass Route between %s to %s can not be defined",
 359            A_surfxml_bypassRoute_src, A_surfxml_bypassRoute_dst);
 360   src = A_surfxml_bypassRoute_src;
 361   dst = A_surfxml_bypassRoute_dst;
 362   gw_src = A_surfxml_bypassRoute_gw_src;
 363   gw_dst = A_surfxml_bypassRoute_gw_dst;
 364   xbt_assert2(strlen(src) > 0 || strlen(dst) > 0 || strlen(gw_src) > 0
 365               || strlen(gw_dst) > 0,
 366               "Some limits are null in the route between \"%s\" and \"%s\"",
 367               src, dst);
 368   link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 369 }
 370
 371 /**
 372  * \brief Set a new link on the actual list of link for a route or ASroute
 373  */
 374 static void parse_E_link_ctn_new_elem(const char *link_id)
 375 {
 376   char *val;
 377   val = xbt_strdup(link_id);
 378   xbt_dynar_push(link_list, &val);
 379 }
 380
 381 /**
 382  * \brief Set a new link on the actual list of link for a route or ASroute from XML
 383  */
 384
 385 static void parse_E_link_ctn_new_elem_XML(void)
 386 {
 387   if (A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_NONE)
 388     parse_E_link_ctn_new_elem(A_surfxml_link_ctn_id);
 389   if (A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_UP) {
 390     char *link_id = bprintf("%s_UP", A_surfxml_link_ctn_id);
 391     parse_E_link_ctn_new_elem(link_id);
 392     free(link_id);
 393   }
 394   if (A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_DOWN) {
 395     char *link_id = bprintf("%s_DOWN", A_surfxml_link_ctn_id);
 396     parse_E_link_ctn_new_elem(link_id);
 397     free(link_id);
 398   }
 399 }
 400
 401 /**
 402  * \brief Set a new link on the actual list of link for a route or ASroute from lua
 403  */
 404 static void parse_E_link_c_ctn_new_elem_lua(const char *link_id)
 405 {
 406   parse_E_link_ctn_new_elem(link_id);
 407 }
 408
 409 /**
 410  * \brief Store the route by calling the set_route function of the current routing component
 411  */
 412 static void parse_E_route_store_route(void)
 413 {
 414   name_route_extended_t route = xbt_new0(s_name_route_extended_t, 1);
 415   route->generic_route.link_list = link_list;
 416   xbt_assert1(current_routing->set_route,
 417               "no defined method \"set_route\" in \"%s\"",
 418               current_routing->name);
 419   (*(current_routing->set_route)) (current_routing, src, dst, route);
 420   link_list = NULL;
 421   src = NULL;
 422   dst = NULL;
 423 }
 424
 425 /**
 426  * \brief Store the ASroute by calling the set_ASroute function of the current routing component
 427  */
 428 static void parse_E_ASroute_store_route(void)
 429 {
 430   name_route_extended_t e_route = xbt_new0(s_name_route_extended_t, 1);
 431   e_route->generic_route.link_list = link_list;
 432   e_route->src_gateway = xbt_strdup(gw_src);
 433   e_route->dst_gateway = xbt_strdup(gw_dst);
 434   xbt_assert1(current_routing->set_ASroute,
 435               "no defined method \"set_ASroute\" in \"%s\"",
 436               current_routing->name);
 437   (*(current_routing->set_ASroute)) (current_routing, src, dst, e_route);
 438   link_list = NULL;
 439   src = NULL;
 440   dst = NULL;
 441   gw_src = NULL;
 442   gw_dst = NULL;
 443 }
 444
 445 /**
 446  * \brief Store the bypass route by calling the set_bypassroute function of the current routing component
 447  */
 448 static void parse_E_bypassRoute_store_route(void)
 449 {
 450   route_extended_t e_route = xbt_new0(s_route_extended_t, 1);
 451   e_route->generic_route.link_list = link_list;
 452   e_route->src_gateway = xbt_strdup(gw_src);
 453   e_route->dst_gateway = xbt_strdup(gw_dst);
 454   xbt_assert1(current_routing->set_bypassroute,
 455               "no defined method \"set_bypassroute\" in \"%s\"",
 456               current_routing->name);
 457   (*(current_routing->set_bypassroute)) (current_routing, src, dst,
 458                                          e_route);
 459   link_list = NULL;
 460   src = NULL;
 461   dst = NULL;
 462   gw_src = NULL;
 463   gw_dst = NULL;
 464 }
 465
 466 /**
 467  * \brief Make a new routing component
 468  *
 469  * make the new structure and
 470  * set the parsing functions to allows parsing the part of the routing tree
 471  */
 472 static void parse_S_AS(char *AS_id, char *AS_routing)
 473 {
 474   routing_component_t new_routing;
 475   model_type_t model = NULL;
 476   char *wanted = AS_routing;
 477   int cpt;
 478   /* seach the routing model */
 479   for (cpt = 0; routing_models[cpt].name; cpt++)
 480     if (!strcmp(wanted, routing_models[cpt].name))
 481       model = &routing_models[cpt];
 482   /* if its not exist, error */
 483   if (model == NULL) {
 484     fprintf(stderr, "Routing model %s not found. Existing models:\n",
 485             wanted);
 486     for (cpt = 0; routing_models[cpt].name; cpt++)
 487       if (!strcmp(wanted, routing_models[cpt].name))
 488         fprintf(stderr, "   %s: %s\n", routing_models[cpt].name,
 489                 routing_models[cpt].desc);
 490     xbt_die(NULL);
 491   }
 492
 493   /* make a new routing component */
 494   new_routing = (routing_component_t) (*(model->create)) ();
 495   new_routing->routing = model;
 496   new_routing->hierarchy = SURF_ROUTING_NULL;
 497   new_routing->name = xbt_strdup(AS_id);
 498   new_routing->routing_sons = xbt_dict_new();
 499
 500   /* Hack for Vivaldi */
 501   if(!strcmp(model->name,"Vivaldi"))
 502         new_routing->get_latency = vivaldi_get_link_latency;
 503
 504   if (current_routing == NULL && global_routing->root == NULL) {
 505
 506     /* it is the first one */
 507     new_routing->routing_father = NULL;
 508     global_routing->root = new_routing;
 509
 510   } else if (current_routing != NULL && global_routing->root != NULL) {
 511
 512     xbt_assert1(!xbt_dict_get_or_null
 513                 (current_routing->routing_sons, AS_id),
 514                 "The AS \"%s\" already exists", AS_id);
 515     /* it is a part of the tree */
 516     new_routing->routing_father = current_routing;
 517     /* set the father behavior */
 518     if (current_routing->hierarchy == SURF_ROUTING_NULL)
 519       current_routing->hierarchy = SURF_ROUTING_RECURSIVE;
 520     /* add to the sons dictionary */
 521     xbt_dict_set(current_routing->routing_sons, AS_id,
 522                  (void *) new_routing, NULL);
 523     /* add to the father element list */
 524     (*(current_routing->set_autonomous_system)) (current_routing, AS_id);
 525     /* unload the prev parse rules */
 526     (*(current_routing->routing->unload)) ();
 527
 528   } else {
 529     THROW0(arg_error, 0, "All defined components must be belong to a AS");
 530   }
 531   /* set the new parse rules */
 532   (*(new_routing->routing->load)) ();
 533   /* set the new current component of the tree */
 534   current_routing = new_routing;
 535 }
 536
 537 /*
 538  * Detect the routing model type of the routing component from XML platforms
 539  */
 540 static void parse_S_AS_XML(void)
 541 {
 542   parse_S_AS(A_surfxml_AS_id, A_surfxml_AS_routing);
 543 }
 544
 545 /*
 546  * define the routing model type of routing component from lua script
 547  */
 548 static void parse_S_AS_lua(char *id, char *mode)
 549 {
 550   parse_S_AS(id, mode);
 551 }
 552
 553
 554 /**
 555  * \brief Finish the creation of a new routing component
 556  *
 557  * When you finish to read the routing component, other structures must be created.
 558  * the "end" method allow to do that for any routing model type
 559  */
 560 static void parse_E_AS(const char *AS_id)
 561 {
 562
 563   if (current_routing == NULL) {
 564     THROW1(arg_error, 0, "Close AS(%s), that never open", AS_id);
 565   } else {
 566     network_element_info_t info = NULL;
 567     xbt_assert1(!xbt_dict_get_or_null
 568                 (global_routing->where_network_elements,
 569                  current_routing->name), "The AS \"%s\" already exists",
 570                 current_routing->name);
 571     info = xbt_new0(s_network_element_info_t, 1);
 572     info->rc_component = current_routing->routing_father;
 573     info->rc_type = SURF_NETWORK_ELEMENT_AS;
 574     xbt_dict_set(global_routing->where_network_elements,
 575                  current_routing->name, info, xbt_free);
 576     (*(current_routing->routing->unload)) ();
 577     (*(current_routing->routing->end)) ();
 578     current_routing = current_routing->routing_father;
 579     if (current_routing != NULL)
 580       (*(current_routing->routing->load)) ();
 581   }
 582 }
 583
 584 /*
 585  * \brief Finish the creation of a new routing component from XML
 586  */
 587 static void parse_E_AS_XML(void)
 588 {
 589   parse_E_AS(A_surfxml_AS_id);
 590 }
 591
 592 /*
 593  * \brief Finish the creation of a new routing component from lua
 594  */
 595 static void parse_E_AS_lua(const char *id)
 596 {
 597   parse_E_AS(id);
 598 }
 599
 600 /* Aux Business methods */
 601
 602 /**
 603  * \brief Get the AS father and the first elements of the chain
 604  *
 605  * \param src the source host name
 606  * \param dst the destination host name
 607  *
 608  * Get the common father of the to processing units, and the first different
 609  * father in the chain
 610  */
 611 static xbt_dynar_t elements_father(const char *src, const char *dst)
 612 {
 613
 614   xbt_assert0(src && dst, "bad parameters for \"elements_father\" method");
 615
 616   xbt_dynar_t result = xbt_dynar_new(sizeof(char *), NULL);
 617
 618   routing_component_t src_as, dst_as;
 619   int index_src, index_dst, index_father_src, index_father_dst;
 620   xbt_dynar_t path_src = NULL;
 621   xbt_dynar_t path_dst = NULL;
 622   routing_component_t current = NULL;
 623   routing_component_t *current_src = NULL;
 624   routing_component_t *current_dst = NULL;
 625   routing_component_t *father = NULL;
 626
 627   /* (1) find the as where the src and dst are located */
 628   src_as = ((network_element_info_t)
 629             xbt_dict_get_or_null(global_routing->where_network_elements,
 630                                  src))->rc_component;
 631   dst_as = ((network_element_info_t)
 632             xbt_dict_get_or_null(global_routing->where_network_elements,
 633                                  dst))->rc_component;
 634   xbt_assert2(src_as
 635               && dst_as,
 636               "Ask for route \"from\"(%s) or \"to\"(%s) no found", src,
 637               dst);
 638
 639   /* (2) find the path to the root routing component */
 640   path_src = xbt_dynar_new(sizeof(routing_component_t), NULL);
 641   current = src_as;
 642   while (current != NULL) {
 643     xbt_dynar_push(path_src, &current);
 644     current = current->routing_father;
 645   }
 646   path_dst = xbt_dynar_new(sizeof(routing_component_t), NULL);
 647   current = dst_as;
 648   while (current != NULL) {
 649     xbt_dynar_push(path_dst, &current);
 650     current = current->routing_father;
 651   }
 652
 653   /* (3) find the common father */
 654   index_src = path_src->used - 1;
 655   index_dst = path_dst->used - 1;
 656   current_src = xbt_dynar_get_ptr(path_src, index_src);
 657   current_dst = xbt_dynar_get_ptr(path_dst, index_dst);
 658   while (index_src >= 0 && index_dst >= 0 && *current_src == *current_dst) {
 659     current_src = xbt_dynar_get_ptr(path_src, index_src);
 660     current_dst = xbt_dynar_get_ptr(path_dst, index_dst);
 661     index_src--;
 662     index_dst--;
 663   }
 664   index_src++;
 665   index_dst++;
 666   current_src = xbt_dynar_get_ptr(path_src, index_src);
 667   current_dst = xbt_dynar_get_ptr(path_dst, index_dst);
 668
 669   /* (4) they are not in the same routing component, make the path */
 670   index_father_src = index_src + 1;
 671   index_father_dst = index_dst + 1;
 672
 673   if (*current_src == *current_dst)
 674     father = current_src;
 675   else
 676     father = xbt_dynar_get_ptr(path_src, index_father_src);
 677
 678   /* (5) result generation */
 679   xbt_dynar_push(result, father);       /* first same the father of src and dst */
 680   xbt_dynar_push(result, current_src);  /* second the first different father of src */
 681   xbt_dynar_push(result, current_dst);  /* three  the first different father of dst */
 682
 683   xbt_dynar_free(&path_src);
 684   xbt_dynar_free(&path_dst);
 685
 686   return result;
 687 }
 688
 689 /* Global Business methods */
 690
 691 /**
 692  * \brief Recursive function for get_route
 693  *
 694  * \param src the source host name
 695  * \param dst the destination host name
 696  *
 697  * This fuction is call by "get_route". It allow to walk through the
 698  * routing components tree.
 699  */
 700 static route_extended_t _get_route(const char *src, const char *dst)
 701 {
 702
 703   void *link;
 704   unsigned int cpt = 0;
 705
 706   DEBUG2("Solve route  \"%s\" to \"%s\"", src, dst);
 707
 708   xbt_assert0(src && dst, "bad parameters for \"_get_route\" method");
 709
 710   route_extended_t e_route, e_route_cnt, e_route_src = NULL, e_route_dst =
 711       NULL;
 712
 713   xbt_dynar_t elem_father_list = elements_father(src, dst);
 714
 715   routing_component_t common_father =
 716       xbt_dynar_get_as(elem_father_list, 0, routing_component_t);
 717   routing_component_t src_father =
 718       xbt_dynar_get_as(elem_father_list, 1, routing_component_t);
 719   routing_component_t dst_father =
 720       xbt_dynar_get_as(elem_father_list, 2, routing_component_t);
 721
 722   e_route = xbt_new0(s_route_extended_t, 1);
 723   e_route->src_gateway = NULL;
 724   e_route->dst_gateway = NULL;
 725   e_route->generic_route.link_list =
 726       xbt_dynar_new(global_routing->size_of_link, NULL);
 727
 728   if (src_father == dst_father) {       /* SURF_ROUTING_BASE */
 729
 730     if (strcmp(src, dst)) {
 731       e_route_cnt =
 732           (*(common_father->get_route)) (common_father, src, dst);
 733       xbt_assert2(e_route_cnt, "no route between \"%s\" and \"%s\"", src,
 734                   dst);
 735       xbt_dynar_foreach(e_route_cnt->generic_route.link_list, cpt, link) {
 736         xbt_dynar_push(e_route->generic_route.link_list, &link);
 737       }
 738       generic_free_extended_route(e_route_cnt);
 739     }
 740
 741   } else {                      /* SURF_ROUTING_RECURSIVE */
 742
 743     route_extended_t e_route_bypass = NULL;
 744
 745     if (common_father->get_bypass_route)
 746       e_route_bypass =
 747           (*(common_father->get_bypass_route)) (common_father, src, dst);
 748
 749     if (e_route_bypass)
 750       e_route_cnt = e_route_bypass;
 751     else
 752       e_route_cnt =
 753           (*(common_father->get_route)) (common_father, src_father->name,
 754                                          dst_father->name);
 755
 756     xbt_assert2(e_route_cnt, "no route between \"%s\" and \"%s\"",
 757                 src_father->name, dst_father->name);
 758
 759     xbt_assert2((e_route_cnt->src_gateway == NULL) ==
 760                 (e_route_cnt->dst_gateway == NULL),
 761                 "bad gateway for route between \"%s\" and \"%s\"", src,
 762                 dst);
 763
 764     if (strcmp(src, e_route_cnt->src_gateway)) {
 765       e_route_src = _get_route(src, e_route_cnt->src_gateway);
 766       xbt_assert2(e_route_src, "no route between \"%s\" and \"%s\"", src,
 767                   e_route_cnt->src_gateway);
 768       xbt_dynar_foreach(e_route_src->generic_route.link_list, cpt, link) {
 769         xbt_dynar_push(e_route->generic_route.link_list, &link);
 770       }
 771     }
 772
 773     xbt_dynar_foreach(e_route_cnt->generic_route.link_list, cpt, link) {
 774       xbt_dynar_push(e_route->generic_route.link_list, &link);
 775     }
 776
 777     if (strcmp(e_route_cnt->dst_gateway, dst)) {
 778       e_route_dst = _get_route(e_route_cnt->dst_gateway, dst);
 779       xbt_assert2(e_route_dst, "no route between \"%s\" and \"%s\"",
 780                   e_route_cnt->dst_gateway, dst);
 781       xbt_dynar_foreach(e_route_dst->generic_route.link_list, cpt, link) {
 782         xbt_dynar_push(e_route->generic_route.link_list, &link);
 783       }
 784     }
 785
 786     e_route->src_gateway = xbt_strdup(e_route_cnt->src_gateway);
 787     e_route->dst_gateway = xbt_strdup(e_route_cnt->dst_gateway);
 788
 789     generic_free_extended_route(e_route_src);
 790     generic_free_extended_route(e_route_cnt);
 791     generic_free_extended_route(e_route_dst);
 792   }
 793
 794   xbt_dynar_free(&elem_father_list);
 795
 796   return e_route;
 797 }
 798
 799 static double _get_latency(const char *src, const char *dst)
 800 {
 801   double latency, latency_src, latency_dst = 0.0;
 802
 803   DEBUG2("Solve route  \"%s\" to \"%s\"", src, dst);
 804
 805   xbt_assert0(src && dst, "bad parameters for \"_get_route\" method");
 806
 807   route_extended_t e_route_cnt;
 808
 809   xbt_dynar_t elem_father_list = elements_father(src, dst);
 810
 811   routing_component_t common_father =
 812       xbt_dynar_get_as(elem_father_list, 0, routing_component_t);
 813   routing_component_t src_father =
 814       xbt_dynar_get_as(elem_father_list, 1, routing_component_t);
 815   routing_component_t dst_father =
 816       xbt_dynar_get_as(elem_father_list, 2, routing_component_t);
 817
 818   if (src_father == dst_father) {       /* SURF_ROUTING_BASE */
 819
 820     if (strcmp(src, dst)) {
 821       latency =
 822           (*(common_father->get_latency)) (common_father, src, dst);
 823       xbt_assert2(latency>=0, "no route between \"%s\" and \"%s\"", src,
 824                   dst);
 825      } else latency = 0;
 826   } else {                      /* SURF_ROUTING_RECURSIVE */
 827      route_extended_t e_route_bypass = NULL;
 828
 829     if (common_father->get_bypass_route)
 830       e_route_bypass =
 831           (*(common_father->get_bypass_route)) (common_father, src, dst);
 832
 833     xbt_assert0(!e_route_bypass,"Bypass cannot work yet with get_latency");
 834
 835     e_route_cnt =
 836           (*(common_father->get_route)) (common_father, src_father->name,
 837                                          dst_father->name);
 838
 839     xbt_assert2(e_route_cnt, "no route between \"%s\" and \"%s\"",
 840                 src_father->name, dst_father->name);
 841
 842     xbt_assert2((e_route_cnt->src_gateway == NULL) ==
 843                 (e_route_cnt->dst_gateway == NULL),
 844                 "bad gateway for route between \"%s\" and \"%s\"", src,
 845                 dst);
 846     latency =
 847           (*(common_father->get_latency)) (common_father, e_route_cnt->src_gateway,
 848                                          e_route_cnt->src_gateway);
 849     xbt_assert2(latency>=0, "no route between \"%s\" and \"%s\"",
 850                 src_father->name, dst_father->name);
 851
 852
 853     if (src != e_route_cnt->src_gateway) {
 854
 855       latency_src = _get_latency(src, e_route_cnt->src_gateway);
 856       xbt_assert2(latency_src>=0, "no route between \"%s\" and \"%s\"", src,
 857                   e_route_cnt->src_gateway);
 858       latency += latency_src;
 859     }
 860
 861     if (e_route_cnt->dst_gateway != dst) {
 862
 863       latency_dst = _get_latency(e_route_cnt->dst_gateway, dst);
 864       xbt_assert2(latency_dst>=0, "no route between \"%s\" and \"%s\"",
 865                   e_route_cnt->dst_gateway, dst);
 866       latency += latency_dst;
 867     }
 868
 869   }
 870
 871   xbt_dynar_free(&elem_father_list);
 872
 873   return latency;
 874 }
 875
 876 /**
 877  * \brief Generic method: find a route between hosts
 878  *
 879  * \param src the source host name
 880  * \param dst the destination host name
 881  *
 882  * walk through the routing components tree and find a route between hosts
 883  * by calling the differents "get_route" functions in each routing component.
 884  * No need to free the returned dynar. It will be freed at the next call.
 885  */
 886 static xbt_dynar_t get_route(const char *src, const char *dst)
 887 {
 888
 889   route_extended_t e_route;
 890   xbt_dynar_t elem_father_list = NULL;
 891   routing_component_t common_father = NULL;
 892
 893   if (strcmp(src, dst))
 894     e_route = _get_route(src, dst);
 895   else {
 896     elem_father_list = elements_father(src, dst);
 897     common_father =
 898         xbt_dynar_get_as(elem_father_list, 0, routing_component_t);
 899
 900     e_route = (*(common_father->get_route)) (common_father, src, dst);
 901     xbt_dynar_free(&elem_father_list);
 902   }
 903
 904   xbt_assert2(e_route, "no route between \"%s\" and \"%s\"", src, dst);
 905
 906   if (global_routing->last_route)
 907     xbt_dynar_free(&(global_routing->last_route));
 908   global_routing->last_route = e_route->generic_route.link_list;
 909
 910   if (e_route->src_gateway)
 911     xbt_free(e_route->src_gateway);
 912   if (e_route->dst_gateway)
 913     xbt_free(e_route->dst_gateway);
 914
 915   xbt_free(e_route);
 916
 917 /*
 918   if (xbt_dynar_length(global_routing->last_route) == 0)
 919     return NULL;
 920   else
 921 */
 922     return global_routing->last_route;
 923 }
 924
 925 /**
 926  * \brief Generic method: find a route between hosts
 927  *
 928  * \param src the source host name
 929  * \param dst the destination host name
 930  *
 931  * walk through the routing components tree and find a route between hosts
 932  * by calling the differents "get_route" functions in each routing component.
 933  * Leaves the caller the responsability to clean the returned dynar.
 934  */
 935 static xbt_dynar_t get_route_no_cleanup(const char *src, const char *dst)
 936 {
 937         xbt_dynar_t d = get_route(src,dst);
 938         global_routing->last_route = NULL;
 939         return d;
 940 }
 941
 942 /*Get Latency*/
 943 static double get_latency(const char *src, const char *dst)
 944 {
 945
 946   double latency = -1.0;
 947   xbt_dynar_t elem_father_list = elements_father(src, dst);
 948   routing_component_t common_father =
 949       xbt_dynar_get_as(elem_father_list, 0, routing_component_t);
 950
 951   if (strcmp(src, dst))
 952     latency = _get_latency(src, dst);
 953   else
 954     latency = (*(common_father->get_latency)) (common_father, src, dst);
 955
 956   xbt_assert2(latency>=0.0, "no route between \"%s\" and \"%s\"", src, dst);
 957   xbt_dynar_free(&elem_father_list);
 958
 959   return latency;
 960 }
 961
 962 /**
 963  * \brief Recursive function for finalize
 964  *
 965  * \param rc the source host name
 966  *
 967  * This fuction is call by "finalize". It allow to finalize the
 968  * AS or routing components. It delete all the structures.
 969  */
 970 static void _finalize(routing_component_t rc)
 971 {
 972   if (rc) {
 973     xbt_dict_cursor_t cursor = NULL;
 974     char *key;
 975     routing_component_t elem;
 976     xbt_dict_foreach(rc->routing_sons, cursor, key, elem) {
 977       _finalize(elem);
 978     }
 979     xbt_dict_t tmp_sons = rc->routing_sons;
 980     char *tmp_name = rc->name;
 981     xbt_dict_free(&tmp_sons);
 982     xbt_free(tmp_name);
 983     xbt_assert1(rc->finalize, "no defined method \"finalize\" in \"%s\"",
 984                 current_routing->name);
 985     (*(rc->finalize)) (rc);
 986   }
 987 }
 988
 989 /**
 990  * \brief Generic method: delete all the routing structures
 991  *
 992  * walk through the routing components tree and delete the structures
 993  * by calling the differents "finalize" functions in each routing component
 994  */
 995 static void finalize(void)
 996 {
 997   /* delete recursibly all the tree */
 998   _finalize(global_routing->root);
 999   /* delete "where" dict */
1000   xbt_dict_free(&(global_routing->where_network_elements));
1001   xbt_dict_free(&(coordinates));
1002   /* delete last_route */
1003   xbt_dynar_free(&(global_routing->last_route));
1004   /* delete global routing structure */
1005   xbt_free(global_routing);
1006 }
1007
1008 static xbt_dynar_t recursive_get_onelink_routes(routing_component_t rc)
1009 {
1010   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
1011
1012   //adding my one link routes
1013   unsigned int cpt;
1014   void *link;
1015   xbt_dynar_t onelink_mine = rc->get_onelink_routes(rc);
1016   if (onelink_mine) {
1017     xbt_dynar_foreach(onelink_mine, cpt, link) {
1018       xbt_dynar_push(ret, &link);
1019     }
1020   }
1021   //recursing
1022   char *key;
1023   xbt_dict_cursor_t cursor = NULL;
1024   routing_component_t rc_child;
1025   xbt_dict_foreach(rc->routing_sons, cursor, key, rc_child) {
1026     xbt_dynar_t onelink_child = recursive_get_onelink_routes(rc_child);
1027     if (onelink_child) {
1028       xbt_dynar_foreach(onelink_child, cpt, link) {
1029         xbt_dynar_push(ret, &link);
1030       }
1031     }
1032   }
1033   return ret;
1034 }
1035
1036 static xbt_dynar_t get_onelink_routes(void)
1037 {
1038   return recursive_get_onelink_routes(global_routing->root);
1039 }
1040
1041 static e_surf_network_element_type_t get_network_element_type(const char
1042                                                               *name)
1043 {
1044   network_element_info_t rc = NULL;
1045   rc = xbt_dict_get(global_routing->where_network_elements, name);
1046   return rc->rc_type;
1047 }
1048
1049 /**
1050  * \brief Generic method: create the global routing schema
1051  *
1052  * Make a global routing structure and set all the parsing functions.
1053  */
1054 void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_t get_link_latency_fun)
1055 {
1056
1057   /* config the uniq global routing */
1058   global_routing = xbt_new0(s_routing_global_t, 1);
1059   global_routing->where_network_elements = xbt_dict_new();
1060   global_routing->root = NULL;
1061   global_routing->get_route = get_route;
1062   global_routing->get_latency = get_latency;
1063   global_routing->get_route_no_cleanup = get_route_no_cleanup;
1064   global_routing->get_onelink_routes = get_onelink_routes;
1065   global_routing->get_network_element_type = get_network_element_type;
1066   global_routing->finalize = finalize;
1067   global_routing->loopback = loopback;
1068   global_routing->size_of_link = size_of_links;
1069   global_routing->last_route = NULL;
1070   get_link_latency = get_link_latency_fun;
1071   /* no current routing at moment */
1072   current_routing = NULL;
1073
1074   coordinates = xbt_dict_new();
1075
1076   /* parse generic elements */
1077   surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host_XML);
1078   surfxml_add_callback(ETag_surfxml_host_cb_list, &parse_E_host_XML);
1079   surfxml_add_callback(STag_surfxml_router_cb_list, &parse_S_router);
1080
1081   surfxml_add_callback(STag_surfxml_route_cb_list,
1082                        &parse_S_route_new_and_endpoints_XML);
1083   surfxml_add_callback(STag_surfxml_ASroute_cb_list,
1084                        &parse_S_ASroute_new_and_endpoints);
1085   surfxml_add_callback(STag_surfxml_bypassRoute_cb_list,
1086                        &parse_S_bypassRoute_new_and_endpoints);
1087
1088   surfxml_add_callback(ETag_surfxml_link_ctn_cb_list,
1089                        &parse_E_link_ctn_new_elem_XML);
1090
1091   surfxml_add_callback(ETag_surfxml_route_cb_list,
1092                        &parse_E_route_store_route);
1093   surfxml_add_callback(ETag_surfxml_ASroute_cb_list,
1094                        &parse_E_ASroute_store_route);
1095   surfxml_add_callback(ETag_surfxml_bypassRoute_cb_list,
1096                        &parse_E_bypassRoute_store_route);
1097
1098   surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS_XML);
1099   surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS_XML);
1100
1101   surfxml_add_callback(STag_surfxml_cluster_cb_list,
1102                        &routing_parse_Scluster);
1103
1104   surfxml_add_callback(STag_surfxml_peer_cb_list,
1105                          &routing_parse_Speer);
1106
1107   surfxml_add_callback(STag_surfxml_config_cb_list,
1108                                            &routing_parse_Sconfig);
1109   surfxml_add_callback(ETag_surfxml_config_cb_list,
1110                                            &routing_parse_Econfig);
1111
1112 #ifdef HAVE_TRACING
1113   instr_routing_define_callbacks();
1114 #endif
1115 }
1116
1117 /* ************************************************************************** */
1118 /* *************************** FULL ROUTING ********************************* */
1119
1120 #define TO_ROUTE_FULL(i,j) routing->routing_table[(i)+(j)*table_size]
1121
1122 /* Routing model structure */
1123
1124 typedef struct {
1125   s_routing_component_t generic_routing;
1126   route_extended_t *routing_table;
1127 } s_routing_component_full_t, *routing_component_full_t;
1128
1129 /* Business methods */
1130 static xbt_dynar_t full_get_onelink_routes(routing_component_t rc)
1131 {
1132   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
1133
1134   routing_component_full_t routing = (routing_component_full_t) rc;
1135   size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1136   xbt_dict_cursor_t c1 = NULL, c2 = NULL;
1137   char *k1, *d1, *k2, *d2;
1138   xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
1139     xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
1140       int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k1);
1141       int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k2);
1142       xbt_assert2(src_id
1143                   && dst_id,
1144                   "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
1145                   src, dst);
1146       route_extended_t route = TO_ROUTE_FULL(*src_id, *dst_id);
1147       if (route) {
1148         if (xbt_dynar_length(route->generic_route.link_list) == 1) {
1149           void *link =
1150               *(void **) xbt_dynar_get_ptr(route->generic_route.link_list,
1151                                            0);
1152           onelink_t onelink = xbt_new0(s_onelink_t, 1);
1153           onelink->link_ptr = link;
1154           if (routing->generic_routing.hierarchy == SURF_ROUTING_BASE) {
1155             onelink->src = xbt_strdup(k1);
1156             onelink->dst = xbt_strdup(k2);
1157           } else if (routing->generic_routing.hierarchy ==
1158                      SURF_ROUTING_RECURSIVE) {
1159             onelink->src = xbt_strdup(route->src_gateway);
1160             onelink->dst = xbt_strdup(route->dst_gateway);
1161           }
1162           xbt_dynar_push(ret, &onelink);
1163         }
1164       }
1165     }
1166   }
1167   return ret;
1168 }
1169
1170 static route_extended_t full_get_route(routing_component_t rc,
1171                                        const char *src, const char *dst)
1172 {
1173   xbt_assert1(rc && src
1174               && dst,
1175               "Invalid params for \"get_route\" function at AS \"%s\"",
1176               rc->name);
1177
1178   /* set utils vars */
1179   routing_component_full_t routing = (routing_component_full_t) rc;
1180   size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1181
1182   generic_src_dst_check(rc, src, dst);
1183   int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
1184   int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
1185   xbt_assert2(src_id
1186               && dst_id,
1187               "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
1188               src, dst);
1189
1190   route_extended_t e_route = NULL;
1191   route_extended_t new_e_route = NULL;
1192   void *link;
1193   unsigned int cpt = 0;
1194
1195   e_route = TO_ROUTE_FULL(*src_id, *dst_id);
1196
1197   if (e_route) {
1198     new_e_route = xbt_new0(s_route_extended_t, 1);
1199     new_e_route->src_gateway = xbt_strdup(e_route->src_gateway);
1200     new_e_route->dst_gateway = xbt_strdup(e_route->dst_gateway);
1201     new_e_route->generic_route.link_list =
1202         xbt_dynar_new(global_routing->size_of_link, NULL);
1203     xbt_dynar_foreach(e_route->generic_route.link_list, cpt, link) {
1204       xbt_dynar_push(new_e_route->generic_route.link_list, &link);
1205     }
1206   }
1207   return new_e_route;
1208 }
1209
1210 static void full_finalize(routing_component_t rc)
1211 {
1212   routing_component_full_t routing = (routing_component_full_t) rc;
1213   size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1214   int i, j;
1215   if (routing) {
1216     /* Delete routing table */
1217     for (i = 0; i < table_size; i++)
1218       for (j = 0; j < table_size; j++)
1219         generic_free_extended_route(TO_ROUTE_FULL(i, j));
1220     xbt_free(routing->routing_table);
1221     /* Delete bypass dict */
1222     xbt_dict_free(&rc->bypassRoutes);
1223     /* Delete index dict */
1224     xbt_dict_free(&rc->to_index);
1225     /* Delete structure */
1226     xbt_free(rc);
1227   }
1228 }
1229
1230 /* Creation routing model functions */
1231
1232 static void *model_full_create(void)
1233 {
1234   routing_component_full_t new_component =
1235       xbt_new0(s_routing_component_full_t, 1);
1236   new_component->generic_routing.set_processing_unit =
1237       generic_set_processing_unit;
1238   new_component->generic_routing.set_autonomous_system =
1239       generic_set_autonomous_system;
1240   new_component->generic_routing.set_route = model_full_set_route;
1241   new_component->generic_routing.set_ASroute = model_full_set_route;
1242   new_component->generic_routing.set_bypassroute = generic_set_bypassroute;
1243   new_component->generic_routing.get_route = full_get_route;
1244   new_component->generic_routing.get_latency = generic_get_link_latency;
1245   new_component->generic_routing.get_onelink_routes =
1246       full_get_onelink_routes;
1247   new_component->generic_routing.get_bypass_route =
1248       generic_get_bypassroute;
1249   new_component->generic_routing.finalize = full_finalize;
1250   new_component->generic_routing.to_index = xbt_dict_new();
1251   new_component->generic_routing.bypassRoutes = xbt_dict_new();
1252   return new_component;
1253 }
1254
1255 static void model_full_load(void)
1256 {
1257   /* use "surfxml_add_callback" to add a parse function call */
1258 }
1259
1260 static void model_full_unload(void)
1261 {
1262   /* use "surfxml_del_callback" to remove a parse function call */
1263 }
1264
1265 static void model_full_end(void)
1266 {
1267   unsigned int i;
1268   route_extended_t e_route;
1269
1270   /* set utils vars */
1271   routing_component_full_t routing =
1272       ((routing_component_full_t) current_routing);
1273   size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1274
1275   /* Create table if necessary */
1276   if(!routing->routing_table)
1277           routing->routing_table = xbt_new0(route_extended_t, table_size * table_size);
1278
1279   /* Add the loopback if needed */
1280   if (current_routing->hierarchy == SURF_ROUTING_BASE) {
1281     for (i = 0; i < table_size; i++) {
1282       e_route = TO_ROUTE_FULL(i, i);
1283       if (!e_route) {
1284         e_route = xbt_new0(s_route_extended_t, 1);
1285         e_route->src_gateway = NULL;
1286         e_route->dst_gateway = NULL;
1287         e_route->generic_route.link_list =
1288             xbt_dynar_new(global_routing->size_of_link, NULL);
1289         xbt_dynar_push(e_route->generic_route.link_list,
1290                        &global_routing->loopback);
1291         TO_ROUTE_FULL(i, i) = e_route;
1292       }
1293     }
1294   }
1295 }
1296
1297 static void model_full_set_route(routing_component_t rc, const char *src,
1298                 const char *dst, name_route_extended_t route)
1299 {
1300         int *src_id, *dst_id;
1301         src_id = xbt_dict_get_or_null(rc->to_index, src);
1302         dst_id = xbt_dict_get_or_null(rc->to_index, dst);
1303         routing_component_full_t routing = ((routing_component_full_t) rc);
1304         size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1305
1306         xbt_assert2(src_id
1307                           && dst_id, "Network elements %s or %s not found", src, dst);
1308
1309         xbt_assert2(xbt_dynar_length(route->generic_route.link_list) > 0,
1310                           "Invalid count of links, must be greater than zero (%s,%s)",
1311                           src, dst);
1312
1313         if(!routing->routing_table)
1314                 routing->routing_table = xbt_new0(route_extended_t, table_size * table_size);
1315
1316         if(TO_ROUTE_FULL(*src_id, *dst_id))
1317         {
1318                 char * link_name;
1319                 unsigned int i;
1320                 xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
1321                 xbt_dynar_foreach(route->generic_route.link_list,i,link_name)
1322                 {
1323                         void *link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
1324                         xbt_assert1(link,"Link : '%s' doesn't exists.",link_name);
1325                         xbt_dynar_push(link_route_to_test,&link);
1326                 }
1327                 xbt_assert2(!xbt_dynar_compare(
1328                           (void*)TO_ROUTE_FULL(*src_id, *dst_id)->generic_route.link_list,
1329                           (void*)link_route_to_test,
1330                           (int_f_cpvoid_cpvoid_t) surf_pointer_resource_cmp),
1331                           "The route between \"%s\" and \"%s\" already exists", src,dst);
1332                 xbt_dynar_free(&link_route_to_test);
1333         }
1334         else
1335         {
1336                   if(!route->dst_gateway && !route->src_gateway)
1337                           DEBUG2("Load Route from \"%s\" to \"%s\"", src, dst);
1338                   else
1339                           DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
1340                                  route->src_gateway, dst, route->dst_gateway);
1341               TO_ROUTE_FULL(*src_id, *dst_id) = generic_new_extended_route(rc->hierarchy,route,1);
1342               xbt_dynar_shrink(TO_ROUTE_FULL(*src_id, *dst_id)->generic_route.link_list, 0);
1343         }
1344
1345         if( A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
1346                 || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES )
1347         {
1348                 if(route->dst_gateway && route->src_gateway)
1349                 {
1350                   char *gw_src = xbt_strdup(route->src_gateway);
1351                   char *gw_dst = xbt_strdup(route->dst_gateway);
1352                   route->src_gateway = gw_dst;
1353                   route->dst_gateway = gw_src;
1354                 }
1355                 if(TO_ROUTE_FULL(*dst_id, *src_id))
1356                 {
1357                         char * link_name;
1358                         unsigned int i;
1359                         xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
1360                         for(i=xbt_dynar_length(route->generic_route.link_list) ;i>0 ;i--)
1361                         {
1362                                 link_name = xbt_dynar_get_as(route->generic_route.link_list,i-1,void *);
1363                                 void *link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
1364                                 xbt_assert1(link,"Link : '%s' doesn't exists.",link_name);
1365                                 xbt_dynar_push(link_route_to_test,&link);
1366                         }
1367                         xbt_assert2(!xbt_dynar_compare(
1368                                   (void*)TO_ROUTE_FULL(*dst_id, *src_id)->generic_route.link_list,
1369                               (void*)link_route_to_test,
1370                                   (int_f_cpvoid_cpvoid_t) surf_pointer_resource_cmp),
1371                                   "The route between \"%s\" and \"%s\" already exists", src,dst);
1372                         xbt_dynar_free(&link_route_to_test);
1373                 }
1374                 else
1375                 {
1376                           if(!route->dst_gateway && !route->src_gateway)
1377                                   DEBUG2("Load Route from \"%s\" to \"%s\"", dst, src);
1378                           else
1379                                   DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
1380                                          route->src_gateway, src, route->dst_gateway);
1381                       TO_ROUTE_FULL(*dst_id, *src_id) = generic_new_extended_route(rc->hierarchy,route,0);
1382                       xbt_dynar_shrink(TO_ROUTE_FULL(*dst_id, *src_id)->generic_route.link_list, 0);
1383                 }
1384
1385         }
1386 }
1387
1388 /* ************************************************************************** */
1389 /* *************************** FLOYD ROUTING ******************************** */
1390
1391 #define TO_FLOYD_COST(i,j) (routing->cost_table)[(i)+(j)*table_size]
1392 #define TO_FLOYD_PRED(i,j) (routing->predecessor_table)[(i)+(j)*table_size]
1393 #define TO_FLOYD_LINK(i,j) (routing->link_table)[(i)+(j)*table_size]
1394
1395 /* Routing model structure */
1396
1397 typedef struct {
1398   s_routing_component_t generic_routing;
1399   /* vars for calculate the floyd algorith. */
1400   int *predecessor_table;
1401   double *cost_table;
1402   route_extended_t *link_table; /* char* -> int* */
1403 } s_routing_component_floyd_t, *routing_component_floyd_t;
1404
1405 static route_extended_t floyd_get_route(routing_component_t rc,
1406                                         const char *src, const char *dst);
1407
1408 /* Business methods */
1409 static xbt_dynar_t floyd_get_onelink_routes(routing_component_t rc)
1410 {
1411   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
1412
1413   routing_component_floyd_t routing = (routing_component_floyd_t) rc;
1414   //size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1415   xbt_dict_cursor_t c1 = NULL, c2 = NULL;
1416   char *k1, *d1, *k2, *d2;
1417   xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
1418     xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
1419       route_extended_t route = floyd_get_route(rc, k1, k2);
1420       if (route) {
1421         if (xbt_dynar_length(route->generic_route.link_list) == 1) {
1422           void *link =
1423               *(void **) xbt_dynar_get_ptr(route->generic_route.link_list,
1424                                            0);
1425           onelink_t onelink = xbt_new0(s_onelink_t, 1);
1426           onelink->link_ptr = link;
1427           if (routing->generic_routing.hierarchy == SURF_ROUTING_BASE) {
1428             onelink->src = xbt_strdup(k1);
1429             onelink->dst = xbt_strdup(k2);
1430           } else if (routing->generic_routing.hierarchy ==
1431                      SURF_ROUTING_RECURSIVE) {
1432             onelink->src = xbt_strdup(route->src_gateway);
1433             onelink->dst = xbt_strdup(route->dst_gateway);
1434           }
1435           xbt_dynar_push(ret, &onelink);
1436         }
1437       }
1438     }
1439   }
1440   return ret;
1441 }
1442
1443 static route_extended_t floyd_get_route(routing_component_t rc,
1444                                         const char *src, const char *dst)
1445 {
1446   xbt_assert1(rc && src
1447               && dst,
1448               "Invalid params for \"get_route\" function at AS \"%s\"",
1449               rc->name);
1450
1451   /* set utils vars */
1452   routing_component_floyd_t routing = (routing_component_floyd_t) rc;
1453   size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1454
1455   generic_src_dst_check(rc, src, dst);
1456   int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
1457   int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
1458   xbt_assert2(src_id
1459               && dst_id,
1460               "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
1461               src, dst);
1462
1463   /* create a result route */
1464   route_extended_t new_e_route = xbt_new0(s_route_extended_t, 1);
1465   new_e_route->generic_route.link_list =
1466       xbt_dynar_new(global_routing->size_of_link, NULL);
1467   new_e_route->src_gateway = NULL;
1468   new_e_route->dst_gateway = NULL;
1469
1470   int first = 1;
1471   int pred = *dst_id;
1472   int prev_pred = 0;
1473   char *gw_src = NULL, *gw_dst =
1474       NULL, *prev_gw_src, *prev_gw_dst, *first_gw = NULL;
1475   unsigned int cpt;
1476   void *link;
1477   xbt_dynar_t links;
1478
1479   do {
1480     prev_pred = pred;
1481     pred = TO_FLOYD_PRED(*src_id, pred);
1482     if (pred == -1)             /* if no pred in route -> no route to host */
1483       break;
1484     xbt_assert2(TO_FLOYD_LINK(pred, prev_pred),
1485                 "Invalid link for the route between \"%s\" or \"%s\"", src,
1486                 dst);
1487
1488     prev_gw_src = gw_src;
1489     prev_gw_dst = gw_dst;
1490
1491     route_extended_t e_route = TO_FLOYD_LINK(pred, prev_pred);
1492     gw_src = e_route->src_gateway;
1493     gw_dst = e_route->dst_gateway;
1494
1495     if (first)
1496       first_gw = gw_dst;
1497
1498     if (rc->hierarchy == SURF_ROUTING_RECURSIVE && !first
1499         && strcmp(gw_dst, prev_gw_src)) {
1500       xbt_dynar_t e_route_as_to_as =
1501           (*(global_routing->get_route)) (gw_dst, prev_gw_src);
1502       xbt_assert2(e_route_as_to_as, "no route between \"%s\" and \"%s\"",
1503                   gw_dst, prev_gw_src);
1504       links = e_route_as_to_as;
1505       int pos = 0;
1506       xbt_dynar_foreach(links, cpt, link) {
1507         xbt_dynar_insert_at(new_e_route->generic_route.link_list, pos,
1508                             &link);
1509         pos++;
1510       }
1511     }
1512
1513     links = e_route->generic_route.link_list;
1514     xbt_dynar_foreach(links, cpt, link) {
1515       xbt_dynar_unshift(new_e_route->generic_route.link_list, &link);
1516     }
1517     first = 0;
1518
1519   } while (pred != *src_id);
1520   xbt_assert4(pred != -1, "no route from host %d to %d (\"%s\" to \"%s\")",
1521               *src_id, *dst_id, src, dst);
1522
1523   if (rc->hierarchy == SURF_ROUTING_RECURSIVE) {
1524     new_e_route->src_gateway = xbt_strdup(gw_src);
1525     new_e_route->dst_gateway = xbt_strdup(first_gw);
1526   }
1527
1528   return new_e_route;
1529 }
1530
1531 static void floyd_finalize(routing_component_t rc)
1532 {
1533   routing_component_floyd_t routing = (routing_component_floyd_t) rc;
1534   int i, j;
1535   size_t table_size;
1536   if (routing) {
1537     table_size = xbt_dict_length(routing->generic_routing.to_index);
1538     /* Delete link_table */
1539     for (i = 0; i < table_size; i++)
1540       for (j = 0; j < table_size; j++)
1541         generic_free_extended_route(TO_FLOYD_LINK(i, j));
1542     xbt_free(routing->link_table);
1543     /* Delete bypass dict */
1544     xbt_dict_free(&routing->generic_routing.bypassRoutes);
1545     /* Delete index dict */
1546     xbt_dict_free(&(routing->generic_routing.to_index));
1547     /* Delete dictionary index dict, predecessor and links table */
1548     xbt_free(routing->predecessor_table);
1549     /* Delete structure */
1550     xbt_free(rc);
1551   }
1552 }
1553
1554 static void *model_floyd_create(void)
1555 {
1556   routing_component_floyd_t new_component =
1557       xbt_new0(s_routing_component_floyd_t, 1);
1558   new_component->generic_routing.set_processing_unit =
1559       generic_set_processing_unit;
1560   new_component->generic_routing.set_autonomous_system =
1561       generic_set_autonomous_system;
1562   new_component->generic_routing.set_route = model_floyd_set_route;
1563   new_component->generic_routing.set_ASroute = model_floyd_set_route;
1564   new_component->generic_routing.set_bypassroute = generic_set_bypassroute;
1565   new_component->generic_routing.get_route = floyd_get_route;
1566   new_component->generic_routing.get_latency = generic_get_link_latency;
1567   new_component->generic_routing.get_onelink_routes =
1568       floyd_get_onelink_routes;
1569   new_component->generic_routing.get_bypass_route =
1570       generic_get_bypassroute;
1571   new_component->generic_routing.finalize = floyd_finalize;
1572   new_component->generic_routing.to_index = xbt_dict_new();
1573   new_component->generic_routing.bypassRoutes = xbt_dict_new();
1574   return new_component;
1575 }
1576
1577 static void model_floyd_load(void)
1578 {
1579   /* use "surfxml_add_callback" to add a parse function call */
1580 }
1581
1582 static void model_floyd_unload(void)
1583 {
1584   /* use "surfxml_del_callback" to remove a parse function call */
1585 }
1586
1587 static void model_floyd_end(void)
1588 {
1589
1590         routing_component_floyd_t routing =
1591           ((routing_component_floyd_t) current_routing);
1592
1593         unsigned int i, j, a, b, c;
1594
1595         /* set the size of table routing */
1596         size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
1597
1598         if(!routing->link_table)
1599         {
1600                 /* Create Cost, Predecessor and Link tables */
1601                 routing->cost_table = xbt_new0(double, table_size * table_size);       /* link cost from host to host */
1602                 routing->predecessor_table = xbt_new0(int, table_size * table_size);  /* predecessor host numbers */
1603                 routing->link_table = xbt_new0(route_extended_t, table_size * table_size);    /* actual link between src and dst */
1604
1605                 /* Initialize costs and predecessors */
1606                 for (i = 0; i < table_size; i++)
1607                 for (j = 0; j < table_size; j++) {
1608                   TO_FLOYD_COST(i, j) = DBL_MAX;
1609                   TO_FLOYD_PRED(i, j) = -1;
1610                   TO_FLOYD_LINK(i, j) = NULL;       /* fixed, missing in the previous version */
1611                 }
1612         }
1613
1614         /* Add the loopback if needed */
1615         if (current_routing->hierarchy == SURF_ROUTING_BASE) {
1616                 for (i = 0; i < table_size; i++) {
1617                   route_extended_t e_route = TO_FLOYD_LINK(i, i);
1618                   if (!e_route) {
1619                         e_route = xbt_new0(s_route_extended_t, 1);
1620                         e_route->src_gateway = NULL;
1621                         e_route->dst_gateway = NULL;
1622                         e_route->generic_route.link_list =
1623                                 xbt_dynar_new(global_routing->size_of_link, NULL);
1624                         xbt_dynar_push(e_route->generic_route.link_list,
1625                                                    &global_routing->loopback);
1626                         TO_FLOYD_LINK(i, i) = e_route;
1627                         TO_FLOYD_PRED(i, i) = i;
1628                         TO_FLOYD_COST(i, i) = 1;
1629                   }
1630                 }
1631         }
1632         /* Calculate path costs */
1633         for (c = 0; c < table_size; c++) {
1634                 for (a = 0; a < table_size; a++) {
1635                   for (b = 0; b < table_size; b++) {
1636                         if (TO_FLOYD_COST(a, c) < DBL_MAX && TO_FLOYD_COST(c, b) < DBL_MAX) {
1637                           if (TO_FLOYD_COST(a, b) == DBL_MAX ||
1638                                   (TO_FLOYD_COST(a, c) + TO_FLOYD_COST(c, b) <
1639                                    TO_FLOYD_COST(a, b))) {
1640                                 TO_FLOYD_COST(a, b) =
1641                                         TO_FLOYD_COST(a, c) + TO_FLOYD_COST(c, b);
1642                                 TO_FLOYD_PRED(a, b) = TO_FLOYD_PRED(c, b);
1643                           }
1644                         }
1645                   }
1646                 }
1647         }
1648 }
1649
1650 static void model_floyd_set_route(routing_component_t rc, const char *src,
1651         const char *dst, name_route_extended_t route)
1652 {
1653         routing_component_floyd_t routing = (routing_component_floyd_t) rc;
1654
1655         /* set the size of table routing */
1656         size_t table_size = xbt_dict_length(rc->to_index);
1657         int *src_id, *dst_id;
1658         int i,j;
1659
1660         src_id = xbt_dict_get_or_null(rc->to_index, src);
1661         dst_id = xbt_dict_get_or_null(rc->to_index, dst);
1662
1663         if(!routing->link_table)
1664         {
1665                 /* Create Cost, Predecessor and Link tables */
1666                 routing->cost_table = xbt_new0(double, table_size * table_size);       /* link cost from host to host */
1667                 routing->predecessor_table = xbt_new0(int, table_size * table_size);  /* predecessor host numbers */
1668                 routing->link_table = xbt_new0(route_extended_t, table_size * table_size);    /* actual link between src and dst */
1669
1670                 /* Initialize costs and predecessors */
1671                 for (i = 0; i < table_size; i++)
1672                 for (j = 0; j < table_size; j++) {
1673                   TO_FLOYD_COST(i, j) = DBL_MAX;
1674                   TO_FLOYD_PRED(i, j) = -1;
1675                   TO_FLOYD_LINK(i, j) = NULL;       /* fixed, missing in the previous version */
1676                 }
1677         }
1678
1679         if(TO_FLOYD_LINK(*src_id, *dst_id))
1680         {
1681                 if(!route->dst_gateway && !route->src_gateway)
1682                         DEBUG2("See Route from \"%s\" to \"%s\"", src, dst);
1683                 else
1684                         DEBUG4("See ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
1685                                  route->src_gateway, dst, route->dst_gateway);
1686                 char * link_name;
1687                 unsigned int cpt;
1688                 xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
1689                 xbt_dynar_foreach(route->generic_route.link_list,cpt,link_name)
1690                 {
1691                         void *link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
1692                         xbt_assert1(link,"Link : '%s' doesn't exists.",link_name);
1693                         xbt_dynar_push(link_route_to_test,&link);
1694                 }
1695                 xbt_assert2(!xbt_dynar_compare(
1696                           (void*)TO_FLOYD_LINK(*src_id, *dst_id)->generic_route.link_list,
1697                           (void*)link_route_to_test,
1698                           (int_f_cpvoid_cpvoid_t) surf_pointer_resource_cmp),
1699                           "The route between \"%s\" and \"%s\" already exists", src,dst);
1700                 xbt_free(link_route_to_test);
1701         }
1702         else
1703         {
1704                 if(!route->dst_gateway && !route->src_gateway)
1705                   DEBUG2("Load Route from \"%s\" to \"%s\"", src, dst);
1706                 else
1707                   DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
1708                                  route->src_gateway, dst, route->dst_gateway);
1709
1710             TO_FLOYD_LINK(*src_id, *dst_id) =
1711                         generic_new_extended_route(rc->hierarchy, route, 1);
1712             TO_FLOYD_PRED(*src_id, *dst_id) = *src_id;
1713             TO_FLOYD_COST(*src_id, *dst_id) =
1714                         ((TO_FLOYD_LINK(*src_id, *dst_id))->generic_route.link_list)->used;   /* count of links, old model assume 1 */
1715         }
1716
1717         if( A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
1718                 || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES )
1719         {
1720                 if(TO_FLOYD_LINK(*dst_id, *src_id))
1721                 {
1722                         if(!route->dst_gateway && !route->src_gateway)
1723                           DEBUG2("See Route from \"%s\" to \"%s\"", dst, src);
1724                         else
1725                           DEBUG4("See ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
1726                                          route->src_gateway, src, route->dst_gateway);
1727                         char * link_name;
1728                         unsigned int i;
1729                         xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
1730                         for(i=xbt_dynar_length(route->generic_route.link_list) ;i>0 ;i--)
1731                         {
1732                                 link_name = xbt_dynar_get_as(route->generic_route.link_list,i-1,void *);
1733                                 void *link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
1734                                 xbt_assert1(link,"Link : '%s' doesn't exists.",link_name);
1735                                 xbt_dynar_push(link_route_to_test,&link);
1736                         }
1737                         xbt_assert2(!xbt_dynar_compare(
1738                                   (void*)TO_FLOYD_LINK(*dst_id, *src_id)->generic_route.link_list,
1739                               (void*)link_route_to_test,
1740                                   (int_f_cpvoid_cpvoid_t) surf_pointer_resource_cmp),
1741                                   "The route between \"%s\" and \"%s\" already exists", src,dst);
1742                         xbt_free(link_route_to_test);
1743                 }
1744                 else
1745                 {
1746                         if(route->dst_gateway && route->src_gateway)
1747                         {
1748                           char *gw_src = xbt_strdup(route->src_gateway);
1749                           char *gw_dst = xbt_strdup(route->dst_gateway);
1750                           route->src_gateway = gw_dst;
1751                           route->dst_gateway = gw_src;
1752                         }
1753
1754                         if(!route->dst_gateway && !route->src_gateway)
1755                           DEBUG2("Load Route from \"%s\" to \"%s\"", dst, src);
1756                         else
1757                           DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
1758                                          route->src_gateway, src, route->dst_gateway);
1759
1760                     TO_FLOYD_LINK(*dst_id, *src_id) =
1761                                 generic_new_extended_route(rc->hierarchy, route, 0);
1762                     TO_FLOYD_PRED(*dst_id, *src_id) = *dst_id;
1763                     TO_FLOYD_COST(*dst_id, *src_id) =
1764                                 ((TO_FLOYD_LINK(*dst_id, *src_id))->generic_route.link_list)->used;   /* count of links, old model assume 1 */
1765                 }
1766         }
1767 }
1768
1769 /* ************************************************************************** */
1770 /* ********** Dijkstra & Dijkstra Cached ROUTING **************************** */
1771
1772 typedef struct {
1773   s_routing_component_t generic_routing;
1774   xbt_graph_t route_graph;      /* xbt_graph */
1775   xbt_dict_t graph_node_map;    /* map */
1776   xbt_dict_t route_cache;       /* use in cache mode */
1777   int cached;
1778 } s_routing_component_dijkstra_t, *routing_component_dijkstra_t;
1779
1780
1781 typedef struct graph_node_data {
1782   int id;
1783   int graph_id;                 /* used for caching internal graph id's */
1784 } s_graph_node_data_t, *graph_node_data_t;
1785
1786 typedef struct graph_node_map_element {
1787   xbt_node_t node;
1788 } s_graph_node_map_element_t, *graph_node_map_element_t;
1789
1790 typedef struct route_cache_element {
1791   int *pred_arr;
1792   int size;
1793 } s_route_cache_element_t, *route_cache_element_t;
1794
1795 /* Free functions */
1796
1797 static void route_cache_elem_free(void *e)
1798 {
1799   route_cache_element_t elm = (route_cache_element_t) e;
1800   if (elm) {
1801     xbt_free(elm->pred_arr);
1802     xbt_free(elm);
1803   }
1804 }
1805
1806 static void graph_node_map_elem_free(void *e)
1807 {
1808   graph_node_map_element_t elm = (graph_node_map_element_t) e;
1809   if (elm) {
1810     xbt_free(elm);
1811   }
1812 }
1813
1814 static void graph_edge_data_free(void *e)
1815 {
1816   route_extended_t e_route = (route_extended_t) e;
1817   if (e_route) {
1818     xbt_dynar_free(&(e_route->generic_route.link_list));
1819     if (e_route->src_gateway)
1820       xbt_free(e_route->src_gateway);
1821     if (e_route->dst_gateway)
1822       xbt_free(e_route->dst_gateway);
1823     xbt_free(e_route);
1824   }
1825 }
1826
1827 /* Utility functions */
1828
1829 static xbt_node_t route_graph_new_node(routing_component_dijkstra_t rc,
1830                                        int id, int graph_id)
1831 {
1832   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
1833   xbt_node_t node = NULL;
1834   graph_node_data_t data = NULL;
1835   graph_node_map_element_t elm = NULL;
1836
1837   data = xbt_new0(struct graph_node_data, 1);
1838   data->id = id;
1839   data->graph_id = graph_id;
1840   node = xbt_graph_new_node(routing->route_graph, data);
1841
1842   elm = xbt_new0(struct graph_node_map_element, 1);
1843   elm->node = node;
1844   xbt_dict_set_ext(routing->graph_node_map, (char *) (&id), sizeof(int),
1845                    (xbt_set_elm_t) elm, &graph_node_map_elem_free);
1846
1847   return node;
1848 }
1849
1850 static graph_node_map_element_t
1851 graph_node_map_search(routing_component_dijkstra_t rc, int id)
1852 {
1853   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
1854   graph_node_map_element_t elm = (graph_node_map_element_t)
1855       xbt_dict_get_or_null_ext(routing->graph_node_map,
1856                                (char *) (&id),
1857                                sizeof(int));
1858   return elm;
1859 }
1860
1861 /* Parsing */
1862
1863 static void route_new_dijkstra(routing_component_dijkstra_t rc, int src_id,
1864                                int dst_id, route_extended_t e_route)
1865 {
1866   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
1867   DEBUG2("Load Route from \"%d\" to \"%d\"", src_id, dst_id);
1868   xbt_node_t src = NULL;
1869   xbt_node_t dst = NULL;
1870
1871   graph_node_map_element_t src_elm = (graph_node_map_element_t)
1872       xbt_dict_get_or_null_ext(routing->graph_node_map,
1873                                (char *) (&src_id),
1874                                sizeof(int));
1875   graph_node_map_element_t dst_elm = (graph_node_map_element_t)
1876       xbt_dict_get_or_null_ext(routing->graph_node_map,
1877                                (char *) (&dst_id),
1878                                sizeof(int));
1879
1880
1881   if (src_elm)
1882     src = src_elm->node;
1883
1884   if (dst_elm)
1885     dst = dst_elm->node;
1886
1887   /* add nodes if they don't exist in the graph */
1888   if (src_id == dst_id && src == NULL && dst == NULL) {
1889     src = route_graph_new_node(rc, src_id, -1);
1890     dst = src;
1891   } else {
1892     if (src == NULL) {
1893       src = route_graph_new_node(rc, src_id, -1);
1894     }
1895     if (dst == NULL) {
1896       dst = route_graph_new_node(rc, dst_id, -1);
1897     }
1898   }
1899
1900   /* add link as edge to graph */
1901   xbt_graph_new_edge(routing->route_graph, src, dst, e_route);
1902 }
1903
1904 static void add_loopback_dijkstra(routing_component_dijkstra_t rc)
1905 {
1906   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
1907
1908   xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph);
1909
1910   xbt_node_t node = NULL;
1911   unsigned int cursor2;
1912   xbt_dynar_foreach(nodes, cursor2, node) {
1913     xbt_dynar_t out_edges = xbt_graph_node_get_outedges(node);
1914     xbt_edge_t edge = NULL;
1915     unsigned int cursor;
1916
1917     int found = 0;
1918     xbt_dynar_foreach(out_edges, cursor, edge) {
1919       xbt_node_t other_node = xbt_graph_edge_get_target(edge);
1920       if (other_node == node) {
1921         found = 1;
1922         break;
1923       }
1924     }
1925
1926     if (!found) {
1927       route_extended_t e_route = xbt_new0(s_route_extended_t, 1);
1928       e_route->src_gateway = NULL;
1929       e_route->dst_gateway = NULL;
1930       e_route->generic_route.link_list =
1931           xbt_dynar_new(global_routing->size_of_link, NULL);
1932       xbt_dynar_push(e_route->generic_route.link_list,
1933                      &global_routing->loopback);
1934       xbt_graph_new_edge(routing->route_graph, node, node, e_route);
1935     }
1936   }
1937 }
1938
1939 /* Business methods */
1940 static xbt_dynar_t dijkstra_get_onelink_routes(routing_component_t rc)
1941 {
1942   xbt_die("\"dijkstra_get_onelink_routes\" function not implemented yet");
1943 }
1944
1945 static route_extended_t dijkstra_get_route(routing_component_t rc,
1946                                            const char *src,
1947                                            const char *dst)
1948 {
1949   xbt_assert1(rc && src
1950               && dst,
1951               "Invalid params for \"get_route\" function at AS \"%s\"",
1952               rc->name);
1953
1954   /* set utils vars */
1955   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
1956
1957   generic_src_dst_check(rc, src, dst);
1958   int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
1959   int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
1960   xbt_assert2(src_id
1961               && dst_id,
1962               "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
1963               src, dst);
1964
1965   /* create a result route */
1966   route_extended_t new_e_route = xbt_new0(s_route_extended_t, 1);
1967   new_e_route->generic_route.link_list =
1968       xbt_dynar_new(global_routing->size_of_link, NULL);
1969   new_e_route->src_gateway = NULL;
1970   new_e_route->dst_gateway = NULL;
1971
1972   int *pred_arr = NULL;
1973   int src_node_id = 0;
1974   int dst_node_id = 0;
1975   int *nodeid = NULL;
1976   int v;
1977   route_extended_t e_route;
1978   int size = 0;
1979   unsigned int cpt;
1980   void *link;
1981   xbt_dynar_t links = NULL;
1982   route_cache_element_t elm = NULL;
1983   xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph);
1984
1985   /* Use the graph_node id mapping set to quickly find the nodes */
1986   graph_node_map_element_t src_elm =
1987       graph_node_map_search(routing, *src_id);
1988   graph_node_map_element_t dst_elm =
1989       graph_node_map_search(routing, *dst_id);
1990   xbt_assert2(src_elm != NULL
1991               && dst_elm != NULL, "src %d or dst %d does not exist",
1992               *src_id, *dst_id);
1993   src_node_id = ((graph_node_data_t)
1994                  xbt_graph_node_get_data(src_elm->node))->graph_id;
1995   dst_node_id = ((graph_node_data_t)
1996                  xbt_graph_node_get_data(dst_elm->node))->graph_id;
1997
1998   /* if the src and dst are the same *//* fixed, missing in the previous version */
1999   if (src_node_id == dst_node_id) {
2000
2001     xbt_node_t node_s_v = xbt_dynar_get_as(nodes, src_node_id, xbt_node_t);
2002     xbt_node_t node_e_v = xbt_dynar_get_as(nodes, dst_node_id, xbt_node_t);
2003     xbt_edge_t edge =
2004         xbt_graph_get_edge(routing->route_graph, node_s_v, node_e_v);
2005
2006     xbt_assert2(edge != NULL, "no route between host %d and %d", *src_id,
2007                 *dst_id);
2008
2009     e_route = (route_extended_t) xbt_graph_edge_get_data(edge);
2010
2011     links = e_route->generic_route.link_list;
2012     xbt_dynar_foreach(links, cpt, link) {
2013       xbt_dynar_unshift(new_e_route->generic_route.link_list, &link);
2014     }
2015
2016     return new_e_route;
2017   }
2018
2019   if (routing->cached) {
2020     /*check if there is a cached predecessor list avail */
2021     elm = (route_cache_element_t)
2022         xbt_dict_get_or_null_ext(routing->route_cache, (char *) (&src_id),
2023                                  sizeof(int));
2024   }
2025
2026   if (elm) {                    /* cached mode and cache hit */
2027     pred_arr = elm->pred_arr;
2028   } else {                      /* not cached mode or cache miss */
2029     double *cost_arr = NULL;
2030     xbt_heap_t pqueue = NULL;
2031     int i = 0;
2032
2033     int nr_nodes = xbt_dynar_length(nodes);
2034     cost_arr = xbt_new0(double, nr_nodes);      /* link cost from src to other hosts */
2035     pred_arr = xbt_new0(int, nr_nodes); /* predecessors in path from src */
2036     pqueue = xbt_heap_new(nr_nodes, xbt_free);
2037
2038     /* initialize */
2039     cost_arr[src_node_id] = 0.0;
2040
2041     for (i = 0; i < nr_nodes; i++) {
2042       if (i != src_node_id) {
2043         cost_arr[i] = DBL_MAX;
2044       }
2045
2046       pred_arr[i] = 0;
2047
2048       /* initialize priority queue */
2049       nodeid = xbt_new0(int, 1);
2050       *nodeid = i;
2051       xbt_heap_push(pqueue, nodeid, cost_arr[i]);
2052
2053     }
2054
2055     /* apply dijkstra using the indexes from the graph's node array */
2056     while (xbt_heap_size(pqueue) > 0) {
2057       int *v_id = xbt_heap_pop(pqueue);
2058       xbt_node_t v_node = xbt_dynar_get_as(nodes, *v_id, xbt_node_t);
2059       xbt_dynar_t out_edges = xbt_graph_node_get_outedges(v_node);
2060       xbt_edge_t edge = NULL;
2061       unsigned int cursor;
2062
2063       xbt_dynar_foreach(out_edges, cursor, edge) {
2064         xbt_node_t u_node = xbt_graph_edge_get_target(edge);
2065         graph_node_data_t data = xbt_graph_node_get_data(u_node);
2066         int u_id = data->graph_id;
2067         route_extended_t tmp_e_route =
2068             (route_extended_t) xbt_graph_edge_get_data(edge);
2069         int cost_v_u = (tmp_e_route->generic_route.link_list)->used;    /* count of links, old model assume 1 */
2070
2071         if (cost_v_u + cost_arr[*v_id] < cost_arr[u_id]) {
2072           pred_arr[u_id] = *v_id;
2073           cost_arr[u_id] = cost_v_u + cost_arr[*v_id];
2074           nodeid = xbt_new0(int, 1);
2075           *nodeid = u_id;
2076           xbt_heap_push(pqueue, nodeid, cost_arr[u_id]);
2077         }
2078       }
2079
2080       /* free item popped from pqueue */
2081       xbt_free(v_id);
2082     }
2083
2084     xbt_free(cost_arr);
2085     xbt_heap_free(pqueue);
2086   }
2087
2088   /* compose route path with links */
2089   char *gw_src = NULL, *gw_dst =
2090       NULL, *prev_gw_src, *prev_gw_dst, *first_gw = NULL;
2091
2092   for (v = dst_node_id; v != src_node_id; v = pred_arr[v]) {
2093     xbt_node_t node_pred_v =
2094         xbt_dynar_get_as(nodes, pred_arr[v], xbt_node_t);
2095     xbt_node_t node_v = xbt_dynar_get_as(nodes, v, xbt_node_t);
2096     xbt_edge_t edge =
2097         xbt_graph_get_edge(routing->route_graph, node_pred_v, node_v);
2098
2099     xbt_assert2(edge != NULL, "no route between host %d and %d", *src_id,
2100                 *dst_id);
2101
2102     prev_gw_src = gw_src;
2103     prev_gw_dst = gw_dst;
2104
2105     e_route = (route_extended_t) xbt_graph_edge_get_data(edge);
2106     gw_src = e_route->src_gateway;
2107     gw_dst = e_route->dst_gateway;
2108
2109     if (v == dst_node_id)
2110       first_gw = gw_dst;
2111
2112     if (rc->hierarchy == SURF_ROUTING_RECURSIVE && v != dst_node_id
2113         && strcmp(gw_dst, prev_gw_src)) {
2114       xbt_dynar_t e_route_as_to_as =
2115           (*(global_routing->get_route)) (gw_dst, prev_gw_src);
2116       xbt_assert2(e_route_as_to_as, "no route between \"%s\" and \"%s\"",
2117                   gw_dst, prev_gw_src);
2118       links = e_route_as_to_as;
2119       int pos = 0;
2120       xbt_dynar_foreach(links, cpt, link) {
2121         xbt_dynar_insert_at(new_e_route->generic_route.link_list, pos,
2122                             &link);
2123         pos++;
2124       }
2125     }
2126
2127     links = e_route->generic_route.link_list;
2128     xbt_dynar_foreach(links, cpt, link) {
2129       xbt_dynar_unshift(new_e_route->generic_route.link_list, &link);
2130     }
2131     size++;
2132   }
2133
2134   if (rc->hierarchy == SURF_ROUTING_RECURSIVE) {
2135     new_e_route->src_gateway = xbt_strdup(gw_src);
2136     new_e_route->dst_gateway = xbt_strdup(first_gw);
2137   }
2138
2139   if (routing->cached && elm == NULL) {
2140     /* add to predecessor list of the current src-host to cache */
2141     elm = xbt_new0(struct route_cache_element, 1);
2142     elm->pred_arr = pred_arr;
2143     elm->size = size;
2144     xbt_dict_set_ext(routing->route_cache, (char *) (&src_id), sizeof(int),
2145                      (xbt_set_elm_t) elm, &route_cache_elem_free);
2146   }
2147
2148   if (!routing->cached)
2149     xbt_free(pred_arr);
2150
2151   return new_e_route;
2152 }
2153
2154 static void dijkstra_finalize(routing_component_t rc)
2155 {
2156   routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
2157
2158   if (routing) {
2159     xbt_graph_free_graph(routing->route_graph, &xbt_free,
2160                          &graph_edge_data_free, &xbt_free);
2161     xbt_dict_free(&routing->graph_node_map);
2162     if (routing->cached)
2163       xbt_dict_free(&routing->route_cache);
2164     /* Delete bypass dict */
2165     xbt_dict_free(&routing->generic_routing.bypassRoutes);
2166     /* Delete index dict */
2167     xbt_dict_free(&(routing->generic_routing.to_index));
2168     /* Delete structure */
2169     xbt_free(routing);
2170   }
2171 }
2172
2173 /* Creation routing model functions */
2174
2175 static void *model_dijkstra_both_create(int cached)
2176 {
2177   routing_component_dijkstra_t new_component =
2178       xbt_new0(s_routing_component_dijkstra_t, 1);
2179   new_component->generic_routing.set_processing_unit =
2180       generic_set_processing_unit;
2181   new_component->generic_routing.set_autonomous_system =
2182       generic_set_autonomous_system;
2183   new_component->generic_routing.set_route = model_dijkstra_both_set_route;
2184   new_component->generic_routing.set_ASroute = model_dijkstra_both_set_route; //TODO
2185   new_component->generic_routing.set_bypassroute = generic_set_bypassroute;
2186   new_component->generic_routing.get_route = dijkstra_get_route;
2187   new_component->generic_routing.get_latency = generic_get_link_latency;
2188   new_component->generic_routing.get_onelink_routes =
2189       dijkstra_get_onelink_routes;
2190   new_component->generic_routing.get_bypass_route =
2191       generic_get_bypassroute;
2192   new_component->generic_routing.finalize = dijkstra_finalize;
2193   new_component->cached = cached;
2194   new_component->generic_routing.to_index = xbt_dict_new();
2195   new_component->generic_routing.bypassRoutes = xbt_dict_new();
2196   return new_component;
2197 }
2198
2199 static void *model_dijkstra_create(void)
2200 {
2201   return model_dijkstra_both_create(0);
2202 }
2203
2204 static void *model_dijkstracache_create(void)
2205 {
2206   return model_dijkstra_both_create(1);
2207 }
2208
2209 static void model_dijkstra_both_load(void)
2210 {
2211   /* use "surfxml_add_callback" to add a parse function call */
2212 }
2213
2214 static void model_dijkstra_both_unload(void)
2215 {
2216   /* use "surfxml_del_callback" to remove a parse function call */
2217 }
2218
2219 static void model_dijkstra_both_end(void)
2220 {
2221   routing_component_dijkstra_t routing =
2222       (routing_component_dijkstra_t) current_routing;
2223
2224   xbt_node_t node = NULL;
2225   unsigned int cursor2;
2226   xbt_dynar_t nodes = NULL;
2227
2228   /* Add the loopback if needed */
2229   if (current_routing->hierarchy == SURF_ROUTING_BASE)
2230     add_loopback_dijkstra(routing);
2231
2232   /* initialize graph indexes in nodes after graph has been built */
2233   nodes = xbt_graph_get_nodes(routing->route_graph);
2234
2235   xbt_dynar_foreach(nodes, cursor2, node) {
2236     graph_node_data_t data = xbt_graph_node_get_data(node);
2237     data->graph_id = cursor2;
2238   }
2239
2240 }
2241 static void model_dijkstra_both_set_route (routing_component_t rc, const char *src,
2242                      const char *dst, name_route_extended_t route)
2243 {
2244         routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
2245         int *src_id, *dst_id;
2246         src_id = xbt_dict_get_or_null(rc->to_index, src);
2247         dst_id = xbt_dict_get_or_null(rc->to_index, dst);
2248
2249     /* Create the topology graph */
2250         if(!routing->route_cache)
2251         routing->route_graph = xbt_graph_new_graph(1, NULL);
2252         if(!routing->graph_node_map)
2253         routing->graph_node_map = xbt_dict_new();
2254
2255         if (routing->cached && !routing->route_cache)
2256         routing->route_cache = xbt_dict_new();
2257
2258         if( A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
2259                 || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES )
2260                 xbt_die("Route symmetrical not supported on model dijkstra");
2261
2262         if(!route->dst_gateway && !route->src_gateway)
2263           DEBUG2("Load Route from \"%s\" to \"%s\"", src, dst);
2264         else
2265           DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
2266                          route->src_gateway, dst, route->dst_gateway);
2267
2268         route_extended_t e_route =
2269                 generic_new_extended_route(current_routing->hierarchy, route, 1);
2270         route_new_dijkstra(routing, *src_id, *dst_id, e_route);
2271 }
2272
2273 #ifdef HAVE_PCRE_LIB
2274 /* ************************************************** */
2275 /* ************** RULE-BASED ROUTING **************** */
2276
2277 /* Routing model structure */
2278
2279 typedef struct {
2280   s_routing_component_t generic_routing;
2281   xbt_dict_t dict_processing_units;
2282   xbt_dict_t dict_autonomous_systems;
2283   xbt_dynar_t list_route;
2284   xbt_dynar_t list_ASroute;
2285 } s_routing_component_rulebased_t, *routing_component_rulebased_t;
2286
2287 typedef struct s_rule_route s_rule_route_t, *rule_route_t;
2288 typedef struct s_rule_route_extended s_rule_route_extended_t,
2289     *rule_route_extended_t;
2290
2291 struct s_rule_route {
2292   xbt_dynar_t re_str_link;      // dynar of char*
2293   pcre *re_src;
2294   pcre *re_dst;
2295 };
2296
2297 struct s_rule_route_extended {
2298   s_rule_route_t generic_rule_route;
2299   char *re_src_gateway;
2300   char *re_dst_gateway;
2301 };
2302
2303 static void rule_route_free(void *e)
2304 {
2305   rule_route_t *elem = (rule_route_t *) (e);
2306   if (*elem) {
2307     xbt_dynar_free(&(*elem)->re_str_link);
2308     pcre_free((*elem)->re_src);
2309     pcre_free((*elem)->re_dst);
2310     xbt_free(*elem);
2311   }
2312   *elem = NULL;
2313 }
2314
2315 static void rule_route_extended_free(void *e)
2316 {
2317   rule_route_extended_t *elem = (rule_route_extended_t *) e;
2318   if (*elem) {
2319     xbt_dynar_free(&(*elem)->generic_rule_route.re_str_link);
2320     pcre_free((*elem)->generic_rule_route.re_src);
2321     pcre_free((*elem)->generic_rule_route.re_dst);
2322     xbt_free((*elem)->re_src_gateway);
2323     xbt_free((*elem)->re_dst_gateway);
2324     xbt_free(*elem);
2325   }
2326 }
2327
2328 /* Parse routing model functions */
2329
2330 static void model_rulebased_set_processing_unit(routing_component_t rc,
2331                                                 const char *name)
2332 {
2333   routing_component_rulebased_t routing =
2334       (routing_component_rulebased_t) rc;
2335   xbt_dict_set(routing->dict_processing_units, name, (void *) (-1), NULL);
2336 }
2337
2338 static void model_rulebased_set_autonomous_system(routing_component_t rc,
2339                                                   const char *name)
2340 {
2341   routing_component_rulebased_t routing =
2342       (routing_component_rulebased_t) rc;
2343   xbt_dict_set(routing->dict_autonomous_systems, name, (void *) (-1),
2344                NULL);
2345 }
2346
2347 static void model_rulebased_set_route(routing_component_t rc,
2348                                       const char *src, const char *dst,
2349                                       name_route_extended_t route)
2350 {
2351   routing_component_rulebased_t routing =
2352       (routing_component_rulebased_t) rc;
2353   rule_route_t ruleroute = xbt_new0(s_rule_route_t, 1);
2354   const char *error;
2355   int erroffset;
2356   ruleroute->re_src = pcre_compile(src, 0, &error, &erroffset, NULL);
2357   xbt_assert3(ruleroute->re_src,
2358               "PCRE compilation failed at offset %d (\"%s\"): %s\n",
2359               erroffset, src, error);
2360   ruleroute->re_dst = pcre_compile(dst, 0, &error, &erroffset, NULL);
2361   xbt_assert3(ruleroute->re_src,
2362               "PCRE compilation failed at offset %d (\"%s\"): %s\n",
2363               erroffset, dst, error);
2364   ruleroute->re_str_link = route->generic_route.link_list;
2365   xbt_dynar_push(routing->list_route, &ruleroute);
2366   xbt_free(route);
2367 }
2368
2369 static void model_rulebased_set_ASroute(routing_component_t rc,
2370                                         const char *src, const char *dst,
2371                                         name_route_extended_t route)
2372 {
2373   routing_component_rulebased_t routing =
2374       (routing_component_rulebased_t) rc;
2375   rule_route_extended_t ruleroute_e = xbt_new0(s_rule_route_extended_t, 1);
2376   const char *error;
2377   int erroffset;
2378   ruleroute_e->generic_rule_route.re_src =
2379       pcre_compile(src, 0, &error, &erroffset, NULL);
2380   xbt_assert3(ruleroute_e->generic_rule_route.re_src,
2381               "PCRE compilation failed at offset %d (\"%s\"): %s\n",
2382               erroffset, src, error);
2383   ruleroute_e->generic_rule_route.re_dst =
2384       pcre_compile(dst, 0, &error, &erroffset, NULL);
2385   xbt_assert3(ruleroute_e->generic_rule_route.re_src,
2386               "PCRE compilation failed at offset %d (\"%s\"): %s\n",
2387               erroffset, dst, error);
2388   ruleroute_e->generic_rule_route.re_str_link =
2389       route->generic_route.link_list;
2390   ruleroute_e->re_src_gateway = route->src_gateway;
2391   ruleroute_e->re_dst_gateway = route->dst_gateway;
2392   xbt_dynar_push(routing->list_ASroute, &ruleroute_e);
2393 //  xbt_free(route->src_gateway);
2394 //  xbt_free(route->dst_gateway);
2395   xbt_free(route);
2396 }
2397
2398 static void model_rulebased_set_bypassroute(routing_component_t rc,
2399                                             const char *src,
2400                                             const char *dst,
2401                                             route_extended_t e_route)
2402 {
2403   xbt_die("bypass routing not supported for Route-Based model");
2404 }
2405
2406 #define BUFFER_SIZE 4096        /* result buffer size */
2407 #define OVECCOUNT 30            /* should be a multiple of 3 */
2408
2409 static char *remplace(char *value, const char **src_list, int src_size,
2410                       const char **dst_list, int dst_size)
2411 {
2412
2413   char result_result[BUFFER_SIZE];
2414   int i_result_buffer;
2415   int value_length = (int) strlen(value);
2416   int number = 0;
2417
2418   int i = 0;
2419   i_result_buffer = 0;
2420   do {
2421     if (value[i] == '$') {
2422       i++;                      // skip $
2423
2424       // find the number
2425       int number_length = 0;
2426       while ('0' <= value[i + number_length]
2427              && value[i + number_length] <= '9') {
2428         number_length++;
2429       }
2430       xbt_assert2(number_length != 0,
2431                   "bad string parameter, no number indication, at offset: %d (\"%s\")",
2432                   i, value);
2433
2434       // solve number
2435       number = atoi(value + i);
2436       i = i + number_length;
2437       xbt_assert2(i + 2 < value_length,
2438                   "bad string parameter, too few chars, at offset: %d (\"%s\")",
2439                   i, value);
2440
2441       // solve the indication
2442       const char **param_list;
2443       int param_size;
2444       if (value[i] == 's' && value[i + 1] == 'r' && value[i + 2] == 'c') {
2445         param_list = src_list;
2446         param_size = src_size;
2447       } else if (value[i] == 'd' && value[i + 1] == 's'
2448                  && value[i + 2] == 't') {
2449         param_list = dst_list;
2450         param_size = dst_size;
2451       } else {
2452         xbt_assert2(0,
2453                     "bad string parameter, support only \"src\" and \"dst\", at offset: %d (\"%s\")",
2454                     i, value);
2455       }
2456       i = i + 3;
2457
2458       xbt_assert4(param_size >= number,
2459                   "bad string parameter, not enough length param_size, at offset: %d (\"%s\") %d %d",
2460                   i, value, param_size, number);
2461
2462       const char *param = param_list[number];
2463       int size = strlen(param);
2464       int cp;
2465       for (cp = 0; cp < size; cp++) {
2466         result_result[i_result_buffer] = param[cp];
2467         i_result_buffer++;
2468         if (i_result_buffer >= BUFFER_SIZE)
2469           break;
2470       }
2471     } else {
2472       result_result[i_result_buffer] = value[i];
2473       i_result_buffer++;
2474       i++;                      // next char
2475     }
2476
2477   } while (i < value_length && i_result_buffer < BUFFER_SIZE);
2478
2479   xbt_assert2(i_result_buffer < BUFFER_SIZE,
2480               "solving string \"%s\", small buffer size (%d)", value,
2481               BUFFER_SIZE);
2482   result_result[i_result_buffer] = 0;
2483   return xbt_strdup(result_result);
2484 }
2485
2486 static route_extended_t rulebased_get_route(routing_component_t rc,
2487                                             const char *src,
2488                                             const char *dst);
2489 static xbt_dynar_t rulebased_get_onelink_routes(routing_component_t rc)
2490 {
2491   xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free);
2492   routing_component_rulebased_t routing = (routing_component_rulebased_t)rc;
2493
2494   xbt_dict_cursor_t c1 = NULL;
2495   char *k1, *d1;
2496
2497   //find router
2498   char *router = NULL;
2499   xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
2500     if (strstr (k1, "router")){
2501       router = k1;
2502     }
2503   }
2504   if (!router){
2505     xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
2506   }
2507
2508   xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
2509     route_extended_t route = rulebased_get_route (rc, router, k1);
2510
2511     int number_of_links = xbt_dynar_length(route->generic_route.link_list);
2512     if (number_of_links != 3) {
2513       xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
2514     }
2515
2516     void *link_ptr;
2517     xbt_dynar_get_cpy (route->generic_route.link_list, 2, &link_ptr);
2518     onelink_t onelink = xbt_new0 (s_onelink_t, 1);
2519     onelink->src = xbt_strdup (k1);
2520     onelink->dst = xbt_strdup (router);
2521     onelink->link_ptr = link_ptr;
2522     xbt_dynar_push (ret, &onelink);
2523   }
2524   return ret;
2525 }
2526
2527 /* Business methods */
2528 static route_extended_t rulebased_get_route(routing_component_t rc,
2529                                             const char *src,
2530                                             const char *dst)
2531 {
2532   xbt_assert1(rc && src
2533               && dst,
2534               "Invalid params for \"get_route\" function at AS \"%s\"",
2535               rc->name);
2536
2537   /* set utils vars */
2538   routing_component_rulebased_t routing =
2539       (routing_component_rulebased_t) rc;
2540
2541   int are_processing_units;
2542   xbt_dynar_t rule_list;
2543   if (xbt_dict_get_or_null(routing->dict_processing_units, src)
2544       && xbt_dict_get_or_null(routing->dict_processing_units, dst)) {
2545     are_processing_units = 1;
2546     rule_list = routing->list_route;
2547   } else if (xbt_dict_get_or_null(routing->dict_autonomous_systems, src)
2548              && xbt_dict_get_or_null(routing->dict_autonomous_systems,
2549                                      dst)) {
2550     are_processing_units = 0;
2551     rule_list = routing->list_ASroute;
2552   } else
2553     xbt_assert2(NULL,
2554                 "Ask for route \"from\"(%s)  or \"to\"(%s) no found in the local table",
2555                 src, dst);
2556
2557   int rc_src = -1;
2558   int rc_dst = -1;
2559   int src_length = (int) strlen(src);
2560   int dst_length = (int) strlen(dst);
2561
2562   xbt_dynar_t links_list =
2563       xbt_dynar_new(global_routing->size_of_link, NULL);
2564
2565   rule_route_t ruleroute;
2566   unsigned int cpt;
2567   int ovector_src[OVECCOUNT];
2568   int ovector_dst[OVECCOUNT];
2569   const char **list_src = NULL;
2570   const char **list_dst = NULL;
2571   xbt_dynar_foreach(rule_list, cpt, ruleroute) {
2572     rc_src =
2573         pcre_exec(ruleroute->re_src, NULL, src, src_length, 0, 0,
2574                   ovector_src, OVECCOUNT);
2575     if (rc_src >= 0) {
2576       rc_dst =
2577           pcre_exec(ruleroute->re_dst, NULL, dst, dst_length, 0, 0,
2578                     ovector_dst, OVECCOUNT);
2579       if (rc_dst >= 0) {
2580         xbt_assert1(!pcre_get_substring_list
2581                     (src, ovector_src, rc_src, &list_src),
2582                     "error solving substring list for src \"%s\"", src);
2583         xbt_assert1(!pcre_get_substring_list
2584                     (dst, ovector_dst, rc_dst, &list_dst),
2585                     "error solving substring list for src \"%s\"", dst);
2586         char *link_name;
2587         xbt_dynar_foreach(ruleroute->re_str_link, cpt, link_name) {
2588           char *new_link_name =
2589               remplace(link_name, list_src, rc_src, list_dst, rc_dst);
2590           void *link =
2591               xbt_dict_get_or_null(surf_network_model->resource_set,
2592                                    new_link_name);
2593           if (link)
2594             xbt_dynar_push(links_list, &link);
2595           else
2596             THROW1(mismatch_error, 0, "Link %s not found", new_link_name);
2597           xbt_free(new_link_name);
2598         }
2599       }
2600     }
2601     if (rc_src >= 0 && rc_dst >= 0)
2602       break;
2603   }
2604
2605   route_extended_t new_e_route = NULL;
2606   if (rc_src >= 0 && rc_dst >= 0) {
2607     new_e_route = xbt_new0(s_route_extended_t, 1);
2608     new_e_route->generic_route.link_list = links_list;
2609   } else if (!strcmp(src, dst) && are_processing_units) {
2610     new_e_route = xbt_new0(s_route_extended_t, 1);
2611     xbt_dynar_push(links_list, &(global_routing->loopback));
2612     new_e_route->generic_route.link_list = links_list;
2613   } else {
2614     xbt_dynar_free(&link_list);
2615   }
2616
2617   if (!are_processing_units && new_e_route) {
2618     rule_route_extended_t ruleroute_extended =
2619         (rule_route_extended_t) ruleroute;
2620     new_e_route->src_gateway =
2621         remplace(ruleroute_extended->re_src_gateway, list_src, rc_src,
2622                  list_dst, rc_dst);
2623     new_e_route->dst_gateway =
2624         remplace(ruleroute_extended->re_dst_gateway, list_src, rc_src,
2625                  list_dst, rc_dst);
2626   }
2627
2628   if (list_src)
2629     pcre_free_substring_list(list_src);
2630   if (list_dst)
2631     pcre_free_substring_list(list_dst);
2632
2633   return new_e_route;
2634 }
2635
2636 static route_extended_t rulebased_get_bypass_route(routing_component_t rc,
2637                                                    const char *src,
2638                                                    const char *dst)
2639 {
2640   return NULL;
2641 }
2642
2643 static void rulebased_finalize(routing_component_t rc)
2644 {
2645   routing_component_rulebased_t routing =
2646       (routing_component_rulebased_t) rc;
2647   if (routing) {
2648     xbt_dict_free(&routing->dict_processing_units);
2649     xbt_dict_free(&routing->dict_autonomous_systems);
2650     xbt_dynar_free(&routing->list_route);
2651     xbt_dynar_free(&routing->list_ASroute);
2652     /* Delete structure */
2653     xbt_free(routing);
2654   }
2655 }
2656
2657 /* Creation routing model functions */
2658 static void *model_rulebased_create(void)
2659 {
2660   routing_component_rulebased_t new_component =
2661       xbt_new0(s_routing_component_rulebased_t, 1);
2662   new_component->generic_routing.set_processing_unit =
2663       model_rulebased_set_processing_unit;
2664   new_component->generic_routing.set_autonomous_system =
2665       model_rulebased_set_autonomous_system;
2666   new_component->generic_routing.set_route = model_rulebased_set_route;
2667   new_component->generic_routing.set_ASroute = model_rulebased_set_ASroute;
2668   new_component->generic_routing.set_bypassroute = model_rulebased_set_bypassroute;
2669   new_component->generic_routing.get_onelink_routes = rulebased_get_onelink_routes;
2670   new_component->generic_routing.get_route = rulebased_get_route;
2671   new_component->generic_routing.get_latency = generic_get_link_latency;
2672   new_component->generic_routing.get_bypass_route = rulebased_get_bypass_route;
2673   new_component->generic_routing.finalize = rulebased_finalize;
2674   /* initialization of internal structures */
2675   new_component->dict_processing_units = xbt_dict_new();
2676   new_component->dict_autonomous_systems = xbt_dict_new();
2677   new_component->list_route = xbt_dynar_new(sizeof(rule_route_t), &rule_route_free);
2678   new_component->list_ASroute =
2679       xbt_dynar_new(sizeof(rule_route_extended_t),
2680                     &rule_route_extended_free);
2681   return new_component;
2682 }
2683
2684 static void model_rulebased_load(void)
2685 {
2686   /* use "surfxml_add_callback" to add a parse function call */
2687 }
2688
2689 static void model_rulebased_unload(void)
2690 {
2691   /* use "surfxml_del_callback" to remove a parse function call */
2692 }
2693
2694 static void model_rulebased_end(void)
2695 {
2696 }
2697
2698 #endif                          /* HAVE_PCRE_LIB */
2699
2700 /* ************************************************************************** */
2701 /* ******************************* NO ROUTING ******************************* */
2702
2703 /* Routing model structure */
2704 typedef struct {
2705   s_routing_component_t generic_routing;
2706 } s_routing_component_none_t, *routing_component_none_t;
2707
2708 /* Business methods */
2709 static xbt_dynar_t none_get_onelink_routes(routing_component_t rc)
2710 {
2711   return NULL;
2712 }
2713
2714 static route_extended_t none_get_route(routing_component_t rc,
2715                                        const char *src, const char *dst)
2716 {
2717   return NULL;
2718 }
2719
2720 static route_extended_t none_get_bypass_route(routing_component_t rc,
2721                                               const char *src,
2722                                               const char *dst)
2723 {
2724   return NULL;
2725 }
2726
2727 static void none_finalize(routing_component_t rc)
2728 {
2729   xbt_free(rc);
2730 }
2731
2732 static void none_set_processing_unit(routing_component_t rc,
2733                                      const char *name)
2734 {
2735 }
2736
2737 static void none_set_autonomous_system(routing_component_t rc,
2738                                        const char *name)
2739 {
2740 }
2741
2742 /* Creation routing model functions */
2743 static void *model_none_create(void)
2744 {
2745   routing_component_none_t new_component =
2746       xbt_new0(s_routing_component_none_t, 1);
2747   new_component->generic_routing.set_processing_unit =
2748       none_set_processing_unit;
2749   new_component->generic_routing.set_autonomous_system =
2750       none_set_autonomous_system;
2751   new_component->generic_routing.set_route = NULL;
2752   new_component->generic_routing.set_ASroute = NULL;
2753   new_component->generic_routing.set_bypassroute = NULL;
2754   new_component->generic_routing.get_route = none_get_route;
2755   new_component->generic_routing.get_onelink_routes =
2756       none_get_onelink_routes;
2757   new_component->generic_routing.get_bypass_route = none_get_bypass_route;
2758   new_component->generic_routing.finalize = none_finalize;
2759   return new_component;
2760 }
2761
2762 static void model_none_load(void)
2763 {
2764 }
2765
2766 static void model_none_unload(void)
2767 {
2768 }
2769
2770 static void model_none_end(void)
2771 {
2772 }
2773
2774 /* ************************************************** */
2775 /* ********** PATERN FOR NEW ROUTING **************** */
2776
2777 /* The minimal configuration of a new routing model need the next functions,
2778  * also you need to set at the start of the file, the new model in the model
2779  * list. Remember keep the null ending of the list.
2780  */
2781 /*** Routing model structure ***/
2782 // typedef struct {
2783 //   s_routing_component_t generic_routing;
2784 //   /* things that your routing model need */
2785 // } s_routing_component_NEW_t,*routing_component_NEW_t;
2786
2787 /*** Parse routing model functions ***/
2788 // static void model_NEW_set_processing_unit(routing_component_t rc, const char* name) {}
2789 // static void model_NEW_set_autonomous_system(routing_component_t rc, const char* name) {}
2790 // static void model_NEW_set_route(routing_component_t rc, const char* src, const char* dst, route_t route) {}
2791 // static void model_NEW_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t route) {}
2792 // static void model_NEW_set_bypassroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) {}
2793
2794 /*** Business methods ***/
2795 // static route_extended_t NEW_get_route(routing_component_t rc, const char* src,const char* dst) {return NULL;}
2796 // static route_extended_t NEW_get_bypass_route(routing_component_t rc, const char* src,const char* dst) {return NULL;}
2797 // static void NEW_finalize(routing_component_t rc) { xbt_free(rc);}
2798
2799 /*** Creation routing model functions ***/
2800 // static void* model_NEW_create(void) {
2801 //   routing_component_NEW_t new_component =  xbt_new0(s_routing_component_NEW_t,1);
2802 //   new_component->generic_routing.set_processing_unit = model_NEW_set_processing_unit;
2803 //   new_component->generic_routing.set_autonomous_system = model_NEW_set_autonomous_system;
2804 //   new_component->generic_routing.set_route = model_NEW_set_route;
2805 //   new_component->generic_routing.set_ASroute = model_NEW_set_ASroute;
2806 //   new_component->generic_routing.set_bypassroute = model_NEW_set_bypassroute;
2807 //   new_component->generic_routing.get_route = NEW_get_route;
2808 //   new_component->generic_routing.get_bypass_route = NEW_get_bypass_route;
2809 //   new_component->generic_routing.finalize = NEW_finalize;
2810 //   /* initialization of internal structures */
2811 //   return new_component;
2812 // } /* mandatory */
2813 // static void  model_NEW_load(void) {}   /* mandatory */
2814 // static void  model_NEW_unload(void) {} /* mandatory */
2815 // static void  model_NEW_end(void) {}    /* mandatory */
2816
2817 /* ************************************************************************** */
2818 /* ************************* GENERIC PARSE FUNCTIONS ************************ */
2819
2820 static void generic_set_processing_unit(routing_component_t rc,
2821                                         const char *name)
2822 {
2823   DEBUG1("Load process unit \"%s\"", name);
2824   int *id = xbt_new0(int, 1);
2825   xbt_dict_t _to_index;
2826   _to_index = current_routing->to_index;
2827   *id = xbt_dict_length(_to_index);
2828   xbt_dict_set(_to_index, name, id, xbt_free);
2829 }
2830
2831 static void generic_set_autonomous_system(routing_component_t rc,
2832                                           const char *name)
2833 {
2834   DEBUG1("Load Autonomous system \"%s\"", name);
2835   int *id = xbt_new0(int, 1);
2836   xbt_dict_t _to_index;
2837   _to_index = current_routing->to_index;
2838   *id = xbt_dict_length(_to_index);
2839   xbt_dict_set(_to_index, name, id, xbt_free);
2840 }
2841
2842 static int surf_pointer_resource_cmp(const void *a, const void *b)
2843 {
2844   return a != b;
2845 }
2846
2847 static int surf_link_resource_cmp(const void *a, const void *b)
2848 {
2849   return !!memcmp(a,b,global_routing->size_of_link);
2850 }
2851
2852 static void generic_set_bypassroute(routing_component_t rc,
2853                                     const char *src, const char *dst,
2854                                     route_extended_t e_route)
2855 {
2856   DEBUG2("Load bypassRoute from \"%s\" to \"%s\"", src, dst);
2857   xbt_dict_t dict_bypassRoutes = rc->bypassRoutes;
2858   char *route_name;
2859
2860   route_name = bprintf("%s#%s", src, dst);
2861   xbt_assert2(xbt_dynar_length(e_route->generic_route.link_list) > 0,
2862               "Invalid count of links, must be greater than zero (%s,%s)",
2863               src, dst);
2864   xbt_assert4(!xbt_dict_get_or_null(dict_bypassRoutes, route_name),
2865               "The bypass route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exists",
2866               src, e_route->src_gateway, dst, e_route->dst_gateway);
2867
2868   route_extended_t new_e_route =
2869       generic_new_extended_route(SURF_ROUTING_RECURSIVE, e_route, 0);
2870   xbt_dynar_free(&(e_route->generic_route.link_list));
2871   xbt_free(e_route);
2872
2873   xbt_dict_set(dict_bypassRoutes, route_name, new_e_route,
2874                (void (*)(void *)) generic_free_extended_route);
2875   xbt_free(route_name);
2876 }
2877
2878 /* ************************************************************************** */
2879 /* *********************** GENERIC BUSINESS METHODS ************************* */
2880
2881 static double generic_get_link_latency(routing_component_t rc,
2882                                        const char *src, const char *dst)
2883 {
2884         route_extended_t route = rc->get_route(rc,src,dst);
2885         void * link;
2886         unsigned int i;
2887         double latency = 0.0;
2888
2889         xbt_dynar_foreach(route->generic_route.link_list,i,link) {
2890                 latency += get_link_latency(link);
2891         }
2892         generic_free_extended_route(route);
2893   return latency;
2894 }
2895
2896 static xbt_dynar_t generic_get_onelink_routes(routing_component_t rc)
2897 {
2898   xbt_die("\"generic_get_onelink_routes\" not implemented yet");
2899 }
2900
2901 static route_extended_t generic_get_bypassroute(routing_component_t rc,
2902                                                 const char *src,
2903                                                 const char *dst)
2904 {
2905   xbt_dict_t dict_bypassRoutes = rc->bypassRoutes;
2906   routing_component_t src_as, dst_as;
2907   int index_src, index_dst;
2908   xbt_dynar_t path_src = NULL;
2909   xbt_dynar_t path_dst = NULL;
2910   routing_component_t current = NULL;
2911   routing_component_t *current_src = NULL;
2912   routing_component_t *current_dst = NULL;
2913
2914   /* (1) find the as where the src and dst are located */
2915   src_as = ((network_element_info_t)
2916             xbt_dict_get_or_null(global_routing->where_network_elements,
2917                                  src))->rc_component;
2918   dst_as = ((network_element_info_t)
2919             xbt_dict_get_or_null(global_routing->where_network_elements,
2920                                  dst))->rc_component;
2921   xbt_assert2(src_as
2922               && dst_as,
2923               "Ask for route \"from\"(%s) or \"to\"(%s) no found", src,
2924               dst);
2925
2926   /* (2) find the path to the root routing component */
2927   path_src = xbt_dynar_new(sizeof(routing_component_t), NULL);
2928   current = src_as;
2929   while (current != NULL) {
2930     xbt_dynar_push(path_src, &current);
2931     current = current->routing_father;
2932   }
2933   path_dst = xbt_dynar_new(sizeof(routing_component_t), NULL);
2934   current = dst_as;
2935   while (current != NULL) {
2936     xbt_dynar_push(path_dst, &current);
2937     current = current->routing_father;
2938   }
2939
2940   /* (3) find the common father */
2941   index_src = path_src->used - 1;
2942   index_dst = path_dst->used - 1;
2943   current_src = xbt_dynar_get_ptr(path_src, index_src);
2944   current_dst = xbt_dynar_get_ptr(path_dst, index_dst);
2945   while (index_src >= 0 && index_dst >= 0 && *current_src == *current_dst) {
2946     routing_component_t *tmp_src, *tmp_dst;
2947     tmp_src = xbt_dynar_pop_ptr(path_src);
2948     tmp_dst = xbt_dynar_pop_ptr(path_dst);
2949     index_src--;
2950     index_dst--;
2951     current_src = xbt_dynar_get_ptr(path_src, index_src);
2952     current_dst = xbt_dynar_get_ptr(path_dst, index_dst);
2953   }
2954
2955   int max_index_src = path_src->used - 1;
2956   int max_index_dst = path_dst->used - 1;
2957
2958   int max_index = max(max_index_src, max_index_dst);
2959   int i, max;
2960
2961   route_extended_t e_route_bypass = NULL;
2962
2963   for (max = 0; max <= max_index; max++) {
2964     for (i = 0; i < max; i++) {
2965       if (i <= max_index_src && max <= max_index_dst) {
2966         char *route_name = bprintf("%s#%s",
2967                                    (*(routing_component_t *)
2968                                     (xbt_dynar_get_ptr
2969                                      (path_src, i)))->name,
2970                                    (*(routing_component_t *)
2971                                     (xbt_dynar_get_ptr
2972                                      (path_dst, max)))->name);
2973         e_route_bypass =
2974             xbt_dict_get_or_null(dict_bypassRoutes, route_name);
2975         xbt_free(route_name);
2976       }
2977       if (e_route_bypass)
2978         break;
2979       if (max <= max_index_src && i <= max_index_dst) {
2980         char *route_name = bprintf("%s#%s",
2981                                    (*(routing_component_t *)
2982                                     (xbt_dynar_get_ptr
2983                                      (path_src, max)))->name,
2984                                    (*(routing_component_t *)
2985                                     (xbt_dynar_get_ptr
2986                                      (path_dst, i)))->name);
2987         e_route_bypass =
2988             xbt_dict_get_or_null(dict_bypassRoutes, route_name);
2989         xbt_free(route_name);
2990       }
2991       if (e_route_bypass)
2992         break;
2993     }
2994
2995     if (e_route_bypass)
2996       break;
2997
2998     if (max <= max_index_src && max <= max_index_dst) {
2999       char *route_name = bprintf("%s#%s",
3000                                  (*(routing_component_t *)
3001                                   (xbt_dynar_get_ptr
3002                                    (path_src, max)))->name,
3003                                  (*(routing_component_t *)
3004                                   (xbt_dynar_get_ptr
3005                                    (path_dst, max)))->name);
3006       e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes, route_name);
3007       xbt_free(route_name);
3008     }
3009     if (e_route_bypass)
3010       break;
3011   }
3012
3013   xbt_dynar_free(&path_src);
3014   xbt_dynar_free(&path_dst);
3015
3016   route_extended_t new_e_route = NULL;
3017
3018   if (e_route_bypass) {
3019     void *link;
3020     unsigned int cpt = 0;
3021     new_e_route = xbt_new0(s_route_extended_t, 1);
3022     new_e_route->src_gateway = xbt_strdup(e_route_bypass->src_gateway);
3023     new_e_route->dst_gateway = xbt_strdup(e_route_bypass->dst_gateway);
3024     new_e_route->generic_route.link_list =
3025         xbt_dynar_new(global_routing->size_of_link, NULL);
3026     xbt_dynar_foreach(e_route_bypass->generic_route.link_list, cpt, link) {
3027       xbt_dynar_push(new_e_route->generic_route.link_list, &link);
3028     }
3029   }
3030
3031   return new_e_route;
3032 }
3033
3034 /* ************************************************************************** */
3035 /* ************************* GENERIC AUX FUNCTIONS ************************** */
3036
3037 static route_t
3038 generic_new_route(e_surf_routing_hierarchy_t hierarchy,
3039                            void *data, int order)
3040 {
3041
3042   char *link_name;
3043   route_t new_route;
3044   unsigned int cpt;
3045   xbt_dynar_t links = NULL, links_id = NULL;
3046
3047   new_route = xbt_new0(s_route_t, 1);
3048   new_route->link_list =
3049       xbt_dynar_new(global_routing->size_of_link, NULL);
3050
3051   xbt_assert0(hierarchy == SURF_ROUTING_BASE,
3052               "the hierarchy type is not SURF_ROUTING_BASE");
3053
3054   links = ((route_t) data)->link_list;
3055
3056
3057   links_id = new_route->link_list;
3058
3059   xbt_dynar_foreach(links, cpt, link_name) {
3060
3061     void *link =
3062         xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
3063     if (link) {
3064       if (order)
3065         xbt_dynar_push(links_id, &link);
3066       else
3067         xbt_dynar_unshift(links_id, &link);
3068     } else
3069       THROW1(mismatch_error, 0, "Link %s not found", link_name);
3070   }
3071
3072   return new_route;
3073 }
3074
3075 static route_extended_t
3076 generic_new_extended_route(e_surf_routing_hierarchy_t hierarchy,
3077                            void *data, int order)
3078 {
3079
3080   char *link_name;
3081   route_extended_t e_route, new_e_route;
3082   route_t route;
3083   unsigned int cpt;
3084   xbt_dynar_t links = NULL, links_id = NULL;
3085
3086   new_e_route = xbt_new0(s_route_extended_t, 1);
3087   new_e_route->generic_route.link_list =
3088       xbt_dynar_new(global_routing->size_of_link, NULL);
3089   new_e_route->src_gateway = NULL;
3090   new_e_route->dst_gateway = NULL;
3091
3092   xbt_assert0(hierarchy == SURF_ROUTING_BASE
3093               || hierarchy == SURF_ROUTING_RECURSIVE,
3094               "the hierarchy type is not defined");
3095
3096   if (hierarchy == SURF_ROUTING_BASE) {
3097
3098     route = (route_t) data;
3099     links = route->link_list;
3100
3101   } else if (hierarchy == SURF_ROUTING_RECURSIVE) {
3102
3103     e_route = (route_extended_t) data;
3104     xbt_assert0(e_route->src_gateway
3105                 && e_route->dst_gateway, "bad gateway, is null");
3106     links = e_route->generic_route.link_list;
3107
3108     /* remeber not erase the gateway names */
3109     new_e_route->src_gateway = e_route->src_gateway;
3110     new_e_route->dst_gateway = e_route->dst_gateway;
3111   }
3112
3113   links_id = new_e_route->generic_route.link_list;
3114
3115   xbt_dynar_foreach(links, cpt, link_name) {
3116
3117     void *link =
3118         xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
3119     if (link) {
3120       if (order)
3121         xbt_dynar_push(links_id, &link);
3122       else
3123         xbt_dynar_unshift(links_id, &link);
3124     } else
3125       THROW1(mismatch_error, 0, "Link %s not found", link_name);
3126   }
3127
3128   return new_e_route;
3129 }
3130
3131 static void generic_free_route(route_t route)
3132 {
3133   if (route) {
3134     xbt_dynar_free(&(route->link_list));
3135     xbt_free(route);
3136   }
3137 }
3138
3139 static void generic_free_extended_route(route_extended_t e_route)
3140 {
3141   if (e_route) {
3142     xbt_dynar_free(&(e_route->generic_route.link_list));
3143     if (e_route->src_gateway)
3144       xbt_free(e_route->src_gateway);
3145     if (e_route->dst_gateway)
3146       xbt_free(e_route->dst_gateway);
3147     xbt_free(e_route);
3148   }
3149 }
3150
3151 static routing_component_t generic_as_exist(routing_component_t find_from,
3152                                             routing_component_t to_find)
3153 {
3154   //return to_find; // FIXME: BYPASSERROR OF FOREACH WITH BREAK
3155   xbt_dict_cursor_t cursor = NULL;
3156   char *key;
3157   int found = 0;
3158   routing_component_t elem;
3159   xbt_dict_foreach(find_from->routing_sons, cursor, key, elem) {
3160     if (to_find == elem || generic_as_exist(elem, to_find)) {
3161       found = 1;
3162       break;
3163     }
3164   }
3165   if (found)
3166     return to_find;
3167   return NULL;
3168 }
3169
3170 static routing_component_t
3171 generic_autonomous_system_exist(routing_component_t rc, char *element)
3172 {
3173   //return rc; // FIXME: BYPASSERROR OF FOREACH WITH BREAK
3174   routing_component_t element_as, result, elem;
3175   xbt_dict_cursor_t cursor = NULL;
3176   char *key;
3177   element_as = ((network_element_info_t)
3178                 xbt_dict_get_or_null
3179                 (global_routing->where_network_elements,
3180                  element))->rc_component;
3181   result = ((routing_component_t) - 1);
3182   if (element_as != rc)
3183     result = generic_as_exist(rc, element_as);
3184
3185   int found = 0;
3186   if (result) {
3187     xbt_dict_foreach(element_as->routing_sons, cursor, key, elem) {
3188       found = !strcmp(elem->name, element);
3189       if (found)
3190         break;
3191     }
3192     if (found)
3193       return element_as;
3194   }
3195   return NULL;
3196 }
3197
3198 static routing_component_t
3199 generic_processing_units_exist(routing_component_t rc, char *element)
3200 {
3201   routing_component_t element_as;
3202   element_as = ((network_element_info_t)
3203                 xbt_dict_get_or_null
3204                 (global_routing->where_network_elements,
3205                  element))->rc_component;
3206   if (element_as == rc)
3207     return element_as;
3208   return generic_as_exist(rc, element_as);
3209 }
3210
3211 static void generic_src_dst_check(routing_component_t rc, const char *src,
3212                                   const char *dst)
3213 {
3214
3215   routing_component_t src_as = ((network_element_info_t)
3216                                 xbt_dict_get_or_null
3217                                 (global_routing->where_network_elements,
3218                                  src))->rc_component;
3219   routing_component_t dst_as = ((network_element_info_t)
3220                                 xbt_dict_get_or_null
3221                                 (global_routing->where_network_elements,
3222                                  dst))->rc_component;
3223
3224   xbt_assert3(src_as != NULL && dst_as != NULL,
3225               "Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",
3226               src, dst, rc->name);
3227   xbt_assert4(src_as == dst_as,
3228               "The src(%s in %s) and dst(%s in %s) are in differents AS",
3229               src, src_as->name, dst, dst_as->name);
3230   xbt_assert2(rc == dst_as,
3231               "The routing component of src and dst is not the same as the network elements belong (%s==%s)",
3232               rc->name, dst_as->name);
3233 }
3234
3235 static void routing_parse_Sconfig(void)
3236 {
3237   //TODO
3238   DEBUG0("WARNING tag config not yet implemented.");
3239   DEBUG1("Configuration name = %s",A_surfxml_config_id);
3240 }
3241
3242 static void routing_parse_Econfig(void)
3243 {
3244   //TODO
3245   xbt_dict_cursor_t cursor = NULL;
3246   char *key;
3247   char *elem;
3248   xbt_dict_foreach(current_property_set, cursor, key, elem) {
3249           DEBUG2("property : %s = %s",key,elem);
3250         }
3251 }
3252
3253 static void routing_parse_Scluster(void)
3254 {
3255   static int AX_ptr = 0;
3256
3257   char *cluster_id = A_surfxml_cluster_id;
3258   char *cluster_prefix = A_surfxml_cluster_prefix;
3259   char *cluster_suffix = A_surfxml_cluster_suffix;
3260   char *cluster_radical = A_surfxml_cluster_radical;
3261   char *cluster_power = A_surfxml_cluster_power;
3262   char *cluster_core = A_surfxml_cluster_core;
3263   char *cluster_bw = A_surfxml_cluster_bw;
3264   char *cluster_lat = A_surfxml_cluster_lat;
3265   char *cluster_bb_bw = A_surfxml_cluster_bb_bw;
3266   char *cluster_bb_lat = A_surfxml_cluster_bb_lat;
3267   char *cluster_availability_file = A_surfxml_cluster_availability_file;
3268   char *cluster_state_file = A_surfxml_cluster_state_file;
3269   char *host_id, *groups, *link_id = NULL;
3270   char *router_id, *link_router, *link_backbone;
3271   char *availability_file = bprintf("%s",cluster_availability_file);
3272   char *state_file = bprintf("%s",cluster_state_file);
3273
3274   xbt_dict_t patterns = xbt_dict_new();
3275   xbt_dict_set(patterns,"id",cluster_id,NULL);
3276   xbt_dict_set(patterns,"prefix",cluster_prefix,NULL);
3277   xbt_dict_set(patterns,"suffix",cluster_suffix,NULL);
3278
3279
3280 #ifdef HAVE_PCRE_LIB
3281   char *route_src_dst;
3282 #endif
3283   unsigned int iter;
3284   int start, end, i;
3285   xbt_dynar_t radical_elements;
3286   xbt_dynar_t radical_ends;
3287   int cluster_sharing_policy = AX_surfxml_cluster_sharing_policy;
3288   int cluster_bb_sharing_policy = AX_surfxml_cluster_bb_sharing_policy;
3289
3290 #ifndef HAVE_PCRE_LIB
3291   xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL);
3292   char *route_src, *route_dst;
3293   int j;
3294 #endif
3295
3296   static unsigned int surfxml_buffer_stack_stack_ptr = 1;
3297   static unsigned int surfxml_buffer_stack_stack[1024];
3298
3299   surfxml_buffer_stack_stack[0] = 0;
3300
3301   surfxml_bufferstack_push(1);
3302
3303   SURFXML_BUFFER_SET(AS_id, cluster_id);
3304 #ifdef HAVE_PCRE_LIB
3305   SURFXML_BUFFER_SET(AS_routing, "RuleBased");
3306   DEBUG1("<AS id=\"%s\"\trouting=\"RuleBased\">", cluster_id);
3307 #else
3308   SURFXML_BUFFER_SET(AS_routing, "Full");
3309   DEBUG1("<AS id=\"%s\"\trouting=\"Full\">", cluster_id);
3310 #endif
3311   SURFXML_START_TAG(AS);
3312
3313   radical_elements = xbt_str_split(cluster_radical, ",");
3314   xbt_dynar_foreach(radical_elements, iter, groups) {
3315     radical_ends = xbt_str_split(groups, "-");
3316     switch (xbt_dynar_length(radical_ends)) {
3317     case 1:
3318       surf_parse_get_int(&start,
3319                          xbt_dynar_get_as(radical_ends, 0, char *));
3320       host_id = bprintf("%s%d%s", cluster_prefix, start, cluster_suffix);
3321 #ifndef HAVE_PCRE_LIB
3322       xbt_dynar_push_as(tab_elements_num, int, start);
3323 #endif
3324       link_id = bprintf("%s_link_%d", cluster_id, start);
3325
3326       DEBUG2("<host\tid=\"%s\"\tpower=\"%s\">", host_id, cluster_power);
3327       A_surfxml_host_state = A_surfxml_host_state_ON;
3328       SURFXML_BUFFER_SET(host_id, host_id);
3329       SURFXML_BUFFER_SET(host_power, cluster_power);
3330       SURFXML_BUFFER_SET(host_core, cluster_core);
3331       SURFXML_BUFFER_SET(host_availability, "1.0");
3332           xbt_dict_set(patterns,"radical",bprintf("%d",start),NULL);
3333           availability_file = bprintf("%s",cluster_availability_file);
3334           state_file = bprintf("%s",cluster_state_file);
3335           DEBUG1("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns));
3336           DEBUG1("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns));
3337           SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns));
3338           SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns));
3339           DEBUG0("</host>");
3340       SURFXML_START_TAG(host);
3341       SURFXML_END_TAG(host);
3342
3343       DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,cluster_bw, cluster_lat);
3344       A_surfxml_link_state = A_surfxml_link_state_ON;
3345       A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
3346       if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3347           {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
3348       if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
3349           {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
3350       SURFXML_BUFFER_SET(link_id, link_id);
3351       SURFXML_BUFFER_SET(link_bandwidth, cluster_bw);
3352       SURFXML_BUFFER_SET(link_latency, cluster_lat);
3353       SURFXML_BUFFER_SET(link_bandwidth_file, "");
3354       SURFXML_BUFFER_SET(link_latency_file, "");
3355       SURFXML_BUFFER_SET(link_state_file, "");
3356       SURFXML_START_TAG(link);
3357       SURFXML_END_TAG(link);
3358
3359       free(link_id);
3360       free(host_id);
3361       break;
3362
3363     case 2:
3364
3365       surf_parse_get_int(&start,
3366                          xbt_dynar_get_as(radical_ends, 0, char *));
3367       surf_parse_get_int(&end, xbt_dynar_get_as(radical_ends, 1, char *));
3368       for (i = start; i <= end; i++) {
3369         host_id = bprintf("%s%d%s", cluster_prefix, i, cluster_suffix);
3370 #ifndef HAVE_PCRE_LIB
3371         xbt_dynar_push_as(tab_elements_num, int, i);
3372 #endif
3373         link_id = bprintf("%s_link_%d", cluster_id, i);
3374
3375         DEBUG2("<host\tid=\"%s\"\tpower=\"%s\"", host_id, cluster_power);
3376         A_surfxml_host_state = A_surfxml_host_state_ON;
3377         SURFXML_BUFFER_SET(host_id, host_id);
3378         SURFXML_BUFFER_SET(host_power, cluster_power);
3379         SURFXML_BUFFER_SET(host_core, cluster_core);
3380                 SURFXML_BUFFER_SET(host_availability, "1.0");
3381                 xbt_dict_set(patterns,"radical",bprintf("%d",i),NULL);
3382                 availability_file = bprintf("%s",cluster_availability_file);
3383                 state_file = bprintf("%s",cluster_state_file);
3384                 DEBUG1("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns));
3385                 DEBUG1("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns));
3386                 SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns));
3387                 SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns));
3388                 DEBUG0("</host>");
3389         SURFXML_START_TAG(host);
3390         SURFXML_END_TAG(host);
3391
3392         DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,cluster_bw, cluster_lat);
3393         A_surfxml_link_state = A_surfxml_link_state_ON;
3394         A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
3395         if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3396             {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
3397         if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
3398             {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
3399         SURFXML_BUFFER_SET(link_id, link_id);
3400         SURFXML_BUFFER_SET(link_bandwidth, cluster_bw);
3401         SURFXML_BUFFER_SET(link_latency, cluster_lat);
3402         SURFXML_BUFFER_SET(link_bandwidth_file, "");
3403         SURFXML_BUFFER_SET(link_latency_file, "");
3404         SURFXML_BUFFER_SET(link_state_file, "");
3405         SURFXML_START_TAG(link);
3406         SURFXML_END_TAG(link);
3407
3408         free(link_id);
3409         free(host_id);
3410       }
3411       break;
3412
3413     default:
3414       DEBUG0("Malformed radical");
3415     }
3416
3417     xbt_dynar_free(&radical_ends);
3418   }
3419   xbt_dynar_free(&radical_elements);
3420
3421   DEBUG0(" ");
3422   router_id =
3423       bprintf("%s%s_router%s", cluster_prefix, cluster_id,
3424               cluster_suffix);
3425   link_router = bprintf("%s_link_%s_router", cluster_id, cluster_id);
3426   link_backbone = bprintf("%s_backbone", cluster_id);
3427
3428   DEBUG1("<router id=\"%s\"/>", router_id);
3429   SURFXML_BUFFER_SET(router_id, router_id);;
3430   SURFXML_START_TAG(router);
3431   SURFXML_END_TAG(router);
3432
3433   DEBUG3("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_router,cluster_bw, cluster_lat);
3434   A_surfxml_link_state = A_surfxml_link_state_ON;
3435   A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
3436   if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3437   {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
3438   if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
3439   {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
3440   SURFXML_BUFFER_SET(link_id, link_router);
3441   SURFXML_BUFFER_SET(link_bandwidth, cluster_bw);
3442   SURFXML_BUFFER_SET(link_latency, cluster_lat);
3443   SURFXML_BUFFER_SET(link_bandwidth_file, "");
3444   SURFXML_BUFFER_SET(link_latency_file, "");
3445   SURFXML_BUFFER_SET(link_state_file, "");
3446   SURFXML_START_TAG(link);
3447   SURFXML_END_TAG(link);
3448
3449   DEBUG3("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_backbone,cluster_bw, cluster_lat);
3450   A_surfxml_link_state = A_surfxml_link_state_ON;
3451   A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
3452   if(cluster_bb_sharing_policy == A_surfxml_cluster_bb_sharing_policy_FATPIPE)
3453   {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
3454   SURFXML_BUFFER_SET(link_id, link_backbone);
3455   SURFXML_BUFFER_SET(link_bandwidth, cluster_bb_bw);
3456   SURFXML_BUFFER_SET(link_latency, cluster_bb_lat);
3457   SURFXML_BUFFER_SET(link_bandwidth_file, "");
3458   SURFXML_BUFFER_SET(link_latency_file, "");
3459   SURFXML_BUFFER_SET(link_state_file, "");
3460   SURFXML_START_TAG(link);
3461   SURFXML_END_TAG(link);
3462
3463   DEBUG0(" ");
3464
3465 #ifdef HAVE_PCRE_LIB
3466   char *new_suffix = xbt_strdup("");
3467
3468   radical_elements = xbt_str_split(cluster_suffix, ".");
3469   xbt_dynar_foreach(radical_elements, iter, groups) {
3470     if (strcmp(groups, "")) {
3471       char *old_suffix = new_suffix;
3472       new_suffix = bprintf("%s\\.%s", old_suffix, groups);
3473       free(old_suffix);
3474     }
3475   }
3476   route_src_dst = bprintf("%s(.*)%s", cluster_prefix, new_suffix);
3477   xbt_dynar_free(&radical_elements);
3478   free(new_suffix);
3479
3480   char *pcre_link_src = bprintf("%s_link_$1src", cluster_id);
3481   char *pcre_link_backbone = bprintf("%s_backbone", cluster_id);
3482   char *pcre_link_dst = bprintf("%s_link_$1dst", cluster_id);
3483
3484   DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src_dst, route_src_dst);
3485   DEBUG0("symmetrical=\"NO\">");
3486   SURFXML_BUFFER_SET(route_src, route_src_dst);
3487   SURFXML_BUFFER_SET(route_dst, route_src_dst);
3488   A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
3489   SURFXML_START_TAG(route);
3490
3491   DEBUG1("<link_ctn\tid=\"%s\"/>", pcre_link_src);
3492   SURFXML_BUFFER_SET(link_ctn_id, pcre_link_src);
3493   A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3494   if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3495   {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
3496   SURFXML_START_TAG(link_ctn);
3497   SURFXML_END_TAG(link_ctn);
3498
3499   DEBUG1("<link_ctn\tid=\"%s\"/>", pcre_link_backbone);
3500   SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone);
3501   A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3502   SURFXML_START_TAG(link_ctn);
3503   SURFXML_END_TAG(link_ctn);
3504
3505   DEBUG1("<link_ctn\tid=\"%s\"/>", pcre_link_dst);
3506   SURFXML_BUFFER_SET(link_ctn_id, pcre_link_dst);
3507   A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3508   if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3509   {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
3510   SURFXML_START_TAG(link_ctn);
3511   SURFXML_END_TAG(link_ctn);
3512
3513   DEBUG0("</route>");
3514   SURFXML_END_TAG(route);
3515
3516   free(pcre_link_dst);
3517   free(pcre_link_backbone);
3518   free(pcre_link_src);
3519   free(route_src_dst);
3520 #else
3521   for (i = 0; i <= xbt_dynar_length(tab_elements_num); i++) {
3522     for (j = 0; j <= xbt_dynar_length(tab_elements_num); j++) {
3523       if (i == xbt_dynar_length(tab_elements_num)) {
3524         route_src = router_id;
3525       } else {
3526         route_src =
3527             bprintf("%s%d%s", cluster_prefix,
3528                     xbt_dynar_get_as(tab_elements_num, i, int),
3529                     cluster_suffix);
3530       }
3531
3532       if (j == xbt_dynar_length(tab_elements_num)) {
3533         route_dst = router_id;
3534       } else {
3535         route_dst =
3536             bprintf("%s%d%s", cluster_prefix,
3537                     xbt_dynar_get_as(tab_elements_num, j, int),
3538                     cluster_suffix);
3539       }
3540
3541       DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src, route_dst);
3542       DEBUG0("symmetrical=\"NO\">");
3543       SURFXML_BUFFER_SET(route_src, route_src);
3544       SURFXML_BUFFER_SET(route_dst, route_dst);
3545       A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
3546       SURFXML_START_TAG(route);
3547
3548       if (i == xbt_dynar_length(tab_elements_num)) {
3549         route_src = link_router;
3550       } else {
3551         route_src =
3552             bprintf("%s_link_%d", cluster_id,
3553                     xbt_dynar_get_as(tab_elements_num, i, int));
3554       }
3555
3556       if (j == xbt_dynar_length(tab_elements_num)) {
3557         route_dst = link_router;
3558       } else {
3559         route_dst =
3560             bprintf("%s_link_%d", cluster_id,
3561                     xbt_dynar_get_as(tab_elements_num, j, int));
3562       }
3563
3564       DEBUG1("<link_ctn\tid=\"%s\"/>", route_src);
3565       SURFXML_BUFFER_SET(link_ctn_id, route_src);
3566       A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3567       if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3568       {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
3569       SURFXML_START_TAG(link_ctn);
3570       SURFXML_END_TAG(link_ctn);
3571
3572       DEBUG1("<link_ctn\tid=\"%s_backbone\"/>", cluster_id);
3573       SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone", cluster_id));
3574       A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3575       SURFXML_START_TAG(link_ctn);
3576       SURFXML_END_TAG(link_ctn);
3577
3578       DEBUG1("<link_ctn\tid=\"%s\"/>", route_dst);
3579       SURFXML_BUFFER_SET(link_ctn_id, route_dst);
3580       A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3581       if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3582       {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
3583       SURFXML_START_TAG(link_ctn);
3584       SURFXML_END_TAG(link_ctn);
3585
3586       DEBUG0("</route>");
3587       SURFXML_END_TAG(route);
3588     }
3589   }
3590   xbt_dynar_free(&tab_elements_num);
3591   free(router_id);
3592
3593 #endif
3594
3595   free(link_backbone);
3596   free(link_router);
3597   xbt_dict_free(&patterns);
3598   free(availability_file);
3599   free(state_file);
3600
3601   DEBUG0("</AS>");
3602   SURFXML_END_TAG(AS);
3603   DEBUG0(" ");
3604
3605   surfxml_bufferstack_pop(1);
3606 }
3607
3608 static void routing_parse_Speer(void)
3609 {
3610   static int AX_ptr = 0;
3611
3612   char *peer_id = A_surfxml_peer_id;
3613   char *peer_power = A_surfxml_peer_power;
3614   char *peer_bw_in = A_surfxml_peer_bw_in;
3615   char *peer_bw_out = A_surfxml_peer_bw_out;
3616   char *peer_lat = A_surfxml_peer_lat;
3617   char *peer_coord = A_surfxml_peer_coordinates;
3618   char *peer_state_file = A_surfxml_peer_state_file;
3619   char *peer_availability_file = A_surfxml_peer_availability_file;
3620
3621   char *host_id = NULL;
3622   char *router_id, *link_router, *link_backbone, *link_id_up, *link_id_down;
3623
3624 #ifdef HAVE_PCRE_LIB
3625
3626 #endif
3627
3628   int peer_sharing_policy = AX_surfxml_peer_sharing_policy;
3629
3630 #ifndef HAVE_PCRE_LIB
3631   //xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL);
3632   //char *route_src, *route_dst;
3633   //int j;
3634 #endif
3635
3636   static unsigned int surfxml_buffer_stack_stack_ptr = 1;
3637   static unsigned int surfxml_buffer_stack_stack[1024];
3638
3639   surfxml_buffer_stack_stack[0] = 0;
3640
3641   surfxml_bufferstack_push(1);
3642
3643   SURFXML_BUFFER_SET(AS_id, peer_id);
3644 #ifdef HAVE_PCRE_LIB
3645   SURFXML_BUFFER_SET(AS_routing, "RuleBased");
3646   DEBUG1("<AS id=\"%s\"\trouting=\"RuleBased\">", peer_id);
3647 #else
3648   SURFXML_BUFFER_SET(AS_routing, "Full");
3649   DEBUG1("<AS id=\"%s\"\trouting=\"Full\">", peer_id);
3650 #endif
3651   SURFXML_START_TAG(AS);
3652
3653   DEBUG0(" ");
3654   host_id = bprintf("peer_%s", peer_id);
3655   router_id = bprintf("router_%s", peer_id);
3656   link_id_up = bprintf("link_%s_up", peer_id);
3657   link_id_down = bprintf("link_%s_down", peer_id);
3658
3659   link_router = bprintf("%s_link_router", peer_id);
3660   link_backbone = bprintf("%s_backbone", peer_id);
3661
3662   DEBUG2("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, peer_power);
3663   A_surfxml_host_state = A_surfxml_host_state_ON;
3664   SURFXML_BUFFER_SET(host_id, host_id);
3665   SURFXML_BUFFER_SET(host_power, peer_power);
3666   SURFXML_BUFFER_SET(host_availability, "1.0");
3667   SURFXML_BUFFER_SET(host_availability_file, peer_availability_file);
3668   SURFXML_BUFFER_SET(host_state_file, peer_state_file);
3669   SURFXML_START_TAG(host);
3670   SURFXML_END_TAG(host);
3671
3672   DEBUG2("<router id=\"%s\"\tcoordinates=\"%s\"/>", router_id, peer_coord);
3673   SURFXML_BUFFER_SET(router_id, router_id);
3674   SURFXML_BUFFER_SET(router_coordinates, peer_coord);
3675   SURFXML_START_TAG(router);
3676   SURFXML_END_TAG(router);
3677
3678   DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_up, peer_bw_in, peer_lat);
3679   A_surfxml_link_state = A_surfxml_link_state_ON;
3680   A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
3681   if(peer_sharing_policy == A_surfxml_peer_sharing_policy_FULLDUPLEX)
3682 {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
3683   SURFXML_BUFFER_SET(link_id, link_id_up);
3684   SURFXML_BUFFER_SET(link_bandwidth, peer_bw_in);
3685   SURFXML_BUFFER_SET(link_latency, peer_lat);
3686   SURFXML_BUFFER_SET(link_bandwidth_file, "");
3687   SURFXML_BUFFER_SET(link_latency_file, "");
3688   SURFXML_BUFFER_SET(link_state_file, "");
3689   SURFXML_START_TAG(link);
3690   SURFXML_END_TAG(link);
3691
3692   DEBUG3("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_down, peer_bw_out, peer_lat);
3693   A_surfxml_link_state = A_surfxml_link_state_ON;
3694   A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
3695   if(peer_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
3696 {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
3697   SURFXML_BUFFER_SET(link_id, link_id_down);
3698   SURFXML_BUFFER_SET(link_bandwidth, peer_bw_out);
3699   SURFXML_BUFFER_SET(link_latency, peer_lat);
3700   SURFXML_BUFFER_SET(link_bandwidth_file, "");
3701   SURFXML_BUFFER_SET(link_latency_file, "");
3702   SURFXML_BUFFER_SET(link_state_file, "");
3703   SURFXML_START_TAG(link);
3704   SURFXML_END_TAG(link);
3705
3706   DEBUG0(" ");
3707
3708   // begin here
3709   DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", peer_id, router_id);
3710   DEBUG0("symmetrical=\"NO\">");
3711   SURFXML_BUFFER_SET(route_src, peer_id);
3712   SURFXML_BUFFER_SET(route_dst, router_id);
3713   A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
3714   SURFXML_START_TAG(route);
3715
3716   DEBUG1("<link_ctn\tid=\"%s\"/>", link_id_up);
3717   SURFXML_BUFFER_SET(link_ctn_id, link_id_up);
3718   A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3719   if(peer_sharing_policy == A_surfxml_peer_sharing_policy_FULLDUPLEX)
3720   {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
3721   SURFXML_START_TAG(link_ctn);
3722   SURFXML_END_TAG(link_ctn);
3723
3724   DEBUG0("</route>");
3725   SURFXML_END_TAG(route);
3726
3727   //Opposite Route
3728   DEBUG2("<route\tsrc=\"%s\"\tdst=\"%s\"", router_id, peer_id);
3729   DEBUG0("symmetrical=\"NO\">");
3730   SURFXML_BUFFER_SET(route_src, router_id);
3731   SURFXML_BUFFER_SET(route_dst, peer_id);
3732   A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
3733   SURFXML_START_TAG(route);
3734
3735   DEBUG1("<link_ctn\tid=\"%s\"/>", link_id_down);
3736   SURFXML_BUFFER_SET(link_ctn_id, link_id_down);
3737   A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
3738   if(peer_sharing_policy == A_surfxml_peer_sharing_policy_FULLDUPLEX)
3739   {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
3740   SURFXML_START_TAG(link_ctn);
3741   SURFXML_END_TAG(link_ctn);
3742
3743   DEBUG0("</route>");
3744   SURFXML_END_TAG(route);
3745
3746   DEBUG0("</AS>");
3747   SURFXML_END_TAG(AS);
3748   DEBUG0(" ");
3749
3750   //xbt_dynar_free(&tab_elements_num);
3751
3752   surfxml_bufferstack_pop(1);
3753 }
3754
3755
3756 /*
3757  * New methods to init the routing model component from the lua script
3758  */
3759
3760 /*
3761  * calling parse_S_AS_lua with lua values
3762  */
3763 void routing_AS_init(const char *AS_id, const char *AS_routing)
3764 {
3765   parse_S_AS_lua((char *) AS_id, (char *) AS_routing);
3766 }
3767
3768 /*
3769  * calling parse_E_AS_lua to fisnish the creation of routing component
3770  */
3771 void routing_AS_end(const char *AS_id)
3772 {
3773   parse_E_AS_lua((char *) AS_id);
3774 }
3775
3776 /*
3777  * add a host to the network element list
3778  */
3779
3780 void routing_add_host(const char *host_id)
3781 {
3782   parse_S_host_lua((char *) host_id, (char*)""); // FIXME propagate coordinate system to lua
3783 }
3784
3785 /*
3786  * Set a new link on the actual list of link for a route or ASroute
3787  */
3788 void routing_add_link(const char *link_id)
3789 {
3790   parse_E_link_c_ctn_new_elem_lua((char *) link_id);
3791 }
3792
3793 /*
3794  *Set the endpoints for a route
3795  */
3796 void routing_set_route(const char *src_id, const char *dst_id)
3797 {
3798   parse_S_route_new_and_endpoints_lua(src_id, dst_id);
3799 }
3800
3801 /*
3802  * Store the route by calling parse_E_route_store_route
3803  */
3804 void routing_store_route(void)
3805 {
3806   parse_E_route_store_route();
3807 }