version 3.16.0

• fix require() wrapper to return all values returned by original require()
• Lanes no longer relies on malloc/free for internal allocations, but uses the primary alloc function from the master Lua state (excepted for LuaJIT flavors, because the allocator seems to assume that it won't be used oustide the Lua state).
• __lanesclone is now called only once with 3 parameters dest, source, size -> BREAKS CUSTOM DEEP USERDATA API

version 3.15.1

Fix Lanes not working with Lua 5.4 due to changes in the way luaL_buffer is working compared to previous versions of Lua.

version 3.15

• a bunch of code cleanup.
• some build fixes pull from external contributors working on platforms I don't have access to.
• fixed set_tread_affinity.
• changed lanes.threads() output so that several lanes with the same name don't clobber each other in the result table
• __lanesclone now receives the original as light userdata the first time it is called
• correctly transfer the uservalue of a deep userdata
• fix stack overflow when transfering a clonable userdata referencing itself through a uservalue.
• fixed some unit tests.

version 3.13

• Lua 5.4 support
• New API lanes.set_thread_affinity()
• Add support for user-provided __gc in deep userdata
• Add deep user data cloning support though __lanesclone metamethod
• Deep userdata must embed DeepPrelude to save an allocation (also changes Deep protocol)
• set_debug_threadname implemented with win32 pthread
• lane:join() now returns nil, "timeout" in case of timeout
• Don't test __lanesignore for POD types (-> slightly faster when trasnfering lots of data)
• protected_allocator option replaced by something else more flexible (see documentation)
• Version is available in public header
• More complete deep userdata sample
• Raise an error instead of crashing when attempting to transfer a non-deep full userdata
• Make sure any linda operation that can raise an error won't ever leave a mutex unreleased
• Support for integer formatting in verbose errors
• Fix a stack overflow when copying large tables with verbose_errors option enabled
• Compilation and runtime fixes for LuaJIT, MacOS and Android.
• Fix crash trying to use a deep-aware module while not requiring Lanes
• Fix an internal error trying to call on_state_create in a lane without any libs loaded
• Fix potential crash at application shutdown when deep userdata were created before Lanes is required
• Lots of internal code changes (function split, file split, type declarations moved around, etc.)

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