8 files changed, 105 insertions, 40 deletions

diff --git a/CHANGES b/CHANGES
index 16faa44..52fcf5f 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,11 @@
 CHANGES:
 
+CHANGE 85: BGe 28-Nov-13
+   * version 3.7.3
+   * set pthread thread cancel type to PTHREAD_CANCEL_ASYNCHRONOUS
+   * lane_h:cancel() accepts a 3rd timeout argument used when waiting for actual thread termination (hitting the timeout raises an error)
+   * added PROPAGATE_ALLOCF macro to select state creation mode (lua_newstate or luaL_newstate)
+
 CHANGE 84: BGe 18-Nov-13
    * Fix a deadlock when GCing during a linda operation.
    * Fix a compilation warning about an unused variable
diff --git a/docs/index.html b/docs/index.html
index 40930d8..25f9e22 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -70,7 +70,7 @@
                         </p>
 
                         <p>
-                                This document was revised on 16-Nov-13, and applies to version <tt>3.7.2</tt>.
+                                This document was revised on 28-Nov-13, and applies to version <tt>3.7.3</tt>.
                         </p>
                 </font>
         </center>
@@ -102,7 +102,7 @@
                 <li>Data passing uses fast inter-state copies (no serialization required).</li>
                 <li>"Deep userdata" concept, for sharing userdata over multiple lanes.</li>
                 <li>Millisecond level timers, integrated with the Linda system.</li>
-                <li>Threads can be given priorities -2..+2 (default is 0).</li>
+                <li>Threads can be given priorities.</li>
                 <li>Lanes are cancellable, with proper cleanup.</li>
                 <li>No Lua-side application level locking - ever!</li>
         </ul>
@@ -587,9 +587,10 @@
                         <td>
                                 <code>.priority</code>
                         </td>
-                        <td> integer -2..+2</td>
+                        <td>integer</td>
                         <td>
-                                The priority of lanes generated. -2 is lowest, +2 is highest.
+                                The priority of lanes generated in the range -3..+3 (MinGW pthread and Windows thread API), or -2..+2 otherwise (default is 0).
+                                These values are a mapping over the actual priority range of the underlying implementation.
                                 <br>
                                 Implementation and dependability of priorities varies by platform. Especially Linux kernel 2.6 is not supporting priorities in user mode.
                         </td>
@@ -842,14 +843,15 @@
 <h2 id="cancelling">Cancelling</h2>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        bool[,reason] = lane_h:cancel( [timeout_secs=0.0,] [force_kill_bool = false] )
+        bool[,reason] = lane_h:cancel( [timeout_secs=0.0,] [force_kill_bool = false] [, forcekill_timeout=0.0])
 </pre></td></tr></table>
 
 <p>
-        <tt>cancel()</tt>sends a cancellation request to the lane.<br/>
+        <tt>cancel()</tt> sends a cancellation request to the lane.<br/>
+        If <tt>timeout_secs</tt> is negative (aka "soft cancel"), starting with version 3.6.3, will only cause <tt>cancel_test()</tt> to return <tt>true</tt>, so that the lane can cleanup manually (the actual value is irrelevant). You can't provide the additional arguments in that case.<br/>
         If <tt>timeout_secs</tt> is positive (aka "hard cancel"), waits for the request to be processed, or a timeout to occur.<br/>
-        If <tt>timeout_secs</tt> is negative (aka "soft cancel"), starting with version 3.6.3, will only cause <tt>cancel_test()</tt> to return true, so that the lane can cleanup manually. You can't provide a second argument in that case.<br/>
-        Returns <tt>true</tt> if soft cancelling, or the lane was already done (in <tt>"done"</tt>, <tt>"error"</tt> or <tt>"cancelled"</tt> status), or the cancellation was fruitful within timeout period.
+        If <tt>force_kill_bool</tt> is <tt>true</tt>, <tt>forcekill_timeout</tt> can be set to tell how long lanes will wait for the OS thread to terminate before raising an error. Windows threads always terminate immediately, but it might not always be the case with some pthread implementations.
+        Returns <tt>true</tt> if soft cancelling, or the lane was already done (in <tt>"done"</tt>, <tt>"error"</tt> or <tt>"cancelled"</tt> status), or the cancellation was fruitful within <tt>timeout_secs</tt> timeout period.
 </p>
 
 <p>
