koffi 1.3.4 → 1.3.5

package/CMakeLists.txt

@@ -54,7 +54,7 @@ set(KOFFI_SRC
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
     # CMAKE_SYSTEM_PROCESSOR is wrong on Windows ARM64
 
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch|arm" OR CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64")
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch|arm" OR CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64" OR CMAKE_OSX_ARCHITECTURES MATCHES "arm")
         if(WIN32)
             get_filename_component(cl_dir "${CMAKE_CXX_COMPILER}" DIRECTORY)
             file(TO_CMAKE_PATH "${cl_dir}/armasm64.exe" asm_compiler)

package/ChangeLog.md

@@ -1,10 +1,22 @@
 # Changelog
 
+## Koffi 1.3.5
+
+**Main changes:**
+
+- Fix memory leak when many async calls are running
+- Add configurable limit for maximum number of async calls (max_async_calls)
+
+**Other changes:**
+
+- Reduce default async memory stack and heap size
+- Various documentation improvements
+
 ## Koffi 1.3.4
 
 **Main fixes:**
 
-- Fix possible OpenBSD i386 crash with (void) functions
+- Fix possible OpenBSD i386 crash with `(void)` functions
 
 ## Koffi 1.3.3
 

package/doc/dist/html/_sources/functions.md.txt

@@ -2,16 +2,16 @@
 
 ## Function definitions
 
-To declare functions, start by loading the shared library with `koffi.load()`.
+To declare functions, start by loading the shared library with `koffi.load(filename)`.
 
 ```js
 const koffi = require('koffi');
 const lib = koffi.load('/path/to/shared/library'); // File extension depends on platforms: .so, .dll, .dylib, etc.
 ```
 
-You can use the returned object to load C functions from the library. Koffi supports two syntaxes:
+You can use the returned object to load C functions from the library. To do so, you can use two syntaxes:
 
-- Classic syntax, inspired by node-ffi
+- The classic syntax, inspired by node-ffi
 - C-like prototypes
 
 ### Classic syntax
@@ -27,18 +27,20 @@ Koffi automatically tries mangled names for non-standard x86 calling conventions
 
 ### C-like prototypes
 
-You can declare functions using simple C-like prototype strings, as shown below:
+If you prefer, you can declare functions using simple C-like prototype strings, as shown below:
 
 ```js
 const printf = lib.func('int printf(const char *fmt, ...)');
 const atoi = lib.func('int atoi(string)'); // The parameter name is not used by Koffi, and optional
 ```
 
+You can use `()` or `(void)` for functions that take no argument.
+
 ## Synchronous calls
 
 By default, calling a C function happens synchronously.
 
-Most architectures only support one procedure call standard per process. The 32-bit x86 platform is an exception to this, and Koffi support several standards:
+Most architectures only support one procedure call standard per process. The 32-bit x86 platform is an exception to this, and Koffi supports several x86 conventions:
 
  Convention   | Classic form                  | Prototype form | Description
 ------------- | ----------------------------- | -------------- | -------------------------------------------------------------------
@@ -49,7 +51,7 @@ Most architectures only support one procedure call standard per process. The 32-
 
 You can safely use these on non-x86 platforms, they are simply ignored.
 
-Below you can find a small example showing how to use a non-default calling convention:
+Below you can find a small example showing how to use a non-default calling convention, with the two syntaxes:
 
 ```js
 const koffi = require('koffi');
@@ -75,7 +77,9 @@ atoi.async('1257', (err, res) => {
 })
 console.log('Hello World!');
 
-// This program will print "Hello World!", and then "Result: 1257"
+// This program will print:
+//   Hello World!
+//   Result: 1257
 ```
 
 These calls are executed by worker threads. It is **your responsibility to deal with data sharing issues** in the native code that may be caused by multi-threading.
@@ -103,7 +107,7 @@ On x86 platforms, only the Cdecl convention can be used for variadic functions.
 
 By default, Koffi will only forward arguments from Javascript to C. However, many C functions use pointer arguments for output values, or input/output values.
 
