From 57ccc40847716069053a68e9d6079355dd5a1795 Mon Sep 17 00:00:00 2001 From: Benoit Germain Date: Mon, 20 Jan 2014 17:37:50 +0100 Subject: linda performance improvement slightly improve linda performance when the producer/consumer scenario leaves leave the key empty --- tests/linda_perf.lua | 130 +++++++++++++++++++++------------------------------ 1 file changed, 54 insertions(+), 76 deletions(-) (limited to 'tests') diff --git a/tests/linda_perf.lua b/tests/linda_perf.lua index 9348f71..1d92c8e 100644 --- a/tests/linda_perf.lua +++ b/tests/linda_perf.lua @@ -6,7 +6,9 @@ local table_unpack = unpack or table.unpack -- this lane eats items in the linda one by one local eater = function( l, loop) - local key, val = l:receive( "go") + -- wait for start signal + l:receive( "go") + -- eat data one by one for i = 1, loop do local val, key = l:receive( "key") --print( val) @@ -18,7 +20,9 @@ end -- this lane eats items in the linda in batches local batched = function( l, loop, batch) - local key, val = l:receive( "go") + -- wait for start signal + l:receive( "go") + -- eat data in batches for i = 1, loop/batch do l:receive( l.batched, "key", batch) end @@ -30,6 +34,7 @@ end local lane_eater_gen = lanes.gen( "*", eater) local lane_batched_gen = lanes.gen( "*", batched) +-- main thread writes data while a lane reads it local function ziva( preloop, loop, batch) -- prefill the linda a bit to increase fifo stress local top = math.max( preloop, loop) @@ -38,8 +43,8 @@ local function ziva( preloop, loop, batch) for i = 1, preloop do l:send( "key", i) end - print( l:count( "key")) - if batch then + print( "stored " .. l:count( "key") .. " items in the linda before starting consumer lane") + if batch > 0 then if l.batched then lane = lane_batched_gen( l, top, batch) else @@ -49,12 +54,21 @@ local function ziva( preloop, loop, batch) else lane = lane_eater_gen( l, top) end - -- tell the lanes they can start eating data - l:send("go", "go") + -- tell the consumer lane it can start eating data + l:send( "go", true) -- send the remainder of the elements while they are consumed + -- create a function that can send several values in one shot + batch = math.max( batch, 1) + local batch_values = {} + for i = 1, batch do + table.insert( batch_values, i) + end + local batch_send = function() + l:send( "key", table_unpack( batch_values)) + end if loop > preloop then - for i = preloop + 1, loop do - l:send( "key", i) + for i = preloop + 1, loop, batch do + batch_send() end end l:send( "done" ,"are you happy?") @@ -62,33 +76,25 @@ local function ziva( preloop, loop, batch) return lanes.now_secs() - t1 end -local tests = +local tests1 = { - --[[{ 2000000, 0}, - { 3000000, 0}, - { 4000000, 0}, - { 5000000, 0}, - { 6000000, 0},]] - --[[{ 1000000, 2000000}, - { 2000000, 3000000}, - { 3000000, 4000000}, - { 4000000, 5000000}, - { 5000000, 6000000},]] - --[[{ 4000000, 0}, - { 4000000, 0, 1}, - { 4000000, 0, 2}, - { 4000000, 0, 3}, - { 4000000, 0, 5}, - { 4000000, 0, 8}, - { 4000000, 0, 13}, - { 4000000, 0, 21}, - { 4000000, 0, 44},]] + --[[ + { 10000, 2000000, 0}, + { 10000, 2000000, 1}, + { 10000, 2000000, 2}, + { 10000, 2000000, 3}, + { 10000, 2000000, 5}, + { 10000, 2000000, 8}, + { 10000, 2000000, 13}, + { 10000, 2000000, 21}, + { 10000, 2000000, 44}, + --]] } -print "tests #1" -for k, v in pairs( tests) do +print "############################################\ntests #1" +for k, v in pairs( tests1) do local pre, loop, batch = v[1], v[2], v[3] print( "testing", pre, loop, batch) - print( pre, loop, batch, "duration = " .. ziva( pre, loop, batch)) + print( pre, loop, batch, "duration = " .. ziva( pre, loop, batch) .. "\n") end --[[ @@ -124,6 +130,7 @@ end ziva( 4000000, 0, 44) -> 2s ]] +-- sequential write/read (no parallelization involved) local function ziva2( preloop, loop, batch) local l = lanes.linda() -- prefill the linda a bit to increase fifo stress @@ -154,6 +161,7 @@ local function ziva2( preloop, loop, batch) for i = 1, preloop, step do batch_send() end + print( "stored " .. (l:count( "key") or 0) .. " items in the linda before starting consumer lane") -- loop that alternatively sends and reads data off the linda if loop > preloop then for i = preloop + 1, loop, step do @@ -170,16 +178,8 @@ end local tests2 = { - --[[{ 2000000, 0}, - { 3000000, 0}, - { 4000000, 0}, - { 5000000, 0}, - { 6000000, 0}, - { 1000000, 2000000}, - { 2000000, 3000000}, - { 3000000, 4000000}, - { 4000000, 5000000}, - { 5000000, 6000000},]] + -- prefill, then consume everything + --[[ { 4000000, 0}, { 4000000, 0, 1}, { 4000000, 0, 2}, @@ -189,44 +189,22 @@ local tests2 = { 4000000, 0, 13}, { 4000000, 0, 21}, { 4000000, 0, 44}, + --]] + -- alternatively fill and consume + { 0, 4000000}, + { 0, 4000000, 1}, + { 0, 4000000, 2}, + { 0, 4000000, 3}, + { 0, 4000000, 5}, + { 0, 4000000, 8}, + { 0, 4000000, 13}, + { 0, 4000000, 21}, + { 0, 4000000, 44}, } -print "tests #2" +print "\n############################################\ntests #2" for k, v in pairs( tests2) do local pre, loop, batch = v[1], v[2], v[3] print( "testing", pre, loop, batch) - print( pre, loop, batch, "duration = " .. ziva2( pre, loop, batch)) + print( pre, loop, batch, "duration = " .. ziva2( pre, loop, batch) .. "\n") end - ---[[ - V 2.1.0: - ziva( 20000, 0) -> 3s ziva( 10000, 20000) -> 3s - ziva( 30000, 0) -> 8s ziva( 20000, 30000) -> 7s - ziva( 40000, 0) -> 15s ziva( 30000, 40000) -> 14s - ziva( 50000, 0) -> 24s ziva( 40000, 50000) -> 22s - ziva( 60000, 0) -> 34s ziva( 50000, 60000) -> 33s - - SIMPLIFIED: - ziva( 20000, 0) -> 4s ziva( 10000, 20000) -> 3s - ziva( 30000, 0) -> 8s ziva( 20000, 30000) -> 7s - ziva( 40000, 0) -> 14s ziva( 30000, 40000) -> 14s - ziva( 50000, 0) -> 23s ziva( 40000, 50000) -> 22s - ziva( 60000, 0) -> 33s ziva( 50000, 60000) -> 32s - - FIFO: - ziva( 2000000, 0) -> 9s ziva( 1000000, 2000000) -> 14s - ziva( 3000000, 0) -> 14s ziva( 2000000, 3000000) -> 23s - ziva( 4000000, 0) -> 19s ziva( 3000000, 4000000) -> 23s - ziva( 5000000, 0) -> 24s ziva( 4000000, 5000000) -> 32s - ziva( 6000000, 0) -> 29s ziva( 5000000, 6000000) -> 33s - - FIFO BATCHED: - ziva( 4000000, 0, 1) -> 19s - ziva( 4000000, 0, 2) -> 11s - ziva( 4000000, 0, 3) -> s - ziva( 4000000, 0, 5) -> s - ziva( 4000000, 0, 8) -> s - ziva( 4000000, 0, 13) -> s - ziva( 4000000, 0, 21) -> s - ziva( 4000000, 0, 44) -> s -]] -- cgit v1.2.3-55-g6feb