Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
eeda51d9f19438865ccf223be7763e5278e7d970
[simgrid.git] / src / bindings / lua / lua_console.c
1 /* SimGrid Lua Console                                                    */
2
3 /* Copyright (c) 2010. The SimGrid Team.
4  * All rights reserved.                                                     */
5
6 /* This program is free software; you can redistribute it and/or modify it
7  * under the terms of the license (GNU LGPL) which comes with this package. */
8
9 #include "simgrid_lua.h"
10 #include <string.h>
11 #include <ctype.h>
12
13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua_console, bindings, "Lua Bindings");
14
15
16 //AS List
17 static xbt_dynar_t as_list_d;
18
19 /*
20  * Initialize platform model routing
21  */
22
23 static void create_AS(const char *id, const char *mode)
24 {
25   surf_AS_new(id, mode);
26 }
27
28 /**
29  * create host resource via CPU model [for MSG]
30  */
31
32 static void create_host(const char *id, double power_peak, double power_sc,
33                         const char *power_tr,int core,int state_init,
34                         const char *state_tr,xbt_dict_t properties)
35 {
36   double power_scale = 1.0;
37   int core_nb = 1; //default value
38   tmgr_trace_t power_trace = NULL;
39   e_surf_resource_state_t state_initial;
40   tmgr_trace_t state_trace;
41   if (power_sc)                 // !=0
42     power_scale = power_sc;
43   if (core)
44           core_nb = core; //default value
45   if (state_init == -1)
46     state_initial = SURF_RESOURCE_OFF;
47   else
48     state_initial = SURF_RESOURCE_ON;
49   if (power_tr)
50     power_trace = tmgr_trace_new(power_tr);
51   else
52     power_trace = tmgr_trace_new("");
53   if (state_tr)
54     state_trace = tmgr_trace_new(state_tr);
55   else
56     state_trace = tmgr_trace_new("");
57
58   surf_host_create_resource(xbt_strdup(id), power_peak, power_scale,
59                             power_trace, core_nb, state_initial, state_trace,
60                             properties);
61 }
62
63 /**
64  * create link resource via network model
65  */
66 static void create_link(const char *name,
67                         double bw_initial, const char *trace,
68                         double lat_initial, const char *latency_trace,
69                         int state_init, const char *state_trace,
70                         int policy)
71 {
72   tmgr_trace_t bw_trace;
73   tmgr_trace_t lat_trace;
74   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
75   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
76   tmgr_trace_t st_trace;
77   if (trace)
78     bw_trace = tmgr_trace_new(trace);
79   else
80     bw_trace = tmgr_trace_new("");
81
82   if (latency_trace)
83     lat_trace = tmgr_trace_new(latency_trace);
84   else
85     lat_trace = tmgr_trace_new("");
86
87   if (state_trace)
88     st_trace = tmgr_trace_new(state_trace);
89   else
90     st_trace = tmgr_trace_new("");
91
92   if (state_init == -1)
93     state_initial_link = SURF_RESOURCE_OFF;
94   if (policy == -1)
95     policy_initial_link = SURF_LINK_FATPIPE;
96
97   surf_link_create_resource(xbt_strdup(name), bw_initial, bw_trace,
98                             lat_initial, lat_trace, state_initial_link,
99                             st_trace, policy_initial_link, xbt_dict_new());
100 }
101
102 /*
103  *create host resource via workstation_ptask_L07 model [for SimDag]
104  */
105 static void create_host_wsL07(const char *id, double power_peak,
106                               double power_sc, const char *power_tr,
107                               int state_init, const char *state_tr)
108 {
109   double power_scale = 1.0;
110   tmgr_trace_t power_trace = NULL;
111   e_surf_resource_state_t state_initial;
112   tmgr_trace_t state_trace;
113   if (power_sc)                 // !=0
114     power_scale = power_sc;
115   if (state_init == -1)
116     state_initial = SURF_RESOURCE_OFF;
117   else
118     state_initial = SURF_RESOURCE_ON;
119   if (power_tr)
120     power_trace = tmgr_trace_new(power_tr);
121   else
122     power_trace = tmgr_trace_new("");
123   if (state_tr)
124     state_trace = tmgr_trace_new(state_tr);
125   else
126     state_trace = tmgr_trace_new("");
127
128   surf_wsL07_host_create_resource(xbt_strdup(id), power_peak, power_scale,
129                                   power_trace, state_initial, state_trace,
130                                   current_property_set);
131   current_property_set = NULL;
132 }
133
134 /**
135  * create link resource via workstation_ptask_L07 model [for SimDag]
136  */
137
138 static void create_link_wsL07(const char *name,
139                               double bw_initial, const char *trace,
140                               double lat_initial,
141                               const char *latency_trace, int state_init,
142                               const char *state_trace, int policy)
143 {
144   tmgr_trace_t bw_trace;
145   tmgr_trace_t lat_trace;
146   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
147   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
148   tmgr_trace_t st_trace;
149   if (trace)
150     bw_trace = tmgr_trace_new(trace);
151   else
152     bw_trace = tmgr_trace_new("");
153
154   if (latency_trace)
155     lat_trace = tmgr_trace_new(latency_trace);
156   else
157     lat_trace = tmgr_trace_new("");
158
159   if (state_trace)
160     st_trace = tmgr_trace_new(state_trace);
161   else
162     st_trace = tmgr_trace_new("");
163
164   if (state_init == -1)
165     state_initial_link = SURF_RESOURCE_OFF;
166   if (policy == -1)
167     policy_initial_link = SURF_LINK_FATPIPE;
168
169   surf_wsL07_link_create_resource(xbt_strdup(name), bw_initial, bw_trace,
170                                   lat_initial, lat_trace,
171                                   state_initial_link, st_trace,
172                                   policy_initial_link, xbt_dict_new());
173 }
174
175
176 /*
177  * Append new AS to the Platform
178  */
179
180 static int AS_new(lua_State * L)
181 {
182
183    if (xbt_dynar_is_empty(as_list_d))
184             as_list_d = xbt_dynar_new(sizeof(p_AS_attr), &xbt_free_ref);
185
186   p_AS_attr AS;
187   const char *id;
188   const char *mode;
189   if (lua_istable(L, 1)) {
190     lua_pushstring(L, "id");
191     lua_gettable(L, -2);
192     id = lua_tostring(L, -1);
193     lua_pop(L, 1);
194
195     lua_pushstring(L, "mode");
196     lua_gettable(L, -2);
197     mode = lua_tostring(L, -1);
198     lua_pop(L, 1);
199   } else {
200     XBT_ERROR
201         ("Bad Arguments to AS.new, Should be a table with named arguments");
202     return -1;
203   }
204   AS = malloc(sizeof(AS_attr));
205   AS->id = id;
206   AS->mode = mode;
207   AS->host_list_d = xbt_dynar_new(sizeof(p_host_attr),&xbt_free_ref);
208   AS->link_list_d = xbt_dynar_new(sizeof(p_link_attr),&xbt_free_ref);
209   AS->route_list_d = xbt_dynar_new(sizeof(p_route_attr),&xbt_free_ref);
210   AS->router_list_d = xbt_dynar_new(sizeof(p_router_attr),&xbt_free_ref);
211   AS->sub_as_list_id = xbt_dynar_new(sizeof(p_AS_attr),&xbt_free_ref);
212   xbt_dynar_push(as_list_d, &AS);
213
214   return 0;
215 }
216
217 /**
218  * add sub AS to the Parent AS
219  */
220 static int AS_add(lua_State *L)
221 {
222         unsigned int i;
223         p_AS_attr AS;
224         p_AS_attr super_as,p_as;
225         const char *super_AS_id;
226         const char *sub_AS_id = NULL;
227         const char *sub_AS_routing= NULL;
228         if(lua_istable(L, -1))
229         {
230                 lua_pushstring(L, "AS");
231                 lua_gettable(L, -2);
232                 super_AS_id = lua_tostring(L, -1);
233                 lua_pop(L,1);
234
235                 lua_pushstring(L, "id");
236                 lua_gettable(L, -2);
237                 sub_AS_id = lua_tostring(L, -1);
238                 lua_pop(L,1);
239
240         }
241
242         xbt_dynar_foreach(as_list_d, i, p_as){
243                   if (p_as->id == super_AS_id){
244                           super_as = p_as;
245                           break;
246                   }
247         }
248         AS = malloc(sizeof(AS_attr));
249         AS->id = sub_AS_id;
250         AS->mode = sub_AS_routing;
251         AS->host_list_d = xbt_dynar_new(sizeof(p_host_attr),&xbt_free_ref);
252         AS->link_list_d = xbt_dynar_new(sizeof(p_link_attr),&xbt_free_ref);
253         AS->route_list_d = xbt_dynar_new(sizeof(p_route_attr),&xbt_free_ref);
254         AS->sub_as_list_id = xbt_dynar_new(sizeof(p_AS_attr),&xbt_free_ref);
255         xbt_dynar_push(super_as->sub_as_list_id, &AS);
256
257         return 0;
258 }
259
260
261 /*
262  * add new host to platform hosts list
263  */
264 static int Host_new(lua_State * L)
265 {
266   p_host_attr host;
267   unsigned int i;
268   p_AS_attr p_as,current_as = NULL;
269   const char *AS_id;
270   const char *id;
271   const char *power_trace;
272   const char *state_trace;
273   double power, power_scale;
274   int state_initial,core;
275   //get values from the table passed as argument
276   if (lua_istable(L, -1)) {
277         // get AS id
278         lua_pushstring(L, "AS");
279         lua_gettable(L, -2);
280         AS_id = lua_tostring(L, -1);
281         lua_pop(L,1);
282
283     // get Id Value
284     lua_pushstring(L, "id");
285     lua_gettable(L, -2);
286     id = lua_tostring(L, -1);
287     lua_pop(L, 1);
288
289     // get power value
290     lua_pushstring(L, "power");
291     lua_gettable(L, -2);
292     power = lua_tonumber(L, -1);
293     lua_pop(L, 1);
294
295     //get power_scale
296     lua_pushstring(L, "power_scale");
297     lua_gettable(L, -2);
298     power_scale = lua_tonumber(L, -1);
299     lua_pop(L, 1);
300
301     //get power_trace
302     lua_pushstring(L, "power_trace");
303     lua_gettable(L, -2);
304     power_trace = lua_tostring(L, -1);
305     lua_pop(L, 1);
306
307     lua_pushstring(L, "core");
308     lua_gettable(L, -2);
309     core = lua_tonumber(L, -1);
310     lua_pop(L, 1);
311
312     //get state initial
313     lua_pushstring(L, "state_initial");
314     lua_gettable(L, -2);
315     state_initial = lua_tonumber(L, -1);
316     lua_pop(L, 1);
317
318     //get trace state
319     lua_pushstring(L, "state_trace");
320     lua_gettable(L, -2);
321     state_trace = lua_tostring(L, -1);
322     lua_pop(L, 1);
323
324   } else {
325     XBT_ERROR
326         ("Bad Arguments to create host, Should be a table with named arguments");
327     return -1;
328   }
329   xbt_dynar_foreach(as_list_d, i, p_as){
330           if (p_as->id == AS_id){
331                   current_as = p_as;
332                   break;
333           }
334   }
335
336   if (!current_as)
337   {
338           XBT_ERROR("No AS_id :%s found",AS_id);
339           return -2;
340   }
341
342   host = malloc(sizeof(host_attr));
343   host->id = id;
344   host->power_peak = power;
345   host->power_scale = power_scale;
346   host->power_trace = power_trace;
347   host->core = core;
348   host->state_initial = state_initial;
349   host->state_trace = state_trace;
350   host->function = NULL;
351   host->properties = xbt_dict_new();
352   xbt_dynar_push(current_as->host_list_d, &host);
353
354   return 0;
355 }
356
357 /**
358  * add link to AS links list
359  */
360 static int Link_new(lua_State * L)      // (id,bandwidth,latency)
361 {
362   const char *AS_id;
363   unsigned int i;
364   p_AS_attr p_as,current_as = NULL;
365   const char* id;
366   double bandwidth, latency;
367   const char *bandwidth_trace;
368   const char *latency_trace;
369   const char *state_trace;
370   int state_initial, policy;
371
372   //get values from the table passed as argument
373   if (lua_istable(L, -1)) {
374
375         //get AS id
376         lua_pushstring(L, "AS");
377         lua_gettable(L, -2);
378         AS_id = lua_tostring(L, -1);
379         lua_pop(L, 1);
380
381     // get Id Value
382     lua_pushstring(L, "id");
383     lua_gettable(L, -2);
384     id = lua_tostring(L, -1);
385     lua_pop(L, 1);
386
387     // get bandwidth value
388     lua_pushstring(L, "bandwidth");
389     lua_gettable(L, -2);
390     bandwidth = lua_tonumber(L, -1);
391     lua_pop(L, 1);
392
393     //get latency value
394     lua_pushstring(L, "latency");
395     lua_gettable(L, -2);
396     latency = lua_tonumber(L, -1);
397     lua_pop(L, 1);
398
399     /*Optional Arguments  */
400
401     //get bandwidth_trace value
402     lua_pushstring(L, "bandwidth_trace");
403     lua_gettable(L, -2);
404     bandwidth_trace = lua_tostring(L, -1);
405     lua_pop(L, 1);
406
407     //get latency_trace value
408     lua_pushstring(L, "latency_trace");
409     lua_gettable(L, -2);
410     latency_trace = lua_tostring(L, -1);
411     lua_pop(L, 1);
412
413     //get state_trace value
414     lua_pushstring(L, "state_trace");
415     lua_gettable(L, -2);
416     state_trace = lua_tostring(L, -1);
417     lua_pop(L, 1);
418
419     //get state_initial value
420     lua_pushstring(L, "state_initial");
421     lua_gettable(L, -2);
422     state_initial = lua_tonumber(L, -1);
423     lua_pop(L, 1);
424
425     //get policy value
426     lua_pushstring(L, "policy");
427     lua_gettable(L, -2);
428     policy = lua_tonumber(L, -1);
429     lua_pop(L, 1);
430
431   } else {
432     XBT_ERROR
433         ("Bad Arguments to create link, Should be a table with named arguments");
434     return -1;
435   }
436   xbt_dynar_foreach(as_list_d, i, p_as){
437           if (p_as->id == AS_id){
438                   current_as = p_as;
439                   break;
440           }
441   }
442
443   if (!current_as)
444   {
445           XBT_ERROR("No AS_id :%s found",AS_id);
446           return -2;
447   }
448   p_link_attr link = malloc(sizeof(link_attr));
449   link->id = id;
450   link->bandwidth = bandwidth;
451   link->latency = latency;
452   link->bandwidth_trace = bandwidth_trace;
453   link->latency_trace = latency_trace;
454   link->state_trace = state_trace;
455   link->state_initial = state_initial;
456   link->policy = policy;
457   xbt_dynar_push(current_as->link_list_d, &link);
458
459   return 0;
460 }
461
462 /**
463  * add route to AS routes list
464  */
465 static int Route_new(lua_State * L)     // (src_id,dest_id,links_number,link_table)
466 {
467   const char* AS_id;
468   unsigned int i;
469   p_AS_attr p_as,current_as = NULL;
470   const char *links;
471   const char* link_id;
472   p_route_attr route = malloc(sizeof(route_attr));
473
474
475   if (!lua_istable(L, 4)) { // if Route.new is declared as an indexed table (FIXME : we check the third arg if it's not a table)
476
477          //get AS_id
478          lua_pushstring(L, "AS");
479          lua_gettable(L, -2);
480          AS_id = lua_tostring(L, -1);
481          lua_pop(L, 1);
482
483          xbt_dynar_foreach(as_list_d, i, p_as){
484           if (p_as->id == AS_id){
485                   current_as = p_as;
486                   break;
487           }
488          }
489
490          if (!current_as)
491          {
492           XBT_ERROR("addRoute: No AS_id :%s found",AS_id);
493           return -2;
494          }
495          // get Source Value
496      lua_pushstring(L, "src");
497      lua_gettable(L, -2);
498      route->src_id = lua_tostring(L, -1);
499      lua_pop(L, 1);
500
501      // get Destination Value
502      lua_pushstring(L, "dest");
503      lua_gettable(L, -2);
504      route->dest_id = lua_tostring(L, -1);
505      lua_pop(L, 1);
506
507      // get Links Table (char* to be splited later)
508      lua_pushstring(L, "links");
509      lua_gettable(L, -2);
510      links = lua_tostring(L, -1);
511      lua_pop(L,1);
512
513      route->links_id = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
514
515      char *tmp_links = xbt_strdup(links);
516      link_id = strtok(tmp_links,",");   //tmp_link = strtok((char*)links,",");
517      while(link_id != NULL)
518        {
519           xbt_dynar_push(route->links_id, &link_id);
520           link_id = strtok(NULL,","); //Alternatively, a null pointer may be specified, in which case the function continues scanning where a previous successful call to the function ended.
521         }
522      xbt_dynar_push(current_as->route_list_d, &route);
523      return 0;
524       }
525   else { // Route.new is declared as a function
526          AS_id = luaL_checkstring(L, 1);
527          xbt_dynar_foreach(as_list_d, i, p_as){
528                   if (p_as->id == AS_id){
529                           current_as = p_as;
530                           break;
531                   }
532                  }
533
534          if (!current_as)
535          {
536                 XBT_ERROR("addRoute: No AS_id :%s found",AS_id);
537                 return -2;
538          }
539      route->src_id = luaL_checkstring(L, 2);
540      route->dest_id = luaL_checkstring(L, 3);
541      route->links_id = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
542      lua_pushnil(L);
543      while (lua_next(L, 4) != 0)
544                 {
545          link_id = lua_tostring(L, -1);
546          xbt_dynar_push(route->links_id, &link_id);
547          XBT_DEBUG("index = %f , Link_id = %s \n", lua_tonumber(L, -2),
548          lua_tostring(L, -1));
549          lua_pop(L, 1);
550         }
551     lua_pop(L, 1);
552     //add route to platform's route list
553     xbt_dynar_push(current_as->route_list_d, &route);
554     return 0;
555     }
556
557   return -1;
558 }
559 /**
560  * add Router to AS components
561  */
562 static int Router_new(lua_State* L)
563 {
564         p_router_attr router;
565         const char* AS_id;
566         unsigned int i;
567         p_AS_attr p_as,current_as = NULL;
568         const char* id;
569         if (lua_istable(L, -1)) {
570                 // get AS id
571                 lua_pushstring(L, "AS");
572                 lua_gettable(L, -2);
573                 AS_id = lua_tostring(L, -1);
574                 lua_pop(L,1);
575
576                 lua_pushstring(L, "id");
577                 lua_gettable(L, -2);
578                 id = lua_tostring(L, -1);
579                 lua_pop(L,1);
580         }
581         xbt_dynar_foreach(as_list_d, i, p_as){
582                   if (p_as->id == AS_id){
583                           current_as = p_as;
584                           break;
585                   }
586           }
587
588           if (!current_as)
589           {
590                   XBT_ERROR("No AS_id :%s found",AS_id);
591                   return -2;
592           }
593         router = malloc(sizeof(router_attr));
594         router->id = id;
595         xbt_dynar_push(current_as->router_list_d, &router);
596         return 0;
597
598 }
599
600 /**
601  * set function to process
602  */
603 static int Host_set_function(lua_State * L)     //(host,function,nb_args,list_args)
604 {
605         p_AS_attr p_as;
606         p_host_attr p_host;
607         unsigned int i,j;
608         const char *host_id ;
609         const char *function_id;
610         const char *args;
611         char * tmp_arg;
612
613    if (lua_istable(L, -1)) {
614          // get Host id
615          lua_pushstring(L, "host");
616          lua_gettable(L, -2);
617          host_id = lua_tostring(L, -1);
618          lua_pop(L, 1);
619          // get Function Name
620          lua_pushstring(L, "fct");
621          lua_gettable(L, -2);
622      function_id = lua_tostring(L, -1);
623      lua_pop(L, 1);
624      //get args
625      lua_pushstring(L,"args");
626      lua_gettable(L, -2);
627      args = lua_tostring(L,-1);
628      lua_pop(L, 1);
629    }
630    else {
631            XBT_ERROR("Bad Arguments to create link, Should be a table with named arguments");
632            return -1;
633    }
634
635   // look for the index of host in host_list for each AS
636    xbt_dynar_foreach(as_list_d, i, p_as)
637    {
638            xbt_dynar_foreach(p_as->host_list_d, j, p_host) {
639                    if (p_host->id == host_id) {
640                            p_host->function = function_id;
641                            p_host->args_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
642                            // split & fill the args list
643                            tmp_arg = strtok((char*)args,",");
644                            while (tmp_arg != NULL) {
645                                    xbt_dynar_push(p_host->args_list, &tmp_arg);
646                                    tmp_arg = strtok(NULL,",");
647                            }
648                            return 0;
649                    }
650         }
651    }
652           XBT_ERROR("Host : %s Not Found !!", host_id);
653           return 1;
654
655 }
656
657 static int Host_set_property(lua_State* L)
658 {
659         p_AS_attr p_as;
660         p_host_attr p_host;
661         unsigned int i,j;
662         const char* host_id ="";
663         const char* prop_id = "";
664         const char* prop_value = "";
665         if (lua_istable(L, -1)) {
666                  // get Host id
667                  lua_pushstring(L, "host");
668                  lua_gettable(L, -2);
669                  host_id = lua_tostring(L, -1);
670                  lua_pop(L, 1);
671                  // get Function Name
672                  lua_pushstring(L, "prop_id");
673                  lua_gettable(L, -2);
674              prop_id = lua_tostring(L, -1);
675              lua_pop(L, 1);
676              //get args
677              lua_pushstring(L,"prop_value");
678              lua_gettable(L, -2);
679              prop_value = lua_tostring(L,-1);
680              lua_pop(L, 1);
681          }
682         xbt_dynar_foreach(as_list_d, i, p_as)
683            {
684                    xbt_dynar_foreach(p_as->host_list_d, j, p_host) {
685                            if (p_host->id == host_id) {
686                                    xbt_dict_set(p_host->properties, prop_id, xbt_strdup(prop_value), free);
687                            }
688                    }
689       }
690         return 1;
691
692 }
693 /*
694  * surf parse bypass platform
695  * through CPU/network Models
696  */
697
698 static int surf_parse_bypass_platform()
699 {
700   unsigned int i,j;
701   p_AS_attr p_as;
702   p_host_attr p_host;
703   p_link_attr p_link;
704   p_route_attr p_route;
705
706
707   // Add AS
708   xbt_dynar_foreach(as_list_d, i,p_as)
709   {
710           create_AS(p_as->id, p_as->mode);
711           // add associated Hosts
712           xbt_dynar_foreach(p_as->host_list_d, j, p_host){
713                   create_host(p_host->id, p_host->power_peak, p_host->power_scale,
714                                   p_host->power_trace, p_host->core, p_host->state_initial,
715                                   p_host->state_trace, p_host->properties);
716
717
718                    //add to routing model host list
719                    surf_route_add_host((char *) p_host->id);
720           }
721           // add associated Links
722           xbt_dynar_foreach(p_as->link_list_d, j, p_link){
723                   create_link(p_link->id, p_link->bandwidth, p_link->bandwidth_trace,
724                                   p_link->latency, p_link->latency_trace,
725                                   p_link->state_initial, p_link->state_trace,
726                                   p_link->policy);
727           }
728           // add associated Routes
729           xbt_dynar_foreach(p_as->route_list_d, j, p_route){
730                   surf_routing_add_route((char *) p_route->src_id,
731                                              (char *) p_route->dest_id, p_route->links_id);
732           }
733
734           // Finalize AS
735           surf_AS_finalize(p_as->id);
736   }
737
738   // add traces
739   surf_add_host_traces();
740   surf_add_link_traces();
741
742   return 0;                     // must return 0 ?!!
743
744 }
745
746 /**
747  *
748  * surf parse bypass platform
749  * through workstation_ptask_L07 Model
750  */
751
752 static int surf_wsL07_parse_bypass_platform()
753 {
754   unsigned int i,j;
755   p_AS_attr p_as, p_sub_as;
756   p_host_attr p_host;
757   p_link_attr p_link;
758   p_route_attr p_route;
759
760   xbt_dynar_foreach(as_list_d, i, p_as)
761   {
762           // Init AS
763           create_AS(p_as->id, p_as->mode);
764
765           // add Sub AS
766
767           // Add Hosts
768           xbt_dynar_foreach(p_as->sub_as_list_id, j, p_sub_as) {
769                           //...
770           }
771           xbt_dynar_foreach(p_as->host_list_d, j, p_host) {
772             create_host_wsL07(p_host->id, p_host->power_peak, p_host->power_scale,
773                               p_host->power_trace, p_host->state_initial,
774                               p_host->state_trace);
775             //add to routing model host list
776             surf_route_add_host((char *) p_host->id);
777           }
778           //add Links
779           xbt_dynar_foreach(p_as->link_list_d, j, p_link) {
780               create_link_wsL07(p_link->id, p_link->bandwidth,
781                                 p_link->bandwidth_trace, p_link->latency,
782                                 p_link->latency_trace, p_link->state_initial,
783                                 p_link->state_trace, p_link->policy);
784             }
785             // add route
786           xbt_dynar_foreach(p_as->route_list_d, j, p_route) {
787                 surf_routing_add_route((char *) p_route->src_id,
788                                        (char *) p_route->dest_id, p_route->links_id);
789               }
790           /* </AS> */
791           // Finalize AS
792           surf_AS_finalize(p_as->id);
793   }
794   // add traces
795   surf_wsL07_add_traces();
796   return 0;
797 }
798
799 /*
800  * surf parse bypass application for MSG Module
801  */
802 static int surf_parse_bypass_application()
803 {
804   unsigned int i,j;
805   p_AS_attr p_as;
806   p_host_attr p_host;
807   xbt_dynar_foreach(as_list_d, i, p_as)
808   {
809           xbt_dynar_foreach(p_as->host_list_d, j, p_host) {
810                   if (p_host->function)
811                           MSG_set_function(p_host->id, p_host->function, p_host->args_list);
812           }
813   }
814   return 0;
815 }
816
817 /*
818  * Public Methods
819  */
820 int console_add_host(lua_State *L)
821 {
822         return Host_new(L);
823 }
824
825 int  console_add_link(lua_State *L)
826 {
827         return Link_new(L);
828 }
829
830 int console_add_route(lua_State *L)
831 {
832         return Route_new(L);
833 }
834
835 int console_add_AS(lua_State *L)
836 {
837         return AS_new(L);
838 }
839
840 int console_set_function(lua_State *L)
841 {
842         return Host_set_function(L);
843 }
844
845 int console_host_set_property(lua_State *L)
846 {
847         return Host_set_property(L);
848 }
849
850 int console_parse_platform()
851 {
852         return surf_parse_bypass_platform();
853 }
854
855 int  console_parse_application()
856 {
857         return surf_parse_bypass_application();
858 }
859
860 int console_parse_platform_wsL07()
861 {
862         return surf_wsL07_parse_bypass_platform();
863 }