X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d49c6559c186278e8b7f4a5183ef8688983db82d..ce5366b7ccfd889609351fcdd759891a2ceb0c9a:/src/bindings/lua/simgrid_lua.c diff --git a/src/bindings/lua/simgrid_lua.c b/src/bindings/lua/simgrid_lua.c index de08abce87..c01a74b63c 100644 --- a/src/bindings/lua/simgrid_lua.c +++ b/src/bindings/lua/simgrid_lua.c @@ -5,86 +5,482 @@ /* 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 -#include -#include -#include -#include "msg/msg.h" -#include "simdag/simdag.h" -#include -#include "xbt.h" -#include "lua_stub_generator.h" +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua, bindings, "Lua Bindings"); -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua,bindings,"Lua Bindings"); +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* 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); /* ********************************************************************************* */ /* 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); +/** + * @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]; - for (i = 1; i <= top; i++) { /* repeat for each level */ - int t = lua_type(L, i); - switch (t) { + switch (lua_type(L, index)) { - case LUA_TSTRING: /* strings */ - p+=sprintf(p,"`%s'", lua_tostring(L, i)); + case LUA_TNIL: + sprintf(buff, "nil"); break; - case LUA_TBOOLEAN: /* booleans */ - p+=sprintf(p,lua_toboolean(L, i) ? "true" : "false"); + case LUA_TNUMBER: + sprintf(buff, "%.3f", lua_tonumber(L, index)); break; - case LUA_TNUMBER: /* numbers */ - p+=sprintf(p,"%g", lua_tonumber(L, i)); + 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: - p+=sprintf(p, "Table"); + sprintf(buff, "table(%d)", lua_objlen(L, index)); 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: + 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 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) +{ + 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 */ } - 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) { + + 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: + 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 */ + 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: + + /* 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; + + case LUA_TLIGHTUSERDATA: + lua_pushlightuserdata(dst, lua_touserdata(src, -1)); + break; + + 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; } - INFO2("%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; } -/** @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) { - 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); +/** + * @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; - if(!tk) - luaL_error(L,"null Task"); - lua_pop(L,1); - return tk; + if (!tk) + luaL_error(L, "null Task"); + lua_pop(L, 1); + return tk; } + /* ********************************************************************************* */ /* wrapper functions */ /* ********************************************************************************* */ @@ -98,8 +494,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 @@ -112,773 +509,257 @@ static m_task_t checkTask (lua_State *L,int index) { * If 0, then it cannot be transfered with the get() and put() methods. * This value has to be >= 0. */ -static int Task_new(lua_State* L) { - const char *name=luaL_checkstring(L,1); - int comp_size = luaL_checkint(L,2); - int msg_size = luaL_checkint(L,3); - 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_task = msg_task; - luaL_getmetatable(L,TASK_MODULE_NAME); - 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); - return 1; +static int Task_new(lua_State * L) +{ + 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); + 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_task = msg_task; + luaL_getmetatable(L, TASK_MODULE_NAME); + 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); + return 1; } -static int Task_get_name(lua_State *L) { - m_task_t tk = checkTask(L,-1); - lua_pushstring(L,MSG_task_get_name(tk)); +static int Task_get_name(lua_State * L) +{ + m_task_t tk = checkTask(L, -1); + lua_pushstring(L, MSG_task_get_name(tk)); return 1; } -static int Task_computation_duration(lua_State *L){ - m_task_t tk = checkTask(L,-1); - lua_pushnumber(L,MSG_task_get_compute_duration (tk)); +static int 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); +static int Task_execute(lua_State * L) +{ + m_task_t tk = checkTask(L, -1); int res = MSG_task_execute(tk); - lua_pushnumber(L,res); + lua_pushnumber(L, res); return 1; } -static int Task_destroy(lua_State *L) { - m_task_t tk = checkTask(L,-1); +static int Task_destroy(lua_State * L) +{ + m_task_t tk = checkTask(L, -1); int res = MSG_task_destroy(tk); - lua_pushnumber(L,res); + lua_pushnumber(L, res); return 1; } -static int Task_send(lua_State *L) { +static int 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 - - if (res != MSG_OK) switch(res) { - case MSG_TIMEOUT : - ERROR0("MSG_task_send failed : Timeout"); + 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_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 + + if (res != MSG_OK) + switch (res) { + case MSG_TIMEOUT: + XBT_DEBUG("MSG_task_send failed : Timeout"); break; - case MSG_TRANSFER_FAILURE : - ERROR0("MSG_task_send failed : Transfer Failure"); + case MSG_TRANSFER_FAILURE: + XBT_DEBUG("MSG_task_send failed : Transfer Failure"); break; - case MSG_HOST_FAILURE : - ERROR0("MSG_task_send failed : Host Failure "); + case MSG_HOST_FAILURE: + XBT_DEBUG("MSG_task_send failed : Host Failure "); break; - default : - ERROR0("MSG_task_send failed : Unexpected error , please report this bug"); + default: + XBT_ERROR + ("MSG_task_send failed : Unexpected error , please report this bug"); break; } return 0; } -static int Task_recv(lua_State *L) { +static int 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); - - if(res != MSG_OK) switch(res){ - case MSG_TIMEOUT : - ERROR0("MSG_task_receive failed : Timeout"); - break; - case MSG_TRANSFER_FAILURE : - ERROR0("MSG_task_receive failed : Transfer Failure"); - break; - case MSG_HOST_FAILURE : - ERROR0("MSG_task_receive failed : Host Failure "); - break; - default : - ERROR0("MSG_task_receive failed : Unexpected error , please report this bug"); - break; - } - + 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); + + if (res == MSG_OK) { + 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); + } + else { + switch (res) { + case MSG_TIMEOUT: + XBT_DEBUG("MSG_task_receive failed : Timeout"); + break; + case MSG_TRANSFER_FAILURE: + XBT_DEBUG("MSG_task_receive failed : Transfer Failure"); + break; + case MSG_HOST_FAILURE: + XBT_DEBUG("MSG_task_receive failed : Host Failure "); + break; + default: + XBT_ERROR("MSG_task_receive failed : Unexpected error , please report this bug"); + break; + } + lua_pushnil(L); + } return 1; } +static int Task_recv(lua_State * L) +{ + lua_pushnumber(L, -1.0); + return Task_recv_with_timeout(L); +} + 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} + {"new", Task_new}, + {"name", Task_get_name}, + {"computation_duration", Task_computation_duration}, + {"execute", Task_execute}, + {"destroy", Task_destroy}, + {"send", Task_send}, + {"recv", Task_recv}, + {"recv_timeout", Task_recv_with_timeout}, + {NULL, NULL} }; -static int Task_gc(lua_State *L) { - m_task_t tk=checkTask(L,-1); - if (tk) MSG_task_destroy(tk); + +static int Task_gc(lua_State * L) +{ + m_task_t tk = checkTask(L, -1); + if (tk) + MSG_task_destroy(tk); return 0; } -static int Task_tostring(lua_State *L) { - lua_pushfstring(L, "Task :%p",lua_touserdata(L,1)); +static int Task_tostring(lua_State * L) +{ + lua_pushfstring(L, "Task :%p", lua_touserdata(L, 1)); return 1; } static const luaL_reg Task_meta[] = { - {"__gc", Task_gc}, - {"__tostring", Task_tostring}, - {0,0} + {"__gc", Task_gc}, + {"__tostring", Task_tostring}, + {NULL, NULL} }; /** * Host */ -static m_host_t 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); - if(pi == NULL) - luaL_typerror(L,index,HOST_MODULE_NAME); +static m_host_t 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); + if (pi == NULL) + luaL_typerror(L, index, HOST_MODULE_NAME); ht = *pi; - if(!ht) - luaL_error(L,"null Host"); - lua_pop(L,1); - return ht; + if (!ht) + luaL_error(L, "null Host"); + lua_pop(L, 1); + return ht; } -static int Host_get_by_name(lua_State *L) +static int Host_get_by_name(lua_State * L) { - const char *name=luaL_checkstring(L,1); - DEBUG0("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"); - } - 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)); - *lua_host = msg_host; - luaL_getmetatable(L,HOST_MODULE_NAME); - lua_setmetatable(L,-2); - lua_setfield (L, -2, "__simgrid_host"); /* put the userdata as field of the table */ - /* remove the args from the stack */ - lua_remove(L,1); - return 1; -} - - -static int Host_get_name(lua_State *L) { - m_host_t ht = checkHost(L,-1); - lua_pushstring(L,MSG_host_get_name(ht)); - return 1; -} - -static int Host_number(lua_State *L) { - lua_pushnumber(L,MSG_get_host_number()); + const char *name = luaL_checkstring(L, 1); + 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 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)); + *lua_host = msg_host; + luaL_getmetatable(L, HOST_MODULE_NAME); + lua_setmetatable(L, -2); + lua_setfield(L, -2, "__simgrid_host"); /* put the userdata as field of the table */ + /* remove the args from the stack */ + lua_remove(L, 1); return 1; } -static int Host_at(lua_State *L) +static int Host_get_name(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]) - 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)); - *lua_host = host; - luaL_getmetatable(L,HOST_MODULE_NAME); - lua_setmetatable(L,-2); - lua_setfield (L, -2, "__simgrid_host"); /* put the userdata as field of the table */ - return 1; - -} - -/***************************************************************************************** - * BYPASS XML SURF Methods * - *************************** - *************************** -******************************************************************************************/ -#include "surf/surfxml_parse.h" /* to override surf_parse and bypass the parser */ -#include "surf/surf_private.h" - -typedef struct t_AS_attr -{ - const char* id; - const char *mode; -}AS_attr,*p_AS_attr; - -typedef struct t_host_attr -{ - //platform attribute - // Mandatory attributes - const char* id; - double power_peak; - // Optional attributes - double power_scale; - const char *power_trace; - int state_initial; - const char *state_trace; - //deployment attribute - const char* function; - xbt_dynar_t args_list; -}host_attr,*p_host_attr; - -typedef struct t_link_attr -{ - //mandatory attributes - const char* id; - double bandwidth; - double latency; - // Optional attributes - const char* bandwidth_trace; - const char* latency_trace; - const char* state_trace; - int state_initial; - int policy; -}link_attr,*p_link_attr; - -typedef struct t_route_attr -{ - const char *src_id; - const char *dest_id; - xbt_dynar_t links_id; - -}route_attr,*p_route_attr; - -//AS : One struct needed -static p_AS_attr AS; - -//using xbt_dynar_t : -static xbt_dynar_t host_list_d ; -static xbt_dynar_t link_list_d ; -static xbt_dynar_t route_list_d ; - - -/* - * Initialize platform model routing - */ -static void create_AS(const char* id,const char * mode) -{ - surf_AS_new(id,mode); -} - -/** - * create host resource via CPU model [for MSG] - */ - -static void create_host(const char* id,double power_peak,double power_sc, - const char* power_tr,int state_init, - const char* state_tr) -{ - - double power_scale = 1.0; - tmgr_trace_t power_trace = NULL; - e_surf_resource_state_t state_initial; - tmgr_trace_t state_trace; - if(power_sc) // !=0 - power_scale = power_sc; - if (state_init == -1) - state_initial = SURF_RESOURCE_OFF; - else - state_initial = SURF_RESOURCE_ON; - if(power_tr) - power_trace = tmgr_trace_new(power_tr); - else - power_trace = tmgr_trace_new(""); - if(state_tr) - state_trace = tmgr_trace_new(state_tr); - else - state_trace = tmgr_trace_new(""); - current_property_set = xbt_dict_new(); - surf_host_create_resource(xbt_strdup(id), power_peak, power_scale, - power_trace, state_initial, state_trace, current_property_set); - -} - -/** - * create link resource via network model - */ -static void create_link(const char *name, - double bw_initial,const char *trace,double lat_initial, - const char* latency_trace,int state_init, const char* state_trace,int policy) -{ - tmgr_trace_t bw_trace; - tmgr_trace_t lat_trace; - e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON; - e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED; - tmgr_trace_t st_trace; - if(trace) - bw_trace = tmgr_trace_new(trace); - else - bw_trace = tmgr_trace_new(""); - - if(latency_trace) - lat_trace = tmgr_trace_new(latency_trace); - else - lat_trace = tmgr_trace_new(""); - - if(state_trace) - st_trace = tmgr_trace_new(state_trace); - else - st_trace = tmgr_trace_new(""); - - if(state_init == -1) - state_initial_link = SURF_RESOURCE_OFF; - if(policy == -1) - policy_initial_link = SURF_LINK_FATPIPE; - - surf_link_create_resource(xbt_strdup(name), bw_initial, bw_trace, - lat_initial, lat_trace, state_initial_link, st_trace, - policy_initial_link, xbt_dict_new()); -} - - -/* - *create host resource via workstation_ptask_L07 model [for SimDag] - */ -static void create_host_wsL07(const char* id,double power_peak,double power_sc, - const char* power_tr,int state_init, - const char* state_tr) -{ - double power_scale = 1.0; - tmgr_trace_t power_trace = NULL; - e_surf_resource_state_t state_initial; - tmgr_trace_t state_trace; - if(power_sc) // !=0 - power_scale = power_sc; - if (state_init == -1) - state_initial = SURF_RESOURCE_OFF; - else - state_initial = SURF_RESOURCE_ON; - if(power_tr) - power_trace = tmgr_trace_new(power_tr); - else - power_trace = tmgr_trace_new(""); - if(state_tr) - state_trace = tmgr_trace_new(state_tr); - else - state_trace = tmgr_trace_new(""); - current_property_set = xbt_dict_new(); - surf_wsL07_host_create_resource(xbt_strdup(id), power_peak, power_scale, - power_trace, state_initial, state_trace, current_property_set); - -} - -/** - * create link resource via workstation_ptask_L07 model [for SimDag] - */ - -static void create_link_wsL07(const char *name, - double bw_initial,const char *trace,double lat_initial, - const char* latency_trace,int state_init, const char* state_trace,int policy) -{ - tmgr_trace_t bw_trace; - tmgr_trace_t lat_trace; - e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON; - e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED; - tmgr_trace_t st_trace; - if(trace) - bw_trace = tmgr_trace_new(trace); - else - bw_trace = tmgr_trace_new(""); - - if(latency_trace) - lat_trace = tmgr_trace_new(latency_trace); - else - lat_trace = tmgr_trace_new(""); - - if(state_trace) - st_trace = tmgr_trace_new(state_trace); - else - st_trace = tmgr_trace_new(""); - - if(state_init == -1) - state_initial_link = SURF_RESOURCE_OFF; - if(policy == -1) - policy_initial_link = SURF_LINK_FATPIPE; - - surf_wsL07_link_create_resource(xbt_strdup(name), bw_initial, bw_trace, - lat_initial, lat_trace, state_initial_link, st_trace, - policy_initial_link, xbt_dict_new()); -} - - -/* - * init AS - */ - -static int AS_new(lua_State *L) -{ - const char *id; - const char *mode; - if(lua_istable(L,1)) - { - lua_pushstring(L,"id"); - lua_gettable(L,-2); - id = lua_tostring(L,-1); - lua_pop(L,1); - - lua_pushstring(L,"mode"); - lua_gettable(L,-2); - mode = lua_tostring(L,-1); - lua_pop(L,1); - } - else { - ERROR0("Bad Arguments to AS.new, Should be a table with named arguments"); - return -1; - } - AS = malloc(sizeof(AS_attr)); - AS->id = id; - AS->mode = mode; - - return 0; + m_host_t ht = checkHost(L, -1); + lua_pushstring(L, MSG_host_get_name(ht)); + return 1; } -/* - * add new host to platform hosts list - */ -static int Host_new(lua_State *L) +static int Host_number(lua_State * L) { - - if(xbt_dynar_is_empty(host_list_d)) - host_list_d = xbt_dynar_new(sizeof(p_host_attr), &xbt_free_ref); - - p_host_attr host; - const char * id; - const char *power_trace; - const char *state_trace; - double power,power_scale; - int state_initial; - //get values from the table passed as argument - if (lua_istable(L,-1)) { - - // get Id Value - lua_pushstring(L,"id"); - lua_gettable(L, -2 ); - id = lua_tostring(L,-1); - lua_pop(L,1); - - // get power value - lua_pushstring(L,"power"); - lua_gettable(L, -2 ); - power = lua_tonumber(L,-1); - lua_pop(L,1); - - //get power_scale - lua_pushstring(L,"power_scale"); - lua_gettable(L, -2 ); - power_scale = lua_tonumber(L,-1); - lua_pop(L,1); - - //get power_trace - lua_pushstring(L,"power_trace"); - lua_gettable(L, -2 ); - power_trace = lua_tostring(L,-1); - lua_pop(L,1); - - //get state initial - lua_pushstring(L,"state_initial"); - lua_gettable(L, -2 ); - state_initial = lua_tonumber(L,-1); - lua_pop(L,1); - - //get trace state - lua_pushstring(L,"state_trace"); - lua_gettable(L, -2 ); - state_trace = lua_tostring(L,-1); - lua_pop(L,1); - - } else { - ERROR0("Bad Arguments to create host, Should be a table with named arguments"); - return -1; - } - - host = malloc(sizeof(host_attr)); - host->id = id; - host->power_peak = power; - host->power_scale = power_scale; - host->power_trace = power_trace; - host->state_initial = state_initial; - host->state_trace = state_trace; - host->function = NULL; - xbt_dynar_push(host_list_d, &host); - - return 0; + lua_pushnumber(L, MSG_get_host_number()); + return 1; } -/** - * add link to platform links list - */ -static int Link_new(lua_State *L) // (id,bandwidth,latency) +static int Host_at(lua_State * L) { - if(xbt_dynar_is_empty(link_list_d)) - link_list_d = xbt_dynar_new(sizeof(p_link_attr), &xbt_free_ref); - - const char* id; - double bandwidth,latency; - const char* bandwidth_trace; - const char* latency_trace; - const char* state_trace; - int state_initial,policy; - - //get values from the table passed as argument - if (lua_istable(L,-1)) { - // get Id Value - lua_pushstring(L,"id"); - lua_gettable(L, -2 ); - id = lua_tostring(L,-1); - lua_pop(L,1); - - // get bandwidth value - lua_pushstring(L,"bandwidth"); - lua_gettable(L, -2 ); - bandwidth = lua_tonumber(L,-1); - lua_pop(L,1); - - //get latency value - lua_pushstring(L,"latency"); - lua_gettable(L, -2 ); - latency = lua_tonumber(L,-1); - lua_pop(L,1); - - /*Optional Arguments */ - - //get bandwidth_trace value - lua_pushstring(L,"bandwidth_trace"); - lua_gettable(L, -2 ); - bandwidth_trace = lua_tostring(L,-1); - lua_pop(L,1); - - //get latency_trace value - lua_pushstring(L,"latency_trace"); - lua_gettable(L, -2 ); - latency_trace = lua_tostring(L,-1); - lua_pop(L,1); - - //get state_trace value - lua_pushstring(L,"state_trace"); - lua_gettable(L, -2 ); - state_trace = lua_tostring(L,-1); - lua_pop(L,1); - - //get state_initial value - lua_pushstring(L,"state_initial"); - lua_gettable(L, -2 ); - state_initial = lua_tonumber(L,-1); - lua_pop(L,1); - - - //get policy value - lua_pushstring(L,"policy"); - lua_gettable(L, -2 ); - policy = lua_tonumber(L,-1); - lua_pop(L,1); - - } else { - ERROR0("Bad Arguments to create link, Should be a table with named arguments"); - return -1; - } - - p_link_attr link = malloc(sizeof(link_attr)); - link->id = id; - link->bandwidth = bandwidth; - link->latency = latency; - link->bandwidth_trace = bandwidth_trace; - link->latency_trace = latency_trace; - link->state_trace = state_trace; - link->state_initial= state_initial; - link->policy = policy; - xbt_dynar_push(link_list_d,&link); - return 0; -} + 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]) + 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)); + *lua_host = host; + luaL_getmetatable(L, HOST_MODULE_NAME); + lua_setmetatable(L, -2); + lua_setfield(L, -2, "__simgrid_host"); /* put the userdata as field of the table */ + return 1; -/** - * add route to platform routes list - */ -static int Route_new(lua_State *L) // (src_id,dest_id,links_number,link_table) -{ - if(xbt_dynar_is_empty(route_list_d)) - route_list_d = xbt_dynar_new(sizeof(p_route_attr), &xbt_free_ref); - const char * link_id; - p_route_attr route = malloc(sizeof(route_attr)); - route->src_id = luaL_checkstring(L,1); - route->dest_id = luaL_checkstring(L,2); - route->links_id = xbt_dynar_new(sizeof(char *), &xbt_free_ref); - lua_pushnil(L); - while (lua_next(L,3) != 0) { - link_id = lua_tostring(L, -1); - xbt_dynar_push(route->links_id, &link_id); - DEBUG2("index = %f , Link_id = %s \n",lua_tonumber(L, -2),lua_tostring(L, -1)); - lua_pop(L, 1); - } - lua_pop(L, 1); - - //add route to platform's route list - xbt_dynar_push(route_list_d,&route); - return 0; } -/** - * set function to process - */ -static int Host_set_function(lua_State *L) //(host,function,nb_args,list_args) +static int Host_self(lua_State * L) { - // look for the index of host in host_list - const char *host_id = luaL_checkstring(L,1); - const char* argument; - unsigned int i; - p_host_attr p_host; - - xbt_dynar_foreach(host_list_d,i,p_host) - { - if(p_host->id == host_id) - { - p_host->function = luaL_checkstring(L,2); - if(lua_istable(L,3)) - { - p_host->args_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref); - // fill the args list - lua_pushnil(L); - int j = 0; - while (lua_next(L,3) != 0) { - argument = lua_tostring(L, -1); - xbt_dynar_push(p_host->args_list, &argument); - DEBUG2("index = %f , Arg_id = %s \n",lua_tonumber(L, -2),lua_tostring(L, -1)); - j++; - lua_pop(L, 1); - } - } - lua_pop(L, 1); - return 0; - } - } - ERROR1("Host : %s Not Found !!",host_id); - 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; } -/* - * surf parse bypass platform - * through CPU/network Models - */ - -static int surf_parse_bypass_platform() +static int Host_get_property_value(lua_State * L) { - unsigned int i; - p_host_attr p_host; - p_link_attr p_link; - p_route_attr p_route; - - // Init routing mode - create_AS(AS->id,AS->mode); - - - // Add Hosts - xbt_dynar_foreach(host_list_d,i,p_host) - { - create_host(p_host->id,p_host->power_peak,p_host->power_scale,p_host->power_trace, - p_host->state_initial,p_host->state_trace); - //add to routing model host list - surf_route_add_host((char*)p_host->id); - - } - - //add Links - xbt_dynar_foreach(link_list_d,i,p_link) - { - create_link(p_link->id,p_link->bandwidth,p_link->bandwidth_trace,p_link->latency, - p_link->latency_trace,p_link->state_initial,p_link->state_trace,p_link->policy); - } - // add route - xbt_dynar_foreach(route_list_d,i,p_route) - { - surf_routing_add_route((char*)p_route->src_id,(char*)p_route->dest_id,p_route->links_id); - } - /* */ - - // Finalize AS - surf_AS_finalize(AS->id); - - // add traces - surf_add_host_traces(); - surf_add_link_traces(); - - return 0; // must return 0 ?!! - + 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; } -/** - * - * surf parse bypass platform - * through workstation_ptask_L07 Model - */ - - -static int surf_wsL07_parse_bypass_platform() +static int Host_sleep(lua_State *L) { - unsigned int i; - p_host_attr p_host; - p_link_attr p_link; - p_route_attr p_route; - - // Init routing mode - create_AS(AS->id,AS->mode); - - // Add Hosts - xbt_dynar_foreach(host_list_d,i,p_host) - { - create_host_wsL07(p_host->id,p_host->power_peak,p_host->power_scale,p_host->power_trace, - p_host->state_initial,p_host->state_trace); - //add to routing model host list - surf_route_add_host((char*)p_host->id); - } - - //add Links - xbt_dynar_foreach(link_list_d,i,p_link) - { - create_link_wsL07(p_link->id,p_link->bandwidth,p_link->bandwidth_trace,p_link->latency, - p_link->latency_trace,p_link->state_initial,p_link->state_trace,p_link->policy); - } - // add route - xbt_dynar_foreach(route_list_d,i,p_route) - { - surf_routing_add_route((char*)p_route->src_id,(char*)p_route->dest_id,p_route->links_id); - } - /* */ - - // Finalize AS - surf_AS_finalize(AS->id); - // add traces - surf_wsL07_add_traces(); - - return 0; + int time = luaL_checknumber(L, -1); + MSG_process_sleep(time); + return 1; } -/* - * surf parse bypass application for MSG Module - */ -static int surf_parse_bypass_application() +static int Host_destroy(lua_State *L) { - unsigned int i; - p_host_attr p_host; - xbt_dynar_foreach(host_list_d,i,p_host) - { - if(p_host->function) - MSG_set_function(p_host->id,p_host->function,p_host->args_list); - } - return 0; + m_host_t ht = checkHost(L, -1); + __MSG_host_destroy(ht); + return 1; } - -/** - * Generate Gras Templates File from lua - */ +/* ********************************************************************************* */ +/* lua_stub_generator functions */ +/* ********************************************************************************* */ xbt_dict_t process_function_set; xbt_dynar_t process_list; @@ -895,356 +776,426 @@ void s_process_free(void *process) free(p->host); } -static int gras_add_process_function(lua_State *L) +static int gras_add_process_function(lua_State * L) { - const char * arg; - const char* process_host = luaL_checkstring(L,1); - const char *process_function = luaL_checkstring(L,2); - - if(xbt_dict_is_empty(machine_set) || xbt_dict_is_empty(process_function_set) - || xbt_dynar_is_empty(process_list)) - { - process_function_set = xbt_dict_new(); - process_list = xbt_dynar_new(sizeof(s_process_t), s_process_free); - machine_set = xbt_dict_new(); - } - - xbt_dict_set(machine_set,process_host, NULL, NULL); - xbt_dict_set(process_function_set,process_function, NULL, NULL); - - process.argc = 1; - process.argv = xbt_new(char *, 1); - process.argv[0] = xbt_strdup(process_function); - process.host = strdup(process_host); - - lua_pushnil(L); - while (lua_next(L,3) != 0) { - arg = lua_tostring(L, -1); - process.argc++; - process.argv = 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),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; + const char *arg; + const char *process_host = luaL_checkstring(L, 1); + const char *process_function = luaL_checkstring(L, 2); + + if (xbt_dict_is_empty(machine_set) + || xbt_dict_is_empty(process_function_set) + || xbt_dynar_is_empty(process_list)) { + process_function_set = xbt_dict_new(); + process_list = xbt_dynar_new(sizeof(s_process_t), s_process_free); + machine_set = xbt_dict_new(); + } + xbt_dict_set(machine_set, process_host, NULL, NULL); + xbt_dict_set(process_function_set, process_function, NULL, NULL); + + process.argc = 1; + process.argv = xbt_new(char *, 1); + process.argv[0] = xbt_strdup(process_function); + process.host = strdup(process_host); + + lua_pushnil(L); + while (lua_next(L, 3) != 0) { + arg = lua_tostring(L, -1); + process.argc++; + process.argv = + xbt_realloc(process.argv, (process.argc) * sizeof(char *)); + process.argv[(process.argc) - 1] = xbt_strdup(arg); + + 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; } -static int gras_generate(lua_State *L) +static int gras_generate(lua_State * L) { - const char *project_name = luaL_checkstring(L,1); + const char *project_name = luaL_checkstring(L, 1); generate_sim(project_name); generate_rl(project_name); generate_makefile_local(project_name); - return 0; } -//***********Register Methods *******************************************// +/*********************************** + * 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; +} + +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}, - // Bypass XML Methods - {"new", Host_new}, - {"setFunction", Host_set_function}, - {0,0} + {"getByName", Host_get_by_name}, + {"name", Host_get_name}, + {"number", Host_number}, + {"at", Host_at}, + {"self", Host_self}, + {"getPropValue", Host_get_property_value}, + {"sleep", Host_sleep}, + {"destroy", Host_destroy}, + // Bypass XML Methods + {"setFunction", console_set_function}, + {"setProperty", console_host_set_property}, + {NULL, NULL} }; -static int Host_gc(lua_State *L) +static int Host_gc(lua_State * L) { - m_host_t ht = checkHost(L,-1); - if (ht) ht = NULL; + m_host_t ht = checkHost(L, -1); + if (ht) + ht = NULL; return 0; } -static int Host_tostring(lua_State *L) +static int Host_tostring(lua_State * L) { - lua_pushfstring(L,"Host :%p",lua_touserdata(L,1)); + lua_pushfstring(L, "Host :%p", lua_touserdata(L, 1)); return 1; } static const luaL_reg Host_meta[] = { - {"__gc", Host_gc}, - {"__tostring", Host_tostring}, - {0,0} + {"__gc", Host_gc}, + {"__tostring", Host_tostring}, + {0, 0} }; /* * AS Methods */ static const luaL_reg AS_methods[] = { - {"new",AS_new}, - {0,0} + {"new", console_add_AS}, + {"addHost", console_add_host}, + {"addLink", console_add_link}, + {"addRoute", console_add_route}, + {NULL, NULL} }; - -/* - * Link Methods - */ -static const luaL_reg Link_methods[] = { - {"new",Link_new}, - {0,0} -}; -/* - * Route Methods +/** + * Tracing Functions */ -static const luaL_reg Route_methods[] ={ - {"new",Route_new}, - {0,0} +static const luaL_reg Trace_methods[] = { + {"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]); -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 + lua_State *L = clone_lua_state(lua_maestro_state); int res = 1; - /* Start the co-routine */ - lua_getglobal(L,argv[0]); - xbt_assert1(lua_isfunction(L,-1), - "The lua function %s does not seem to exist",argv[0]); + /* 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