X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/625de49f7dc6c904af2e59b60b9378df6e9077da..fe832229f8b8467994bac54665117823e7ed97e9:/src/bindings/lua/simgrid_lua.c diff --git a/src/bindings/lua/simgrid_lua.c b/src/bindings/lua/simgrid_lua.c index 6468de3b2b..79f09ecc11 100644 --- a/src/bindings/lua/simgrid_lua.c +++ b/src/bindings/lua/simgrid_lua.c @@ -1,6 +1,7 @@ /* 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. */ @@ -8,19 +9,23 @@ #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"); #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" /* ********************************************************************************* */ /* helper functions */ /* ********************************************************************************* */ - static void stackDump (const char *msg, lua_State *L) { char buff[2048]; char *p=buff; @@ -31,7 +36,6 @@ static void stackDump (const char *msg, lua_State *L) { 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) { @@ -80,44 +84,49 @@ static m_task_t checkTask (lua_State *L,int index) { lua_pop(L,1); return tk; } - -/** @brief leaves a new userdata on top of the stack, sets its metatable, and sets the Task pointer inside the userdata */ -// NOT USED -/*static m_task_t *pushTask (lua_State *L,m_task_t tk) { - m_task_t *pi = NULL; - pi = (m_task_t*)lua_newuserdata(L,sizeof(m_task_t)); - *pi=tk; - DEBUG1("push lua task with Name : %s \n",MSG_task_get_name(*pi)); - luaL_getmetatable(L,TASK_MODULE_NAME); - lua_setmetatable(L,-2); - return pi; -}*/ - /* ********************************************************************************* */ /* wrapper functions */ /* ********************************************************************************* */ /** - * Task + * A task is either something to compute somewhere, or something to exchange between two hosts (or both). + * It is defined by a computing amount and a message size. + * */ +/* * * * + * * Constructors * * + * * * */ +/** + * Construct an new task with the specified processing amount and amount + * of data needed. + * + * @param name Task's name + * + * @param computeDuration A value of the processing amount (in flop) needed to process the task. + * If 0, then it cannot be executed with the execute() method. + * This value has to be >= 0. + * + * @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) { - const char *name=luaL_checkstring(L,1); - int comp_size = luaL_checkint(L,2); - int msg_size = luaL_checkint(L,3); - INFO0("Creating task"); - 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; + 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) { @@ -145,6 +154,7 @@ static int Task_destroy(lua_State *L) { lua_pushnumber(L,res); return 1; } + static int Task_send(lua_State *L) { //stackDump("send ",L); m_task_t tk = checkTask(L,-2); @@ -152,7 +162,7 @@ static int Task_send(lua_State *L) { 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_has_data(tk)) // Don't mess up with my stack: the receiver didn't copy the data yet + 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) { @@ -243,7 +253,6 @@ static m_host_t checkHost (lua_State *L,int index) { return ht; } - static int Host_get_by_name(lua_State *L) { const char *name=luaL_checkstring(L,1); @@ -276,11 +285,578 @@ static int Host_number(lua_State *L) { return 1; } +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; + +} + +/***************************************************************************************** + * 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_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; + +//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 ; + + +/** + * 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); + +} +/* + * add new host to platform hosts list + */ +static int Host_new(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; +} + +/** + * add link to platform links list + */ +static int Link_new(lua_State *L) // (id,bandwidth,latency) +{ + 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; +} + +/** + * 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) +{ + // 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 Fount !!",host_id); + return 1; +} + +/* + * surf parse bypass platform + * through CPU/network Models + */ + +static int surf_parse_bypass_platform() +{ + unsigned int i; + p_host_attr p_host; + p_link_attr p_link; + p_route_attr p_route; + + // 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) + { + /*(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)*/ + 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_route_set_resource((char*)p_route->src_id,(char*)p_route->dest_id,p_route->links_id,0); + } + /* */ + + surf_add_host_traces(); + surf_set_routes(); + surf_add_link_traces(); + + return 0; // must return 0 ?!! + +} + +/** + * + * surf parse bypass platform + * through workstation_ptask_L07 Model + */ + + +static int surf_wsL07_parse_bypass_platform() +{ + unsigned int i; + p_host_attr p_host; + p_link_attr p_link; + p_route_attr p_route; + + // 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) + { + surf_wsL07_link_create_resource((char*)p_link->id,p_link->bandwidth,p_link->latency); + } + // add route + xbt_dynar_foreach(route_list_d,i,p_route) + { + surf_route_set_resource((char*)p_route->src_id,(char*)p_route->dest_id,p_route->links_id,0); + } + /* */ + + surf_wsL07_add_traces(); + surf_set_routes(); + + return 0; + +} +/* + * surf parse bypass application for MSG Module + */ +static int surf_parse_bypass_application() +{ + 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; +} + + +/** + * Generate Gras Templates File from lua + */ +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); + + 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; + +} + + +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; +} + +//***********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} }; @@ -303,9 +879,25 @@ static const luaL_reg Host_meta[] = { {0,0} }; +/* + * Link Methods + */ +static const luaL_reg Link_methods[] = { + {"new",Link_new}, + {0,0} +}; +/* + * Route Methods + */ +static const luaL_reg Route_methods[] ={ + {"new",Route_new}, + {0,0} +}; + /* * Environment related */ + extern lua_State *simgrid_lua_state; static int run_lua_code(int argc,char **argv) { @@ -333,7 +925,6 @@ 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 ); DEBUG1("Execution of lua code %s is over", (argv ? argv[0] : "(null)")); @@ -358,6 +949,7 @@ static int create_environment(lua_State *L) { return 0; } + static int debug(lua_State *L) { const char *str = luaL_checkstring(L,1); DEBUG1("%s",str); @@ -376,6 +968,64 @@ static int clean(lua_State *L) { MSG_clean(); return 0; } + +/* + * Bypass XML Parser + */ + +/* + * Register platform for MSG + */ +static int msg_register_platform(lua_State *L) +{ + /* Tell Simgrid we dont wanna use its parser*/ + surf_parse = surf_parse_bypass_platform; + MSG_create_environment(NULL); + return 0; +} + +/* + * Register platform for Simdag + */ + +static int sd_register_platform(lua_State *L) +{ + surf_parse = surf_wsL07_parse_bypass_platform; + SD_create_environment(NULL); + return 0; +} +/* + * Register platform for gras + */ +static int gras_register_platform(lua_State *L) +{ + /* Tell Simgrid we dont wanna use surf parser*/ + surf_parse = surf_parse_bypass_platform; + gras_create_environment(NULL); + return 0; +} + +/** + * Register applicaiton for MSG + */ +static int msg_register_application(lua_State *L) +{ + MSG_function_register_default(run_lua_code); + surf_parse = surf_parse_bypass_application; + MSG_launch_application(NULL); + return 0; +} + +/* + * Register application for gras + */ +static int gras_register_application(lua_State *L) +{ + gras_function_register_default(run_lua_code); + surf_parse = surf_parse_bypass_application; + gras_launch_application(NULL); + return 0; +} static const luaL_Reg simgrid_funcs[] = { { "create_environment", create_environment}, { "launch_application", launch_application}, @@ -386,6 +1036,15 @@ static const luaL_Reg simgrid_funcs[] = { /* short names */ { "platform", create_environment}, { "application", launch_application}, + /* methods to bypass XML parser*/ + { "msg_register_platform",msg_register_platform}, + { "sd_register_platform",sd_register_platform}, + { "msg_register_application",msg_register_application}, + { "gras_register_platform",gras_register_platform}, + { "gras_register_application",gras_register_application}, + /* gras sub generator method*/ + {"gras_set_process_function",gras_add_process_function}, + {"gras_generate",gras_generate}, { NULL, NULL } }; @@ -396,40 +1055,44 @@ static const luaL_Reg simgrid_funcs[] = { extern const char*xbt_ctx_factory_to_use; /*Hack: let msg load directly the right factory */ #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) { - //xbt_ctx_factory_to_use = "lua"; + //xbt_ctx_factory_to_use = "lua"; 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"); - xbt_assert1(lua_istable(L,-1),"arg parameter is not a table but a %s",lua_typename(L,-1)); - int done=0; - while (!done) { - argc++; - lua_pushinteger(L,argc-2); - lua_gettable(L,-2); - if (lua_isnil(L,-1)) { - done = 1; - } else { - xbt_assert1(lua_isstring(L,-1),"argv[%d] got from lua is no string",argc-1); - xbt_assert2(argc