X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e7a674ab548877a615a048135694d7169da51212..83d441ea28abf1131b70319a5a59f53e59688497:/src/bindings/lua/simgrid_lua.c diff --git a/src/bindings/lua/simgrid_lua.c b/src/bindings/lua/simgrid_lua.c index c908712c06..330b99a287 100644 --- a/src/bindings/lua/simgrid_lua.c +++ b/src/bindings/lua/simgrid_lua.c @@ -6,74 +6,612 @@ /* 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" +#include // memcpy XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua, bindings, "Lua Bindings"); -lua_State *simgrid_lua_state; +static lua_State *lua_maestro_state; #define TASK_MODULE_NAME "simgrid.Task" #define HOST_MODULE_NAME "simgrid.Host" -// Surf ( bypass XML ) +// 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" +/** + * @brief A chunk of memory. + * + * TODO replace this by a dynar + */ +typedef struct s_buffer { + char* data; + size_t size; + size_t capacity; +} s_buffer_t, *buffer_t; + +static const char* value_tostring(lua_State* L, int index); +static const char* keyvalue_tostring(lua_State* L, int key_index, int value_index); +static void stack_dump(const char *msg, lua_State* L); +static int writer(lua_State* L, const void* source, size_t size, void* userdata); +static void move_value(lua_State* src, lua_State* dst); +static void move_value_impl(lua_State* src, lua_State* dst, const char* name); +static int l_get_from_father(lua_State* L); +static lua_State *clone_lua_state(lua_State* L); +static m_task_t check_task(lua_State *L, int index); +static void register_c_functions(lua_State *L); + /* ********************************************************************************* */ /* helper functions */ /* ********************************************************************************* */ -static void stackDump(const char *msg, lua_State * L) + +/** + * @brief Returns a string representation of a value in the Lua stack. + * + * This function is for debugging purposes. + * It always returns the same pointer. + * + * @param L the Lua state + * @param index index in the stack + * @return a string representation of the value at this index + */ +static const char* value_tostring(lua_State* L, int index) { + + static char buff[64]; + + switch (lua_type(L, index)) { + + case LUA_TNIL: + sprintf(buff, "nil"); + break; + + case LUA_TNUMBER: + sprintf(buff, "%.3f", lua_tonumber(L, index)); + break; + + case LUA_TBOOLEAN: + sprintf(buff, "%s", lua_toboolean(L, index) ? "true" : "false"); + break; + + case LUA_TSTRING: + snprintf(buff, 63, "'%s'", lua_tostring(L, index)); + break; + + case LUA_TFUNCTION: + if (lua_iscfunction(L, index)) { + sprintf(buff, "C-function"); + } + else { + sprintf(buff, "function"); + } + break; + + case LUA_TTABLE: + sprintf(buff, "table(%zu)", lua_objlen(L, index)); + break; + + case LUA_TLIGHTUSERDATA: + case LUA_TUSERDATA: + sprintf(buff, "userdata(%p)", lua_touserdata(L, index)); + break; + + case LUA_TTHREAD: + sprintf(buff, "thread"); + break; + } + return buff; +} + +/** + * @brief Returns a string representation of a key-value pair. + * + * This function is for debugging purposes. + * It always returns the same pointer. + * + * @param L the Lua state + * @param key_index index of the key + * @param value_index index of the value + * @return a string representation of the key-value pair + */ +static const char* keyvalue_tostring(lua_State* L, int key_index, int value_index) { + + static char buff[64]; + /* value_tostring also always returns the same pointer */ + int len = snprintf(buff, 63, "[%s] -> ", value_tostring(L, key_index)); + snprintf(buff + len, 63 - len, "%s", value_tostring(L, value_index)); + return buff; +} + +/** + * @brief Returns a string composed of the specified number of spaces. + * + * This function is for debugging purposes. + * It always returns the same pointer. + * + * @param length length of the string + * @return a string of this length with only spaces + */ +static const char* get_spaces(int length) { + + static char spaces[128]; + + xbt_assert(length < 128); + memset(spaces, ' ', length); + spaces[length] = '\0'; + return spaces; +} + +/** + * @brief Dumps the Lua stack if debug logs are enabled. + * @param msg a message to print + * @param L a Lua state + */ +static void stack_dump(const char* msg, lua_State* L) { - char buff[2048]; - char *p = buff; - int i; - int top = lua_gettop(L); + if (XBT_LOG_ISENABLED(lua, xbt_log_priority_debug)) { + char buff[2048]; + char* p = buff; + int i; + int top = lua_gettop(L); + + //if (1) return; + + fflush(stdout); + + p[0] = '\0'; + for (i = 1; i <= top; i++) { /* repeat for each level */ + + p += sprintf(p, "%s", value_tostring(L, i)); + p += sprintf(p, " "); /* put a separator */ + } + XBT_DEBUG("%s%s", msg, buff); + } +} + +/** + * @brief Writes the specified data into a memory buffer. + * + * This function is a valid lua_Writer that writes into a memory buffer passed + * as userdata. + * + * @param L a lua state + * @param source some data + * @param sz number of bytes of data + * @param user_data the memory buffer to write + */ +static int writer(lua_State* L, const void* source, size_t size, void* userdata) { - fflush(stdout); - p += sprintf(p, "STACK(top=%d): ", top); + buffer_t buffer = (buffer_t) userdata; + while (buffer->capacity < buffer->size + size) { + buffer->capacity *= 2; + buffer->data = xbt_realloc(buffer->data, buffer->capacity); + } + memcpy(buffer->data + buffer->size, source, size); + buffer->size += size; - for (i = 1; i <= top; i++) { /* repeat for each level */ - int t = lua_type(L, i); - switch (t) { + return 0; +} + +/** + * @brief Pops a value from a state and pushes it onto the stack of another + * state. + * + * @param src the source state + * @param dst the destination state + */ +static void move_value(lua_State* src, lua_State* dst) { + + if (src != dst) { + + /* create a list of visited tables at index 1 of dst */ + /* src: ... value + dst: ... */ + lua_newtable(dst); + /* dst: ... visited */ + lua_insert(dst, 1); + /* dst: visited ... */ + + move_value_impl(src, dst, value_tostring(src, -1)); + /* src: ... + dst: visited ... value */ + lua_remove(dst, 1); + /* dst: ... value */ + stack_dump("src after xmove: ", src); + stack_dump("dst after xmove: ", dst); + } +} - case LUA_TSTRING: /* strings */ - p += sprintf(p, "`%s'", lua_tostring(L, i)); +/** + * @brief Pops a value from the stack of a source state and pushes it on the + * stack of another state. + * + * If the value is a table, its content is copied recursively. To avoid cycles, + * a table of previously visited tables must be present at index 1 of dst. + * Its keys are pointers to visited tables in src and its values are the tables + * already built. + * + * TODO: add support of closures + * + * @param src the source state + * @param dst the destination state, with a list of visited tables at index 1 + * @param name a name describing the value + */ +static void move_value_impl(lua_State* src, lua_State *dst, const char* name) { + + luaL_checkany(src, -1); /* check the value to copy */ + luaL_checktype(dst, 1, LUA_TTABLE); /* check the presence of a table of + previously visited tables */ + + int indent = (lua_gettop(dst) - 1) * 6; + XBT_DEBUG("%sCopying data %s", get_spaces(indent), name); + indent += 2; + + stack_dump("src before copying a value (should be ... value): ", src); + stack_dump("dst before copying a value (should be visited ...): ", dst); + + switch (lua_type(src, -1)) { + + case LUA_TNIL: + lua_pushnil(dst); break; - case LUA_TBOOLEAN: /* booleans */ - p += sprintf(p, lua_toboolean(L, i) ? "true" : "false"); + case LUA_TNUMBER: + lua_pushnumber(dst, lua_tonumber(src, -1)); break; - case LUA_TNUMBER: /* numbers */ - p += sprintf(p, "%g", lua_tonumber(L, i)); + case LUA_TBOOLEAN: + lua_pushboolean(dst, lua_toboolean(src, -1)); + break; + + case LUA_TSTRING: + /* no worries about memory: lua_pushstring makes a copy */ + lua_pushstring(dst, lua_tostring(src, -1)); + break; + + case LUA_TFUNCTION: + /* it's a function that does not exist yet in L2 */ + + if (lua_iscfunction(src, -1)) { + /* it's a C function: just copy the pointer */ + lua_CFunction f = lua_tocfunction(src, -1); + lua_pushcfunction(dst, f); + } + else { + /* it's a Lua function: dump it from src */ + XBT_DEBUG("%sDumping Lua function '%s'", get_spaces(indent), name); + + s_buffer_t buffer; + buffer.capacity = 64; + buffer.size = 0; + buffer.data = xbt_new(char, buffer.capacity); + + /* copy the binary chunk from src into a buffer */ + int error = lua_dump(src, writer, &buffer); + xbt_assert(!error, "Failed to dump function '%s' from the source state: error %d", + name, error); + + /* load the chunk into dst */ + error = luaL_loadbuffer(dst, buffer.data, buffer.size, name); + xbt_assert(!error, "Failed to load function '%s' into the destination state: %s", + name, lua_tostring(dst, -1)); + XBT_DEBUG("%sFunction '%s' successfully loaded", get_spaces(indent), name); + } break; case LUA_TTABLE: - p += sprintf(p, "Table"); + + /* see if this table was already visited */ + lua_pushlightuserdata(dst, (void*) lua_topointer(src, -1)); + /* dst: visited ... psrctable */ + lua_gettable(dst, 1); + /* dst: visited ... table/nil */ + if (lua_istable(dst, -1)) { + XBT_DEBUG("%sNothing to do: table already visited", get_spaces(indent)); + /* dst: visited ... table */ + } + else { + XBT_DEBUG("%sFirst visit of this table", get_spaces(indent)); + /* dst: visited ... nil */ + lua_pop(dst, 1); + /* dst: visited ... */ + + /* first visit: create the new table in dst */ + lua_newtable(dst); + /* dst: visited ... table */ + + /* mark the table as visited to avoid infinite recursion */ + lua_pushlightuserdata(dst, (void*) lua_topointer(src, -1)); + /* dst: visited ... table psrctable */ + lua_pushvalue(dst, -2); + /* dst: visited ... table psrctable table */ + lua_settable(dst, 1); + /* dst: visited ... table */ + XBT_DEBUG("%sTable marked as visited", get_spaces(indent)); + + stack_dump("dst after marking the table as visited (should be visited ... table): ", dst); + + /* copy the metatable if any */ + int has_meta_table = lua_getmetatable(src, -1); + /* src: ... table mt? */ + if (has_meta_table) { + XBT_DEBUG("%sCopying metatable", get_spaces(indent)); + /* src: ... table mt */ + move_value_impl(src, dst, "metatable"); + /* src: ... table + dst: visited ... table mt */ + lua_setmetatable(dst, -2); + /* dst: visited ... table */ + } + else { + XBT_DEBUG("%sNo metatable", get_spaces(indent)); + } + + stack_dump("src before traversing the table (should be ... table): ", src); + stack_dump("dst before traversing the table (should be visited ... table): ", dst); + + /* traverse the table of src and copy each element */ + lua_pushnil(src); + /* src: ... table nil */ + while (lua_next(src, -2) != 0) { + /* src: ... table key value */ + + XBT_DEBUG("%sCopying table element %s", get_spaces(indent), keyvalue_tostring(src, -2, -1)); + + stack_dump("src before copying table element (should be ... table key value): ", src); + stack_dump("dst before copying table element (should be visited ... table): ", dst); + + /* copy the key */ + lua_pushvalue(src, -2); + /* src: ... table key value key */ + indent += 2; + XBT_DEBUG("%sCopying the key part of the table element", get_spaces(indent)); + move_value_impl(src, dst, value_tostring(src, -1)); + /* src: ... table key value + dst: visited ... table key */ + XBT_DEBUG("%sCopied the key part of the table element", get_spaces(indent)); + + /* copy the value */ + XBT_DEBUG("%sCopying the value part of the table element", get_spaces(indent)); + move_value_impl(src, dst, value_tostring(src, -1)); + /* src: ... table key + dst: visited ... table key value */ + XBT_DEBUG("%sCopied the value part of the table element", get_spaces(indent)); + indent -= 2; + + /* set the table element */ + lua_settable(dst, -3); + /* dst: visited ... table */ + + /* the key stays on top of src for next iteration */ + stack_dump("src before next iteration (should be ... table key): ", src); + stack_dump("dst before next iteration (should be visited ... table): ", dst); + + XBT_DEBUG("%sTable element copied", get_spaces(indent)); + } + XBT_DEBUG("%sFinished traversing the table", get_spaces(indent)); + } break; - 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)); - }*/ + case LUA_TLIGHTUSERDATA: + lua_pushlightuserdata(dst, lua_touserdata(src, -1)); break; + case LUA_TUSERDATA: + { + /* copy the data */ + size_t size = lua_objlen(src, -1); + void* src_block = lua_touserdata(src, -1); + void* dst_block = lua_newuserdata(dst, size); + memcpy(dst_block, src_block, size); + + /* copy the metatable if any */ + int has_meta_table = lua_getmetatable(src, -1); + /* src: ... udata mt? */ + if (has_meta_table) { + XBT_DEBUG("%sCopying metatable of userdata", get_spaces(indent)); + /* src: ... udata mt */ + move_value_impl(src, dst, "metatable"); + /* src: ... udata + dst: visited ... udata mt */ + lua_setmetatable(dst, -2); + /* dst: visited ... udata */ + + XBT_DEBUG("%sMetatable of userdata copied", get_spaces(indent)); + } + else { + XBT_DEBUG("%sNo metatable for this userdata", get_spaces(indent)); + /* src: ... udata */ + } } - p += sprintf(p, " "); /* put a separator */ + break; + + case LUA_TTHREAD: + XBT_WARN("Cannot copy a thread from the source state."); + lua_pushnil(dst); + break; + } + + /* pop the value from src */ + lua_pop(src, 1); + + indent -= 2; + XBT_DEBUG("%sData copied", get_spaces(indent)); + + stack_dump("src after copying a value (should be ...): ", src); + stack_dump("dst after copying a value (should be visited ... value): ", dst); +} + +/** + * @brief Copies a global value or a registry value from the father state. + * + * The state L must have a father, i.e. it should have been created by + * clone_lua_state(). + * This function is meant to be an __index metamethod. + * Consequently, it assumes that the stack has two elements: + * a table (either the environment or the registry of L) and the string key of + * a value that does not exist yet in this table. It copies the corresponding + * value from the father state and pushes it on the stack of L. + * If the value does not exist in the father state either, nil is pushed. + * + * TODO: make this function thread safe. If the simulation runs in parallel, + * several simulated processes may trigger this __index metamethod at the same + * time and get globals from maestro. + * + * @param L the current state + * @return number of return values pushed (always 1) + */ +static int l_get_from_father(lua_State *L) { + + /* check the arguments */ + luaL_checktype(L, 1, LUA_TTABLE); + const char* key = luaL_checkstring(L, 2); + /* L: table key */ + XBT_DEBUG("__index of '%s' begins", key); + + /* want a global or a registry value? */ + int pseudo_index; + if (lua_equal(L, 1, LUA_REGISTRYINDEX)) { + /* registry */ + pseudo_index = LUA_REGISTRYINDEX; + XBT_DEBUG("Will get the value from the registry of the father"); + } + else { + /* global */ + pseudo_index = LUA_GLOBALSINDEX; + XBT_DEBUG("Will get the value from the globals of the father"); + } + + /* get the father */ + lua_pushstring(L, "simgrid.father_state"); + /* L table key "simgrid.father_state" */ + lua_rawget(L, LUA_REGISTRYINDEX); + /* L table key father */ + + lua_State* father = lua_touserdata(L, -1); + + if (father == NULL) { + XBT_WARN("This state has no father"); + lua_pop(L, 3); + lua_pushnil(L); + return 1; } - XBT_INFO("%s%s", msg, buff); + + lua_pop(L, 1); + /* L: table key */ + + /* get the list of visited tables */ + lua_pushstring(L, "simgrid.father_visited_tables"); + /* L: table key "simgrid.father_visited_tables" */ + lua_rawget(L, LUA_REGISTRYINDEX); + /* L: table key visited */ + lua_insert(L, 1); + /* L: visited table key */ + + /* get the value from the father */ + lua_getfield(father, pseudo_index, key); + /* father: ... value */ + + /* push the value onto the stack of L */ + move_value_impl(father, L, key); + /* father: ... + L: visited table key value */ + lua_remove(L, 1); + /* L: table key value */ + + /* prepare the return value of __index */ + lua_pushvalue(L, -1); + /* L: table key value value */ + lua_insert(L, 1); + /* L: value table key value */ + + /* save the copied value in the table for subsequent accesses */ + lua_settable(L, -3); + /* L: value table */ + lua_settop(L, 1); + /* L: value */ + + XBT_DEBUG("__index of '%s' returns %s", key, value_tostring(L, -1)); + + return 1; +} + +/** + * @brief Creates a new Lua state and get its environment from an existing state. + * + * The state created is independent from the existing one and has its own + * copies of global variables and functions. + * However, the global variables and functions are not copied right now from + * the original state; they are copied only the first time they are accessed. + * This behavior saves time and memory, and is okay for Simgrid's needs. + * + * @param father an existing state + * @return the state created + */ +static lua_State* clone_lua_state(lua_State *father) { + + /* create the new state */ + lua_State *L = luaL_newstate(); + + /* set its environment and its registry: + * - create a table newenv + * - create a metatable mt + * - set mt.__index = a function that copies the global from the father state + * - set mt as the metatable of the registry + * - set mt as the metatable of newenv + * - set newenv as the environment of the new state + */ + lua_pushthread(L); /* thread */ + lua_newtable(L); /* thread newenv */ + lua_newtable(L); /* thread newenv mt */ + lua_pushvalue(L, LUA_REGISTRYINDEX); /* thread newenv mt reg */ + lua_pushcfunction(L, l_get_from_father); /* thread newenv mt reg f */ + lua_setfield(L, -3, "__index"); /* thread newenv mt reg */ + lua_pushvalue(L, -2); /* thread newenv mt reg mt */ + lua_setmetatable(L, -2); /* thread newenv mt reg */ + lua_pop(L, 1); /* thread newenv mt */ + lua_setmetatable(L, -2); /* thread newenv */ + lua_setfenv(L, -2); /* thread */ + lua_pop(L, 1); /* -- */ + + /* set a pointer to the father */ + lua_pushlightuserdata(L, father); /* father */ + lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.father_state"); + /* -- */ + + lua_getfield(L, LUA_REGISTRYINDEX, "simgrid.father_state"); /* father */ + + /* create the table of visited tables from the father */ + lua_newtable(L); /* visited */ + lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.father_visited_tables"); + /* -- */ + + /* open the standard libs (theoretically, this is not necessary as they can + * be inherited like any global values, but without a proper support of + * closures, iterators like ipairs don't work). */ + XBT_DEBUG("Metatable of globals and registry set, opening standard libraries now"); + luaL_openlibs(L); + + XBT_DEBUG("New state created"); + + return L; } -/** @brief ensures that a userdata on the stack is a task and returns the pointer inside the userdata */ +/** + * @brief Ensures that a userdata on the stack is a task + * and returns the pointer inside the userdata. + * @param L a Lua state + * @param index an index in the Lua stack + * @return the task at this index + */ static m_task_t checkTask(lua_State * L, int index) { m_task_t *pi, tk; luaL_checktype(L, index, LUA_TTABLE); 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; @@ -96,8 +634,9 @@ static m_task_t checkTask(lua_State * L, int index) /* * * * * * Constructors * * * * * */ + /** - * Construct an new task with the specified processing amount and amount + * @brief Constructs a new task with the specified processing amount and amount * of data needed. * * @param name Task's name @@ -162,7 +701,7 @@ static int Task_destroy(lua_State * L) static int Task_send(lua_State * L) { - //stackDump("send ",L); + //stack_dump("send ", L); m_task_t tk = checkTask(L, 1); const char *mailbox = luaL_checkstring(L, 2); lua_pop(L, 1); // remove the string so that the task is on top of it @@ -174,13 +713,13 @@ static int Task_send(lua_State * L) if (res != MSG_OK) switch (res) { case MSG_TIMEOUT: - XBT_ERROR("MSG_task_send failed : Timeout"); + XBT_DEBUG("MSG_task_send failed : Timeout"); break; case MSG_TRANSFER_FAILURE: - XBT_ERROR("MSG_task_send failed : Transfer Failure"); + XBT_DEBUG("MSG_task_send failed : Transfer Failure"); break; case MSG_HOST_FAILURE: - XBT_ERROR("MSG_task_send failed : Host Failure "); + XBT_DEBUG("MSG_task_send failed : Host Failure "); break; default: XBT_ERROR @@ -190,99 +729,50 @@ static int Task_send(lua_State * L) return 0; } -static int Task_recv(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); - - if (res != MSG_OK) - switch (res) { - case MSG_TIMEOUT: - XBT_ERROR("MSG_task_receive failed : Timeout"); - break; - case MSG_TRANSFER_FAILURE: - XBT_ERROR("MSG_task_receive failed : Transfer Failure"); - break; - case MSG_HOST_FAILURE: - XBT_ERROR("MSG_task_receive failed : Host Failure "); - break; - default: - XBT_ERROR - ("MSG_task_receive failed : Unexpected error , please report this bug"); - break; - } - - return 1; -} - -static int Task_recv_with_timeout(lua_State * L) +static int Task_recv_with_timeout(lua_State *L) { m_task_t tk = NULL; const char *mailbox = luaL_checkstring(L, -2); int timeout = luaL_checknumber(L, -1); MSG_error_t res = MSG_task_receive_with_timeout(&tk, mailbox, timeout); - 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); + if (res == MSG_OK) { + lua_State *sender_stack = MSG_task_get_data(tk); - if (res != MSG_OK) + stack_dump("sender before moving data: ", sender_stack); + stack_dump("receiver before moving data: ", L); + + move_value(sender_stack, L); // copy the data directly from sender's stack + + stack_dump("sender after moving data: ", sender_stack); + stack_dump("receiver after moving data: ", L); + + MSG_task_set_data(tk, NULL); + } + else { switch (res) { case MSG_TIMEOUT: - XBT_ERROR("MSG_task_receive failed : Timeout"); + XBT_DEBUG("MSG_task_receive failed : Timeout"); break; case MSG_TRANSFER_FAILURE: - XBT_ERROR("MSG_task_receive failed : Transfer Failure"); + XBT_DEBUG("MSG_task_receive failed : Transfer Failure"); break; case MSG_HOST_FAILURE: - XBT_ERROR("MSG_task_receive failed : Host Failure "); + XBT_DEBUG("MSG_task_receive failed : Host Failure "); break; default: - XBT_ERROR - ("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); + } return 1; } -/** - * Static Binding for the Splay methods : event.sleep : - * it use MSG_task_irecv with MSG_comm_wait - */ -static int Task_splay_irecv(lua_State *L) -{ - m_task_t task = NULL; - msg_comm_t comm = NULL; //current communication to receive - const char *mailbox = luaL_checkstring(L, -2); - double timeout = luaL_checknumber(L, -1); - comm = MSG_task_irecv(&task, mailbox); - MSG_comm_wait(comm, timeout); - if (MSG_comm_get_status(comm) == MSG_OK) - { - lua_State *sender_stack = MSG_task_get_data(task); - lua_xmove(sender_stack, L, 1); // copy the data directly from sender's stack - MSG_task_set_data(task, NULL); - MSG_comm_destroy(comm); - } - - return 1; -} - -static int Task_splay_isend(lua_State *L) +static int Task_recv(lua_State * L) { - m_task_t tk = checkTask(L, 1); - const char *mailbox = luaL_checkstring(L, 2); - 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_task_isend(tk, mailbox); - - return 1; + lua_pushnumber(L, -1.0); + return Task_recv_with_timeout(L); } static const luaL_reg Task_methods[] = { @@ -293,10 +783,8 @@ static const luaL_reg Task_methods[] = { {"destroy", Task_destroy}, {"send", Task_send}, {"recv", Task_recv}, - {"recv_timeout",Task_recv_with_timeout}, - {"splay_recv",Task_splay_irecv}, - {"iSend",Task_splay_isend}, - {0, 0} + {"recv_timeout", Task_recv_with_timeout}, + {NULL, NULL} }; static int Task_gc(lua_State * L) @@ -316,7 +804,7 @@ static int Task_tostring(lua_State * L) static const luaL_reg Task_meta[] = { {"__gc", Task_gc}, {"__tostring", Task_tostring}, - {0, 0} + {NULL, NULL} }; /** @@ -356,7 +844,6 @@ static int Host_get_by_name(lua_State * L) return 1; } - static int Host_get_name(lua_State * L) { m_host_t ht = checkHost(L, -1); @@ -386,37 +873,36 @@ static int Host_at(lua_State * L) static int Host_self(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 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; } static int Host_get_property_value(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 = checkHost(L, -2); + const char *prop = luaL_checkstring(L, -1); + lua_pushstring(L,MSG_host_get_property_value(ht,prop)); + return 1; } static int Host_sleep(lua_State *L) { - int time = luaL_checknumber(L, -1); - MSG_process_sleep(time); - return 1; + int time = luaL_checknumber(L, -1); + MSG_process_sleep(time); + return 1; } static int Host_destroy(lua_State *L) { - m_host_t ht = checkHost(L, -1); - __MSG_host_destroy(ht); - return 1; + m_host_t ht = checkHost(L, -1); + __MSG_host_destroy(ht); + return 1; } /* ********************************************************************************* */ @@ -522,7 +1008,9 @@ static int trace_end(lua_State *L) #endif return 1; } -//***********Register Methods *******************************************// + +// *********** Register Methods ******************************************* // + /* * Host Methods */ @@ -531,14 +1019,14 @@ static const luaL_reg Host_methods[] = { {"name", Host_get_name}, {"number", Host_number}, {"at", Host_at}, - {"self",Host_self}, + {"self", Host_self}, {"getPropValue", Host_get_property_value}, {"sleep", Host_sleep}, - {"destroy",Host_destroy}, + {"destroy", Host_destroy}, // Bypass XML Methods {"setFunction", console_set_function}, {"setProperty", console_host_set_property}, - {0, 0} + {NULL, NULL} }; static int Host_gc(lua_State * L) @@ -566,46 +1054,51 @@ static const luaL_reg Host_meta[] = { */ static const luaL_reg AS_methods[] = { {"new", console_add_AS}, - {"addHost",console_add_host}, - {"addLink",console_add_link}, - {"addRoute",console_add_route}, - {0, 0} + {"addHost", console_add_host}, + {"addLink", console_add_link}, + {"addRoute", console_add_route}, + {NULL, NULL} }; /** * Tracing Functions */ static const luaL_reg Trace_methods[] = { - {"start",trace_start}, - {"category",trace_category}, - {"setTaskCategory",trace_set_task_category}, - {"finish",trace_end}, - {0,0} + {"start", trace_start}, + {"category", trace_category}, + {"setTaskCategory", trace_set_task_category}, + {"finish", trace_end}, + {NULL, NULL} }; + /* * Environment related */ -//extern lua_State *simgrid_lua_state; - +/** + * @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 + */ static int run_lua_code(int argc, char **argv) { XBT_DEBUG("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 + + lua_State *L = clone_lua_state(lua_maestro_state); int res = 1; - /* Start the co-routine */ + /* start the function */ lua_getglobal(L, argv[0]); 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) + /* call the function */ int err; err = lua_pcall(L, argc - 1, 1, 0); xbt_assert(err == 0, "error running function `%s': %s", argv[0], @@ -616,9 +1109,9 @@ static int run_lua_code(int argc, char **argv) res = lua_tonumber(L, -1); lua_pop(L, 1); /* pop returned value */ } - // cleanups - luaL_unref(simgrid_lua_state, LUA_REGISTRYINDEX, ref); - XBT_DEBUG("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; } @@ -630,24 +1123,11 @@ 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); 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) { - XBT_DEBUG("We have an host %s", SIMIX_host_get_name(host)); - } -*/ - return 0; } @@ -769,15 +1249,23 @@ static const luaL_Reg simgrid_funcs[] = { /* ********************************************************************************* */ #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 *****"); + 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 @@ -807,19 +1295,35 @@ int luaopen_simgrid(lua_State * L) MSG_global_init(&argc, argv); 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 */ + lua_maestro_state = L; + + register_c_functions(L); + + return 1; +} + +/** + * 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); + /* 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, 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 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); // matatable.__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); @@ -838,14 +1342,8 @@ int luaopen_simgrid(lua_State * L) luaL_newmetatable(L, AS_MODULE_NAME); lua_pop(L, 1); - - - /*register the Tracing functions to lua */ + /* 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; }