Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Start to fix the <cluster> tag (see ChangeLog)
[simgrid.git] / src / surf / surf_routing.c
1 /* Copyright (c) 2009 The SimGrid team. All rights reserved.                */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include <float.h>
7 #include "surf_private.h"
8 #include "xbt/dynar.h"
9 #include "xbt/str.h"
10 #include "xbt/config.h"
11 #include "xbt/graph.h"
12 #include "xbt/set.h"
13
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route,surf,"Routing part of surf");
15
16 routing_t used_routing = NULL;
17 xbt_dict_t onelink_routes = NULL;
18
19 /* Prototypes of each model */
20 static void routing_model_full_create(size_t size_of_link,void *loopback);
21 static void routing_model_floyd_create(size_t size_of_link, void*loopback);
22 static void routing_model_dijkstra_create(size_t size_of_link, void*loopback);
23 static void routing_model_dijkstracache_create(size_t size_of_link, void*loopback);
24 static void routing_model_none_create(size_t size_of_link, void*loopback);
25
26 /* Definition of each model */
27 struct model_type {
28   const char *name;
29   const char *desc;
30   void (*fun)(size_t,void*);
31 };
32 struct model_type models[] =
33 { {"Full", "Full routing data (fast, large memory requirements, fully expressive)", routing_model_full_create },
34   {"Floyd", "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)", routing_model_floyd_create },
35   {"Dijkstra", "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)", routing_model_dijkstra_create },
36   {"DijkstraCache", "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)", routing_model_dijkstracache_create },
37   {"none", "No routing (usable with Constant network only)", routing_model_none_create },
38     {NULL,NULL,NULL}};
39
40
41 void routing_model_create(size_t size_of_links, void* loopback) {
42
43   char * wanted=xbt_cfg_get_string(_surf_cfg_set,"routing");
44   int cpt;
45   for (cpt=0;models[cpt].name;cpt++) {
46     if (!strcmp(wanted,models[cpt].name)) {
47       (*(models[cpt].fun))(size_of_links,loopback);
48       return;
49     }
50   }
51   fprintf(stderr,"Routing model %s not found. Existing models:\n",wanted);
52   for (cpt=0;models[cpt].name;cpt++)
53     if (!strcmp(wanted,models[cpt].name))
54       fprintf(stderr,"   %s: %s\n",models[cpt].name,models[cpt].desc);
55   exit(1);
56 }
57
58 /* ************************************************************************** */
59 /* *************************** FULL ROUTING ********************************* */
60 typedef struct {
61   s_routing_t generic_routing;
62   xbt_dynar_t *routing_table;
63   void *loopback;
64   size_t size_of_link;
65 } s_routing_full_t,*routing_full_t;
66
67 #define ROUTE_FULL(i,j) ((routing_full_t)used_routing)->routing_table[(i)+(j)*(used_routing)->host_count]
68 #define HOST2ROUTER(id) ((id)+(2<<29))
69 #define ROUTER2HOST(id) ((id)-(2>>29))
70 #define ISROUTER(id) ((id)>=(2<<29))
71
72 /*
73  * Free the onelink routes
74  */
75 static void onelink_route_elem_free(void *e) {
76   s_onelink_t tmp = (s_onelink_t)e;
77   if(tmp) {
78     free(tmp);
79   }
80 }
81
82 /*
83  * Parsing
84  */
85 static void routing_full_parse_Shost(void) {
86   int *val = xbt_malloc(sizeof(int));
87   DEBUG2("Seen host %s (#%d)",A_surfxml_host_id,used_routing->host_count);
88   *val = used_routing->host_count++;
89   xbt_dict_set(used_routing->host_id,A_surfxml_host_id,val,xbt_free);
90 }
91
92 static void routing_full_parse_Srouter(void) {
93         int *val = xbt_malloc(sizeof(int));
94   DEBUG3("Seen router %s (%d -> #%d)",A_surfxml_router_id,used_routing->router_count,
95                 HOST2ROUTER(used_routing->router_count));
96   *val = HOST2ROUTER(used_routing->router_count++);
97   xbt_dict_set(used_routing->host_id,A_surfxml_router_id,val,xbt_free);
98 }
99
100 static int src_id = -1;
101 static int dst_id = -1;
102 static void routing_full_parse_Sroute_set_endpoints(void)
103 {
104   src_id = *(int*)xbt_dict_get(used_routing->host_id,A_surfxml_route_src);
105   dst_id = *(int*)xbt_dict_get(used_routing->host_id,A_surfxml_route_dst);
106   DEBUG4("Route %s %d -> %s %d",A_surfxml_route_src,src_id,A_surfxml_route_dst,dst_id);
107   route_action = A_surfxml_route_action;
108 }
109 static void routing_full_parse_Eroute(void)
110 {
111   char *name;
112   if (src_id != -1 && dst_id != -1) {
113     name = bprintf("%x#%x", src_id, dst_id);
114     manage_route(route_table, name, route_action, 0);
115     free(name);
116   }
117 }
118
119 /* Cluster tag functions */
120
121 static void routing_full_parse_change_cpu_data(const char *hostName,
122                                   const char *surfxml_host_power,
123                                   const char *surfxml_host_availability,
124                                   const char *surfxml_host_availability_file,
125                                   const char *surfxml_host_state_file)
126 {
127   int AX_ptr = 0;
128
129   SURFXML_BUFFER_SET(host_id, hostName);
130   SURFXML_BUFFER_SET(host_power, surfxml_host_power /*hostPower */ );
131   SURFXML_BUFFER_SET(host_availability, surfxml_host_availability);
132   SURFXML_BUFFER_SET(host_availability_file, surfxml_host_availability_file);
133   SURFXML_BUFFER_SET(host_state_file, surfxml_host_state_file);
134 }
135
136 static void routing_full_parse_change_link_data(const char *linkName,
137                                    const char *surfxml_link_bandwidth,
138                                    const char *surfxml_link_bandwidth_file,
139                                    const char *surfxml_link_latency,
140                                    const char *surfxml_link_latency_file,
141                                    const char *surfxml_link_state_file)
142 {
143   int AX_ptr = 0;
144
145   SURFXML_BUFFER_SET(link_id, linkName);
146   SURFXML_BUFFER_SET(link_bandwidth, surfxml_link_bandwidth);
147   SURFXML_BUFFER_SET(link_bandwidth_file, surfxml_link_bandwidth_file);
148   SURFXML_BUFFER_SET(link_latency, surfxml_link_latency);
149   SURFXML_BUFFER_SET(link_latency_file, surfxml_link_latency_file);
150   SURFXML_BUFFER_SET(link_state_file, surfxml_link_state_file);
151 }
152
153 static void routing_full_parse_Scluster(void)
154 {
155   static int AX_ptr = 0;
156
157   char *cluster_id = A_surfxml_cluster_id;
158   char *cluster_prefix = A_surfxml_cluster_prefix;
159   char *cluster_suffix = A_surfxml_cluster_suffix;
160   char *cluster_radical = A_surfxml_cluster_radical;
161   char *cluster_power = A_surfxml_cluster_power;
162   char *cluster_bw = A_surfxml_cluster_bw;
163   char *cluster_lat = A_surfxml_cluster_lat;
164   char *cluster_bb_bw = A_surfxml_cluster_bb_bw;
165   char *cluster_bb_lat = A_surfxml_cluster_bb_lat;
166   char *backbone_name;
167
168   surfxml_bufferstack_push(1);
169
170   /* Make set a set to parse the prefix/suffix/radical into a neat list of names */
171   DEBUG4("Make <set id='%s' prefix='%s' suffix='%s' radical='%s'>",
172       cluster_id,cluster_prefix,cluster_suffix,cluster_radical);
173   SURFXML_BUFFER_SET(set_id, cluster_id);
174   SURFXML_BUFFER_SET(set_prefix, cluster_prefix);
175   SURFXML_BUFFER_SET(set_suffix, cluster_suffix);
176   SURFXML_BUFFER_SET(set_radical, cluster_radical);
177
178   SURFXML_START_TAG(set);
179   SURFXML_END_TAG(set);
180
181   xbt_dynar_t names = xbt_dict_get(set_list,cluster_id);
182
183   unsigned int it1,it2;
184   char *name1,*name2;
185   xbt_dynar_foreach(names,it1,name1) {
186     /* create the host */
187     routing_full_parse_change_cpu_data(name1, cluster_power, "1.0", "", "");
188     A_surfxml_host_state = A_surfxml_host_state_ON;
189
190     SURFXML_START_TAG(host);
191     SURFXML_END_TAG(host);
192
193     /* Here comes the link */
194     routing_full_parse_change_link_data(name1, cluster_bw, "", cluster_lat, "", "");
195     A_surfxml_link_state = A_surfxml_link_state_ON;
196     A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
197
198     SURFXML_START_TAG(link);
199     SURFXML_END_TAG(link);
200   }
201
202   /* Make backbone link */
203   backbone_name = bprintf("%s_bb", cluster_id);
204   routing_full_parse_change_link_data(backbone_name, cluster_bb_bw, "", cluster_bb_lat, "",
205                          "");
206   A_surfxml_link_state = A_surfxml_link_state_ON;
207   A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;
208
209   SURFXML_START_TAG(link);
210   SURFXML_END_TAG(link);
211
212   /* And now the internal routes */
213   xbt_dynar_foreach(names,it1,name1) {
214     xbt_dynar_foreach(names,it2,name2) {
215       if (strcmp(name1,name2)) {
216         A_surfxml_route_action = A_surfxml_route_action_POSTPEND;
217         SURFXML_BUFFER_SET(route_src,name1);
218         SURFXML_BUFFER_SET(route_dst,name2);
219         SURFXML_START_TAG(route); {
220           /* FIXME: name1 link is added by error about 20 lines below, so don't add it here
221           SURFXML_BUFFER_SET(link_c_ctn_id, name1);
222           SURFXML_START_TAG(link_c_ctn);
223           SURFXML_END_TAG(link_c_ctn);
224            */
225           SURFXML_BUFFER_SET(link_c_ctn_id, backbone_name);
226           SURFXML_START_TAG(link_c_ctn);
227           SURFXML_END_TAG(link_c_ctn);
228
229           SURFXML_BUFFER_SET(link_c_ctn_id, name2);
230           SURFXML_START_TAG(link_c_ctn);
231           SURFXML_END_TAG(link_c_ctn);
232
233         } SURFXML_END_TAG(route);
234       }
235     }
236   }
237
238   /* Make route multi with the outside world, i.e. cluster->$* */
239
240   /* FIXME
241    * This also adds an elements to the routes within the cluster,
242    * and I guess it's wrong, but since this element is commented out in the above
243    * code creating the internal routes, we're good.
244    * To fix it, I'd say that we need a way to understand "$*-${cluster_id}" as "whole world, but the guys in that cluster"
245    * But for that, we need to install a real expression parser for src/dst attributes
246    *
247    * FIXME
248    * This also adds a dumb element (the private link) in place of the loopback. Then, since
249    * the loopback is added only if no link to self already exist, this fails.
250    * That's really dumb.
251    *
252    * FIXME
253    * It seems to me that it does not add the backbone to the path to outside world...
254    */
255   SURFXML_BUFFER_SET(route_c_multi_src, cluster_id);
256   SURFXML_BUFFER_SET(route_c_multi_dst, "$*");
257   A_surfxml_route_c_multi_symmetric = A_surfxml_route_c_multi_symmetric_NO;
258   A_surfxml_route_c_multi_action = A_surfxml_route_c_multi_action_PREPEND;
259
260   SURFXML_START_TAG(route_c_multi);
261
262   SURFXML_BUFFER_SET(link_c_ctn_id, "$src");
263
264   SURFXML_START_TAG(link_c_ctn);
265   SURFXML_END_TAG(link_c_ctn);
266
267   SURFXML_END_TAG(route_c_multi);
268
269   free(backbone_name);
270
271   /* Restore buff */
272   surfxml_bufferstack_pop(1);
273 }
274
275
276 static void routing_full_parse_end(void) {
277   routing_full_t routing = (routing_full_t) used_routing;
278   int nb_link = 0;
279   unsigned int cpt = 0;
280   xbt_dict_cursor_t cursor = NULL;
281   char *key, *data, *end;
282   const char *sep = "#";
283   xbt_dynar_t links, keys;
284   char *link_name = NULL;
285   int i,j;
286
287   int host_count = routing->generic_routing.host_count;
288
289   /* Create the routing table */
290   routing->routing_table = xbt_new0(xbt_dynar_t, host_count * host_count);
291   for (i=0;i<host_count;i++)
292     for (j=0;j<host_count;j++)
293       ROUTE_FULL(i,j) = xbt_dynar_new(routing->size_of_link,NULL);
294
295   /* Put the routes in position */
296   xbt_dict_foreach(route_table, cursor, key, data) {
297     nb_link = 0;
298     links = (xbt_dynar_t) data;
299     keys = xbt_str_split_str(key, sep);
300
301     src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 16);
302     dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 16);
303     xbt_dynar_free(&keys);
304
305     if(xbt_dynar_length(links) == 1){
306       s_onelink_t new_link = (s_onelink_t) xbt_malloc0(sizeof(s_onelink));
307       new_link->src_id = src_id;
308       new_link->dst_id = dst_id;
309       link_name = xbt_dynar_getfirst_as(links, char*);
310       new_link->link_ptr = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
311       DEBUG3("Adding onelink route from (#%d) to (#%d), link_name %s",src_id, dst_id, link_name);
312       xbt_dict_set(onelink_routes, link_name, (void *)new_link, onelink_route_elem_free);
313     }
314
315     if(ISROUTER(src_id) || ISROUTER(dst_id)) {
316                                 DEBUG2("There is route with a router here: (%d ,%d)",src_id,dst_id);
317                                 /* Check there is only one link in the route and store the information */
318                                 continue;
319     }
320
321     DEBUG4("Handle %d %d (from %d hosts): %ld links",
322         src_id,dst_id,routing->generic_routing.host_count,xbt_dynar_length(links));
323     xbt_dynar_foreach(links, cpt, link_name) {
324       void* link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
325       if (link)
326         xbt_dynar_push(ROUTE_FULL(src_id,dst_id),&link);
327       else
328         THROW1(mismatch_error,0,"Link %s not found", link_name);
329     }
330   }
331
332   /* Add the loopback if needed */
333   for (i = 0; i < host_count; i++)
334     if (!xbt_dynar_length(ROUTE_FULL(i, i)))
335       xbt_dynar_push(ROUTE_FULL(i,i),&routing->loopback);
336
337   /* Shrink the dynar routes (save unused slots) */
338   for (i=0;i<host_count;i++)
339     for (j=0;j<host_count;j++)
340       xbt_dynar_shrink(ROUTE_FULL(i,j),0);
341 }
342
343 /*
344  * Business methods
345  */
346 static xbt_dynar_t routing_full_get_route(int src,int dst) {
347   xbt_assert0(!(ISROUTER(src) || ISROUTER(dst)), "Ask for route \"from\" or \"to\" a router node");
348   return ROUTE_FULL(src,dst);
349 }
350
351 static xbt_dict_t routing_full_get_onelink_routes(void){
352   return onelink_routes;
353 }
354
355 static int routing_full_is_router(int id){
356         return ISROUTER(id);
357 }
358
359 static void routing_full_finalize(void) {
360   routing_full_t routing = (routing_full_t)used_routing;
361   int i,j;
362
363   if (routing) {
364     for (i = 0; i < used_routing->host_count; i++)
365       for (j = 0; j < used_routing->host_count; j++)
366         xbt_dynar_free(&ROUTE_FULL(i, j));
367     free(routing->routing_table);
368     xbt_dict_free(&used_routing->host_id);
369     free(routing);
370     routing=NULL;
371   }
372 }
373
374 static void routing_model_full_create(size_t size_of_link,void *loopback) {
375   /* initialize our structure */
376   routing_full_t routing = xbt_new0(s_routing_full_t,1);
377   routing->generic_routing.name = "Full";
378   routing->generic_routing.host_count = 0;
379   routing->generic_routing.get_route = routing_full_get_route;
380   routing->generic_routing.get_onelink_routes = routing_full_get_onelink_routes;
381   routing->generic_routing.is_router = routing_full_is_router;
382   routing->generic_routing.finalize = routing_full_finalize;
383
384   routing->size_of_link = size_of_link;
385   routing->loopback = loopback;
386
387   /* Set it in position */
388   used_routing = (routing_t) routing;
389
390   /* Set the dict for onehop routes */
391   onelink_routes =  xbt_dict_new();
392
393   /* Setup the parsing callbacks we need */
394   routing->generic_routing.host_id = xbt_dict_new();
395   surfxml_add_callback(STag_surfxml_host_cb_list, &routing_full_parse_Shost);
396   surfxml_add_callback(STag_surfxml_router_cb_list, &routing_full_parse_Srouter);
397   surfxml_add_callback(ETag_surfxml_platform_cb_list, &routing_full_parse_end);
398   surfxml_add_callback(STag_surfxml_route_cb_list,
399       &routing_full_parse_Sroute_set_endpoints);
400   surfxml_add_callback(ETag_surfxml_route_cb_list, &routing_full_parse_Eroute);
401   surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_full_parse_Scluster);
402 }
403
404 /* ************************************************************************** */
405
406 static void routing_shortest_path_parse_Scluster(void)
407 {
408   static int AX_ptr = 0;
409
410   char *cluster_id = A_surfxml_cluster_id;
411   char *cluster_prefix = A_surfxml_cluster_prefix;
412   char *cluster_suffix = A_surfxml_cluster_suffix;
413   char *cluster_radical = A_surfxml_cluster_radical;
414   char *cluster_power = A_surfxml_cluster_power;
415   char *cluster_bb_bw = A_surfxml_cluster_bb_bw;
416   char *cluster_bb_lat = A_surfxml_cluster_bb_lat;
417   char *backbone_name;
418
419   surfxml_bufferstack_push(1);
420
421   /* Make set */
422   SURFXML_BUFFER_SET(set_id, cluster_id);
423   SURFXML_BUFFER_SET(set_prefix, cluster_prefix);
424   SURFXML_BUFFER_SET(set_suffix, cluster_suffix);
425   SURFXML_BUFFER_SET(set_radical, cluster_radical);
426
427   SURFXML_START_TAG(set);
428   SURFXML_END_TAG(set);
429
430   /* Make foreach */
431   SURFXML_BUFFER_SET(foreach_set_id, cluster_id);
432
433   SURFXML_START_TAG(foreach);
434
435   /* Make host for the foreach */
436   routing_full_parse_change_cpu_data("$1", cluster_power, "1.0", "", "");
437   A_surfxml_host_state = A_surfxml_host_state_ON;
438
439   SURFXML_START_TAG(host);
440   SURFXML_END_TAG(host);
441
442   SURFXML_END_TAG(foreach);
443
444   /* Make backbone link */
445   backbone_name = bprintf("%s_bb", cluster_id);
446   routing_full_parse_change_link_data(backbone_name, cluster_bb_bw, "", cluster_bb_lat, "",
447                          "");
448   A_surfxml_link_state = A_surfxml_link_state_ON;
449   A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;
450
451   SURFXML_START_TAG(link);
452   SURFXML_END_TAG(link);
453
454   free(backbone_name);
455
456   /* Restore buff */
457   surfxml_bufferstack_pop(1);
458 }
459
460 /* ************************************************************************** */
461 /* *************************** FLOYD ROUTING ********************************* */
462 typedef struct {
463   s_routing_t generic_routing;
464   int *predecessor_table;
465   void** link_table;
466   xbt_dynar_t last_route;
467   void *loopback;
468   size_t size_of_link;
469 } s_routing_floyd_t,*routing_floyd_t;
470
471 #define FLOYD_COST(i,j) cost_table[(i)+(j)*(used_routing)->host_count]
472 #define FLOYD_PRED(i,j) ((routing_floyd_t)used_routing)->predecessor_table[(i)+(j)*(used_routing)->host_count]
473 #define FLOYD_LINK(i,j) ((routing_floyd_t)used_routing)->link_table[(i)+(j)*(used_routing)->host_count]
474
475 static void routing_floyd_parse_end(void) {
476
477   routing_floyd_t routing = (routing_floyd_t) used_routing;
478   int nb_link = 0;
479   void* link_list = NULL;
480   double * cost_table;
481   xbt_dict_cursor_t cursor = NULL;
482   char *key,*data, *end;
483   const char *sep = "#";
484   xbt_dynar_t links, keys;
485
486   unsigned int i,j;
487
488   int host_count = routing->generic_routing.host_count;
489
490   /* Create Cost, Predecessor and Link tables */
491   cost_table = xbt_new0(double, host_count * host_count); //link cost from host to host
492   routing->predecessor_table = xbt_new0(int, host_count*host_count); //predecessor host numbers
493   routing->link_table = xbt_new0(void*,host_count*host_count); //actual link between src and dst
494   routing->last_route = xbt_dynar_new(routing->size_of_link, NULL);
495
496   /* Initialize costs and predecessors*/
497   for(i = 0; i<host_count;i++)
498     for(j = 0; j<host_count;j++) {
499         FLOYD_COST(i,j) = DBL_MAX;
500         FLOYD_PRED(i,j) = -1;
501     }
502
503    /* Put the routes in position */
504   xbt_dict_foreach(route_table, cursor, key, data) {
505     nb_link = 0;
506     links = (xbt_dynar_t)data;
507     keys = xbt_str_split_str(key, sep);
508
509     
510     src_id = strtol(xbt_dynar_get_as(keys, 0, char*), &end, 16);
511     dst_id = strtol(xbt_dynar_get_as(keys, 1, char*), &end, 16);
512     xbt_dynar_free(&keys);
513  
514     DEBUG4("Handle %d %d (from %d hosts): %ld links",
515         src_id,dst_id,routing->generic_routing.host_count,xbt_dynar_length(links));
516     xbt_assert3(xbt_dynar_length(links) == 1, "%ld links in route between host %d and %d, should be 1", xbt_dynar_length(links), src_id, dst_id);
517     
518     char * link_name = xbt_dynar_getfirst_as(links, char*);
519     void * link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
520     if (link)
521       link_list = link;
522     else
523       THROW1(mismatch_error,0,"Link %s not found", link_name);
524     
525
526     FLOYD_LINK(src_id,dst_id) = link_list;
527     FLOYD_PRED(src_id, dst_id) = src_id;
528
529     //link cost
530     FLOYD_COST(src_id, dst_id) = 1; // assume 1 for now
531
532   }
533
534     /* Add the loopback if needed */
535   for (i = 0; i < host_count; i++)
536     if (!FLOYD_PRED(i, i)) {
537       FLOYD_PRED(i, i) = i;
538       FLOYD_COST(i, i) = 1;
539       FLOYD_LINK(i, i) = routing->loopback;
540     }
541
542
543   //Calculate path costs 
544   unsigned int a,b,c;
545   for(c=0;c<host_count;c++) {
546     for(a=0;a<host_count;a++) {
547       for(b=0;b<host_count;b++) {
548         if(FLOYD_COST(a,c) < DBL_MAX && FLOYD_COST(c,b) < DBL_MAX) {
549           if(FLOYD_COST(a,b) == DBL_MAX || (FLOYD_COST(a,c)+FLOYD_COST(c,b) < FLOYD_COST(a,b))) {
550             FLOYD_COST(a,b) = FLOYD_COST(a,c)+FLOYD_COST(c,b);
551             FLOYD_PRED(a,b) = FLOYD_PRED(c,b);
552           }
553         }
554       }
555     }
556   }
557
558   //cleanup
559   free(cost_table);
560 }
561
562 /*
563  * Business methods
564  */
565 static xbt_dynar_t routing_floyd_get_route(int src_id,int dst_id) {
566
567   routing_floyd_t routing = (routing_floyd_t) used_routing;
568
569   int pred = dst_id;
570   int prev_pred = 0;
571
572   xbt_dynar_reset(routing->last_route);
573
574   do {
575     prev_pred = pred;
576     pred = FLOYD_PRED(src_id, pred);
577
578     if(pred == -1) // if no pred in route -> no route to host
579         break;
580
581     xbt_dynar_unshift(routing->last_route, &FLOYD_LINK(pred,prev_pred));
582
583   } while(pred != src_id);
584
585   xbt_assert2(pred != -1, "no route from host %d to %d", src_id, dst_id);
586
587   return routing->last_route;
588 }
589
590 static void routing_floyd_finalize(void) {
591   routing_floyd_t routing = (routing_floyd_t)used_routing;
592
593   if (routing) {
594     free(routing->link_table);
595     free(routing->predecessor_table);
596     xbt_dynar_free(&routing->last_route);
597     xbt_dict_free(&used_routing->host_id);
598     free(routing);
599     routing=NULL;
600   }
601 }
602
603 static xbt_dict_t routing_floyd_get_onelink_routes(void){
604   xbt_assert0(0,"The get_onelink_routes feature is not supported in routing model Floyd");
605 }
606
607 static int routing_floyd_is_router(int id){
608   xbt_assert0(0,"The get_is_router feature is not supported in routing model Floyd");
609 }
610
611 static void routing_model_floyd_create(size_t size_of_link,void *loopback) {
612   /* initialize our structure */
613   routing_floyd_t routing = xbt_new0(s_routing_floyd_t,1);
614   routing->generic_routing.name = "Floyd";
615   routing->generic_routing.host_count = 0;
616   routing->generic_routing.host_id = xbt_dict_new();
617   routing->generic_routing.get_route = routing_floyd_get_route;
618   routing->generic_routing.get_onelink_routes = routing_floyd_get_onelink_routes;
619   routing->generic_routing.is_router = routing_floyd_is_router;
620   routing->generic_routing.finalize = routing_floyd_finalize;
621   routing->size_of_link = size_of_link;
622   routing->loopback = loopback;
623
624   /* Set it in position */
625   used_routing = (routing_t) routing;
626   
627   /* Setup the parsing callbacks we need */
628   surfxml_add_callback(STag_surfxml_host_cb_list, &routing_full_parse_Shost);
629   surfxml_add_callback(ETag_surfxml_platform_cb_list, &routing_floyd_parse_end);
630   surfxml_add_callback(STag_surfxml_route_cb_list, 
631       &routing_full_parse_Sroute_set_endpoints);
632   surfxml_add_callback(ETag_surfxml_route_cb_list, &routing_full_parse_Eroute);
633   surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_shortest_path_parse_Scluster);
634   
635 }
636
637 /* ************************************************************************** */
638 /* ********** Dijkstra & Dijkstra Cached ROUTING **************************** */
639 typedef struct {
640   s_routing_t generic_routing;
641   xbt_graph_t route_graph;
642   xbt_dict_t graph_node_map;
643   xbt_dict_t route_cache;
644   xbt_dynar_t last_route;
645   int cached;
646   void *loopback;
647   size_t size_of_link;
648 } s_routing_dijkstra_t,*routing_dijkstra_t;
649
650
651 typedef struct graph_node_data {
652   int id; 
653   int graph_id; //used for caching internal graph id's
654 } s_graph_node_data_t, * graph_node_data_t;
655
656 typedef struct graph_node_map_element {
657   xbt_node_t node;
658 } s_graph_node_map_element_t, * graph_node_map_element_t;
659
660 typedef struct route_cache_element {
661   int * pred_arr;
662   int size;
663 } s_route_cache_element_t, * route_cache_element_t;     
664
665 /*
666  * Free functions
667  */
668 static void route_cache_elem_free(void *e) {
669   route_cache_element_t elm=(route_cache_element_t)e;
670
671   if (elm) {
672     free(elm->pred_arr);
673     free(elm);
674   }
675 }
676
677 static void graph_node_map_elem_free(void *e) {
678   graph_node_map_element_t elm = (graph_node_map_element_t)e;
679
680   if(elm) {
681     free(elm);
682   }
683 }
684
685 /*
686  * Utility functions
687 */
688 static xbt_node_t route_graph_new_node(int id, int graph_id) {
689   routing_dijkstra_t routing = (routing_dijkstra_t) used_routing;
690
691   graph_node_data_t data = xbt_new0(struct graph_node_data, sizeof(struct graph_node_data));
692   data->id = id;
693   data->graph_id = graph_id;
694   xbt_node_t node = xbt_graph_new_node(routing->route_graph, data);
695
696   graph_node_map_element_t elm = xbt_new0(struct graph_node_map_element, sizeof(struct graph_node_map_element));
697   elm->node = node;
698   xbt_dict_set_ext(routing->graph_node_map, (char*)(&id), sizeof(int), (xbt_set_elm_t)elm, &graph_node_map_elem_free);
699
700   return node;
701 }
702
703 static graph_node_map_element_t graph_node_map_search(int id) {
704   routing_dijkstra_t routing = (routing_dijkstra_t) used_routing;
705
706   graph_node_map_element_t elm = (graph_node_map_element_t)xbt_dict_get_or_null_ext(routing->graph_node_map, (char*)(&id), sizeof(int));
707
708   return elm;
709 }
710
711 /*
712  * Parsing
713  */
714 static void route_new_dijkstra(int src_id, int dst_id, void* link) {
715   routing_dijkstra_t routing = (routing_dijkstra_t) used_routing;
716
717   xbt_node_t src = NULL;
718   xbt_node_t dst = NULL;
719   graph_node_map_element_t src_elm = (graph_node_map_element_t)xbt_dict_get_or_null_ext(routing->graph_node_map, (char*)(&src_id), sizeof(int));
720   graph_node_map_element_t dst_elm = (graph_node_map_element_t)xbt_dict_get_or_null_ext(routing->graph_node_map, (char*)(&dst_id), sizeof(int));
721
722   if(src_elm)
723     src = src_elm->node;
724
725   if(dst_elm)
726     dst = dst_elm->node;
727
728   //add nodes if they don't exist in the graph
729   if(src_id == dst_id && src == NULL && dst == NULL) {
730     src = route_graph_new_node(src_id, -1);
731     dst = src;
732   } else {
733     if(src == NULL) {
734       src = route_graph_new_node(src_id, -1);
735     }
736         
737     if(dst == NULL) {
738       dst = route_graph_new_node(dst_id, -1);
739     }
740   }
741
742   //add link as edge to graph
743   xbt_graph_new_edge(routing->route_graph, src, dst, link);
744   
745 }
746
747 static void add_loopback_dijkstra(void) {
748   routing_dijkstra_t routing = (routing_dijkstra_t) used_routing;
749
750         xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph);
751         
752         xbt_node_t node = NULL;
753         unsigned int cursor2;
754         xbt_dynar_foreach(nodes, cursor2, node) {
755                 xbt_dynar_t out_edges = xbt_graph_node_get_outedges(node); 
756                 xbt_edge_t edge = NULL;
757                 unsigned int cursor;
758         
759                 int found = 0;
760                 xbt_dynar_foreach(out_edges, cursor, edge) {
761                         xbt_node_t other_node = xbt_graph_edge_get_target(edge);
762                         if(other_node == node) {
763                                 found = 1;
764                                 break;
765                         }
766                 }
767
768                 if(!found)
769                         xbt_graph_new_edge(routing->route_graph, node, node, &routing->loopback);
770         }
771 }
772
773 static void routing_dijkstra_parse_end(void) {
774   routing_dijkstra_t routing = (routing_dijkstra_t) used_routing;
775   int nb_link = 0;
776   xbt_dict_cursor_t cursor = NULL;
777   char *key, *data, *end;
778   const char *sep = "#";
779   xbt_dynar_t links, keys;
780
781   /* Create the topology graph */
782   routing->route_graph = xbt_graph_new_graph(1, NULL);
783   routing->graph_node_map = xbt_dict_new();
784   routing->last_route = xbt_dynar_new(routing->size_of_link, NULL);
785   if(routing->cached)
786     routing->route_cache = xbt_dict_new();
787
788
789   /* Put the routes in position */
790   xbt_dict_foreach(route_table, cursor, key, data) {
791     nb_link = 0;
792     links = (xbt_dynar_t) data;
793     keys = xbt_str_split_str(key, sep);
794
795     src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 16);
796     dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 16);
797     xbt_dynar_free(&keys);
798
799     DEBUG4("Handle %d %d (from %d hosts): %ld links",
800         src_id,dst_id,routing->generic_routing.host_count,xbt_dynar_length(links));
801
802     xbt_assert3(xbt_dynar_length(links) == 1, "%ld links in route between host %d and %d, should be 1", xbt_dynar_length(links), src_id, dst_id);
803
804     char* link_name = xbt_dynar_getfirst_as(links, char*);
805     void* link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name);
806     if (link)
807       route_new_dijkstra(src_id,dst_id,link);
808     else
809       THROW1(mismatch_error,0,"Link %s not found", link_name);
810     
811   }
812
813   /* Add the loopback if needed */
814   add_loopback_dijkstra();
815
816   /* initialize graph indexes in nodes after graph has been built */
817   xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph);
818
819   xbt_node_t node = NULL;
820   unsigned int cursor2;
821   xbt_dynar_foreach(nodes, cursor2, node) {
822     graph_node_data_t data = xbt_graph_node_get_data(node);
823     data->graph_id = cursor2;
824   }
825
826 }
827
828 /*
829  * Business methods
830  */
831 static xbt_dynar_t routing_dijkstra_get_route(int src_id,int dst_id) {
832
833   routing_dijkstra_t routing = (routing_dijkstra_t) used_routing;
834   int * pred_arr = NULL;
835   
836   xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph);
837
838   /*Use the graph_node id mapping set to quickly find the nodes */
839   graph_node_map_element_t src_elm = graph_node_map_search(src_id);
840   graph_node_map_element_t dst_elm = graph_node_map_search(dst_id);
841   xbt_assert2(src_elm != NULL && dst_elm != NULL, "src %d or dst %d does not exist", src_id, dst_id);
842   int src_node_id = ((graph_node_data_t)xbt_graph_node_get_data(src_elm->node))->graph_id;
843   int dst_node_id = ((graph_node_data_t)xbt_graph_node_get_data(dst_elm->node))->graph_id;
844
845   route_cache_element_t elm = NULL;
846   if(routing->cached) {
847     /*check if there is a cached predecessor list avail */
848     elm = (route_cache_element_t)xbt_dict_get_or_null_ext(routing->route_cache, (char*)(&src_id), sizeof(int));
849   }
850
851   if(elm) { //cached mode and cache hit
852     pred_arr = elm->pred_arr;
853   } else { //not cached mode or cache miss
854     double * cost_arr = NULL;
855     xbt_heap_t pqueue = NULL;
856     int i = 0;
857
858     int nr_nodes = xbt_dynar_length(nodes);
859     cost_arr = xbt_new0(double, nr_nodes); //link cost from src to other hosts
860     pred_arr = xbt_new0(int, nr_nodes); //predecessors in path from src
861     pqueue = xbt_heap_new(nr_nodes, free);
862
863     //initialize
864     cost_arr[src_node_id] = 0.0;
865
866     for(i = 0; i < nr_nodes; i++) {
867       if(i != src_node_id) {
868         cost_arr[i] = DBL_MAX;
869       }
870
871       pred_arr[i] = 0;
872
873       //initialize priority queue
874       int * nodeid = xbt_new0(int, 1);
875       *nodeid = i;
876       xbt_heap_push(pqueue, nodeid, cost_arr[i]);
877
878     }
879
880     // apply dijkstra using the indexes from the graph's node array
881     while(xbt_heap_size(pqueue) > 0) {
882       int * v_id = xbt_heap_pop(pqueue);
883       xbt_node_t v_node = xbt_dynar_get_as(nodes, *v_id, xbt_node_t);
884       xbt_dynar_t out_edges = xbt_graph_node_get_outedges(v_node); 
885       xbt_edge_t edge = NULL;
886       unsigned int cursor;
887
888       xbt_dynar_foreach(out_edges, cursor, edge) {
889         xbt_node_t u_node = xbt_graph_edge_get_target(edge);
890         graph_node_data_t data = xbt_graph_node_get_data(u_node);
891         int u_id = data->graph_id;
892         int cost_v_u = 1; //fixed link cost for now
893
894         if(cost_v_u + cost_arr[*v_id] < cost_arr[u_id]) {
895           pred_arr[u_id] = *v_id;
896           cost_arr[u_id] = cost_v_u + cost_arr[*v_id];
897           int * nodeid = xbt_new0(int, 1);
898           *nodeid = u_id;
899           xbt_heap_push(pqueue, nodeid, cost_arr[u_id]);
900         }
901       }
902
903       //free item popped from pqueue
904       free(v_id);
905     }
906
907     free(cost_arr);
908     xbt_heap_free(pqueue);
909
910   }
911
912   //compose route path with links
913   xbt_dynar_reset(routing->last_route);
914
915   int v;
916   int size = 0;
917   for(v = dst_node_id; v != src_node_id; v = pred_arr[v]) {
918     xbt_node_t node_pred_v = xbt_dynar_get_as(nodes, pred_arr[v], xbt_node_t);
919     xbt_node_t node_v = xbt_dynar_get_as(nodes, v, xbt_node_t);
920     xbt_edge_t edge = xbt_graph_get_edge(routing->route_graph, node_pred_v, node_v);
921
922     xbt_assert2(edge != NULL, "no route between host %d and %d", src_id, dst_id);
923
924     void * link = xbt_graph_edge_get_data(edge);
925     xbt_dynar_unshift(routing->last_route, &link);
926     size++;
927   }
928
929
930   if(routing->cached && elm == NULL) {
931     //add to predecessor list of the current src-host to cache
932     elm = xbt_new0(struct route_cache_element, sizeof(struct route_cache_element));
933     elm->pred_arr = pred_arr;
934     elm->size = size;
935     xbt_dict_set_ext(routing->route_cache, (char*)(&src_id), sizeof(int), (xbt_set_elm_t)elm, &route_cache_elem_free);
936   }
937
938   if(!routing->cached)
939     free(pred_arr);
940
941   return routing->last_route;
942 }
943
944
945 static void routing_dijkstra_finalize(void) {
946   routing_dijkstra_t routing = (routing_dijkstra_t)used_routing;
947
948   if (routing) {
949     xbt_graph_free_graph(routing->route_graph, &free, NULL, &free);
950     xbt_dict_free(&routing->graph_node_map);
951     if(routing->cached)
952       xbt_dict_free(&routing->route_cache);
953     xbt_dynar_free(&routing->last_route);
954     xbt_dict_free(&used_routing->host_id);
955     free(routing);
956     routing=NULL;
957   }
958 }
959
960 static xbt_dict_t routing_dijkstraboth_get_onelink_routes(void){
961   xbt_assert0(0,"The get_onelink_routes feature is not supported in routing model dijkstraboth");
962 }
963
964 static int routing_dijkstraboth_is_router(int id){
965   xbt_assert0(0,"The get_is_router feature is not supported in routing model dijkstraboth");
966 }
967
968 /*
969  *
970  */
971 static void routing_model_dijkstraboth_create(size_t size_of_link,void *loopback, int cached) {
972   /* initialize our structure */
973   routing_dijkstra_t routing = xbt_new0(s_routing_dijkstra_t,1);
974   routing->generic_routing.name = "Dijkstra";
975   routing->generic_routing.host_count = 0;
976   routing->generic_routing.get_route = routing_dijkstra_get_route;
977   routing->generic_routing.get_onelink_routes = routing_dijkstraboth_get_onelink_routes;
978   routing->generic_routing.is_router = routing_dijkstraboth_is_router;
979   routing->generic_routing.finalize = routing_dijkstra_finalize;
980   routing->size_of_link = size_of_link;
981   routing->loopback = loopback;
982   routing->cached = cached;
983
984   /* Set it in position */
985   used_routing = (routing_t) routing;
986
987   /* Setup the parsing callbacks we need */
988   routing->generic_routing.host_id = xbt_dict_new();
989   surfxml_add_callback(STag_surfxml_host_cb_list, &routing_full_parse_Shost);
990   surfxml_add_callback(ETag_surfxml_platform_cb_list, &routing_dijkstra_parse_end);
991   surfxml_add_callback(STag_surfxml_route_cb_list,
992       &routing_full_parse_Sroute_set_endpoints);
993   surfxml_add_callback(ETag_surfxml_route_cb_list, &routing_full_parse_Eroute);
994   surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_shortest_path_parse_Scluster);
995 }
996
997 static void routing_model_dijkstra_create(size_t size_of_link,void *loopback) {
998   routing_model_dijkstraboth_create(size_of_link, loopback, 0);
999 }
1000
1001 static void routing_model_dijkstracache_create(size_t size_of_link,void *loopback) {
1002   routing_model_dijkstraboth_create(size_of_link, loopback, 1);
1003 }
1004
1005 /* ************************************************** */
1006 /* ********** NO ROUTING **************************** */
1007
1008
1009 static void routing_none_finalize(void) {
1010   if (used_routing) {
1011     xbt_dict_free(&used_routing->host_id);
1012     free(used_routing);
1013     used_routing=NULL;
1014   }
1015 }
1016
1017 static void routing_model_none_create(size_t size_of_link,void *loopback) {
1018   routing_t routing = xbt_new0(s_routing_t,1);
1019   INFO0("Null routing");
1020   routing->name = "none";
1021   routing->host_count = 0;
1022   routing->host_id = xbt_dict_new();
1023   routing->get_onelink_routes = NULL;
1024   routing->is_router = NULL;
1025   routing->get_route = NULL;
1026
1027   routing->finalize = routing_none_finalize;
1028
1029   /* Set it in position */
1030   used_routing = (routing_t) routing;
1031 }