some dead code elimination and other trifles

3 files changed, 44 insertions, 34 deletions

diff --git a/tests/basic.lua b/tests/basic.lua
index 4b4fae6..1cf37e6 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -63,9 +63,9 @@ tables_match= function( a, b )
     return subtable( a, b ) and subtable( b, a )
 end
 
---##############################################################
---##############################################################
---##############################################################
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 PRINT( "\n\n", "---=== Tasking (basic) ===---", "\n\n")
 
@@ -112,9 +112,9 @@ assert( lane1.status == "done" )
 lane1, lane2 = nil
 collectgarbage()
 
---##############################################################
---##############################################################
---##############################################################
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 PRINT( "\n\n", "---=== Tasking (cancelling) ===---", "\n\n")
 
@@ -201,9 +201,9 @@ repeat until wait_receive_batched_lane.status == "cancelled"
 print "wait_receive_batched_lane is cancelled"
 --################################################]]
 
---##############################################################
---##############################################################
---##############################################################
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 PRINT( "\n\n", "---=== Communications ===---", "\n\n")
 
@@ -285,9 +285,9 @@ collectgarbage()
 WR("waiting 1s")
 linda:receive( 1, "wait")
 
---##############################################################
---##############################################################
---##############################################################
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 PRINT( "\n\n", "---=== Stdlib naming ===---", "\n\n")
 
@@ -341,9 +341,9 @@ end
 WR("collectgarbage")
 collectgarbage()
 
---##############################################################
---##############################################################
---##############################################################
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 PRINT( "\n\n", "---=== Comms criss cross ===---", "\n\n")
 
@@ -374,9 +374,9 @@ WR("collectgarbage")
 a, b = nil
 collectgarbage()
 
---##############################################################
---##############################################################
---##############################################################
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 PRINT( "\n\n", "---=== Receive & send of code ===---", "\n\n")
 
@@ -436,9 +436,9 @@ assert( s2==":)" )
 local k,ok2= linda:receive( "up" )
 assert( ok2 == "ok2" )
 
---##############################################################
---##############################################################
---##############################################################
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 PRINT( "\n\n", "---=== :join test ===---", "\n\n")
 
diff --git a/tests/cancel.lua b/tests/cancel.lua
index c22103f..5bd569f 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -5,7 +5,7 @@ for k,v in ipairs{...} do
         remaining_tests[v] = true
 end
 
---####################################################################
+-- ##################################################################################################
 
 local lanes = require "lanes" .configure{ with_timers = false}
 
@@ -13,7 +13,8 @@ local linda = lanes.linda()
 -- a numeric value to read
 linda:set( "val", 33.0)
 
---####################################################################
+-- ##################################################################################################
+
 if not next(which_tests) or which_tests.genlock then
         remaining_tests.genlock = nil
         print "\n\n####################################################################\nbegin genlock & genatomic cancel test\n"
@@ -42,7 +43,8 @@ if not next(which_tests) or which_tests.genlock then
 
         print "test OK"
 end
---####################################################################
+
+-- ##################################################################################################
 
 local waitCancellation = function( h, expected_status)
         local l = lanes.linda()
@@ -127,8 +129,8 @@ local protectedBody = function( ...)
         end
 end
 
---####################################################################
---####################################################################
+-- ##################################################################################################
+-- ##################################################################################################
 
 if not next(which_tests) or which_tests.linda then
         remaining_tests.linda = nil
@@ -149,6 +151,8 @@ if not next(which_tests) or which_tests.linda then
         linda:cancel( "none")
 end
 
+-- ##################################################################################################
+
 if not next(which_tests) or which_tests.soft then
         remaining_tests.soft = nil
         print "\n\n####################################################################\nbegin soft cancel test\n"
@@ -171,6 +175,8 @@ if not next(which_tests) or which_tests.soft then
         waitCancellation( h, "done")
 end
 
+-- ##################################################################################################
+
 if not next(which_tests) or which_tests.hook then
         remaining_tests.hook = nil
         print "\n\n####################################################################\nbegin hook cancel test\n"
@@ -186,6 +192,8 @@ if not next(which_tests) or which_tests.hook then
         waitCancellation( h, "cancelled")
 end
 
+-- ##################################################################################################
+
 if not next(which_tests) or which_tests.hard then
         remaining_tests.hard = nil
         print "\n\n####################################################################\nbegin hard cancel test\n"
@@ -203,6 +211,8 @@ if not next(which_tests) or which_tests.hard then
         waitCancellation( h, "cancelled")
 end
 
+-- ##################################################################################################
+
 if not next(which_tests) or which_tests.hard_unprotected then
         remaining_tests.hard_unprotected = nil
         print "\n\n####################################################################\nbegin hard cancel test with unprotected lane body\n"
@@ -220,7 +230,7 @@ if not next(which_tests) or which_tests.hard_unprotected then
         waitCancellation( h, "cancelled")
 end
 
---####################################################################
+-- ##################################################################################################
 
 local unknown_test, val = next(remaining_tests)
 assert(not unknown_test, tostring(unknown_test) .. " test is unknown")
diff --git a/tests/linda_perf.lua b/tests/linda_perf.lua
index 61b8f05..6b79c1f 100644
--- a/tests/linda_perf.lua
+++ b/tests/linda_perf.lua
@@ -17,7 +17,7 @@ local finalizer = function(err, stk)
         end
 end
 
---##################################################################################################
+-- #################################################################################################
 
 -- this lane eats items in the linda one by one
 local eater = function( l, loop)
@@ -34,7 +34,7 @@ local eater = function( l, loop)
         print("eater: done ("..val..")")
 end
 
---##################################################################################################
+-- #################################################################################################
 
 -- this lane eats items in the linda in batches
 local gobbler = function( l, loop, batch)
@@ -51,12 +51,12 @@ local gobbler = function( l, loop, batch)
         print("gobbler: done ("..val..")")
 end
 
---##################################################################################################
+-- #################################################################################################
 
 local lane_eater_gen = lanes.gen( "*", {priority = 3}, eater)
 local lane_gobbler_gen = lanes.gen( "*", {priority = 3}, gobbler)
 
---##################################################################################################
+-- #################################################################################################
 
 -- main thread writes data while a lane reads it
 local function ziva( preloop, loop, batch)
@@ -102,7 +102,7 @@ local function ziva( preloop, loop, batch)
         return lanes.now_secs() - t1
 end
 
---##################################################################################################
+-- #################################################################################################
 
 TEST1 = TEST1 or 1000
 PREFILL1 = PREFILL1 or 10000
@@ -130,7 +130,7 @@ for i, v in ipairs( tests1) do
         print("DURATION = " .. ziva( pre, loop, batch) .. "\n")
 end
 
---##################################################################################################
+-- #################################################################################################
 
 -- sequential write/read (no parallelization involved)
 local function ziva2( preloop, loop, batch)
@@ -178,7 +178,7 @@ local function ziva2( preloop, loop, batch)
         return lanes.now_secs() - t1
 end
 
---##################################################################################################
+-- #################################################################################################
 
 TEST2 = TEST2 or 1000
 PREFILL2 = PREFILL2 or 0