1 /* Copyright (c) 2010. The SimGrid Team.
2 * All rights reserved. */
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. */
7 /* SimGrid Lua bindings */
9 #include "simgrid_lua.h"
10 #include "lua_state_cloner.h"
11 #include "lua_utils.h"
13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua, bindings, "Lua Bindings");
15 static lua_State *lua_maestro_state;
17 #define TASK_MODULE_NAME "simgrid.Task"
18 #define HOST_MODULE_NAME "simgrid.Host"
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"
25 static void register_c_functions(lua_State *L);
27 static void *my_checkudata (lua_State *L, int ud, const char *tname) {
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);
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);
42 if (p == NULL || !lua_getmetatable(L, ud) || !lua_rawequal(L, -1, -2))
43 luaL_typerror(L, ud, tname);
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
55 static m_task_t checkTask(lua_State * L, int index)
58 XBT_DEBUG("Lua task: %s", sglua_tostring(L, index));
59 luaL_checktype(L, index, LUA_TTABLE);
60 lua_getfield(L, index, "__simgrid_task");
62 pi = (m_task_t *) luaL_checkudata(L, lua_gettop(L), TASK_MODULE_NAME);
65 luaL_typerror(L, index, TASK_MODULE_NAME);
68 luaL_error(L, "null Task");
73 /* ********************************************************************************* */
74 /* wrapper functions */
75 /* ********************************************************************************* */
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.
88 * @brief Constructs a new task with the specified processing amount and amount
91 * @param name Task's name
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.
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.
101 static int Task_new(lua_State * L)
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 */
121 static int Task_get_name(lua_State * L)
123 m_task_t tk = checkTask(L, -1);
124 lua_pushstring(L, MSG_task_get_name(tk));
128 static int Task_computation_duration(lua_State * L)
130 m_task_t tk = checkTask(L, -1);
131 lua_pushnumber(L, MSG_task_get_compute_duration(tk));
135 static int Task_execute(lua_State * L)
137 m_task_t tk = checkTask(L, -1);
138 int res = MSG_task_execute(tk);
139 lua_pushnumber(L, res);
143 static int Task_destroy(lua_State * L)
145 m_task_t tk = checkTask(L, -1);
146 int res = MSG_task_destroy(tk);
147 lua_pushnumber(L, res);
151 static int Task_send(lua_State * L)
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
165 XBT_DEBUG("MSG_task_send failed : Timeout");
167 case MSG_TRANSFER_FAILURE:
168 XBT_DEBUG("MSG_task_send failed : Transfer Failure");
170 case MSG_HOST_FAILURE:
171 XBT_DEBUG("MSG_task_send failed : Host Failure ");
175 ("MSG_task_send failed : Unexpected error , please report this bug");
181 static int Task_recv_with_timeout(lua_State *L)
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);
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);
196 XBT_DEBUG("MSG_task_receive failed : Timeout");
198 case MSG_TRANSFER_FAILURE:
199 XBT_DEBUG("MSG_task_receive failed : Transfer Failure");
201 case MSG_HOST_FAILURE:
202 XBT_DEBUG("MSG_task_receive failed : Host Failure ");
205 XBT_ERROR("MSG_task_receive failed : Unexpected error , please report this bug");
213 static int Task_recv(lua_State * L)
215 lua_pushnumber(L, -1.0);
216 return Task_recv_with_timeout(L);
219 static const luaL_reg Task_methods[] = {
221 {"name", Task_get_name},
222 {"computation_duration", Task_computation_duration},
223 {"execute", Task_execute},
224 {"destroy", Task_destroy},
227 {"recv_timeout", Task_recv_with_timeout},
231 static int Task_gc(lua_State * L)
233 m_task_t tk = checkTask(L, -1);
235 MSG_task_destroy(tk);
239 static int Task_tostring(lua_State * L)
241 lua_pushfstring(L, "Task :%p", lua_touserdata(L, 1));
245 static const luaL_reg Task_meta[] = {
247 {"__tostring", Task_tostring},
254 static m_host_t checkHost(lua_State * L, int index)
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);
261 luaL_typerror(L, index, HOST_MODULE_NAME);
264 luaL_error(L, "null Host");
269 static int Host_get_by_name(lua_State * L)
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);
275 luaL_error(L, "null Host : MSG_get_host_by_name failed");
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 */
288 static int Host_get_name(lua_State * L)
290 m_host_t ht = checkHost(L, -1);
291 lua_pushstring(L, MSG_host_get_name(ht));
295 static int Host_number(lua_State * L)
297 lua_pushnumber(L, MSG_get_host_number());
301 static int Host_at(lua_State * L)
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));
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 */
315 static int Host_self(lua_State * L)
318 m_host_t host = MSG_host_self();
321 m_host_t* lua_host = (m_host_t*) lua_newuserdata(L, sizeof(m_host_t));
324 luaL_getmetatable(L, HOST_MODULE_NAME);
326 lua_setmetatable(L, -2);
328 lua_setfield(L, -2, "__simgrid_host");
333 static int Host_get_property_value(lua_State * L)
335 m_host_t ht = checkHost(L, -2);
336 const char *prop = luaL_checkstring(L, -1);
337 lua_pushstring(L,MSG_host_get_property_value(ht,prop));
341 static int Host_sleep(lua_State *L)
343 int time = luaL_checknumber(L, -1);
344 MSG_process_sleep(time);
348 static int Host_destroy(lua_State *L)
350 m_host_t ht = checkHost(L, -1);
351 __MSG_host_destroy(ht);
355 /* ********************************************************************************* */
356 /* lua_stub_generator functions */
357 /* ********************************************************************************* */
359 xbt_dict_t process_function_set;
360 xbt_dynar_t process_list;
361 xbt_dict_t machine_set;
362 static s_process_t process;
364 void s_process_free(void *process)
366 s_process_t *p = (s_process_t *) process;
368 for (i = 0; i < p->argc; i++)
374 static int gras_add_process_function(lua_State * L)
377 const char *process_host = luaL_checkstring(L, 1);
378 const char *process_function = luaL_checkstring(L, 2);
380 if (xbt_dict_is_empty(machine_set)
381 || xbt_dict_is_empty(process_function_set)
382 || xbt_dynar_is_empty(process_list)) {
383 process_function_set = xbt_dict_new();
384 process_list = xbt_dynar_new(sizeof(s_process_t), s_process_free);
385 machine_set = xbt_dict_new();
388 xbt_dict_set(machine_set, process_host, NULL, NULL);
389 xbt_dict_set(process_function_set, process_function, NULL, NULL);
392 process.argv = xbt_new(char *, 1);
393 process.argv[0] = xbt_strdup(process_function);
394 process.host = strdup(process_host);
397 while (lua_next(L, 3) != 0) {
398 arg = lua_tostring(L, -1);
401 xbt_realloc(process.argv, (process.argc) * sizeof(char *));
402 process.argv[(process.argc) - 1] = xbt_strdup(arg);
404 XBT_DEBUG("index = %f , arg = %s \n", lua_tonumber(L, -2),
405 lua_tostring(L, -1));
409 //add to the process list
410 xbt_dynar_push(process_list, &process);
415 static int gras_generate(lua_State * L)
417 const char *project_name = luaL_checkstring(L, 1);
418 generate_sim(project_name);
419 generate_rl(project_name);
420 generate_makefile_local(project_name);
424 /***********************************
426 **********************************/
427 static int trace_start(lua_State *L)
435 static int trace_category(lua_State * L)
438 TRACE_category(luaL_checkstring(L, 1));
443 static int trace_set_task_category(lua_State *L)
446 TRACE_msg_set_task_category(checkTask(L, -2), luaL_checkstring(L, -1));
451 static int trace_end(lua_State *L)
459 // *********** Register Methods ******************************************* //
464 static const luaL_reg Host_methods[] = {
465 {"getByName", Host_get_by_name},
466 {"name", Host_get_name},
467 {"number", Host_number},
470 {"getPropValue", Host_get_property_value},
471 {"sleep", Host_sleep},
472 {"destroy", Host_destroy},
473 // Bypass XML Methods
474 {"setFunction", console_set_function},
475 {"setProperty", console_host_set_property},
479 static int Host_gc(lua_State * L)
481 m_host_t ht = checkHost(L, -1);
487 static int Host_tostring(lua_State * L)
489 lua_pushfstring(L, "Host :%p", lua_touserdata(L, 1));
493 static const luaL_reg Host_meta[] = {
495 {"__tostring", Host_tostring},
502 static const luaL_reg AS_methods[] = {
503 {"new", console_add_AS},
504 {"addHost", console_add_host},
505 {"addLink", console_add_link},
506 {"addRoute", console_add_route},
513 static const luaL_reg Trace_methods[] = {
514 {"start", trace_start},
515 {"category", trace_category},
516 {"setTaskCategory", trace_set_task_category},
517 {"finish", trace_end},
522 * Environment related
526 * @brief Runs a Lua function as a new simulated process.
527 * @param argc number of arguments of the function
528 * @param argv name of the Lua function and array of its arguments
529 * @return result of the function
531 static int run_lua_code(int argc, char **argv)
533 XBT_DEBUG("Run lua code %s", argv[0]);
535 lua_State *L = sglua_clone_maestro();
538 /* start the function */
539 lua_getglobal(L, argv[0]);
540 xbt_assert(lua_isfunction(L, -1),
541 "The lua function %s does not seem to exist", argv[0]);
543 /* push arguments onto the stack */
545 for (i = 1; i < argc; i++)
546 lua_pushstring(L, argv[i]);
548 /* call the function */
550 err = lua_pcall(L, argc - 1, 1, 0);
551 xbt_assert(err == 0, "error running function `%s': %s", argv[0],
552 lua_tostring(L, -1));
554 /* retrieve result */
555 if (lua_isnumber(L, -1)) {
556 res = lua_tonumber(L, -1);
557 lua_pop(L, 1); /* pop returned value */
560 XBT_DEBUG("Execution of Lua code %s is over", (argv ? argv[0] : "(null)"));
565 static int launch_application(lua_State * L)
567 const char *file = luaL_checkstring(L, 1);
568 MSG_function_register_default(run_lua_code);
569 MSG_launch_application(file);
573 static int create_environment(lua_State * L)
575 const char *file = luaL_checkstring(L, 1);
576 XBT_DEBUG("Loading environment file %s", file);
577 MSG_create_environment(file);
581 static int debug(lua_State * L)
583 const char *str = luaL_checkstring(L, 1);
584 XBT_DEBUG("%s", str);
588 static int info(lua_State * L)
590 const char *str = luaL_checkstring(L, 1);
595 static int run(lua_State * L)
601 static int clean(lua_State * L)
608 * Bypass XML Parser (lua console)
612 * Register platform for MSG
614 static int msg_register_platform(lua_State * L)
616 /* Tell Simgrid we dont wanna use its parser */
617 surf_parse = console_parse_platform;
618 surf_parse_reset_callbacks();
619 surf_config_models_setup(NULL);
620 MSG_create_environment(NULL);
625 * Register platform for Simdag
628 static int sd_register_platform(lua_State * L)
630 surf_parse = console_parse_platform_wsL07;
631 surf_parse_reset_callbacks();
632 surf_config_models_setup(NULL);
633 SD_create_environment(NULL);
638 * Register platform for gras
640 static int gras_register_platform(lua_State * L)
642 /* Tell Simgrid we dont wanna use surf parser */
643 surf_parse = console_parse_platform;
644 surf_parse_reset_callbacks();
645 surf_config_models_setup(NULL);
646 gras_create_environment(NULL);
651 * Register applicaiton for MSG
653 static int msg_register_application(lua_State * L)
655 MSG_function_register_default(run_lua_code);
656 surf_parse = console_parse_application;
657 MSG_launch_application(NULL);
662 * Register application for gras
664 static int gras_register_application(lua_State * L)
666 gras_function_register_default(run_lua_code);
667 surf_parse = console_parse_application;
668 gras_launch_application(NULL);
672 static const luaL_Reg simgrid_funcs[] = {
673 {"create_environment", create_environment},
674 {"launch_application", launch_application},
680 {"platform", create_environment},
681 {"application", launch_application},
682 /* methods to bypass XML parser */
683 {"msg_register_platform", msg_register_platform},
684 {"sd_register_platform", sd_register_platform},
685 {"msg_register_application", msg_register_application},
686 {"gras_register_platform", gras_register_platform},
687 {"gras_register_application", gras_register_application},
688 /* gras sub generator method */
689 {"gras_set_process_function", gras_add_process_function},
690 {"gras_generate", gras_generate},
694 /* ********************************************************************************* */
695 /* module management functions */
696 /* ********************************************************************************* */
698 #define LUA_MAX_ARGS_COUNT 10 /* maximum amount of arguments we can get from lua on command line */
700 int luaopen_simgrid(lua_State *L); // Fuck gcc: we don't need that prototype
703 * This function is called automatically by the Lua interpreter when some Lua code requires
704 * the "simgrid" module.
705 * @param L the Lua state
707 int luaopen_simgrid(lua_State *L)
709 XBT_DEBUG("luaopen_simgrid *****");
711 /* Get the command line arguments from the lua interpreter */
712 char **argv = malloc(sizeof(char *) * LUA_MAX_ARGS_COUNT);
714 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? */
716 lua_getglobal(L, "arg");
717 /* if arg is a null value, it means we use lua only as a script to init platform
718 * else it should be a table and then take arg in consideration
720 if (lua_istable(L, -1)) {
724 lua_pushinteger(L, argc - 2);
726 if (lua_isnil(L, -1)) {
729 xbt_assert(lua_isstring(L, -1),
730 "argv[%d] got from lua is no string", argc - 1);
731 xbt_assert(argc < LUA_MAX_ARGS_COUNT,
732 "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",
733 __FILE__, LUA_MAX_ARGS_COUNT - 1);
734 argv[argc - 1] = (char *) luaL_checkstring(L, -1);
736 XBT_DEBUG("Got command line argument %s from lua", argv[argc - 1]);
741 /* Initialize the MSG core */
742 MSG_global_init(&argc, argv);
743 XBT_DEBUG("Still %d arguments on command line", argc); // FIXME: update the lua's arg table to reflect the changes from SimGrid
746 /* Keep the context mechanism informed of our lua world today */
747 lua_maestro_state = L;
749 /* initialize access to my tables by children Lua states */
751 lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.maestro_tables");
753 register_c_functions(L);
759 * @brief Returns whether a Lua state is the maestro state.
760 * @param L a Lua state
761 * @return true if this is maestro
763 int sglua_is_maestro(lua_State* L) {
764 return L == lua_maestro_state;
768 * @brief Returns the maestro state.
769 * @return true the maestro Lua state
771 lua_State* sglua_get_maestro(void) {
772 return lua_maestro_state;
776 * Makes the appropriate Simgrid functions available to the Lua world.
777 * @param L a Lua world
779 void register_c_functions(lua_State *L) {
781 /* register the core C functions to lua */
782 luaL_register(L, "simgrid", simgrid_funcs);
784 /* register the task methods to lua */
785 luaL_openlib(L, TASK_MODULE_NAME, Task_methods, 0); // create methods table, add it to the globals
786 luaL_newmetatable(L, TASK_MODULE_NAME); // create metatable for Task, add it to the Lua registry
787 luaL_openlib(L, 0, Task_meta, 0); // fill metatable
788 lua_pushliteral(L, "__index");
789 lua_pushvalue(L, -3); // dup methods table
790 lua_rawset(L, -3); // matatable.__index = methods
791 lua_pushliteral(L, "__metatable");
792 lua_pushvalue(L, -3); // dup methods table
793 lua_rawset(L, -3); // hide metatable:metatable.__metatable = methods
794 lua_pop(L, 1); // drop metatable
796 /* register the hosts methods to lua */
797 luaL_openlib(L, HOST_MODULE_NAME, Host_methods, 0);
798 luaL_newmetatable(L, HOST_MODULE_NAME);
799 luaL_openlib(L, 0, Host_meta, 0);
800 lua_pushliteral(L, "__index");
801 lua_pushvalue(L, -3);
803 lua_pushliteral(L, "__metatable");
804 lua_pushvalue(L, -3);
808 /* register the links methods to lua */
809 luaL_openlib(L, AS_MODULE_NAME, AS_methods, 0);
810 luaL_newmetatable(L, AS_MODULE_NAME);
813 /* register the Tracing functions to lua */
814 luaL_openlib(L, TRACE_MODULE_NAME, Trace_methods, 0);
815 luaL_newmetatable(L, TRACE_MODULE_NAME);