diff --git a/src/keeper.c b/src/keeper.c
index 8da3c08..99f510b 100644
--- a/src/keeper.c
+++ b/src/keeper.c
@@ -567,8 +567,7 @@ void close_keepers( void)
 char const* init_keepers( lua_State* L)
 {
         int i;
-        void* allocUD;
-        lua_Alloc allocF = lua_getallocf( L, &allocUD);
+        PROPAGATE_ALLOCF_PREP( L);
 
         STACK_CHECK( L);
         lua_getfield( L, 1, "nb_keepers");
@@ -580,10 +579,10 @@ char const* init_keepers( lua_State* L)
         GKeepers = malloc( GNbKeepers * sizeof( struct s_Keeper));
         for( i = 0; i < GNbKeepers; ++ i)
         {
-                lua_State* K = lua_newstate( allocF, allocUD);
+                lua_State* K = PROPAGATE_ALLOCF_ALLOC();
                 if( K == NULL)
                 {
-                        (void) luaL_error( L, "'lua_newstate()' failed while creating keeper state; out of memory");
+                        (void) luaL_error( L, "init_keepers() failed while creating keeper state; out of memory");
                 }
                 STACK_CHECK( K);
 
@@ -627,7 +626,7 @@ struct s_Keeper* keeper_acquire( void const* ptr)
                 * have to cast to unsigned long to avoid compilation warnings about loss of data when converting pointer-to-integer
                 */
                 unsigned int i = (unsigned int)(((unsigned long)(ptr) >> 3) % GNbKeepers);
-                struct s_Keeper* K = &GKeepers[i];
+                struct s_Keeper *K= &GKeepers[i];
 
                 MUTEX_LOCK( &K->lock_);
                 //++ K->count;
diff --git a/src/lanes.c b/src/lanes.c
index 53ed5e4..9e32f9a 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.7.2";
+char const* VERSION = "3.7.3";
 
 /*
 ===============================================================================
@@ -1197,7 +1197,7 @@ typedef enum
         CR_Killed
 } cancel_result;
 
-static cancel_result thread_cancel( struct s_lane *s, double secs, bool_t force)
+static cancel_result thread_cancel( lua_State* L, struct s_lane* s, double secs, bool_t force, double waitkill_timeout_)
 {
         cancel_result result;
 
@@ -1239,6 +1239,15 @@ static cancel_result thread_cancel( struct s_lane *s, double secs, bool_t force)
                                 // 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" : "");
+                                }
+#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.
@@ -1357,7 +1366,7 @@ static int selfdestruct_gc( lua_State* L)
                         while( s != SELFDESTRUCT_END)
                         {
                                 // attempt a regular unforced hard cancel with a small timeout
-                                bool_t cancelled = THREAD_ISNULL( s->thread) || thread_cancel( s, 0.0001, FALSE);
+                                bool_t cancelled = THREAD_ISNULL( s->thread) || thread_cancel( L, s, 0.0001, FALSE, 0.0);
                                 // if we failed, and we know the thread is waiting on a linda
                                 if( cancelled == FALSE && s->status == WAITING && s->waiting_on != NULL)
                                 {
@@ -1758,6 +1767,17 @@ static char const* get_errcode_name( int _code)
 }
 #endif // USE_DEBUG_SPEW
 
+#if THREADWAIT_METHOD == THREADWAIT_CONDVAR // implies THREADAPI == THREADAPI_PTHREAD
+static void thread_cleanup_handler( void* opaque)
+{
+        struct s_lane* s= (struct s_lane*) opaque;
+        MUTEX_LOCK( &s->done_lock);
+        s->status = CANCELLED;
+        SIGNAL_ONE( &s->done_signal);   // wake up master (while 's->done_lock' is on)
+        MUTEX_UNLOCK( &s->done_lock);
+}
+#endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
+
 //---
 static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
 {
@@ -1770,7 +1790,8 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
         tracking_add( s);
     }
 #endif // HAVE_LANE_TRACKING
-
+    THREAD_MAKE_ASYNCH_CANCELLABLE();
+    THREAD_CLEANUP_PUSH( thread_cleanup_handler, s);
     s->status= RUNNING;  // PENDING -> RUNNING
 
     // Tie "set_finalizer()" to the state
@@ -1888,7 +1909,7 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
                     : ERROR_ST;
 
         // Posix no PTHREAD_TIMEDJOIN:
-        //              'done_lock' protects the -> DONE|ERROR_ST|CANCELLED state change
+        // 'done_lock' protects the -> DONE|ERROR_ST|CANCELLED state change
         //
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
         MUTEX_LOCK( &s->done_lock);
@@ -1901,6 +1922,7 @@ static THREAD_RETURN_T THREAD_CALLCONV lane_main( void *vs)
         MUTEX_UNLOCK( &s->done_lock);
 #endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
     }
+    THREAD_CLEANUP_POP( FALSE);
     return 0;   // ignored
 }
 
@@ -2248,6 +2270,7 @@ LUAG_FUNC( thread_gc)
         return 0;
 }
 
+// lane_h:cancel( [timeout,] force[, forcekill_timeout])
 LUAG_FUNC( thread_cancel)
 {
         if( lua_gettop( L) < 1 || lua_type( L, 1) != LUA_TUSERDATA)
@@ -2258,9 +2281,8 @@ LUAG_FUNC( thread_cancel)
         {
                 struct s_lane* s = lua_toLane( L, 1);
                 double secs = 0.0;
-                uint_t force_i = 2;
-                cancel_result result;
-                bool_t force;
+                int force_i = 2;
+                int forcekill_timeout_i = 3;
 
                 if( lua_isnumber( L, 2))
                 {
@@ -2270,30 +2292,34 @@ LUAG_FUNC( thread_cancel)
                                 return luaL_error( L, "can't force a soft cancel");
                         }
                         ++ force_i;
+                        ++ forcekill_timeout_i;
                 }
                 else if( lua_isnil( L, 2))
                 {
                         ++ force_i;
+                        ++ forcekill_timeout_i;
                 }
 
-                force = lua_toboolean( L, force_i);     // FALSE if nothing there
-
-                result = thread_cancel( s, secs, force);
-                switch( result)
                 {
+                        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;
+                                lua_pushboolean( L, 0);
+                                lua_pushstring( L, "timeout");
+                                return 2;
 
                         case CR_Cancelled:
-                        lua_pushboolean( L, 1);
-                        return 1;
-                        
+                                lua_pushboolean( L, 1);
+                                return 1;
+
                         case CR_Killed:
-                        lua_pushboolean( L, 0);
-                        lua_pushstring( L, "killed");
-                        return 2;
+                                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"
diff --git a/src/threading.c b/src/threading.c
index 63c39ae..ad5b473 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -330,6 +330,8 @@ bool_t THREAD_WAIT_IMPL( THREAD_T *ref, double secs)
                 *ref= NULL;
         }
 
+        void THREAD_MAKE_ASYNCH_CANCELLABLE() {} // nothing to do for windows threads, we can cancel them anytime we want
+
 #if !defined __GNUC__
         //see http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
         #define MS_VC_EXCEPTION 0x406D1388
@@ -896,11 +898,19 @@ bool_t THREAD_WAIT( THREAD_T *ref, double secs , SIGNAL_T *signal_ref, MUTEX_T *
 #endif // THREADWAIT_METHOD == THREADWAIT_CONDVAR
     return done;
   }
-  //
+        //
   void THREAD_KILL( THREAD_T *ref ) {
     pthread_cancel( *ref );
   }
 
+        void THREAD_MAKE_ASYNCH_CANCELLABLE()
+        {
+                // that's the default, but just in case...
+                pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+                // we want cancellation to take effect immediately if possible, instead of waiting for a cancellation point (which is the default)
+                pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+        }
+
         void THREAD_SETNAME( char const* _name)
         {
                 // exact API to set the thread name is platform-dependant
diff --git a/src/threading.h b/src/threading.h
index aa34248..4b28ce8 100644
--- a/src/threading.h
+++ b/src/threading.h
@@ -194,10 +194,16 @@ bool_t SIGNAL_WAIT( SIGNAL_T *ref, MUTEX_T *mu, time_d timeout );
 # define THREAD_PRIO_MIN (-3)
 # define THREAD_PRIO_MAX (+3)
 
+#define THREAD_CLEANUP_PUSH( cb_, val_)
+#define THREAD_CLEANUP_POP( execute_)
+
 #else // THREADAPI == THREADAPI_PTHREAD
     /* Platforms that have a timed 'pthread_join()' can get away with a simpler
     * implementation. Others will use a condition variable.
     */
+#if defined __WINPTHREADS_VERSION
+#define USE_PTHREAD_TIMEDJOIN
+#endif // __WINPTHREADS_VERSION
 # ifdef USE_PTHREAD_TIMEDJOIN
 #  ifdef PLATFORM_OSX
 #   error "No 'pthread_timedjoin()' on this system"
@@ -229,6 +235,9 @@ bool_t SIGNAL_WAIT( SIGNAL_T *ref, MUTEX_T *mu, time_d timeout );
 #  define THREAD_PRIO_MIN (-2)
 #  define THREAD_PRIO_MAX (+2)
 # endif
+
+#define THREAD_CLEANUP_PUSH( cb_, val_) pthread_cleanup_push( cb_, val_)
+#define THREAD_CLEANUP_POP( execute_) pthread_cleanup_pop( execute_)
 #endif // THREADAPI == THREADAPI_WINDOWS
 
 /*
@@ -253,7 +262,8 @@ bool_t THREAD_WAIT_IMPL( THREAD_T *ref, double secs, SIGNAL_T *signal_ref, MUTEX
 #define THREAD_WAIT THREAD_WAIT_IMPL
 #endif // // THREADWAIT_METHOD == THREADWAIT_CONDVAR
 
-void THREAD_KILL( THREAD_T *ref );
+void THREAD_KILL( THREAD_T* ref);
 void THREAD_SETNAME( char const* _name);
+void THREAD_MAKE_ASYNCH_CANCELLABLE();
 
 #endif // __threading_h__
diff --git a/src/tools.c b/src/tools.c
index 754605b..b5f2f4b 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -570,13 +570,14 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
 lua_State* luaG_newstate( lua_State* _from, int const _on_state_create, char const* libs)
 {
         // reuse alloc function from the originating state
-        void* allocUD;
-        lua_Alloc allocF = lua_getallocf( _from, &allocUD);
-        lua_State* L = lua_newstate( allocF, allocUD);
+#if PROPAGATE_ALLOCF
+        PROPAGATE_ALLOCF_PREP( _from);
+#endif // PROPAGATE_ALLOCF
+        lua_State* L = PROPAGATE_ALLOCF_ALLOC();
 
         if( L == NULL)
         {
-                (void) luaL_error( _from, "'lua_newstate()' failed; out of memory");
+                (void) luaL_error( _from, "luaG_newstate() failed while creating state; out of memory");
         }
 
         // we'll need this everytime we transfer some C function from/to this state
diff --git a/src/tools.h b/src/tools.h
index e984ec2..19dca70 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -41,6 +41,17 @@ void luaL_requiref (lua_State* L, const char* modname, lua_CFunction openf, int
 #define luaG_registerlibfuncs( L, _funcs) luaL_setfuncs( L, _funcs, 0)
 #endif // LUA_VERSION_NUM == 502
 
+// For some reason, LuaJIT 64bits doesn't support lua_newstate()
+// If you build specifically for this situation, change value to 0
+#define PROPAGATE_ALLOCF 1
+#if PROPAGATE_ALLOCF
+#define PROPAGATE_ALLOCF_PREP( L) void* allocUD; lua_Alloc allocF = lua_getallocf( L, &allocUD)
+#define PROPAGATE_ALLOCF_ALLOC() lua_newstate( allocF, allocUD)
+#else // PROPAGATE_ALLOCF
+#define PROPAGATE_ALLOCF_PREP( L)
+#define PROPAGATE_ALLOCF_ALLOC() luaL_newstate()
+#endif // PROPAGATE_ALLOCF
+
 #define USE_DEBUG_SPEW 0
 #if USE_DEBUG_SPEW
 extern char const* debugspew_indent;