Moved lanes.sleep implementation to the C-side

8 files changed, 67 insertions, 36 deletions

diff --git a/docs/index.html b/docs/index.html
index 98c2abb..c3e8285 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1767,6 +1767,7 @@ static MyDeepFactory g_MyDeepFactory;
         <li>Include <tt>"deep.h"</tt> and either link against Lanes or statically compile <tt>compat.cpp deep.cpp</tt> into your module if you want to avoid a runtime dependency for users that will use your module without Lanes.
         <li>Instanciate your userdata using <tt>yourFactoryObject.pushDeepUserdata()</tt>, instead of the regular <tt>lua_newuserdata()</tt>. Given a <tt>factory</tt>, it sets up the support structures and returns a state-specific proxy userdata for accessing your data. This proxy can also be copied over to other lanes.</li>
         <li>Accessing the deep userdata from your C code, use <tt>yourFactoryObject.toDeep()</tt> instead of the regular <tt>lua_touserdata()</tt>.</li>
+        <li>To push an existing proxy on the stack, use <tt>DeepPrelude::push(L)</tt>.</li>
 </ol>
 
 <p>
diff --git a/src/cancel.h b/src/cancel.h
index bac8b05..d60903c 100644
--- a/src/cancel.h
+++ b/src/cancel.h
@@ -26,6 +26,7 @@ class Lane; // forward
 enum class CancelRequest
 {
     None, // no pending cancel request
+    // TODO: add a Wake mode: user wants to wake the waiting lindas (in effect resulting in a timeout before the initial operation duration)
     Soft, // user wants the lane to cancel itself manually on cancel_test()
     Hard // user wants the lane to be interrupted (meaning code won't return from those functions) from inside linda:send/receive calls
 };
diff --git a/src/deep.cpp b/src/deep.cpp
index 34cc4b4..76397ae 100644
--- a/src/deep.cpp
+++ b/src/deep.cpp
@@ -191,7 +191,7 @@ void DeepFactory::PushDeepProxy(DestState const L_, DeepPrelude* const prelude_,
     STACK_GROW(L_, 7);
 
     // a new full userdata, fitted with the specified number of uservalue slots (always 1 for Lua < 5.4)
-    DeepPrelude** const _proxy{ lua_newuserdatauv<DeepPrelude*>(L_, nuv_) };                        // L_: DPC proxy
+    DeepPrelude** const _proxy{ lua_newuserdatauv<DeepPrelude*>(L_, nuv_) };                       // L_: DPC proxy
     LUA_ASSERT(L_, _proxy);
     *_proxy = prelude_;
     prelude_->refcount.fetch_add(1, std::memory_order_relaxed); // one more proxy pointing to this deep data
@@ -268,10 +268,10 @@ void DeepFactory::PushDeepProxy(DestState const L_, DeepPrelude* const prelude_,
             }
         }
     }
-    STACK_CHECK(L_, 3);                                                                            // DPC proxy metatable
+    STACK_CHECK(L_, 3);                                                                            // L_: DPC proxy metatable
     LUA_ASSERT(L_, lua_type_as_enum(L_, -2) == LuaType::USERDATA);
     LUA_ASSERT(L_, lua_istable(L_, -1));
-    lua_setmetatable(L_, -2);                                                                      // DPC proxy
+    lua_setmetatable(L_, -2);                                                                      // L_: DPC proxy
 
     // If we're here, we obviously had to create a new proxy, so cache it.
     lua_pushlightuserdata(L_, prelude_);                                                           // L_: DPC proxy deep
@@ -375,3 +375,15 @@ DeepPrelude* DeepFactory::toDeep(lua_State* const L_, int const index_) const
     DeepPrelude** const _proxy{ lua_tofulluserdata<DeepPrelude*>(L_, index_) };
     return *_proxy;
 }
