koffi 1.3.4 → 1.3.5

package/src/ffi.cc

@@ -43,7 +43,7 @@ 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)
+static bool ChangeMemorySize(const char *name, Napi::Value value, Size *out_size)
 {
     const Size MinSize = Kibibytes(1);
     const Size MaxSize = Mebibytes(16);
@@ -51,14 +51,16 @@ static bool ChangeMemorySize(Napi::Value value, Size *out_size)
     Napi::Env env = value.Env();
 
     if (!value.IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for memory size, expected number");
-        return env.Null();
+        InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected number", GetValueType(instance, value), name);
+        return false;
     }
 
     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));
+        ThrowError<Napi::Error>(env, "Setting '%1' must be between %2 and %3", name, FmtMemSize(MinSize), FmtMemSize(MaxSize));
         return false;
     }
 
@@ -66,6 +68,28 @@ static bool ChangeMemorySize(Napi::Value value, Size *out_size)
     return true;
 }
 
+static bool ChangeAsyncLimit(const char *name, Napi::Value value, int max, int *out_limit)
+{
+    Napi::Env env = value.Env();
+
+    if (!value.IsNumber()) {
+        InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected number", GetValueType(instance, value), name);
+        return false;
+    }
+
+    int64_t n = value.As<Napi::Number>().Int64Value();
+
+    if (n < 0 || n > max) {
+        ThrowError<Napi::Error>(env, "Setting '%1' must be between 0 and %2", name, max);
+        return false;
+    }
+
+    *out_limit = (int)n;
+    return true;
+}
+
 static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -82,6 +106,13 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             return env.Null();
         }
 
+        Size sync_stack_size = instance->sync_stack_size;
+        Size sync_heap_size = instance->sync_heap_size;
+        Size async_stack_size = instance->async_stack_size;
+        Size async_heap_size = instance->async_heap_size;
+        int resident_async_pools = instance->resident_async_pools;
+        int max_async_calls = resident_async_pools + instance->max_temporaries;
+
         Napi::Object obj = info[0].As<Napi::Object>();
         Napi::Array keys = obj.GetPropertyNames();
 
@@ -90,38 +121,40 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             Napi::Value value = obj[key];
 
             if (key == "sync_stack_size") {
-                if (!ChangeMemorySize(value, &instance->sync_stack_size))
+                if (!ChangeMemorySize(key.c_str(), value, &sync_stack_size))
                     return env.Null();
             } else if (key == "sync_heap_size") {
-                if (!ChangeMemorySize(value, &instance->sync_heap_size))
+                if (!ChangeMemorySize(key.c_str(), value, &sync_heap_size))
                     return env.Null();
             } else if (key == "async_stack_size") {
-                if (!ChangeMemorySize(value, &instance->async_stack_size))
+                if (!ChangeMemorySize(key.c_str(), value, &async_stack_size))
                     return env.Null();
             } else if (key == "async_heap_size") {
-                if (!ChangeMemorySize(value, &instance->async_heap_size))
+                if (!ChangeMemorySize(key.c_str(), value, &async_heap_size))
                     return env.Null();
             } else if (key == "resident_async_pools") {
-                RG_STATIC_ASSERT(DefaultResidentAsyncPools <= RG_LEN(instance->memories.data));
-
-                if (!value.IsNumber()) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for resident_async_pools, expected number");
+                if (!ChangeAsyncLimit(key.c_str(), value, RG_LEN(instance->memories.data) - 1, &resident_async_pools))
                     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));
+            } else if (key == "max_async_calls") {
+                if (!ChangeAsyncLimit(key.c_str(), value, MaxAsyncCalls, &max_async_calls))
                     return env.Null();
-                }
-
-                instance->resident_async_pools = (int)n;
             } else {
                 ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
                 return env.Null();
             }
         }
+
+        if (max_async_calls < resident_async_pools) {
+            ThrowError<Napi::Error>(env, "Setting max_async_calls must be >= to resident_async_pools");
+            return env.Null();
+        }
+
+        instance->sync_stack_size = sync_stack_size;
+        instance->sync_heap_size = sync_heap_size;
+        instance->async_stack_size = async_stack_size;
+        instance->async_heap_size = async_heap_size;
+        instance->resident_async_pools = resident_async_pools;
+        instance->max_temporaries = max_async_calls - resident_async_pools;
     }
 
     Napi::Object obj = Napi::Object::New(env);
