8 files changed, 258 insertions, 126 deletions

diff --git a/CHANGES b/CHANGES
index 0a6889d..f450700 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,16 @@
 CHANGES:
 
+CHANGE 90: BGe 16-Jan-14
+   * version 3.7.8
+   * lane:cancel() now accepts a boolean second argument when soft cancelling (negative timeout) to wake the thread if necessary
+   * if a blocked linda send() or receive() call is interrupted by a cancellation request,
+     it returns CANCEL_ERROR so that this case can be differentiated from a simple timeout
+   * fixed WIN32 THREAD_CREATE() wrong _beginthreadex() error detection
+   * fatal WIN32 threading errors retrieve and output the error description string with FormatMessage()
+   * fixed missing lanes.set_singlethreaded
+   * fixed perftest.lua
+   * added test/cancel.lua
+
 CHANGE 89: BGe 09-Jan-14
    * version 3.7.7
    * fix crash when calling linda:count() on unknown keys
diff --git a/docs/index.html b/docs/index.html
index c62f64f..3b64cb4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -70,7 +70,7 @@
                         </p>
 
                         <p>
-                                This document was revised on 09-Jan-14, and applies to version <tt>3.7.7</tt>.
+                                This document was revised on 16-Jan-14, and applies to version <tt>3.7.8</tt>.
                         </p>
                 </font>
         </center>
@@ -880,13 +880,18 @@
 <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] [, forcekill_timeout=0.0])
+        bool[,reason] = lane_h:cancel( [positive_timeout_secs=0.0] [, force_kill_bool = false] [, forcekill_timeout=0.0])
+        bool[,reason] = lane_h:cancel( negative_timeout_secs [, wake_bool = false])
 </pre></td></tr></table>
 
 <p>
         <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/>
