Logo AND Algorithmique Numérique Distribuée

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