lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index]

Hi, list!

I'm writing a generic task server. Each task is a Lua coroutine.
Server runs several system threads, each thread with separate Lua
state. Each state may contain many tasks. New tasks are added to the
least loaded thread. Preliminary analysis suggest that performance
would benefit from some more fine-grained load balancing on the server
-- make each task thread-independent, to allow next available thread
to update next available task.

This is not easy thing to do though.

Simplest solution would be to keep a separate Lua state for each task
(possibly with cache of states). This would require almost no
modifications to existing code. However, I'm afraid (haven't tested
yet) that this solution is too heavy as I have too many script files
to read, compile and execute on state creation (okay, no compile step
with precompiled code; also can keep all sources cached in memory...
but still feels like too much). I thought about loading single Lua
state and then cloning it with lper. However this is Linux-only
solution. Furthermore, LPSM seems to be abandoned long ago. Have any
one used it in production environment?

Then there is an option to keep single state per thread and to copy
task data between them. This looks even less viable. My tasks are
sometimes data-heavy (up to few megabytes), and I expect serialization
and deserialization on each tick to take too much time. Also, this
imposes restrictions on what may be serialized -- I'd like to avoid
using low-level patches/libraries like Pluto. What-to-serialize
problems are not too much complex to workaround, but would require
some painful code changes -- again, hard to expect serialization
performance to be good enough.

I have never looked close enough, but looks like existing solutions
like Copas and Helper Threads Toolkit are not exactly fit to my
problem. Perhaps there is something else that I've missed? Any recent
advances in the field? Any advice?

Perhaps there is some way to implement some performance-effective
cross-state Lua table? Looks like such thing (albeit filled with
native Lua data only, and no coroutines/functions with upvalues etc.)
would benefit implementing second solution by eliminating the need of
serialization. But then, I guess, even *if* it would be possible, it
would involve some nasty core source patching. :-)