+        First argument is a timeout, that defaults to 0 if not specified. (Starting with version 3.6.3) signification of the following arguments differ depending on whether the timeout is negative or not.
+        <br/>
+        If <tt>timeout_secs</tt> is negative (aka "soft cancel"), cancellation will only cause <tt>cancel_test()</tt> to return <tt>true</tt>, so that the lane can cleanup manually (the actual value is irrelevant).
+        If <tt>wake_bool</tt> is <tt>true</tt>, the lane is also signalled so that execution returns from any pending linda operation.
+        <br/>
+        If <tt>timeout_secs</tt> is positive (aka "hard cancel"), waits for the request to be processed, or a timeout to occur. Linda operations detecting the cancellation request will raise a special cancellation error (meaning they won't return in that case).
         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>
@@ -1010,11 +1015,11 @@
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
         h = lanes.linda( [opt_name])
 
-        bool = h:send( [timeout_secs,] key, ...)
+        bool|cancel_error = h:send( [timeout_secs,] key, ...)
 
-        [key, val] = h:receive( [timeout_secs,] key [, ...])
+        [key, val]|[cancel_error] = h:receive( [timeout_secs,] key [, ...])
 
-        [key, val [, ...]] = h:receive( timeout, h.batched, key, n_uint_min[, n_uint_max])
+        [key, val [, ...]]|[cancel_error] = h:receive( timeout, h.batched, key, n_uint_min[, n_uint_max])
 
         [true] = h:limit( key, n_uint)
 </pre></td></tr></table>
@@ -1041,12 +1046,16 @@
 
 <p>
         <tt>send()</tt> returns <tt>true</tt> if the sending succeeded, and <tt>false</tt> if the queue limit was met, and the queue did not empty enough during the given timeout.
+        <br/>
+        (Since version 3.7.8) <tt>send()</tt> returns <tt>lanes.cancel_error</tt> if interrupted by a soft cancel request.
 </p>
 
 <p>
         Equally, <tt>receive()</tt> returns a key and the value extracted from it, or nothing for timeout. Note that <tt>nil</tt>s can be sent and received; the <tt>key</tt> value will tell it apart from a timeout.
-        <br>
+        <br/>
         Version 3.4.0 introduces an API change in the returned values: <tt>receive()</tt> returns the key followed by the value(s), in that order, and not the other way around.
+        <br/>
+        (Since version 3.7.8) <tt>receive()</tt> returns <tt>lanes.cancel_error</tt> if interrupted by a soft cancel request.
 </p>
 
 <p>
diff --git a/src/lanes.c b/src/lanes.c
index ef44d90..cad8fb1 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.7.7";
+char const* VERSION = "3.7.8";
 
 /*
 ===============================================================================
@@ -189,11 +189,59 @@ struct s_lane
         // For tracking only
 };
 
-static enum e_cancel_request cancel_test( lua_State* L);
-static void cancel_error( lua_State*L );
+// To allow free-running threads (longer lifespan than the handle's)
+// 'struct s_lane' are malloc/free'd and the handle only carries a pointer.
+// This is not deep userdata since the handle's not portable among lanes.
+//
+#define lua_toLane( L, i)  (*((struct s_lane**) lua_touserdata( L, i)))
+
+#define CANCEL_TEST_KEY ((void*)get_lane)    // used as registry key
+static inline struct s_lane* get_lane( lua_State* L)
+{
+        struct s_lane* s;
+        STACK_GROW( L, 1);
+        STACK_CHECK( L);
+        lua_pushlightuserdata( L, CANCEL_TEST_KEY);
+        lua_rawget( L, LUA_REGISTRYINDEX);
+        s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) / nil
+        lua_pop( L, 1);
+        STACK_END( L, 0);
+        return s;
+}
+
+/*
+* 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)
+{
+        struct s_lane* const s = get_lane( L);
+        // 's' is NULL for the original main state (and no-one can cancel that)
+        return s ? s->cancel_request : CANCEL_NONE;
+}
 
-#define CANCEL_TEST_KEY ((void*)cancel_test)    // used as registry key
 #define CANCEL_ERROR ((void*)cancel_error)      // 'cancel_error' sentinel
+static int cancel_error( lua_State* L)
+{
+        STACK_GROW( L, 1);
+        lua_pushlightuserdata( L, CANCEL_ERROR); // special error value
+        return lua_error( L); // doesn't return
+}
+
+static void cancel_hook( lua_State* L, lua_Debug* ar)
+{
+        (void)ar;
+        if( cancel_test( L) != CANCEL_NONE)
+        {
+                cancel_error( L);
+        }
+}
+
 
 #if ERROR_FULL_STACK
 static int lane_error( lua_State* L);
@@ -383,6 +431,7 @@ static void check_key_types( lua_State*L, int _start, int _end)
 *
 * Returns:  'true' if the value was queued
 *           'false' for timeout (only happens when the queue size is limited)
+*           nil, CANCEL_ERROR if cancelled
 */
 LUAG_FUNC( linda_send)
 {
@@ -417,7 +466,7 @@ LUAG_FUNC( linda_send)
         // convert nils to some special non-nil sentinel in sent values
         keeper_toggle_nil_sentinels( L, key_i + 1, 1);
 
-        STACK_GROW(L, 1);
+        STACK_GROW( L, 1);
         {
                 struct s_Keeper* K = keeper_acquire( linda);
                 lua_State* KL = K ? K->L : NULL; // need to do this for 'STACK_CHECK'
@@ -451,26 +500,17 @@ LUAG_FUNC( linda_send)
                         }
                         /* limit faced; push until timeout */
 
-                        cancel = cancel_test( L);   // testing here causes no delays
-                        if( cancel != CANCEL_NONE) // if user wants to cancel, the call returns without sending anything
                         {
-                                break;
-                        }
-
-                        // change status of lane to "waiting"
-                        {
-                                struct s_lane* s;
                                 enum e_status prev_status = ERROR_ST; // prevent 'might be used uninitialized' warnings
-                                STACK_GROW( L, 1);
-
-                                STACK_CHECK( L);
-                                lua_pushlightuserdata( L, CANCEL_TEST_KEY);
-                                lua_rawget( L, LUA_REGISTRYINDEX);
-                                s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) or nil if in the main Lua state
-                                lua_pop( L, 1);
-                                STACK_END( L, 0);
+                                struct s_lane* const s = get_lane( L);
                                 if( s != NULL)
                                 {
+                                        cancel = s->cancel_request; // testing here causes no delays
+                                        if( cancel != CANCEL_NONE) // if user wants to cancel, the call returns without sending anything
+                                        {
+                                                break;
+                                        }
+                                        // change status of lane to "waiting"
                                         prev_status = s->status; // RUNNING, most likely
                                         ASSERT_L( prev_status == RUNNING); // but check, just in case
                                         s->status = WAITING;
@@ -484,6 +524,8 @@ LUAG_FUNC( linda_send)
                                         {
                                                 s->waiting_on = NULL;
                                                 s->status = prev_status;
+                                                // if woken by a cancel request, be sure to handle it properly
+                                                cancel = s->cancel_request;
                                         }
                                         break;
                                 }
@@ -504,12 +546,21 @@ LUAG_FUNC( linda_send)
                 return luaL_error( L, "tried to copy unsupported types");
         }
 
-        // raise an error interrupting execution only in case of hard cancel
-        if( cancel == CANCEL_HARD)
-                cancel_error( L);
+        switch( cancel)
+        {
+                case CANCEL_SOFT:
+                // if user wants to soft-cancel, the call returns CANCEL_ERROR
+                lua_pushlightuserdata( L, CANCEL_ERROR);
+                return 1;
 
-        lua_pushboolean( L, ret);
-        return 1;
+                case CANCEL_HARD:
+                // raise an error interrupting execution only in case of hard cancel
+                return cancel_error( L); // raises an error and doesn't return
+
+                default:
+                lua_pushboolean( L, ret); // true (success) or false (timeout)
+                return 1;
+        }
 }
 
 
