Refactored keeper implementation of linda:get()

3 files changed, 74 insertions, 24 deletions

diff --git a/src/keeper.cpp b/src/keeper.cpp
index eba184f..f1079e4 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -125,15 +125,23 @@ void KeyUD::prepareAccess(KeeperState const K_)
 
 // in: fifo
 // out: ...|nothing
-// expects exactly 1 value on the stack!
-// function assumes that there is enough data in the fifo to satisfy the request
+// pops the fifo, push as much data as is available (up to the specified count) without consuming it
 void KeyUD::peek(KeeperState const K_, int const count_)
 {
-    //LUA_ASSERT(K_, KeyUD::GetPtr(K_, 1) == this);
-    STACK_GROW(K_, count_);
-    for (int const _i : std::ranges::iota_view{ 0, count_ }) {
-        lua_rawgeti(K_, 1, first + _i);
+    LUA_ASSERT(K_, KeyUD::GetPtr(K_, -1) == this);
+    if (count <= 0) { // no data is available
+        lua_pop(K_, 1);                                                                            // K_:
+        return;
+    }
+
+    // read <count_> value off the fifo
+    prepareAccess(K_);                                                                             // K_: fifo
+    int const _at{ lua_gettop(K_) };
+    for (int const _i : std::ranges::iota_view{ 1, std::min(count_, count) }) { // push val2 to valN
+        lua_rawgeti(K_, 1, first + _i);                                                            // K_: fifo val2..N
     }
+    lua_rawgeti(K_, 1, first); // push val1                                                        // K_: fifo val2..N val1
+    lua_replace(K_, _at); // replace fifo by val1 to get the output properly ordered               // K_: val1..N
 }
 
 // #################################################################################################
@@ -518,23 +526,21 @@ int keepercall_get(lua_State* const L_)
     KeeperState const _K{ L_ };
     int _count{ 1 };
     if (lua_gettop(_K) == 3) {                                                                     // _K: linda key count
-        _count = static_cast<int>(lua_tointeger(_K, 3));
+        _count = static_cast<int>(lua_tointeger(_K, 3)); // linda:get() made sure _count >= 1
         lua_pop(_K, 1);                                                                            // _K: linda key
     }
     PushKeysDB(_K, 1);                                                                             // _K: linda key KeysDB
     lua_replace(_K, 1);                                                                            // _K: KeysDB key
     lua_rawget(_K, 1);                                                                             // _K: KeysDB KeyUD
+    lua_remove(_K, 1);                                                                             // _K: KeyUD
     KeyUD* const _key{ KeyUD::GetPtr(_K, -1) };
-    if (_key != nullptr && _key->count > 0) {
-        _key->prepareAccess(_K);                                                                   // _K: KeysDB fifo
-        lua_remove(_K, 1);                                                                         // _K: fifo
-        _count = std::min(_count, _key->count);
-        // read <count> value off the fifo
-        _key->peek(_K, _count);                                                                    // _K: fifo ...
-        return _count;
-    }
-    // no fifo was ever registered for this key, or it is empty
-    return 0;
+    if (_key != nullptr) {
+        _key->peek(_K, _count);                                                                    // _K: val...
+    } else {
+        // no fifo was ever registered for this key, or it is empty
+        lua_pop(_K, 1);                                                                            // _K:
+    }
+    return lua_gettop(_K);
 }
 
 // #################################################################################################
diff --git a/tests/basic.lua b/tests/basic.lua
index fff19ed..ecd93fc 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -249,7 +249,26 @@ assert(type(linda) == "userdata" and tostring(linda) == "Linda: communications")
     -- ["->"] master -> slave
     -- ["<-"] slave <- master
 
