Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
6c6faf13fc39abcdb7d2e3b0b87669ea002dd493
[simgrid.git] / 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_SUBCATEGORY(lua, bindings, "Lua Bindings");
14
15 #define TASK_MODULE_NAME "simgrid.task"
16 #define HOST_MODULE_NAME "simgrid.host"
17 // Surf (bypass XML)
18 #define LINK_MODULE_NAME "simgrid.link"
19 #define ROUTE_MODULE_NAME "simgrid.route"
20 #define PLATF_MODULE_NAME "simgrid.platf"
21
22 static lua_State* sglua_maestro_state;
23
24 int luaopen_simgrid(lua_State *L);
25 static void register_c_functions(lua_State *L);
26 static int run_lua_code(int argc, char **argv);
27
28 /* ********************************************************************************* */
29 /*                                simgrid.task API                                   */
30 /* ********************************************************************************* */
31
32 /**
33  * \brief Ensures that a value in the stack is a valid task and returns it.
34  * \param L a Lua state
35  * \param index an index in the Lua stack
36  * \return the C task corresponding to this Lua task
37  */
38 static m_task_t sglua_checktask(lua_State* L, int index)
39 {
40   sglua_stack_dump("check task: ", L);
41   luaL_checktype(L, index, LUA_TTABLE);
42                                   /* ... task ... */
43   lua_getfield(L, index, "__simgrid_task");
44                                   /* ... task ... ctask */
45   m_task_t task = *((m_task_t*) luaL_checkudata(L, -1, TASK_MODULE_NAME));
46   lua_pop(L, 1);
47                                   /* ... task ... */
48
49   if (task == NULL) {
50     luaL_error(L, "This task was sent to someone else, you cannot access it anymore");
51   }
52
53   return task;
54 }
55
56 /**
57  * \brief Creates a new task and leaves it onto the stack.
58  * \param L a Lua state
59  * \return number of values returned to Lua
60  *
61  * - Argument 1 (string): name of the task
62  * - Argument 2 (number): computation size
63  * - Argument 3 (number): communication size
64  * - Return value (task): the task created
65  *
66  * A Lua task is a regular table with a full userdata inside, and both share
67  * the same metatable. For the regular table, the metatable allows OO-style
68  * writing such as your_task:send(someone).
69  * For the userdata, the metatable is used to check its type.
70  */
71 static int l_task_new(lua_State* L)
72 {
73   XBT_DEBUG("Task new");
74   const char* name = luaL_checkstring(L, 1);
75   int comp_size = luaL_checkint(L, 2);
76   int msg_size = luaL_checkint(L, 3);
77                                   /* name comp comm */
78   lua_settop(L, 0);
79                                   /* -- */
80   m_task_t msg_task = MSG_task_create(name, comp_size, msg_size, NULL);
81
82   lua_newtable(L);
83                                   /* task */
84   luaL_getmetatable(L, TASK_MODULE_NAME);
85                                   /* task mt */
86   lua_setmetatable(L, -2);
87                                   /* task */
88   m_task_t* lua_task = (m_task_t*) lua_newuserdata(L, sizeof(m_task_t));
89                                   /* task ctask */
90   *lua_task = msg_task;
91   luaL_getmetatable(L, TASK_MODULE_NAME);
92                                   /* task ctask mt */
93   lua_setmetatable(L, -2);
94                                   /* task ctask */
95   lua_setfield(L, -2, "__simgrid_task");
96                                   /* task */
97   return 1;
98 }
99
100 /**
101  * \brief Returns the name of a task.
102  * \param L a Lua state
103  * \return number of values returned to Lua
104  *
105  * - Argument 1 (task): a task
106  * - Return value (string): name of the task
107  */
108 static int l_task_get_name(lua_State* L)
109 {
110   m_task_t task = sglua_checktask(L, 1);
111   lua_pushstring(L, MSG_task_get_name(task));
112   return 1;
113 }
114
115 /**
116  * \brief Returns the computation duration of a task.
117  * \param L a Lua state
118  * \return number of values returned to Lua
119  *
120  * - Argument 1 (task): a task
121  * - Return value (number): computation duration of this task
122  */
123 static int l_task_get_computation_duration(lua_State* L)
124 {
125   m_task_t task = sglua_checktask(L, 1);
126   lua_pushnumber(L, MSG_task_get_compute_duration(task));
127   return 1;
128 }
129
130 /**
131  * \brief Executes a task.
132  * \param L a Lua state
133  * \return number of values returned to Lua
134  *
135  * - Argument 1 (task): the task to execute
136  * - Return value (number): error code
137  */
138 static int l_task_execute(lua_State* L)
139 {
140   m_task_t task = sglua_checktask(L, 1);
141   int res = MSG_task_execute(task);
142   lua_pushnumber(L, res);
143   return 1;
144 }
145
146 /**
147  * \brief Sends a task to a mailbox and waits for its completion.
148  * \param L a Lua state
149  * \return number of values returned to Lua
150  *
151  * - Argument 1 (task): the task to send
152  * - Argument 2 (string): mailbox
153  */
154 static int l_task_send(lua_State* L)
155 {
156   m_task_t task = sglua_checktask(L, 1);
157   const char* mailbox = luaL_checkstring(L, 2);
158                                   /* task mailbox */
159   lua_settop(L, 1);
160                                   /* task */
161   /* copy my stack into the task, so that the receiver can copy the lua task */
162   MSG_task_set_data(task, L);
163   MSG_error_t res = MSG_task_send(task, mailbox);
164   while (MSG_task_get_data(task) != NULL) {
165     /* don't mess up with my stack: the receiver didn't copy the data yet */
166     MSG_process_sleep(0);
167   }
168
169   if (res == MSG_OK) {
170     /* the receiver is the owner of the task and may destroy it:
171      * remove the C task on my side so that I don't garbage collect it */
172     lua_getfield(L, 1, "__simgrid_task");
173                                   /* task ctask */
174     m_task_t* udata = (m_task_t*) luaL_checkudata(L, -1, TASK_MODULE_NAME);
175     *udata = NULL;
176     lua_pop(L, 1);
177                                   /* task */
178   }
179   else {
180     switch (res) {
181     case MSG_TIMEOUT:
182       XBT_DEBUG("MSG_task_send failed : Timeout");
183       break;
184     case MSG_TRANSFER_FAILURE:
185       XBT_DEBUG("MSG_task_send failed : Transfer Failure");
186       break;
187     case MSG_HOST_FAILURE:
188       XBT_DEBUG("MSG_task_send failed : Host Failure ");
189       break;
190     default:
191       XBT_ERROR
192           ("MSG_task_send failed : Unexpected error , please report this bug");
193       break;
194     }
195   }
196   return 0;
197 }
198
199 /**
200  * \brief Receives a task.
201  * \param L a Lua state
202  * \return number of values returned to Lua
203  *
204  * - Argument 1 (string): mailbox
205  * - Argument 2 (number, optional): timeout (default is no timeout)
206  * - Return value (task/nil): the task received or nil if the communication
207  * has failed
208  */
209 static int l_task_recv(lua_State *L)
210 {
211   m_task_t task = NULL;
212   const char* mailbox = luaL_checkstring(L, 1);
213   int timeout;
214   if (lua_gettop(L) >= 2) {
215                                   /* mailbox timeout */
216     timeout = luaL_checknumber(L, 2);
217   }
218   else {
219                                   /* mailbox */
220     timeout = -1;
221     /* no timeout by default */
222   }
223   lua_settop(L, 0);
224                                   /* -- */
225   MSG_error_t res = MSG_task_receive_with_timeout(&task, mailbox, timeout);
226
227   if (res == MSG_OK) {
228     /* copy the data directly from sender's stack */
229     lua_State* sender_stack = MSG_task_get_data(task);
230     sglua_copy_value(sender_stack, L);
231                                   /* task */
232     MSG_task_set_data(task, NULL);
233   }
234   else {
235     switch (res) {
236     case MSG_TIMEOUT:
237       XBT_DEBUG("MSG_task_receive failed : Timeout");
238       break;
239     case MSG_TRANSFER_FAILURE:
240       XBT_DEBUG("MSG_task_receive failed : Transfer Failure");
241       break;
242     case MSG_HOST_FAILURE:
243       XBT_DEBUG("MSG_task_receive failed : Host Failure ");
244       break;
245     default:
246       XBT_ERROR("MSG_task_receive failed : Unexpected error , please report this bug");
247       break;
248     }
249     lua_pushnil(L);
250                                   /* nil */
251   }
252                                   /* task/nil */
253   return 1;
254 }
255
256 static const luaL_reg task_functions[] = {
257   {"new", l_task_new},
258   {"get_name", l_task_get_name},
259   {"get_computation_duration", l_task_get_computation_duration},
260   {"execute", l_task_execute},
261   {"send", l_task_send},
262   {"recv", l_task_recv},
263   {NULL, NULL}
264 };
265
266 /**
267  * \brief Finalizes the userdata of a task.
268  * \param L a Lua state
269  * \return number of values returned to Lua
270  *
271  * - Argument 1 (userdata): a C task, possibly NULL if it was sent to another
272  * Lua state
273  */
274 static int l_task_gc(lua_State* L)
275 {
276                                   /* ctask */
277   m_task_t task = *((m_task_t*) luaL_checkudata(L, 1, TASK_MODULE_NAME));
278   /* the task is NULL if I sent it to someone else */
279   if (task != NULL) {
280     MSG_task_destroy(task);
281   }
282   return 0;
283 }
284
285 /**
286  * \brief Returns a string representation of a C task.
287  * \param L a Lua state
288  * \return number of values returned to Lua
289  *
290  * - Argument 1 (userdata): a task
291  * - Return value (string): a string describing this task
292  */
293 static int l_task_tostring(lua_State* L)
294 {
295   m_task_t task = *((m_task_t*) luaL_checkudata(L, 1, TASK_MODULE_NAME));
296   lua_pushfstring(L, "Task: %p", task);
297   return 1;
298 }
299
300 /**
301  * \brief Metamethods of both a task table and the userdata inside it.
302  */
303 static const luaL_reg task_meta[] = {
304   {"__gc", l_task_gc}, /* will be called only for userdata */
305   {"__tostring", l_task_tostring},
306   {NULL, NULL}
307 };
308
309 /* ********************************************************************************* */
310 /*                                simgrid.host API                                   */
311 /* ********************************************************************************* */
312
313 /**
314  * \brief Ensures that a value in the stack is a host and returns it.
315  * \param L a Lua state
316  * \param index an index in the Lua stack
317  * \return the C host corresponding to this Lua host
318  */
319 static m_host_t sglua_checkhost(lua_State * L, int index)
320 {
321   m_host_t *pi, ht;
322   luaL_checktype(L, index, LUA_TTABLE);
323   lua_getfield(L, index, "__simgrid_host");
324   pi = (m_host_t *) luaL_checkudata(L, lua_gettop(L), HOST_MODULE_NAME);
325   if (pi == NULL)
326     luaL_typerror(L, index, HOST_MODULE_NAME);
327   ht = *pi;
328   if (!ht)
329     luaL_error(L, "null Host");
330   lua_pop(L, 1);
331   return ht;
332 }
333
334 /**
335  * \brief Returns a host given its name.
336  * \param L a Lua state
337  * \return number of values returned to Lua
338  *
339  * - Argument 1 (string): name of a host
340  * - Return value (host): the corresponding host
341  */
342 static int l_host_get_by_name(lua_State * L)
343 {
344   const char *name = luaL_checkstring(L, 1);
345   XBT_DEBUG("Getting Host from name...");
346   m_host_t msg_host = MSG_get_host_by_name(name);
347   if (!msg_host) {
348     luaL_error(L, "null Host : MSG_get_host_by_name failed");
349   }
350   lua_newtable(L);              /* create a table, put the userdata on top of it */
351   m_host_t *lua_host = (m_host_t *) lua_newuserdata(L, sizeof(m_host_t));
352   *lua_host = msg_host;
353   luaL_getmetatable(L, HOST_MODULE_NAME);
354   lua_setmetatable(L, -2);
355   lua_setfield(L, -2, "__simgrid_host");        /* put the userdata as field of the table */
356   /* remove the args from the stack */
357   lua_remove(L, 1);
358   return 1;
359 }
360
361 /**
362  * \brief Returns the name of a host.
363  * \param L a Lua state
364  * \return number of values returned to Lua
365  *
366  * - Argument 1 (host): a host
367  * - Return value (string): name of this host
368  */
369 static int l_host_get_name(lua_State * L)
370 {
371   m_host_t ht = sglua_checkhost(L, 1);
372   lua_pushstring(L, MSG_host_get_name(ht));
373   return 1;
374 }
375
376 /**
377  * \brief Returns the number of existing hosts.
378  * \param L a Lua state
379  * \return number of values returned to Lua
380  *
381  * - Return value (number): number of hosts
382  */
383 static int l_host_number(lua_State * L)
384 {
385   lua_pushnumber(L, MSG_get_host_number());
386   return 1;
387 }
388
389 /**
390  * \brief Returns the host given its index.
391  * \param L a Lua state
392  * \return number of values returned to Lua
393  *
394  * - Argument 1 (number): an index (1 is the first)
395  * - Return value (host): the host at this index
396  */
397 static int l_host_at(lua_State * L)
398 {
399   int index = luaL_checkinteger(L, 1);
400   m_host_t host = MSG_get_host_table()[index - 1];      // lua indexing start by 1 (lua[1] <=> C[0])
401   lua_newtable(L);              /* create a table, put the userdata on top of it */
402   m_host_t *lua_host = (m_host_t *) lua_newuserdata(L, sizeof(m_host_t));
403   *lua_host = host;
404   luaL_getmetatable(L, HOST_MODULE_NAME);
405   lua_setmetatable(L, -2);
406   lua_setfield(L, -2, "__simgrid_host");        /* put the userdata as field of the table */
407   return 1;
408 }
409
410 /**
411  * \brief Returns the host where the current process is located.
412  * \param L a Lua state
413  * \return number of values returned to Lua
414  *
415  * - Return value (host): the current host
416  */
417 static int l_host_self(lua_State * L)
418 {
419                                   /* -- */
420   m_host_t host = MSG_host_self();
421   lua_newtable(L);
422                                   /* table */
423   m_host_t* lua_host = (m_host_t*) lua_newuserdata(L, sizeof(m_host_t));
424                                   /* table ud */
425   *lua_host = host;
426   luaL_getmetatable(L, HOST_MODULE_NAME);
427                                   /* table ud mt */
428   lua_setmetatable(L, -2);
429                                   /* table ud */
430   lua_setfield(L, -2, "__simgrid_host");
431                                   /* table */
432   return 1;
433 }
434
435 /**
436  * \brief Returns the value of a host property.
437  * \param L a Lua state
438  * \return number of values returned to Lua
439  *
440  * - Argument 1 (host): a host
441  * - Argument 2 (string): name of the property to get
442  * - Return value (string): the value of this property
443  */
444 static int l_host_get_property_value(lua_State * L)
445 {
446   m_host_t ht = sglua_checkhost(L, 1);
447   const char *prop = luaL_checkstring(L, 2);
448   lua_pushstring(L,MSG_host_get_property_value(ht,prop));
449   return 1;
450 }
451
452 /**
453  * \brief Makes the current process sleep for a while.
454  * \param L a Lua state
455  * \return number of values returned to Lua
456  *
457  * - Argument 1 (number): duration of the sleep
458  */
459 static int l_host_sleep(lua_State *L)
460 {
461   int time = luaL_checknumber(L, 1);
462   MSG_process_sleep(time);
463   return 0;
464 }
465
466 /**
467  * \brief Destroys a host.
468  * \param L a Lua state
469  * \return number of values returned to Lua
470  *
471  * - Argument 1 (host): the host to destroy
472  */
473 static int l_host_destroy(lua_State *L)
474 {
475   m_host_t ht = sglua_checkhost(L, 1);
476   __MSG_host_destroy(ht);
477   return 0;
478 }
479
480 static const luaL_reg host_functions[] = {
481   {"get_by_name", l_host_get_by_name},
482   {"name", l_host_get_name},
483   {"number", l_host_number},
484   {"at", l_host_at},
485   {"self", l_host_self},
486   {"get_prop_value", l_host_get_property_value},
487   {"sleep", l_host_sleep},
488   {"destroy", l_host_destroy},
489   // Bypass XML Methods
490   {"set_function", console_set_function},
491   {"set_property", console_host_set_property},
492   {NULL, NULL}
493 };
494
495 /**
496  * \brief Returns a string representation of a host.
497  * \param L a Lua state
498  * \return number of values returned to Lua
499  *
500  * - Argument 1 (userdata): a host
501  * - Return value (string): a string describing this host
502  */
503 static int l_host_tostring(lua_State * L)
504 {
505   lua_pushfstring(L, "Host :%p", lua_touserdata(L, 1));
506   return 1;
507 }
508
509 static const luaL_reg host_meta[] = {
510   {"__tostring", l_host_tostring},
511   {0, 0}
512 };
513
514 /* ********************************************************************************* */
515 /*                           lua_stub_generator functions                            */
516 /* ********************************************************************************* */
517
518 xbt_dict_t process_function_set;
519 xbt_dynar_t process_list;
520 xbt_dict_t machine_set;
521 static s_process_t process;
522
523 void s_process_free(void *process)
524 {
525   s_process_t *p = (s_process_t *) process;
526   int i;
527   for (i = 0; i < p->argc; i++)
528     free(p->argv[i]);
529   free(p->argv);
530   free(p->host);
531 }
532
533 static int gras_add_process_function(lua_State * L)
534 {
535   const char *arg;
536   const char *process_host = luaL_checkstring(L, 1);
537   const char *process_function = luaL_checkstring(L, 2);
538
539   if (xbt_dict_is_empty(machine_set)
540       || xbt_dict_is_empty(process_function_set)
541       || xbt_dynar_is_empty(process_list)) {
542     process_function_set = xbt_dict_new();
543     process_list = xbt_dynar_new(sizeof(s_process_t), s_process_free);
544     machine_set = xbt_dict_new();
545   }
546
547   xbt_dict_set(machine_set, process_host, NULL, NULL);
548   xbt_dict_set(process_function_set, process_function, NULL, NULL);
549
550   process.argc = 1;
551   process.argv = xbt_new(char *, 1);
552   process.argv[0] = xbt_strdup(process_function);
553   process.host = strdup(process_host);
554
555   lua_pushnil(L);
556   while (lua_next(L, 3) != 0) {
557     arg = lua_tostring(L, -1);
558     process.argc++;
559     process.argv =
560         xbt_realloc(process.argv, (process.argc) * sizeof(char *));
561     process.argv[(process.argc) - 1] = xbt_strdup(arg);
562
563     XBT_DEBUG("index = %f , arg = %s \n", lua_tonumber(L, -2),
564            lua_tostring(L, -1));
565     lua_pop(L, 1);
566   }
567   lua_pop(L, 1);
568   //add to the process list
569   xbt_dynar_push(process_list, &process);
570   return 0;
571 }
572
573 static int gras_generate(lua_State * L)
574 {
575   const char *project_name = luaL_checkstring(L, 1);
576   generate_sim(project_name);
577   generate_rl(project_name);
578   generate_makefile_local(project_name);
579   return 0;
580 }
581
582 /* ********************************************************************************* */
583 /*                               simgrid.platf API                                   */
584 /* ********************************************************************************* */
585
586 static const luaL_reg platf_functions[] = {
587     {"open", console_open},
588     {"close", console_close},
589     {"AS_open", console_AS_open},
590     {"AS_close", console_AS_close},
591     {"host_new", console_add_host},
592     {"link_new", console_add_link},
593     {"router_new", console_add_router},
594     {"route_new", console_add_route},
595     {NULL, NULL}
596 };
597
598 /* ********************************************************************************* */
599 /*                                  simgrid API                                      */
600 /* ********************************************************************************* */
601
602 /**
603  * \brief Deploys your application.
604  * \param L a Lua state
605  * \return number of values returned to Lua
606  *
607  * - Argument 1 (string): name of the deployment file to load
608  */
609 static int launch_application(lua_State * L)
610 {
611   const char *file = luaL_checkstring(L, 1);
612   MSG_function_register_default(run_lua_code);
613   MSG_launch_application(file);
614   return 0;
615 }
616
617 /**
618  * \brief Creates the platform.
619  * \param L a Lua state
620  * \return number of values returned to Lua
621  *
622  * - Argument 1 (string): name of the platform file to load
623  */
624 static int create_environment(lua_State * L)
625 {
626   const char *file = luaL_checkstring(L, 1);
627   XBT_DEBUG("Loading environment file %s", file);
628   MSG_create_environment(file);
629   return 0;
630 }
631
632 /**
633  * \brief Prints a log string with debug level.
634  * \param L a Lua state
635  * \return number of values returned to Lua
636  *
637  * - Argument 1 (string): the text to print
638  */
639 static int debug(lua_State * L)
640 {
641   const char *str = luaL_checkstring(L, 1);
642   XBT_DEBUG("%s", str);
643   return 0;
644 }
645
646 /**
647  * \brief Prints a log string with info level.
648  * \param L a Lua state
649  * \return number of values returned to Lua
650  *
651  * - Argument 1 (string): the text to print
652  */
653 static int info(lua_State * L)
654 {
655   const char *str = luaL_checkstring(L, 1);
656   XBT_INFO("%s", str);
657   return 0;
658 }
659
660 /**
661  * \brief Runs your application.
662  * \param L a Lua state
663  * \return number of values returned to Lua
664  */
665 static int run(lua_State * L)
666 {
667   MSG_main();
668   return 0;
669 }
670
671 /**
672  * \brief Cleans the simulation.
673  * \param L a Lua state
674  * \return number of values returned to Lua
675  */
676 static int simgrid_gc(lua_State * L)
677 {
678   MSG_clean();
679   return 0;
680 }
681
682 /*
683  * Register platform for MSG
684  */
685 static int msg_register_platform(lua_State * L)
686 {
687   /* Tell Simgrid we dont wanna use its parser */
688   //surf_parse = console_parse_platform;
689   surf_parse_reset_callbacks();
690   MSG_create_environment(NULL);
691   return 0;
692 }
693
694 /*
695  * Register platform for Simdag
696  */
697
698 static int sd_register_platform(lua_State * L)
699 {
700   //surf_parse = console_parse_platform_wsL07;
701   surf_parse_reset_callbacks();
702   SD_create_environment(NULL);
703   return 0;
704 }
705
706 /*
707  * Register platform for gras
708  */
709 static int gras_register_platform(lua_State * L)
710 {
711   //surf_parse = console_parse_platform;
712   surf_parse_reset_callbacks();
713   gras_create_environment(NULL);
714   return 0;
715 }
716
717 /**
718  * Register applicaiton for MSG
719  */
720 static int msg_register_application(lua_State * L)
721 {
722   MSG_function_register_default(run_lua_code);
723   //surf_parse = console_parse_application;
724   MSG_launch_application(NULL);
725   return 0;
726 }
727
728 /*
729  * Register application for gras
730  */
731 static int gras_register_application(lua_State * L)
732 {
733   gras_function_register_default(run_lua_code);
734   //surf_parse = console_parse_application;
735   gras_launch_application(NULL);
736   return 0;
737 }
738
739 static const luaL_Reg simgrid_functions[] = {
740   {"create_environment", create_environment},
741   {"launch_application", launch_application},
742   {"debug", debug},
743   {"info", info},
744   {"run", run},
745   /* short names */
746   {"platform", create_environment},
747   {"application", launch_application},
748   /* methods to bypass XML parser */
749   {"msg_register_platform", msg_register_platform},
750   {"sd_register_platform", sd_register_platform},
751   {"msg_register_application", msg_register_application},
752   {"gras_register_platform", gras_register_platform},
753   {"gras_register_application", gras_register_application},
754   /* gras sub generator method */
755   {"gras_set_process_function", gras_add_process_function},
756   {"gras_generate", gras_generate},
757   {NULL, NULL}
758 };
759
760 /* ********************************************************************************* */
761 /*                           module management functions                             */
762 /* ********************************************************************************* */
763
764 #define LUA_MAX_ARGS_COUNT 10   /* maximum amount of arguments we can get from lua on command line */
765
766 /**
767  * \brief Opens the simgrid Lua module.
768  *
769  * This function is called automatically by the Lua interpreter when some
770  * Lua code requires the "simgrid" module.
771  *
772  * \param L the Lua state
773  */
774 int luaopen_simgrid(lua_State *L)
775 {
776   XBT_DEBUG("luaopen_simgrid *****");
777
778   /* Get the command line arguments from the lua interpreter */
779   char **argv = malloc(sizeof(char *) * LUA_MAX_ARGS_COUNT);
780   int argc = 1;
781   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? */
782
783   lua_getglobal(L, "arg");
784   /* if arg is a null value, it means we use lua only as a script to init platform
785    * else it should be a table and then take arg in consideration
786    */
787   if (lua_istable(L, -1)) {
788     int done = 0;
789     while (!done) {
790       argc++;
791       lua_pushinteger(L, argc - 2);
792       lua_gettable(L, -2);
793       if (lua_isnil(L, -1)) {
794         done = 1;
795       } else {
796         xbt_assert(lua_isstring(L, -1),
797                     "argv[%d] got from lua is no string", argc - 1);
798         xbt_assert(argc < LUA_MAX_ARGS_COUNT,
799                     "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",
800                     __FILE__, LUA_MAX_ARGS_COUNT - 1);
801         argv[argc - 1] = (char *) luaL_checkstring(L, -1);
802         lua_pop(L, 1);
803         XBT_DEBUG("Got command line argument %s from lua", argv[argc - 1]);
804       }
805     }
806     argv[argc--] = NULL;
807
808     /* Initialize the MSG core */
809     MSG_global_init(&argc, argv);
810     XBT_DEBUG("Still %d arguments on command line", argc); // FIXME: update the lua's arg table to reflect the changes from SimGrid
811   }
812
813   /* Keep the context mechanism informed of our lua world today */
814   sglua_maestro_state = L;
815
816   /* initialize access to my tables by children Lua states */
817   lua_newtable(L);
818   lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.maestro_tables");
819
820   register_c_functions(L);
821
822   return 1;
823 }
824
825 /**
826  * \brief Returns whether a Lua state is the maestro state.
827  * \param L a Lua state
828  * \return true if this is maestro
829  */
830 int sglua_is_maestro(lua_State* L) {
831   return L == sglua_maestro_state;
832 }
833
834 /**
835  * \brief Returns the maestro state.
836  * \return the maestro Lua state
837  */
838 lua_State* sglua_get_maestro(void) {
839   return sglua_maestro_state;
840 }
841
842 /**
843  * \brief Registers the task functions into the table simgrid.task.
844  *
845  * Also initialize the metatable of the task userdata type.
846  *
847  * \param L a lua state
848  */
849 static void register_task_functions(lua_State* L)
850 {
851   /* create a table simgrid.task and fill it with task functions */
852   luaL_openlib(L, TASK_MODULE_NAME, task_functions, 0);
853                                   /* simgrid.task */
854
855   /* create the metatable for tasks, add it to the Lua registry */
856   luaL_newmetatable(L, TASK_MODULE_NAME);
857                                   /* simgrid.task mt */
858   /* fill the metatable */
859   luaL_openlib(L, NULL, task_meta, 0);
860                                   /* simgrid.task mt */
861   lua_pushvalue(L, -2);
862                                   /* simgrid.task mt simgrid.task */
863   /* metatable.__index = simgrid.task
864    * we put the task functions inside the task itself:
865    * this allows to write task:method(args) for
866    * simgrid.task.method(task, args) */
867   lua_setfield(L, -2, "__index");
868                                   /* simgrid.task mt */
869   lua_pop(L, 2);
870                                   /* -- */
871 }
872
873 /**
874  * \brief Registers the host functions into the table simgrid.host.
875  *
876  * Also initialize the metatable of the host userdata type.
877  *
878  * \param L a lua state
879  */
880 static void register_host_functions(lua_State* L)
881 {
882   /* create a table simgrid.host and fill it with host functions */
883   luaL_openlib(L, HOST_MODULE_NAME, host_functions, 0);
884                                   /* simgrid.host */
885
886   /* create the metatable for host, add it to the Lua registry */
887   luaL_newmetatable(L, HOST_MODULE_NAME);
888                                   /* simgrid.host mt */
889   /* fill the metatable */
890   luaL_openlib(L, NULL, host_meta, 0);
891                                   /* simgrid.host mt */
892   lua_pushvalue(L, -2);
893                                   /* simgrid.host mt simgrid.host */
894   /* metatable.__index = simgrid.host
895    * we put the host functions inside the host userdata itself:
896    * this allows to write host(args) for
897    * simgrid.host.method(host, args) */
898   // FIXME: cannot work currently, same problem as tasks
899   lua_setfield(L, -2, "__index");
900                                   /* simgrid.host mt */
901   lua_pop(L, 2);
902                                   /* -- */
903 }
904
905 /**
906  * \brief Registers the platform functions into the table simgrid.platf.
907  * \param L a lua state
908  */
909 static void register_platf_functions(lua_State* L)
910 {
911   luaL_openlib(L, PLATF_MODULE_NAME, platf_functions, 0);
912                                   /* simgrid.platf */
913   lua_pop(L, 1);
914 }
915
916 /**
917  * \brief Makes the core functions available to the Lua world.
918  * \param L a Lua world
919  */
920 static void register_core_functions(lua_State *L)
921 {
922   /* register the core C functions to lua */
923   luaL_register(L, "simgrid", simgrid_functions);
924                                   /* simgrid */
925
926   /* set a finalizer that cleans simgrid, by adding to the simgrid module a
927    * dummy userdata whose __gc metamethod calls MSG_clean() */
928   lua_newuserdata(L, sizeof(void*));
929                                   /* simgrid udata */
930   lua_newtable(L);
931                                   /* simgrid udata mt */
932   lua_pushcfunction(L, simgrid_gc);
933                                   /* simgrid udata mt simgrid_gc */
934   lua_setfield(L, -2, "__gc");
935                                   /* simgrid udata mt */
936   lua_setmetatable(L, -2);
937                                   /* simgrid udata */
938   lua_setfield(L, -2, "__simgrid_loaded");
939                                   /* simgrid */
940   lua_pop(L, 1);
941                                   /* -- */
942 }
943
944 /**
945  * \brief Creates the simgrid module and make it available to Lua.
946  * \param L a Lua world
947  */
948 static void register_c_functions(lua_State *L)
949 {
950   register_core_functions(L);
951   register_task_functions(L);
952   register_host_functions(L);
953   register_platf_functions(L);
954 }
955
956 /**
957  * \brief Runs a Lua function as a new simulated process.
958  * \param argc number of arguments of the function
959  * \param argv name of the Lua function and array of its arguments
960  * \return result of the function
961  */
962 static int run_lua_code(int argc, char **argv)
963 {
964   XBT_DEBUG("Run lua code %s", argv[0]);
965
966   /* create a new state, getting globals from maestro */
967   lua_State *L = sglua_clone_maestro();
968   int res = 1;
969
970   /* start the function */
971   lua_getglobal(L, argv[0]);
972   xbt_assert(lua_isfunction(L, -1),
973               "There is no Lua function with name `%s'", argv[0]);
974
975   /* push arguments onto the stack */
976   int i;
977   for (i = 1; i < argc; i++)
978     lua_pushstring(L, argv[i]);
979
980   /* call the function */
981   _XBT_GNUC_UNUSED int err;
982   err = lua_pcall(L, argc - 1, 1, 0);
983   xbt_assert(err == 0, "Error running function `%s': %s", argv[0],
984               lua_tostring(L, -1));
985
986   /* retrieve result */
987   if (lua_isnumber(L, -1)) {
988     res = lua_tonumber(L, -1);
989     lua_pop(L, 1);              /* pop returned value */
990   }
991
992   XBT_DEBUG("Execution of Lua code %s is over", (argv ? argv[0] : "(null)"));
993
994   return res;
995 }