Logo AND Algorithmique Numérique Distribuée

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