koffi 1.0.4 → 1.1.0-beta.1

package/src/call.hh

@@ -24,24 +24,27 @@ namespace RG {
 bool AnalyseFunction(InstanceData *instance, FunctionInfo *func);
 
 class CallData {
-    Napi::Env env;
-    InstanceData *instance;
-    const FunctionInfo *func;
-
     struct OutObject {
-        Napi::Object obj;
+        Napi::ObjectReference ref;
         const uint8_t *ptr;
         const TypeInfo *type;
     };
 
-    Span<uint8_t> *stack_mem;
-    Span<uint8_t> *heap_mem;
-    LocalArray<OutObject, MaxOutParameters> out_objects;
-    BlockAllocator big_alloc;
+    Napi::Env env;
+    InstanceData *instance;
+    const FunctionInfo *func;
+
+    bool debug;
 
+    InstanceMemory *mem;
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
+    LocalArray<OutObject, MaxOutParameters> out_objects;
+
+    Span<uint8_t> heap;
+    Span<uint8_t> stack;
+
     union {
         uint32_t u32;
         uint64_t u64;
@@ -53,26 +56,9 @@ class CallData {
     uint8_t *return_ptr = nullptr;
 
 public:
-    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
+    CallData(Napi::Env env, const FunctionInfo *func, InstanceMemory *mem, bool debug);
     ~CallData();
 
-    Span<uint8_t> GetStack() const
-    {
-        uint8_t *sp = stack_mem->end();
-        Size len = old_stack_mem.end() - sp;
-
-        return MakeSpan(sp, len);
-    }
-    uint8_t *GetSP() const { return stack_mem->end(); };
-
-    Span<uint8_t> GetHeap() const
-    {
-        uint8_t *ptr = old_heap_mem.ptr;
-        Size len = heap_mem->ptr - ptr;
-
-        return MakeSpan(ptr, len);
-    }
-
     bool Prepare(const Napi::CallbackInfo &info);
     void Execute();
     Napi::Value Complete();
@@ -82,11 +68,11 @@ public:
         if (!RG_UNLIKELY(Prepare(info)))
             return env.Null();
 
-        if (instance->debug) {
+        if (debug) {
             DumpDebug();
         }
-
         Execute();
+
         return Complete();
     }
 
@@ -109,19 +95,19 @@ private:
 template <typename T>
 bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 {
-    uint8_t *ptr = AlignDown(stack_mem->end() - size, align);
-    Size delta = stack_mem->end() - ptr;
+    uint8_t *ptr = AlignDown(mem->stack.end() - size, align);
+    Size delta = mem->stack.end() - ptr;
 
-    if (RG_UNLIKELY(stack_mem->len < delta)) {
+    if (RG_UNLIKELY(mem->stack.len < delta)) {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
         return false;
     }
 
-    if (instance->debug) {
+    if (debug) {
         memset(ptr, 0, delta);
     }
 
-    stack_mem->len -= delta;
+    mem->stack.len -= delta;
 
     if (out_ptr) {
         *out_ptr = (T *)ptr;
@@ -132,20 +118,20 @@ bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 template <typename T>
 bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
 {
-    uint8_t *ptr = AlignUp(heap_mem->ptr, align);
-    Size delta = size + (ptr - heap_mem->ptr);
+    uint8_t *ptr = AlignUp(mem->heap.ptr, align);
+    Size delta = size + (ptr - mem->heap.ptr);
 
-    if (RG_UNLIKELY(delta > heap_mem->len)) {
+    if (RG_UNLIKELY(delta > mem->heap.len)) {
         ThrowError<Napi::Error>(env, "FFI call is taking up too much memory");
         return false;
     }
 
-    if (instance->debug) {
-        memset(heap_mem->ptr, 0, (size_t)delta);
+    if (debug) {
+        memset(mem->heap.ptr, 0, (size_t)delta);
     }
 
-    heap_mem->ptr += delta;
-    heap_mem->len -= delta;
+    mem->heap.ptr += delta;
+    mem->heap.len -= delta;
 
     if (out_ptr) {
         *out_ptr = (T *)ptr;

package/src/ffi.cc

@@ -241,6 +241,42 @@ static Napi::Value MarkInOut(const Napi::CallbackInfo &info)
     return EncodePointerDirection(info, 3);
 }
 
+static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
+{
+    RG_ASSERT(AlignLen(size, 16) == size);
+    RG_ASSERT(size >= Kibibytes(1));
+
+    // Account for allocator overhead
+    size -= 256;
+
+    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
+    uint8_t *aligned = AlignUp(ptr, 16);
+    Size delta = AlignLen(aligned - ptr, 16);
+
+    return MakeSpan(aligned, size - delta);
+}
+
+static InstanceMemory *AllocateCallMemory(InstanceData *instance)
+{
+    for (InstanceMemory *mem: instance->memories) {
+        if (!mem->depth)
+            return mem;
+    }
+
+    InstanceMemory *mem = new InstanceMemory();
+
+    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(1));
+    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
+
+    if (instance->memories.Available()) {
+        instance->memories.Append(mem);
+    } else {
+        mem->temporary = true;
+    }
+
+    return mem;
+}
+
 static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -252,7 +288,9 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    CallData call(env, instance, func);
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    CallData call(env, func, mem, instance->debug);
+
     return call.Run(info);
 }
 
@@ -309,10 +347,93 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(instance, &func))
         return env.Null();
 
-    CallData call(env, instance, &func);
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    CallData call(env, &func, mem, instance->debug);
+
     return call.Run(info);
 }
 
+class AsyncCall: public Napi::AsyncWorker {
+    Napi::Env env;
+    const FunctionInfo *func;
+
+    CallData call;
+    bool prepared = false;
+
+public:
+    AsyncCall(Napi::Env env, InstanceMemory *mem, FunctionInfo *func, bool debug,
+              Napi::Function &callback)
+        : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
+          call(env, func, mem, debug) {}
+    ~AsyncCall() { func->Unref(); }
+
+    bool Prepare(const Napi::CallbackInfo &info) {
+        prepared = call.Prepare(info);
+
+        if (!prepared) {
+            Napi::Error err = env.GetAndClearPendingException();
+            SetError(err.Message());
+        }
+
+        return prepared;
+    }
+    void DumpDebug() { call.DumpDebug(); }
+
+    void Execute() override;
+    void OnOK() override;
+};
+
+void AsyncCall::Execute()
+{
+    if (prepared) {
+        call.Execute();
+    }
+}
+
+void AsyncCall::OnOK()
+{
+    RG_ASSERT(prepared);
+
+    Napi::FunctionReference &callback = Callback();
+
+    Napi::Value self = env.Null();
+    napi_value args[] = {
+        env.Null(),
+        call.Complete()
+    };
+
+    callback.Call(self, RG_LEN(args), args);
+}
+
+static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    FunctionInfo *func = (FunctionInfo *)info.Data();
+
+    if (info.Length() <= (uint32_t)func->parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len + 1, info.Length());
+        return env.Null();
+    }
+
+    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));
+        return env.Null();
+    }
+
+    InstanceMemory *mem = AllocateCallMemory(instance);
+    AsyncCall *async = new AsyncCall(env, mem, func, instance->debug, callback);
+
+    if (async->Prepare(info) && instance->debug) {
+        async->DumpDebug();
+    }
+    async->Queue();
+
+    return env.Null();
+}
+
 static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
                                  Napi::Array parameters, FunctionInfo *func)
 {
@@ -386,7 +507,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     LibraryHolder *lib = (LibraryHolder *)info.Data();
 
     FunctionInfo *func = new FunctionInfo();
-    RG_DEFER_N(func_guard) { delete func; };
+    RG_DEFER { func->Unref(); };
 
     func->lib = lib->Ref();
     func->convention = convention;
@@ -445,9 +566,14 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
     Napi::Function::Callback call = func->variadic ? TranslateVariadicCall : TranslateNormalCall;
-    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func);
-    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { delete func; }, func);
-    func_guard.Disable();
+    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
+
+    if (!func->variadic) {
+        Napi::Function async = Napi::Function::New(env, TranslateAsyncCall, func->name, (void *)func->Ref());
+        async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
+        wrapper.Set("async", async);
+    }
 
     return wrapper;
 }
