src/surf/surfxml_parse.c

   1 /* Copyright (c) 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "xbt/misc.h"
   8 #include "xbt/log.h"
   9 #include "xbt/str.h"
  10 #include "xbt/dict.h"
  11 #include "surf/surfxml_parse_private.h"
  12 #include "surf/surf_private.h"
  13
  14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_parse, surf,
  15                                 "Logging specific to the SURF parsing module");
  16 #undef CLEANUP
  17 #include "simgrid_dtd.c"
  18
  19 /* Initialize the parsing globals */
  20 xbt_dict_t traces_set_list = NULL;
  21 xbt_dict_t trace_connect_list_host_avail = NULL;
  22 xbt_dict_t trace_connect_list_power = NULL;
  23 xbt_dict_t trace_connect_list_link_avail = NULL;
  24 xbt_dict_t trace_connect_list_bandwidth = NULL;
  25 xbt_dict_t trace_connect_list_latency = NULL;
  26
  27 /* This buffer is used to store the original buffer before substituting it by out own buffer. Useful for the foreach tag */
  28 static xbt_dynar_t surfxml_bufferstack_stack = NULL;
  29 int surfxml_bufferstack_size = 2048;
  30
  31 static char *old_buff = NULL;
  32 static void surf_parse_error(char *msg);
  33
  34 void surfxml_bufferstack_push(int new)
  35 {
  36   if (!new)
  37     old_buff = surfxml_bufferstack;
  38   else {
  39     xbt_dynar_push(surfxml_bufferstack_stack, &surfxml_bufferstack);
  40     surfxml_bufferstack = xbt_new0(char, surfxml_bufferstack_size);
  41   }
  42 }
  43
  44 void surfxml_bufferstack_pop(int new)
  45 {
  46   if (!new)
  47     surfxml_bufferstack = old_buff;
  48   else {
  49     free(surfxml_bufferstack);
  50     xbt_dynar_pop(surfxml_bufferstack_stack, &surfxml_bufferstack);
  51   }
  52 }
  53
  54 /* make sure these symbols are defined as strong ones in this file so that the linked can resolve them */
  55 xbt_dynar_t STag_surfxml_platform_cb_list = NULL;
  56 xbt_dynar_t ETag_surfxml_platform_cb_list = NULL;
  57 xbt_dynar_t STag_surfxml_host_cb_list = NULL;
  58 xbt_dynar_t ETag_surfxml_host_cb_list = NULL;
  59 xbt_dynar_t STag_surfxml_router_cb_list = NULL;
  60 xbt_dynar_t ETag_surfxml_router_cb_list = NULL;
  61 xbt_dynar_t STag_surfxml_link_cb_list = NULL;
  62 xbt_dynar_t ETag_surfxml_link_cb_list = NULL;
  63 xbt_dynar_t STag_surfxml_route_cb_list = NULL;
  64 xbt_dynar_t ETag_surfxml_route_cb_list = NULL;
  65 xbt_dynar_t STag_surfxml_link_c_ctn_cb_list = NULL;
  66 xbt_dynar_t ETag_surfxml_link_c_ctn_cb_list = NULL;
  67 xbt_dynar_t STag_surfxml_process_cb_list = NULL;
  68 xbt_dynar_t ETag_surfxml_process_cb_list = NULL;
  69 xbt_dynar_t STag_surfxml_argument_cb_list = NULL;
  70 xbt_dynar_t ETag_surfxml_argument_cb_list = NULL;
  71 xbt_dynar_t STag_surfxml_prop_cb_list = NULL;
  72 xbt_dynar_t ETag_surfxml_prop_cb_list = NULL;
  73 xbt_dynar_t STag_surfxml_cluster_cb_list = NULL;
  74 xbt_dynar_t ETag_surfxml_cluster_cb_list = NULL;
  75 xbt_dynar_t STag_surfxml_trace_cb_list = NULL;
  76 xbt_dynar_t ETag_surfxml_trace_cb_list = NULL;
  77 xbt_dynar_t STag_surfxml_trace_c_connect_cb_list = NULL;
  78 xbt_dynar_t ETag_surfxml_trace_c_connect_cb_list = NULL;
  79 xbt_dynar_t STag_surfxml_random_cb_list = NULL;
  80 xbt_dynar_t ETag_surfxml_random_cb_list = NULL;
  81 xbt_dynar_t STag_surfxml_AS_cb_list = NULL;
  82 xbt_dynar_t ETag_surfxml_AS_cb_list = NULL;
  83 xbt_dynar_t STag_surfxml_ASroute_cb_list = NULL;
  84 xbt_dynar_t ETag_surfxml_ASroute_cb_list = NULL;
  85 xbt_dynar_t STag_surfxml_bypassRoute_cb_list = NULL;
  86 xbt_dynar_t ETag_surfxml_bypassRoute_cb_list = NULL;
  87
  88 /* store the current property set for any tag */
  89 xbt_dict_t current_property_set = NULL;
  90 /* dictionary of random generator data */
  91 xbt_dict_t random_data_list = NULL;
  92
  93 static XBT_INLINE void surfxml_call_cb_functions(xbt_dynar_t);
  94
  95 YY_BUFFER_STATE surf_input_buffer;
  96 FILE *surf_file_to_parse = NULL;
  97
  98 static void surf_parse_error(char *msg);
  99
 100 static void parse_Stag_trace(void);
 101 static void parse_Etag_trace(void);
 102 static void parse_Stag_trace_c_connect(void);
 103
 104 static void init_randomness(void);
 105 static void add_randomness(void);
 106
 107 void surf_parse_free_callbacks(void)
 108 {
 109   xbt_dynar_free(&STag_surfxml_platform_cb_list);
 110   xbt_dynar_free(&ETag_surfxml_platform_cb_list);
 111   xbt_dynar_free(&STag_surfxml_host_cb_list);
 112   xbt_dynar_free(&ETag_surfxml_host_cb_list);
 113   xbt_dynar_free(&STag_surfxml_router_cb_list);
 114   xbt_dynar_free(&ETag_surfxml_router_cb_list);
 115   xbt_dynar_free(&STag_surfxml_link_cb_list);
 116   xbt_dynar_free(&ETag_surfxml_link_cb_list);
 117   xbt_dynar_free(&STag_surfxml_route_cb_list);
 118   xbt_dynar_free(&ETag_surfxml_route_cb_list);
 119   xbt_dynar_free(&STag_surfxml_link_c_ctn_cb_list);
 120   xbt_dynar_free(&ETag_surfxml_link_c_ctn_cb_list);
 121   xbt_dynar_free(&STag_surfxml_process_cb_list);
 122   xbt_dynar_free(&ETag_surfxml_process_cb_list);
 123   xbt_dynar_free(&STag_surfxml_argument_cb_list);
 124   xbt_dynar_free(&ETag_surfxml_argument_cb_list);
 125   xbt_dynar_free(&STag_surfxml_prop_cb_list);
 126   xbt_dynar_free(&ETag_surfxml_prop_cb_list);
 127   xbt_dynar_free(&STag_surfxml_trace_cb_list);
 128   xbt_dynar_free(&ETag_surfxml_trace_cb_list);
 129   xbt_dynar_free(&STag_surfxml_trace_c_connect_cb_list);
 130   xbt_dynar_free(&ETag_surfxml_trace_c_connect_cb_list);
 131   xbt_dynar_free(&STag_surfxml_random_cb_list);
 132   xbt_dynar_free(&ETag_surfxml_random_cb_list);
 133   xbt_dynar_free(&STag_surfxml_AS_cb_list);
 134   xbt_dynar_free(&ETag_surfxml_AS_cb_list);
 135   xbt_dynar_free(&STag_surfxml_ASroute_cb_list);
 136   xbt_dynar_free(&ETag_surfxml_ASroute_cb_list);
 137   xbt_dynar_free(&STag_surfxml_bypassRoute_cb_list);
 138   xbt_dynar_free(&ETag_surfxml_bypassRoute_cb_list);
 139   xbt_dynar_free(&STag_surfxml_cluster_cb_list);
 140   xbt_dynar_free(&ETag_surfxml_cluster_cb_list);
 141 }
 142
 143 void surf_parse_reset_parser(void)
 144 {
 145   surf_parse_free_callbacks();
 146   STag_surfxml_platform_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 147   ETag_surfxml_platform_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 148   STag_surfxml_host_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 149   ETag_surfxml_host_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 150   STag_surfxml_router_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 151   ETag_surfxml_router_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 152   STag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 153   ETag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 154   STag_surfxml_route_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 155   ETag_surfxml_route_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 156   STag_surfxml_link_c_ctn_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 157   ETag_surfxml_link_c_ctn_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 158   STag_surfxml_process_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 159   ETag_surfxml_process_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 160   STag_surfxml_argument_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 161   ETag_surfxml_argument_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 162   STag_surfxml_prop_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 163   ETag_surfxml_prop_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 164   STag_surfxml_trace_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 165   ETag_surfxml_trace_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 166   STag_surfxml_trace_c_connect_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 167   ETag_surfxml_trace_c_connect_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 168   STag_surfxml_random_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 169   ETag_surfxml_random_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 170   STag_surfxml_AS_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 171   ETag_surfxml_AS_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 172   STag_surfxml_ASroute_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 173   ETag_surfxml_ASroute_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 174   STag_surfxml_bypassRoute_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 175   ETag_surfxml_bypassRoute_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 176   STag_surfxml_cluster_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 177   ETag_surfxml_cluster_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 178 }
 179
 180 /* Stag and Etag parse functions */
 181
 182 void STag_surfxml_platform(void)
 183 {
 184   double version = 0.0;
 185
 186   sscanf(A_surfxml_platform_version, "%lg", &version);
 187
 188   xbt_assert0((version >= 1.0), "******* BIG FAT WARNING *********\n "
 189               "You're using an ancient XML file. "
 190               "Since SimGrid 3.1, units are Bytes, Flops, and seconds "
 191               "instead of MBytes, MFlops and seconds. "
 192               "A script (surfxml_update.pl) to help you convert your old "
 193               "platform files "
 194               "is available in the contrib/platform_generation directory "
 195               "of the simgrid repository. Please check also out the "
 196               "SURF section of the ChangeLog for the 3.1 version. "
 197               "Last, do not forget to also update your values for "
 198               "the calls to MSG_task_create (if any).");
 199   xbt_assert0((version >= 2.0), "******* BIG FAT WARNING *********\n "
 200               "You're using an old XML file. "
 201               "A script (surfxml_update.pl) to help you convert your old "
 202               "platform files "
 203               "is available in the contrib/platform_generation directory "
 204               "of the simgrid repository.");
 205
 206   surfxml_call_cb_functions(STag_surfxml_platform_cb_list);
 207
 208 }
 209
 210 #define parse_method(type,name) \
 211 void type##Tag_surfxml_##name(void) \
 212 { surfxml_call_cb_functions(type##Tag_surfxml_##name##_cb_list); }
 213
 214                                   parse_method(E,platform);
 215 parse_method(S,host);             parse_method(E,host);
 216 parse_method(S,router);           parse_method(E,router);
 217 parse_method(S,link);             parse_method(E,link);
 218 parse_method(S,route);            parse_method(E,route);
 219 parse_method(S,link_c_ctn);       parse_method(E,link_c_ctn);
 220 parse_method(S,process);          parse_method(E,process);
 221 parse_method(S,argument);         parse_method(E,argument);
 222 parse_method(S,prop);             parse_method(E,prop);
 223 parse_method(S,trace);            parse_method(E,trace);
 224 parse_method(S,trace_c_connect);  parse_method(E,trace_c_connect);
 225 parse_method(S,random);           parse_method(E,random);
 226 parse_method(S,AS);               parse_method(E,AS);
 227 parse_method(S,ASroute);          parse_method(E,ASroute);
 228 parse_method(S,bypassRoute);      parse_method(E,bypassRoute);
 229 parse_method(S,cluster);          parse_method(E,cluster);
 230
 231 /* Open and Close parse file */
 232
 233 void surf_parse_open(const char *file)
 234 {
 235   static int warned = 0;        /* warn only once */
 236   if (!file) {
 237     if (!warned) {
 238       WARN0
 239         ("Bypassing the XML parser since surf_parse_open received a NULL pointer. If it is not what you want, go fix your code.");
 240       warned = 1;
 241     }
 242     return;
 243   }
 244   surf_file_to_parse = surf_fopen(file, "r");
 245   xbt_assert1((surf_file_to_parse), "Unable to open \"%s\"\n", file);
 246   surf_input_buffer = surf_parse__create_buffer(surf_file_to_parse, 10);
 247   surf_parse__switch_to_buffer(surf_input_buffer);
 248   surf_parse_lineno = 1;
 249 }
 250
 251 void surf_parse_close(void)
 252 {
 253   if (surf_file_to_parse) {
 254     surf_parse__delete_buffer(surf_input_buffer);
 255     fclose(surf_file_to_parse);
 256   }
 257 }
 258
 259 /* Parse Function */
 260
 261 static int _surf_parse(void)
 262 {
 263   return surf_parse_lex();
 264 }
 265
 266 int_f_void_t surf_parse = _surf_parse;
 267
 268 void surf_parse_error(char *msg)
 269 {
 270   fprintf(stderr, "Parse error on line %d: %s\n", surf_parse_lineno, msg);
 271   abort();
 272 }
 273
 274 void surf_parse_get_double(double *value, const char *string)
 275 {
 276   int ret = 0;
 277   ret = sscanf(string, "%lg", value);
 278   if (ret != 1)
 279     surf_parse_error(bprintf("%s is not a double", string));
 280 }
 281
 282 void surf_parse_get_int(int *value, const char *string)
 283 {
 284   int ret = 0;
 285   ret = sscanf(string, "%d", value);
 286   if (ret != 1)
 287     surf_parse_error(bprintf("%s is not an integer", string));
 288 }
 289
 290 /* Aux parse functions */
 291
 292 void surfxml_add_callback(xbt_dynar_t cb_list, void_f_void_t function)
 293 {
 294   xbt_dynar_push(cb_list, &function);
 295 }
 296
 297 void surfxml_del_callback(xbt_dynar_t* p_cb_list, void_f_void_t function)
 298 {
 299   xbt_dynar_t new_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
 300   unsigned int it;
 301   void_f_void_t func;
 302   xbt_dynar_foreach(*p_cb_list,it,func) {
 303     if( func != function )
 304       xbt_dynar_push(new_cb_list, &func);
 305   }
 306   xbt_dynar_free(p_cb_list);
 307   *p_cb_list = new_cb_list;
 308 }
 309
 310 static XBT_INLINE void surfxml_call_cb_functions(xbt_dynar_t cb_list)
 311 {
 312   unsigned int iterator;
 313   void_f_void_t fun;
 314   xbt_dynar_foreach(cb_list, iterator, fun) {
 315     (*fun) ();
 316   }
 317 }
 318
 319 /* Init and free parse data */
 320
 321 static void init_data(void)
 322 {
 323   if (!surfxml_bufferstack_stack)
 324     surfxml_bufferstack_stack = xbt_dynar_new(sizeof(char *), NULL);
 325
 326   random_data_list = xbt_dict_new();
 327   traces_set_list = xbt_dict_new();
 328   trace_connect_list_host_avail = xbt_dict_new();
 329   trace_connect_list_power = xbt_dict_new();
 330   trace_connect_list_link_avail = xbt_dict_new();
 331   trace_connect_list_bandwidth = xbt_dict_new();
 332   trace_connect_list_latency = xbt_dict_new();
 333
 334   surfxml_add_callback(STag_surfxml_random_cb_list, &init_randomness);
 335   surfxml_add_callback(ETag_surfxml_random_cb_list, &add_randomness);
 336   surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties);
 337   surfxml_add_callback(STag_surfxml_trace_cb_list, &parse_Stag_trace);
 338   surfxml_add_callback(ETag_surfxml_trace_cb_list, &parse_Etag_trace);
 339   surfxml_add_callback(STag_surfxml_trace_c_connect_cb_list, &parse_Stag_trace_c_connect);
 340 }
 341
 342 static void free_data(void)
 343 {
 344   xbt_dict_free(&trace_connect_list_host_avail);
 345   xbt_dict_free(&trace_connect_list_power);
 346   xbt_dict_free(&trace_connect_list_link_avail);
 347   xbt_dict_free(&trace_connect_list_bandwidth);
 348   xbt_dict_free(&trace_connect_list_latency);
 349   xbt_dict_free(&traces_set_list);
 350   xbt_dict_free(&random_data_list);
 351   xbt_dynar_free(&surfxml_bufferstack_stack);
 352 }
 353
 354 /* Here start parse */
 355
 356 void parse_platform_file(const char *file)
 357 {
 358   int parse_status;
 359   surf_parse_open(file);
 360   init_data();
 361   parse_status = surf_parse();
 362   free_data();
 363   surf_parse_close();
 364   xbt_assert1(!parse_status, "Parse error in %s", file);
 365 }
 366
 367 /* Prop tag functions */
 368
 369 void parse_properties(void)
 370 {
 371   char *value = NULL;
 372   if (!current_property_set)
 373     current_property_set = xbt_dict_new(); // Maybe, it should be make a error
 374   value = xbt_strdup(A_surfxml_prop_value);
 375   xbt_dict_set(current_property_set, A_surfxml_prop_id, value, free);
 376 }
 377
 378 /* Trace management functions */
 379
 380 static double trace_periodicity = -1.0;
 381 static char *trace_file = NULL;
 382 static char *trace_id;
 383
 384 static void parse_Stag_trace(void)
 385 {
 386   trace_id = strdup(A_surfxml_trace_id);
 387   trace_file = strdup(A_surfxml_trace_file);
 388   surf_parse_get_double(&trace_periodicity, A_surfxml_trace_periodicity);
 389 }
 390
 391 static void parse_Etag_trace(void)
 392 {
 393   tmgr_trace_t trace;
 394   if (!trace_file || strcmp(trace_file, "") != 0) {
 395     trace = tmgr_trace_new(trace_file);
 396   } else {
 397     if (strcmp(surfxml_pcdata, "") == 0)
 398       trace = NULL;
 399     else
 400       trace =
 401         tmgr_trace_new_from_string(trace_id, surfxml_pcdata,
 402                                    trace_periodicity);
 403   }
 404   xbt_dict_set(traces_set_list, trace_id, (void *) trace, NULL);
 405 }
 406
 407 static void parse_Stag_trace_c_connect(void)
 408 {
 409   xbt_assert2(xbt_dict_get_or_null
 410               (traces_set_list, A_surfxml_trace_c_connect_trace),
 411               "Cannot connect trace %s to %s: trace unknown",
 412               A_surfxml_trace_c_connect_trace,
 413               A_surfxml_trace_c_connect_element);
 414
 415   switch (A_surfxml_trace_c_connect_kind) {
 416   case A_surfxml_trace_c_connect_kind_HOST_AVAIL:
 417     xbt_dict_set(trace_connect_list_host_avail,
 418                  A_surfxml_trace_c_connect_trace,
 419                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
 420     break;
 421   case A_surfxml_trace_c_connect_kind_POWER:
 422     xbt_dict_set(trace_connect_list_power, A_surfxml_trace_c_connect_trace,
 423                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
 424     break;
 425   case A_surfxml_trace_c_connect_kind_LINK_AVAIL:
 426     xbt_dict_set(trace_connect_list_link_avail,
 427                  A_surfxml_trace_c_connect_trace,
 428                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
 429     break;
 430   case A_surfxml_trace_c_connect_kind_BANDWIDTH:
 431     xbt_dict_set(trace_connect_list_bandwidth,
 432                  A_surfxml_trace_c_connect_trace,
 433                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
 434     break;
 435   case A_surfxml_trace_c_connect_kind_LATENCY:
 436     xbt_dict_set(trace_connect_list_latency, A_surfxml_trace_c_connect_trace,
 437                  xbt_strdup(A_surfxml_trace_c_connect_element), free);
 438     break;
 439   default:
 440     xbt_die(bprintf("Cannot connect trace %s to %s: kind of trace unknown",
 441                     A_surfxml_trace_c_connect_trace,
 442                     A_surfxml_trace_c_connect_element));
 443   }
 444 }
 445
 446 /* Random tag functions */
 447
 448 double get_cpu_power(const char *power)
 449 {
 450   double power_scale = 0.0;
 451   const char *p, *q;
 452   char *generator;
 453   random_data_t random = NULL;
 454   /* randomness is inserted like this: power="$rand(my_random)" */
 455   if (((p = strstr(power, "$rand(")) != NULL)
 456       && ((q = strstr(power, ")")) != NULL)) {
 457     if (p < q) {
 458       generator = xbt_malloc(q - (p + 6) + 1);
 459       memcpy(generator, p + 6, q - (p + 6));
 460       generator[q - (p + 6)] = '\0';
 461       xbt_assert1((random =
 462                    xbt_dict_get_or_null(random_data_list, generator)),
 463                   "Random generator %s undefined", generator);
 464       power_scale = random_generate(random);
 465     }
 466   } else {
 467     surf_parse_get_double(&power_scale, power);
 468   }
 469   return power_scale;
 470 }
 471
 472 double random_min, random_max, random_mean, random_std_deviation, random_generator;
 473 char *random_id;
 474
 475 static void init_randomness(void)
 476 {
 477   random_id = A_surfxml_random_id;
 478   surf_parse_get_double(&random_min, A_surfxml_random_min);
 479   surf_parse_get_double(&random_max, A_surfxml_random_max);
 480   surf_parse_get_double(&random_mean, A_surfxml_random_mean);
 481   surf_parse_get_double(&random_std_deviation, A_surfxml_random_std_deviation);
 482   random_generator = A_surfxml_random_generator;
 483 }
 484
 485 static void add_randomness(void)
 486 {
 487   /* If needed aditional properties can be added by using the prop tag */
 488   random_data_t random = random_new(random_generator, 0, random_min, random_max, random_mean, random_std_deviation);
 489   xbt_dict_set(random_data_list, random_id, (void *) random, &xbt_free_ref);
 490 }
 491
 492 /**
 493  * create CPU resource via CPU Model
 494  */
 495 void surf_host_create_resource(char *name, double power_peak,
 496         double power_scale,
 497         tmgr_trace_t power_trace,
 498         e_surf_resource_state_t state_initial,
 499         tmgr_trace_t state_trace,
 500         xbt_dict_t cpu_properties)
 501 {
 502     return surf_cpu_model->extension.cpu.
 503         create_resource(name,power_peak,power_scale,power_trace,state_initial,state_trace,cpu_properties);
 504 }
 505
 506 /**
 507  * create CPU resource via worsktation_ptask_L07 model
 508  */
 509
 510 void surf_wsL07_host_create_resource(char *name, double power_peak,
 511         double power_scale,
 512         tmgr_trace_t power_trace,
 513         e_surf_resource_state_t state_initial,
 514         tmgr_trace_t state_trace,
 515         xbt_dict_t cpu_properties)
 516 {
 517         surf_workstation_model->extension.workstation.
 518                 cpu_create_resource(name,power_peak,power_scale,power_trace,state_initial,state_trace,cpu_properties);
 519 }
 520 /**
 521  * create link resource via network Model
 522  */
 523 void surf_link_create_resource(char *name,
 524         double bw_initial,
 525         tmgr_trace_t bw_trace,
 526         double lat_initial,
 527         tmgr_trace_t lat_trace,
 528         e_surf_resource_state_t
 529         state_initial,
 530         tmgr_trace_t state_trace,
 531         e_surf_link_sharing_policy_t policy,
 532         xbt_dict_t properties)
 533 {
 534     return surf_network_model->extension.network.
 535         create_resource(name,bw_initial,bw_trace,lat_initial,lat_trace,
 536             state_initial,state_trace,policy,properties);
 537 }
 538
 539 /**
 540  * create link resource via workstation_ptask_L07 model
 541  */
 542
 543 void surf_wsL07_link_create_resource(char *name,
 544         double bw_initial,
 545         tmgr_trace_t bw_trace,
 546         double lat_initial,
 547         tmgr_trace_t lat_trace,
 548         e_surf_resource_state_t
 549         state_initial,
 550         tmgr_trace_t state_trace,
 551         e_surf_link_sharing_policy_t
 552         policy, xbt_dict_t properties)
 553 {
 554     return surf_workstation_model->extension.workstation.
 555     link_create_resource(name,bw_initial,bw_trace,lat_initial,lat_trace,
 556                                                 state_initial,state_trace,policy,properties);
 557 }
 558
 559 /**
 560  * Route: add route element bypassing the parser :
 561  * same job as parse_route_elem
 562  */
 563
 564 void surf_add_route_element(char* link_ctn_id)
 565 {
 566         xbt_die("\"surf_add_route_element\" not support");
 567 //      char *val;
 568 //      val = xbt_strdup(link_ctn_id);
 569 //      xbt_dynar_push(route_link_list,&val);
 570 }
 571 /**
 572  * set route
 573  */
 574 void surf_route_set_resource(char *source_id,char *destination_id,xbt_dynar_t links_id,int action)
 575 {
 576         xbt_die("\"surf_route_set_resource\" not support");
 577         //route_link_list = xbt_dynar_new(sizeof(char *), NULL);
 578         //routing_add_route(source_id,destination_id,links_id,action);
 579
 580 }
 581
 582 /**
 583  * add host to routing host list
 584  */
 585 void surf_route_add_host(char *host_id)
 586 {
 587         xbt_die("\"surf_route_add_host\" not support");
 588         //routing_add_host(host_id);
 589 }
 590
 591 /**
 592  * Add Traces
 593  */
 594 void surf_add_host_traces(void)
 595 {
 596         return surf_cpu_model->extension.cpu.add_traces();
 597 }
 598
 599 void surf_add_link_traces(void)
 600 {
 601         return surf_network_model->extension.network.add_traces();
 602 }
 603
 604 void surf_wsL07_add_traces(void)
 605 {
 606         return surf_workstation_model->extension.workstation.add_traces();
 607 }
 608
 609 /**
 610  * set routes
 611  */
 612 void surf_set_routes(void)
 613 {
 614         xbt_die("\"surf_set_routes\" not support");
 615         //routing_set_routes();
 616 }