1 files changed, 2 insertions, 201 deletions

diff --git a/src/lanes.c b/src/lanes.c
index 8762766..cbac6da 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -1,6 +1,6 @@
 /*
  * LANES.C                              Copyright (c) 2007-08, Asko Kauppi
- *                                      Copyright (C) 2009-17, Benoit Germain
+ *                                      Copyright (C) 2009-19, Benoit Germain
  *
  * Multithreading in Lua.
  * 
@@ -56,7 +56,7 @@
 ===============================================================================
 
 Copyright (C) 2007-10 Asko Kauppi <akauppi@gmail.com>
-              2011-17 Benoit Germain <bnt.germain@gmail.com>
+              2011-19 Benoit Germain <bnt.germain@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -124,33 +124,6 @@ static void securize_debug_threadname( lua_State* L, Lane* s)
         STACK_END( L, 0);
 }
 
-/*
-* Check if the thread in question ('L') has been signalled for cancel.
-*
-* Called by cancellation hooks and/or pending Linda operations (because then
-* the check won't affect performance).
-*
-* Returns TRUE if any locks are to be exited, and 'cancel_error()' called,
-* to make execution of the lane end.
-*/
-static inline enum e_cancel_request cancel_test( lua_State* L)
-{
-        Lane* const s = get_lane_from_registry( L);
-        // 's' is NULL for the original main state (and no-one can cancel that)
-        return s ? s->cancel_request : CANCEL_NONE;
-}
-
-static void cancel_hook( lua_State* L, lua_Debug* ar)
-{
-        (void)ar;
-        DEBUGSPEW_CODE( fprintf( stderr, "cancel_hook\n"));
-        if( cancel_test( L) != CANCEL_NONE)
-        {
-                cancel_error( L);
-        }
-}
-
-
 #if ERROR_FULL_STACK
 static int lane_error( lua_State* L);
 // crc64/we of string "STACKTRACE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
@@ -404,115 +377,6 @@ static int run_finalizers( lua_State* L, int lua_rc)
  * ###############################################################################################
  */
 
-//---
-// = thread_cancel( lane_ud [,timeout_secs=0.0] [,force_kill_bool=false] )
-//
-// The originator thread asking us specifically to cancel the other thread.
-//
-// 'timeout': <0: wait forever, until the lane is finished
-//            0.0: just signal it to cancel, no time waited
-//            >0: time to wait for the lane to detect cancellation
-//
-// 'force_kill': if true, and lane does not detect cancellation within timeout,
-//            it is forcefully killed. Using this with 0.0 timeout means just kill
-//            (unless the lane is already finished).
-//
-// Returns: true if the lane was already finished (DONE/ERROR_ST/CANCELLED) or if we
-//          managed to cancel it.
-//          false if the cancellation timed out, or a kill was needed.
-//
-
-typedef enum
-{
-        CR_Timeout,
-        CR_Cancelled,
-        CR_Killed
-} cancel_result;
-
-static cancel_result thread_cancel_soft( lua_State* L, Lane* s, bool_t wake_lindas_)
-{
-        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
-        {
-                SIGNAL_T *waiting_on = s->waiting_on;
-                if( s->status == WAITING && waiting_on != NULL)
-                {
-                        SIGNAL_ALL( waiting_on);
-                }
-        }
-        // 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_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;
-
-        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" : "");
-                }
-#else
-                (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;
-        }
-        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
-                return CR_Cancelled;
-        }
-
-        // 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
 
@@ -734,19 +598,6 @@ static int selfdestruct_gc( lua_State* L)
 
 
 //---
-// bool = cancel_test()
-//
-// Available inside the global namespace of lanes
-// returns a boolean saying if a cancel request is pending
-//
-LUAG_FUNC( cancel_test)
-{
-        enum e_cancel_request test = cancel_test( L);
-        lua_pushboolean( L, test != CANCEL_NONE);
-        return 1;
-}
-
-//---
 // = _single( [cores_uint=1] )
 //
 // Limits the process to use only 'cores' CPU cores. To be used for performance
@@ -1527,56 +1378,6 @@ LUAG_FUNC( thread_gc)
         return 0;
 }
 
-// lane_h:cancel( [timeout] [, force [, forcekill_timeout]])
-LUAG_FUNC( thread_cancel)
-{
-        Lane* s = lua_toLane( L, 1);
-        double secs = 0.0;
-        int force_i = 2;
-        int forcekill_timeout_i = 3;
-
-        if( lua_isnumber( L, 2))
-        {
-                secs = lua_tonumber( L, 2);
-                if( secs < 0.0 && lua_gettop( L) > 3)
-                {
-                        return luaL_error( L, "can't force_kill a soft cancel");
-                }
-                // negative timeout and force flag means we want to wake linda-waiting threads
-                ++ force_i;
-                ++ forcekill_timeout_i;
-        }
-        else if( lua_isnil( L, 2))
-        {
-                ++ force_i;
-                ++ forcekill_timeout_i;
-        }
-
-        {
-                bool_t force = lua_toboolean( L, force_i);     // FALSE if nothing there
-                double forcekill_timeout = luaL_optnumber( L, forcekill_timeout_i, 0.0);
-
-                switch( thread_cancel( L, s, secs, force, forcekill_timeout))
-                {
-                        case CR_Timeout:
-                        lua_pushboolean( L, 0);
-                        lua_pushstring( L, "timeout");
-                        return 2;
-
-                        case CR_Cancelled:
-                        lua_pushboolean( L, 1);
-                        return 1;
-
-                        case CR_Killed:
-                        lua_pushboolean( L, 0);
-                        lua_pushstring( L, "killed");
-                        return 2;
-                }
-        }
-        // should never happen, only here to prevent the compiler from complaining of "not all control paths returning a value"
-        return 0;
-}
-
 //---
 // str= thread_status( lane )
 //