From: Christophe Thiéry Date: Tue, 27 Sep 2011 11:47:05 +0000 (+0200) Subject: Implementing Lua simulated processes as independent Lua states X-Git-Tag: v3_6_2~50 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/2fda1afe4cce38e40bc19930b4c72cb63eee2937 Implementing Lua simulated processes as independent Lua states --- diff --git a/src/bindings/lua/simgrid_lua.c b/src/bindings/lua/simgrid_lua.c index 2002beac00..c7b1bf6bfa 100644 --- a/src/bindings/lua/simgrid_lua.c +++ b/src/bindings/lua/simgrid_lua.c @@ -6,6 +6,7 @@ /* 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"); @@ -19,7 +20,24 @@ static lua_State *lua_maestro_state; #define AS_MODULE_NAME "simgrid.AS" #define TRACE_MODULE_NAME "simgrid.Trace" -static void stack_dump(const char *msg, lua_State *L); +/** + * @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* dst, lua_State* src, 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); @@ -28,53 +46,415 @@ static void register_c_functions(lua_State *L); /* ********************************************************************************* */ /** - * @brief Dumps the Lua stack + * @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(%d)", 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 Dumps the Lua stack for debugging purposes. * @param msg a message to print * @param L a Lua state */ -static void stack_dump(const char *msg, lua_State *L) +static void stack_dump(const char* msg, lua_State* L) { char buff[2048]; - char *p = buff; + char* p = buff; int i; int top = lua_gettop(L); +// if (1) return; + fflush(stdout); - p += sprintf(p, "STACK(top=%d): ", top); + p[0] = '\0'; for (i = 1; i <= top; i++) { /* repeat for each level */ - int t = lua_type(L, i); - switch (t) { - case LUA_TSTRING: /* strings */ - p += sprintf(p, "`%s'", lua_tostring(L, i)); + p += sprintf(p, "%s", value_tostring(L, i)); + p += sprintf(p, " "); /* put a separator */ + } + XBT_INFO("%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) { + + 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; + + return 0; +} + +/** + * @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 previsously 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 upvalues + * + * @param src the source state + * @param dst the destination state + * @param name a name describing the value + */ +static void move_value(lua_State* dst, lua_State *src, 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 */ + + XBT_DEBUG("Copying value %s", name); + + 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_TNUMBER: + lua_pushnumber(dst, lua_tonumber(src, -1)); break; - case LUA_TBOOLEAN: /* booleans */ - p += sprintf(p, lua_toboolean(L, i) ? "true" : "false"); + case LUA_TBOOLEAN: + lua_pushboolean(dst, lua_toboolean(src, -1)); break; - case LUA_TNUMBER: /* numbers */ - p += sprintf(p, "%g", lua_tonumber(L, i)); + 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 */ + XBT_DEBUG("Copying C function '%s'", name); + lua_CFunction f = lua_tocfunction(src, -1); + lua_pushcfunction(dst, f); + } + else { + /* it's a Lua function: dump it from src */ + XBT_DEBUG("Dumping Lua function '%s'", 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' from the source state: %s", + name, lua_tostring(dst, -1)); + XBT_DEBUG("Function '%s' successfully dumped from source state.", 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("Nothing to do: table already visited"); + /* dst: visited ... table */ + } + else { + XBT_DEBUG("First visit of this table"); + /* 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("Table marked as visited"); + + 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("Copying metatable"); + /* src: ... table mt */ + move_value(dst, src, "metatable"); + /* src: ... table + dst: visited ... table mt */ + lua_setmetatable(dst, -2); + /* dst: visited ... table */ + } + else { + XBT_DEBUG("No metatable"); + } + + 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("Copying table element %s", 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 */ + XBT_DEBUG("Copying the element key"); + move_value(dst, src, value_tostring(src, -1)); + /* src: ... table key value + dst: visited ... table key */ + XBT_DEBUG("Copied the element key"); + + /* copy the value */ + XBT_DEBUG("Copying the element value"); + move_value(dst, src, value_tostring(src, -1)); + /* src: ... table key + dst: visited ... table key value */ + XBT_DEBUG("Copied the element value"); + + /* 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("Finished traversing the table"); + } 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; - } - p += sprintf(p, " "); /* put a separator */ + case LUA_TUSERDATA: + XBT_WARN("Cannot copy a full userdata from the source state."); + lua_pushnil(dst); + break; + + case LUA_TTHREAD: + XBT_WARN("Cannot copy a thread from the source state."); + lua_pushnil(dst); + break; } - XBT_INFO("%s%s", msg, buff); + + /* pop the value from src */ + lua_pop(src, 1); + + 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 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 (usually the environment of L) and the string key of a value + * that does not exist yet in this table. It copies the corresponding global + * value from the father state and pushes it on the stack of L. + * If the global 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) { + + /* retrieve the father */ + lua_getfield(L, LUA_REGISTRYINDEX, "simgrid.father_state"); + lua_State* father = lua_touserdata(L, -1); + xbt_assert(father != NULL, "This Lua state has no father"); + lua_pop(L, 1); + + /* get the global from the father */ + const char* key = luaL_checkstring(L, 2); /* L: table key */ + lua_getglobal(father, key); /* father: ... value */ + XBT_DEBUG("__index of '%s' begins", key); + + /* push the value onto the stack of L */ + lua_newtable(L); /* L: table key visited */ + lua_insert(L, 1); /* L: visited table key */ + move_value(L, father, 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_remove(L, 2); /* 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: + * - 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 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_pushcfunction(L, l_get_from_father); /* thread newenv mt f */ + lua_setfield(L, -2, "__index"); /* thread newenv mt */ + lua_setmetatable(L, -2); /* thread newenv */ + lua_setfenv(L, -2); /* thread */ + lua_pop(L, 1); /* -- */ + + /* open the standard libs (theoretically, this is not necessary) */ + luaL_openlibs(L); + + /* put a pointer to the father */ + lua_pushlightuserdata(L, father); + lua_setfield(L, LUA_REGISTRYINDEX, "simgrid.father_state"); + + XBT_DEBUG("New state created"); + + return L; } /** @@ -555,11 +935,10 @@ static int run_lua_code(int argc, char **argv) { XBT_DEBUG("Run lua code %s", argv[0]); - lua_State *L = lua_newthread(lua_maestro_state); - int ref = luaL_ref(lua_maestro_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]); @@ -581,8 +960,6 @@ static int run_lua_code(int argc, char **argv) lua_pop(L, 1); /* pop returned value */ } - /* cleanups */ - luaL_unref(lua_maestro_state, LUA_REGISTRYINDEX, ref); XBT_DEBUG("Execution of Lua code %s is over", (argv ? argv[0] : "(null)")); return res;