@@ -131,6 +164,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
     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);
+    obj.Set("max_async_calls", instance->resident_async_pools + instance->max_temporaries);
 
     return obj;
 }
@@ -616,6 +650,9 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
             return mem;
     }
 
+    if (RG_UNLIKELY(instance->temporaries >= instance->max_temporaries))
+        return nullptr;
+
     InstanceMemory *mem = new InstanceMemory();
 
     mem->stack.len = stack_size;
@@ -628,6 +665,11 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 #endif
     RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 
+#ifdef __OpenBSD__
+    // Make sure the SP points inside the MAP_STACK area, or (void) functions may crash on OpenBSD i386
+    mem->stack.len -= 16;
+#endif
+
     mem->heap.len = heap_size;
 #ifdef _WIN32
     mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
@@ -640,7 +682,9 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 
     if (instance->memories.len <= instance->resident_async_pools) {
         instance->memories.Append(mem);
+        mem->temporary = false;
     } else {
+        instance->temporaries++;
         mem->temporary = true;
     }
 
@@ -806,11 +850,15 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     Napi::Function callback = info[(uint32_t)func->parameters.len].As<Napi::Function>();
 
     if (!callback.IsFunction()) {
-        ThrowError<Napi::TypeError>(env, "Expected callback function as last arguments, got %1", GetValueType(instance, callback));
+        ThrowError<Napi::TypeError>(env, "Expected callback function as last argument, got %1", GetValueType(instance, callback));
         return env.Null();
     }
 
     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 env.Null();
+    }
     AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
@@ -919,6 +967,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 
     if (!instance->memories.len) {
         AllocateMemory(instance, instance->sync_stack_size, instance->sync_heap_size);
+        RG_ASSERT(instance->memories.len);
     }
 
     // Load shared library

package/src/ffi.hh

@@ -21,10 +21,12 @@ namespace RG {
 
 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 Size DefaultAsyncStackSize = Kibibytes(256);
+static const Size DefaultAsyncHeapSize = Kibibytes(512);
 static const int DefaultResidentAsyncPools = 2;
+static const int DefaultMaxAsyncCalls = 64;
 
+static const int MaxAsyncCalls = 256;
 static const Size MaxParameters = 32;
 static const Size MaxOutParameters = 4;
 static const Size MaxTrampolines = 16;
@@ -216,7 +218,8 @@ struct InstanceData {
     bool debug;
     uint64_t tag_lower;
 
-    LocalArray<InstanceMemory *, 16> memories;
+    LocalArray<InstanceMemory *, 9> memories;
+    int temporaries = 0;
 
     TrampolineInfo trampolines[MaxTrampolines];
     uint32_t free_trampolines = UINT32_MAX;
@@ -228,7 +231,11 @@ struct InstanceData {
     Size async_stack_size = DefaultAsyncStackSize;
     Size async_heap_size = DefaultAsyncHeapSize;
     int resident_async_pools = DefaultResidentAsyncPools;
+    int max_temporaries = DefaultMaxAsyncCalls - DefaultResidentAsyncPools;
 };
-RG_STATIC_ASSERT(MaxTrampolines <= 32);
+RG_STATIC_ASSERT(DefaultResidentAsyncPools <= RG_LEN(InstanceData::memories.data) - 1);
+RG_STATIC_ASSERT(DefaultMaxAsyncCalls >= DefaultResidentAsyncPools);
+RG_STATIC_ASSERT(MaxAsyncCalls >= DefaultMaxAsyncCalls);
+RG_STATIC_ASSERT(MaxTrampolines <= 16);
 
 }

package/test/async.js

@@ -51,7 +51,7 @@ async function test() {
     let promises = [];
 
     // Issue several async calls
-    for (let i = 0; i < 64; i++) {
+    for (let i = 0; i < 32; i++) {
         let p = new Promise((resolve, reject) => {
             try {
                 ConcatenateToInt1.async(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7, (err, res) => {