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)
  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                             current_property_set);
  61   current_property_set = NULL;
  62 }
  63
  64 /**
  65  * create link resource via network model
  66  */
  67 static void create_link(const char *name,
  68                         double bw_initial, const char *trace,
  69                         double lat_initial, const char *latency_trace,
  70                         int state_init, const char *state_trace,
  71                         int policy)
  72 {
  73   tmgr_trace_t bw_trace;
  74   tmgr_trace_t lat_trace;
  75   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
  76   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
  77   tmgr_trace_t st_trace;
  78   if (trace)
  79     bw_trace = tmgr_trace_new(trace);
  80   else
  81     bw_trace = tmgr_trace_new("");
  82
  83   if (latency_trace)
  84     lat_trace = tmgr_trace_new(latency_trace);
  85   else
  86     lat_trace = tmgr_trace_new("");
  87
  88   if (state_trace)
  89     st_trace = tmgr_trace_new(state_trace);
  90   else
  91     st_trace = tmgr_trace_new("");
  92
  93   if (state_init == -1)
  94     state_initial_link = SURF_RESOURCE_OFF;
  95   if (policy == -1)
  96     policy_initial_link = SURF_LINK_FATPIPE;
  97
  98   surf_link_create_resource(xbt_strdup(name), bw_initial, bw_trace,
  99                             lat_initial, lat_trace, state_initial_link,
 100                             st_trace, policy_initial_link, xbt_dict_new());
 101 }
 102
 103 /*
 104  *create host resource via workstation_ptask_L07 model [for SimDag]
 105  */
 106 static void create_host_wsL07(const char *id, double power_peak,
 107                               double power_sc, const char *power_tr,
 108                               int state_init, const char *state_tr)
 109 {
 110   double power_scale = 1.0;
 111   tmgr_trace_t power_trace = NULL;
 112   e_surf_resource_state_t state_initial;
 113   tmgr_trace_t state_trace;
 114   if (power_sc)                 // !=0
 115     power_scale = power_sc;
 116   if (state_init == -1)
 117     state_initial = SURF_RESOURCE_OFF;
 118   else
 119     state_initial = SURF_RESOURCE_ON;
 120   if (power_tr)
 121     power_trace = tmgr_trace_new(power_tr);
 122   else
 123     power_trace = tmgr_trace_new("");
 124   if (state_tr)
 125     state_trace = tmgr_trace_new(state_tr);
 126   else
 127     state_trace = tmgr_trace_new("");
 128
 129   surf_wsL07_host_create_resource(xbt_strdup(id), power_peak, power_scale,
 130                                   power_trace, state_initial, state_trace,
 131                                   current_property_set);
 132   current_property_set = NULL;
 133 }
 134
 135 /**
 136  * create link resource via workstation_ptask_L07 model [for SimDag]
 137  */
 138
 139 static void create_link_wsL07(const char *name,
 140                               double bw_initial, const char *trace,
 141                               double lat_initial,
 142                               const char *latency_trace, int state_init,
 143                               const char *state_trace, int policy)
 144 {
 145   tmgr_trace_t bw_trace;
 146   tmgr_trace_t lat_trace;
 147   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
 148   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
 149   tmgr_trace_t st_trace;
 150   if (trace)
 151     bw_trace = tmgr_trace_new(trace);
 152   else
 153     bw_trace = tmgr_trace_new("");
 154
 155   if (latency_trace)
 156     lat_trace = tmgr_trace_new(latency_trace);
 157   else
 158     lat_trace = tmgr_trace_new("");
 159
 160   if (state_trace)
 161     st_trace = tmgr_trace_new(state_trace);
 162   else
 163     st_trace = tmgr_trace_new("");
 164
 165   if (state_init == -1)
 166     state_initial_link = SURF_RESOURCE_OFF;
 167   if (policy == -1)
 168     policy_initial_link = SURF_LINK_FATPIPE;
 169
 170   surf_wsL07_link_create_resource(xbt_strdup(name), bw_initial, bw_trace,
 171                                   lat_initial, lat_trace,
 172                                   state_initial_link, st_trace,
 173                                   policy_initial_link, xbt_dict_new());
 174 }
 175
 176
 177 /*
 178  * Append new AS to the Platform
 179  */
 180
 181 static int AS_new(lua_State * L)
 182 {
 183
 184    if (xbt_dynar_is_empty(as_list_d))
 185             as_list_d = xbt_dynar_new(sizeof(p_AS_attr), &xbt_free_ref);
 186
 187   p_AS_attr AS;
 188   const char *id;
 189   const char *mode;
 190   if (lua_istable(L, 1)) {
 191     lua_pushstring(L, "id");
 192     lua_gettable(L, -2);
 193     id = lua_tostring(L, -1);
 194     lua_pop(L, 1);
 195
 196     lua_pushstring(L, "mode");
 197     lua_gettable(L, -2);
 198     mode = lua_tostring(L, -1);
 199     lua_pop(L, 1);
 200   } else {
 201     XBT_ERROR
 202         ("Bad Arguments to AS.new, Should be a table with named arguments");
 203     return -1;
 204   }
 205   AS = malloc(sizeof(AS_attr));
 206   AS->id = id;
 207   AS->mode = mode;
 208   AS->host_list_d = xbt_dynar_new(sizeof(p_host_attr),&xbt_free_ref);
 209   AS->link_list_d = xbt_dynar_new(sizeof(p_link_attr),&xbt_free_ref);
 210   AS->route_list_d = xbt_dynar_new(sizeof(p_route_attr),&xbt_free_ref);
 211   AS->router_list_d = xbt_dynar_new(sizeof(p_router_attr),&xbt_free_ref);
 212   AS->sub_as_list_id = xbt_dynar_new(sizeof(p_AS_attr),&xbt_free_ref);
 213   xbt_dynar_push(as_list_d, &AS);
 214
 215   return 0;
 216 }
 217
 218 /**
 219  * add sub AS to the Parent AS
 220  */
 221 static int AS_add(lua_State *L)
 222 {
 223         unsigned int i;
 224         p_AS_attr AS;
 225         p_AS_attr super_as,p_as;
 226         const char *super_AS_id;
 227         const char *sub_AS_id = NULL;
 228         const char *sub_AS_routing= NULL;
 229         if(lua_istable(L, -1))
 230         {
 231                 lua_pushstring(L, "AS");
 232                 lua_gettable(L, -2);
 233                 super_AS_id = lua_tostring(L, -1);
 234                 lua_pop(L,1);
 235
 236                 lua_pushstring(L, "id");
 237                 lua_gettable(L, -2);
 238                 sub_AS_id = lua_tostring(L, -1);
 239                 lua_pop(L,1);
 240
 241         }
 242
 243         xbt_dynar_foreach(as_list_d, i, p_as){
 244                   if (p_as->id == super_AS_id){
 245                           super_as = p_as;
 246                           break;
 247                   }
 248         }
 249         AS = malloc(sizeof(AS_attr));
 250         AS->id = sub_AS_id;
 251         AS->mode = sub_AS_routing;
 252         AS->host_list_d = xbt_dynar_new(sizeof(p_host_attr),&xbt_free_ref);
 253         AS->link_list_d = xbt_dynar_new(sizeof(p_link_attr),&xbt_free_ref);
 254         AS->route_list_d = xbt_dynar_new(sizeof(p_route_attr),&xbt_free_ref);
 255         AS->sub_as_list_id = xbt_dynar_new(sizeof(p_AS_attr),&xbt_free_ref);
 256         xbt_dynar_push(super_as->sub_as_list_id, &AS);
 257
 258         return 0;
 259 }
 260
 261
 262 /*
 263  * add new host to platform hosts list
 264  */
 265 static int Host_new(lua_State * L)
 266 {
 267   p_host_attr host;
 268   unsigned int i;
 269   p_AS_attr p_as,current_as = NULL;
 270   const char *AS_id;
 271   const char *id;
 272   const char *power_trace;
 273   const char *state_trace;
 274   double power, power_scale;
 275   int state_initial,core;
 276   //get values from the table passed as argument
 277   if (lua_istable(L, -1)) {
 278         // get AS id
 279         lua_pushstring(L, "AS");
 280         lua_gettable(L, -2);
 281         AS_id = lua_tostring(L, -1);
 282         lua_pop(L,1);
 283
 284     // get Id Value
 285     lua_pushstring(L, "id");
 286     lua_gettable(L, -2);
 287     id = lua_tostring(L, -1);
 288     lua_pop(L, 1);
 289
 290     // get power value
 291     lua_pushstring(L, "power");
 292     lua_gettable(L, -2);
 293     power = lua_tonumber(L, -1);
 294     lua_pop(L, 1);
 295
 296     //get power_scale
 297     lua_pushstring(L, "power_scale");
 298     lua_gettable(L, -2);
 299     power_scale = lua_tonumber(L, -1);
 300     lua_pop(L, 1);
 301
 302     //get power_trace
 303     lua_pushstring(L, "power_trace");
 304     lua_gettable(L, -2);
 305     power_trace = lua_tostring(L, -1);
 306     lua_pop(L, 1);
 307
 308     lua_pushstring(L, "core");
 309     lua_gettable(L, -2);
 310     core = lua_tonumber(L, -1);
 311     lua_pop(L, 1);
 312
 313     //get state initial
 314     lua_pushstring(L, "state_initial");
 315     lua_gettable(L, -2);
 316     state_initial = lua_tonumber(L, -1);
 317     lua_pop(L, 1);
 318
 319     //get trace state
 320     lua_pushstring(L, "state_trace");
 321     lua_gettable(L, -2);
 322     state_trace = lua_tostring(L, -1);
 323     lua_pop(L, 1);
 324
 325   } else {
 326     XBT_ERROR
 327         ("Bad Arguments to create host, Should be a table with named arguments");
 328     return -1;
 329   }
 330   xbt_dynar_foreach(as_list_d, i, p_as){
 331           if (p_as->id == AS_id){
 332                   current_as = p_as;
 333                   break;
 334           }
 335   }
 336
 337   if (!current_as)
 338   {
 339           XBT_ERROR("No AS_id :%s found",AS_id);
 340           return -2;
 341   }
 342
 343   host = malloc(sizeof(host_attr));
 344   host->id = id;
 345   host->power_peak = power;
 346   host->power_scale = power_scale;
 347   host->power_trace = power_trace;
 348   host->core = core;
 349   host->state_initial = state_initial;
 350   host->state_trace = state_trace;
 351   host->function = NULL;
 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         const char *host;
 608         const char *function;
 609         const char *args;
 610         char * tmp_arg;
 611         unsigned int i,j;
 612
 613    if (lua_istable(L, -1)) {
 614          // get Host id
 615          lua_pushstring(L, "host");
 616          lua_gettable(L, -2);
 617          host = 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 = 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) {
 640                            p_host->function = function;
 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);
 653           return 1;
 654
 655 }
 656 /*
 657  * surf parse bypass platform
 658  * through CPU/network Models
 659  */
 660
 661 static int surf_parse_bypass_platform()
 662 {
 663   unsigned int i,j;
 664   p_AS_attr p_as;
 665   p_host_attr p_host;
 666   p_link_attr p_link;
 667   p_route_attr p_route;
 668
 669
 670   // Add AS
 671   xbt_dynar_foreach(as_list_d, i,p_as)
 672   {
 673           create_AS(p_as->id, p_as->mode);
 674           // add associated Hosts
 675           xbt_dynar_foreach(p_as->host_list_d, j, p_host){
 676                   create_host(p_host->id, p_host->power_peak, p_host->power_scale,
 677                                   p_host->power_trace, p_host->core, p_host->state_initial,
 678                                   p_host->state_trace);
 679                       //add to routing model host list
 680                       surf_route_add_host((char *) p_host->id);
 681           }
 682           // add associated Links
 683           xbt_dynar_foreach(p_as->link_list_d, j, p_link){
 684                   create_link(p_link->id, p_link->bandwidth, p_link->bandwidth_trace,
 685                                   p_link->latency, p_link->latency_trace,
 686                                   p_link->state_initial, p_link->state_trace,
 687                                   p_link->policy);
 688           }
 689           // add associated Routes
 690           xbt_dynar_foreach(p_as->route_list_d, j, p_route){
 691                   surf_routing_add_route((char *) p_route->src_id,
 692                                              (char *) p_route->dest_id, p_route->links_id);
 693           }
 694
 695           // Finalize AS
 696           surf_AS_finalize(p_as->id);
 697   }
 698
 699   // add traces
 700   surf_add_host_traces();
 701   surf_add_link_traces();
 702
 703   return 0;                     // must return 0 ?!!
 704
 705 }
 706
 707 /**
 708  *
 709  * surf parse bypass platform
 710  * through workstation_ptask_L07 Model
 711  */
 712
 713 static int surf_wsL07_parse_bypass_platform()
 714 {
 715   unsigned int i,j;
 716   p_AS_attr p_as, p_sub_as;
 717   p_host_attr p_host;
 718   p_link_attr p_link;
 719   p_route_attr p_route;
 720
 721   xbt_dynar_foreach(as_list_d, i, p_as)
 722   {
 723           // Init AS
 724           create_AS(p_as->id, p_as->mode);
 725
 726           // add Sub AS
 727
 728           // Add Hosts
 729           xbt_dynar_foreach(p_as->sub_as_list_id, j, p_sub_as) {
 730                           //...
 731           }
 732           xbt_dynar_foreach(p_as->host_list_d, j, p_host) {
 733             create_host_wsL07(p_host->id, p_host->power_peak, p_host->power_scale,
 734                               p_host->power_trace, p_host->state_initial,
 735                               p_host->state_trace);
 736             //add to routing model host list
 737             surf_route_add_host((char *) p_host->id);
 738           }
 739           //add Links
 740           xbt_dynar_foreach(p_as->link_list_d, j, p_link) {
 741               create_link_wsL07(p_link->id, p_link->bandwidth,
 742                                 p_link->bandwidth_trace, p_link->latency,
 743                                 p_link->latency_trace, p_link->state_initial,
 744                                 p_link->state_trace, p_link->policy);
 745             }
 746             // add route
 747           xbt_dynar_foreach(p_as->route_list_d, j, p_route) {
 748                 surf_routing_add_route((char *) p_route->src_id,
 749                                        (char *) p_route->dest_id, p_route->links_id);
 750               }
 751           /* </AS> */
 752           // Finalize AS
 753           surf_AS_finalize(p_as->id);
 754   }
 755   // add traces
 756   surf_wsL07_add_traces();
 757   return 0;
 758 }
 759
 760 /*
 761  * surf parse bypass application for MSG Module
 762  */
 763 static int surf_parse_bypass_application()
 764 {
 765   unsigned int i,j;
 766   p_AS_attr p_as;
 767   p_host_attr p_host;
 768   xbt_dynar_foreach(as_list_d, i, p_as)
 769   {
 770           xbt_dynar_foreach(p_as->host_list_d, j, p_host) {
 771                   if (p_host->function)
 772                           MSG_set_function(p_host->id, p_host->function, p_host->args_list);
 773           }
 774   }
 775   return 0;
 776 }
 777
 778 /*
 779  * Public Methods
 780  */
 781 int console_add_host(lua_State *L)
 782 {
 783         return Host_new(L);
 784 }
 785
 786 int  console_add_link(lua_State *L)
 787 {
 788         return Link_new(L);
 789 }
 790
 791 int console_add_route(lua_State *L)
 792 {
 793         return Route_new(L);
 794 }
 795
 796 int console_add_AS(lua_State *L)
 797 {
 798         return AS_new(L);
 799 }
 800
 801 int console_set_function(lua_State *L)
 802 {
 803         return Host_set_function(L);
 804 }
 805
 806 int console_parse_platform()
 807 {
 808         return surf_parse_bypass_platform();
 809 }
 810
 811 int  console_parse_application()
 812 {
 813         return surf_parse_bypass_application();
 814 }
 815
 816 int console_parse_platform_wsL07()
 817 {
 818         return surf_wsL07_parse_bypass_platform();
 819 }