Re: safely buffering Lua data between (system) threads & lua

On Sep 15, 2006, at 5:15 PM, Luiz Henrique de Figueiredo wrote:

How much can I copy Lua data around between distinct
states (assuming thread safety is managed correctly)?

If you have got your locking right, you can use lua_xmove if the Lua
states are related (ie, children of the same Lua top state).

Aha! I didn't realise what lua_newthread did (I thought it was something to do with coroutines). OK. So if I understand correctly, I can have a root lua_State in one thread, create new lua_States from it using lua_newthread(), which will be managed in other threads, but create thread-safe interchanges between them using lua_xmove.

So lua_xmove is really creating copies from one stack to another. How are references resolved - are they deep copies?

lua_newthread retains references to global data; how can this be thread safe if both the old & new threads (running in different system threads) can access them? Are they also independent copies?

Sorry if I'm not understanding something here.

According to the manual:

lua_newthread

lua_State *lua_newthread (lua_State *L);

Creates a new thread, pushes it on the stack, and returns a pointer to a lua_State that represents this new thread. The new state returned by this function shares with the original state all global objects (such as tables), but has an independent execution stack.

There is no explicit function to close or to destroy a thread. Threads are subject to garbage collection, like any Lua object.