@@ -540,13 +666,13 @@ LibraryHolder::~LibraryHolder()
 #endif
 }
 
-LibraryHolder *LibraryHolder::Ref()
+const LibraryHolder *LibraryHolder::Ref() const
 {
     refcount++;
     return this;
 }
 
-void LibraryHolder::Unref()
+void LibraryHolder::Unref() const
 {
     if (!--refcount) {
         delete this;
@@ -646,21 +772,30 @@ FunctionInfo::~FunctionInfo()
     }
 }
 
-static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
+const FunctionInfo *FunctionInfo::Ref() const
 {
-    RG_ASSERT(AlignLen(size, 16) == size);
-
-    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
-    uint8_t *aligned = AlignUp(ptr, 16);
-    Size delta = AlignLen(aligned - ptr, 16);
+    refcount++;
+    return this;
+}
 
-    return MakeSpan(aligned, size - delta);
+void FunctionInfo::Unref() const
+{
+    if (!--refcount) {
+        delete this;
+    }
 }
 
 InstanceData::InstanceData()
 {
-    stack_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(2));
-    heap_mem = AllocateAndAlign16(&mem_alloc, Mebibytes(4));
+    AllocateCallMemory(this);
+    RG_ASSERT(memories.len == 1);
+}
+
+InstanceData::~InstanceData()
+{
+    for (InstanceMemory *mem: memories) {
+        delete mem;
+    }
 }
 
 template <typename Func>