-local function PEEK() return linda:get("<-") end
+WR "test linda:get/set..."
+linda:set("<->", "x", "y", "z")
+local x,y,z = linda:get("<->", 1)
+assert(x == "x" and y == nil and z == nil)
+local x,y,z = linda:get("<->", 2)
+assert(x == "x" and y == "y" and z == nil)
+local x,y,z = linda:get("<->", 3)
+assert(x == "x" and y == "y" and z == "z")
+local x,y,z,w = linda:get("<->", 4)
+assert(x == "x" and y == "y" and z == "z" and w == nil)
+local k, x = linda:receive("<->")
+assert(k == "<->" and x == "x")
+local k,y,z = linda:receive(linda.batched, "<->", 2)
+assert(k == "<->" and y == "y" and z == "z")
+linda:set("<->")
+local x,y,z,w = linda:get("<->", 4)
+assert(x == nil and y == nil and z == nil and w == nil)
+WR "ok\n"
+
+local function PEEK(...) return linda:get("<-", ...) end
 local function SEND(...) linda:send("->", ...) end
 local function RECEIVE() local k,v = linda:receive(1, "<-") return v end
 
@@ -259,7 +278,7 @@ SEND(1);  WR("main ", "1 sent\n")
 SEND(2);  WR("main ", "2 sent\n")
 SEND(3);  WR("main ", "3 sent\n")
 SEND(setmetatable({"should be ignored"},{__lanesignore=true})); WR("main ", "__lanesignore table sent\n")
-for i=1,100 do
+for i=1,40 do
     WR "."
     SLEEP(0.0001)
     assert(PEEK() == nil)    -- nothing coming in, yet
diff --git a/tests/linda_perf.lua b/tests/linda_perf.lua
index a50e906..4d35380 100644
--- a/tests/linda_perf.lua
+++ b/tests/linda_perf.lua
@@ -62,12 +62,13 @@ local lane_gobbler_gen = lanes.gen( "*", {priority = 3}, gobbler)
 local function ziva( preloop, loop, batch)
         -- prefill the linda a bit to increase fifo stress
         local top = math.max( preloop, loop)
-        local l, lane = lanes.linda()
+        local l = lanes.linda()
         local t1 = lanes.now_secs()
         for i = 1, preloop do
                 l:send( "key", i)
         end
         print( "stored " .. l:count( "key") .. " items in the linda before starting consumer lane")
+        local lane
         if batch > 0 then
                 if l.batched then
                         lane = lane_gobbler_gen( l, top, batch)
@@ -103,6 +104,28 @@ local function ziva( preloop, loop, batch)
 end
 
 -- #################################################################################################
+do
+        print "############################################ tests get/set"
+        -- linda:get throughput
+        local l = lanes.linda("get/set")
+        local batch = {}
+        for i = 1,1000 do
+                table.insert(batch, i)
+        end
+        for _,size in ipairs{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987 } do
+                l:set("<->", table_unpack(batch))
+                local count = 20000000//size
+                print("START", "get("..size..") " .. count, " times")
+                local t1 = lanes.now_secs()
+                for i = 1, 2000000/math.sqrt(size) do
+                        l:get("<->", size)
+                end
+                print("DURATION = " .. lanes.now_secs() - t1 .. "\n")
+        end
+end
+
+do return end
+-- #################################################################################################
 
 TEST1 = TEST1 or 1000
 PREFILL1 = PREFILL1 or 10000
@@ -118,8 +141,9 @@ local tests1 =
         { PREFILL1, FILL1, 8},
         { PREFILL1, FILL1, 13},
         { PREFILL1, FILL1, 21},
-        { PREFILL1, FILL1, 44},
-        { PREFILL1, FILL1, 65},
+        { PREFILL1, FILL1, 34},
+        { PREFILL1, FILL1, 55},
+        { PREFILL1, FILL1, 89},
 }
 print "############################################ tests #1"
 for i, v in ipairs( tests1) do
@@ -194,8 +218,9 @@ local tests2 =
         { PREFILL2, FILL2, 8},
         { PREFILL2, FILL2, 13},
         { PREFILL2, FILL2, 21},
-        { PREFILL2, FILL2, 44},
-        { PREFILL2, FILL2, 65},
+        { PREFILL2, FILL2, 34},
+        { PREFILL2, FILL2, 55},
+        { PREFILL2, FILL2, 89},
 }
 
 print "############################################ tests #2"