src/surf/surfxml_parse.c

   1 /*      $Id$     */
   2
   3 /* Copyright (c) 2004 Arnaud Legrand. All rights reserved.                  */
   4
   5 /* This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the license (GNU LGPL) which comes with this package. */
   7
   8 #include "xbt/misc.h"
   9 #include "xbt/log.h"
  10 #include "xbt/str.h"
  11 #include "xbt/dict.h"
  12 #include "surf/surfxml_parse_private.h"
  13 #include "surf/surf_private.h"
  14
  15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_parse, surf,
  16                                 "Logging specific to the SURF parsing module");
  17 #undef CLEANUP
  18 #include "simgrid_dtd.c"
  19
  20 /* Initialize the parsing globals */
  21 int route_action = 0;
  22 xbt_dict_t traces_set_list = NULL;
  23 //xbt_dynar_t traces_connect_list = NULL;
  24 xbt_dict_t trace_connect_list_host_avail = NULL;
  25 xbt_dict_t trace_connect_list_power = NULL;
  26 xbt_dict_t trace_connect_list_link_avail = NULL;
  27 xbt_dict_t trace_connect_list_bandwidth = NULL;
  28 xbt_dict_t trace_connect_list_latency = NULL;
  29
  30 /* This buffer is used to store the original buffer before substituing it by out own buffer. Usefull for the foreach tag */
  31 static xbt_dynar_t surfxml_bufferstack_stack = NULL;
  32 int surfxml_bufferstack_size = 2048;
  33 static char *old_buff = NULL;
  34 static void surf_parse_error(char *msg);
  35
  36 void surfxml_bufferstack_push(int new)
  37 {
  38   if (!new)
  39     old_buff = surfxml_bufferstack;
  40   else {
  41     xbt_dynar_push(surfxml_bufferstack_stack, &surfxml_bufferstack);
  42     surfxml_bufferstack = xbt_new0(char, surfxml_bufferstack_size);
  43   }
  44 }
  45
  46 void surfxml_bufferstack_pop(int new)
  47 {
  48   if (!new)
  49     surfxml_bufferstack = old_buff;
  50   else {
  51     free(surfxml_bufferstack);
  52     xbt_dynar_pop(surfxml_bufferstack_stack, &surfxml_bufferstack);
  53   }
  54 }
  55
  56 /* Stores the set name reffered to by the foreach tag */
  57 static char *foreach_set_name;
  58 static xbt_dynar_t main_STag_surfxml_host_cb_list = NULL;
  59 static xbt_dynar_t main_ETag_surfxml_host_cb_list = NULL;
  60 static xbt_dynar_t main_STag_surfxml_link_cb_list = NULL;
  61 static xbt_dynar_t main_ETag_surfxml_link_cb_list = NULL;
  62
  63 /* make sure these symbols are defined as strong ones in this file so that the linked can resolve them */
  64 xbt_dynar_t STag_surfxml_platform_cb_list = NULL;
  65 xbt_dynar_t ETag_surfxml_platform_cb_list = NULL;
  66 xbt_dynar_t STag_surfxml_host_cb_list = NULL;
  67 xbt_dynar_t ETag_surfxml_host_cb_list = NULL;
  68 xbt_dynar_t STag_surfxml_router_cb_list = NULL;
  69 xbt_dynar_t ETag_surfxml_router_cb_list = NULL;
  70 xbt_dynar_t STag_surfxml_link_cb_list = NULL;
  71 xbt_dynar_t ETag_surfxml_link_cb_list = NULL;
  72 xbt_dynar_t STag_surfxml_route_cb_list = NULL;
  73 xbt_dynar_t ETag_surfxml_route_cb_list = NULL;
  74 xbt_dynar_t STag_surfxml_link_c_ctn_cb_list = NULL;
  75 xbt_dynar_t ETag_surfxml_link_c_ctn_cb_list = NULL;
  76 xbt_dynar_t STag_surfxml_process_cb_list = NULL;
  77 xbt_dynar_t ETag_surfxml_process_cb_list = NULL;
  78 xbt_dynar_t STag_surfxml_argument_cb_list = NULL;
  79 xbt_dynar_t ETag_surfxml_argument_cb_list = NULL;
  80 xbt_dynar_t STag_surfxml_prop_cb_list = NULL;
  81 xbt_dynar_t ETag_surfxml_prop_cb_list = NULL;
  82 xbt_dynar_t STag_surfxml_set_cb_list = NULL;
  83 xbt_dynar_t ETag_surfxml_set_cb_list = NULL;
  84 xbt_dynar_t STag_surfxml_foreach_cb_list = NULL;
  85 xbt_dynar_t ETag_surfxml_foreach_cb_list = NULL;
  86 xbt_dynar_t STag_surfxml_route_c_multi_cb_list = NULL;
  87 xbt_dynar_t ETag_surfxml_route_c_multi_cb_list = NULL;
  88 xbt_dynar_t STag_surfxml_cluster_cb_list = NULL;
  89 xbt_dynar_t ETag_surfxml_cluster_cb_list = NULL;
  90 xbt_dynar_t STag_surfxml_trace_cb_list = NULL;
  91 xbt_dynar_t ETag_surfxml_trace_cb_list = NULL;
  92 xbt_dynar_t STag_surfxml_trace_c_connect_cb_list = NULL;
  93 xbt_dynar_t ETag_surfxml_trace_c_connect_cb_list = NULL;
  94 xbt_dynar_t STag_surfxml_random_cb_list = NULL;
  95 xbt_dynar_t ETag_surfxml_random_cb_list = NULL;
  96
  97 /* Stores the sets defined in the XML */
  98 xbt_dict_t set_list = NULL;
  99
 100 xbt_dict_t current_property_set = NULL;
 101
 102 /* For the route:multi tag */
 103 xbt_dict_t route_table = NULL;
 104 xbt_dict_t route_multi_table = NULL;
 105 xbt_dynar_t route_multi_elements = NULL;
 106 static xbt_dynar_t route_link_list = NULL;
 107 xbt_dynar_t links = NULL;
 108 xbt_dynar_t keys = NULL;
 109
 110 xbt_dict_t random_data_list = NULL;
 111
 112 static xbt_dynar_t surf_input_buffer_stack = NULL;
 113 static xbt_dynar_t surf_file_to_parse_stack = NULL;
 114
 115 static XBT_INLINE void surfxml_call_cb_functions(xbt_dynar_t);
 116
 117 YY_BUFFER_STATE surf_input_buffer;
 118 FILE *surf_file_to_parse = NULL;
 119
 120 static void convert_route_multi_to_routes(void);
 121 static void parse_route_elem(void);
 122 static void parse_foreach(void);
 123 static void parse_sets(void);
 124 static void parse_route_multi_set_endpoints(void);
 125 static void parse_route_multi_set_route(void);
 126 static void parse_trace_init(void);
 127 static void parse_trace_finalize(void);
 128 static void parse_trace_c_connect(void);
 129 static void init_randomness(void);
 130 static void add_randomness(void);
 131
 132 void surf_parse_free_callbacks(void)
 133 {
 134   xbt_dynar_free(&STag_surfxml_platform_cb_list);
 135   xbt_dynar_free(&ETag_surfxml_platform_cb_list);
 136   xbt_dynar_free(&STag_surfxml_host_cb_list);
 137   xbt_dynar_free(&ETag_surfxml_host_cb_list);
 138   xbt_dynar_free(&STag_surfxml_router_cb_list);
 139   xbt_dynar_free(&ETag_surfxml_router_cb_list);
 140   xbt_dynar_free(&STag_surfxml_link_cb_list);
 141   xbt_dynar_free(&ETag_surfxml_link_cb_list);
 142   xbt_dynar_free(&STag_surfxml_route_cb_list);
 143   xbt_dynar_free(&ETag_surfxml_route_cb_list);
 144   xbt_dynar_free(&STag_surfxml_link_c_ctn_cb_list);
 145   xbt_dynar_free(&ETag_surfxml_link_c_ctn_cb_list);
 146   xbt_dynar_free(&STag_surfxml_process_cb_list);
 147   xbt_dynar_free(&ETag_surfxml_process_cb_list);
 148   xbt_dynar_free(&STag_surfxml_argument_cb_list);
 149   xbt_dynar_free(&ETag_surfxml_argument_cb_list);
 150   xbt_dynar_free(&STag_surfxml_prop_cb_list);
 151   xbt_dynar_free(&ETag_surfxml_prop_cb_list);
 152   xbt_dynar_free(&STag_surfxml_set_cb_list);
 153   xbt_dynar_free(&ETag_surfxml_set_cb_list);
 154   xbt_dynar_free(&STag_surfxml_foreach_cb_list);
 155   xbt_dynar_free(&ETag_surfxml_foreach_cb_list);
 156   xbt_dynar_free(&STag_surfxml_route_c_multi_cb_list);
 157   xbt_dynar_free(&ETag_surfxml_route_c_multi_cb_list);
 158   xbt_dynar_free(&STag_surfxml_cluster_cb_list);
 159   xbt_dynar_free(&ETag_surfxml_cluster_cb_list);
 160   xbt_dynar_free(&STag_surfxml_trace_cb_list);
 161   xbt_dynar_free(&ETag_surfxml_trace_cb_list);
 162   xbt_dynar_free(&STag_surfxml_trace_c_connect_cb_list);
 163   xbt_dynar_free(&ETag_surfxml_trace_c_connect_cb_list);
 164   xbt_dynar_free(&STag_surfxml_random_cb_list);
 165   xbt_dynar_free(&ETag_surfxml_random_cb_list);
 166 }
 167
 168 void surf_parse_reset_parser(void)
 169 {
 170   surf_parse_free_callbacks();
 171   STag_surfxml_platform_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 172   ETag_surfxml_platform_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 173   STag_surfxml_host_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 174   ETag_surfxml_host_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 175   STag_surfxml_router_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 176   ETag_surfxml_router_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 177   STag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 178   ETag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 179   STag_surfxml_route_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 180   ETag_surfxml_route_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 181   STag_surfxml_link_c_ctn_cb_list =
 182     xbt_dynar_new(sizeof(void_f_void_t), NULL);
 183   ETag_surfxml_link_c_ctn_cb_list =
 184     xbt_dynar_new(sizeof(void_f_void_t), NULL);
 185   STag_surfxml_process_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 186   ETag_surfxml_process_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 187   STag_surfxml_argument_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 188   ETag_surfxml_argument_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 189   STag_surfxml_prop_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 190   ETag_surfxml_prop_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 191   STag_surfxml_set_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 192   ETag_surfxml_set_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 193   STag_surfxml_foreach_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 194   ETag_surfxml_foreach_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 195   STag_surfxml_route_c_multi_cb_list =
 196     xbt_dynar_new(sizeof(void_f_void_t), NULL);
 197   ETag_surfxml_route_c_multi_cb_list =
 198     xbt_dynar_new(sizeof(void_f_void_t), NULL);
 199   STag_surfxml_cluster_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 200   ETag_surfxml_cluster_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 201   STag_surfxml_trace_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 202   ETag_surfxml_trace_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 203   STag_surfxml_trace_c_connect_cb_list =
 204     xbt_dynar_new(sizeof(void_f_void_t), NULL);
 205   ETag_surfxml_trace_c_connect_cb_list =
 206     xbt_dynar_new(sizeof(void_f_void_t), NULL);
 207   STag_surfxml_random_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 208   ETag_surfxml_random_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 209 }
 210
 211 void STag_surfxml_include(void)
 212 {
 213   xbt_dynar_push(surf_input_buffer_stack, &surf_input_buffer);
 214   xbt_dynar_push(surf_file_to_parse_stack, &surf_file_to_parse);
 215
 216   surf_file_to_parse = surf_fopen(A_surfxml_include_file, "r");
 217   xbt_assert1((surf_file_to_parse), "Unable to open \"%s\"\n",
 218               A_surfxml_include_file);
 219   surf_input_buffer = surf_parse__create_buffer(surf_file_to_parse, 10);
 220   surf_parse__switch_to_buffer(surf_input_buffer);
 221   printf("STAG\n");
 222   fflush(NULL);
 223 }
 224
 225 void ETag_surfxml_include(void)
 226 {
 227   printf("ETAG\n");
 228   fflush(NULL);
 229   surf_parse__delete_buffer(surf_input_buffer);
 230   fclose(surf_file_to_parse);
 231   xbt_dynar_pop(surf_file_to_parse_stack, &surf_file_to_parse);
 232   xbt_dynar_pop(surf_input_buffer_stack, &surf_input_buffer);
 233 }
 234
 235 void STag_surfxml_platform(void)
 236 {
 237   double version = 0.0;
 238
 239   sscanf(A_surfxml_platform_version, "%lg", &version);
 240
 241   xbt_assert0((version >= 1.0), "******* BIG FAT WARNING *********\n "
 242               "You're using an ancient XML file. "
 243               "Since SimGrid 3.1, units are Bytes, Flops, and seconds "
 244               "instead of MBytes, MFlops and seconds. "
 245               "A script (surfxml_update.pl) to help you convert your old "
 246               "platform files "
 247               "is available in the contrib/platform_generation directory "
 248               "of the simgrid repository. Please check also out the "
 249               "SURF section of the ChangeLog for the 3.1 version. "
 250               "Last, do not forget to also update your values for "
 251               "the calls to MSG_task_create (if any).");
 252   xbt_assert0((version >= 2.0), "******* BIG FAT WARNING *********\n "
 253               "You're using an old XML file. "
 254               "A script (surfxml_update.pl) to help you convert your old "
 255               "platform files "
 256               "is available in the contrib/platform_generation directory "
 257               "of the simgrid repository.");
 258
 259   surfxml_call_cb_functions(STag_surfxml_platform_cb_list);
 260
 261 }
 262
 263 void ETag_surfxml_platform(void)
 264 {
 265   convert_route_multi_to_routes();
 266
 267   surfxml_call_cb_functions(ETag_surfxml_platform_cb_list);
 268
 269   xbt_dict_free(&random_data_list);
 270 }
 271
 272 void STag_surfxml_host(void)
 273 {
 274   surfxml_call_cb_functions(STag_surfxml_host_cb_list);
 275 }
 276
 277 void ETag_surfxml_host(void)
 278 {
 279   surfxml_call_cb_functions(ETag_surfxml_host_cb_list);
 280 }
 281
 282 void STag_surfxml_router(void)
 283 {
 284   surfxml_call_cb_functions(STag_surfxml_router_cb_list);
 285 }
 286
 287 void ETag_surfxml_router(void)
 288 {
 289   surfxml_call_cb_functions(ETag_surfxml_router_cb_list);
 290 }
 291
 292 void STag_surfxml_link(void)
 293 {
 294   surfxml_call_cb_functions(STag_surfxml_link_cb_list);
 295 }
 296
 297 void ETag_surfxml_link(void)
 298 {
 299   surfxml_call_cb_functions(ETag_surfxml_link_cb_list);
 300 }
 301
 302 void STag_surfxml_route(void)
 303 {
 304   surfxml_call_cb_functions(STag_surfxml_route_cb_list);
 305 }
 306
 307 void ETag_surfxml_route(void)
 308 {
 309   surfxml_call_cb_functions(ETag_surfxml_route_cb_list);
 310 }
 311
 312 void STag_surfxml_link_c_ctn(void)
 313 {
 314   surfxml_call_cb_functions(STag_surfxml_link_c_ctn_cb_list);
 315 }
 316
 317 void ETag_surfxml_link_c_ctn(void)
 318 {
 319   surfxml_call_cb_functions(ETag_surfxml_link_c_ctn_cb_list);
 320 }
 321
 322 void STag_surfxml_process(void)
 323 {
 324   surfxml_call_cb_functions(STag_surfxml_process_cb_list);
 325 }
 326
 327 void ETag_surfxml_process(void)
 328 {
 329   surfxml_call_cb_functions(ETag_surfxml_process_cb_list);
 330 }
 331
 332 void STag_surfxml_argument(void)
 333 {
 334   surfxml_call_cb_functions(STag_surfxml_argument_cb_list);
 335 }
 336
 337 void ETag_surfxml_argument(void)
 338 {
 339   surfxml_call_cb_functions(ETag_surfxml_argument_cb_list);
 340 }
 341
 342 void STag_surfxml_prop(void)
 343 {
 344   surfxml_call_cb_functions(STag_surfxml_prop_cb_list);
 345 }
 346
 347 void ETag_surfxml_prop(void)
 348 {
 349   surfxml_call_cb_functions(ETag_surfxml_prop_cb_list);
 350 }
 351
 352 void STag_surfxml_set(void)
 353 {
 354   surfxml_call_cb_functions(STag_surfxml_set_cb_list);
 355 }
 356
 357 void ETag_surfxml_set(void)
 358 {
 359   surfxml_call_cb_functions(ETag_surfxml_set_cb_list);
 360 }
 361
 362 void STag_surfxml_foreach(void)
 363 {
 364   /* Save the current buffer */
 365   surfxml_bufferstack_push(0);
 366   surfxml_call_cb_functions(STag_surfxml_foreach_cb_list);
 367 }
 368
 369 void ETag_surfxml_foreach(void)
 370 {
 371   surfxml_call_cb_functions(ETag_surfxml_foreach_cb_list);
 372
 373   /* free the temporary dynar and restore original */
 374   xbt_dynar_free(&STag_surfxml_host_cb_list);
 375   xbt_dynar_free(&ETag_surfxml_host_cb_list);
 376
 377   STag_surfxml_host_cb_list = main_STag_surfxml_host_cb_list;
 378   ETag_surfxml_host_cb_list = main_ETag_surfxml_host_cb_list;
 379
 380   /* free the temporary dynar and restore original */
 381   xbt_dynar_free(&STag_surfxml_link_cb_list);
 382   xbt_dynar_free(&ETag_surfxml_link_cb_list);
 383
 384   STag_surfxml_link_cb_list = main_STag_surfxml_link_cb_list;
 385   ETag_surfxml_link_cb_list = main_ETag_surfxml_link_cb_list;
 386
 387 }
 388
 389 void STag_surfxml_route_c_multi(void)
 390 {
 391   surfxml_call_cb_functions(STag_surfxml_route_c_multi_cb_list);
 392 }
 393
 394 void ETag_surfxml_route_c_multi(void)
 395 {
 396   surfxml_call_cb_functions(ETag_surfxml_route_c_multi_cb_list);
 397 }
 398
 399 void STag_surfxml_cluster(void)
 400 {
 401   surfxml_call_cb_functions(STag_surfxml_cluster_cb_list);
 402 }
 403
 404 void ETag_surfxml_cluster(void)
 405 {
 406   surfxml_call_cb_functions(ETag_surfxml_cluster_cb_list);
 407 }
 408
 409 void STag_surfxml_trace(void)
 410 {
 411   surfxml_call_cb_functions(STag_surfxml_trace_cb_list);
 412 }
 413
 414 void ETag_surfxml_trace(void)
 415 {
 416   surfxml_call_cb_functions(ETag_surfxml_trace_cb_list);
 417 }
 418
 419 void STag_surfxml_trace_c_connect(void)
 420 {
 421   surfxml_call_cb_functions(STag_surfxml_trace_c_connect_cb_list);
 422 }
 423
 424 void ETag_surfxml_trace_c_connect(void)
 425 {
 426   surfxml_call_cb_functions(ETag_surfxml_trace_c_connect_cb_list);
 427 }
 428
 429 void STag_surfxml_random(void)
 430 {
 431   surfxml_call_cb_functions(STag_surfxml_random_cb_list);
 432 }
 433
 434 void ETag_surfxml_random(void)
 435 {
 436   surfxml_call_cb_functions(ETag_surfxml_random_cb_list);
 437 }
 438
 439 void surf_parse_open(const char *file)
 440 {
 441   static int warned = 0;        /* warn only once */
 442   if (!file) {
 443     if (!warned) {
 444       WARN0
 445         ("Bypassing the XML parser since surf_parse_open received a NULL pointer. If it is not what you want, go fix your code.");
 446       warned = 1;
 447     }
 448     return;
 449   }
 450   if (!surf_input_buffer_stack)
 451     surf_input_buffer_stack = xbt_dynar_new(sizeof(YY_BUFFER_STATE), NULL);
 452   if (!surf_file_to_parse_stack)
 453     surf_file_to_parse_stack = xbt_dynar_new(sizeof(FILE *), NULL);
 454
 455   surf_file_to_parse = surf_fopen(file, "r");
 456   xbt_assert1((surf_file_to_parse), "Unable to open \"%s\"\n", file);
 457   surf_input_buffer = surf_parse__create_buffer(surf_file_to_parse, 10);
 458   surf_parse__switch_to_buffer(surf_input_buffer);
 459   surf_parse_lineno = 1;
 460 }
 461
 462 void surf_parse_close(void)
 463 {
 464   if (surf_input_buffer_stack)
 465     xbt_dynar_free(&surf_input_buffer_stack);
 466   if (surf_file_to_parse_stack)
 467     xbt_dynar_free(&surf_file_to_parse_stack);
 468
 469   if (surf_file_to_parse) {
 470     surf_parse__delete_buffer(surf_input_buffer);
 471     fclose(surf_file_to_parse);
 472   }
 473 }
 474
 475
 476 static int _surf_parse(void)
 477 {
 478   return surf_parse_lex();
 479 }
 480
 481 int_f_void_t surf_parse = _surf_parse;
 482
 483 void surf_parse_error(char *msg)
 484 {
 485   fprintf(stderr, "Parse error on line %d: %s\n", surf_parse_lineno, msg);
 486   abort();
 487 }
 488
 489
 490 void surf_parse_get_double(double *value, const char *string)
 491 {
 492   int ret = 0;
 493
 494   ret = sscanf(string, "%lg", value);
 495   if (ret != 1)
 496     surf_parse_error(bprintf("%s is not a double", string));
 497 }
 498
 499 void surf_parse_get_int(int *value, const char *string)
 500 {
 501   int ret = 0;
 502
 503   ret = sscanf(string, "%d", value);
 504   if (ret != 1)
 505     surf_parse_error(bprintf("%s is not an integer", string));
 506 }
 507
 508 void parse_properties(void)
 509 {
 510   char *value = NULL;
 511
 512   if (!current_property_set)
 513     current_property_set = xbt_dict_new();
 514
 515   value = xbt_strdup(A_surfxml_prop_value);
 516   xbt_dict_set(current_property_set, A_surfxml_prop_id, value, free);
 517 }
 518
 519 void surfxml_add_callback(xbt_dynar_t cb_list, void_f_void_t function)
 520 {
 521   xbt_dynar_push(cb_list, &function);
 522 }
 523
 524 static XBT_INLINE void surfxml_call_cb_functions(xbt_dynar_t cb_list)
 525 {
 526   unsigned int iterator;
 527   void_f_void_t fun;
 528   xbt_dynar_foreach(cb_list, iterator, fun) {
 529     DEBUG2("call %p %p", fun, *fun);
 530     (*fun) ();
 531   }
 532 }
 533
 534 static void parse_route_set_endpoints(void)
 535 {
 536   route_link_list = xbt_dynar_new(sizeof(char *), NULL);
 537 }
 538
 539 static void init_data(void)
 540 {
 541   xbt_dict_free(&route_table);
 542   xbt_dynar_free(&route_link_list);
 543   route_table = xbt_dict_new();
 544
 545   if (!surfxml_bufferstack_stack)
 546     surfxml_bufferstack_stack = xbt_dynar_new(sizeof(char *), NULL);
 547   route_multi_table = xbt_dict_new();
 548   route_multi_elements = xbt_dynar_new(sizeof(char *), NULL);
 549   traces_set_list = xbt_dict_new();
 550   if (set_list == NULL)
 551     set_list = xbt_dict_new();
 552
 553   trace_connect_list_host_avail = xbt_dict_new();
 554   trace_connect_list_power = xbt_dict_new();
 555   trace_connect_list_link_avail = xbt_dict_new();
 556   trace_connect_list_bandwidth = xbt_dict_new();
 557   trace_connect_list_latency = xbt_dict_new();
 558
 559   random_data_list = xbt_dict_new();
 560   surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties);
 561   surfxml_add_callback(ETag_surfxml_link_c_ctn_cb_list, &parse_route_elem);
 562   surfxml_add_callback(STag_surfxml_route_cb_list,
 563                        &parse_route_set_endpoints);
 564   surfxml_add_callback(STag_surfxml_set_cb_list, &parse_sets);
 565   surfxml_add_callback(STag_surfxml_route_c_multi_cb_list,
 566                        &parse_route_multi_set_endpoints);
 567   surfxml_add_callback(ETag_surfxml_route_c_multi_cb_list,
 568                        &parse_route_multi_set_route);
 569   surfxml_add_callback(STag_surfxml_foreach_cb_list, &parse_foreach);
 570   surfxml_add_callback(STag_surfxml_trace_cb_list, &parse_trace_init);
 571   surfxml_add_callback(ETag_surfxml_trace_cb_list, &parse_trace_finalize);
 572   surfxml_add_callback(STag_surfxml_trace_c_connect_cb_list,
 573                        &parse_trace_c_connect);
 574   surfxml_add_callback(STag_surfxml_random_cb_list, &init_randomness);
 575   surfxml_add_callback(ETag_surfxml_random_cb_list, &add_randomness);
 576 }
 577
 578 static void free_data(void)
 579 {
 580   char *key, *data;
 581   xbt_dict_cursor_t cursor = NULL;
 582   char *name;
 583   unsigned int cpt = 0;
 584
 585   xbt_dict_foreach(route_table, cursor, key, data) {
 586     xbt_dynar_t links = (xbt_dynar_t) data;
 587     char *name;
 588     unsigned int cpt = 0;
 589
 590     xbt_dynar_foreach(links, cpt, name) free(name);
 591     xbt_dynar_free(&links);
 592   }
 593   xbt_dict_free(&route_table);
 594   route_link_list = NULL;
 595
 596   xbt_dict_free(&route_multi_table);
 597
 598   xbt_dynar_foreach(route_multi_elements, cpt, name) free(name);
 599   xbt_dynar_free(&route_multi_elements);
 600
 601   xbt_dict_foreach(set_list, cursor, key, data) {
 602     xbt_dynar_t set = (xbt_dynar_t) data;
 603
 604     xbt_dynar_foreach(set, cpt, name) free(name);
 605     xbt_dynar_free(&set);
 606   }
 607   xbt_dict_free(&set_list);
 608
 609   xbt_dynar_free(&surfxml_bufferstack_stack);
 610
 611   xbt_dict_free(&traces_set_list);
 612   xbt_dict_free(&trace_connect_list_host_avail);
 613   xbt_dict_free(&trace_connect_list_power);
 614   xbt_dict_free(&trace_connect_list_link_avail);
 615   xbt_dict_free(&trace_connect_list_bandwidth);
 616   xbt_dict_free(&trace_connect_list_latency);
 617   xbt_dict_free(&traces_set_list);
 618 }
 619
 620 void parse_platform_file(const char *file)
 621 {
 622   surf_parse_open(file);
 623   init_data();
 624   xbt_assert1((!(*surf_parse) ()), "Parse error in %s", file);
 625   free_data();
 626   surf_parse_close();
 627 }
 628
 629 /* Functions to bypass route, host and link tags. Used by the foreach and route:multi tags */
 630
 631 static void parse_make_temporary_route(const char *src, const char *dst,
 632                                        int action)
 633 {
 634   int AX_ptr = 0;
 635
 636   A_surfxml_route_action = action;
 637   SURFXML_BUFFER_SET(route_src, src);
 638   SURFXML_BUFFER_SET(route_dst, dst);
 639 }
 640
 641 static void parse_change_cpu_data(const char *hostName,
 642                                   const char *surfxml_host_power,
 643                                   const char *surfxml_host_availability,
 644                                   const char *surfxml_host_availability_file,
 645                                   const char *surfxml_host_state_file)
 646 {
 647   int AX_ptr = 0;
 648
 649   SURFXML_BUFFER_SET(host_id, hostName);
 650   SURFXML_BUFFER_SET(host_power, surfxml_host_power /*hostPower */ );
 651   SURFXML_BUFFER_SET(host_availability, surfxml_host_availability);
 652   SURFXML_BUFFER_SET(host_availability_file, surfxml_host_availability_file);
 653   SURFXML_BUFFER_SET(host_state_file, surfxml_host_state_file);
 654 }
 655
 656 static void parse_change_link_data(const char *linkName,
 657                                    const char *surfxml_link_bandwidth,
 658                                    const char *surfxml_link_bandwidth_file,
 659                                    const char *surfxml_link_latency,
 660                                    const char *surfxml_link_latency_file,
 661                                    const char *surfxml_link_state_file)
 662 {
 663   int AX_ptr = 0;
 664
 665   SURFXML_BUFFER_SET(link_id, linkName);
 666   SURFXML_BUFFER_SET(link_bandwidth, surfxml_link_bandwidth);
 667   SURFXML_BUFFER_SET(link_bandwidth_file, surfxml_link_bandwidth_file);
 668   SURFXML_BUFFER_SET(link_latency, surfxml_link_latency);
 669   SURFXML_BUFFER_SET(link_latency_file, surfxml_link_latency_file);
 670   SURFXML_BUFFER_SET(link_state_file, surfxml_link_state_file);
 671 }
 672
 673 /* Functions for the sets and foreach tags */
 674
 675 static void parse_sets(void)
 676 {
 677   char *id, *suffix, *prefix, *radical;
 678   int start, end;
 679   xbt_dynar_t radical_elements;
 680   xbt_dynar_t radical_ends;
 681   xbt_dynar_t current_set;
 682   char *value, *groups;
 683   int i;
 684   unsigned int iter;
 685
 686   id = xbt_strdup(A_surfxml_set_id);
 687   prefix = xbt_strdup(A_surfxml_set_prefix);
 688   suffix = xbt_strdup(A_surfxml_set_suffix);
 689   radical = xbt_strdup(A_surfxml_set_radical);
 690
 691   if (xbt_dict_get_or_null(set_list, id))
 692     surf_parse_error(bprintf
 693                      ("Set '%s' declared several times in the platform file.",
 694                       id));
 695
 696   current_set = xbt_dynar_new(sizeof(char *), NULL);
 697
 698   radical_elements = xbt_str_split(radical, ",");
 699   xbt_dynar_foreach(radical_elements, iter, groups) {
 700
 701     radical_ends = xbt_str_split(groups, "-");
 702     switch (xbt_dynar_length(radical_ends)) {
 703     case 1:
 704       surf_parse_get_int(&start, xbt_dynar_get_as(radical_ends, 0, char *));
 705       value = bprintf("%s%d%s", prefix, start, suffix);
 706       xbt_dynar_push(current_set, &value);
 707       break;
 708
 709     case 2:
 710
 711       surf_parse_get_int(&start, xbt_dynar_get_as(radical_ends, 0, char *));
 712       surf_parse_get_int(&end, xbt_dynar_get_as(radical_ends, 1, char *));
 713
 714
 715       for (i = start; i <= end; i++) {
 716         value = bprintf("%s%d%s", prefix, i, suffix);
 717         xbt_dynar_push(current_set, &value);
 718       }
 719       break;
 720
 721     default:
 722       surf_parse_error(xbt_strdup("Malformed radical"));
 723     }
 724
 725     xbt_dynar_free(&radical_ends);
 726   }
 727
 728   xbt_dict_set(set_list, id, current_set, NULL);
 729
 730   xbt_dynar_free(&radical_elements);
 731   free(radical);
 732   free(suffix);
 733   free(prefix);
 734   free(id);
 735 }
 736
 737 static const char *surfxml_host_power;
 738 static const char *surfxml_host_availability;
 739 static const char *surfxml_host_availability_file;
 740 static const char *surfxml_host_state_file;
 741
 742 static void parse_host_foreach(void)
 743 {
 744   surfxml_host_power = A_surfxml_host_power;
 745   surfxml_host_availability = A_surfxml_host_availability;
 746   surfxml_host_availability_file = A_surfxml_host_availability_file;
 747   surfxml_host_state_file = A_surfxml_host_state_file;
 748 }
 749
 750 static void finalize_host_foreach(void)
 751 {
 752   xbt_dynar_t names = NULL;
 753   unsigned int cpt = 0;
 754   char *name;
 755   xbt_dict_cursor_t cursor = NULL;
 756   char *key, *data;
 757
 758   xbt_dict_t cluster_host_props = current_property_set;
 759
 760   names = xbt_dict_get_or_null(set_list, foreach_set_name);
 761   if (!names)
 762     surf_parse_error(bprintf("Set name '%s' used in <foreach> not found.",
 763                              foreach_set_name));
 764   if (strcmp(A_surfxml_host_id, "$1"))
 765     surf_parse_error(bprintf
 766                      ("The host id within <foreach> should point to the foreach set_id (use $1 instead of %s)",
 767                       A_surfxml_host_id));
 768
 769
 770   /* foreach name in set call the main host callback */
 771   xbt_dynar_foreach(names, cpt, name) {
 772     surfxml_bufferstack_push(1);
 773     parse_change_cpu_data(name, surfxml_host_power, surfxml_host_availability,
 774                           surfxml_host_availability_file,
 775                           surfxml_host_state_file);
 776     surfxml_call_cb_functions(main_STag_surfxml_host_cb_list);
 777
 778     xbt_dict_foreach(cluster_host_props, cursor, key, data) {
 779       xbt_dict_set(current_property_set, xbt_strdup(key), xbt_strdup(data),
 780                    free);
 781     }
 782
 783     surfxml_call_cb_functions(main_ETag_surfxml_host_cb_list);
 784     surfxml_bufferstack_pop(1);
 785   }
 786
 787   current_property_set = xbt_dict_new();
 788
 789   surfxml_bufferstack_pop(0);
 790 }
 791
 792 static const char *surfxml_link_bandwidth;
 793 static const char *surfxml_link_bandwidth_file;
 794 static const char *surfxml_link_latency;
 795 static const char *surfxml_link_latency_file;
 796 static const char *surfxml_link_state_file;
 797
 798 static void parse_link_foreach(void)
 799 {
 800   surfxml_link_bandwidth = A_surfxml_link_bandwidth;
 801   surfxml_link_bandwidth_file = A_surfxml_link_bandwidth_file;
 802   surfxml_link_latency = A_surfxml_link_latency;
 803   surfxml_link_latency_file = A_surfxml_link_latency_file;
 804   surfxml_link_state_file = A_surfxml_link_state_file;
 805 }
 806
 807 static void finalize_link_foreach(void)
 808 {
 809   xbt_dynar_t names = NULL;
 810   unsigned int cpt = 0;
 811   char *name;
 812   xbt_dict_cursor_t cursor = NULL;
 813   char *key, *data;
 814
 815   xbt_dict_t cluster_link_props = current_property_set;
 816
 817   names = xbt_dict_get_or_null(set_list, foreach_set_name);
 818   if (!names)
 819     surf_parse_error(bprintf("Set name '%s' used in <foreach> not found.",
 820                              foreach_set_name));
 821   if (strcmp(A_surfxml_link_id, "$1"))
 822     surf_parse_error(bprintf
 823                      ("The host id within <foreach> should point to the foreach set_id (use $1 instead of %s)",
 824                       A_surfxml_link_id));
 825
 826   /* for each name in set call the main link callback */
 827   xbt_dynar_foreach(names, cpt, name) {
 828     surfxml_bufferstack_push(1);
 829     parse_change_link_data(name, surfxml_link_bandwidth,
 830                            surfxml_link_bandwidth_file, surfxml_link_latency,
 831                            surfxml_link_latency_file,
 832                            surfxml_link_state_file);
 833     surfxml_call_cb_functions(main_STag_surfxml_link_cb_list);
 834
 835     xbt_dict_foreach(cluster_link_props, cursor, key, data) {
 836       xbt_dict_set(current_property_set, xbt_strdup(key), xbt_strdup(data),
 837                    free);
 838     }
 839
 840     surfxml_call_cb_functions(main_ETag_surfxml_link_cb_list);
 841     surfxml_bufferstack_pop(1);
 842   }
 843
 844   current_property_set = xbt_dict_new();
 845
 846   surfxml_bufferstack_pop(0);
 847   free(foreach_set_name);
 848   foreach_set_name = NULL;
 849 }
 850
 851 static void parse_foreach(void)
 852 {
 853   /* save the host & link callbacks */
 854   main_STag_surfxml_host_cb_list = STag_surfxml_host_cb_list;
 855   main_ETag_surfxml_host_cb_list = ETag_surfxml_host_cb_list;
 856   main_STag_surfxml_link_cb_list = STag_surfxml_link_cb_list;
 857   main_ETag_surfxml_link_cb_list = ETag_surfxml_link_cb_list;
 858
 859   /* define host & link callbacks to be used only by the foreach tag */
 860   STag_surfxml_host_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 861   ETag_surfxml_host_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 862   STag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 863   ETag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 864
 865   surfxml_add_callback(STag_surfxml_host_cb_list, &parse_host_foreach);
 866   surfxml_add_callback(ETag_surfxml_host_cb_list, &finalize_host_foreach);
 867   surfxml_add_callback(STag_surfxml_link_cb_list, &parse_link_foreach);
 868   surfxml_add_callback(ETag_surfxml_link_cb_list, &finalize_link_foreach);
 869
 870   /* get set name */
 871   foreach_set_name = xbt_strdup(A_surfxml_foreach_set_id);
 872 }
 873
 874 /* Route:multi functions */
 875
 876 static int route_multi_size = 0;
 877 static char *src_name, *dst_name;
 878 static int is_symmetric_route;
 879
 880 static void parse_route_elem(void)
 881 {
 882   char *val;
 883
 884   val = xbt_strdup(A_surfxml_link_c_ctn_id);
 885
 886   xbt_dynar_push(route_link_list, &val);
 887 }
 888
 889 static void parse_route_multi_set_endpoints(void)
 890 {
 891   src_name = xbt_strdup(A_surfxml_route_c_multi_src);
 892   dst_name = xbt_strdup(A_surfxml_route_c_multi_dst);
 893   route_action = A_surfxml_route_c_multi_action;
 894   is_symmetric_route = A_surfxml_route_c_multi_symmetric;
 895   route_multi_size++;
 896
 897   route_link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 898 }
 899
 900 static int contains(xbt_dynar_t list, const char *value)
 901 {
 902   unsigned int cpt;
 903   char *val;
 904   xbt_dynar_foreach(list, cpt, val) {
 905     if (strcmp(val, value) == 0)
 906       return 1;
 907   }
 908   return 0;
 909 }
 910
 911 /*
 912    This function is used to append or override the contents of an already existing route in the case a new one with its name is found.
 913    The decision is based upon the value of action specified in the xml route:multi attribute action
 914  */
 915 void manage_route(xbt_dict_t routing_table, const char *route_name,
 916                   int action, int isMultiRoute)
 917 {
 918   unsigned int cpt;
 919   xbt_dynar_t links;
 920   char *value;
 921
 922   /* get already existing list if it exists */
 923   links = xbt_dict_get_or_null(routing_table, route_name);
 924   DEBUG1("ROUTE: %s", route_name);
 925   if (links != NULL) {
 926     switch (action) {
 927     case A_surfxml_route_action_PREPEND:       /* add existing links at the end; route_link_list + links */
 928       xbt_dynar_foreach(links, cpt, value) {
 929         xbt_dynar_push(route_link_list, &value);
 930       }
 931       xbt_dynar_free(&links);
 932       break;
 933     case A_surfxml_route_action_POSTPEND:      /* add existing links in front; links + route_link_list */
 934       xbt_dynar_foreach(route_link_list, cpt, value) {
 935         xbt_dynar_push(links, &value);
 936       }
 937       xbt_dynar_free(&route_link_list);
 938       route_link_list = links;
 939       break;
 940     case A_surfxml_route_action_OVERRIDE:
 941       xbt_dynar_free(&links);
 942       break;
 943     default:
 944       break;
 945     }
 946   }
 947   /* this is the final route; do not add if name is a set; add only if name is in set list */
 948   if (!isMultiRoute) {
 949     xbt_dict_set(routing_table, route_name, route_link_list, NULL);
 950   }
 951 }
 952
 953 static void parse_route_multi_set_route(void)
 954 {
 955   char *route_name;
 956
 957   route_name =
 958     bprintf("%s#%s#%d#%d#%d", src_name, dst_name, route_action,
 959             is_symmetric_route, route_multi_size);
 960
 961   xbt_dynar_push(route_multi_elements, &route_name);
 962
 963   /* Add route */
 964   xbt_dict_set(route_multi_table, route_name, route_link_list, NULL);
 965   /* add symmetric if it is the case */
 966   if (is_symmetric_route == 1) {
 967     char *symmetric_name =
 968       bprintf("%s#%s#%d#%d#%d", dst_name, src_name, route_action,
 969               !is_symmetric_route, route_multi_size);
 970
 971     xbt_dict_set(route_multi_table, symmetric_name, route_link_list, NULL);
 972     xbt_dynar_push(route_multi_elements, &symmetric_name);
 973     is_symmetric_route = 0;
 974   }
 975   free(src_name);
 976   free(dst_name);
 977 }
 978
 979 static void add_multi_links(const char *src, const char *dst,
 980                             xbt_dynar_t links, const char *src_name,
 981                             const char *dst_name)
 982 {
 983   unsigned int cpt;
 984   char *value, *val;
 985
 986   surfxml_bufferstack_push(1);
 987
 988   parse_make_temporary_route(src_name, dst_name, route_action);
 989   surfxml_call_cb_functions(STag_surfxml_route_cb_list);
 990   DEBUG2("\tADDING ROUTE: %s -> %s", src_name, dst_name);
 991   /* Build link list */
 992   xbt_dynar_foreach(links, cpt, value) {
 993     if (strcmp(value, src) == 0)
 994       val = xbt_strdup(src_name);
 995     else if (strcmp(value, dst) == 0)
 996       val = xbt_strdup(dst_name);
 997     else if (strcmp(value, "$dst") == 0)
 998       val = xbt_strdup(dst_name);
 999     else if (strcmp(value, "$src") == 0)
1000       val = xbt_strdup(src_name);
1001     else
1002       val = xbt_strdup(value);
1003     DEBUG1("\t\tELEMENT: %s", val);
1004     xbt_dynar_push(route_link_list, &val);
1005   }
1006   surfxml_call_cb_functions(ETag_surfxml_route_cb_list);
1007   surfxml_bufferstack_pop(1);
1008 }
1009
1010 static void convert_route_multi_to_routes(void)
1011 {
1012   xbt_dict_cursor_t cursor_w;
1013   int symmetric;
1014   unsigned int cpt, cpt2, cursor;
1015   char *src_host_name, *dst_host_name, *key, *src, *dst, *val, *key_w,
1016     *data_w;
1017   const char *sep = "#";
1018   xbt_dict_t set = NULL;
1019   xbt_dynar_t src_names = NULL, dst_names = NULL, links;
1020
1021   if (!route_multi_elements)
1022     return;
1023
1024   if (surf_cpu_model)
1025     set = surf_model_resource_set(surf_cpu_model);
1026   if (surf_workstation_model != NULL &&
1027       surf_model_resource_set(surf_workstation_model) != NULL &&
1028       xbt_dict_length(surf_model_resource_set(surf_workstation_model)) > 0)
1029     set = surf_model_resource_set(surf_workstation_model);
1030
1031
1032   surfxml_bufferstack_push(0);
1033   /* Get all routes in the exact order they were entered in the platform file */
1034   xbt_dynar_foreach(route_multi_elements, cursor, key) {
1035     /* Get links for the route */
1036     links = (xbt_dynar_t) xbt_dict_get_or_null(route_multi_table, key);
1037     keys = xbt_str_split_str(key, sep);
1038     /* Get route ends */
1039     src = xbt_dynar_get_as(keys, 0, char *);
1040     dst = xbt_dynar_get_as(keys, 1, char *);
1041     route_action = atoi(xbt_dynar_get_as(keys, 2, char *));
1042     symmetric = atoi(xbt_dynar_get_as(keys, 3, char *));
1043
1044     /* Create the dynar of src and dst hosts for the new routes */
1045     /* NOTE: src and dst can be either set names or simple host names */
1046     src_names = (xbt_dynar_t) xbt_dict_get_or_null(set_list, src);
1047     dst_names = (xbt_dynar_t) xbt_dict_get_or_null(set_list, dst);
1048     /* Add to dynar even if they are simple names */
1049     if (src_names == NULL) {
1050       src_names = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
1051       val = xbt_strdup(src);
1052       xbt_dynar_push(src_names, &val);
1053       if (strcmp(val, "$*") != 0 && NULL == xbt_dict_get_or_null(set, val))
1054         THROW3(unknown_error, 0,
1055                "(In route:multi (%s -> %s) source %s does not exist (not a set or a host)",
1056                src, dst, src);
1057     }
1058     if (dst_names == NULL) {
1059       dst_names = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
1060       val = xbt_strdup(dst);
1061       if (strcmp(val, "$*") != 0 && NULL == xbt_dict_get_or_null(set, val))
1062         THROW3(unknown_error, 0,
1063                "(In route:multi (%s -> %s) destination %s does not exist (not a set or a host)",
1064                src, dst, dst);
1065       xbt_dynar_push(dst_names, &val);
1066     }
1067
1068     /* Build the routes */
1069     DEBUG2("ADDING MULTI ROUTE: %s -> %s", xbt_dynar_get_as(keys, 0, char *),
1070            xbt_dynar_get_as(keys, 1, char *));
1071     xbt_dynar_foreach(src_names, cpt, src_host_name) {
1072       xbt_dynar_foreach(dst_names, cpt2, dst_host_name) {
1073         /* If dst is $* then set this route to have its dst point to all hosts */
1074         if (strcmp(src_host_name, "$*") != 0
1075             && strcmp(dst_host_name, "$*") == 0) {
1076           xbt_dict_foreach(set, cursor_w, key_w, data_w) {
1077             //int n = xbt_dynar_member(src_names, (char*)key_w);
1078             add_multi_links(src, dst, links, src_host_name, key_w);
1079           }
1080         }
1081         /* If src is $* then set this route to have its dst point to all hosts */
1082         if (strcmp(src_host_name, "$*") == 0
1083             && strcmp(dst_host_name, "$*") != 0) {
1084           xbt_dict_foreach(set, cursor_w, key_w, data_w) {
1085             // if (!symmetric || (symmetric && !contains(dst_names, key_w)))
1086             add_multi_links(src, dst, links, key_w, dst_host_name);
1087           }
1088         }
1089         /* if none of them are equal to $* */
1090         if (strcmp(src_host_name, "$*") != 0
1091             && strcmp(dst_host_name, "$*") != 0) {
1092           add_multi_links(src, dst, links, src_host_name, dst_host_name);
1093         }
1094       }
1095     }
1096     xbt_dynar_free(&keys);
1097   }
1098   surfxml_bufferstack_pop(0);
1099 }
1100
1101
1102 /* Trace management functions */
1103
1104 static double trace_periodicity = -1.0;
1105 static double trace_timestep = -1.0;
1106 static char *trace_file = NULL;
1107 static char *trace_id;
1108
1109 static void parse_trace_init(void)
1110 {
1111   trace_id = strdup(A_surfxml_trace_id);
1112   trace_file = strdup(A_surfxml_trace_file);
1113   surf_parse_get_double(&trace_periodicity, A_surfxml_trace_periodicity);
1114   surf_parse_get_double(&trace_timestep, A_surfxml_trace_timestep);
1115 }
1116
1117 static void parse_trace_finalize(void)
1118 {
1119   tmgr_trace_t trace;
1120   if (!trace_file || strcmp(trace_file, "") != 0) {
1121     trace = tmgr_trace_new(trace_file);
1122   } else {
1123     if (strcmp(surfxml_pcdata, "") == 0)
1124       trace = NULL;
1125     else
1126       trace =
1127         tmgr_trace_new_from_string(trace_id, surfxml_pcdata,
1128                                    trace_periodicity, trace_timestep);
1129   }
1130   xbt_dict_set(traces_set_list, trace_id, (void *) trace, NULL);
1131 }
1132
1133 static void parse_trace_c_connect(void)
1134 {
1135   xbt_assert2(xbt_dict_get_or_null
1136               (traces_set_list, A_surfxml_trace_c_connect_trace),
1137               "Cannot connect trace %s to %s: trace unknown",
1138               A_surfxml_trace_c_connect_trace,
1139               A_surfxml_trace_c_connect_element);
1140
1141   switch (A_surfxml_trace_c_connect_kind) {
1142   case A_surfxml_trace_c_connect_kind_HOST_AVAIL:
1143     xbt_dict_set(trace_connect_list_host_avail,
1144                  A_surfxml_trace_c_connect_trace,
1145                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
1146     break;
1147   case A_surfxml_trace_c_connect_kind_POWER:
1148     xbt_dict_set(trace_connect_list_power, A_surfxml_trace_c_connect_trace,
1149                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
1150     break;
1151   case A_surfxml_trace_c_connect_kind_LINK_AVAIL:
1152     xbt_dict_set(trace_connect_list_link_avail,
1153                  A_surfxml_trace_c_connect_trace,
1154                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
1155     break;
1156   case A_surfxml_trace_c_connect_kind_BANDWIDTH:
1157     xbt_dict_set(trace_connect_list_bandwidth,
1158                  A_surfxml_trace_c_connect_trace,
1159                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
1160     break;
1161   case A_surfxml_trace_c_connect_kind_LATENCY:
1162     xbt_dict_set(trace_connect_list_latency, A_surfxml_trace_c_connect_trace,
1163                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
1164     break;
1165   default:
1166     xbt_die(bprintf("Cannot connect trace %s to %s: kind of trace unknown",
1167                     A_surfxml_trace_c_connect_trace,
1168                     A_surfxml_trace_c_connect_element));
1169   }
1170 }
1171
1172 /* Random tag functions */
1173
1174 double get_cpu_power(const char *power)
1175 {
1176   double power_scale = 0.0;
1177   const char *p, *q;
1178   char *generator;
1179   random_data_t random = NULL;
1180   /* randomness is inserted like this: power="$rand(my_random)" */
1181   if (((p = strstr(power, "$rand(")) != NULL)
1182       && ((q = strstr(power, ")")) != NULL)) {
1183     if (p < q) {
1184       generator = xbt_malloc(q - (p + 6) + 1);
1185       memcpy(generator, p + 6, q - (p + 6));
1186       generator[q - (p + 6)] = '\0';
1187       xbt_assert1((random =
1188                    xbt_dict_get_or_null(random_data_list, generator)),
1189                   "Random generator %s undefined", generator);
1190       power_scale = random_generate(random);
1191     }
1192   } else {
1193     surf_parse_get_double(&power_scale, power);
1194   }
1195   return power_scale;
1196 }
1197
1198 double random_min, random_max, random_mean, random_std_deviation,
1199   random_generator;
1200 char *random_id;
1201
1202 static void init_randomness(void)
1203 {
1204   random_id = A_surfxml_random_id;
1205   surf_parse_get_double(&random_min, A_surfxml_random_min);
1206   surf_parse_get_double(&random_max, A_surfxml_random_max);
1207   surf_parse_get_double(&random_mean, A_surfxml_random_mean);
1208   surf_parse_get_double(&random_std_deviation,
1209                         A_surfxml_random_std_deviation);
1210   random_generator = A_surfxml_random_generator;
1211 }
1212
1213 static void add_randomness(void)
1214 {
1215   /* If needed aditional properties can be added by using the prop tag */
1216   random_data_t random =
1217     random_new(random_generator, 0, random_min, random_max, random_mean,
1218                random_std_deviation);
1219   xbt_dict_set(random_data_list, random_id, (void *) random, NULL);
1220 }