lane:cancel internal code refactorization

3 files changed, 130 insertions, 137 deletions

diff --git a/src/lanes.c b/src/lanes.c
index 90da9bf..abd4171 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -169,20 +169,6 @@ static DECLARE_CONST_UNIQUE_KEY( FINALIZER_REGKEY, 0x188fccb8bf348e09);
 
 struct s_Linda;
 
-#if 1
-# define DEBUG_SIGNAL( msg, signal_ref ) /* */
-#else
-# define DEBUG_SIGNAL( msg, signal_ref ) \
-    { int i; unsigned char *ptr; char buf[999]; \
-      sprintf( buf, ">>> " msg ": %p\t", (signal_ref) ); \
-      ptr= (unsigned char *)signal_ref; \
-      for( i=0; i<sizeof(*signal_ref); i++ ) { \
-        sprintf( strchr(buf,'\0'), "%02x %c ", ptr[i], ptr[i] ); \
-      } \
-      fprintf( stderr, "%s\n", buf ); \
-    }
-#endif
-
 /*
 * Push a table stored in registry onto Lua stack.
 *
@@ -442,90 +428,97 @@ typedef enum
         CR_Killed
 } cancel_result;
 
-static cancel_result thread_cancel( lua_State* L, Lane* s, double secs, bool_t force, double waitkill_timeout_)
+static cancel_result thread_cancel_soft( lua_State* L, Lane* s, bool_t wake_lindas_)
 {
-        cancel_result result;
-
-        // remember that lanes are not transferable: only one thread can cancel a lane, so no multithreading issue here
-        // We can read 's->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
-        if( s->mstatus == KILLED)
+        s->cancel_request = CANCEL_SOFT;    // it's now signaled to stop
+        // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
+        if( wake_lindas_) // wake the thread so that execution returns from any pending linda operation if desired
         {
-                result = CR_Killed;
+                SIGNAL_T *waiting_on = s->waiting_on;
+                if( s->status == WAITING && waiting_on != NULL)
+                {
+                        SIGNAL_ALL( waiting_on);
+                }
         }
-        else if( s->status < DONE)
+        // say we succeeded though
+        return CR_Cancelled;
+}
+
+static cancel_result thread_cancel_hard( lua_State* L, Lane* s, double secs_, bool_t force_, double waitkill_timeout_)
+{
+        cancel_result result;
+
+        s->cancel_request = CANCEL_HARD;    // it's now signaled to stop
         {
-                // signal the linda the wake up the thread so that it can react to the cancel query
-                // let us hope we never land here with a pointer on a linda that has been destroyed...
-                if( secs < 0.0)
+                SIGNAL_T *waiting_on = s->waiting_on;
+                if( s->status == WAITING && waiting_on != NULL)
                 {
-                        s->cancel_request = CANCEL_SOFT;    // it's now signaled to stop
-                        // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
-                        if( force) // wake the thread so that execution returns from any pending linda operation if desired
-                        {
-                                SIGNAL_T *waiting_on = s->waiting_on;
-                                if( s->status == WAITING && waiting_on != NULL)
-                                {
-                                        SIGNAL_ALL( waiting_on);
-                                }
-                        }
-                        // say we succeeded though
-                        result = CR_Cancelled;
+                        SIGNAL_ALL( waiting_on);
                 }
-                else
-                {
-                        s->cancel_request = CANCEL_HARD;    // it's now signaled to stop
-                        {
-                                SIGNAL_T *waiting_on = s->waiting_on;
-                                if( s->status == WAITING && waiting_on != NULL)
-                                {
-                                        SIGNAL_ALL( waiting_on);
-                                }
-                        }
+        }
 
-                        result = THREAD_WAIT( &s->thread, secs, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
+        result = THREAD_WAIT( &s->thread, secs_, &s->done_signal, &s->done_lock, &s->status) ? CR_Cancelled : CR_Timeout;
 
-                        if( (result == CR_Timeout) && force)
-                        {
-                                // Killing is asynchronous; we _will_ wait for it to be done at
-                                // GC, to make sure the data structure can be released (alternative
-                                // would be use of "cancellation cleanup handlers" that at least
-                                // PThread seems to have).
-                                //
-                                THREAD_KILL( &s->thread);
+        if( (result == CR_Timeout) && force_)
+        {
+                // Killing is asynchronous; we _will_ wait for it to be done at
+                // GC, to make sure the data structure can be released (alternative
+                // would be use of "cancellation cleanup handlers" that at least
+                // PThread seems to have).
+                //
+                THREAD_KILL( &s->thread);
 #if THREADAPI == THREADAPI_PTHREAD
-                                // pthread: make sure the thread is really stopped!
-                                // note that this may block forever if the lane doesn't call a cancellation point and pthread doesn't honor PTHREAD_CANCEL_ASYNCHRONOUS
-                                result = THREAD_WAIT( &s->thread, waitkill_timeout_, &s->done_signal, &s->done_lock, &s->status);
-                                if( result == CR_Timeout)
-                                {
-                                        return luaL_error( L, "force-killed lane failed to terminate within %f second%s", waitkill_timeout_, waitkill_timeout_ > 1 ? "s" : "");
-                                }
+                // pthread: make sure the thread is really stopped!
+                // note that this may block forever if the lane doesn't call a cancellation point and pthread doesn't honor PTHREAD_CANCEL_ASYNCHRONOUS
+                result = THREAD_WAIT( &s->thread, waitkill_timeout_, &s->done_signal, &s->done_lock, &s->status);
+                if( result == CR_Timeout)
+                {
+                        return luaL_error( L, "force-killed lane failed to terminate within %f second%s", waitkill_timeout_, waitkill_timeout_ > 1 ? "s" : "");
+                }
 #else
-                                (void) waitkill_timeout_; // unused
-                                (void) L; // unused
+                (void) waitkill_timeout_; // unused
+                (void) L; // unused
 #endif // THREADAPI == THREADAPI_PTHREAD
-                                s->mstatus = KILLED;     // mark 'gc' to wait for it
-                                // note that s->status value must remain to whatever it was at the time of the kill
-                                // because we need to know if we can lua_close() the Lua State or not.
-                                result = CR_Killed;
-                        }
-                }
+                s->mstatus = KILLED;     // mark 'gc' to wait for it
+                // note that s->status value must remain to whatever it was at the time of the kill
+                // because we need to know if we can lua_close() the Lua State or not.
+                result = CR_Killed;
         }
-        else
+        return result;
+}
+
+static cancel_result thread_cancel( lua_State* L, Lane* s, double secs_, bool_t force_, double waitkill_timeout_)
+{
+        // remember that lanes are not transferable: only one thread can cancel a lane, so no multithreading issue here
+        // We can read 's->status' without locks, but not wait for it (if Posix no PTHREAD_TIMEDJOIN)
+        if( s->mstatus == KILLED)
+        {
+                return CR_Killed;
+        }
+
+        if( s->status >= DONE)
         {
                 // say "ok" by default, including when lane is already done
-                result = CR_Cancelled;
+                return CR_Cancelled;
         }
-        return result;
+
+        // signal the linda the wake up the thread so that it can react to the cancel query
+        // let us hope we never land here with a pointer on a linda that has been destroyed...
+        if( secs_ < 0.0)
+        {
+                return thread_cancel_soft( L, s, force_);
+        }
+
+        return thread_cancel_hard( L, s, secs_, force_, waitkill_timeout_);
 }
 
-    //
-    // Protects modifying the selfdestruct chain
+//
+// Protects modifying the selfdestruct chain
 
 #define SELFDESTRUCT_END ((Lane*)(-1))
-    //
-    // The chain is ended by '(Lane*)(-1)', not NULL:
-    //      'selfdestruct_first -> ... -> ... -> (-1)'
+//
+// The chain is ended by '(Lane*)(-1)', not NULL:
+//      'selfdestruct_first -> ... -> ... -> (-1)'
 
 /*
  * Add the lane to selfdestruct chain; the ones still running at the end of the
diff --git a/src/linda.c b/src/linda.c
index 69f41b6..150649d 100644
--- a/src/linda.c
+++ b/src/linda.c
@@ -245,7 +245,7 @@ LUAG_FUNC( linda_send)
         {
                 case CANCEL_SOFT:
                 // if user wants to soft-cancel, the call returns lanes.cancel_error
-                        push_unique_key( L, CANCEL_ERROR);
+                push_unique_key( L, CANCEL_ERROR);
                 return 1;
 
                 case CANCEL_HARD:
@@ -400,7 +400,7 @@ LUAG_FUNC( linda_receive)
         {
                 case CANCEL_SOFT:
                 // if user wants to soft-cancel, the call returns CANCEL_ERROR
-                        push_unique_key( L, CANCEL_ERROR);
+                push_unique_key( L, CANCEL_ERROR);
                 return 1;
 
                 case CANCEL_HARD:
diff --git a/tests/basic.lua b/tests/basic.lua
index 7d42ad5..020fe78 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -26,7 +26,7 @@ local function PRINT(...)
 end
 
 local gc_cb = function( name_, status_)
-        PRINT( "                                ---> lane '" .. name_ .. "' collected with status " .. status_)
+    PRINT( "                            ---> lane '" .. name_ .. "' collected with status " .. status_)
 end
 --gc_cb = nil
 
@@ -77,7 +77,7 @@ local function task( a, b, c )
 end
 
 local task_launch= lanes_gen( "", { globals={hey=true}, gc_cb = gc_cb}, task )
-        -- base stdlibs, normal priority
+    -- base stdlibs, normal priority
 
 -- 'task_launch' is a factory of multithreaded tasks, we can launch several:
 
@@ -155,12 +155,12 @@ limited:limit( "key", 1)
 -- [[################################################
 limited:send( "key", "hello") -- saturate linda
 for k, v in pairs( limited:dump()) do
-        PRINT("limited[" .. tostring( k) .. "] = " .. tostring( v))
+    PRINT("limited[" .. tostring( k) .. "] = " .. tostring( v))
 end
 local wait_send = function()
-        local a,b
-        set_finalizer( function() print( "wait_send", a, b) end)
-        a,b = limited:send( "key", "bybye") -- infinite timeout, returns only when lane is cancelled
+    local a,b
+    set_finalizer( function() print( "wait_send", a, b) end)
+    a,b = limited:send( "key", "bybye") -- infinite timeout, returns only when lane is cancelled
 end
 
 local wait_send_lane = lanes.gen( "*", wait_send)()
@@ -171,9 +171,9 @@ repeat until wait_send_lane.status == "cancelled"
 print "wait_send_lane is cancelled"
 --################################################]]
 local wait_receive = function()
-        local k, v
-        set_finalizer( function() print( "wait_receive", k, v) end)
-        k, v = limited:receive( "dummy") -- infinite timeout, returns only when lane is cancelled
+    local k, v
+    set_finalizer( function() print( "wait_receive", k, v) end)
+    k, v = limited:receive( "dummy") -- infinite timeout, returns only when lane is cancelled
 end
 
 local wait_receive_lane = lanes.gen( "*", wait_receive)()
@@ -184,9 +184,9 @@ repeat until wait_receive_lane.status == "cancelled"
 print "wait_receive_lane is cancelled"
 --################################################]]
 local wait_receive_batched = function()
-        local k, v1, v2
-        set_finalizer( function() print( "wait_receive_batched", k, v1, v2) end)
-        k, v1, v2 = limited:receive( limited.batched, "dummy", 2) -- infinite timeout, returns only when lane is cancelled
+    local k, v1, v2
+    set_finalizer( function() print( "wait_receive_batched", k, v1, v2) end)
+    k, v1, v2 = limited:receive( limited.batched, "dummy", 2) -- infinite timeout, returns only when lane is cancelled
 end
 
 local wait_receive_batched_lane = lanes.gen( "*", wait_receive_batched)()
@@ -206,7 +206,7 @@ PRINT( "\n\n", "---=== Communications ===---", "\n\n")
 local function WR(...) io.stderr:write(...) end
 
 local chunk= function( linda )
-        set_debug_threadname "chunk"
+    set_debug_threadname "chunk"
     local function receive() return linda:receive( "->" ) end
     local function send(...) linda:send( "<-", ... ) end
 
@@ -254,9 +254,9 @@ local a,b,c= RECEIVE(), RECEIVE(), RECEIVE()
 
 print( "lane status: " .. t.status)
 if t.status == "error" then
-        print( t:join())
+    print( t:join())
 else
-        WR( a..", "..b..", "..c.." received\n" )
+    WR( a..", "..b..", "..c.." received\n" )
 end
 
 assert( a==1 and b==2 and c==3 )
@@ -286,50 +286,50 @@ linda: receive( 1, "wait")
 PRINT( "\n\n", "---=== Stdlib naming ===---", "\n\n")
 
 local function dump_g( _x)
-        set_debug_threadname "dump_g"
-        assert(print)
-        print( "### dumping _G for '" .. _x .. "'")
-        for k, v in pairs( _G) do
-                print( "\t" .. k .. ": " .. type( v))
-        end
-        return true
+    set_debug_threadname "dump_g"
+    assert(print)
+    print( "### dumping _G for '" .. _x .. "'")
+    for k, v in pairs( _G) do
+        print( "\t" .. k .. ": " .. type( v))
+    end
+    return true
 end
 
 local function io_os_f( _x)
-        set_debug_threadname "io_os_f"
-        assert(print)
-        print( "### checking io and os libs existence for '" .. _x .. "'")
-        assert(io)
-        assert(os)
-        return true
+    set_debug_threadname "io_os_f"
+    assert(print)
+    print( "### checking io and os libs existence for '" .. _x .. "'")
+    assert(io)
+    assert(os)
+    return true
 end
 
 local function coro_f( _x)
-        set_debug_threadname "coro_f"
-        assert(print)
-        print( "### checking coroutine lib existence for '" .. _x .. "'")
-        assert(coroutine)
-        return true
+    set_debug_threadname "coro_f"
+    assert(print)
+    print( "### checking coroutine lib existence for '" .. _x .. "'")
+    assert(coroutine)
+    return true
 end
 
 assert.fails( function() lanes_gen( "xxx", {gc_cb = gc_cb}, io_os_f ) end )
 
 local stdlib_naming_tests =
 {
-        -- { "", dump_g},
-        -- { "coroutine", dump_g},
-        -- { "io", dump_g},
-        -- { "bit32", dump_g},
-        { "coroutine", coro_f},
-        { "*", io_os_f},
-        { "io,os", io_os_f},
-        { "io+os", io_os_f},
-        { "io,os,base", io_os_f},
+    -- { "", dump_g},
+    -- { "coroutine", dump_g},
+    -- { "io", dump_g},
+    -- { "bit32", dump_g},
+    { "coroutine", coro_f},
+    { "*", io_os_f},
+    { "io,os", io_os_f},
+    { "io+os", io_os_f},
+    { "io,os,base", io_os_f},
 }
 
 for _, t in ipairs( stdlib_naming_tests) do
-        local f= lanes_gen( t[1], {gc_cb = gc_cb}, t[2])     -- any delimiter will do
-        assert( f(t[1])[1] )
+    local f= lanes_gen( t[1], {gc_cb = gc_cb}, t[2])     -- any delimiter will do
+    assert( f(t[1])[1] )
 end
 
 collectgarbage()
@@ -344,7 +344,7 @@ PRINT( "\n\n", "---=== Comms criss cross ===---", "\n\n")
 --
 local tc= lanes_gen( "io", {gc_cb = gc_cb},
   function( linda, ch_in, ch_out )
-                set_debug_threadname( "criss cross " .. ch_in .. " -> " .. ch_out)
+        set_debug_threadname( "criss cross " .. ch_in .. " -> " .. ch_out)
     local function STAGE(str)
         io.stderr:write( ch_in..": "..str.."\n" )
         linda:send( nil, ch_out, str )
@@ -412,7 +412,7 @@ linda:send( "down", function(linda) linda:send( "up", "ready!" ) end,
 --
 local k,s= linda:receive( 1, "up" )
 if t2.status == "error" then
-        print( "t2 error: " , t2:join())
+    print( "t2 error: " , t2:join())
 end
 PRINT(s)
 assert( s=="ready!" )
@@ -440,13 +440,13 @@ PRINT( "\n\n", "---=== :join test ===---", "\n\n")
 
 local S= lanes_gen( "table", {gc_cb = gc_cb},
   function(arg)
-                set_debug_threadname "join test lane"
-                set_finalizer( function() end)
+        set_debug_threadname "join test lane"
+        set_finalizer( function() end)
     aux= {}
     for i, v in ipairs(arg) do
-           table.insert (aux, 1, v)
+       table.insert (aux, 1, v)
     end
-                -- unpack was renamed table.unpack in Lua 5.2: cater for both!
+        -- unpack was renamed table.unpack in Lua 5.2: cater for both!
     return (unpack or table.unpack)(aux)
 end )
 
@@ -456,13 +456,13 @@ linda:receive(0.5, "gloupti")
 print( "joining with '" .. h:get_debug_threadname() .. "'")
 local a,b,c,d= h:join()
 if h.status == "error" then
-        print( h:get_debug_threadname(), "error: " , a, b, c, d)
+    print( h:get_debug_threadname(), "error: " , a, b, c, d)
 else
-        print( h:get_debug_threadname(), a,b,c,d)
-        assert(a==14)
-        assert(b==13)
-        assert(c==12)
-        assert(d==nil)
+    print( h:get_debug_threadname(), a,b,c,d)
+    assert(a==14)
+    assert(b==13)
+    assert(c==12)
+    assert(d==nil)
 end
 
 local nameof_type, nameof_name = lanes.nameof( print)