+
+// #################################################################################################
+
+void DeepPrelude::push(lua_State* L_) const
+{
+    STACK_CHECK_START_REL(L_, 0);
+    kDeepProxyCacheRegKey.getSubTableMode(L_, "v");                                                // L_: DPC
+    lua_pushlightuserdata(L_, const_cast<DeepPrelude*>(this));                                     // L_: DPC this
+    lua_rawget(L_, -2);                                                                            // L_: DPC deep
+    lua_remove(L_, -2);                                                                            // L_: deep
+    STACK_CHECK(L_, 1);
+}
diff --git a/src/deep.h b/src/deep.h
index 1710aba..e15f07b 100644
--- a/src/deep.h
+++ b/src/deep.h
@@ -43,6 +43,8 @@ struct DeepPrelude
     : factory{ factory_ }
     {
     }
+
+    void push(lua_State* L_) const;
 };
 
 // #################################################################################################
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 41450f3..25f44d9 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -161,6 +161,33 @@ LUAG_FUNC(set_thread_affinity)
 
 // #################################################################################################
 
+LUAG_FUNC(sleep)
+{
+    extern LUAG_FUNC(linda_receive);
+
+    Universe* const _U{ Universe::Get(L_) };
+    lua_settop(L_, 1);
+    lua_pushcfunction(L_, LG_linda_receive);                                                       // L_: duration|nil receive()
+    STACK_CHECK_START_REL(L_, 0); // we pushed the function we intend to call, now prepare the arguments
+    _U->timerLinda->push(L_);                                                                      // L_: duration|nil receive() timerLinda
+    if (lua_tostringview(L_, 1) == "indefinitely") {
+        lua_pushnil(L_);                                                                           // L_: duration? receive() timerLinda nil
+    } else if (lua_isnoneornil(L_, 1)) {
+        lua_pushnumber(L_, 0);                                                                     // L_: duration? receive() timerLinda 0
+    } else if (!lua_isnumber(L_, 1)) {
+        raise_luaL_argerror(L_, 1, "invalid duration");
+    }
+    else {
+        lua_pushnumber(L_, lua_tonumber(L_, 1));                                                   // L_: duration? receive() timerLinda duration
+    }
+    std::ignore = lua_pushstringview(L_, "ac100de1-a696-4619-b2f0-a26de9d58ab8");                  // L_: duration? receive() timerLinda duration key
+    STACK_CHECK(L_, 3); // 3 arguments ready
+    lua_call(L_, 3, LUA_MULTRET); // timerLinda:receive(duration,key)                              // L_: duration? result...
+    return lua_gettop(L_) - 1;
+}
+
+// #################################################################################################
+
 // --- If a client wants to transfer stuff of a given module from the current state to another Lane, the module must be required
 // with lanes.require, that will call the regular 'require', then populate the lookup database in the source lane
 // module = lanes.require( "modname")
