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