1 /* Copyright (c) 2010. The SimGrid Team.
2 * All rights reserved. */
4 /* This program is free software; you can redistribute it and/or modify it
5 * under the terms of the license (GNU LGPL) which comes with this package. */
7 #include "lua_private.h"
9 #include "lua_state_cloner.h"
12 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua_task, bindings, "Lua bindings (task module)");
14 #define TASK_MODULE_NAME "simgrid.task"
16 /* ********************************************************************************* */
17 /* simgrid.task API */
18 /* ********************************************************************************* */
21 * \brief Ensures that a value in the stack is a valid task and returns it.
22 * \param L a Lua state
23 * \param index an index in the Lua stack
24 * \return the C task corresponding to this Lua task
26 m_task_t sglua_check_task(lua_State* L, int index)
28 sglua_stack_dump("check task: ", L);
29 luaL_checktype(L, index, LUA_TTABLE);
31 lua_getfield(L, index, "__simgrid_task");
32 /* ... task ... ctask */
33 m_task_t task = *((m_task_t*) luaL_checkudata(L, -1, TASK_MODULE_NAME));
38 luaL_error(L, "This task was sent to someone else, you cannot access it anymore");
45 * \brief Creates a new task and leaves it onto the stack.
46 * \param L a Lua state
47 * \return number of values returned to Lua
49 * - Argument 1 (string): name of the task
50 * - Argument 2 (number): computation size
51 * - Argument 3 (number): communication size
52 * - Return value (task): the task created
54 * A Lua task is a regular table with a full userdata inside, and both share
55 * the same metatable. For the regular table, the metatable allows OO-style
56 * writing such as your_task:send(someone).
57 * For the userdata, the metatable is used to check its type.
58 * TODO: make the task name an optional last parameter
60 static int l_task_new(lua_State* L)
62 XBT_DEBUG("Task new");
63 const char* name = luaL_checkstring(L, 1);
64 int comp_size = luaL_checkint(L, 2);
65 int msg_size = luaL_checkint(L, 3);
69 m_task_t msg_task = MSG_task_create(name, comp_size, msg_size, NULL);
73 luaL_getmetatable(L, TASK_MODULE_NAME);
75 lua_setmetatable(L, -2);
77 m_task_t* lua_task = (m_task_t*) lua_newuserdata(L, sizeof(m_task_t));
80 luaL_getmetatable(L, TASK_MODULE_NAME);
82 lua_setmetatable(L, -2);
84 lua_setfield(L, -2, "__simgrid_task");
90 * \brief Returns the name of a task.
91 * \param L a Lua state
92 * \return number of values returned to Lua
94 * - Argument 1 (task): a task
95 * - Return value (string): name of the task
97 static int l_task_get_name(lua_State* L)
99 m_task_t task = sglua_check_task(L, 1);
100 lua_pushstring(L, MSG_task_get_name(task));
105 * \brief Returns the computation duration of a task.
106 * \param L a Lua state
107 * \return number of values returned to Lua
109 * - Argument 1 (task): a task
110 * - Return value (number): computation duration of this task
112 static int l_task_get_computation_duration(lua_State* L)
114 m_task_t task = sglua_check_task(L, 1);
115 lua_pushnumber(L, MSG_task_get_compute_duration(task));
120 * \brief Executes a task.
121 * \param L a Lua state
122 * \return number of values returned to Lua
124 * - Argument 1 (task): the task to execute
125 * - Return value (nil or string): nil if the task was successfully executed,
126 * or an error string in case of failure, which may be "task canceled" or
129 static int l_task_execute(lua_State* L)
131 m_task_t task = sglua_check_task(L, 1);
132 MSG_error_t res = MSG_task_execute(task);
138 lua_pushstring(L, sglua_get_msg_error(res));
144 * \brief Pops the Lua task from the stack and registers it so that the
145 * process can retrieve it later knowing the C task.
146 * \param L a lua state
148 void sglua_task_register(lua_State* L) {
150 m_task_t task = sglua_check_task(L, -1);
152 /* put in the C task a ref to the lua task so that the receiver finds it */
153 unsigned long ref = luaL_ref(L, LUA_REGISTRYINDEX);
155 MSG_task_set_data(task, (void*) ref);
159 * \brief Pushes onto the stack the Lua task corresponding to a C task.
161 * The Lua task must have been previously registered with task_register so
162 * that it can be retrieved knowing the C task.
164 * \param L a lua state
165 * \param task a C task
167 void sglua_task_unregister(lua_State* L, m_task_t task) {
170 /* the task is in my registry, put it onto my stack */
171 unsigned long ref = (unsigned long) MSG_task_get_data(task);
172 lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
174 luaL_unref(L, LUA_REGISTRYINDEX, ref);
175 MSG_task_set_data(task, NULL);
179 * \brief This function is called when a C task has just been copied.
181 * This callback is used to move the corresponding Lua task from the sender
182 * process to the receiver process.
183 * It is executed in SIMIX kernel mode when the communication finishes,
184 * before both processes are awaken. Thus, this function is thread-safe when
185 * user processes are executed in parallel, though it modifies the Lua
186 * stack of both processes to move the task.
187 * After this function, both Lua stacks are restored in their previous state.
188 * The task is moved from the registry of the sender to the registry of the
191 * \param task the task copied
192 * \param src_process the sender
193 * \param dst_process the receiver
195 static void task_copy_callback(m_task_t task, m_process_t src_process,
196 m_process_t dst_process) {
198 lua_State* src = MSG_process_get_data(src_process);
199 lua_State* dst = MSG_process_get_data(dst_process);
203 sglua_task_unregister(src, task);
205 sglua_copy_value(src, dst);
208 sglua_task_register(dst); /* dst: ... */
210 /* the receiver is now the owner of the task and may destroy it:
211 * make the sender forget the C task so that it doesn't garbage */
212 lua_getfield(src, -1, "__simgrid_task");
213 /* src: ... task ctask */
214 m_task_t* udata = (m_task_t*) luaL_checkudata(src, -1, TASK_MODULE_NAME);
221 * \brief Sends a task to a mailbox and waits for its completion.
222 * \param L a Lua state
223 * \return number of values returned to Lua
225 * - Argument 1 (task): the task to send
226 * - Argument 2 (string or compatible): mailbox name, as a real string or any
227 * type convertible to string (numbers always are)
228 * - Return values (boolean + string): true if the communication was successful,
229 * or false plus an error string in case of failure, which may be "timeout",
230 * "host failure" or "transfer failure"
232 static int l_task_send(lua_State* L)
234 m_task_t task = sglua_check_task(L, 1);
235 const char* mailbox = luaL_checkstring(L, 2);
236 /* task mailbox ... */
239 sglua_task_register(L);
241 MSG_error_t res = MSG_task_send(task, mailbox);
244 lua_pushboolean(L, 1);
249 /* the communication has failed, I'm still the owner of the task */
250 sglua_task_unregister(L, task);
252 lua_pushboolean(L, 0);
254 lua_pushstring(L, sglua_get_msg_error(res));
255 /* task false error */
261 * \brief Sends a task on a mailbox.
262 * \param L a Lua state
263 * \return number of values returned to Lua
265 * This is a non-blocking function: use simgrid.comm.wait() or
266 * simgrid.comm.test() to end the communication.
268 * - Argument 1 (task): the task to send
269 * - Argument 2 (string or compatible): mailbox name, as a real string or any
270 * type convertible to string (numbers always are)
271 * - Return value (comm): a communication object to be used later with wait or test
273 static int l_task_isend(lua_State* L)
275 m_task_t task = sglua_check_task(L, 1);
276 const char* mailbox = luaL_checkstring(L, 2);
277 /* task mailbox ... */
280 sglua_task_register(L);
282 msg_comm_t comm = MSG_task_isend(task, mailbox);
284 sglua_push_comm(L, comm);
290 * \brief Sends a task on a mailbox on a best effort way (detached send).
291 * \param L a Lua state
292 * \return number of values returned to Lua
294 * Like simgrid.task.isend, this is a non-blocking function.
295 * You can use this function if you don't care about when the communication
296 * ends and whether it succeeds.
297 * FIXME: isn't this equivalent to calling simgrid.task.isend() and ignoring
300 * - Argument 1 (task): the task to send
301 * - Argument 2 (string or compatible): mailbox name, as a real string or any
302 * type convertible to string (numbers always are)
304 static int l_task_dsend(lua_State* L)
306 m_task_t task = sglua_check_task(L, 1);
307 const char* mailbox = luaL_checkstring(L, 2);
308 /* task mailbox ... */
311 sglua_task_register(L);
313 MSG_task_dsend(task, mailbox, NULL);
318 * \brief Receives a task.
319 * \param L a Lua state
320 * \return number of values returned to Lua
322 * - Argument 1 (string or compatible): mailbox name, as a real string or any
323 * type convertible to string (numbers always are)
324 * - Argument 2 (number, optional): timeout (default is no timeout)
325 * - Return values (task or nil + string): the task received, or nil plus an
326 * error message if the communication has failed
328 static int l_task_recv(lua_State* L)
330 m_task_t task = NULL;
331 const char* mailbox = luaL_checkstring(L, 1);
333 if (lua_gettop(L) >= 2) {
334 /* mailbox timeout ... */
335 timeout = luaL_checknumber(L, 2);
340 /* no timeout by default */
343 MSG_error_t res = MSG_task_receive_with_timeout(&task, mailbox, timeout);
346 sglua_task_unregister(L, task);
347 /* mailbox ... task */
352 /* mailbox ... nil */
353 lua_pushstring(L, sglua_get_msg_error(res));
354 /* mailbox ... nil error */
360 * \brief Asynchronously receives a task on a mailbox.
361 * \param L a Lua state
362 * \return number of values returned to Lua
364 * This is a non-blocking function: use simgrid.comm.wait() or
365 * simgrid.comm.test() to end the communication and get the task in case of
368 * - Argument 1 (string or compatible): mailbox name, as a real string or any
369 * type convertible to string (numbers always are)
370 * - Return value (comm): a communication object to be used later with wait or test
373 static int l_task_irecv(lua_State* L)
375 const char* mailbox = luaL_checkstring(L, 1);
377 m_task_t* task = xbt_new0(m_task_t, 1); // FIXME fix this leak
378 msg_comm_t comm = MSG_task_irecv(task, mailbox);
379 sglua_push_comm(L, comm);
380 /* mailbox ... comm */
384 static const luaL_reg task_functions[] = {
386 {"get_name", l_task_get_name},
387 {"get_computation_duration", l_task_get_computation_duration},
388 {"execute", l_task_execute},
389 {"send", l_task_send},
390 {"isend", l_task_isend},
391 {"dsend", l_task_dsend},
392 {"recv", l_task_recv},
393 {"irecv", l_task_irecv},
398 * \brief Finalizes the userdata of a task.
399 * \param L a Lua state
400 * \return number of values returned to Lua
402 * - Argument 1 (userdata): a C task, possibly NULL if it was sent to another
405 static int l_task_gc(lua_State* L)
408 m_task_t task = *((m_task_t*) luaL_checkudata(L, 1, TASK_MODULE_NAME));
409 /* the task is NULL if I sent it to someone else */
411 MSG_task_destroy(task);
417 * \brief Returns a string representation of a C task.
418 * \param L a Lua state
419 * \return number of values returned to Lua
421 * - Argument 1 (userdata): a task
422 * - Return value (string): a string describing this task
424 static int l_task_tostring(lua_State* L)
426 m_task_t task = *((m_task_t*) luaL_checkudata(L, 1, TASK_MODULE_NAME));
427 lua_pushfstring(L, "Task: %p", task);
432 * \brief Metamethods of both a task table and the userdata inside it.
434 static const luaL_reg task_meta[] = {
435 {"__gc", l_task_gc}, /* will be called only for userdata */
436 {"__tostring", l_task_tostring},
441 * \brief Registers the task functions into the table simgrid.task.
443 * Also initialize the metatable of the task userdata type.
445 * \param L a lua state
447 void sglua_register_task_functions(lua_State* L)
449 /* create a table simgrid.task and fill it with task functions */
450 luaL_openlib(L, TASK_MODULE_NAME, task_functions, 0);
453 /* create the metatable for tasks, add it to the Lua registry */
454 luaL_newmetatable(L, TASK_MODULE_NAME);
455 /* simgrid.task mt */
456 /* fill the metatable */
457 luaL_openlib(L, NULL, task_meta, 0);
458 /* simgrid.task mt */
459 lua_pushvalue(L, -2);
460 /* simgrid.task mt simgrid.task */
461 /* metatable.__index = simgrid.task
462 * we put the task functions inside the task itself:
463 * this allows to write my_task:method(args) for
464 * simgrid.task.method(my_task, args) */
465 lua_setfield(L, -2, "__index");
466 /* simgrid.task mt */
470 /* set up MSG to copy Lua tasks between states */
471 MSG_task_set_copy_callback(task_copy_callback);