X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/460bf13957aee18682f280a06910bd4032342fe4..9c13b98a571f44f7f2faf7193a60ce7e94a82094:/src/bindings/lua/simgrid_lua.c diff --git a/src/bindings/lua/simgrid_lua.c b/src/bindings/lua/simgrid_lua.c index 67328c6c2c..5fdd7c1618 100644 --- a/src/bindings/lua/simgrid_lua.c +++ b/src/bindings/lua/simgrid_lua.c @@ -1,317 +1,811 @@ -/* SimGrid Lua bindings */ - -/* Copyright (c) 2010, the SimGrid team. All right reserved. */ +/* Copyright (c) 2010. The SimGrid Team. + * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#include -#include -#include +/* SimGrid Lua bindings */ + +#include "simgrid_lua.h" +#include "lua_state_cloner.h" +#include "lua_utils.h" -#include "msg/msg.h" -#include "xbt.h" +XBT_LOG_NEW_DEFAULT_CATEGORY(lua, "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) +#define LINK_MODULE_NAME "simgrid.Link" +#define ROUTE_MODULE_NAME "simgrid.Route" +#define AS_MODULE_NAME "simgrid.AS" +#define TRACE_MODULE_NAME "simgrid.Trace" + +static void register_c_functions(lua_State *L); + +static void *my_checkudata (lua_State *L, int ud, const char *tname) { + + XBT_DEBUG("Checking the task: ud = %d", ud); + sglua_stack_dump("my_checkudata: ", L); + void *p = lua_touserdata(L, ud); + lua_getfield(L, LUA_REGISTRYINDEX, tname); + const void* correct_mt = lua_topointer(L, -1); + + int has_mt = lua_getmetatable(L, ud); + XBT_DEBUG("Checking the task: has metatable ? %d", has_mt); + const void* actual_mt = NULL; + if (has_mt) { actual_mt = lua_topointer(L, -1); lua_pop(L, 1); } + XBT_DEBUG("Checking the task's metatable: expected %p, found %p", correct_mt, actual_mt); + sglua_stack_dump("my_checkudata: ", L); + + if (p == NULL || !lua_getmetatable(L, ud) || !lua_rawequal(L, -1, -2)) + luaL_typerror(L, ud, tname); + lua_pop(L, 2); + return p; +} + +/** + * @brief Ensures that a userdata on the stack is a task + * and returns the pointer inside the userdata. + * @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; + XBT_DEBUG("Lua task: %s", sglua_tostring(L, index)); + luaL_checktype(L, index, LUA_TTABLE); + lua_getfield(L, index, "__simgrid_task"); + + pi = (m_task_t *) luaL_checkudata(L, lua_gettop(L), 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; +} /* ********************************************************************************* */ -/* helper functions */ +/* wrapper functions */ /* ********************************************************************************* */ -static void stackDump (lua_State *L) { - char buff[2048]; - char *p=buff; - int i; - int top = lua_gettop(L); - void *ptr; - fflush(stdout); - p+=sprintf(p,"STACK(top=%d): ",top); - 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)); - break; +/** + * A task is either something to compute somewhere, or something to exchange between two hosts (or both). + * It is defined by a computing amount and a message size. + * + */ - case LUA_TBOOLEAN: /* booleans */ - p+=sprintf(p,lua_toboolean(L, i) ? "true" : "false"); - break; +/* * * * + * * Constructors * * + * * * */ + +/** + * @brief Constructs a new task with the specified processing amount and amount + * of data needed. + * + * @param name Task's name + * + * @param computeDuration A value of the processing amount (in flop) needed to process the task. + * If 0, then it cannot be executed with the execute() method. + * This value has to be >= 0. + * + * @param messageSize A value of amount of data (in bytes) needed to transfert this task. + * If 0, then it cannot be transfered with the get() and put() methods. + * This value has to be >= 0. + */ +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; +} - case LUA_TNUMBER: /* numbers */ - p+=sprintf(p,"%g", lua_tonumber(L, i)); - break; +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; +} - default: /* other values */ - if ((ptr = luaL_checkudata(L,i,TASK_MODULE_NAME))) { - p+=sprintf(p,"task"); - } else { - p+=printf(p,"%s", lua_typename(L, t)); - } +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); + int res = MSG_task_execute(tk); + lua_pushnumber(L, res); + return 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); + return 1; +} + +static int Task_send(lua_State * 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 + 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: + XBT_DEBUG("MSG_task_send failed : Transfer Failure"); break; + case MSG_HOST_FAILURE: + XBT_DEBUG("MSG_task_send failed : Host Failure "); + break; + default: + XBT_ERROR + ("MSG_task_send failed : Unexpected error , please report this bug"); + break; + } + return 0; +} +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); + + if (res == MSG_OK) { + lua_State *sender_stack = MSG_task_get_data(tk); + sglua_move_value(sender_stack, L); // 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; } - p+=sprintf(p," "); /* put a separator */ + lua_pushnil(L); } - DEBUG1("%s",buff); + return 1; } -/** @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_TUSERDATA); - pi = (m_task_t*)luaL_checkudata(L,index,TASK_MODULE_NAME); - if(pi == NULL) - luaL_typerror(L,index,TASK_MODULE_NAME); - tk = *pi; - if(!tk) - luaL_error(L,"null Task"); - return tk; +static int Task_recv(lua_State * L) +{ + lua_pushnumber(L, -1.0); + return Task_recv_with_timeout(L); } -/** @brief leaves a new userdata on top of the stack, sets its metatable, and sets the Task pointer inside the userdata */ -static m_task_t *pushTask (lua_State *L,m_task_t tk) { - m_task_t *pi = (m_task_t*)lua_newuserdata(L,sizeof(m_task_t)); - *pi=tk; - luaL_getmetatable(L,TASK_MODULE_NAME); - lua_setmetatable(L,-2); - return pi; +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}, + {"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); + return 0; } +static int Task_tostring(lua_State * L) +{ + lua_pushfstring(L, "Task :%p", lua_touserdata(L, 1)); + return 1; +} -/* ********************************************************************************* */ -/* wrapper functions */ -/* ********************************************************************************* */ +static const luaL_reg Task_meta[] = { + {"__gc", Task_gc}, + {"__tostring", Task_tostring}, + {NULL, NULL} +}; -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); - // FIXME: data shouldn't be NULL I guess - pushTask(L,MSG_task_create(name,comp_size,msg_size,NULL)); - DEBUG0("Created task"); +/** + * 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, lua_gettop(L), 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; +} + +static int Host_get_by_name(lua_State * L) +{ + 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 Task_get_name(lua_State *L) { - m_task_t tk = checkTask(L,1); - lua_pushstring(L,MSG_task_get_name(tk)); +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 Task_computation_duration(lua_State *L){ - m_task_t tk = checkTask(L,1); - lua_pushnumber(L,MSG_task_get_compute_duration (tk)); +static int Host_number(lua_State * L) +{ + lua_pushnumber(L, MSG_get_host_number()); return 1; } -static int Task_execute(lua_State *L){ - m_task_t tk = checkTask(L,1); - int res = MSG_task_execute(tk); - lua_pushnumber(L,res); +static int Host_at(lua_State * L) +{ + int index = luaL_checkinteger(L, 1); + m_host_t host = MSG_get_host_table()[index - 1]; // lua indexing start by 1 (lua[1] <=> C[0]) + 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; + } -static int Task_destroy(lua_State *L) { - m_task_t tk = checkTask(L,1); - int res = MSG_task_destroy(tk); - lua_pushnumber(L,res); +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; } -static int Task_send(lua_State *L) { - m_task_t tk = checkTask(L,1); - const char *mailbox = luaL_checkstring(L,2); - int res = MSG_task_send(tk,mailbox); - res++;//FIXME: check it instead of avoiding the warning + +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; +} + +static int Host_sleep(lua_State *L) +{ + 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; +} + +/* ********************************************************************************* */ +/* lua_stub_generator functions */ +/* ********************************************************************************* */ + +xbt_dict_t process_function_set; +xbt_dynar_t process_list; +xbt_dict_t machine_set; +static s_process_t process; + +void s_process_free(void *process) +{ + s_process_t *p = (s_process_t *) process; + int i; + for (i = 0; i < p->argc; i++) + free(p->argv[i]); + free(p->argv); + free(p->host); +} + +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); + + 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 Task_recv(lua_State *L) { - m_task_t tk = NULL; - const char *mailbox = luaL_checkstring(L,1); - int res = MSG_task_receive(&tk,mailbox); - MSG_task_ref(tk); - res++;//FIXME: check it instead of avoiding the warning - DEBUG1("Task Name : >>>%s",MSG_task_get_name(tk)); - pushTask(L,tk); + + +static int gras_generate(lua_State * L) +{ + const char *project_name = luaL_checkstring(L, 1); + generate_sim(project_name); + generate_rl(project_name); + generate_makefile_local(project_name); + return 0; +} + +/*********************************** + * Tracing + **********************************/ +static int trace_start(lua_State *L) +{ +#ifdef HAVE_TRACING + TRACE_start(); +#endif return 1; } -static const luaL_reg Task_methods[] = { - {"new", Task_new}, - {"name", Task_get_name}, - {"computation_duration", Task_computation_duration}, - {"execute", Task_execute}, - {"destroy", Task_destroy}, - {"send", Task_send}, - {"recv", Task_recv}, - {0,0} +static int 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}, + {"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 Task_gc(lua_State *L) { - m_task_t tk=checkTask(L,1); - if (tk) MSG_task_destroy(tk); - //printf("GoodBye Task(%p)\n",lua_touserdata(L,1)); + +static int Host_gc(lua_State * L) +{ + m_host_t ht = checkHost(L, -1); + if (ht) + ht = NULL; return 0; } -static int Task_tostring(lua_State *L) { - lua_pushfstring(L, "Task :%p",lua_touserdata(L,1)); +static int Host_tostring(lua_State * L) +{ + lua_pushfstring(L, "Host :%p", lua_touserdata(L, 1)); return 1; } +static const luaL_reg Host_meta[] = { + {"__gc", Host_gc}, + {"__tostring", Host_tostring}, + {0, 0} +}; -static const luaL_reg Task_meta[] = { - {"__gc", Task_gc}, - {"__tostring", Task_tostring}, - {0,0} +/* + * AS Methods + */ +static const luaL_reg AS_methods[] = { + {"new", console_add_AS}, + {"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}, + {NULL, NULL} }; /* * Environment related */ -extern lua_State *simgrid_lua_state; -static int run_lua_code(int argc,char **argv) { - DEBUG1("Run lua code %s",argv[0]); -// fprintf(stderr,"Run lua code %s\n", (argv ? argv[0] : "(null)")); - lua_State *L = lua_newthread(simgrid_lua_state); - int ref = luaL_ref(simgrid_lua_state, LUA_REGISTRYINDEX); // protect the thread from being garbage collected +/** + * @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 = sglua_clone_maestro(); 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