X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/521aa2e579bdf76e25487fb6b9019e78ec75ad32..ed5bc1532577eb73f0ae8ebe686961097ae30fdf:/src/bindings/lua/simgrid_lua.c diff --git a/src/bindings/lua/simgrid_lua.c b/src/bindings/lua/simgrid_lua.c index 7c395d2ff4..81cb592a91 100644 --- a/src/bindings/lua/simgrid_lua.c +++ b/src/bindings/lua/simgrid_lua.c @@ -1,33 +1,39 @@ /* 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 - +#include +#include #include "msg/msg.h" #include "xbt.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" +#undef BYPASS_MODEL /* ********************************************************************************* */ /* helper functions */ /* ********************************************************************************* */ -static void stackDump (lua_State *L) { +static void stackDump (const char *msg, 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) { @@ -44,101 +50,161 @@ static void stackDump (lua_State *L) { p+=sprintf(p,"%g", lua_tonumber(L, i)); break; + case LUA_TTABLE: + p+=sprintf(p, "Table"); + break; + default: /* other values */ - if ((ptr = luaL_checkudata(L,i,TASK_MODULE_NAME))) { + 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)); - } + }*/ break; } p+=sprintf(p," "); /* put a separator */ } - INFO1("%s",buff); + INFO2("%s%s",msg,buff); } /** @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); + 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); + luaL_typerror(L,index,TASK_MODULE_NAME); tk = *pi; if(!tk) - luaL_error(L,"null Task"); + luaL_error(L,"null Task"); + 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 */ -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; - -} - - /* ********************************************************************************* */ /* wrapper functions */ /* ********************************************************************************* */ +/** + * 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); - // FIXME: data shouldn't be NULL I guess - pushTask(L,MSG_task_create(name,comp_size,msg_size,NULL)); - INFO0("Created task"); - 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) { - m_task_t tk = checkTask(L,1); + 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); + 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); + 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); + 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) { - m_task_t tk = checkTask(L,1); - const char *mailbox = luaL_checkstring(L,2); - stackDump(L);fflush(stdout);fflush(stderr); - int res = MSG_task_send(tk,mailbox); - res++;//FIXME: check it instead of avoiding the warning - stackDump(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"); + break; + case MSG_TRANSFER_FAILURE : + ERROR0("MSG_task_send failed : Transfer Failure"); + break; + case MSG_HOST_FAILURE : + ERROR0("MSG_task_send failed : Host Failure "); + break; + default : + ERROR0("MSG_task_send failed : Unexpected error , please report this bug"); + break; + } return 0; } + static int Task_recv(lua_State *L) { m_task_t tk = NULL; - //stackDump(L); - const char *mailbox = luaL_checkstring(L,1); - int res = MSG_task_receive(&tk,mailbox); - res++;//FIXME: check it instead of avoiding the warning - INFO1("Task Name : >>>%s",MSG_task_get_name(tk)); - pushTask(L,tk); - // stackDump(L); + 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; + } + return 1; } @@ -153,9 +219,8 @@ static const luaL_reg Task_methods[] = { {0,0} }; static int Task_gc(lua_State *L) { - m_task_t tk=checkTask(L,1); + m_task_t tk=checkTask(L,-1); if (tk) MSG_task_destroy(tk); - //printf("GoodBye Task(%p)\n",lua_touserdata(L,1)); return 0; } @@ -164,34 +229,584 @@ static int Task_tostring(lua_State *L) { return 1; } - static const luaL_reg Task_meta[] = { {"__gc", Task_gc}, {"__tostring", Task_tostring}, {0,0} }; +/** + * 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); + 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); + 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()); + 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 +{ + const char* id; + double bandwidth; + double latency; +}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 resource + +/*FIXME : still have to use a dictionary as argument make it possible to +consider some arguments as optional and removes the importance of the +parameter order */ + +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_ON; + else + state_init = SURF_RESOURCE_OFF; + 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); + +} + +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; + +} + + +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; + //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); + + } 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; + xbt_dynar_push(link_list_d,&link); + return 0; +} + +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; +} + +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); + 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 + */ +static int surf_parse_bypass_platform() +{ + char buffer[22]; + unsigned int i,j; + char* link_id; + + p_host_attr p_host; + p_link_attr p_link; + p_route_attr p_route; + + static int AX_ptr = 0; + static int surfxml_bufferstack_size = 2048; + + /* FIXME allocating memory for the buffer, I think 2kB should be enough */ + surfxml_bufferstack = xbt_new0(char, surfxml_bufferstack_size); + /* */ +#ifndef BYPASS_CPU + SURFXML_BUFFER_SET(platform_version, "2"); + SURFXML_START_TAG(platform); +#endif + + // Add Hosts + xbt_dynar_foreach(host_list_d,i,p_host) + { + +#ifdef BYPASS_MODEL + 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); +#else + + SURFXML_BUFFER_SET(host_id,p_host->id); + sprintf(buffer,"%f",p_host->power_peak); + SURFXML_BUFFER_SET(host_power,buffer); + SURFXML_BUFFER_SET(host_availability, "1.0"); + SURFXML_BUFFER_SET(host_availability_file, ""); + A_surfxml_host_state = A_surfxml_host_state_ON; + SURFXML_BUFFER_SET(host_state_file, ""); + SURFXML_BUFFER_SET(host_interference_send, "1.0"); + SURFXML_BUFFER_SET(host_interference_recv, "1.0"); + SURFXML_BUFFER_SET(host_interference_send_recv, "1.0"); + SURFXML_BUFFER_SET(host_max_outgoing_rate, "-1.0"); + SURFXML_START_TAG(host); + SURFXML_END_TAG(host); +#endif + } + + //add Links + xbt_dynar_foreach(link_list_d,i,p_link) + { +#ifdef BYPASS_MODEL + surf_link_create_resouce((char*)p_link->id,p_link->bandwidth,p_link->latency); +#else + + SURFXML_BUFFER_SET(link_id,p_link->id); + sprintf(buffer,"%f",p_link->bandwidth); + SURFXML_BUFFER_SET(link_bandwidth,buffer); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + sprintf(buffer,"%f",p_link->latency); + SURFXML_BUFFER_SET(link_latency,buffer); + SURFXML_BUFFER_SET(link_latency_file, ""); + A_surfxml_link_state = A_surfxml_link_state_ON; + SURFXML_BUFFER_SET(link_state_file, ""); + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); +#endif + } + + // add route + xbt_dynar_foreach(route_list_d,i,p_route) + { +#ifdef BYPASS_MODEL + surf_route_set_resource((char*)p_route->src_id,(char*)p_route->dest_id,p_route->links_id,0); +#else + + SURFXML_BUFFER_SET(route_src,p_route->src_id); + SURFXML_BUFFER_SET(route_dst,p_route->dest_id); + SURFXML_BUFFER_SET(route_impact_on_src, "0.0"); + SURFXML_BUFFER_SET(route_impact_on_dst, "0.0"); + SURFXML_BUFFER_SET(route_impact_on_src_with_other_recv, "0.0"); + SURFXML_BUFFER_SET(route_impact_on_dst_with_other_send, "0.0"); + SURFXML_START_TAG(route); + + xbt_dynar_foreach(p_route->links_id,j,link_id) + { + SURFXML_BUFFER_SET(link_c_ctn_id,link_id); + SURFXML_START_TAG(link_c_ctn); + SURFXML_END_TAG(link_c_ctn); + + } + + SURFXML_END_TAG(route); +#endif + } + /* */ +#ifndef BYPASS_MODEL + SURFXML_END_TAG(platform); +#endif + + free(surfxml_bufferstack); + return 0; // must return 0 ?!! + +} +/* + * surf parse bypass application + */ +static int surf_parse_bypass_application() +{ + unsigned int i,j; + p_host_attr p_host; + char * arg; + static int AX_ptr; + static int surfxml_bufferstack_size = 2048; + /* FIXME ( should be manual )allocating memory to the buffer, I think 2MB should be enough */ + surfxml_bufferstack = xbt_new0(char, surfxml_bufferstack_size); + +#ifdef BYPASS_MODEL + 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); + } +#else + + /* */ + SURFXML_BUFFER_SET(platform_version, "2"); + SURFXML_START_TAG(platform); + xbt_dynar_foreach(host_list_d,i,p_host) + { + if(p_host->function) + { + SURFXML_BUFFER_SET(process_host, p_host->id); + SURFXML_BUFFER_SET(process_function, p_host->function); + SURFXML_BUFFER_SET(process_start_time, "-1.0"); + SURFXML_BUFFER_SET(process_kill_time, "-1.0"); + SURFXML_START_TAG(process); + //args + xbt_dynar_foreach(p_host->args_list,j,arg) + { + SURFXML_BUFFER_SET(argument_value,arg); + SURFXML_START_TAG(argument); + SURFXML_END_TAG(argument); + } + SURFXML_END_TAG(process); + } + } + /* */ + SURFXML_END_TAG(platform); +#endif + free(surfxml_bufferstack); + 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} +}; + +static int Host_gc(lua_State *L) +{ + m_host_t ht = checkHost(L,-1); + if (ht) ht = NULL; + return 0; +} + +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} +}; + +/* + * 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) { + 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 + 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]); + + // push arguments onto the stack + int i; + for(i=1;i