@@ -592,15 +619,16 @@ extern LUAG_FUNC(linda);
 namespace {
     namespace local {
         static struct luaL_Reg const sLanesFunctions[] = {
+            { Universe::kFinally, Universe::InitializeFinalizer },
             { "linda", LG_linda },
-            { "now_secs", LG_now_secs },
-            { "wakeup_conv", LG_wakeup_conv },
-            { "set_thread_priority", LG_set_thread_priority },
-            { "set_thread_affinity", LG_set_thread_affinity },
             { "nameof", LG_nameof },
+            { "now_secs", LG_now_secs },
             { "register", LG_register },
-            { Universe::kFinally, Universe::InitializeFinalizer },
             { "set_singlethreaded", LG_set_singlethreaded },
+            { "set_thread_priority", LG_set_thread_priority },
+            { "set_thread_affinity", LG_set_thread_affinity },
+            { "sleep", LG_sleep },
+            { "wakeup_conv", LG_wakeup_conv },
             { nullptr, nullptr }
         };
     } // namespace local
diff --git a/src/lanes.lua b/src/lanes.lua
index f5e81d4..4f11033 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -644,26 +644,6 @@ local configure_timers = function()
 end -- configure_timers()
 
 -- #################################################################################################
--- ###################################### lanes.sleep() ############################################
--- #################################################################################################
-
--- nil, "timeout" = sleep([seconds_])
---
--- PUBLIC LANES API
-local sleep = function(seconds_)
-    local type = type(seconds_)
-    if type == "string" then
-        seconds_ = (seconds_ ~= 'indefinitely') and tonumber(seconds_) or nil
-    elseif type == "nil" then
-        seconds_ = 0
-    elseif type ~= "number" then
-        error("invalid duration " .. string_format("%q", tostring(seconds_)))
-    end
-    -- receive data on a channel no-one ever sends anything, thus blocking for the specified duration
-    return timerLinda:receive(seconds_, "ac100de1-a696-4619-b2f0-a26de9d58ab8")
-end -- sleep()
-
--- #################################################################################################
 -- ##################################### lanes.genlock() ###########################################
 -- #################################################################################################
     -- These functions are just surface sugar, but make solutions easier to read.
@@ -799,22 +779,22 @@ local configure = function(settings_)
 
     -- activate full interface
     lanes.cancel_error = core.cancel_error
+    lanes.finally = core.finally
     lanes.linda = core.linda
     lanes.nameof = core.nameof
     lanes.now_secs = core.now_secs
     lanes.null = core.null
-    lanes.require = core.require
     lanes.register = core.register
-    lanes.finally = core.finally
+    lanes.require = core.require
     lanes.set_singlethreaded = core.set_singlethreaded
     lanes.set_thread_affinity = core.set_thread_affinity
     lanes.set_thread_priority = core.set_thread_priority
+    lanes.sleep = core.sleep
     lanes.threads = core.threads or function() error "lane tracking is not available" end -- core.threads isn't registered if settings.track_lanes is false
 
     lanes.gen = gen
     lanes.genatomic = genatomic
     lanes.genlock = genlock
-    lanes.sleep = sleep
     lanes.timer = timer
     lanes.timer_lane = timer_lane
     lanes.timers = timers
diff --git a/src/uniquekey.h b/src/uniquekey.h
index cfc8ab0..7e86cbe 100644
--- a/src/uniquekey.h
+++ b/src/uniquekey.h
@@ -59,7 +59,7 @@ class RegistryUniqueKey
     }
     // ---------------------------------------------------------------------------------------------
     template <typename OP>
-    void setValue(lua_State* L_, OP operation_) const
+    void setValue(lua_State* const L_, OP operation_) const
     {
         // Note we can't check stack consistency because operation is not always a push (could be insert, replace, whatever)
         pushKey(L_);                                                                               // ... key
@@ -91,7 +91,7 @@ class RegistryUniqueKey
     }
     // ---------------------------------------------------------------------------------------------
     // equivalent to luaL_getsubtable
-    [[nodiscard]] bool getSubTable(lua_State* const L_, int narr_, int nrec_) const
+    [[nodiscard]] bool getSubTable(lua_State* const L_, int const narr_, int const nrec_) const
     {
         STACK_CHECK_START_REL(L_, 0);
         pushValue(L_);                                                                             // L_: {}|nil
@@ -108,7 +108,7 @@ class RegistryUniqueKey
         return false;
     }
     // ---------------------------------------------------------------------------------------------
-    void getSubTableMode(lua_State* L_, const char* mode_) const
+    void getSubTableMode(lua_State* const L_, char const* const mode_) const
     {
         STACK_CHECK_START_REL(L_, 0);
         if (!getSubTable(L_, 0, 0)) {                                                              // L_: {}
diff --git a/tests/cancel.lua b/tests/cancel.lua
index b75d085..92ab439 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -10,8 +10,15 @@ end
 local lanes = require "lanes" .configure{ with_timers = false}
 
 local SLEEP = function(...)
-        local k, v = lanes.sleep(...)
-        assert(k == nil and v == "timeout")
+        -- just for fun: start a lane that will do the sleeping for us
+        local sleeperBody = function(...)
+                local lanes = require "lanes"
+                local k, v = lanes.sleep(...)
+                assert(k == nil and v == "timeout")
+        end
+        local sleeper = lanes.gen("*", sleeperBody)(...)
+        -- then wait for the lane to terminate
+        sleeper:join()
 end
 
 local linda = lanes.linda()