koffi 2.2.2-beta.5 → 2.2.2

package/ChangeLog.md

@@ -2,6 +2,20 @@
 
 ## History
 
+### Koffi 2.2.2
+
+**Main fixes:**
+
+- Support transparent [asynchronous callbacks](callbacks.md#asynchronous-callbacks)
+- Expand from a maximum of 16+16 to 1024 callbacks running in parallel
+
+**Other fixes:**
+
+- Fix bundler support by removing shebang from index.js
+- Fix bugs when loading Koffi multiples times in same process (context aware module)
+- Check N-API version when module is loaded
+- Optimize callback unregistration
+
 ### Koffi 2.2.1
 
 **Main fixes:**

package/doc/callbacks.md

@@ -77,7 +77,7 @@ console.log(ret);
 
 Use registered callbacks when the function needs to be called at a later time (e.g. log handler, event handler, `fopencookie/funopen`). Call `koffi.register(func, type)` to register a callback function, with two arguments: the JS function, and the callback type.
 
-When you are done, call `koffi.unregister()` (with the value returned by `koffi.register()`) to release the slot. A maximum of 16 registered callbacks can exist at the same time. Failure to do so will leak the slot, and subsequent registrations may fail (with an exception) once all slots are used.
+When you are done, call `koffi.unregister()` (with the value returned by `koffi.register()`) to release the slot. A maximum of 1024 callbacks can exist at the same time. Failure to do so will leak the slot, and subsequent registrations may fail (with an exception) once all slots are used.
 
 The example below shows how to register and unregister delayed callbacks.
 
@@ -172,9 +172,16 @@ console.log(array); // Prints ['123', 'bar', 'foo', 'foobar']
 
 *New in Koffi 2.2.2*
 
-In Koffi, [asynchronous native calls](functions.md#asynchronous-calls) happen on a secondary thread. However, JS execution is inherently single-threaded, callbacks must run on the main thread.
+JS execution is inherently single-threaded, so JS callbacks must run on the main thread. There are two ways you may want to call a callback function from another thread:
 
-Koffi deals with this by running the JS callback function in the Node.js event loop. This means the callback cannot run while the engine is busy running synchronous code.
+- Call the callback from an asynchronous FFI call (e.g. `waitpid.async`)
+- Inside a synchronous FFI call, pass the callback to another thread
+
+In both cases, Koffi will queue the call back to JS to run on the main thread, as soon as the JS event loop has a chance to run (for example when you await a promise).
+
+```{warning}
+Be careful, you can easily get into a deadlock situation if you call a callback from a secondary thread and your main thread never lets the JS event loop run (for example, if the main thread waits for the secondary thread to finish something itself).
+```
 
 ## Handling of exceptions
 

package/doc/contribute.md

@@ -59,7 +59,7 @@ These machines are not included directly in this repository (for license and siz
 For example, if you want to run the tests on Debian ARM64, run the following commands:
 
 ```sh
-cd rygel/src/koffi/qemu/
+cd rygel/src/koffi/tools/
 wget -q -O- https://koromix.dev/files/machines/qemu_debian_arm64.tar.zst | zstd -d | tar xv
 sha256sum -c --ignore-missing registry/sha256sum.txt
 ```

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.2.2-beta.5",
-    "stable": "2.2.1",
+    "version": "2.2.2",
+    "stable": "2.2.2",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/koffi/src/abi_arm32.cc

@@ -48,78 +48,11 @@ extern "C" uint64_t ForwardCallXGG(const void *func, uint8_t *sp, uint8_t **out_
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp, uint8_t **out_old_sp);
 extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp, uint8_t **out_old_sp);
 
-extern "C" int Trampoline0; extern "C" int TrampolineX0;
-extern "C" int Trampoline1; extern "C" int TrampolineX1;
-extern "C" int Trampoline2; extern "C" int TrampolineX2;
-extern "C" int Trampoline3; extern "C" int TrampolineX3;
-extern "C" int Trampoline4; extern "C" int TrampolineX4;
-extern "C" int Trampoline5; extern "C" int TrampolineX5;
-extern "C" int Trampoline6; extern "C" int TrampolineX6;
-extern "C" int Trampoline7; extern "C" int TrampolineX7;
-extern "C" int Trampoline8; extern "C" int TrampolineX8;
-extern "C" int Trampoline9; extern "C" int TrampolineX9;
-extern "C" int Trampoline10; extern "C" int TrampolineX10;
-extern "C" int Trampoline11; extern "C" int TrampolineX11;
-extern "C" int Trampoline12; extern "C" int TrampolineX12;
-extern "C" int Trampoline13; extern "C" int TrampolineX13;
-extern "C" int Trampoline14; extern "C" int TrampolineX14;
-extern "C" int Trampoline15; extern "C" int TrampolineX15;
-extern "C" int Trampoline16; extern "C" int TrampolineX16;
-extern "C" int Trampoline17; extern "C" int TrampolineX17;
-extern "C" int Trampoline18; extern "C" int TrampolineX18;
-extern "C" int Trampoline19; extern "C" int TrampolineX19;
-extern "C" int Trampoline20; extern "C" int TrampolineX20;
-extern "C" int Trampoline21; extern "C" int TrampolineX21;
-extern "C" int Trampoline22; extern "C" int TrampolineX22;
-extern "C" int Trampoline23; extern "C" int TrampolineX23;
-extern "C" int Trampoline24; extern "C" int TrampolineX24;
-extern "C" int Trampoline25; extern "C" int TrampolineX25;
-extern "C" int Trampoline26; extern "C" int TrampolineX26;
-extern "C" int Trampoline27; extern "C" int TrampolineX27;
-extern "C" int Trampoline28; extern "C" int TrampolineX28;
-extern "C" int Trampoline29; extern "C" int TrampolineX29;
-extern "C" int Trampoline30; extern "C" int TrampolineX30;
-extern "C" int Trampoline31; extern "C" int TrampolineX31;
-
 extern "C" napi_value CallSwitchStack(Napi::Function *func, size_t argc, napi_value *argv,
                                       uint8_t *old_sp, Span<uint8_t> *new_stack,
                                       napi_value (*call)(Napi::Function *func, size_t argc, napi_value *argv));
 
-static void *const Trampolines[][2] = {
-    { &Trampoline0, &TrampolineX0 },
-    { &Trampoline1, &TrampolineX1 },
-    { &Trampoline2, &TrampolineX2 },
-    { &Trampoline3, &TrampolineX3 },
-    { &Trampoline4, &TrampolineX4 },
-    { &Trampoline5, &TrampolineX5 },
-    { &Trampoline6, &TrampolineX6 },
-    { &Trampoline7, &TrampolineX7 },
-    { &Trampoline8, &TrampolineX8 },
-    { &Trampoline9, &TrampolineX9 },
-    { &Trampoline10, &TrampolineX10 },
-    { &Trampoline11, &TrampolineX11 },
-    { &Trampoline12, &TrampolineX12 },
-    { &Trampoline13, &TrampolineX13 },
-    { &Trampoline14, &TrampolineX14 },
-    { &Trampoline15, &TrampolineX15 },
-    { &Trampoline16, &TrampolineX16 },
-    { &Trampoline17, &TrampolineX17 },
-    { &Trampoline18, &TrampolineX18 },
-    { &Trampoline19, &TrampolineX19 },
-    { &Trampoline20, &TrampolineX20 },
-    { &Trampoline21, &TrampolineX21 },
-    { &Trampoline22, &TrampolineX22 },
-    { &Trampoline23, &TrampolineX23 },
-    { &Trampoline24, &TrampolineX24 },
-    { &Trampoline25, &TrampolineX25 },
-    { &Trampoline26, &TrampolineX26 },
-    { &Trampoline27, &TrampolineX27 },
-    { &Trampoline28, &TrampolineX28 },
-    { &Trampoline29, &TrampolineX29 },
-    { &Trampoline30, &TrampolineX30 },
-    { &Trampoline31, &TrampolineX31 }
-};
-RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
+#include "abi_trampolines.inc"
 
 static inline int IsHFA(const TypeInfo *type)
 {
@@ -1031,7 +964,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
                 if (RG_UNLIKELY(!ptr))
                     return;
             } else if (CheckValueTag(instance, value, type->ref.marker)) {
-                ptr = value.As<Napi::External<uint8_t>>().Data();
+                ptr = value.As<Napi::External<void>>().Data();
             } else if (IsNullOrUndefined(value)) {
                 ptr = nullptr;
             } else {
@@ -1053,7 +986,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
     err_guard.Disable();
 }
 
-void *GetTrampoline(Size idx, const FunctionInfo *proto)
+void *GetTrampoline(int16_t idx, const FunctionInfo *proto)
 {
     bool vec = proto->forward_fp || IsFloat(proto->ret.type);
     return Trampolines[idx][vec];