Logo AND Algorithmique Numérique Distribuée

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