WIP: Add fiber.lua module and use in leap.lua and WaitQueue.lua.

fiber.lua goes beyond coro.lua in that it distinguishes ready suspended
coroutines from waiting suspended coroutines, and presents a rudimentary
scheduler in fiber.yield(). yield() can determine that when all coroutines are
waiting, it's time to retrieve the next incoming event from the viewer.
Moreover, it can detect when all coroutines have completed and exit without
being explicitly told.

fiber.launch() associates a name with each fiber for debugging purposes.
fiber.get_name() retrieves the name of the specified fiber, or the running fiber.
fiber.status() is like coroutine.status(), but can return 'ready' or 'waiting'
instead of 'suspended'.
fiber.yield() leaves the calling fiber ready, but lets other ready fibers run.
fiber.wait() suspends the calling fiber and lets other ready fibers run.
fiber.wake(), called from some other coroutine, returns the passed fiber to
ready status for a future call to fiber.yield().
fiber.run() drives the scheduler to run all fibers to completion.

If, on completion of the subject Lua script, LuaState::expr() detects that the
script loaded fiber.lua, it calls fiber.run() to finish running any dangling
fibers. This lets a script make calls to fiber.launch() and then just fall off
the end, leaving the implicit fiber.run() call to run them all.

fiber.lua is designed to allow the main thread, as well as explicitly launched
coroutines, to make leap.request() calls. This part still needs debugging.

The leap.lua module now configures a fiber.set_idle() function that honors
leap.done(), but calls get_event_next() and dispatches the next incoming event.

leap.request() and generate() now leave the reqid stamp in the response. This
lets a caller handle subsequent events with the same reqid, e.g. for
LLLuaFloater.

Remove leap.process(): it has been superseded by fiber.run().

Remove leap.WaitFor:iterate(): unfortunately that would run afoul of the Luau
bug that prevents suspending the calling coroutine within a generic 'for'
iterator function.

Make leap.lua use weak tables to track WaitFor objects.

Make WaitQueue:Dequeue() call fiber.wait() to suspend its caller when the queue
is empty, and Enqueue() call fiber.wake() to set it ready again when a new
item is pushed.

Make llluamanager_test.cpp's leap test script use the fiber module to launch
coroutines, instead of the coro module. Fix a bug in which its drain()
function was inadvertently setting and testing the global 'item' variable
instead of one local to the function. Since some other modules had the same
bug, it was getting confused.

Also add printf.lua, providing a printf() function. printf() is short for
print(string.format()), but it can also print tables: anything not a number or
string is formatted using the inspect() function.

Clean up some LL_DEBUGS() output left over from debugging lua_tollsd().

1 files changed, 20 insertions, 14 deletions

diff --git a/indra/newview/tests/llluamanager_test.cpp b/indra/newview/tests/llluamanager_test.cpp
index 069e10e9cf..1dd081fb98 100644
--- a/indra/newview/tests/llluamanager_test.cpp
+++ b/indra/newview/tests/llluamanager_test.cpp
@@ -311,23 +311,27 @@ namespace tut
         const std::string lua(
             "-- test leap.lua\n"
             "\n"
+            "fiber = require('fiber')\n"
             "leap = require('leap')\n"
-            "coro = require('coro')\n"
+            "-- debug = require('printf')\n"
+            "local function debug(...) end\n"
             "\n"
             "-- negative priority ensures catchall is always last\n"
             "catchall = leap.WaitFor:new(-1, 'catchall')\n"
             "function catchall:filter(pump, data)\n"
+            "    debug('catchall:filter(%s, %s)', pump, data)\n"
             "    return data\n"
             "end\n"
             "\n"
             "-- but first, catch events with 'special' key\n"
             "catch_special = leap.WaitFor:new(2, 'catch_special')\n"
             "function catch_special:filter(pump, data)\n"
+            "    debug('catch_special:filter(%s, %s)', pump, data)\n"
             "    return if data['special'] ~= nil then data else nil\n"
             "end\n"
             "\n"
             "function drain(waitfor)\n"
-            "    print(waitfor.name .. ' start')\n"
+            "    debug('%s start', waitfor.name)\n"
             "    -- It seems as though we ought to be able to code this loop\n"
             "    -- over waitfor:wait() as:\n"
             "    -- for item in waitfor.wait, waitfor do\n"
@@ -335,28 +339,30 @@ namespace tut
             "    -- the coroutine call stack, which prohibits coroutine.yield():\n"
             "    -- 'attempt to yield across metamethod/C-call boundary'\n"
             "    -- So we resort to two different calls to waitfor:wait().\n"
-            "    item = waitfor:wait()\n"
+            "    local item = waitfor:wait()\n"
             "    while item do\n"
-            "        print(waitfor.name .. ' caught', item)\n"
+            "        debug('%s caught %s', waitfor.name, item)\n"
             "        item = waitfor:wait()\n"
             "    end\n"
-            "    print(waitfor.name .. ' done')\n"
+            "    debug('%s done', waitfor.name)\n"
             "end\n"
             "\n"
             "function requester(name)\n"
-            "    print('requester('..name..') start')\n"
-            "    response = leap.request('testpump', {name=name})\n"
-            "    print('requester('..name..') got '..tostring(response))\n"
+            "    debug('requester(%s) start', name)\n"
+            "    local response = leap.request('testpump', {name=name})\n"
+            "    debug('requester(%s) got %s', name, response)\n"
             "    -- verify that the correct response was dispatched to this coroutine\n"
             "    assert(response.name == name)\n"
             "end\n"
             "\n"
-            "coro.launch(drain, catchall)\n"
-            "coro.launch(drain, catch_special)\n"
-            "coro.launch(requester, 'a')\n"
-            "coro.launch(requester, 'b')\n"
-            "\n"
-            "leap.process()\n"
+            "-- fiber.print_all()\n"
+            "fiber.launch('catchall', drain, catchall)\n"
+            "fiber.launch('catch_special', drain, catch_special)\n"
+            "fiber.launch('requester(a)', requester, 'a')\n"
+            "-- requester(a)\n"
+            "fiber.launch('requester(b)', requester, 'b')\n"
+            "-- fiber.print_all()\n"
+            "-- fiber.run()\n"
         );
 
         LLSD requests;