@@ -611,26 +662,17 @@ LUAG_FUNC( linda_receive)
                         }
                         /* nothing received; wait until timeout */
 
-                        cancel = cancel_test( L);   // testing here causes no delays
-                        if( cancel != CANCEL_NONE) // if user wants to cancel, the call returns without providing anything
                         {
-                                break;
-                        }
-
-                        // change status of lane to "waiting"
-                        {
-                                struct s_lane* s;
                                 enum e_status prev_status = ERROR_ST; // prevent 'might be used uninitialized' warnings
-                                STACK_GROW( L, 1);
-
-                                STACK_CHECK( L);
-                                lua_pushlightuserdata( L, CANCEL_TEST_KEY);
-                                lua_rawget( L, LUA_REGISTRYINDEX);
-                                s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) or nil if in the main Lua state
-                                lua_pop( L, 1);
-                                STACK_END( L, 0);
+                                struct s_lane* const s = get_lane( L);
                                 if( s != NULL)
                                 {
+                                        cancel = s->cancel_request; // testing here causes no delays
+                                        if( cancel != CANCEL_NONE) // if user wants to cancel, the call returns without providing anything
+                                        {
+                                                break;
+                                        }
+                                        // change status of lane to "waiting"
                                         prev_status = s->status; // RUNNING, most likely
                                         ASSERT_L( prev_status == RUNNING); // but check, just in case
                                         s->status = WAITING;
@@ -644,6 +686,8 @@ LUAG_FUNC( linda_receive)
                                         {
                                                 s->waiting_on = NULL;
                                                 s->status = prev_status;
+                                                // if woken by a cancel request, be sure to handle it properly
+                                                cancel = s->cancel_request;
                                         }
                                         break;
                                 }
@@ -663,11 +707,20 @@ LUAG_FUNC( linda_receive)
                 return luaL_error( L, "tried to copy unsupported types");
         }
 
-        // raise an error interrupting execution only in case of hard cancel
-        if( cancel == CANCEL_HARD)
-                cancel_error( L);
+        switch( cancel)
+        {
+                case CANCEL_SOFT:
+                // if user wants to soft-cancel, the call returns CANCEL_ERROR
+                lua_pushlightuserdata( L, CANCEL_ERROR);
+                return 1;
 
-        return pushed;
+                case CANCEL_HARD:
+                // raise an error interrupting execution only in case of hard cancel
+                return cancel_error( L); // raises an error and doesn't return
+
+                default:
+                return pushed;
+        }
 }
 
 
@@ -1225,6 +1278,14 @@ static cancel_result thread_cancel( lua_State* L, struct s_lane* s, double secs,
                 {
                         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;
                 }
@@ -1509,54 +1570,6 @@ static int selfdestruct_gc( lua_State* L)
 }
 
 
