Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Remove an obsolete function
[simgrid.git] / src / bindings / lua / lua_state_cloner.c
1 /* Copyright (c) 2010. The SimGrid Team.
2  * All rights reserved.                                                     */
3
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. */
6
7 /* SimGrid Lua state management                                             */
8
9 #include "lua_state_cloner.h"
10 #include "lua_utils.h"
11 #include "xbt.h"
12 #include "xbt/log.h"
13 #include <lauxlib.h>
14 #include <lualib.h>
15
16 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(lua_state_cloner, lua, "Lua state management");
17
18 static void sglua_add_maestro_table(lua_State* L, int index, void* maestro_table_ptr);
19 static void* sglua_get_maestro_table_ptr(lua_State* L, int index);
20 static void sglua_get_table_by_ptr(lua_State* L, void* table_ptr);
21 static int l_get_from_maestro(lua_State* L);
22
23 static void sglua_copy_nil(lua_State* src, lua_State* dst);
24 static void sglua_copy_number(lua_State* src, lua_State* dst);
25 static void sglua_copy_boolean(lua_State* src, lua_State* dst);
26 static void sglua_copy_string(lua_State* src, lua_State* dst);
27 static void sglua_copy_table(lua_State* src, lua_State* dst);
28 static void sglua_copy_function(lua_State* src, lua_State* dst);
29 static void sglua_copy_lightuserdata(lua_State* src, lua_State* dst);
30 static void sglua_copy_userdata(lua_State* src, lua_State* dst);
31 static void sglua_copy_thread(lua_State* src, lua_State* dst);
32
33 /**
34  * @brief Adds a reference to a maestro table to the list of known maestro
35  * tables of a state.
36  *
37  * TODO identify maestro's tables with my own IDs instead of pointers
38  * to Lua internals
39  *
40  * @param L a state (can be maestro itself)
41  * @param index index of the copy of the maestro table in the stack of L
42  * @param maestro_table_ptr pointer to the original table in maestro's world
43  */
44 void sglua_add_maestro_table(lua_State* L, int index, void* maestro_table_ptr) {
45
46   /* we will set both [ptr] -> table and [table] -> ptr */
47
48                                   /* ... */
49   lua_pushvalue(L, index);
50                                   /* ... table */
51   lua_pushstring(L, "simgrid.maestro_tables");
52                                   /* ... table "simgrid.maestro_tables" */
53   lua_rawget(L, LUA_REGISTRYINDEX);
54                                   /* ... table maestrotbs */
55   lua_pushvalue(L, -2);
56                                   /* ... table maestrotbs table */
57   lua_pushlightuserdata(L, maestro_table_ptr);
58                                   /* ... table maestrotbs table tableptr */
59   lua_pushvalue(L, -1);
60                                   /* ... table maestrotbs table tableptr tableptr */
61   lua_pushvalue(L, -3);
62                                   /* ... table maestrotbs table tableptr tableptr table */
63   lua_settable(L, -5);
64                                   /* ... table maestrotbs table tableptr */
65   lua_settable(L, -3);
66                                   /* ... table maestrotbs */
67   lua_pop(L, 2);
68                                   /* ... */
69 }
70
71 /**
72  * @brief For a table in the stack of L, returns a pointer that identifies the
73  * same table in in maestro's world.
74  * @param L a Lua state
75  * @param index index of a table in the stack of L
76  * @return a pointer to maestro's copy of this table, or NULL if this table
77  * did not come from maestro
78  */
79 static void* sglua_get_maestro_table_ptr(lua_State* L, int index) {
80
81   void* maestro_table_ptr = NULL;
82                                   /* ... */
83   lua_pushvalue(L, index);
84                                   /* ... table */
85   lua_pushstring(L, "simgrid.maestro_tables");
86                                   /* ... table "simgrid.maestro_tables" */
87   lua_rawget(L, LUA_REGISTRYINDEX);
88                                   /* ... table maestrotbs */
89   lua_pushvalue(L, -2);
90                                   /* ... table maestrotbs table */
91   lua_gettable(L, -2);
92                                   /* ... table maestrotbs tableptr/nil */
93   if (!lua_isnil(L, -1)) {
94                                   /* ... table maestrotbs tableptr */
95     maestro_table_ptr = (void*) lua_topointer(L, -1);
96   }
97
98   lua_pop(L, 3);
99                                   /* ... */
100   return maestro_table_ptr;
101 }
102
103 /**
104  * @brief Pushes a table knowing a pointer to maestro's copy of this table.
105  *
106  * Pushes nil if L does not know this table in maestro.
107  *
108  * @param L a Lua state
109  * @param maestro_table_ptr pointer that identifies a table in maestro's world
110  */
111 static void sglua_get_table_by_ptr(lua_State* L, void* maestro_table_ptr) {
112
113                                   /* ... */
114   lua_pushstring(L, "simgrid.maestro_tables");
115                                   /* ... "simgrid.maestro_tables" */
116   lua_rawget(L, LUA_REGISTRYINDEX);
117                                   /* ... maestrotbs */
118   lua_pushlightuserdata(L, maestro_table_ptr);
119                                   /* ... maestrotbs tableptr */
120   lua_gettable(L, -2);
121                                   /* ... maestrotbs table/nil */
122   lua_remove(L, -2);
123                                   /* ... table/nil */
124 }
125
126 /**
127  * @brief Pops a value from the stack of a source state and pushes it on the
128  * stack of another state.
129  *
130  * If the value is a table, its content is copied recursively.
131  *
132  * TODO: add support of closures
133  *
134  * @param src the source state (not necessarily maestro)
135  * @param dst the destination state
136  */
137 void sglua_move_value(lua_State* src, lua_State *dst) {
138
139   luaL_checkany(src, -1);                  /* check the value to copy */
140
141   int indent = (lua_gettop(dst) - 1) * 6;
142   XBT_DEBUG("%sCopying data %s", sglua_get_spaces(indent), sglua_tostring(src, -1));
143
144   sglua_stack_dump("src before copying a value (should be ... value): ", src);
145   sglua_stack_dump("dst before copying a value (should be ...): ", dst);
146
147   switch (lua_type(src, -1)) {
148
149     case LUA_TNIL:
150       sglua_copy_nil(src, dst);
151       break;
152
153     case LUA_TNUMBER:
154       sglua_copy_number(src, dst);
155       break;
156
157     case LUA_TBOOLEAN:
158       sglua_copy_boolean(src, dst);
159       break;
160
161     case LUA_TSTRING:
162       sglua_copy_string(src, dst);
163       break;
164
165     case LUA_TFUNCTION:
166       sglua_copy_function(src, dst);
167       break;
168
169     case LUA_TTABLE:
170       sglua_copy_table(src, dst);
171       break;
172
173     case LUA_TLIGHTUSERDATA:
174       sglua_copy_lightuserdata(src, dst);
175       break;
176
177     case LUA_TUSERDATA:
178       sglua_copy_userdata(src, dst);
179       break;
180
181     case LUA_TTHREAD:
182       sglua_copy_thread(src, dst);
183       break;
184   }
185
186   /* the value has been copied to dst: remove it from src */
187   lua_pop(src, 1);
188
189   indent -= 2;
190   XBT_DEBUG("%sData copied", sglua_get_spaces(indent));
191
192   sglua_stack_dump("src after copying a value (should be ...): ", src);
193   sglua_stack_dump("dst after copying a value (should be ... value): ", dst);
194 }
195
196 /**
197  * @brief Copies the nil value on the top of src to the top of dst.
198  * @param src source state
199  * @param dst destination state
200  */
201 static void sglua_copy_nil(lua_State* src, lua_State* dst) {
202   lua_pushnil(dst);
203 }
204
205 /**
206  * @brief Copies the number value on the top of src to the top of dst.
207  * @param src source state
208  * @param dst destination state
209  */
210 static void sglua_copy_number(lua_State* src, lua_State* dst) {
211   lua_pushnumber(dst, lua_tonumber(src, -1));
212 }
213
214 /**
215  * @brief Copies the boolean value on the top of src to the top of dst.
216  * @param src source state
217  * @param dst destination state
218  */
219 static void sglua_copy_boolean(lua_State* src, lua_State* dst) {
220   lua_pushboolean(dst, lua_toboolean(src, -1));
221 }
222
223 /**
224  * @brief Copies the string value on the top of src to the top of dst.
225  * @param src source state
226  * @param dst destination state
227  */
228 static void sglua_copy_string(lua_State* src, lua_State* dst) {
229
230   /* no worries about memory: lua_pushstring makes a copy */
231   lua_pushstring(dst, lua_tostring(src, -1));
232 }
233
234 /**
235  * @brief Copies the table value on the top of src to the top of dst.
236  *
237  * A deep copy of the table is made. If the table has a metatable, the
238  * metatable is also copied.
239  * If the table is already known by the destination state, it is not copied
240  * again.
241  *
242  * @param src source state
243  * @param dst destination state
244  */
245 static void sglua_copy_table(lua_State* src, lua_State* dst) {
246
247                                   /* src: ... table
248                                      dst: ... */
249   int indent = lua_gettop(dst) * 6  + 2;
250
251   /* get from maestro the pointer that identifies this table */
252   void* table_ptr = sglua_get_maestro_table_ptr(src, -1);
253   if (table_ptr == NULL) {
254     /* the table didn't come from maestro: nevermind, use the pointer of src */
255     table_ptr = (void*) lua_topointer(src, -1);
256
257     if (!sglua_is_maestro(src)) {
258       XBT_DEBUG("%sMaestro does not know this table",
259           sglua_get_spaces(indent));
260     }
261   }
262
263   if (sglua_is_maestro(src)) {
264     /* register the table in maestro itself */
265     XBT_DEBUG("%sKeeping track of this table in maestro itself",
266         sglua_get_spaces(indent));
267     sglua_add_maestro_table(src, -1, table_ptr);
268     xbt_assert(sglua_get_maestro_table_ptr(src, -1) == table_ptr);
269   }
270
271   /* to avoid infinite recursion, see if this table is already known by dst */
272   sglua_get_table_by_ptr(dst, table_ptr);
273                                   /* dst: ... table/nil */
274   if (!lua_isnil(dst, -1)) {
275     XBT_DEBUG("%sNothing to do: table already known (%p)",
276         sglua_get_spaces(indent), table_ptr);
277                                   /* dst: ... table */
278   }
279   else {
280     XBT_DEBUG("%sFirst visit of this table (%p)", sglua_get_spaces(indent),
281         table_ptr);
282                                   /* dst: ... nil */
283     lua_pop(dst, 1);
284                                   /* dst: ... */
285
286     /* first visit: create the new table in dst */
287     lua_newtable(dst);
288                                   /* dst: ... table */
289
290     /* mark the table as known right now to avoid infinite recursion */
291     sglua_add_maestro_table(dst, -1, table_ptr);
292     /* FIXME: we may have added a table with a non-maestro pointer, is this a
293        problem? */
294     XBT_DEBUG("%sTable marked as known", sglua_get_spaces(indent));
295     xbt_assert(sglua_get_maestro_table_ptr(dst, -1) == table_ptr);
296
297     sglua_stack_dump("dst after marking the table as known (should be ... table): ", dst);
298
299     /* copy the metatable if any */
300     int has_meta_table = lua_getmetatable(src, -1);
301                                   /* src: ... table mt? */
302     if (has_meta_table) {
303       XBT_DEBUG("%sCopying the metatable", sglua_get_spaces(indent));
304                                   /* src: ... table mt */
305       sglua_copy_table(src, dst);
306                                   /* dst: ... table mt */
307       lua_pop(src, 1);
308                                   /* src: ... table */
309       lua_setmetatable(dst, -2);
310                                   /* dst: ... table */
311     }
312     else {
313                                   /* src: ... table */
314       XBT_DEBUG("%sNo metatable", sglua_get_spaces(indent));
315     }
316
317     sglua_stack_dump("src before traversing the table (should be ... table): ", src);
318     sglua_stack_dump("dst before traversing the table (should be ... table): ", dst);
319
320     /* traverse the table of src and copy each element */
321     lua_pushnil(src);
322                                   /* src: ... table nil */
323     while (lua_next(src, -2) != 0) {
324                                   /* src: ... table key value */
325
326       XBT_DEBUG("%sCopying table element %s", sglua_get_spaces(indent),
327           sglua_keyvalue_tostring(src, -2, -1));
328
329       sglua_stack_dump("src before copying table element (should be ... table key value): ", src);
330       sglua_stack_dump("dst before copying table element (should be ... table): ", dst);
331
332       /* copy the key */
333       lua_pushvalue(src, -2);
334                                   /* src: ... table key value key */
335       indent += 2;
336       XBT_DEBUG("%sCopying the key part of the table element",
337           sglua_get_spaces(indent));
338       sglua_move_value(src, dst);
339                                   /* src: ... table key value
340                                      dst: ... table key */
341       XBT_DEBUG("%sCopied the key part of the table element",
342           sglua_get_spaces(indent));
343
344       /* copy the value */
345       XBT_DEBUG("%sCopying the value part of the table element",
346           sglua_get_spaces(indent));
347       sglua_move_value(src, dst);
348                                   /* src: ... table key
349                                      dst: ... table key value */
350       XBT_DEBUG("%sCopied the value part of the table element",
351           sglua_get_spaces(indent));
352       indent -= 2;
353
354       /* set the table element */
355       lua_settable(dst, -3);
356                                   /* dst: ... table */
357
358       /* the key stays on top of src for next iteration */
359       sglua_stack_dump("src before next iteration (should be ... table key): ", src);
360       sglua_stack_dump("dst before next iteration (should be ... table): ", dst);
361
362       XBT_DEBUG("%sTable element copied", sglua_get_spaces(indent));
363     }
364     XBT_DEBUG("%sFinished traversing the table", sglua_get_spaces(indent));
365   }
366 }
367
368 /**
369  * @brief Copies the function on the top of src to the top of dst.
370  *
371  * It can be a Lua function or a C function.
372  * Copying upvalues is not implemented yet.
373  *
374  * @param src source state
375  * @param dst destination state
376  */
377 static void sglua_copy_function(lua_State* src, lua_State* dst) {
378
379   if (lua_iscfunction(src, -1)) {
380     /* it's a C function: just copy the pointer */
381     lua_CFunction f = lua_tocfunction(src, -1);
382     lua_pushcfunction(dst, f);
383   }
384   else {
385     /* it's a Lua function: dump it from src */
386
387     s_sglua_buffer_t buffer;
388     buffer.capacity = 64;
389     buffer.size = 0;
390     buffer.data = xbt_new(char, buffer.capacity);
391
392     /* copy the binary chunk from src into a buffer */
393     int error = lua_dump(src, sglua_memory_writer, &buffer);
394     xbt_assert(!error, "Failed to dump the function from the source state: error %d",
395         error);
396
397     /* load the chunk into dst */
398     error = luaL_loadbuffer(dst, buffer.data, buffer.size, "(dumped function)");
399     xbt_assert(!error, "Failed to load the function into the destination state: %s",
400         lua_tostring(dst, -1));
401   }
402 }
403
404 /**
405  * @brief Copies the light userdata on the top of src to the top of dst.
406  * @param src source state
407  * @param dst destination state
408  */
409 static void sglua_copy_lightuserdata(lua_State* src, lua_State* dst) {
410   lua_pushlightuserdata(dst, lua_touserdata(src, -1));
411 }
412
413 /**
414  * @brief Copies the full userdata on the top of src to the top of dst.
415  *
416  * If the userdata has a metatable, the metatable is also copied.
417  *
418  * @param src source state
419  * @param dst destination state
420  */
421 static void sglua_copy_userdata(lua_State* src, lua_State* dst) {
422
423   int indent = lua_gettop(dst) * 6  + 2;
424
425   /* copy the data */
426                                   /* src: ... udata
427                                      dst: ... */
428   size_t size = lua_objlen(src, -1);
429   void* src_block = lua_touserdata(src, -1);
430   void* dst_block = lua_newuserdata(dst, size);
431                                   /* dst: ... udata */
432   memcpy(dst_block, src_block, size);
433
434   /* copy the metatable if any */
435   int has_meta_table = lua_getmetatable(src, -1);
436                                   /* src: ... udata mt? */
437   if (has_meta_table) {
438     XBT_DEBUG("%sCopying metatable of userdata (%p)",
439         sglua_get_spaces(indent), lua_topointer(src, -1));
440                                   /* src: ... udata mt */
441     sglua_copy_table(src, dst);
442                                   /* src: ... udata mt
443                                      dst: ... udata mt */
444     lua_pop(src, 1);
445                                   /* src: ... udata */
446     lua_setmetatable(dst, -2);
447                                   /* dst: ... udata */
448
449     XBT_DEBUG("%sMetatable of userdata copied", sglua_get_spaces(indent));
450   }
451   else {
452     XBT_DEBUG("%sNo metatable for this userdata",
453         sglua_get_spaces(indent));
454                                   /* src: ... udata */
455   }
456 }
457
458 /**
459  * @brief This operation is not supported (yet?) so it just pushes nil.
460  *
461  * @param src source state
462  * @param dst destination state
463  */
464 static void sglua_copy_thread(lua_State* src, lua_State* dst) {
465
466   XBT_WARN("Copying a thread from another state is not implemented (yet?).");
467   lua_pushnil(dst);
468 }
469
470 /**
471  * @brief Copies a global value or a registry value from the maestro state.
472  *
473  * The state L must have been created by sglua_clone_maestro_state().
474  * This function is meant to be an __index metamethod.
475  * Consequently, it assumes that the stack has two elements:
476  * a table (either the environment or the registry of L) and the string key of
477  * a value that does not exist yet in this table. It copies the corresponding
478  * value from maestro and pushes it on the stack of L.
479  * If the value does not exist in maestro state either, nil is pushed.
480  *
481  * TODO: make this function thread safe. If the simulation runs in parallel,
482  * several simulated processes may trigger this __index metamethod at the same
483  * time and get globals from maestro.
484  *
485  * @param L the current state
486  * @return number of return values pushed (always 1)
487  */
488 static int l_get_from_maestro(lua_State *L) {
489
490   /* check the arguments */
491   luaL_checktype(L, 1, LUA_TTABLE);
492   const char* key = luaL_checkstring(L, 2);
493                                   /* L:      table key */
494   XBT_DEBUG("__index of '%s' begins", key);
495
496   /* want a global or a registry value? */
497   int pseudo_index;
498   if (lua_equal(L, 1, LUA_REGISTRYINDEX)) {
499     /* registry */
500     pseudo_index = LUA_REGISTRYINDEX;
501     XBT_DEBUG("Will get the value from the registry of maestro");
502   }
503   else {
504     /* global */
505     pseudo_index = LUA_GLOBALSINDEX;
506     XBT_DEBUG("Will get the value from the globals of maestro");
507   }
508
509   /* get the father */
510   lua_State* maestro = sglua_get_maestro();
511
512                                   /* L:      table key */
513
514   /* get the value from maestro */
515   lua_getfield(maestro, pseudo_index, key);
516                                   /* maestro: ... value */
517
518   /* push the value onto the stack of L */
519   sglua_move_value(maestro, L);
520                                   /* maestro: ...
521                                      L:      table key value */
522
523   /* prepare the return value of __index */
524   lua_pushvalue(L, -1);
525                                   /* L:      table key value value */
526   lua_insert(L, 1);
527                                   /* L:      value table key value */
528
529   /* save the copied value in the table for subsequent accesses */
530   lua_settable(L, -3);
531                                   /* L:      value table */
532   lua_settop(L, 1);
533                                   /* L:      value */
534
535   XBT_DEBUG("__index of '%s' returns %s", key, sglua_tostring(L, -1));
536
537   return 1;
538 }
539
540 /**
541  * @brief Creates a new Lua state and get its environment from the maestro
542  * state.
543  *
544  * The state created is independent from maestro and has its own copies of
545  * global and registry values.
546  * However, the global and registry values are not copied right now from
547  * the original state; they are copied only the first time they are accessed.
548  * This behavior saves time and memory, and is okay for Simgrid's needs.
549  *
550  * TODO: if the simulation runs in parallel, copy everything right now?
551  *
552  * @return the state created
553  */
554 lua_State* sglua_clone_maestro(void) {
555
556   /* create the new state */
557   lua_State *L = luaL_newstate();
558
559   /* set its environment and its registry:
560    * - create a table newenv
561    * - create a metatable mt
562    * - set mt.__index = a function that copies the global from the father state
563    * - set mt as the metatable of the registry
564    * - set mt as the metatable of newenv
565    * - set newenv as the environment of the new state
566    */
567   lua_pushthread(L);                        /* thread */
568   lua_newtable(L);                          /* thread newenv */
569   lua_newtable(L);                          /* thread newenv mt */
570   lua_pushvalue(L, LUA_REGISTRYINDEX);      /* thread newenv mt reg */
571   lua_pushcfunction(L, l_get_from_maestro); /* thread newenv mt reg f */
572   lua_setfield(L, -3, "__index");           /* thread newenv mt reg */
573   lua_pushvalue(L, -2);                     /* thread newenv mt reg mt */
574   lua_setmetatable(L, -2);                  /* thread newenv mt reg */
575   lua_pop(L, 1);                            /* thread newenv mt */
576   lua_setmetatable(L, -2);                  /* thread newenv */
577   lua_setfenv(L, -2);                       /* thread */
578   lua_pop(L, 1);                            /* -- */
579
580   /* create the table of known tables from maestro */
581   lua_pushstring(L, "simgrid.maestro_tables");
582                                             /* "simgrid.maestro_tables" */
583   lua_newtable(L);                          /* "simgrid.maestro_tables" maestrotbs*/
584   lua_rawset(L, LUA_REGISTRYINDEX);
585                                             /* -- */
586
587   /* open the standard libs (theoretically, this is not necessary as they can
588    * be inherited like any global values, but without a proper support of
589    * closures, iterators like ipairs don't work). */
590   XBT_DEBUG("Metatable of globals and registry set, opening standard libraries now");
591   luaL_openlibs(L);
592
593   XBT_DEBUG("New state created");
594
595   return L;
596 }