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