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