src/bindings/lua/simgrid_lua.c

   1 /* Copyright (c) 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 /* SimGrid Lua bindings                                                     */
   8
   9 #include "simgrid_lua.h"
  10 #include "lua_state_cloner.h"
  11 #include "lua_utils.h"
  12
  13 XBT_LOG_NEW_DEFAULT_CATEGORY(lua, "Lua Bindings");
  14
  15 static lua_State *lua_maestro_state;
  16
  17 #define TASK_MODULE_NAME "simgrid.Task"
  18 #define HOST_MODULE_NAME "simgrid.Host"
  19 // Surf (bypass XML)
  20 #define LINK_MODULE_NAME "simgrid.Link"
  21 #define ROUTE_MODULE_NAME "simgrid.Route"
  22 #define AS_MODULE_NAME "simgrid.AS"
  23 #define TRACE_MODULE_NAME "simgrid.Trace"
  24
  25 static void register_c_functions(lua_State *L);
  26
  27 static void *my_checkudata (lua_State *L, int ud, const char *tname) {
  28
  29   XBT_DEBUG("Checking the task: ud = %d", ud);
  30   sglua_stack_dump("my_checkudata: ", L);
  31   void *p = lua_touserdata(L, ud);
  32   lua_getfield(L, LUA_REGISTRYINDEX, tname);
  33   const void* correct_mt = lua_topointer(L, -1);
  34
  35   int has_mt = lua_getmetatable(L, ud);
  36   XBT_DEBUG("Checking the task: has metatable ? %d", has_mt);
  37   const void* actual_mt = NULL;
  38   if (has_mt) { actual_mt = lua_topointer(L, -1); lua_pop(L, 1); }
  39   XBT_DEBUG("Checking the task's metatable: expected %p, found %p", correct_mt, actual_mt);
  40   sglua_stack_dump("my_checkudata: ", L);
  41
  42   if (p == NULL || !lua_getmetatable(L, ud) || !lua_rawequal(L, -1, -2))
  43     luaL_typerror(L, ud, tname);
  44   lua_pop(L, 2);
  45   return p;
  46 }
  47
  48 /**
  49  * @brief Ensures that a userdata on the stack is a task
  50  * and returns the pointer inside the userdata.
  51  * @param L a Lua state
  52  * @param index an index in the Lua stack
  53  * @return the task at this index
  54  */
  55 static m_task_t checkTask(lua_State * L, int index)
  56 {
  57   m_task_t *pi, tk;
  58   XBT_DEBUG("Lua task: %s", sglua_tostring(L, index));
  59   luaL_checktype(L, index, LUA_TTABLE);
  60   lua_getfield(L, index, "__simgrid_task");
  61
  62   pi = (m_task_t *) luaL_checkudata(L, lua_gettop(L), TASK_MODULE_NAME);
  63
  64   if (pi == NULL)
  65     luaL_typerror(L, index, TASK_MODULE_NAME);
  66   tk = *pi;
  67   if (!tk)
  68     luaL_error(L, "null Task");
  69   lua_pop(L, 1);
  70   return tk;
  71 }
  72
  73 /* ********************************************************************************* */
  74 /*                           wrapper functions                                       */
  75 /* ********************************************************************************* */
  76
  77 /**
  78  * A task is either something to compute somewhere, or something to exchange between two hosts (or both).
  79  * It is defined by a computing amount and a message size.
  80  *
  81  */
  82
  83 /* *              * *
  84  * * Constructors * *
  85  * *              * */
  86
  87 /**
  88  * @brief Constructs a new task with the specified processing amount and amount
  89  * of data needed.
  90  *
  91  * @param name  Task's name
  92  *
  93  * @param computeDuration       A value of the processing amount (in flop) needed to process the task.
  94  *                              If 0, then it cannot be executed with the execute() method.
  95  *                              This value has to be >= 0.
  96  *
  97  * @param messageSize           A value of amount of data (in bytes) needed to transfert this task.
  98  *                              If 0, then it cannot be transfered with the get() and put() methods.
  99  *                              This value has to be >= 0.
 100  */
 101 static int Task_new(lua_State * L)
 102 {
 103   XBT_DEBUG("Task new...");
 104   const char *name = luaL_checkstring(L, 1);
 105   int comp_size = luaL_checkint(L, 2);
 106   int msg_size = luaL_checkint(L, 3);
 107   m_task_t msg_task = MSG_task_create(name, comp_size, msg_size, NULL);
 108   lua_newtable(L);              /* create a table, put the userdata on top of it */
 109   m_task_t *lua_task = (m_task_t *) lua_newuserdata(L, sizeof(m_task_t));
 110   *lua_task = msg_task;
 111   luaL_getmetatable(L, TASK_MODULE_NAME);
 112   lua_setmetatable(L, -2);
 113   lua_setfield(L, -2, "__simgrid_task");        /* put the userdata as field of the table */
 114   /* remove the args from the stack */
 115   lua_remove(L, 1);
 116   lua_remove(L, 1);
 117   lua_remove(L, 1);
 118   return 1;
 119 }
 120
 121 static int Task_get_name(lua_State * L)
 122 {
 123   m_task_t tk = checkTask(L, -1);
 124   lua_pushstring(L, MSG_task_get_name(tk));
 125   return 1;
 126 }
 127
 128 static int Task_computation_duration(lua_State * L)
 129 {
 130   m_task_t tk = checkTask(L, -1);
 131   lua_pushnumber(L, MSG_task_get_compute_duration(tk));
 132   return 1;
 133 }
 134
 135 static int Task_execute(lua_State * L)
 136 {
 137   m_task_t tk = checkTask(L, -1);
 138   int res = MSG_task_execute(tk);
 139   lua_pushnumber(L, res);
 140   return 1;
 141 }
 142
 143 static int Task_destroy(lua_State * L)
 144 {
 145   m_task_t tk = checkTask(L, -1);
 146   int res = MSG_task_destroy(tk);
 147   lua_pushnumber(L, res);
 148   return 1;
 149 }
 150
 151 static int Task_send(lua_State * L)
 152 {
 153   //stack_dump("send ", L);
 154   m_task_t tk = checkTask(L, 1);
 155   const char *mailbox = luaL_checkstring(L, 2);
 156   lua_pop(L, 1);                // remove the string so that the task is on top of it
 157   MSG_task_set_data(tk, L);     // Copy my stack into the task, so that the receiver can copy the lua task directly
 158   MSG_error_t res = MSG_task_send(tk, mailbox);
 159   while (MSG_task_get_data(tk) != NULL) // Don't mess up with my stack: the receiver didn't copy the data yet
 160     MSG_process_sleep(0);       // yield
 161
 162   if (res != MSG_OK)
 163     switch (res) {
 164     case MSG_TIMEOUT:
 165       XBT_DEBUG("MSG_task_send failed : Timeout");
 166       break;
 167     case MSG_TRANSFER_FAILURE:
 168       XBT_DEBUG("MSG_task_send failed : Transfer Failure");
 169       break;
 170     case MSG_HOST_FAILURE:
 171       XBT_DEBUG("MSG_task_send failed : Host Failure ");
 172       break;
 173     default:
 174       XBT_ERROR
 175           ("MSG_task_send failed : Unexpected error , please report this bug");
 176       break;
 177     }
 178   return 0;
 179 }
 180
 181 static int Task_recv_with_timeout(lua_State *L)
 182 {
 183   m_task_t tk = NULL;
 184   const char *mailbox = luaL_checkstring(L, -2);
 185   int timeout = luaL_checknumber(L, -1);
 186   MSG_error_t res = MSG_task_receive_with_timeout(&tk, mailbox, timeout);
 187
 188   if (res == MSG_OK) {
 189     lua_State *sender_stack = MSG_task_get_data(tk);
 190     sglua_move_value(sender_stack, L);        // copy the data directly from sender's stack
 191     MSG_task_set_data(tk, NULL);
 192   }
 193   else {
 194     switch (res) {
 195     case MSG_TIMEOUT:
 196       XBT_DEBUG("MSG_task_receive failed : Timeout");
 197       break;
 198     case MSG_TRANSFER_FAILURE:
 199       XBT_DEBUG("MSG_task_receive failed : Transfer Failure");
 200       break;
 201     case MSG_HOST_FAILURE:
 202       XBT_DEBUG("MSG_task_receive failed : Host Failure ");
 203       break;
 204     default:
 205       XBT_ERROR("MSG_task_receive failed : Unexpected error , please report this bug");
 206       break;
 207     }
 208     lua_pushnil(L);
 209   }
 210   return 1;
 211 }
 212
 213 static int Task_recv(lua_State * L)
 214 {
 215   lua_pushnumber(L, -1.0);
 216   return Task_recv_with_timeout(L);
 217 }
 218
 219 static const luaL_reg Task_methods[] = {
 220   {"new", Task_new},
 221   {"name", Task_get_name},
 222   {"computation_duration", Task_computation_duration},
 223   {"execute", Task_execute},
 224   {"destroy", Task_destroy},
 225   {"send", Task_send},
 226   {"recv", Task_recv},
 227   {"recv_timeout", Task_recv_with_timeout},
 228   {NULL, NULL}
 229 };
 230
 231 static int Task_gc(lua_State * L)
 232 {
 233   m_task_t tk = checkTask(L, -1);
 234   if (tk)
 235     MSG_task_destroy(tk);
 236   return 0;
 237 }
 238
 239 static int Task_tostring(lua_State * L)
 240 {
 241   lua_pushfstring(L, "Task :%p", lua_touserdata(L, 1));
 242   return 1;
 243 }
 244
 245 static const luaL_reg Task_meta[] = {
 246   {"__gc", Task_gc},
 247   {"__tostring", Task_tostring},
 248   {NULL, NULL}
 249 };
 250
 251 /**
 252  * Host
 253  */
 254 static m_host_t checkHost(lua_State * L, int index)
 255 {
 256   m_host_t *pi, ht;
 257   luaL_checktype(L, index, LUA_TTABLE);
 258   lua_getfield(L, index, "__simgrid_host");
 259   pi = (m_host_t *) luaL_checkudata(L, lua_gettop(L), HOST_MODULE_NAME);
 260   if (pi == NULL)
 261     luaL_typerror(L, index, HOST_MODULE_NAME);
 262   ht = *pi;
 263   if (!ht)
 264     luaL_error(L, "null Host");
 265   lua_pop(L, 1);
 266   return ht;
 267 }
 268
 269 static int Host_get_by_name(lua_State * L)
 270 {
 271   const char *name = luaL_checkstring(L, 1);
 272   XBT_DEBUG("Getting Host from name...");
 273   m_host_t msg_host = MSG_get_host_by_name(name);
 274   if (!msg_host) {
 275     luaL_error(L, "null Host : MSG_get_host_by_name failed");
 276   }
 277   lua_newtable(L);              /* create a table, put the userdata on top of it */
 278   m_host_t *lua_host = (m_host_t *) lua_newuserdata(L, sizeof(m_host_t));
 279   *lua_host = msg_host;
 280   luaL_getmetatable(L, HOST_MODULE_NAME);
 281   lua_setmetatable(L, -2);
 282   lua_setfield(L, -2, "__simgrid_host");        /* put the userdata as field of the table */
 283   /* remove the args from the stack */
 284   lua_remove(L, 1);
 285   return 1;
 286 }
 287
 288 static int Host_get_name(lua_State * L)
 289 {
 290   m_host_t ht = checkHost(L, -1);
 291   lua_pushstring(L, MSG_host_get_name(ht));
 292   return 1;
 293 }
 294
 295 static int Host_number(lua_State * L)
 296 {
 297   lua_pushnumber(L, MSG_get_host_number());
 298   return 1;
 299 }
 300
 301 static int Host_at(lua_State * L)
 302 {
 303   int index = luaL_checkinteger(L, 1);
 304   m_host_t host = MSG_get_host_table()[index - 1];      // lua indexing start by 1 (lua[1] <=> C[0])
 305   lua_newtable(L);              /* create a table, put the userdata on top of it */
 306   m_host_t *lua_host = (m_host_t *) lua_newuserdata(L, sizeof(m_host_t));
 307   *lua_host = host;
 308   luaL_getmetatable(L, HOST_MODULE_NAME);
 309   lua_setmetatable(L, -2);
 310   lua_setfield(L, -2, "__simgrid_host");        /* put the userdata as field of the table */
 311   return 1;
 312
 313 }
 314
 315 static int Host_self(lua_State * L)
 316 {
 317   m_host_t host = MSG_host_self();
 318   lua_newtable(L);
 319   m_host_t *lua_host =(m_host_t *)lua_newuserdata(L,sizeof(m_host_t));
 320   *lua_host = host;
 321   luaL_getmetatable(L, HOST_MODULE_NAME);
 322   lua_setmetatable(L, -2);
 323   lua_setfield(L, -2, "__simgrid_host");
 324   return 1;
 325 }
 326
 327 static int Host_get_property_value(lua_State * L)
 328 {
 329   m_host_t ht = checkHost(L, -2);
 330   const char *prop = luaL_checkstring(L, -1);
 331   lua_pushstring(L,MSG_host_get_property_value(ht,prop));
 332   return 1;
 333 }
 334
 335 static int Host_sleep(lua_State *L)
 336 {
 337   int time = luaL_checknumber(L, -1);
 338   MSG_process_sleep(time);
 339   return 1;
 340 }
 341
 342 static int Host_destroy(lua_State *L)
 343 {
 344   m_host_t ht = checkHost(L, -1);
 345   __MSG_host_destroy(ht);
 346   return 1;
 347 }
 348
 349 /* ********************************************************************************* */
 350 /*                           lua_stub_generator functions                            */
 351 /* ********************************************************************************* */
 352
 353 xbt_dict_t process_function_set;
 354 xbt_dynar_t process_list;
 355 xbt_dict_t machine_set;
 356 static s_process_t process;
 357
 358 void s_process_free(void *process)
 359 {
 360   s_process_t *p = (s_process_t *) process;
 361   int i;
 362   for (i = 0; i < p->argc; i++)
 363     free(p->argv[i]);
 364   free(p->argv);
 365   free(p->host);
 366 }
 367
 368 static int gras_add_process_function(lua_State * L)
 369 {
 370   const char *arg;
 371   const char *process_host = luaL_checkstring(L, 1);
 372   const char *process_function = luaL_checkstring(L, 2);
 373
 374   if (xbt_dict_is_empty(machine_set)
 375       || xbt_dict_is_empty(process_function_set)
 376       || xbt_dynar_is_empty(process_list)) {
 377     process_function_set = xbt_dict_new();
 378     process_list = xbt_dynar_new(sizeof(s_process_t), s_process_free);
 379     machine_set = xbt_dict_new();
 380   }
 381
 382   xbt_dict_set(machine_set, process_host, NULL, NULL);
 383   xbt_dict_set(process_function_set, process_function, NULL, NULL);
 384
 385   process.argc = 1;
 386   process.argv = xbt_new(char *, 1);
 387   process.argv[0] = xbt_strdup(process_function);
 388   process.host = strdup(process_host);
 389
 390   lua_pushnil(L);
 391   while (lua_next(L, 3) != 0) {
 392     arg = lua_tostring(L, -1);
 393     process.argc++;
 394     process.argv =
 395         xbt_realloc(process.argv, (process.argc) * sizeof(char *));
 396     process.argv[(process.argc) - 1] = xbt_strdup(arg);
 397
 398     XBT_DEBUG("index = %f , arg = %s \n", lua_tonumber(L, -2),
 399            lua_tostring(L, -1));
 400     lua_pop(L, 1);
 401   }
 402   lua_pop(L, 1);
 403   //add to the process list
 404   xbt_dynar_push(process_list, &process);
 405   return 0;
 406 }
 407
 408
 409 static int gras_generate(lua_State * L)
 410 {
 411   const char *project_name = luaL_checkstring(L, 1);
 412   generate_sim(project_name);
 413   generate_rl(project_name);
 414   generate_makefile_local(project_name);
 415   return 0;
 416 }
 417
 418 /***********************************
 419  *      Tracing
 420  **********************************/
 421 static int trace_start(lua_State *L)
 422 {
 423 #ifdef HAVE_TRACING
 424   TRACE_start();
 425 #endif
 426   return 1;
 427 }
 428
 429 static int trace_category(lua_State * L)
 430 {
 431 #ifdef HAVE_TRACING
 432   TRACE_category(luaL_checkstring(L, 1));
 433 #endif
 434   return 1;
 435 }
 436
 437 static int trace_set_task_category(lua_State *L)
 438 {
 439 #ifdef HAVE_TRACING
 440   TRACE_msg_set_task_category(checkTask(L, -2), luaL_checkstring(L, -1));
 441 #endif
 442   return 1;
 443 }
 444
 445 static int trace_end(lua_State *L)
 446 {
 447 #ifdef HAVE_TRACING
 448   TRACE_end();
 449 #endif
 450   return 1;
 451 }
 452
 453 // *********** Register Methods ******************************************* //
 454
 455 /*
 456  * Host Methods
 457  */
 458 static const luaL_reg Host_methods[] = {
 459   {"getByName", Host_get_by_name},
 460   {"name", Host_get_name},
 461   {"number", Host_number},
 462   {"at", Host_at},
 463   {"self", Host_self},
 464   {"getPropValue", Host_get_property_value},
 465   {"sleep", Host_sleep},
 466   {"destroy", Host_destroy},
 467   // Bypass XML Methods
 468   {"setFunction", console_set_function},
 469   {"setProperty", console_host_set_property},
 470   {NULL, NULL}
 471 };
 472
 473 static int Host_gc(lua_State * L)
 474 {
 475   m_host_t ht = checkHost(L, -1);
 476   if (ht)
 477     ht = NULL;
 478   return 0;
 479 }
 480
 481 static int Host_tostring(lua_State * L)
 482 {
 483   lua_pushfstring(L, "Host :%p", lua_touserdata(L, 1));
 484   return 1;
 485 }
 486
 487 static const luaL_reg Host_meta[] = {
 488   {"__gc", Host_gc},
 489   {"__tostring", Host_tostring},
 490   {0, 0}
 491 };
 492
 493 /*
 494  * AS Methods
 495  */
 496 static const luaL_reg AS_methods[] = {
 497   {"new", console_add_AS},
 498   {"addHost", console_add_host},
 499   {"addLink", console_add_link},
 500   {"addRoute", console_add_route},
 501   {NULL, NULL}
 502 };
 503
 504 /**
 505  * Tracing Functions
 506  */
 507 static const luaL_reg Trace_methods[] = {
 508   {"start", trace_start},
 509   {"category", trace_category},
 510   {"setTaskCategory", trace_set_task_category},
 511   {"finish", trace_end},
 512   {NULL, NULL}
 513 };
 514
 515 /*
 516  * Environment related
 517  */
 518
 519 /**
 520  * @brief Runs a Lua function as a new simulated process.
 521  * @param argc number of arguments of the function
 522  * @param argv name of the Lua function and array of its arguments
 523  * @return result of the function
 524  */
 525 static int run_lua_code(int argc, char **argv)
 526 {
 527   XBT_DEBUG("Run lua code %s", argv[0]);
 528
 529   lua_State *L = sglua_clone_maestro();
 530   int res = 1;
 531
 532   /* start the function */
 533   lua_getglobal(L, argv[0]);
 534   xbt_assert(lua_isfunction(L, -1),
 535               "The lua function %s does not seem to exist", argv[0]);
 536
 537   /* push arguments onto the stack */
 538   int i;
 539   for (i = 1; i < argc; i++)
 540     lua_pushstring(L, argv[i]);
 541
 542   /* call the function */
 543   int err;
 544   err = lua_pcall(L, argc - 1, 1, 0);
 545   xbt_assert(err == 0, "error running function `%s': %s", argv[0],
 546               lua_tostring(L, -1));
 547
 548   /* retrieve result */
 549   if (lua_isnumber(L, -1)) {
 550     res = lua_tonumber(L, -1);
 551     lua_pop(L, 1);              /* pop returned value */
 552   }
 553
 554   XBT_DEBUG("Execution of Lua code %s is over", (argv ? argv[0] : "(null)"));
 555
 556   return res;
 557 }
 558
 559 static int launch_application(lua_State * L)
 560 {
 561   const char *file = luaL_checkstring(L, 1);
 562   MSG_function_register_default(run_lua_code);
 563   MSG_launch_application(file);
 564   return 0;
 565 }
 566
 567 static int create_environment(lua_State * L)
 568 {
 569   const char *file = luaL_checkstring(L, 1);
 570   XBT_DEBUG("Loading environment file %s", file);
 571   MSG_create_environment(file);
 572   return 0;
 573 }
 574
 575 static int debug(lua_State * L)
 576 {
 577   const char *str = luaL_checkstring(L, 1);
 578   XBT_DEBUG("%s", str);
 579   return 0;
 580 }
 581
 582 static int info(lua_State * L)
 583 {
 584   const char *str = luaL_checkstring(L, 1);
 585   XBT_INFO("%s", str);
 586   return 0;
 587 }
 588
 589 static int run(lua_State * L)
 590 {
 591   MSG_main();
 592   return 0;
 593 }
 594
 595 static int clean(lua_State * L)
 596 {
 597   MSG_clean();
 598   return 0;
 599 }
 600
 601 /*
 602  * Bypass XML Parser (lua console)
 603  */
 604
 605 /*
 606  * Register platform for MSG
 607  */
 608 static int msg_register_platform(lua_State * L)
 609 {
 610   /* Tell Simgrid we dont wanna use its parser */
 611   surf_parse = console_parse_platform;
 612   surf_parse_reset_callbacks();
 613   surf_config_models_setup(NULL);
 614   MSG_create_environment(NULL);
 615   return 0;
 616 }
 617
 618 /*
 619  * Register platform for Simdag
 620  */
 621
 622 static int sd_register_platform(lua_State * L)
 623 {
 624   surf_parse = console_parse_platform_wsL07;
 625   surf_parse_reset_callbacks();
 626   surf_config_models_setup(NULL);
 627   SD_create_environment(NULL);
 628   return 0;
 629 }
 630
 631 /*
 632  * Register platform for gras
 633  */
 634 static int gras_register_platform(lua_State * L)
 635 {
 636   /* Tell Simgrid we dont wanna use surf parser */
 637   surf_parse = console_parse_platform;
 638   surf_parse_reset_callbacks();
 639   surf_config_models_setup(NULL);
 640   gras_create_environment(NULL);
 641   return 0;
 642 }
 643
 644 /**
 645  * Register applicaiton for MSG
 646  */
 647 static int msg_register_application(lua_State * L)
 648 {
 649   MSG_function_register_default(run_lua_code);
 650   surf_parse = console_parse_application;
 651   MSG_launch_application(NULL);
 652   return 0;
 653 }
 654
 655 /*
 656  * Register application for gras
 657  */
 658 static int gras_register_application(lua_State * L)
 659 {
 660   gras_function_register_default(run_lua_code);
 661   surf_parse = console_parse_application;
 662   gras_launch_application(NULL);
 663   return 0;
 664 }
 665
 666 static const luaL_Reg simgrid_funcs[] = {
 667   {"create_environment", create_environment},
 668   {"launch_application", launch_application},
 669   {"debug", debug},
 670   {"info", info},
 671   {"run", run},
 672   {"clean", clean},
 673   /* short names */
 674   {"platform", create_environment},
 675   {"application", launch_application},
 676   /* methods to bypass XML parser */
 677   {"msg_register_platform", msg_register_platform},
 678   {"sd_register_platform", sd_register_platform},
 679   {"msg_register_application", msg_register_application},
 680   {"gras_register_platform", gras_register_platform},
 681   {"gras_register_application", gras_register_application},
 682   /* gras sub generator method */
 683   {"gras_set_process_function", gras_add_process_function},
 684   {"gras_generate", gras_generate},
 685   {NULL, NULL}
 686 };
 687
 688 /* ********************************************************************************* */
 689 /*                       module management functions                                 */
 690 /* ********************************************************************************* */
 691
 692 #define LUA_MAX_ARGS_COUNT 10   /* maximum amount of arguments we can get from lua on command line */
 693
 694 int luaopen_simgrid(lua_State *L);     // Fuck gcc: we don't need that prototype
 695
 696 /**
 697  * This function is called automatically by the Lua interpreter when some Lua code requires
 698  * the "simgrid" module.
 699  * @param L the Lua state
 700  */
 701 int luaopen_simgrid(lua_State *L)
 702 {
 703   XBT_DEBUG("luaopen_simgrid *****");
 704
 705   /* Get the command line arguments from the lua interpreter */
 706   char **argv = malloc(sizeof(char *) * LUA_MAX_ARGS_COUNT);
 707   int argc = 1;
 708   argv[0] = (char *) "/usr/bin/lua";    /* Lie on the argv[0] so that the stack dumping facilities find the right binary. FIXME: what if lua is not in that location? */
 709
 710   lua_getglobal(L, "arg");
 711   /* if arg is a null value, it means we use lua only as a script to init platform
 712    * else it should be a table and then take arg in consideration
 713    */
 714   if (lua_istable(L, -1)) {
 715     int done = 0;
 716     while (!done) {
 717       argc++;
 718       lua_pushinteger(L, argc - 2);
 719       lua_gettable(L, -2);
 720       if (lua_isnil(L, -1)) {
 721         done = 1;
 722       } else {
 723         xbt_assert(lua_isstring(L, -1),
 724                     "argv[%d] got from lua is no string", argc - 1);
 725         xbt_assert(argc < LUA_MAX_ARGS_COUNT,
 726                     "Too many arguments, please increase LUA_MAX_ARGS_COUNT in %s before recompiling SimGrid if you insist on having more than %d args on command line",
 727                     __FILE__, LUA_MAX_ARGS_COUNT - 1);
 728         argv[argc - 1] = (char *) luaL_checkstring(L, -1);
 729         lua_pop(L, 1);
 730         XBT_DEBUG("Got command line argument %s from lua", argv[argc - 1]);
 731       }
 732     }
 733     argv[argc--] = NULL;
 734
 735     /* Initialize the MSG core */
 736     MSG_global_init(&argc, argv);
 737     XBT_DEBUG("Still %d arguments on command line", argc); // FIXME: update the lua's arg table to reflect the changes from SimGrid
 738   }
 739
 740   /* Keep the context mechanism informed of our lua world today */
 741   lua_maestro_state = L;
 742
 743   /* initialize access to my tables by children Lua states */
 744   lua_newtable(L);
 745   lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.maestro_tables");
 746
 747   register_c_functions(L);
 748
 749   return 1;
 750 }
 751
 752 /**
 753  * @brief Returns whether a Lua state is the maestro state.
 754  * @param L a Lua state
 755  * @return true if this is maestro
 756  */
 757 int sglua_is_maestro(lua_State* L) {
 758   return L == lua_maestro_state;
 759 }
 760
 761 /**
 762  * @brief Returns the maestro state.
 763  * @return true the maestro Lua state
 764  */
 765 lua_State* sglua_get_maestro(void) {
 766   return lua_maestro_state;
 767 }
 768
 769 /**
 770  * Makes the appropriate Simgrid functions available to the Lua world.
 771  * @param L a Lua world
 772  */
 773 void register_c_functions(lua_State *L) {
 774
 775   /* register the core C functions to lua */
 776   luaL_register(L, "simgrid", simgrid_funcs);
 777
 778   /* register the task methods to lua */
 779   luaL_openlib(L, TASK_MODULE_NAME, Task_methods, 0);   // create methods table, add it to the globals
 780   luaL_newmetatable(L, TASK_MODULE_NAME);       // create metatable for Task, add it to the Lua registry
 781   luaL_openlib(L, 0, Task_meta, 0);     // fill metatable
 782   lua_pushliteral(L, "__index");
 783   lua_pushvalue(L, -3);         // dup methods table
 784   lua_rawset(L, -3);            // matatable.__index = methods
 785   lua_pushliteral(L, "__metatable");
 786   lua_pushvalue(L, -3);         // dup methods table
 787   lua_rawset(L, -3);            // hide metatable:metatable.__metatable = methods
 788   lua_pop(L, 1);                // drop metatable
 789
 790   /* register the hosts methods to lua */
 791   luaL_openlib(L, HOST_MODULE_NAME, Host_methods, 0);
 792   luaL_newmetatable(L, HOST_MODULE_NAME);
 793   luaL_openlib(L, 0, Host_meta, 0);
 794   lua_pushliteral(L, "__index");
 795   lua_pushvalue(L, -3);
 796   lua_rawset(L, -3);
 797   lua_pushliteral(L, "__metatable");
 798   lua_pushvalue(L, -3);
 799   lua_rawset(L, -3);
 800   lua_pop(L, 1);
 801
 802   /* register the links methods to lua */
 803   luaL_openlib(L, AS_MODULE_NAME, AS_methods, 0);
 804   luaL_newmetatable(L, AS_MODULE_NAME);
 805   lua_pop(L, 1);
 806
 807   /* register the Tracing functions to lua */
 808   luaL_openlib(L, TRACE_MODULE_NAME, Trace_methods, 0);
 809   luaL_newmetatable(L, TRACE_MODULE_NAME);
 810   lua_pop(L, 1);
 811 }