koffi 1.2.0-alpha.4 → 1.2.0-alpha.5

package/README.md

@@ -8,6 +8,7 @@
   * [Variadic functions](#variadic-functions)
   * [Asynchronous calls](#asynchronous-calls)
   * [Callbacks](#callbacks)
+  * [Memory settings](#memory-settings)
 - [Benchmarks](#benchmarks)
   * [atoi results](#atoi-results)
   * [Raylib results](#raylib-results)
@@ -342,6 +343,27 @@ console.log(ret);
 // This example prints "Hello Niels!" first, and then prints 42
 ```
 
+## Memory settings
+
+For synchronous/normal calls, Koffi uses two preallocated memory blocks, one to construct the C stack and the other to allocate strings and big objects/structs. Unless very big strings or objects (at least more than one page of memory) are used, no extra allocation is needed during calls or callbacks.
+
+The size (in bytes) of these preallocated blocks can be changed. Use `koffi.config()` to get an object with the settings, and `koffi.config(obj)` to apply new settings.
+
+```js
+let config = koffi.config();
+console.log(config);
+
+// {
+//   sync_stack_size: 1048576,
+//   sync_heap_size: 2097152,
+//   async_stack_size: 524288,
+//   async_heap_size: 1048576,
+//   resident_async_pools: 2
+// }
+```
+
+The same is true for asynchronous calls. When an asynchronous call is made, Koffi will allocate new blocks unless there is an unused 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.
+
 # Benchmarks
 
 In order to run it, go to `koffi/benchmark` and run `../../cnoke/cnoke.js` (or `node ..\..\cnoke\cnoke.js` on Windows) before doing anything else.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.2.0-alpha.4",
+  "version": "1.2.0-alpha.5",
   "description": "Fast and simple C FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

package/src/abi_arm32.cc

@@ -231,8 +231,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     if (RG_UNLIKELY(!AllocStack(8 * 8, 8, &vec_ptr)))
         return false;
     if (func->ret.use_memory) {
-        if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
-            return false;
+        return_ptr = AllocHeap(func->ret.type->size, 16);
         *(uint8_t **)(gpr_ptr++) = return_ptr;
     }
 
@@ -351,8 +350,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
                     Napi::Object obj = value.As<Napi::Object>();
 
-                    if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
-                        return false;
+                    ptr = AllocHeap(param.type->ref->size, 16);
 
                     if (param.directions & 1) {
                         if (!PushObject(obj, param.type->ref, ptr))
@@ -452,11 +450,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    Size idx = ReserveTrampoline(param.type->proto, func);
-                    if (RG_UNLIKELY(idx < 0))
+                    ptr = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-
-                    ptr = GetTrampoline(idx, param.type->proto);
                 } else if (CheckValueTag(instance, value, param.type)) {
                     ptr = value.As<Napi::External<void>>().Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -570,10 +566,6 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const FunctionInfo *proto = instance->trampolines[idx].proto;
     Napi::Function func = instance->trampolines[idx].func;
 
-    // Allow reuse of static trampoline
-    instance->free_trampolines |= 1u << idx;
-    used_trampolines &= ~(1u << idx);
-
     uint64_t *vec_ptr = (uint64_t *)own_sp;
     uint32_t *gpr_ptr = (uint32_t *)(vec_ptr + 8);
     uint32_t *args_ptr = (uint32_t *)caller_sp;
@@ -690,12 +682,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                     gpr_ptr = AlignUp(gpr_ptr, align);
 
                     if (param.type->size > gpr_size) {
-                        uint8_t *ptr;
-
-                        // XXX: Expensive, and error can't be managed by calling C code.
-                        // But the object is split between the GPRs and the caller stack.
-                        if (RG_UNLIKELY(!AllocHeap(param.type->size, 16, &ptr)))
-                            return;
+                        // XXX: Expensive, can we do better?
+                        // The problem is that the object is split between the GPRs and the caller stack.
+                        uint8_t *ptr = AllocHeap(param.type->size, 16);
 
                         memcpy(ptr, gpr_ptr, gpr_size);
                         memcpy(ptr + gpr_size, args_ptr, param.type->size - gpr_size);
@@ -855,8 +844,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
-                    return;
+                ptr = AllocHeap(type->ref->size, 16);
 
                 if (!PushObject(obj, type->ref, ptr))
                     return;
@@ -920,11 +908,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             if (value.IsFunction()) {
                 Napi::Function func = value.As<Napi::Function>();
 
-                Size idx = ReserveTrampoline(type->proto, func);
-                if (RG_UNLIKELY(idx < 0))
+                ptr = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(!ptr))
                     return;
-
-                ptr = GetTrampoline(idx, type->proto);
             } else if (CheckValueTag(instance, value, type)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
             } else if (IsNullOrUndefined(value)) {

package/src/abi_arm64.cc

@@ -221,8 +221,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     if (RG_UNLIKELY(!AllocStack(9 * 8, 8, &gpr_ptr)))
         return false;
     if (func->ret.use_memory) {
-        if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
-            return false;
+        return_ptr = AllocHeap(func->ret.type->size, 16);
         gpr_ptr[8] = (uint64_t)return_ptr;
     }
 
@@ -338,8 +337,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
                     Napi::Object obj = value.As<Napi::Object>();
 
-                    if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
-                        return false;
+                    ptr = AllocHeap(param.type->ref->size, 16);
 
                     if (param.directions & 1) {
                         if (!PushObject(obj, param.type->ref, ptr))
@@ -394,9 +392,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         args_ptr += (param.type->size + 7) / 8;
                     }
                 } else {
-                    uint8_t *ptr;
-                    if (RG_UNLIKELY(!AllocHeap(param.type->size, 16, &ptr)))
-                        return false;
+                    uint8_t *ptr = AllocHeap(param.type->size, 16);
 
                     if (param.gpr_count) {
                         RG_ASSERT(param.gpr_count == 1);
@@ -460,11 +456,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    Size idx = ReserveTrampoline(param.type->proto, func);
-                    if (RG_UNLIKELY(idx < 0))
+                    ptr = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-
-                    ptr = GetTrampoline(idx, param.type->proto);
                 } else if (CheckValueTag(instance, value, param.type)) {
                     ptr = value.As<Napi::External<void>>().Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -589,10 +583,6 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const FunctionInfo *proto = instance->trampolines[idx].proto;
     Napi::Function func = instance->trampolines[idx].func;
 
-    // Allow reuse of static trampoline
-    instance->free_trampolines |= 1u << idx;
-    used_trampolines &= ~(1u << idx);
-
     uint64_t *gpr_ptr = (uint64_t *)own_sp;
     uint64_t *vec_ptr = gpr_ptr + 9;
     uint64_t *args_ptr = (uint64_t *)caller_sp;
@@ -928,8 +918,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
-                    return;
+                ptr = AllocHeap(type->ref->size, 16);
 
                 if (!PushObject(obj, type->ref, ptr))
                     return;
@@ -987,11 +976,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             if (value.IsFunction()) {
                 Napi::Function func = value.As<Napi::Function>();
 
-                Size idx = ReserveTrampoline(type->proto, func);
-                if (RG_UNLIKELY(idx < 0))
+                ptr = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(!ptr))
                     return;
-
-                ptr = GetTrampoline(idx, type->proto);
             } else if (CheckValueTag(instance, value, type)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
             } else if (IsNullOrUndefined(value)) {

package/src/abi_riscv64.cc

@@ -180,8 +180,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     if (RG_UNLIKELY(!AllocStack(8 * 8, 8, &vec_ptr)))
         return false;
     if (func->ret.use_memory) {
-        if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
-            return false;
+        return_ptr = AllocHeap(func->ret.type->size, 16);
         *(uint8_t **)(gpr_ptr++) = return_ptr;
     }
 
@@ -266,8 +265,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
                     Napi::Object obj = value.As<Napi::Object>();
 
-                    if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
-                        return false;
+                    ptr = AllocHeap(param.type->ref->size, 16);
 
                     if (param.directions & 1) {
                         if (!PushObject(obj, param.type->ref, ptr))
@@ -324,9 +322,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         args_ptr += (param.type->size + 7) / 8;
                     }
                 } else {
-                    uint8_t *ptr;
-                    if (RG_UNLIKELY(!AllocHeap(param.type->size, 16, &ptr)))
-                        return false;
+                    uint8_t *ptr = AllocHeap(param.type->size, 16);
 
                     if (param.gpr_count) {
                         RG_ASSERT(param.gpr_count == 1);
@@ -383,11 +379,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    Size idx = ReserveTrampoline(param.type->proto, func);
-                    if (RG_UNLIKELY(idx < 0))
+                    ptr = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-
-                    ptr = GetTrampoline(idx, param.type->proto);
                 } else if (CheckValueTag(instance, value, param.type)) {
                     ptr = value.As<Napi::External<void>>().Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -513,10 +507,6 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const FunctionInfo *proto = instance->trampolines[idx].proto;
     Napi::Function func = instance->trampolines[idx].func;
 
-    // Allow reuse of static trampoline
-    instance->free_trampolines |= 1u << idx;
-    used_trampolines &= ~(1u << idx);
-
     uint64_t *gpr_ptr = (uint64_t *)own_sp;
     uint64_t *vec_ptr = gpr_ptr + 8;
     uint64_t *args_ptr = (uint64_t *)caller_sp;
@@ -747,8 +737,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
-                    return;
+                ptr = AllocHeap(type->ref->size, 16);
 
                 if (!PushObject(obj, type->ref, ptr))
                     return;
@@ -805,11 +794,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             if (value.IsFunction()) {
                 Napi::Function func = value.As<Napi::Function>();
 
-                Size idx = ReserveTrampoline(type->proto, func);
-                if (RG_UNLIKELY(idx < 0))
+                ptr = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(!ptr))
                     return;
-
-                ptr = GetTrampoline(idx, type->proto);
             } else if (CheckValueTag(instance, value, type)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
             } else if (IsNullOrUndefined(value)) {

package/src/abi_x64_sysv.cc

@@ -260,8 +260,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     if (RG_UNLIKELY(!AllocStack(6 * 8, 8, &gpr_ptr)))
         return false;
     if (func->ret.use_memory) {
-        if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
-            return false;
+        return_ptr = AllocHeap(func->ret.type->size, 16);
         *(uint8_t **)(gpr_ptr++) = return_ptr;
     }
 
@@ -346,8 +345,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
                     Napi::Object obj = value.As<Napi::Object>();
 
-                    if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
-                        return false;
+                    ptr = AllocHeap(param.type->ref->size, 16);
 
                     if (param.directions & 1) {
                         if (!PushObject(obj, param.type->ref, ptr))
@@ -437,11 +435,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    Size idx = ReserveTrampoline(param.type->proto, func);
-                    if (RG_UNLIKELY(idx < 0))
+                    ptr = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-
-                    ptr = GetTrampoline(idx, param.type->proto);
                 } else if (CheckValueTag(instance, value, param.type)) {
                     ptr = value.As<Napi::External<void>>().Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -562,10 +558,6 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const FunctionInfo *proto = instance->trampolines[idx].proto;
     Napi::Function func = instance->trampolines[idx].func;
 
-    // Allow reuse of static trampoline
-    instance->free_trampolines |= 1u << idx;
-    used_trampolines &= ~(1u << idx);
-
     uint64_t *gpr_ptr = (uint64_t *)own_sp;
     uint64_t *xmm_ptr = gpr_ptr + 6;
     uint64_t *args_ptr = (uint64_t *)caller_sp;
@@ -785,8 +777,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
-                    return;
+                ptr = AllocHeap(type->ref->size, 16);
 
                 if (!PushObject(obj, type->ref, ptr))
                     return;
@@ -860,11 +851,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             if (value.IsFunction()) {
                 Napi::Function func = value.As<Napi::Function>();
 
-                Size idx = ReserveTrampoline(type->proto, func);
-                if (RG_UNLIKELY(idx < 0))
+                ptr = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(!ptr))
                     return;
-
-                ptr = GetTrampoline(idx, type->proto);
             } else if (CheckValueTag(instance, value, type)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
             } else if (IsNullOrUndefined(value)) {

package/src/abi_x64_win.cc

@@ -105,8 +105,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
     if (RG_UNLIKELY(!AllocStack(func->args_size, 16, &args_ptr)))
         return false;
     if (!func->ret.regular) {
-        if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
-            return false;
+        return_ptr = AllocHeap(func->ret.type->size, 16);
         *(uint8_t **)(args_ptr++) = return_ptr;
     }
 
@@ -192,8 +191,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
                     Napi::Object obj = value.As<Napi::Object>();
 
-                    if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
-                        return false;
+                    ptr = AllocHeap(param.type->ref->size, 16);
 
                     if (param.directions & 1) {
                         if (!PushObject(obj, param.type->ref, ptr))
@@ -227,8 +225,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (param.regular) {
                     ptr = (uint8_t *)(args_ptr++);
                 } else {
-                    if (RG_UNLIKELY(!AllocHeap(param.type->size, 16, &ptr)))
-                        return false;
+                    ptr = AllocHeap(param.type->size, 16);
                     *(uint8_t **)(args_ptr++) = ptr;
                 }
 
@@ -263,11 +260,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    Size idx = ReserveTrampoline(param.type->proto, func);
-                    if (RG_UNLIKELY(idx < 0))
+                    ptr = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-
-                    ptr = GetTrampoline(idx, param.type->proto);
                 } else if (CheckValueTag(instance, value, param.type)) {
                     ptr = value.As<Napi::External<uint8_t>>().Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -373,10 +368,6 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const FunctionInfo *proto = instance->trampolines[idx].proto;
     Napi::Function func = instance->trampolines[idx].func;
 
-    // Allow reuse of static trampoline
-    instance->free_trampolines |= 1u << idx;
-    used_trampolines &= ~(1u << idx);
-
     uint64_t *gpr_ptr = (uint64_t *)own_sp;
     uint64_t *xmm_ptr = gpr_ptr + 4;
     uint64_t *args_ptr = (uint64_t *)caller_sp;
@@ -586,8 +577,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
-                    return;
+                ptr = AllocHeap(type->ref->size, 16);
 
                 if (!PushObject(obj, type->ref, ptr))
                     return;
@@ -643,11 +633,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             if (value.IsFunction()) {
                 Napi::Function func = value.As<Napi::Function>();
 
-                Size idx = ReserveTrampoline(type->proto, func);
-                if (RG_UNLIKELY(idx < 0))
+                ptr = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(!ptr))
                     return;
-
-                ptr = GetTrampoline(idx, type->proto);
             } else if (CheckValueTag(instance, value, type)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
             } else if (IsNullOrUndefined(value)) {

package/src/abi_x86.cc

@@ -28,6 +28,9 @@ struct BackRegisters {
     double d;
     float f;
     bool is_double;
+#ifndef _WIN32
+    bool ret4;
+#endif
 };
 
 extern "C" uint64_t ForwardCallG(const void *func, uint8_t *sp, uint8_t **out_old_sp);
@@ -152,8 +155,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         args_ptr += 4;
     }
     if (!func->ret.trivial) {
-        if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
-            return false;
+        return_ptr = AllocHeap(func->ret.type->size, 16);
         *((func->ret.fast ? fast_ptr : args_ptr)++) = (uint32_t)return_ptr;
     }
 
@@ -256,8 +258,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
                     Napi::Object obj = value.As<Napi::Object>();
 
-                    if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
-                        return false;
+                    ptr = AllocHeap(param.type->ref->size, 16);
 
                     if (param.directions & 1) {
                         if (!PushObject(obj, param.type->ref, ptr))
@@ -294,7 +295,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     if (!PushObject(obj, param.type, ptr))
                         return false;
                 } else {
-                    uint8_t *ptr = (uint8_t *)AlignUp(args_ptr, param.type->align);
+                    uint8_t *ptr = (uint8_t *)args_ptr;
                     if (!PushObject(obj, param.type, ptr))
                         return false;
                     args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
@@ -326,11 +327,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    Size idx = ReserveTrampoline(param.type->proto, func);
-                    if (RG_UNLIKELY(idx < 0))
+                    ptr = ReserveTrampoline(param.type->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-
-                    ptr = GetTrampoline(idx, param.type->proto);
                 } else if (CheckValueTag(instance, value, param.type)) {
                     ptr = value.As<Napi::External<uint8_t>>().Data();
                 } else if (IsNullOrUndefined(value)) {
@@ -437,15 +436,15 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const FunctionInfo *proto = instance->trampolines[idx].proto;
     Napi::Function func = instance->trampolines[idx].func;
 
-    // Allow reuse of static trampoline
-    instance->free_trampolines |= 1u << idx;
-    used_trampolines &= ~(1u << idx);
-
     uint32_t *args_ptr = (uint32_t *)caller_sp;
 
     uint8_t *return_ptr = !proto->ret.trivial ? (uint8_t *)args_ptr[0] : nullptr;
     args_ptr += !proto->ret.trivial;
 
+#ifndef _WIN32
+    out_reg->ret4 = !!return_ptr;
+#endif
+
     LocalArray<napi_value, MaxParameters> arguments;
 
     // Convert to JS arguments
@@ -540,10 +539,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             case PrimitiveKind::Record: {
                 RG_ASSERT(!param.fast);
 
-                uint8_t *ptr = AlignUp((uint8_t *)args_ptr, param.type->align);
-                args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
+                uint8_t *ptr = (uint8_t *)args_ptr;
+
                 Napi::Object obj2 = PopObject(ptr, param.type);
                 arguments.Append(obj2);
+
+                args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
             } break;
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
@@ -643,8 +644,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             } else if (IsObject(value) && type->ref->primitive == PrimitiveKind::Record) {
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (RG_UNLIKELY(!AllocHeap(type->ref->size, 16, &ptr)))
-                    return;
+                ptr = AllocHeap(type->ref->size, 16);
 
                 if (!PushObject(obj, type->ref, ptr))
                     return;
@@ -681,6 +681,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             }
 
             out_reg->f = CopyNumber<float>(value);
+            out_reg->is_double = false;
         } break;
         case PrimitiveKind::Float64: {
             if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -697,11 +698,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             if (value.IsFunction()) {
                 Napi::Function func = value.As<Napi::Function>();
 
-                Size idx = ReserveTrampoline(type->proto, func);
-                if (RG_UNLIKELY(idx < 0))
+                ptr = ReserveTrampoline(type->proto, func);
+                if (RG_UNLIKELY(!ptr))
                     return;
-
-                ptr = GetTrampoline(idx, type->proto);
             } else if (CheckValueTag(instance, value, type)) {
                 ptr = value.As<Napi::External<uint8_t>>().Data();
             } else if (IsNullOrUndefined(value)) {

package/src/abi_x86_fwd.S

@@ -139,9 +139,16 @@ ForwardCallRD:
     call *RelayCallBack@GOT(%ecx)
     movl 16(%esp), %eax
     movl 20(%esp), %edx
+    cmpb $0, 37(%esp)
+    jne 2f
+1:
     addl $44, %esp
     .cfi_def_cfa esp, 4
     ret
+2:
+    addl $44, %esp
+    .cfi_def_cfa esp, 4
+    ret $4
     .cfi_endproc
 .endm
 
@@ -166,12 +173,11 @@ ForwardCallRD:
     jne 2f
 1:
     flds 32(%esp)
-    jmp 3f
+    addl $44, %esp
+    .cfi_def_cfa esp, 4
+    ret
 2:
     fldl 24(%esp)
-3:
-    movl 16(%esp), %eax
-    movl 20(%esp), %edx
     addl $44, %esp
     .cfi_def_cfa esp, 4
     ret
@@ -267,7 +273,7 @@ CallSwitchStack:
     andl $-16, %eax
     movl %eax, 4(%ecx)
     movl 20(%esp), %esp
-    subl $16, %esp
+    subl $28, %esp
     movl 8(%ebx), %eax
     movl %eax, 0(%esp)
     movl 12(%ebx), %eax

package/src/abi_x86_fwd.asm

@@ -138,8 +138,8 @@ trampoline macro ID
     lea eax, dword ptr [esp+16]
     mov dword ptr [esp+12], eax
     call RelayCallBack
-    mov eax, dword ptr[esp+16]
-    mov edx, dword ptr[esp+20]
+    mov eax, dword ptr [esp+16]
+    mov edx, dword ptr [esp+20]
     add esp, 44
     ret
 endm
@@ -158,16 +158,14 @@ trampoline_x87 macro ID
     lea eax, dword ptr [esp+16]
     mov dword ptr [esp+12], eax
     call RelayCallBack
-    cmp byte ptr[esp+36], 0
+    cmp byte ptr [esp+36], 0
     jne l2
 l1:
     fld dword ptr [esp+32]
-    jmp l3
+    add esp, 44
+    ret
 l2:
     fld qword ptr [esp+24]
-l3:
-    mov eax, dword ptr[esp+16]
-    mov edx, dword ptr[esp+20]
     add esp, 44
     ret
 endm

package/src/call.cc

@@ -298,11 +298,9 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    Size idx = ReserveTrampoline(member.type->proto, func);
-                    if (RG_UNLIKELY(idx < 0))
+                    ptr = ReserveTrampoline(type->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-
-                    ptr = GetTrampoline(idx, member.type->proto);
                 } else if (CheckValueTag(instance, value, member.type)) {
                     Napi::External external = value.As<Napi::External<void>>();
                     ptr = external.Data();
@@ -483,11 +481,9 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
                     if (value.IsFunction()) {
                         Napi::Function func = value.As<Napi::Function>();
 
-                        Size idx = ReserveTrampoline(type->ref->proto, func);
-                        if (RG_UNLIKELY(idx < 0))
+                        ptr = ReserveTrampoline(type->proto, func);
+                        if (RG_UNLIKELY(!ptr))
                             return false;
-
-                        ptr = GetTrampoline(idx, type->ref->proto);
                     } else if (CheckValueTag(instance, value, type->ref)) {
                         Napi::External external = value.As<Napi::External<void>>();
                         ptr = external.Data();
@@ -567,13 +563,13 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
     return true;
 }
 
-Size CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
+void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
 {
     uint32_t idx = CountTrailingZeros(instance->free_trampolines);
 
     if (RG_UNLIKELY(idx >= MaxTrampolines)) {
         ThrowError<Napi::Error>(env, "Too many callbacks are in use (max = %1)", MaxTrampolines);
-        return -1;
+        return nullptr;
     }
 
     instance->free_trampolines &= ~(1u << idx);
@@ -582,7 +578,8 @@ Size CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
     instance->trampolines[idx].proto = proto;
     instance->trampolines[idx].func = func;
 
-    return idx;
+    void *trampoline = GetTrampoline(idx, proto);
+    return trampoline;
 }
 
 void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign)

package/src/call.hh

@@ -41,6 +41,7 @@ class alignas(8) CallData {
     InstanceMemory *mem;
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
+
     uint32_t used_trampolines = 0;
 
     LocalArray<OutObject, MaxOutParameters> out_objects;
@@ -73,10 +74,10 @@ public:
     void DumpForward() const;
 
 private:
-    template <typename T = void>
+    template <typename T>
     bool AllocStack(Size size, Size align, T **out_ptr);
-    template <typename T = void>
-    bool AllocHeap(Size size, Size align, T **out_ptr);
+    template <typename T = uint8_t>
+    T *AllocHeap(Size size, Size align);
 
     const char *PushString(const Napi::Value &value);
     const char16_t *PushString16(const Napi::Value &value);
@@ -87,7 +88,7 @@ private:
     Napi::Object PopObject(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
     Napi::Value PopArray(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
 
-    Size ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
+    void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 };
 
 template <typename T>
@@ -113,25 +114,32 @@ inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 }
 
 template <typename T>
-inline bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
+inline T *CallData::AllocHeap(Size size, Size align)
 {
     uint8_t *ptr = AlignUp(mem->heap.ptr, align);
     Size delta = size + (ptr - mem->heap.ptr);
 
-    if (RG_UNLIKELY(delta > mem->heap.len)) {
-        ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
-        return false;
-    }
+    if (RG_LIKELY(size < 4096 && delta <= mem->heap.len)) {
+#ifdef RG_DEBUG
+        memset(mem->heap.ptr, 0, (size_t)delta);
+#endif
+
+        mem->heap.ptr += delta;
+        mem->heap.len -= delta;
 
+        return ptr;
+    } else {
 #ifdef RG_DEBUG
-    memset(mem->heap.ptr, 0, (size_t)delta);
+        int flags = (int)Allocator::Flag::Zero;
+#else
+        int flags = 0;
 #endif
 
-    mem->heap.ptr += delta;
-    mem->heap.len -= delta;
+        ptr = (uint8_t *)Allocator::Allocate(&call_alloc, size + align, flags);
+        ptr = AlignUp(ptr, align);
 
-    *out_ptr = (T *)ptr;
-    return true;
+        return ptr;
+    }
 }
 
 void *GetTrampoline(Size idx, const FunctionInfo *proto);

package/src/ffi.cc

@@ -43,6 +43,96 @@ namespace RG {
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
 
+static bool ChangeMemorySize(Napi::Value value, Size *out_size)
+{
+    const Size MinSize = Kibibytes(1);
+    const Size MaxSize = Mebibytes(16);
+
+    Napi::Env env = value.Env();
+
+    if (!value.IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for memory size, expected number");
+        return env.Null();
+    }
+
+    int64_t size = value.As<Napi::Number>().Int64Value();
+
+    if (size < MinSize || size > MaxSize) {
+        ThrowError<Napi::Error>(env, "Memory size must be between %1 and %2", FmtMemSize(MinSize), FmtMemSize(MaxSize));
+        return false;
+    }
+
+    *out_size = (Size)size;
+    return true;
+}
+
+static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length()) {
+        if (instance->memories.len) {
+            ThrowError<Napi::Error>(env, "Cannot change Koffi configuration once a library has been loaded");
+            return env.Null();
+        }
+
+        if (!info[0].IsObject()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for config, expected object", GetValueType(instance, info[0]));
+            return env.Null();
+        }
+
+        Napi::Object obj = info[0].As<Napi::Object>();
+        Napi::Array keys = obj.GetPropertyNames();
+
+        for (uint32_t i = 0; i < keys.Length(); i++) {
+            std::string key = ((Napi::Value)keys[i]).As<Napi::String>();
+            Napi::Value value = obj[key];
+
+            if (key == "sync_stack_size") {
+                if (!ChangeMemorySize(value, &instance->sync_stack_size))
+                    return env.Null();
+            } else if (key == "sync_heap_size") {
+                if (!ChangeMemorySize(value, &instance->sync_heap_size))
+                    return env.Null();
+            } else if (key == "async_stack_size") {
+                if (!ChangeMemorySize(value, &instance->async_stack_size))
+                    return env.Null();
+            } else if (key == "async_heap_size") {
+                if (!ChangeMemorySize(value, &instance->async_heap_size))
+                    return env.Null();
+            } else if (key == "resident_async_pools") {
+                if (!value.IsNumber()) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for resident_async_pools, expected number");
+                    return env.Null();
+                }
+
+                int64_t n = value.As<Napi::Number>().Int64Value();
+
+                if (n < 0 || n > RG_LEN(instance->memories.data)) {
+                    ThrowError<Napi::Error>(env, "Parameter resident_async_pools must be between 0 and %1", RG_LEN(instance->memories.data));
+                    return env.Null();
+                }
+
+                RG_STATIC_ASSERT(DefaultResidentAsyncPools <= RG_LEN(instance->memories.data));
+            } else {
+                ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
+                return env.Null();
+            }
+        }
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+
+    obj.Set("sync_stack_size", instance->sync_stack_size);
+    obj.Set("sync_heap_size", instance->sync_heap_size);
+    obj.Set("async_stack_size", instance->async_stack_size);
+    obj.Set("async_heap_size", instance->async_heap_size);
+    obj.Set("resident_async_pools", instance->resident_async_pools);
+
+    return obj;
+}
+
 static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
@@ -509,7 +599,7 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
     return type->defn.Value();
 }
 
-static InstanceMemory *AllocateMemory(InstanceData *instance)
+static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size heap_size)
 {
     for (Size i = 1; i < instance->memories.len; i++) {
         InstanceMemory *mem = instance->memories[i];
@@ -520,7 +610,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance)
 
     InstanceMemory *mem = new InstanceMemory();
 
-    mem->stack.len = StackSize;
+    mem->stack.len = stack_size;
 #if defined(_WIN32)
     mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 #elif defined(__APPLE__)
@@ -530,7 +620,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance)
 #endif
     RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 
-    mem->heap.len = HeapSize;
+    mem->heap.len = heap_size;
 #ifdef _WIN32
     mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 #else
@@ -538,7 +628,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance)
 #endif
     RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
-    if (instance->memories.Available()) {
+    if (instance->memories.len <= instance->resident_async_pools) {
         instance->memories.Append(mem);
     } else {
         mem->temporary = true;
@@ -710,7 +800,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    InstanceMemory *mem = AllocateMemory(instance);
+    InstanceMemory *mem = AllocateMemory(instance, instance->async_stack_size, instance->async_heap_size);
     AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
@@ -817,6 +907,10 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
+    if (!instance->memories.len) {
+        AllocateMemory(instance, instance->sync_stack_size, instance->sync_heap_size);
+    }
+
     // Load shared library
     void *module = nullptr;
 #ifdef _WIN32
@@ -1032,12 +1126,6 @@ InstanceMemory::~InstanceMemory()
 #endif
 }
 
-InstanceData::InstanceData()
-{
-    AllocateMemory(this);
-    RG_ASSERT(memories.len == 1);
-}
-
 InstanceData::~InstanceData()
 {
     for (InstanceMemory *mem: memories) {
@@ -1048,16 +1136,21 @@ InstanceData::~InstanceData()
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
+    func("config", Napi::Function::New(env, GetSetConfig));
+
     func("struct", Napi::Function::New(env, CreatePaddedStructType));
     func("pack", Napi::Function::New(env, CreatePackedStructType));
     func("handle", Napi::Function::New(env, CreateHandleType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("array", Napi::Function::New(env, CreateArrayType));
     func("callback", Napi::Function::New(env, CreateCallbackType));
+
     func("sizeof", Napi::Function::New(env, GetTypeSize));
     func("alignof", Napi::Function::New(env, GetTypeAlign));
     func("introspect", Napi::Function::New(env, GetTypeDefinition));
+
     func("load", Napi::Function::New(env, LoadSharedLibrary));
+
     func("in", Napi::Function::New(env, MarkIn));
     func("out", Napi::Function::New(env, MarkOut));
     func("inout", Napi::Function::New(env, MarkInOut));

package/src/ffi.hh

@@ -19,8 +19,11 @@
 
 namespace RG {
 
-static const Size StackSize = Mebibytes(1);
-static const Size HeapSize = Mebibytes(2);
+static const Size DefaultSyncStackSize = Mebibytes(1);
+static const Size DefaultSyncHeapSize = Mebibytes(2);
+static const Size DefaultAsyncStackSize = Kibibytes(512);
+static const Size DefaultAsyncHeapSize = Mebibytes(1);
+static const int DefaultResidentAsyncPools = 2;
 
 static const Size MaxParameters = 32;
 static const Size MaxOutParameters = 8;
@@ -205,7 +208,6 @@ struct TrampolineInfo {
 };
 
 struct InstanceData {
-    InstanceData();
     ~InstanceData();
 
     BucketArray<TypeInfo> types;
@@ -215,12 +217,18 @@ struct InstanceData {
     bool debug;
     uint64_t tag_lower;
 
-    LocalArray<InstanceMemory *, 6> memories;
+    LocalArray<InstanceMemory *, 16> memories;
 
     TrampolineInfo trampolines[MaxTrampolines];
     uint32_t free_trampolines = UINT32_MAX;
 
     BlockAllocator str_alloc;
+
+    Size sync_stack_size = DefaultSyncStackSize;
+    Size sync_heap_size = DefaultSyncHeapSize;
+    Size async_stack_size = DefaultAsyncStackSize;
+    Size async_heap_size = DefaultAsyncHeapSize;
+    int resident_async_pools = DefaultResidentAsyncPools;
 };
 RG_STATIC_ASSERT(MaxTrampolines <= 32);