X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c4ff2ceeaaa92102632d65d3eb609127955f2cc2..8b30afd41e2c22586e92ecbbfe124403fc861dd6:/src/bindings/lua/simgrid_lua.c diff --git a/src/bindings/lua/simgrid_lua.c b/src/bindings/lua/simgrid_lua.c index 744e24e19f..76a482e76e 100644 --- a/src/bindings/lua/simgrid_lua.c +++ b/src/bindings/lua/simgrid_lua.c @@ -1,86 +1,80 @@ -/* SimGrid Lua bindings */ - /* Copyright (c) 2010. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#include "simgrid_lua.h" - -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua, bindings, "Lua Bindings"); - -lua_State *simgrid_lua_state; -#define TASK_MODULE_NAME "simgrid.Task" -#define HOST_MODULE_NAME "simgrid.Host" -// Surf ( bypass XML ) -#define LINK_MODULE_NAME "simgrid.Link" -#define ROUTE_MODULE_NAME "simgrid.Route" -#define AS_MODULE_NAME "simgrid.AS" -#define TRACE_MODULE_NAME "simgrid.Trace" - -/* ********************************************************************************* */ -/* helper functions */ -/* ********************************************************************************* */ -static void stackDump(const char *msg, lua_State * L) -{ - char buff[2048]; - char *p = buff; - int i; - int top = lua_gettop(L); - - fflush(stdout); - p += sprintf(p, "STACK(top=%d): ", top); +/* SimGrid Lua bindings */ - for (i = 1; i <= top; i++) { /* repeat for each level */ - int t = lua_type(L, i); - switch (t) { +#include "simgrid_lua.h" +#include "lua_state_cloner.h" +#include "lua_utils.h" - case LUA_TSTRING: /* strings */ - p += sprintf(p, "`%s'", lua_tostring(L, i)); - break; +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua, bindings, "Lua Bindings"); - case LUA_TBOOLEAN: /* booleans */ - p += sprintf(p, lua_toboolean(L, i) ? "true" : "false"); - break; +#define TASK_MODULE_NAME "simgrid.task" +#define HOST_MODULE_NAME "simgrid.host" +// Surf (bypass XML) +#define LINK_MODULE_NAME "simgrid.link" +#define ROUTE_MODULE_NAME "simgrid.route" +#define PLATF_MODULE_NAME "simgrid.platf" - case LUA_TNUMBER: /* numbers */ - p += sprintf(p, "%g", lua_tonumber(L, i)); - break; +static lua_State* sglua_maestro_state; - case LUA_TTABLE: - p += sprintf(p, "Table"); - break; +static void register_c_functions(lua_State *L); - default: /* other values */ - p += sprintf(p, "???"); -/* if ((ptr = luaL_checkudata(L,i,TASK_MODULE_NAME))) { - p+=sprintf(p,"task"); - } else { - p+=printf(p,"%s", lua_typename(L, t)); - }*/ - break; - - } - p += sprintf(p, " "); /* put a separator */ +/** + * \brief Like luaL_checkudata, with additional debug logs. + * \param L a lua state + * \param ud index of the userdata to check in the stack + * \param tname key of the metatable of this userdata in the registry + */ +static void* my_checkudata(lua_State* L, int ud, const char* tname) { + + XBT_DEBUG("Checking the userdata: ud = %d", ud); + sglua_stack_dump("my_checkudata: ", L); + void* p = lua_touserdata(L, ud); + lua_getfield(L, LUA_REGISTRYINDEX, tname); + const void* correct_mt = lua_topointer(L, -1); + + int has_mt = lua_getmetatable(L, ud); + XBT_DEBUG("Checking the userdata: has metatable ? %d", has_mt); + const void* actual_mt = NULL; + if (has_mt) { + actual_mt = lua_topointer(L, -1); + lua_pop(L, 1); } - INFO2("%s%s", msg, buff); + XBT_DEBUG("Checking the task's metatable: expected %p, found %p", correct_mt, actual_mt); + sglua_stack_dump("my_checkudata: ", L); + + if (p == NULL || !lua_getmetatable(L, ud) || !lua_rawequal(L, -1, -2)) + luaL_typerror(L, ud, tname); + lua_pop(L, 2); + return p; } -/** @brief ensures that a userdata on the stack is a task and returns the pointer inside the userdata */ -static m_task_t checkTask(lua_State * L, int index) +/** + * @brief Ensures that a value is a valid task and returns it. + * @param L a Lua state + * @param index an index in the Lua stack + * @return the task at this index + */ +static m_task_t sglua_checktask(lua_State* L, int index) { - m_task_t *pi, tk; + sglua_stack_dump("check task: ", L); luaL_checktype(L, index, LUA_TTABLE); + /* ... task ... */ lua_getfield(L, index, "__simgrid_task"); - pi = (m_task_t *) luaL_checkudata(L, -1, TASK_MODULE_NAME); - if (pi == NULL) - luaL_typerror(L, index, TASK_MODULE_NAME); - tk = *pi; - if (!tk) - luaL_error(L, "null Task"); + /* ... task ... ctask */ + m_task_t task = *((m_task_t*) luaL_checkudata(L, -1, TASK_MODULE_NAME)); lua_pop(L, 1); - return tk; + /* ... task ... */ + + if (task == NULL) { + luaL_error(L, "This task was sent to someone else, you cannot access it anymore"); + } + + return task; } /* ********************************************************************************* */ @@ -88,177 +82,194 @@ static m_task_t checkTask(lua_State * L, int index) /* ********************************************************************************* */ /** - * A task is either something to compute somewhere, or something to exchange between two hosts (or both). - * It is defined by a computing amount and a message size. - * - */ - -/* * * * - * * Constructors * * - * * * */ -/** - * Construct an new task with the specified processing amount and amount - * of data needed. - * - * @param name Task's name - * - * @param computeDuration A value of the processing amount (in flop) needed to process the task. - * If 0, then it cannot be executed with the execute() method. - * This value has to be >= 0. + * \brief Creates a new task and leaves it onto the stack. * - * @param messageSize A value of amount of data (in bytes) needed to transfert this task. - * If 0, then it cannot be transfered with the get() and put() methods. - * This value has to be >= 0. + * Lua arguments: + * - task name (string) + * - computation size (integer) + * - communication size (integer) */ -static int Task_new(lua_State * L) +static int l_task_new(lua_State* L) { - const char *name = luaL_checkstring(L, 1); + XBT_DEBUG("Task new"); + const char* name = luaL_checkstring(L, 1); int comp_size = luaL_checkint(L, 2); int msg_size = luaL_checkint(L, 3); + /* name comp comm */ + lua_settop(L, 0); + /* -- */ m_task_t msg_task = MSG_task_create(name, comp_size, msg_size, NULL); - lua_newtable(L); /* create a table, put the userdata on top of it */ - m_task_t *lua_task = (m_task_t *) lua_newuserdata(L, sizeof(m_task_t)); + + lua_newtable(L); + /* task */ + m_task_t* lua_task = (m_task_t*) lua_newuserdata(L, sizeof(m_task_t)); + /* task ctask */ *lua_task = msg_task; luaL_getmetatable(L, TASK_MODULE_NAME); + /* task ctask mt */ lua_setmetatable(L, -2); - lua_setfield(L, -2, "__simgrid_task"); /* put the userdata as field of the table */ - /* remove the args from the stack */ - lua_remove(L, 1); - lua_remove(L, 1); - lua_remove(L, 1); + /* task ctask */ + lua_setfield(L, -2, "__simgrid_task"); + /* task */ return 1; } -static int Task_get_name(lua_State * L) +static int l_task_get_name(lua_State* L) { - m_task_t tk = checkTask(L, -1); - lua_pushstring(L, MSG_task_get_name(tk)); + m_task_t task = sglua_checktask(L, 1); + lua_pushstring(L, MSG_task_get_name(task)); return 1; } -static int Task_computation_duration(lua_State * L) +static int l_task_computation_duration(lua_State* L) { - m_task_t tk = checkTask(L, -1); - lua_pushnumber(L, MSG_task_get_compute_duration(tk)); - return 1; -} - -static int Task_execute(lua_State * L) -{ - m_task_t tk = checkTask(L, -1); - int res = MSG_task_execute(tk); - lua_pushnumber(L, res); + m_task_t task = sglua_checktask(L, 1); + lua_pushnumber(L, MSG_task_get_compute_duration(task)); return 1; } -static int Task_destroy(lua_State * L) +static int l_task_execute(lua_State* L) { - m_task_t tk = checkTask(L, -1); - int res = MSG_task_destroy(tk); + m_task_t task = sglua_checktask(L, 1); + int res = MSG_task_execute(task); lua_pushnumber(L, res); return 1; } -static int Task_send(lua_State * L) +static int l_task_send(lua_State* L) { - //stackDump("send ",L); - m_task_t tk = checkTask(L, -2); - const char *mailbox = luaL_checkstring(L, -1); - lua_pop(L, 1); // remove the string so that the task is on top of it - MSG_task_set_data(tk, L); // Copy my stack into the task, so that the receiver can copy the lua task directly - MSG_error_t res = MSG_task_send(tk, mailbox); - while (MSG_task_get_data(tk) != NULL) // Don't mess up with my stack: the receiver didn't copy the data yet - MSG_process_sleep(0); // yield + m_task_t task = sglua_checktask(L, 1); + const char* mailbox = luaL_checkstring(L, 2); + /* task mailbox */ + lua_settop(L, 1); + /* task */ + /* copy my stack into the task, so that the receiver can copy the lua task */ + MSG_task_set_data(task, L); + MSG_error_t res = MSG_task_send(task, mailbox); + while (MSG_task_get_data(task) != NULL) { + /* don't mess up with my stack: the receiver didn't copy the data yet */ + MSG_process_sleep(0); + } - if (res != MSG_OK) + if (res == MSG_OK) { + /* the receiver is the owner of the task and may destroy it: + * remove the C task on my side so that I don't garbage collect it */ + lua_getfield(L, 1, "__simgrid_task"); + /* task ctask */ + m_task_t* udata = (m_task_t*) luaL_checkudata(L, -1, TASK_MODULE_NAME); + *udata = NULL; + lua_pop(L, 1); + /* task */ + } + else { switch (res) { case MSG_TIMEOUT: - ERROR0("MSG_task_send failed : Timeout"); + XBT_DEBUG("MSG_task_send failed : Timeout"); break; case MSG_TRANSFER_FAILURE: - ERROR0("MSG_task_send failed : Transfer Failure"); + XBT_DEBUG("MSG_task_send failed : Transfer Failure"); break; case MSG_HOST_FAILURE: - ERROR0("MSG_task_send failed : Host Failure "); + XBT_DEBUG("MSG_task_send failed : Host Failure "); break; default: - ERROR0 + XBT_ERROR ("MSG_task_send failed : Unexpected error , please report this bug"); break; } + } return 0; } -static int Task_recv(lua_State * L) +static int l_task_recv_with_timeout(lua_State *L) { - m_task_t tk = NULL; - const char *mailbox = luaL_checkstring(L, -1); - MSG_error_t res = MSG_task_receive(&tk, mailbox); - - lua_State *sender_stack = MSG_task_get_data(tk); - lua_xmove(sender_stack, L, 1); // copy the data directly from sender's stack - MSG_task_set_data(tk, NULL); + m_task_t task = NULL; + const char* mailbox = luaL_checkstring(L, 1); + int timeout = luaL_checknumber(L, 2); + /* mailbox timeout */ + lua_settop(L, 0); + /* -- */ + MSG_error_t res = MSG_task_receive_with_timeout(&task, mailbox, timeout); - if (res != MSG_OK) + if (res == MSG_OK) { + /* copy the data directly from sender's stack */ + lua_State* sender_stack = MSG_task_get_data(task); + sglua_copy_value(sender_stack, L); + /* task */ + MSG_task_set_data(task, NULL); + } + else { switch (res) { case MSG_TIMEOUT: - ERROR0("MSG_task_receive failed : Timeout"); + XBT_DEBUG("MSG_task_receive failed : Timeout"); break; case MSG_TRANSFER_FAILURE: - ERROR0("MSG_task_receive failed : Transfer Failure"); + XBT_DEBUG("MSG_task_receive failed : Transfer Failure"); break; case MSG_HOST_FAILURE: - ERROR0("MSG_task_receive failed : Host Failure "); + XBT_DEBUG("MSG_task_receive failed : Host Failure "); break; default: - ERROR0 - ("MSG_task_receive failed : Unexpected error , please report this bug"); + XBT_ERROR("MSG_task_receive failed : Unexpected error , please report this bug"); break; } - + lua_pushnil(L); + /* nil */ + } + /* task/nil */ return 1; } -static const luaL_reg Task_methods[] = { - {"new", Task_new}, - {"name", Task_get_name}, - {"computation_duration", Task_computation_duration}, - {"execute", Task_execute}, - {"destroy", Task_destroy}, - {"send", Task_send}, - {"recv", Task_recv}, - {0, 0} +static int l_task_recv(lua_State * L) +{ + lua_pushnumber(L, -1.0); + return l_task_recv_with_timeout(L); +} + +static const luaL_reg task_functions[] = { + {"new", l_task_new}, + {"name", l_task_get_name}, + {"computation_duration", l_task_computation_duration}, + {"execute", l_task_execute}, + {"send", l_task_send}, + {"recv", l_task_recv}, + {"recv_timeout", l_task_recv_with_timeout}, + {NULL, NULL} }; -static int Task_gc(lua_State * L) +static int l_task_gc(lua_State* L) { - m_task_t tk = checkTask(L, -1); - if (tk) - MSG_task_destroy(tk); + /* ctask */ + m_task_t task = *((m_task_t*) luaL_checkudata(L, 1, TASK_MODULE_NAME)); + /* the task is NULL if I sent it to someone else */ + if (task != NULL) { + MSG_task_destroy(task); + } return 0; } -static int Task_tostring(lua_State * L) +static int l_task_tostring(lua_State* L) { - lua_pushfstring(L, "Task :%p", lua_touserdata(L, 1)); + m_task_t task = sglua_checktask(L, 1); + lua_pushfstring(L, "Task: %p", task); return 1; } -static const luaL_reg Task_meta[] = { - {"__gc", Task_gc}, - {"__tostring", Task_tostring}, - {0, 0} +static const luaL_reg task_meta[] = { + {"__gc", l_task_gc}, + {"__tostring", l_task_tostring}, + {NULL, NULL} }; /** * Host */ -static m_host_t checkHost(lua_State * L, int index) +static m_host_t sglua_checkhost(lua_State * L, int index) { m_host_t *pi, ht; luaL_checktype(L, index, LUA_TTABLE); lua_getfield(L, index, "__simgrid_host"); - pi = (m_host_t *) luaL_checkudata(L, -1, HOST_MODULE_NAME); + pi = (m_host_t *) luaL_checkudata(L, lua_gettop(L), HOST_MODULE_NAME); if (pi == NULL) luaL_typerror(L, index, HOST_MODULE_NAME); ht = *pi; @@ -268,13 +279,13 @@ static m_host_t checkHost(lua_State * L, int index) return ht; } -static int Host_get_by_name(lua_State * L) +static int l_host_get_by_name(lua_State * L) { const char *name = luaL_checkstring(L, 1); - DEBUG0("Getting Host from name..."); + XBT_DEBUG("Getting Host from name..."); m_host_t msg_host = MSG_get_host_by_name(name); if (!msg_host) { - luaL_error(L, "null Host : MSG_get_host_by_name failled"); + luaL_error(L, "null Host : MSG_get_host_by_name failed"); } lua_newtable(L); /* create a table, put the userdata on top of it */ m_host_t *lua_host = (m_host_t *) lua_newuserdata(L, sizeof(m_host_t)); @@ -287,21 +298,20 @@ static int Host_get_by_name(lua_State * L) return 1; } - -static int Host_get_name(lua_State * L) +static int l_host_get_name(lua_State * L) { - m_host_t ht = checkHost(L, -1); + m_host_t ht = sglua_checkhost(L, -1); lua_pushstring(L, MSG_host_get_name(ht)); return 1; } -static int Host_number(lua_State * L) +static int l_host_number(lua_State * L) { lua_pushnumber(L, MSG_get_host_number()); return 1; } -static int Host_at(lua_State * L) +static int l_host_at(lua_State * L) { int index = luaL_checkinteger(L, 1); m_host_t host = MSG_get_host_table()[index - 1]; // lua indexing start by 1 (lua[1] <=> C[0]) @@ -315,25 +325,44 @@ static int Host_at(lua_State * L) } -static int Host_self(lua_State * L) +static int l_host_self(lua_State * L) +{ + /* -- */ + m_host_t host = MSG_host_self(); + lua_newtable(L); + /* table */ + m_host_t* lua_host = (m_host_t*) lua_newuserdata(L, sizeof(m_host_t)); + /* table ud */ + *lua_host = host; + luaL_getmetatable(L, HOST_MODULE_NAME); + /* table ud mt */ + lua_setmetatable(L, -2); + /* table ud */ + lua_setfield(L, -2, "__simgrid_host"); + /* table */ + return 1; +} + +static int l_host_get_property_value(lua_State * L) { - m_host_t host = MSG_host_self(); - lua_newtable(L); - m_host_t *lua_host =(m_host_t *)lua_newuserdata(L,sizeof(m_host_t)); - *lua_host = host; - luaL_getmetatable(L, HOST_MODULE_NAME); - lua_setmetatable(L, -2); - lua_setfield(L, -2, "__simgrid_host"); - return 1; + m_host_t ht = sglua_checkhost(L, -2); + const char *prop = luaL_checkstring(L, -1); + lua_pushstring(L,MSG_host_get_property_value(ht,prop)); + return 1; +} +static int l_host_sleep(lua_State *L) +{ + int time = luaL_checknumber(L, -1); + MSG_process_sleep(time); + return 1; } -static int Host_get_property_value(lua_State * L) +static int l_host_destroy(lua_State *L) { - m_host_t ht = checkHost(L, -2); - const char *prop = luaL_checkstring(L, -1); - lua_pushstring(L,MSG_host_get_property_value(ht,prop)); - return 1; + m_host_t ht = sglua_checkhost(L, -1); + __MSG_host_destroy(ht); + return 1; } /* ********************************************************************************* */ @@ -385,16 +414,14 @@ static int gras_add_process_function(lua_State * L) xbt_realloc(process.argv, (process.argc) * sizeof(char *)); process.argv[(process.argc) - 1] = xbt_strdup(arg); - DEBUG2("index = %f , arg = %s \n", lua_tonumber(L, -2), + XBT_DEBUG("index = %f , arg = %s \n", lua_tonumber(L, -2), lua_tostring(L, -1)); lua_pop(L, 1); } lua_pop(L, 1); //add to the process list xbt_dynar_push(process_list, &process); - return 0; - } @@ -407,148 +434,94 @@ static int gras_generate(lua_State * L) return 0; } -/*********************************** - * Tracing - **********************************/ -static int trace_start(lua_State *L) -{ -#ifdef HAVE_TRACING - TRACE_start(); -#endif - return 1; -} -static int trace_category(lua_State * L) -{ -#ifdef HAVE_TRACING - TRACE_category(luaL_checkstring(L, 1)); -#endif - return 1; -} - -static int trace_set_task_category(lua_State *L) -{ -#ifdef HAVE_TRACING - TRACE_msg_set_task_category(checkTask(L, -2), luaL_checkstring(L, -1)); -#endif - return 1; -} +// *********** Register Methods ******************************************* // -static int trace_end(lua_State *L) -{ -#ifdef HAVE_TRACING - TRACE_end(); -#endif - return 1; -} -//***********Register Methods *******************************************// /* * Host Methods */ -static const luaL_reg Host_methods[] = { - {"getByName", Host_get_by_name}, - {"name", Host_get_name}, - {"number", Host_number}, - {"at", Host_at}, - {"self",Host_self}, - {"getPropValue",Host_get_property_value}, +static const luaL_reg host_functions[] = { + {"get_by_name", l_host_get_by_name}, + {"name", l_host_get_name}, + {"number", l_host_number}, + {"at", l_host_at}, + {"self", l_host_self}, + {"get_prop_value", l_host_get_property_value}, + {"sleep", l_host_sleep}, + {"destroy", l_host_destroy}, // Bypass XML Methods - {"new", console_add_host}, - {"setFunction", console_set_function}, - {0, 0} + {"set_function", console_set_function}, + {"set_property", console_host_set_property}, + {NULL, NULL} }; -static int Host_gc(lua_State * L) -{ - m_host_t ht = checkHost(L, -1); - if (ht) - ht = NULL; - return 0; -} - -static int Host_tostring(lua_State * L) +static int l_host_tostring(lua_State * L) { lua_pushfstring(L, "Host :%p", lua_touserdata(L, 1)); return 1; } -static const luaL_reg Host_meta[] = { - {"__gc", Host_gc}, - {"__tostring", Host_tostring}, +static const luaL_reg host_meta[] = { + {"__tostring", l_host_tostring}, {0, 0} }; /* * AS Methods */ -static const luaL_reg AS_methods[] = { - {"new", console_add_AS}, - {0, 0} -}; - - -/* - * Link Methods - */ -static const luaL_reg Link_methods[] = { - {"new", console_add_link}, - {0, 0} +static const luaL_reg platf_functions[] = { + {"open", console_open}, + {"close", console_close}, + {"AS_open", console_AS_open}, + {"AS_close", console_AS_close}, + {"host_new", console_add_host}, + {"link_new", console_add_link}, + {"router_new", console_add_router}, + {"route_new", console_add_route}, + {NULL, NULL} }; /* - * Route Methods + * Environment related */ -static const luaL_reg Route_methods[] = { - {"new", console_add_route}, - {0, 0} -}; /** - * Tracing Functions - */ -static const luaL_reg Trace_methods[] = { - {"start",trace_start}, - {"category",trace_category}, - {"setTaskCategory",trace_set_task_category}, - {"finish",trace_end}, - {0,0} -}; -/* - * Environment related + * @brief Runs a Lua function as a new simulated process. + * @param argc number of arguments of the function + * @param argv name of the Lua function and array of its arguments + * @return result of the function */ - -extern lua_State *simgrid_lua_state; - static int run_lua_code(int argc, char **argv) { - DEBUG1("Run lua code %s", argv[0]); - lua_State *L = lua_newthread(simgrid_lua_state); - int ref = luaL_ref(simgrid_lua_state, LUA_REGISTRYINDEX); // protect the thread from being garbage collected + XBT_DEBUG("Run lua code %s", argv[0]); + + lua_State *L = sglua_clone_maestro(); int res = 1; - /* Start the co-routine */ + /* start the function */ lua_getglobal(L, argv[0]); - xbt_assert1(lua_isfunction(L, -1), + xbt_assert(lua_isfunction(L, -1), "The lua function %s does not seem to exist", argv[0]); - // push arguments onto the stack + /* push arguments onto the stack */ int i; for (i = 1; i < argc; i++) lua_pushstring(L, argv[i]); - // Call the function (in resume) - xbt_assert2(lua_pcall(L, argc - 1, 1, 0) == 0, - "error running function `%s': %s", argv[0], lua_tostring(L, - -1)); + /* call the function */ + _XBT_GNUC_UNUSED int err; + err = lua_pcall(L, argc - 1, 1, 0); + xbt_assert(err == 0, "error running function `%s': %s", argv[0], + lua_tostring(L, -1)); /* retrieve result */ if (lua_isnumber(L, -1)) { res = lua_tonumber(L, -1); lua_pop(L, 1); /* pop returned value */ } - // cleanups - luaL_unref(simgrid_lua_state, LUA_REGISTRYINDEX, ref); - DEBUG1("Execution of lua code %s is over", (argv ? argv[0] : "(null)")); + + XBT_DEBUG("Execution of Lua code %s is over", (argv ? argv[0] : "(null)")); + return res; } @@ -560,38 +533,25 @@ static int launch_application(lua_State * L) return 0; } -#include "simix/simix.h" //FIXME: KILLME when debugging on simix internals become useless static int create_environment(lua_State * L) { const char *file = luaL_checkstring(L, 1); - DEBUG1("Loading environment file %s", file); + XBT_DEBUG("Loading environment file %s", file); MSG_create_environment(file); - -/* - xbt_dict_t hosts = SIMIX_host_get_dict(); - smx_host_t host; - xbt_dict_cursor_t c; - const char *name; - - xbt_dict_foreach(hosts, c, name, host) { - DEBUG1("We have an host %s", SIMIX_host_get_name(host)); - } -*/ - return 0; } static int debug(lua_State * L) { const char *str = luaL_checkstring(L, 1); - DEBUG1("%s", str); + XBT_DEBUG("%s", str); return 0; } static int info(lua_State * L) { const char *str = luaL_checkstring(L, 1); - INFO1("%s", str); + XBT_INFO("%s", str); return 0; } @@ -617,7 +577,8 @@ static int clean(lua_State * L) static int msg_register_platform(lua_State * L) { /* Tell Simgrid we dont wanna use its parser */ - surf_parse = console_parse_platform; + //surf_parse = console_parse_platform; + surf_parse_reset_callbacks(); MSG_create_environment(NULL); return 0; } @@ -628,7 +589,8 @@ static int msg_register_platform(lua_State * L) static int sd_register_platform(lua_State * L) { - surf_parse = console_parse_platform_wsL07; + //surf_parse = console_parse_platform_wsL07; + surf_parse_reset_callbacks(); SD_create_environment(NULL); return 0; } @@ -638,8 +600,8 @@ static int sd_register_platform(lua_State * L) */ static int gras_register_platform(lua_State * L) { - /* Tell Simgrid we dont wanna use surf parser */ - surf_parse = console_parse_platform; + //surf_parse = console_parse_platform; + surf_parse_reset_callbacks(); gras_create_environment(NULL); return 0; } @@ -650,7 +612,7 @@ static int gras_register_platform(lua_State * L) static int msg_register_application(lua_State * L) { MSG_function_register_default(run_lua_code); - surf_parse = console_parse_application; + //surf_parse = console_parse_application; MSG_launch_application(NULL); return 0; } @@ -661,12 +623,12 @@ static int msg_register_application(lua_State * L) static int gras_register_application(lua_State * L) { gras_function_register_default(run_lua_code); - surf_parse = console_parse_application; + //surf_parse = console_parse_application; gras_launch_application(NULL); return 0; } -static const luaL_Reg simgrid_funcs[] = { +static const luaL_Reg simgrid_functions[] = { {"create_environment", create_environment}, {"launch_application", launch_application}, {"debug", debug}, @@ -692,17 +654,24 @@ static const luaL_Reg simgrid_funcs[] = { /* module management functions */ /* ********************************************************************************* */ - #define LUA_MAX_ARGS_COUNT 10 /* maximum amount of arguments we can get from lua on command line */ -#define TEST -int luaopen_simgrid(lua_State * L); // Fuck gcc: we don't need that prototype -int luaopen_simgrid(lua_State * L) + +int luaopen_simgrid(lua_State *L); // Fuck gcc: we don't need that prototype + +/** + * This function is called automatically by the Lua interpreter when some Lua code requires + * the "simgrid" module. + * @param L the Lua state + */ +int luaopen_simgrid(lua_State *L) { + XBT_DEBUG("luaopen_simgrid *****"); + /* Get the command line arguments from the lua interpreter */ char **argv = malloc(sizeof(char *) * LUA_MAX_ARGS_COUNT); int argc = 1; 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? */ - /* Get the command line arguments from the lua interpreter */ + lua_getglobal(L, "arg"); /* if arg is a null value, it means we use lua only as a script to init platform * else it should be a table and then take arg in consideration @@ -716,40 +685,77 @@ int luaopen_simgrid(lua_State * L) if (lua_isnil(L, -1)) { done = 1; } else { - xbt_assert1(lua_isstring(L, -1), + xbt_assert(lua_isstring(L, -1), "argv[%d] got from lua is no string", argc - 1); - xbt_assert2(argc < LUA_MAX_ARGS_COUNT, + xbt_assert(argc < LUA_MAX_ARGS_COUNT, "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", __FILE__, LUA_MAX_ARGS_COUNT - 1); argv[argc - 1] = (char *) luaL_checkstring(L, -1); lua_pop(L, 1); - DEBUG1("Got command line argument %s from lua", argv[argc - 1]); + XBT_DEBUG("Got command line argument %s from lua", argv[argc - 1]); } } argv[argc--] = NULL; /* Initialize the MSG core */ MSG_global_init(&argc, argv); - DEBUG1("Still %d arguments on command line", argc); // FIXME: update the lua's arg table to reflect the changes from SimGrid + XBT_DEBUG("Still %d arguments on command line", argc); // FIXME: update the lua's arg table to reflect the changes from SimGrid } + + /* Keep the context mechanism informed of our lua world today */ + sglua_maestro_state = L; + + /* initialize access to my tables by children Lua states */ + lua_newtable(L); + lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.maestro_tables"); + + register_c_functions(L); + + return 1; +} + +/** + * @brief Returns whether a Lua state is the maestro state. + * @param L a Lua state + * @return true if this is maestro + */ +int sglua_is_maestro(lua_State* L) { + return L == sglua_maestro_state; +} + +/** + * @brief Returns the maestro state. + * @return true the maestro Lua state + */ +lua_State* sglua_get_maestro(void) { + return sglua_maestro_state; +} + +/** + * Makes the appropriate Simgrid functions available to the Lua world. + * @param L a Lua world + */ +void register_c_functions(lua_State *L) { + /* register the core C functions to lua */ - luaL_register(L, "simgrid", simgrid_funcs); + luaL_register(L, "simgrid", simgrid_functions); + /* register the task methods to lua */ - luaL_openlib(L, TASK_MODULE_NAME, Task_methods, 0); //create methods table,add it to the globals - luaL_newmetatable(L, TASK_MODULE_NAME); //create metatable for Task,add it to the Lua registry - luaL_openlib(L, 0, Task_meta, 0); // fill metatable + luaL_openlib(L, TASK_MODULE_NAME, task_functions, 0); // create methods table, add it to the globals + luaL_newmetatable(L, TASK_MODULE_NAME); // create metatable for Task, add it to the Lua registry + luaL_openlib(L, 0, task_meta, 0); // fill metatable lua_pushliteral(L, "__index"); - lua_pushvalue(L, -3); //dup methods table - lua_rawset(L, -3); //matatable.__index = methods + lua_pushvalue(L, -3); // dup methods table + lua_rawset(L, -3); // metatable.__index = methods lua_pushliteral(L, "__metatable"); - lua_pushvalue(L, -3); //dup methods table - lua_rawset(L, -3); //hide metatable:metatable.__metatable = methods - lua_pop(L, 1); //drop metatable + lua_pushvalue(L, -3); // dup methods table + lua_rawset(L, -3); // hide metatable:metatable.__metatable = methods + lua_pop(L, 1); // drop metatable /* register the hosts methods to lua */ - luaL_openlib(L, HOST_MODULE_NAME, Host_methods, 0); + luaL_openlib(L, HOST_MODULE_NAME, host_functions, 0); luaL_newmetatable(L, HOST_MODULE_NAME); - luaL_openlib(L, 0, Host_meta, 0); + luaL_openlib(L, 0, host_meta, 0); lua_pushliteral(L, "__index"); lua_pushvalue(L, -3); lua_rawset(L, -3); @@ -758,27 +764,8 @@ int luaopen_simgrid(lua_State * L) lua_rawset(L, -3); lua_pop(L, 1); - /* register the links methods to lua */ - luaL_openlib(L, AS_MODULE_NAME, AS_methods, 0); - luaL_newmetatable(L, AS_MODULE_NAME); - lua_pop(L, 1); - - /* register the links methods to lua */ - luaL_openlib(L, LINK_MODULE_NAME, Link_methods, 0); - luaL_newmetatable(L, LINK_MODULE_NAME); - lua_pop(L, 1); - - /*register the routes methods to lua */ - luaL_openlib(L, ROUTE_MODULE_NAME, Route_methods, 0); - luaL_newmetatable(L, ROUTE_MODULE_NAME); + /* register the platform methods to lua */ + luaL_openlib(L, PLATF_MODULE_NAME, platf_functions, 0); + luaL_newmetatable(L, PLATF_MODULE_NAME); lua_pop(L, 1); - - /*register the Tracing functions to lua */ - luaL_openlib(L, TRACE_MODULE_NAME, Trace_methods, 0); - luaL_newmetatable(L, TRACE_MODULE_NAME); - lua_pop(L, 1); - - /* Keep the context mechanism informed of our lua world today */ - simgrid_lua_state = L; - return 1; }