-// To allow free-running threads (longer lifespan than the handle's)
-// 'struct s_lane' are malloc/free'd and the handle only carries a pointer.
-// This is not deep userdata since the handle's not portable among lanes.
-//
-#define lua_toLane(L,i)  (* ((struct s_lane**) lua_touserdata(L,i)))
-
-
-/*
-* 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 enum e_cancel_request cancel_test( lua_State* L)
-{
-        struct s_lane* s;
-
-        STACK_GROW( L, 1);
-
-        STACK_CHECK( L);
-        lua_pushlightuserdata( L, CANCEL_TEST_KEY);
-        lua_rawget( L, LUA_REGISTRYINDEX);
-        s = lua_touserdata( L, -1);     // lightuserdata (true 's_lane' pointer) / nil
-        lua_pop( L, 1);
-        STACK_END( L, 0);
-
-        // 's' is NULL for the original main state (no-one can cancel that)
-        //
-        return s ? s->cancel_request : CANCEL_NONE;
-}
-
-static void cancel_error( lua_State*L ) {
-    STACK_GROW(L,1);
-    lua_pushlightuserdata( L, CANCEL_ERROR );    // special error value
-    lua_error(L);   // no return
-}
-
-static void cancel_hook( lua_State*L, lua_Debug *ar )
-{
-        (void)ar;
-        if( cancel_test( L) != CANCEL_NONE)
-                cancel_error( L);
-}
-
-
 //---
 // bool = cancel_test()
 //
@@ -2294,7 +2307,7 @@ LUAG_FUNC( thread_gc)
         return 0;
 }
 
-// lane_h:cancel( [timeout,] force[, forcekill_timeout])
+// lane_h:cancel( [timeout] [, force [, forcekill_timeout]])
 LUAG_FUNC( thread_cancel)
 {
         if( lua_gettop( L) < 1 || lua_type( L, 1) != LUA_TUSERDATA)
@@ -2311,10 +2324,11 @@ LUAG_FUNC( thread_cancel)
                 if( lua_isnumber( L, 2))
                 {
                         secs = lua_tonumber( L, 2);
-                        if( secs < 0.0 && lua_gettop( L) > 2)
+                        if( secs < 0.0 && lua_gettop( L) > 3)
                         {
-                                return luaL_error( L, "can't force a soft cancel");
+                                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;
                 }
@@ -2330,16 +2344,16 @@ LUAG_FUNC( thread_cancel)
 
                         switch( thread_cancel( L, s, secs, force, forcekill_timeout))
                         {
-                        case CR_Timeout:
+                                case CR_Timeout:
                                 lua_pushboolean( L, 0);
                                 lua_pushstring( L, "timeout");
                                 return 2;
 
-                        case CR_Cancelled:
+                                case CR_Cancelled:
                                 lua_pushboolean( L, 1);
                                 return 1;
 
-                        case CR_Killed:
+                                case CR_Killed:
                                 lua_pushboolean( L, 0);
                                 lua_pushstring( L, "killed");
                                 return 2;
diff --git a/src/lanes.lua b/src/lanes.lua
index 0c544bb..e7b9715 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -128,7 +128,6 @@ lanes.configure = function( settings_)
         end
         local settings = core.configure and core.configure( params_checker( settings_)) or core.settings
         local thread_new = assert( core.thread_new)
-        local set_singlethreaded = assert( core.set_singlethreaded)
         local max_prio = assert( core.max_prio)
 
 lanes.ABOUT =
@@ -664,6 +663,7 @@ end
         lanes.linda = core.linda
         lanes.cancel_error = core.cancel_error
         lanes.nameof = core.nameof
+        lanes.set_singlethreaded = core.set_singlethreaded
         lanes.threads = core.threads or function() error "lane tracking is not available" end -- core.threads isn't registered if settings.track_lanes is false
         lanes.set_thread_priority = core.set_thread_priority
         lanes.timer = timer
diff --git a/src/threading.c b/src/threading.c
index 3014136..5a3e64b 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -87,11 +87,13 @@ THE SOFTWARE.
 #if defined( PLATFORM_XBOX) || defined( PLATFORM_WIN32) || defined( PLATFORM_POCKETPC)
 static void FAIL( char const* funcname, int rc)
 {
-        fprintf( stderr, "%s() failed! (%d)\n", funcname, rc );
+        char buf[256];
+        FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM, NULL, rc, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 256, NULL);
+        fprintf( stderr, "%s() failed! [GetLastError() -> %d] '%s'", funcname, rc, buf);
 #ifdef _MSC_VER
-    __debugbreak(); // give a chance to the debugger!
+        __debugbreak(); // give a chance to the debugger!
 #endif // _MSC_VER
-    abort();
+        abort();
 }
 #endif // win32 build
 
@@ -296,11 +298,15 @@ void THREAD_CREATE( THREAD_T* ref, THREAD_RETURN_T (__stdcall *func)( void*), vo
                 NULL  // thread id (not used)
         );
 
-        if( h == INVALID_HANDLE_VALUE)
+        if( h == NULL) // _beginthreadex returns 0L on failure instead of -1L (like _beginthread)
+        {
                 FAIL( "CreateThread", GetLastError());
+        }
 
         if (!SetThreadPriority( h, gs_prio_remap[prio + 3]))
+        {
                 FAIL( "SetThreadPriority", GetLastError());
+        }
 
         *ref = h;
 }
diff --git a/tests/cancel.lua b/tests/cancel.lua
new file mode 100644
index 0000000..0aab341
--- /dev/null
+++ b/tests/cancel.lua
@@ -0,0 +1,93 @@
+local lanes = require "lanes" .configure{ with_timers = false}
+
+local linda = lanes.linda()
+
+local laneBody = function( timeout_)
+        set_finalizer( function( err, stk)
+                if err == lanes.cancel_error then
+                        -- note that we don't get the cancel_error when running wrapped inside a protected call if it doesn't rethrow it
+                        print( "                        laneBody after cancel" )
+                elseif err then
+                        print( "                        laneBody error: "..tostring(err))
+                else
+                        print("                 laneBody finalized")
+                end
+        end)
+
+        print( "                        entering lane with " .. tostring( timeout_) .. " timeout")
+        repeat
+                -- block-wait to be hard-cancelled
+                print "                 lane calling receive()"
+                local key, val = linda:receive( timeout_, "boob")
+                print( "                        receive() -> ", lanes.cancel_error == key and "cancel_error" or tostring( key), tostring( val))
+        until cancel_test() -- soft cancel self test
+        print "                 shutting down after breaking out of loop"
+end
+
+local protectedBody = function( ...)
+        local ce = lanes.cancel_error
+        local errorHandler = function( _msg)
+                -- forward the message to the main thread that will display it with a popup
+                print( "                        error handler got ", ce == _msg and "cancel_error"or tostring( _msg))
+                return _msg
+        end
+        -- Lua 5.1 doesn't pass additional xpcall arguments to the called function
+        -- therefore we need to create a closure that has no arguments but pulls everything from its upvalue
+        local params = {...}
+        local paramLessClosure = function() laneBody(table.unpack( params)) end
+        local status, message = xpcall( paramLessClosure, errorHandler)
+        if status == false then
+                print( "                        error handler rethrowing '" .. (ce == message and "cancel_error"or tostring( message)) .. "'")
+                -- if the error isn't rethrown, the lane's finalizer won't get it
+                error( message)
+        end
+end
+
+--####################################################################
+
+print "####################################################################\nbegin soft cancel test\n"
+h = lanes.gen("*", protectedBody)( 0.666)
+print "wait 3s"
+linda:receive( 3, "yeah")
+
+-- soft cancel
+print "soft cancel with awakening"
+h:cancel( -1, true)
+
+-- wait 10s: the lane will interrupt its loop and print the exit message
+print "wait 2s"
+linda:receive( 2, "yeah")
+
+--####################################################################
+
+print "\n\n####################################################################\nbegin hard cancel test\n"
+h = lanes.gen("*", protectedBody)()
+
+-- wait 3s before cancelling the lane
+print "wait 3s"
+linda:receive( 3, "yeah")
+
+-- hard cancel and wait 10s: the lane will be interrupted from inside its current linda:receive() and won't return from it
+print "hard cancel (always awakens)"
+h:cancel()
+
+print "wait 5s"
+linda:receive( 5, "yeah")
+
+--####################################################################
+
+print "\n\n####################################################################\nbegin hard cancel test with unprotected lane body\n"
+h = lanes.gen("*", laneBody)()
+
+-- wait 3s before cancelling the lane
+print "wait 3s"
+linda:receive( 3, "yeah")
+
+-- hard cancel and wait 10s: the lane will be interrupted from inside its current linda:receive() and won't return from it
+print "hard cancel (always awakens)"
+h:cancel()
+
+print "wait 5s"
+linda:receive( 5, "yeah")
+
+print "\ndone"
\ No newline at end of file
diff --git a/tests/linda_perf.lua b/tests/linda_perf.lua
index ebe9eac..9348f71 100644
--- a/tests/linda_perf.lua
+++ b/tests/linda_perf.lua
@@ -34,7 +34,7 @@ local function ziva( preloop, loop, batch)
         -- prefill the linda a bit to increase fifo stress
         local top = math.max( preloop, loop)
         local l, lane = lanes.linda()
-        local t1 = os.time()
+        local t1 = lanes.now_secs()
         for i = 1, preloop do
                 l:send( "key", i)
         end
@@ -59,7 +59,7 @@ local function ziva( preloop, loop, batch)
         end
         l:send( "done" ,"are you happy?")
         lane:join()
-        return os.difftime(os.time(), t1)
+        return lanes.now_secs() - t1
 end
 
 local tests =
@@ -149,7 +149,7 @@ local function ziva2( preloop, loop, batch)
                         l:receive( "key")
                 end
         end
-        local t1 = os.time()
+        local t1 = lanes.now_secs()
         -- first, prime the linda with some data
         for i = 1, preloop, step do
                 batch_send()
@@ -165,7 +165,7 @@ local function ziva2( preloop, loop, batch)
         for i = 1, preloop, step do
                         batch_read()
         end
-        return os.difftime(os.time(), t1)
+        return lanes.now_secs() - t1
 end
 
 local tests2 =
diff --git a/tests/perftest.lua b/tests/perftest.lua
index 4df2ad8..6ffc064 100644
--- a/tests/perftest.lua
+++ b/tests/perftest.lua
@@ -27,8 +27,7 @@
 local MSYS= os.getenv("OSTYPE")=="msys"
 
 
-local lanes = require "lanes"
-lanes.configure()
+local lanes = require "lanes".configure{ with_timers = false}
 
 local m= require "argtable"
 local argtable= assert( m.argtable )
@@ -36,7 +35,7 @@ local argtable= assert( m.argtable )
 local N= 1000   -- threads/loops to use
 local M= 1000   -- sieves from 1..M
 local PLAIN= false      -- single threaded (true) or using Lanes (false)
-local SINGLE= false     -- cores to use (false / 1..n) 
+local SINGLE= 0     -- cores to use (0 / 1..n) 
 local TIME= false       -- use Lua for the timing
 local PRIO_ODD, PRIO_EVEN   -- -3..+3
 
@@ -63,7 +62,7 @@ end
 for k,v in pairs( argtable(...) ) do
     if k==1 then            N= tonumber(v) or HELP()
     elseif k=="plain" then  PLAIN= true
-    elseif k=="single" then  SINGLE= v  -- true/number
+    elseif k=="single" then  SINGLE= v  -- number
     elseif k=="time" then   TIME= true
     elseif k=="prio" then   PRIO_ODD, PRIO_EVEN= prio_param(v)
     else                    HELP()
@@ -104,7 +103,7 @@ local function sieve_lane(N,id)
     while 1 do
       local n = g()
       if n == nil then return end
-      if math.mod(n, p) ~= 0 then coroutine.yield(n) end
+      if math.fmod(n, p) ~= 0 then coroutine.yield(n) end
     end
   end)
  end
@@ -138,7 +137,7 @@ local f_odd= lanes.gen( "base,coroutine,math,table,io",  -- "*" = all
 
 io.stderr:write( "*** Counting primes 1.."..M.." "..N.." times ***\n\n" )
 
-local t0= TIME and os.time()
+local t0= TIME and lanes.now_secs()
 
 if PLAIN then
     io.stderr:write( "Plain (no multithreading):\n" )
@@ -148,9 +147,9 @@ if PLAIN then
         assert( type(tmp)=="table" and tmp[1]==2 and tmp[168]==997 )
     end
 else
-    if SINGLE then
+    if SINGLE > 0 then
         io.stderr:write( (tonumber(SINGLE) and SINGLE or 1) .. " core(s):\n" )
-        lanes.single(SINGLE)    -- limit to N cores (just OS X)
+        lanes.set_singlethreaded(SINGLE)    -- limit to N cores (just OS X)
     else
         io.stderr:write( "Multi core:\n" )
     end
@@ -177,7 +176,7 @@ end
 io.stderr:write "\n"
 
 if TIME then
-    local t= os.time() - t0
+    local t= lanes.now_secs() - t0
     io.stderr:write( "*** TIMING: "..t.." seconds ***\n" )
 end