koffi 2.2.2-beta.2 → 2.2.2-beta.3

package/doc/callbacks.md

@@ -168,6 +168,14 @@ qsort(koffi.as(array, 'char **'), array.length, koffi.sizeof('void *'), (ptr1, p
 console.log(array); // Prints ['123', 'bar', 'foo', 'foobar']
 ```
 
+## Asynchronous callbacks
+
+*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.
+
+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.
+
 ## Handling of exceptions
 
 If an exception happens inside the JS callback, the C API will receive 0 or NULL (depending on the return value type).

package/package.json

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

package/src/koffi/src/abi_arm32.cc

@@ -252,7 +252,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
     return true;
 }
 
-bool CallData::Prepare(const Napi::CallbackInfo &info)
+bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     uint32_t *args_ptr = nullptr;
     uint32_t *gpr_ptr = nullptr;
@@ -491,7 +491,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute()
+void CallData::Execute(const FunctionInfo *func)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -540,7 +540,7 @@ void CallData::Execute()
 #undef PERFORM_CALL
 }
 
-Napi::Value CallData::Complete()
+Napi::Value CallData::Complete(const FunctionInfo *func)
 {
     RG_DEFER {
        PopOutArguments();
@@ -597,12 +597,12 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    const TrampolineInfo &trampoline = instance->trampolines[idx];
+    const TrampolineInfo &trampoline = shared.trampolines[idx];
 
     const FunctionInfo *proto = trampoline.proto;
     Napi::Function func = trampoline.func.Value();

package/src/koffi/src/abi_arm64.cc

@@ -267,7 +267,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
     return true;
 }
 
-bool CallData::Prepare(const Napi::CallbackInfo &info)
+bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     uint64_t *args_ptr = nullptr;
     uint64_t *gpr_ptr = nullptr;
@@ -559,7 +559,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute()
+void CallData::Execute(const FunctionInfo *func)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -611,7 +611,7 @@ void CallData::Execute()
 #undef PERFORM_CALL
 }
 
-Napi::Value CallData::Complete()
+Napi::Value CallData::Complete(const FunctionInfo *func)
 {
     RG_DEFER {
        PopOutArguments();
@@ -673,12 +673,12 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    const TrampolineInfo &trampoline = instance->trampolines[idx];
+    const TrampolineInfo &trampoline = shared.trampolines[idx];
 
     const FunctionInfo *proto = trampoline.proto;
     Napi::Function func = trampoline.func.Value();

package/src/koffi/src/abi_riscv64.cc

@@ -196,7 +196,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
     return true;
 }
 
-bool CallData::Prepare(const Napi::CallbackInfo &info)
+bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     uint64_t *args_ptr = nullptr;
     uint64_t *gpr_ptr = nullptr;
@@ -406,7 +406,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute()
+void CallData::Execute(const FunctionInfo *func)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -462,7 +462,7 @@ void CallData::Execute()
 #undef PERFORM_CALL
 }
 
-Napi::Value CallData::Complete()
+Napi::Value CallData::Complete(const FunctionInfo *func)
 {
     RG_DEFER {
        PopOutArguments();
@@ -524,12 +524,12 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    const TrampolineInfo &trampoline = instance->trampolines[idx];
+    const TrampolineInfo &trampoline = shared.trampolines[idx];
 
     const FunctionInfo *proto = trampoline.proto;
     Napi::Function func = trampoline.func.Value();

package/src/koffi/src/abi_x64_sysv.cc

@@ -284,7 +284,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
     return true;
 }
 
-bool CallData::Prepare(const Napi::CallbackInfo &info)
+bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     uint64_t *args_ptr = nullptr;
     uint64_t *gpr_ptr = nullptr;
@@ -470,7 +470,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute()
+void CallData::Execute(const FunctionInfo *func)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -526,7 +526,7 @@ void CallData::Execute()
 #undef PERFORM_CALL
 }
 
-Napi::Value CallData::Complete()
+Napi::Value CallData::Complete(const FunctionInfo *func)
 {
     RG_DEFER {
        PopOutArguments();
@@ -583,12 +583,12 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    const TrampolineInfo &trampoline = instance->trampolines[idx];
+    const TrampolineInfo &trampoline = shared.trampolines[idx];
 
     const FunctionInfo *proto = trampoline.proto;
     Napi::Function func = trampoline.func.Value();

package/src/koffi/src/abi_x64_win.cc

@@ -121,7 +121,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
     return true;
 }
 
-bool CallData::Prepare(const Napi::CallbackInfo &info)
+bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     uint64_t *args_ptr = nullptr;
 
@@ -281,7 +281,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute()
+void CallData::Execute(const FunctionInfo *func)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -322,7 +322,7 @@ void CallData::Execute()
 #undef PERFORM_CALL
 }
 
-Napi::Value CallData::Complete()
+Napi::Value CallData::Complete(const FunctionInfo *func)
 {
     RG_DEFER {
        PopOutArguments();
@@ -379,12 +379,12 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    const TrampolineInfo &trampoline = instance->trampolines[idx];
+    const TrampolineInfo &trampoline = shared.trampolines[idx];
 
     const FunctionInfo *proto = trampoline.proto;
     Napi::Function func = trampoline.func.Value();

package/src/koffi/src/abi_x86.cc

@@ -172,7 +172,7 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
     return true;
 }
 
-bool CallData::Prepare(const Napi::CallbackInfo &info)
+bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 {
     uint32_t *args_ptr = nullptr;
     uint32_t *fast_ptr = nullptr;
@@ -362,7 +362,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute()
+void CallData::Execute(const FunctionInfo *func)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
@@ -404,7 +404,7 @@ void CallData::Execute()
 #undef PERFORM_CALL
 }
 
-Napi::Value CallData::Complete()
+Napi::Value CallData::Complete(const FunctionInfo *func)
 {
     RG_DEFER {
        PopOutArguments();
@@ -461,12 +461,12 @@ Napi::Value CallData::Complete()
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
 {
     if (RG_UNLIKELY(env.IsExceptionPending()))
         return;
 
-    const TrampolineInfo &trampoline = instance->trampolines[idx];
+    const TrampolineInfo &trampoline = shared.trampolines[idx];
 
     const FunctionInfo *proto = trampoline.proto;
     Napi::Function func = trampoline.func.Value();

package/src/koffi/src/call.cc

@@ -33,10 +33,9 @@ struct RelayContext {
     bool done = false;
 };
 
-CallData::CallData(Napi::Env env, InstanceData *instance,
-                   const FunctionInfo *func, InstanceMemory *mem, bool async)
-    : env(env), instance(instance), func(func),
-      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap), async(async)
+CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
+    : env(env), instance(instance),
+      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
     mem->generation += !mem->depth;
     mem->depth++;
@@ -54,7 +53,21 @@ CallData::~CallData()
     mem->stack = old_stack_mem;
     mem->heap = old_heap_mem;
 
-    instance->temp_trampolines -= used_trampolines;
+    if (used_trampolines) {
+        std::lock_guard<std::mutex> lock(shared.mutex);
+
+        for (Size i = 0; i < MaxTrampolines; i++) {
+            if (used_trampolines & (1u << i)) {
+                TrampolineInfo *trampoline = &shared.trampolines[i];
+
+                trampoline->func.Reset();
+                trampoline->recv.Reset();
+            }
+        }
+
+        shared.temp_trampolines ^= used_trampolines;
+    }
+
     instance->temporaries -= mem->temporary;
 
     if (!--mem->depth && mem->temporary) {
@@ -66,7 +79,7 @@ CallData::~CallData()
 
 void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
-    if (async) {
+    if (std::this_thread::get_id() != instance->main_thread_id) {
         RelayContext ctx;
 
         ctx.call = this;
@@ -83,7 +96,7 @@ void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegi
             ctx.cv.wait(lock);
         }
     } else {
-        Relay(idx, own_sp, caller_sp, out_reg);
+        Relay(idx, own_sp, caller_sp, false, out_reg);
     }
 }
 
@@ -91,7 +104,7 @@ void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
 {
     RelayContext *ctx = (RelayContext *)udata;
 
-    ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, ctx->out_reg);
+    ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, true, ctx->out_reg);
 
     // We're done!
     std::lock_guard<std::mutex> lock(ctx->mutex);
@@ -1012,18 +1025,22 @@ void CallData::PopOutArguments()
 
 void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
 {
-    if (RG_UNLIKELY(instance->temp_trampolines >= MaxTrampolines)) {
-        ThrowError<Napi::Error>(env, "Too many temporary callbacks are in use (max = %1)", MaxTrampolines);
-        return nullptr;
-    }
+    int idx;
+    {
+        std::lock_guard<std::mutex> lock(shared.mutex);
 
-    int idx = instance->next_trampoline;
+        idx = CountTrailingZeros(~shared.temp_trampolines);
 
-    instance->next_trampoline = (int16_t)((instance->next_trampoline + 1) % MaxTrampolines);
-    instance->temp_trampolines++;
-    used_trampolines++;
+        if (RG_UNLIKELY(idx >= MaxTrampolines)) {
+            ThrowError<Napi::Error>(env, "Too many temporary callbacks are in use (max = %1)", MaxTrampolines);
+            return env.Null();
+        }
+
+        shared.temp_trampolines |= 1u << idx;
+        used_trampolines |= 1u << idx;
+    }
 
-    TrampolineInfo *trampoline = &instance->trampolines[idx];
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
 
     trampoline->proto = proto;
     trampoline->func.Reset(func, 1);
@@ -1034,7 +1051,7 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
     return ptr;
 }
 
-void CallData::DumpForward() const
+void CallData::DumpForward(const FunctionInfo *func) const
 {
     PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
 

package/src/koffi/src/call.hh

@@ -36,15 +36,12 @@ class alignas(8) CallData {
 
     Napi::Env env;
     InstanceData *instance;
-    const FunctionInfo *func;
 
     InstanceMemory *mem;
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
-    bool async;
-
-    int16_t used_trampolines = 0;
+    uint32_t used_trampolines = 0;
 
     LocalArray<OutArgument, MaxOutParameters> out_arguments;
 
@@ -70,8 +67,7 @@ class alignas(8) CallData {
     BlockAllocator call_alloc;
 
 public:
-    CallData(Napi::Env env, InstanceData *instance,
-             const FunctionInfo *func, InstanceMemory *mem, bool async);
+    CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem);
     ~CallData();
 
 #ifdef UNITY_BUILD
@@ -84,17 +80,17 @@ public:
     #define INLINE_IF_UNITY
 #endif
 
-    INLINE_IF_UNITY bool Prepare(const Napi::CallbackInfo &info);
-    INLINE_IF_UNITY void Execute();
-    INLINE_IF_UNITY Napi::Value Complete();
+    INLINE_IF_UNITY bool Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info);
+    INLINE_IF_UNITY void Execute(const FunctionInfo *func);
+    INLINE_IF_UNITY Napi::Value Complete(const FunctionInfo *func);
 
 #undef INLINE_IF_UNITY
 
-    void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
+    void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg);
     void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
     static void RelayAsync(napi_env, napi_value, void *, void *udata);
 
-    void DumpForward() const;
+    void DumpForward(const FunctionInfo *func) const;
 
 private:
     template <typename T>

package/src/koffi/src/ffi.cc

@@ -40,6 +40,8 @@
 
 namespace RG {
 
+SharedData shared;
+
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
 const int CastMarker = 0xDEADBEEF;
@@ -1059,16 +1061,16 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     }
 
     InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, func, mem, false);
+    CallData call(env, instance, mem);
 
     RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
     exec_call = &call;
 
-    if (!RG_UNLIKELY(call.Prepare(info)))
+    if (!RG_UNLIKELY(call.Prepare(func, info)))
         return env.Null();
 
     if (instance->debug) {
-        call.DumpForward();
+        call.DumpForward(func);
     }
 
     // Execute call
@@ -1076,10 +1078,10 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
         RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
-        call.Execute();
+        call.Execute(func);
     }
 
-    return call.Complete();
+    return call.Complete(func);
 }
 
 static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -1136,13 +1138,13 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         return env.Null();
 
     InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, &func, mem, false);
+    CallData call(env, instance, mem);
 
-    if (!RG_UNLIKELY(call.Prepare(info)))
+    if (!RG_UNLIKELY(call.Prepare(&func, info)))
         return env.Null();
 
     if (instance->debug) {
-        call.DumpForward();
+        call.DumpForward(&func);
     }
 
     // Execute call
@@ -1150,10 +1152,10 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
-        call.Execute();
+        call.Execute(&func);
     }
 
-    return call.Complete();
+    return call.Complete(&func);
 }
 
 class AsyncCall: public Napi::AsyncWorker {
@@ -1167,11 +1169,11 @@ public:
     AsyncCall(Napi::Env env, InstanceData *instance, const FunctionInfo *func,
               InstanceMemory *mem, Napi::Function &callback)
         : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
-          call(env, instance, func, mem, true) {}
+          call(env, instance, mem) {}
     ~AsyncCall() { func->Unref(); }
 
     bool Prepare(const Napi::CallbackInfo &info) {
-        prepared = call.Prepare(info);
+        prepared = call.Prepare(func, info);
 
         if (!prepared) {
             Napi::Error err = env.GetAndClearPendingException();
@@ -1180,7 +1182,7 @@ public:
 
         return prepared;
     }
-    void DumpForward() { call.DumpForward(); }
+    void DumpForward() { call.DumpForward(func); }
 
     void Execute() override;
     void OnOK() override;
@@ -1192,7 +1194,7 @@ void AsyncCall::Execute()
         RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
-        call.Execute();
+        call.Execute(func);
     }
 }
 
@@ -1205,7 +1207,7 @@ void AsyncCall::OnOK()
     Napi::Value self = env.Null();
     napi_value args[] = {
         env.Null(),
-        call.Complete()
+        call.Complete(func)
     };
 
     callback.Call(self, RG_LEN(args), args);
@@ -1434,18 +1436,22 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
+    int idx;
+    {
+        std::lock_guard<std::mutex> lock(shared.mutex);
 
-    int idx = CountTrailingZeros(~instance->registered_trampolines);
+        idx = CountTrailingZeros(~shared.registered_trampolines);
 
-    if (RG_UNLIKELY(idx >= MaxTrampolines)) {
-        ThrowError<Napi::Error>(env, "Too many registered callbacks are in use (max = %1)", MaxTrampolines);
-        return env.Null();
-    }
+        if (RG_UNLIKELY(idx >= MaxTrampolines)) {
+            ThrowError<Napi::Error>(env, "Too many registered callbacks are in use (max = %1)", MaxTrampolines);
+            return env.Null();
+        }
 
-    instance->registered_trampolines |= 1u << idx;
-    idx += MaxTrampolines;
+        shared.registered_trampolines |= 1u << idx;
+        idx += MaxTrampolines;
+    }
 
-    TrampolineInfo *trampoline = &instance->trampolines[idx];
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
 
     trampoline->proto = type->ref.proto;
     trampoline->func.Reset(func, 1);
@@ -1481,19 +1487,26 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
     Napi::External<void> external = info[0].As<Napi::External<void>>();
     void *ptr = external.Data();
 
-    for (Size i = 0; i < MaxTrampolines; i++) {
-        Size idx = i + MaxTrampolines;
+    // Release shared trampoline safely
+    {
+        std::lock_guard<std::mutex> lock(shared.mutex);
+
+        for (Size i = 0; i < MaxTrampolines; i++) {
+            Size idx = i + MaxTrampolines;
+
+            if (!(shared.registered_trampolines & (1u << i)))
+                continue;
 
-        if (!(instance->registered_trampolines & (1u << i)))
-            continue;
+            TrampolineInfo *trampoline = &shared.trampolines[idx];
 
-        TrampolineInfo *trampoline = &instance->trampolines[idx];
+            if (GetTrampoline(idx, trampoline->proto) == ptr) {
+                shared.registered_trampolines &= ~(1u << i);
 
-        if (GetTrampoline(idx, trampoline->proto) == ptr) {
-            instance->registered_trampolines &= ~(1u << i);
-            trampoline->recv.Reset();
+                trampoline->func.Reset();
+                trampoline->recv.Reset();
 
-            return env.Undefined();
+                return env.Undefined();
+            }
         }
     }
 
@@ -1696,6 +1709,25 @@ InstanceData::~InstanceData()
         delete mem;
     }
 
+    // Clean-up leftover registered trampolines
+    {
+        std::lock_guard<std::mutex> lock(shared.mutex);
+
+        for (Size i = 0; i < MaxTrampolines; i++) {
+            Size idx = i + MaxTrampolines;
+
+            if (!(shared.registered_trampolines & (1u << i)))
+                continue;
+
+            TrampolineInfo *trampoline = &shared.trampolines[idx];
+
+            if (trampoline->func.Env().GetInstanceData<InstanceData>() == this) {
+                trampoline->func.Reset();
+                trampoline->recv.Reset();
+            }
+        }
+    }
+
     if (broker) {
         napi_release_threadsafe_function(broker, napi_tsfn_abort);
     }
@@ -1856,7 +1888,21 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
 
 extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
-    exec_call->RelaySafe(idx, own_sp, caller_sp, out_reg);
+    if (RG_LIKELY(exec_call)) {
+        exec_call->RelaySafe(idx, own_sp, caller_sp, out_reg);
+    } else {
+        Napi::Env env = shared.trampolines[idx].func.Env();
+        InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+        InstanceMemory *mem = AllocateMemory(instance, instance->async_stack_size, instance->async_heap_size);
+        if (RG_UNLIKELY(!mem)) {
+            ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
+            return;
+        }
+
+        CallData call(env, instance, mem);
+        call.RelaySafe(idx, own_sp, caller_sp, out_reg);
+    }
 }
 
 static InstanceData *CreateInstance(Napi::Env env)
@@ -1864,9 +1910,10 @@ static InstanceData *CreateInstance(Napi::Env env)
     InstanceData *instance = new InstanceData();
     RG_DEFER_N(err_guard) { delete instance; };
 
-    Napi::String resource_name = Napi::String::New(env, "Koffi Async Callback Broker");
+    instance->main_thread_id = std::this_thread::get_id();
 
-    if (napi_create_threadsafe_function(env, nullptr, nullptr, resource_name,
+    if (napi_create_threadsafe_function(env, nullptr, nullptr,
+                                        Napi::String::New(env, "Koffi Async Callback Broker"),
                                         0, 1, nullptr, nullptr, nullptr,
                                         CallData::RelayAsync, &instance->broker) != napi_ok) {
         LogError("Failed to create async callback broker");

package/src/koffi/src/ffi.hh

@@ -233,14 +233,6 @@ struct InstanceMemory {
     bool temporary;
 };
 
-struct TrampolineInfo {
-    const FunctionInfo *proto;
-    Napi::FunctionReference func;
-    Napi::Reference<Napi::Value> recv;
-
-    int32_t generation;
-};
-
 struct InstanceData {
     ~InstanceData();
 
@@ -258,11 +250,7 @@ struct InstanceData {
     LocalArray<InstanceMemory *, 9> memories;
     int temporaries = 0;
 
-    TrampolineInfo trampolines[MaxTrampolines * 2];
-    int16_t next_trampoline = 0;
-    int16_t temp_trampolines = 0;
-    uint32_t registered_trampolines = 0;
-
+    std::thread::id main_thread_id;
     napi_threadsafe_function broker = nullptr;
 
     BlockAllocator str_alloc;
@@ -280,4 +268,22 @@ RG_STATIC_ASSERT(DefaultMaxAsyncCalls >= DefaultResidentAsyncPools);
 RG_STATIC_ASSERT(MaxAsyncCalls >= DefaultMaxAsyncCalls);
 RG_STATIC_ASSERT(MaxTrampolines <= 16);
 
+struct TrampolineInfo {
+    const FunctionInfo *proto;
+    Napi::FunctionReference func;
+    Napi::Reference<Napi::Value> recv;
+
+    int32_t generation;
+};
+
+struct SharedData {
+    std::mutex mutex;
+
+    TrampolineInfo trampolines[MaxTrampolines * 2];
+    uint32_t temp_trampolines = 0;
+    uint32_t registered_trampolines = 0;
+};
+
+extern SharedData shared;
+
 }

package/src/koffi/test/callbacks.js

@@ -75,6 +75,7 @@ async function test() {
     const ApplyStruct = lib.func('int ApplyStruct(int x, StructCallbacks callbacks)');
     const SetCallback = lib.func('void SetCallback(IntCallback *func)');
     const CallCallback = lib.func('int CallCallback(int x)');
+    const CallFromThread = lib.func('int CallFromThread(int x)');
     const MakeVectors = lib.func('int MakeVectors(int len, VectorCallback *func)');
     const CallQSort = lib.func('void CallQSort(_Inout_ void *base, size_t nmemb, size_t size, SortCallback *cb)');
     const CallMeChar = lib.func('int CallMeChar(CharCallback *func)');
@@ -260,4 +261,14 @@ async function test() {
 
         assert.equal(ret, 97 + 2 * 98);
     }
+
+    // Use callback from secondary thread
+    for (let i = 0; i < 128; i++) {
+        let cb = koffi.register(x => -x - 2, koffi.pointer(IntCallback));
+
+        SetCallback(cb);
+        assert.equal(await util.promisify(CallFromThread.async)(27), -29);
+
+        koffi.unregister(cb);
+    }
 }

package/src/koffi/test/misc.c

@@ -22,6 +22,14 @@
     typedef uint16_t char16_t;
     typedef uint32_t char32_t;
 #endif
+#ifdef _WIN32
+    #define NOMINMAX
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+#else
+    #include <errno.h>
+    #include <pthread.h>
+#endif
 
 #ifdef _WIN32
     #define EXPORT __declspec(dllexport)
@@ -671,6 +679,55 @@ EXPORT int CallCallback(int x)
     return callback(x);
 }
 
+#ifdef _WIN32
+
+static DWORD WINAPI CallFromThreadFunc(void *udata)
+{
+    int *ptr = (int *)udata;
+    *ptr = callback(*ptr);
+
+    return 0;
+}
+
+EXPORT int CallFromThread(int x)
+{
+    HANDLE h = CreateThread(NULL, 0, CallFromThreadFunc, &x, 0, NULL);
+    if (!h) {
+        perror("CreateThread");
+        exit(1);
+    }
+
+    WaitForSingleObject(h, INFINITE);
+
+    return x;
+}
+
+#else
+
+static void *CallFromThreadFunc(void *udata)
+{
+    int *ptr = (int *)udata;
+    *ptr = callback(*ptr);
+
+    return NULL;
+}
+
+EXPORT int CallFromThread(int x)
+{
+    pthread_t thread;
+
+    if (pthread_create(&thread, NULL, CallFromThreadFunc, &x)) {
+        perror("pthread_create");
+        exit(1);
+    }
+
+    pthread_join(thread, NULL);
+
+    return x;
+}
+
+#endif
+
 EXPORT void ReverseBytes(void *p, int len)
 {
     uint8_t *bytes = (uint8_t *)p;