package/src/ffi.hh

@@ -86,13 +86,13 @@ struct RecordMember {
 
 struct LibraryHolder {
     void *module = nullptr; // HMODULE on Windows
-    std::atomic_int refcount {1};
+    mutable std::atomic_int refcount {1};
 
     LibraryHolder(void *module) : module(module) {}
     ~LibraryHolder();
 
-    LibraryHolder *Ref();
-    void Unref();
+    const LibraryHolder *Ref() const;
+    void Unref() const;
 };
 
 enum class CallConvention {
@@ -132,11 +132,11 @@ struct ParameterInfo {
 };
 
 struct FunctionInfo {
-    ~FunctionInfo();
+    mutable std::atomic_int refcount {1};
 
     const char *name;
     const char *decorated_name;
-    LibraryHolder *lib = nullptr;
+    const LibraryHolder *lib = nullptr;
 
     void *func;
     CallConvention convention;
@@ -152,10 +152,27 @@ struct FunctionInfo {
 #if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64)
     bool forward_fp;
 #endif
+
+    ~FunctionInfo();
+
+    const FunctionInfo *Ref() const;
+    void Unref() const;
+};
+
+struct InstanceMemory {
+    LinkedAllocator mem_alloc;
+
+    Span<uint8_t> stack;
+    Span<uint8_t> heap;
+    IndirectBlockAllocator big_alloc { &mem_alloc };
+
+    int depth;
+    bool temporary;
 };
 
 struct InstanceData {
     InstanceData();
+    ~InstanceData();
 
     BucketArray<TypeInfo> types;
     HashTable<const char *, TypeInfo *> types_map;
@@ -163,12 +180,9 @@ struct InstanceData {
     bool debug;
     uint64_t tag_lower;
 
-    BlockAllocator str_alloc;
-
-    Span<uint8_t> stack_mem;
-    Span<uint8_t> heap_mem;
+    LocalArray<InstanceMemory *, 8> memories;
 
-    LinkedAllocator mem_alloc;
+    BlockAllocator str_alloc;
 };
 
 }

package/test/misc.c

@@ -275,7 +275,7 @@ EXPORT BFG STDCALL MakeBFG(BFG *p, int x, double y, const char *str)
 {
     BFG bfg;
 
-    char buf[64];
+    static char buf[64];
     snprintf(buf, sizeof(buf), "X/%s/X", str);
 
     bfg.a = x;
@@ -294,7 +294,7 @@ EXPORT PackedBFG FASTCALL MakePackedBFG(int x, double y, PackedBFG *p, const cha
 {
     PackedBFG bfg;
 
-    char buf[64];
+    static char buf[64];
     snprintf(buf, sizeof(buf), "X/%s/X", str);
 
     bfg.a = x;