-For simplicy, and because Javascript only has value semantics for primitive types, Koffi can marshal out (or in/out) two types of parameters:
+For simplicity, and because Javascript only has value semantics for primitive types, Koffi can marshal out (or in/out) two types of parameters:
 
 - [Structs](types.md#struct-types) (to/from JS objects)
 - [Opaque handles](types.md#opaque-handles)
@@ -168,8 +172,6 @@ sqlite3_close_v2(db);
 
 ## Javascript callbacks
 
-### Using callbacks
-
 In order to pass a JS function to a C function expecting a callback, you must first create a callback type with the expected return type and parameters. The syntax is similar to the one used to load functions from a shared library.
 
 ```js
@@ -182,7 +184,7 @@ const ExampleCallback = koffi.callback('ExampleCallback', 'void', ['int']);
 const AddDoubleFloat = koffi.callback('double AddDoubleFloat(double d, float f)');
 ```
 
-Once your callback type is declared, you can use them in struct definitions, or as function parameter and/or return type.
+Once your callback type is declared, you can use it in struct definitions, or as function parameter and/or return type.
 
 Here is a small example with the C part and the JS part.
 
@@ -219,8 +221,8 @@ console.log(ret);
 
 On x86 platforms, only Cdecl and Stdcall callbacks are supported.
 
-### Thread safety
+## Thread safety
 
-The callback must be called from the main thread, or more precisely from the same thread as the V8 intepreter.
+Asynchronous functions run on worker threads. You need to deal with thread safety issues if you share data between threads.
 
-Calling the callback from another thread is undefined behavior, and will likely lead to a mess.
+Callbacks must be called from the main thread, or more precisely from the same thread as the V8 intepreter. Calling a callback from another thread is undefined behavior, and will likely lead to a crash or a big mess. You've been warned!

package/doc/dist/html/_sources/memory.md.txt

@@ -4,7 +4,7 @@
 
 For synchronous/normal calls, Koffi uses two preallocated memory blocks:
 
-- One to construct to assign the C stack, subsequently used by the platform-specific assembly code (1 MiB by default)
+- One to construct the C stack and assign registers, subsequently used by the platform-specific assembly code (1 MiB by default)
 - One to allocate strings and big objects/structs (2 MiB by default)
 
 Unless very big strings or objects (at least more than one page of memory) are used, no extra allocation ever happens during calls or callbacks.
@@ -18,12 +18,15 @@ console.log(config);
 
 The same is true for asynchronous calls. When an asynchronous call is made, Koffi will allocate new blocks unless there is an unused (resident) set of blocks still available. Once the asynchronous call is finished, these blocks are freed if there are more than `resident_async_pools` sets of blocks left around.
 
+There cannot be more than `max_async_calls` running at the same time.
+
 ## Default settings
 
 Setting              | Default | Description
 -------------------- | ------- | -----------------------------------------------
 sync_stack_size      | 1 MiB   | Stack size for synchronous calls
 sync_heap_size       | 2 MiB   | Heap size for synchronous calls
-async_stack_size     | 512 kiB | Stack size for asynchronous calls
-async_heap_size      | 1 MiB   | Heap size for asynchronous calls
+async_stack_size     | 256 kiB | Stack size for asynchronous calls
+async_heap_size      | 512 kiB | Heap size for asynchronous calls
 resident_async_pools | 2       | Number of resident pools for asynchronous calls
+max_async_calls      | 64      | Maximum number of ongoing asynchronous calls

package/doc/dist/html/_sources/start.md.txt

@@ -19,7 +19,7 @@ Below you can find three examples:
 
 ## Small Linux example
 
-This is a small example for Linux systems, which uses `gettimeofday()` and `printf()` to print the current time and the timezone.
+This is a small example for Linux systems, which uses `gettimeofday()`, `localtime_r()` and `printf()` to print the current time.
 
 It illustrates the use of output parameters.
 
@@ -69,7 +69,7 @@ printf('Local time: %02d:%02d:%02d\n', 'int', now.tm_hour, 'int', now.tm_min, 'i
 
 ## Small Windows example
 
-This is a small example targeting the Win32 API, using `MessageBox()` to show a Hello message to the user.
+This is a small example targeting the Win32 API, using `MessageBox()` to show a *Hello World!* message to the user.
 
 It illustrates the use of the x86 stdcall calling convention.
 
@@ -85,5 +85,5 @@ const MB_ICONINFORMATION = 0x40;
 // Find functions
 const MessageBoxA = lib.stdcall('MessageBoxA', 'int', ['void *', 'string', 'string', 'uint']);
 
-MessageBoxA(null, 'Hello', 'Foobar', MB_ICONINFORMATION);
+MessageBoxA(null, 'Hello World!', 'Koffi', MB_ICONINFORMATION);
 ```

package/doc/dist/html/_sources/types.md.txt

@@ -42,6 +42,8 @@ Number (float)    | float64            | 8     |            |
 Number (float)    | float              | 4     |            |
 Number (float)    | double             | 8     |            |
 
+Koffi also accepts BigInt values when converting from JS to C integers. If the value exceeds the range of the C type, Koffi will convert the number to an undefined value. In the reverse direction, BigInt values are automatically used when needed for big 64-bit integers.
+
 Koffi defines a few more types that can change size depending on the OS and the architecture:
 
 JS type          | C type        | Signedness | Note
@@ -95,7 +97,7 @@ const A = koffi.struct('A', {
 
 Koffi follows the C and ABI rules regarding struct alignment and padding.
 
-Once a struct is declared, you can use it by name (with a string, like you can do for primitive types) or the through the value returned by the call to `koffi.struct()`. Only the latter is possible when declaring an anonymous struct.
+Once a struct is declared, you can use it by name (with a string, like you can do for primitive types) or through the value returned by the call to `koffi.struct()`. Only the latter is possible when declaring an anonymous struct.
 
 ```js
 // The following two function declarations are equivalent, and declare a function taking an A value and returning A
@@ -107,9 +109,9 @@ const Function2 = lib.func('Function', A, [A]);
 
 In C, pointer arguments are used for differenty purposes. It is important to distinguish these use cases because Koffi provides different ways to deal with each of them:
 
-- **Struct pointers**: Use of struct pointers by C libraries fall in two cases: avoid (potentially) expensive copies, and to let the function change struct contents (output or input/output argument).
-- **Opaque handles**: the library does not expose the contents of the structs, and only provides you with a pointer to it (e.g. `sqlite3_stmt`). Only the functions provided by the library can do something with this pointer, in Koffi we call this a handle. This is usually done for ABI-stability reason, and to prevent library users from messing directly with library internals.
-- **Arrays**: in C, you dynamically-sized arrays are usually passed to functions with pointers, either NULL-terminated or with an additional length argument.
+- **Struct pointers**: Use of struct pointers by C libraries fall in two cases: avoid (potentially) expensive copies, and to let the function change struct contents (output or input/output arguments).
+- **Opaque handles**: the library does not expose the contents of the structs, and only provides you with a pointer to it (e.g. `FILE *`). Only the functions provided by the library can do something with this pointer, in Koffi we call this a handle. This is usually done for ABI-stability reason, and to prevent library users from messing directly with library internals.
+- **Arrays**: in C, you dynamically-sized arrays are usually passed to functions with pointers, either NULL-terminated (or any other sentinel value) or with an additional length argument.
 - **Pointers to primitive types**: This is more rare, and generally used for output or input/output arguments. The Win32 API has a lot of these.
 
 ### Struct pointers
@@ -351,7 +353,7 @@ const ComputeTotalLength = lib.func('int64_t ComputeTotalLength(const char **str
 let strings = ['Get', 'Total', 'Length', null];
 let total = ComputeTotalLength(strings);
 
-console.log(total); // Prints 14n (big int)
+console.log(total); // Prints 14
 ```
 
 By default, just like for objects, array arguments are copied from JS to C but not vice-versa. You can however change the direction as documented in the section on [output parameters](functions.md#output-parameters).
@@ -423,7 +425,7 @@ console.log(filenames);
 
 In javascript, it is not possible to pass a primitive value by reference to another function. This means that you cannot call a function and expect it to modify the value of one of its number or string parameter.
 
-However, arrays and objects (among others) are reference type values. Assigning an array or an object from one variable to another does not invole any copy. Instead, as the following example illustrates, the new variable references the same list as the first:
+However, arrays and objects (among others) are reference type values. Assigning an array or an object from one variable to another does not invole any copy. Instead, as the following example illustrates, the new variable references the same array as the first:
 
 ```js
 let list1 = [1, 2];
@@ -436,7 +438,7 @@ console.log(list1); // Prints [1, 42]
 
 All of this means that C functions that are expected to modify their primitive output values (such as an `int *` parameter) cannot be used directly. However, thanks to Koffi's transparent array support, you can use Javascript arrays to approximate reference semantics with single-element arrays.
 
-Below, you can find an example of an addition function where the result is stored in an `int *` output parameter and how to use this function from Koffi.
+Below, you can find an example of an addition function where the result is stored in an `int *` input/output parameter and how to use this function from Koffi.
 
 ```c
 void AddInt(int *dest, int add)
@@ -445,7 +447,7 @@ void AddInt(int *dest, int add)
 }
 ```
 
-You can simply pass a single-element array as the third argument:
+You can simply pass a single-element array as the first argument:
 
 ```js
 const AddInt = lib.func('void AddInt(_Inout_ int *dest, int add)');

package/doc/dist/html/changes.html

@@ -205,11 +205,24 @@
         <article role="main">
           <section id="changelog">
 <h1>Changelog<a class="headerlink" href="#changelog" title="Permalink to this heading">#</a></h1>
+<section id="koffi-1-3-5">
+<h2>Koffi 1.3.5<a class="headerlink" href="#koffi-1-3-5" title="Permalink to this heading">#</a></h2>
+<p><strong>Main changes:</strong></p>
+<ul class="simple">
+<li><p>Fix memory leak when many async calls are running</p></li>
+<li><p>Add configurable limit for maximum number of async calls (max_async_calls)</p></li>
+</ul>
+<p><strong>Other changes:</strong></p>
+<ul class="simple">
+<li><p>Reduce default async memory stack and heap size</p></li>
+<li><p>Various documentation improvements</p></li>
+</ul>
+</section>
 <section id="koffi-1-3-4">
 <h2>Koffi 1.3.4<a class="headerlink" href="#koffi-1-3-4" title="Permalink to this heading">#</a></h2>
 <p><strong>Main fixes:</strong></p>
 <ul class="simple">
-<li><p>Fix possible OpenBSD i386 crash with (void) functions</p></li>
+<li><p>Fix possible OpenBSD i386 crash with <code class="docutils literal notranslate"><span class="pre">(void)</span></code> functions</p></li>
 </ul>
 </section>
 <section id="koffi-1-3-3">
@@ -348,6 +361,7 @@
           <div class="toc-tree">
             <ul>
 <li><a class="reference internal" href="#">Changelog</a><ul>
+<li><a class="reference internal" href="#koffi-1-3-5">Koffi 1.3.5</a></li>
 <li><a class="reference internal" href="#koffi-1-3-4">Koffi 1.3.4</a></li>
 <li><a class="reference internal" href="#koffi-1-3-3">Koffi 1.3.3</a></li>
 <li><a class="reference internal" href="#koffi-1-3-2">Koffi 1.3.2</a></li>

package/doc/dist/html/functions.html

@@ -207,14 +207,14 @@
 <h1>Function calls<a class="headerlink" href="#function-calls" title="Permalink to this heading">#</a></h1>
 <section id="function-definitions">
 <h2>Function definitions<a class="headerlink" href="#function-definitions" title="Permalink to this heading">#</a></h2>
-<p>To declare functions, start by loading the shared library with <code class="docutils literal notranslate"><span class="pre">koffi.load()</span></code>.</p>
+<p>To declare functions, start by loading the shared library with <code class="docutils literal notranslate"><span class="pre">koffi.load(filename)</span></code>.</p>
 <div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span><span class="w"> </span><span class="nx">koffi</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;koffi&#39;</span><span class="p">);</span><span class="w"></span>
 <span class="linenos">2</span><span class="kd">const</span><span class="w"> </span><span class="nx">lib</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">koffi</span><span class="p">.</span><span class="nx">load</span><span class="p">(</span><span class="s1">&#39;/path/to/shared/library&#39;</span><span class="p">);</span><span class="w"> </span><span class="c1">// File extension depends on platforms: .so, .dll, .dylib, etc.</span><span class="w"></span>
 </pre></div>
 </div>
-<p>You can use the returned object to load C functions from the library. Koffi supports two syntaxes:</p>
+<p>You can use the returned object to load C functions from the library. To do so, you can use two syntaxes:</p>
 <ul class="simple">
-<li><p>Classic syntax, inspired by node-ffi</p></li>
+<li><p>The classic syntax, inspired by node-ffi</p></li>
 <li><p>C-like prototypes</p></li>
 </ul>
 <section id="classic-syntax">
@@ -228,17 +228,18 @@
 </section>
 <section id="c-like-prototypes">
 <h3>C-like prototypes<a class="headerlink" href="#c-like-prototypes" title="Permalink to this heading">#</a></h3>
-<p>You can declare functions using simple C-like prototype strings, as shown below:</p>
+<p>If you prefer, you can declare functions using simple C-like prototype strings, as shown below:</p>
 <div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span><span class="w"> </span><span class="nx">printf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;int printf(const char *fmt, ...)&#39;</span><span class="p">);</span><span class="w"></span>
 <span class="linenos">2</span><span class="kd">const</span><span class="w"> </span><span class="nx">atoi</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;int atoi(string)&#39;</span><span class="p">);</span><span class="w"> </span><span class="c1">// The parameter name is not used by Koffi, and optional</span><span class="w"></span>
 </pre></div>
 </div>
+<p>You can use <code class="docutils literal notranslate"><span class="pre">()</span></code> or <code class="docutils literal notranslate"><span class="pre">(void)</span></code> for functions that take no argument.</p>
 </section>
 </section>
 <section id="synchronous-calls">
 <h2>Synchronous calls<a class="headerlink" href="#synchronous-calls" title="Permalink to this heading">#</a></h2>
 <p>By default, calling a C function happens synchronously.</p>
-<p>Most architectures only support one procedure call standard per process. The 32-bit x86 platform is an exception to this, and Koffi support several standards:</p>
+<p>Most architectures only support one procedure call standard per process. The 32-bit x86 platform is an exception to this, and Koffi supports several x86 conventions:</p>
 <div class="table-wrapper colwidths-auto docutils container">
 <table class="docutils align-default">
 <thead>
@@ -273,7 +274,7 @@
 </table>
 </div>
 <p>You can safely use these on non-x86 platforms, they are simply ignored.</p>
-<p>Below you can find a small example showing how to use a non-default calling convention:</p>
+<p>Below you can find a small example showing how to use a non-default calling convention, with the two syntaxes:</p>
 <div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span><span class="w"> </span><span class="nx">koffi</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;koffi&#39;</span><span class="p">);</span><span class="w"></span>
 <span class="linenos">2</span><span class="kd">const</span><span class="w"> </span><span class="nx">lib</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">koffi</span><span class="p">.</span><span class="nx">load</span><span class="p">(</span><span class="s1">&#39;user32.dll&#39;</span><span class="p">);</span><span class="w"></span>
 <span class="linenos">3</span>
@@ -296,7 +297,9 @@
 <span class="linenos"> 8</span><span class="p">})</span><span class="w"></span>
 <span class="linenos"> 9</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;Hello World!&#39;</span><span class="p">);</span><span class="w"></span>
 <span class="linenos">10</span>
-<span class="linenos">11</span><span class="c1">// This program will print &quot;Hello World!&quot;, and then &quot;Result: 1257&quot;</span><span class="w"></span>
+<span class="linenos">11</span><span class="c1">// This program will print:</span><span class="w"></span>
+<span class="linenos">12</span><span class="c1">//   Hello World!</span><span class="w"></span>
+<span class="linenos">13</span><span class="c1">//   Result: 1257</span><span class="w"></span>
 </pre></div>
 </div>
 <p>These calls are executed by worker threads. It is <strong>your responsibility to deal with data sharing issues</strong> in the native code that may be caused by multi-threading.</p>
@@ -318,7 +321,7 @@
 <section id="output-parameters">
 <h2>Output parameters<a class="headerlink" href="#output-parameters" title="Permalink to this heading">#</a></h2>
 <p>By default, Koffi will only forward arguments from Javascript to C. However, many C functions use pointer arguments for output values, or input/output values.</p>
-<p>For simplicy, and because Javascript only has value semantics for primitive types, Koffi can marshal out (or in/out) two types of parameters:</p>
+<p>For simplicity, and because Javascript only has value semantics for primitive types, Koffi can marshal out (or in/out) two types of parameters:</p>
 <ul class="simple">
 <li><p><a class="reference internal" href="types#struct-types"><span class="std std-doc">Structs</span></a> (to/from JS objects)</p></li>
 <li><p><a class="reference internal" href="types#opaque-handles"><span class="std std-doc">Opaque handles</span></a></p></li>
@@ -382,8 +385,6 @@
 </section>
 <section id="javascript-callbacks">
 <h2>Javascript callbacks<a class="headerlink" href="#javascript-callbacks" title="Permalink to this heading">#</a></h2>
-<section id="using-callbacks">
-<h3>Using callbacks<a class="headerlink" href="#using-callbacks" title="Permalink to this heading">#</a></h3>
 <p>In order to pass a JS function to a C function expecting a callback, you must first create a callback type with the expected return type and parameters. The syntax is similar to the one used to load functions from a shared library.</p>
 <div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span><span class="w"> </span><span class="nx">koffi</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;koffi&#39;</span><span class="p">);</span><span class="w"></span>
 <span class="linenos">2</span>
@@ -394,7 +395,7 @@
 <span class="linenos">7</span><span class="kd">const</span><span class="w"> </span><span class="nx">AddDoubleFloat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">koffi</span><span class="p">.</span><span class="nx">callback</span><span class="p">(</span><span class="s1">&#39;double AddDoubleFloat(double d, float f)&#39;</span><span class="p">);</span><span class="w"></span>
 </pre></div>
 </div>
-<p>Once your callback type is declared, you can use them in struct definitions, or as function parameter and/or return type.</p>
+<p>Once your callback type is declared, you can use it in struct definitions, or as function parameter and/or return type.</p>
 <p>Here is a small example with the C part and the JS part.</p>
 <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string.h&gt;</span><span class="cp"></span>
 <span class="linenos">2</span>
@@ -428,10 +429,9 @@
 <p>On x86 platforms, only Cdecl and Stdcall callbacks are supported.</p>
 </section>
 <section id="thread-safety">
-<h3>Thread safety<a class="headerlink" href="#thread-safety" title="Permalink to this heading">#</a></h3>
-<p>The callback must be called from the main thread, or more precisely from the same thread as the V8 intepreter.</p>
-<p>Calling the callback from another thread is undefined behavior, and will likely lead to a mess.</p>
-</section>
+<h2>Thread safety<a class="headerlink" href="#thread-safety" title="Permalink to this heading">#</a></h2>
+<p>Asynchronous functions run on worker threads. You need to deal with thread safety issues if you share data between threads.</p>
+<p>Callbacks must be called from the main thread, or more precisely from the same thread as the V8 intepreter. Calling a callback from another thread is undefined behavior, and will likely lead to a crash or a big mess. You’ve been warned!</p>
 </section>
 </section>
 
@@ -506,13 +506,10 @@
 <li><a class="reference internal" href="#opaque-handle-example">Opaque handle example</a></li>
 </ul>
 </li>
-<li><a class="reference internal" href="#javascript-callbacks">Javascript callbacks</a><ul>
-<li><a class="reference internal" href="#using-callbacks">Using callbacks</a></li>
+<li><a class="reference internal" href="#javascript-callbacks">Javascript callbacks</a></li>
 <li><a class="reference internal" href="#thread-safety">Thread safety</a></li>
 </ul>
 </li>
-</ul>
-</li>
 </ul>
 
           </div>

package/doc/dist/html/index.html

@@ -204,7 +204,7 @@
         </div>
         <article role="main">
           <section id="koffi-version">
-<h1>Koffi 1.3.4<a class="headerlink" href="#koffi-version" title="Permalink to this heading">#</a></h1>
+<h1>Koffi 1.3.5<a class="headerlink" href="#koffi-version" title="Permalink to this heading">#</a></h1>
 <section id="overview">
 <h2>Overview<a class="headerlink" href="#overview" title="Permalink to this heading">#</a></h2>
 <p>Koffi is a <strong>fast and easy-to-use C FFI module for Node.js</strong>, featuring:</p>
@@ -240,6 +240,7 @@
 <li class="toctree-l2"><a class="reference internal" href="functions#variadic-functions">Variadic functions</a></li>
 <li class="toctree-l2"><a class="reference internal" href="functions#output-parameters">Output parameters</a></li>
 <li class="toctree-l2"><a class="reference internal" href="functions#javascript-callbacks">Javascript callbacks</a></li>
+<li class="toctree-l2"><a class="reference internal" href="functions#thread-safety">Thread safety</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="memory">Memory usage</a><ul>
@@ -263,6 +264,7 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="changes">Changelog</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="changes#koffi-1-3-5">Koffi 1.3.5</a></li>
 <li class="toctree-l2"><a class="reference internal" href="changes#koffi-1-3-4">Koffi 1.3.4</a></li>
 <li class="toctree-l2"><a class="reference internal" href="changes#koffi-1-3-3">Koffi 1.3.3</a></li>
 <li class="toctree-l2"><a class="reference internal" href="changes#koffi-1-3-2">Koffi 1.3.2</a></li>
@@ -330,7 +332,7 @@
         <div class="toc-tree-container">
           <div class="toc-tree">
             <ul>
-<li><a class="reference internal" href="#">Koffi 1.3.4</a><ul>
+<li><a class="reference internal" href="#">Koffi 1.3.5</a><ul>
 <li><a class="reference internal" href="#overview">Overview</a></li>
 <li><a class="reference internal" href="#table-of-contents">Table of contents</a></li>
 <li><a class="reference internal" href="#license">License</a></li>

package/doc/dist/html/memory.html

@@ -209,7 +209,7 @@
 <h2>How it works<a class="headerlink" href="#how-it-works" title="Permalink to this heading">#</a></h2>
 <p>For synchronous/normal calls, Koffi uses two preallocated memory blocks:</p>
 <ul class="simple">
-<li><p>One to construct to assign the C stack, subsequently used by the platform-specific assembly code (1 MiB by default)</p></li>
+<li><p>One to construct the C stack and assign registers, subsequently used by the platform-specific assembly code (1 MiB by default)</p></li>
 <li><p>One to allocate strings and big objects/structs (2 MiB by default)</p></li>
 </ul>
 <p>Unless very big strings or objects (at least more than one page of memory) are used, no extra allocation ever happens during calls or callbacks.</p>
@@ -219,6 +219,7 @@
 </pre></div>
 </div>
 <p>The same is true for asynchronous calls. When an asynchronous call is made, Koffi will allocate new blocks unless there is an unused (resident) set of blocks still available. Once the asynchronous call is finished, these blocks are freed if there are more than <code class="docutils literal notranslate"><span class="pre">resident_async_pools</span></code> sets of blocks left around.</p>
+<p>There cannot be more than <code class="docutils literal notranslate"><span class="pre">max_async_calls</span></code> running at the same time.</p>
 </section>
 <section id="default-settings">
 <h2>Default settings<a class="headerlink" href="#default-settings" title="Permalink to this heading">#</a></h2>
@@ -240,17 +241,21 @@
 <td><p>Heap size for synchronous calls</p></td>
 </tr>
 <tr class="row-even"><td><p>async_stack_size</p></td>
-<td><p>512 kiB</p></td>
+<td><p>256 kiB</p></td>
 <td><p>Stack size for asynchronous calls</p></td>
 </tr>
 <tr class="row-odd"><td><p>async_heap_size</p></td>
-<td><p>1 MiB</p></td>
+<td><p>512 kiB</p></td>
 <td><p>Heap size for asynchronous calls</p></td>
 </tr>
 <tr class="row-even"><td><p>resident_async_pools</p></td>
 <td><p>2</p></td>
 <td><p>Number of resident pools for asynchronous calls</p></td>
 </tr>
+<tr class="row-odd"><td><p>max_async_calls</p></td>
+<td><p>64</p></td>
+<td><p>Maximum number of ongoing asynchronous calls</p></td>
+</tr>
 </tbody>
 </table>
 </div>

package/doc/dist/html/platforms.html

@@ -3,7 +3,7 @@
   <head><meta charset="utf-8"/>
     <meta name="viewport" content="width=device-width,initial-scale=1"/>
     <meta name="color-scheme" content="light dark"><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
-<link rel="index" title="Index" href="genindex" /><link rel="search" title="Search" href="search" /><link rel="next" title="Quick start" href="start" /><link rel="prev" title="Koffi 1.3.4" href="index" />
+<link rel="index" title="Index" href="genindex" /><link rel="search" title="Search" href="search" /><link rel="next" title="Quick start" href="start" /><link rel="prev" title="Koffi 1.3.5" href="index" />
 
     <meta name="generator" content="sphinx-5.0.1, furo 2022.06.04.1"/>
         <title>Supported platforms - Koffi</title>