version 3.11

• Fixed some compilation warnings and some lua API call errors in DEBUG_SPEW code
• Improved LuaJIT support
• new Lanes API function lanes.register( "name", module) to manually register a module table after it was required. Transfering registered module tables will link the equivalent in the destination state instead of cloning it

version 3.10.1

• Fix an implicit number-to-string conversion in keeper.c.
• Fix 64 bits compilation warnings.
• Added support __of lanesignore field in metatables.

version 3.10.0

Lua 5.3 support

version 3.9.4

Changes since version 3.8.3:

• set_finalizer throws an error if provided finalizer isn't a function
• fix error handling when the error doesn't generate an error handler call (IOW, all errors but LUA_ERRRUN)
• provide callstack if LUA_ERRRUN occurs inside a finalizer
• Fixed crash when using protect_allocator option
• new exposed variable linda.null that exposes the internal NIL_SENTINEL marker
• linda:send() interprets send key linda.null as authorization to silently send a single nil when not provided with anything to send (useful when sending results of a function that can return nothing)
• Internal rework: the whole Lanes engine now works "per universe" to allow concurrent Lanes execution in more than one embedded master state
  • this universe is a full userdata created in the master state, selfdestruct_gc is the __gc for this userdata
  • most of what was initialized only once is now per-universe
  • Added forgotten mutex desinitialisation at universe shutdown
  • Fix lookup database table not being created when it should if Lanes is required in more than one Lua master state
• Fixed potential crashes at desinit if problems occur during keeper states initialization
• Fixed require() not always serialized properly
• Make sure we don't mutex-wrap require() more than once, just in case
• Raise an error instead of crashing on deep userdata prelude memory allocation failure
• raise an error instead of dereferencing a NULL pointer on deep userdata creation and lane struct creation
• removed some keeper desinit legacy dead code
• keeper array is allocated with master state's alloc function instead of malloc()/free()
• prevent application crash when specifying a very large number of keepers in the configuration options
• any error occuring during one-time inits is raised outside the one-time mutex protected code region
• lanes.linda() accepts an optional integer group to give control on keeper state repartition
• keepers now require "package", receive package.path & package.cpath, and call on_state_create() if it is a C function
• changed the deep public API (improved deep idfunc signature, renamed luaG_deep_userdata to luaG_newdeepuserdata)
• if an error occurs while copying a deep userdata, don't raise inside the keeper state
• fixed situations where raised errors could lead to memory leaks (deep gc)
• fixed a possible Lua stack overflow when calling linda:dump()
• new API linda:cancel("read"|"write"|"both"|"none")
  • all linda operations return lanes.cancel_error on a cancelled linda
  • lanes.genlock() and lanes.genatomic() support cancelled lindas by returning lanes.cancel_error whenever appropriate
  • linda:limit() returns lanes.cancel_error on a limited linda
  • fixed cases where linda:send() and linda:receive() would not return lanes.cancel_error when they should
• raised an internal string length so that longer linda names are fully output before truncation applies when doing tostring( linda)
• another Lua stack overflow fix when sending complex function through lindas or as lane body

version 3.8.3

• fixed possible Lua stack overflows when sending complex function through lindas or as lane body
• experimental: lanes.nameof() scans the registry if a regular search didn't yield anything interesting
• fixed lanes.nameof() misbehaving when encountering a LUA_TTHREAD object
• new lane launcher option gc_cb to set a callback that is invoked when a lane is garbage collected
• slightly improve linda performance when the producer/consumer scenario leaves leave the key empty
• new function lane:get_debug_threadname()
• Fix invalid memory accesses when fetching the name of a joined lane with lanes:threads() (because its lua_State is closed)
• use luaL_newmetatable() to create the metatable for lane objects
• prevent malicious code from crashing by calling lane methods without passing the lane as first argument (raise an error instead)
• set_debug_threadname() is no longer registered in the function lookup databases because it holds a C pointer as upvalue and it might crash if used maliciously
• linda:set() accepts multiple values to set in the specified slot
• linda:get() accepts an optional count to peek several values at once
• 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

version 3.7.7

Changes since version 3.7.0:

• errors inside finalizers generate a full stack just like any other error
• Fix windows build not exporting public 'deep' API
• Don't call on_state_create in keeper states, as it is no longer necessary
• Remove inclusion of stdint.h
• Fix windows build for WINVER > 0x400
• Fix lanes.nameof() crashing when encountering a light userdata
• Fix a few compilation warnings about uninitialized variables
• Fixed a bad extern variable declaration resulting in multiple instances (crashes the Pelles-C build)
• Make set_finalizer(), set_debug_threadname(), cancel_test() and set_error_reporting() transferable from lane to lane
• Improved some DEBUGSPEW output
• Fix a case where an error could be raised inside a keeper state
• Fixed function returned by lanes.genlock() not handling numeric keys properly when release lock
• Enable lanes.genlock() to attempt lock with an optional "try" mode
• internal: make EnableCrashingOnCrashes a one-time operation
• Fix a deadlock when GCing during a linda operation.
• Fix a compilation warning about an unused variable
• Get rid of uintptr_t to remove dependency on stdint.h
• Fix internal error at lane creation when the generator doesn't open any base library
• 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)
• internal refactoring of pthread priority management code
• new API lanes.set_thread_priority()
• fixed a crash that can occur at shutdown when an object stored inside a keeper state performs a linda operation on a linda making use of another keeper
• new setting demote_full_userdata to select between light userdata demotion or raising an error when attempting to transfer a non-deep full userdata
• if config.on_state_create() is a C function, call it by direct C closure reconstruction in newly created states
• fix crash when calling linda:count() on unknown keys
• purge key storage with linda:set( key, nil) on an unlimited key to reduce memory usage with lots of keys
• linda:limit() wakes write-blocked threads if necessary when the new limit enables writes to occur again
• linda:set() wakes write-blocked threads if necessary if the operation created some room to write into

version 3.7.0

• fix lanes.threads() not being available in a lane where
  lanes.configure() settings didn't contain track_lanes although the
  initial configure() call did.
• require "lanes".configure() sequence is only necessary at the first
  require "lanes".
• fix a crash at application shutdown where in some situations we could
  deinitialize the protected allocator mutex while a lane was still using
  it.
• fix timers broken in version 3.6.5
• bugfix: no longer create a global named "lanes.core" inside lanes having "*" as library list

version 3.6.6

• Reduce memory footprint, simplify module order setup in conjunction with Lanes, and send over native functions a bit faster as well
• Lanes no longer has to internally require modules inside the keeper states because they no longer need a lookup database. Instead, the lookup name is stored as-is and actually converted in the destination state
• optimization: bypass cache when sending native functions over
• removed all the KEEPER_MODEL_LUA code, as it can no longer work anyway
• no longer call core.configure with dummy params when requiring lanes more than once (fixes potential multithreading issues with LuaJIT allocator)
• activated EnableCrashingOnCrashes() on Win32 debug builds
• fixed some comments in code
• properly handle cases when a Lua C module is a C function

version 3.6.4

Fix possible application hang at shutdown if a keeper state referenced a linda.

v3.6.3: version 3.6.3

* lane:cancel(<negative-timeout>) only causes cancel_test() to return
true but won't interrupt execution of the lane during linda operations
* more explicit errors when trying to transfer unknown source functions
(with new configure option verbose_errors)
* default options wrap allocator around a mutex when run by LuaJIT