koffi 2.1.3 → 2.1.5

package/src/cnoke/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "cnoke",
+  "version": "3.2.1",
+  "description": "Build native Node addons based on CMake, without extra dependency",
+  "keywords": [
+    "native",
+    "addon",
+    "cmake",
+    "c",
+    "c++"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Koromix/rygel.git"
+  },
+  "author": "Niels Martignène <niels.martignene@protonmail.com>",
+  "bin": "cnoke.js",
+  "license": "AGPL-3.0",
+  "files": [
+    "cnoke.js",
+    "LICENSE.txt",
+    "README.md",
+    "assets"
+  ]
+}

package/{vendor → src/core}/libcc/libcc.cc

@@ -3069,6 +3069,7 @@ OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int
     DWORD access = 0;
     DWORD share = 0;
     DWORD creation = 0;
+    DWORD attributes = 0;
     int oflags = -1;
     switch (flags & ((int)OpenFlag::Read |
                      (int)OpenFlag::Write |
@@ -3077,47 +3078,63 @@ OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int
             access = GENERIC_READ;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
             creation = OPEN_EXISTING;
-
+            attributes = FILE_ATTRIBUTE_NORMAL;
             oflags = _O_RDONLY | _O_BINARY | _O_NOINHERIT;
         } break;
         case (int)OpenFlag::Write: {
             access = GENERIC_WRITE;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-            creation = (flags & (int)OpenFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
-
+            creation = CREATE_ALWAYS;
+            attributes = FILE_ATTRIBUTE_NORMAL;
             oflags = _O_WRONLY | _O_CREAT | _O_TRUNC | _O_BINARY | _O_NOINHERIT;
         } break;
         case (int)OpenFlag::Read | (int)OpenFlag::Write: {
             access = GENERIC_READ | GENERIC_WRITE;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-            creation = (flags & (int)OpenFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
-
+            creation = CREATE_ALWAYS;
+            attributes = FILE_ATTRIBUTE_NORMAL;
             oflags = _O_RDWR | _O_CREAT | _O_TRUNC | _O_BINARY | _O_NOINHERIT;
         } break;
         case (int)OpenFlag::Append: {
             access = GENERIC_WRITE;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-            creation = (flags & (int)OpenFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
-
+            creation = CREATE_ALWAYS;
+            attributes = FILE_ATTRIBUTE_NORMAL;
             oflags = _O_WRONLY | _O_CREAT | _O_APPEND | _O_BINARY | _O_NOINHERIT;
         } break;
     }
     RG_ASSERT(oflags >= 0);
 
-    if (flags & (int)OpenFlag::Exclusive) {
+    if (flags & (int)OpenFlag::Directory) {
+        RG_ASSERT(!(flags & (int)OpenFlag::Exclusive));
+        RG_ASSERT(!(flags & (int)OpenFlag::Append));
+
+        creation = OPEN_EXISTING;
+        attributes = FILE_FLAG_BACKUP_SEMANTICS;
+        oflags &= ~(_O_CREAT | _O_TRUNC | _O_BINARY);
+    }
+    if (flags & (int)OpenFlag::Exists) {
+        RG_ASSERT(!(flags & (int)OpenFlag::Exclusive));
+
+        creation = OPEN_EXISTING;
+        oflags &= ~_O_CREAT;
+    } else if (flags & (int)OpenFlag::Exclusive) {
+        RG_ASSERT(creation == CREATE_ALWAYS);
+
+        creation = CREATE_NEW;
         oflags |= (int)_O_EXCL;
     }
     share |= FILE_SHARE_DELETE;
 
     HANDLE h;
     if (win32_utf8) {
-        h = CreateFileA(filename, access, share, nullptr, creation, FILE_ATTRIBUTE_NORMAL, nullptr);
+        h = CreateFileA(filename, access, share, nullptr, creation, attributes, nullptr);
     } else {
         wchar_t filename_w[4096];
         if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0)
             return OpenResult::OtherError;
 
-        h = CreateFileW(filename_w, access, share, nullptr, creation, FILE_ATTRIBUTE_NORMAL, nullptr);
+        h = CreateFileW(filename_w, access, share, nullptr, creation, attributes, nullptr);
     }
     if (h == INVALID_HANDLE_VALUE) {
         DWORD err = GetLastError();
@@ -3410,7 +3427,17 @@ OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int
     }
     RG_ASSERT(oflags >= 0);
 
-    if (flags & (int)OpenFlag::Exclusive) {
+    if (flags & (int)OpenFlag::Directory) {
+        RG_ASSERT(!(flags & (int)OpenFlag::Exclusive));
+        RG_ASSERT(!(flags & (int)OpenFlag::Append));
+
+        oflags &= ~O_CREAT;
+    }
+    if (flags & (int)OpenFlag::Exists) {
+        RG_ASSERT(!(flags & (int)OpenFlag::Exclusive));
+        oflags &= ~O_CREAT;
+    } else if (flags & (int)OpenFlag::Exclusive) {
+        RG_ASSERT(oflags & O_CREAT);
         oflags |= O_EXCL;
     }
 

package/{vendor → src/core}/libcc/libcc.hh

@@ -272,7 +272,7 @@ constexpr Size Kilobytes(Size len) { return len * 1000; }
 template <typename T, unsigned N>
 char (&ComputeArraySize(T const (&)[N]))[N];
 #define RG_LEN(Array) RG_SIZE(RG::ComputeArraySize(Array))
-#define RG_OFFSET_OF(Type, Member) __builtin_offsetof(Type, Member)
+#define RG_OFFSET_OF(Type, Member) ((Size)__builtin_offsetof(Type, Member))
 
 static inline constexpr uint16_t ReverseBytes(uint16_t u)
 {
@@ -3868,7 +3868,9 @@ enum class OpenFlag {
     Write = 1 << 1,
     Append = 1 << 2,
 
-    Exclusive = 1 << 3
+    Directory = 1 << 3,
+    Exists = 1 << 4,
+    Exclusive = 1 << 5
 };
 
 enum class OpenResult {

package/{CMakeLists.txt → src/koffi/CMakeLists.txt}

@@ -44,7 +44,7 @@ set(KOFFI_SRC
     src/ffi.cc
     src/parser.cc
     src/util.cc
-    vendor/libcc/libcc.cc
+    ../../src/core/libcc/libcc.cc
 )
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
     # CMAKE_SYSTEM_PROCESSOR is wrong on Windows ARM64
@@ -98,9 +98,9 @@ elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
 endif()
 
 add_node_addon(NAME koffi SOURCES ${KOFFI_SRC})
-target_include_directories(koffi PRIVATE . vendor/node-addon-api)
+target_include_directories(koffi PRIVATE . ../.. ../../vendor/node-addon-api)
 
-target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=8)
+target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=8 LIBCC_NO_BROTLI LIBCC_NO_MINIZ)
 if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
     target_link_libraries(koffi PRIVATE ws2_32)

package/{benchmark → src/koffi/benchmark}/CMakeLists.txt

@@ -36,8 +36,9 @@ endif()
 
 # ---- atoi ----
 
-add_node_addon(NAME atoi_napi SOURCES atoi_napi.cc ../vendor/libcc/libcc.cc)
-target_include_directories(atoi_napi PRIVATE .. ../vendor/node-addon-api)
+add_node_addon(NAME atoi_napi SOURCES atoi_napi.cc ../../../src/core/libcc/libcc.cc)
+target_compile_definitions(atoi_napi PRIVATE LIBCC_NO_BROTLI LIBCC_NO_MINIZ)
+target_include_directories(atoi_napi PRIVATE ../../.. ../../../vendor/node-addon-api)
 target_link_libraries(atoi_napi PRIVATE Threads::Threads)
 
 if(WIN32)
@@ -49,8 +50,9 @@ endif()
 
 # ---- rand ----
 
-add_node_addon(NAME rand_napi SOURCES rand_napi.cc ../vendor/libcc/libcc.cc)
-target_include_directories(rand_napi PRIVATE .. ../vendor/node-addon-api)
+add_node_addon(NAME rand_napi SOURCES rand_napi.cc ../../../src/core/libcc/libcc.cc)
+target_compile_definitions(rand_napi PRIVATE LIBCC_NO_BROTLI LIBCC_NO_MINIZ)
+target_include_directories(rand_napi PRIVATE ../../.. ../../../vendor/node-addon-api)
 target_link_libraries(rand_napi PRIVATE Threads::Threads)
 
 if(WIN32)
@@ -62,8 +64,9 @@ endif()
 
 # ---- Raylib ----
 
-add_executable(raylib_cc raylib_cc.cc ../vendor/libcc/libcc.cc)
-target_include_directories(raylib_cc PRIVATE ..)
+add_executable(raylib_cc raylib_cc.cc  ../../../src/core/libcc/libcc.cc)
+target_compile_definitions(raylib_cc PRIVATE LIBCC_NO_BROTLI LIBCC_NO_MINIZ)
+target_include_directories(raylib_cc PRIVATE ../../..)
 target_link_libraries(raylib_cc PRIVATE Threads::Threads raylib)
 
 if(WIN32)

package/{benchmark → src/koffi/benchmark}/atoi_napi.cc

@@ -11,7 +11,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see https://www.gnu.org/licenses/.
 
-#include "vendor/libcc/libcc.hh"
+#include "src/core/libcc/libcc.hh"
 #include <napi.h>
 
 namespace RG {

package/src/koffi/benchmark/benchmark.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const minimatch = require('minimatch');
+
+main();
+
+function main() {
+    try {
+        let select = process.argv.slice(2);
+        benchmark(select);
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+function benchmark(select) {
+    if (!select.length || select.includes('rand'))
+        format(run('rand', 'rand_napi'), 'ns');
+    if (!select.length || select.includes('atoi'))
+        format(run('atoi', 'atoi_napi'), 'ns');
+    if (!select.length || select.includes('raylib'))
+        format(run('raylib', 'raylib_node_raylib'), 'us');
+}
+
+function run(name, ref) {
+    let tests = [];
+    {
+        let entries = fs.readdirSync(__dirname);
+
+        let pattern = name + '_*.js';
+        let re = minimatch.makeRe(pattern);
+
+        for (let entry of entries) {
+            if (entry.match(re)) {
+                let test = {
+                    name: path.basename(entry, '.js'),
+                    filename: path.join(__dirname, entry)
+                };
+
+                if (test.name == ref)
+                    ref = test;
+                tests.push(test);
+            }
+        }
+    }
+
+    if (typeof ref == 'string')
+        throw new Error('Failed to find reference test');
+
+    for (let test of tests) {
+        let proc = spawnSync(process.execPath, [test.filename]);
+
+        if (proc.status == null)
+            throw new Error(proc.error);
+        if (proc.status !== 0)
+            throw new Error(proc.stderr);
+
+        let perf = JSON.parse(proc.stdout);
+
+        test.iterations = perf.iterations;
+        test.time = perf.time;
+    }
+
+    for (let test of tests) {
+        test.ratio = (ref.time / ref.iterations) / (test.time / test.iterations);
+
+        if (test != ref) {
+            test.overhead = Math.round((1 / test.ratio - 1) * 100);
+        } else {
+            test.overhead = '(ref)';
+        }
+    }
+
+    tests.sort((test1, test2) => test2.ratio - test1.ratio);
+
+    return tests;
+}
+
+function format(tests, unit) {
+    let len0 = tests.reduce((acc, test) => Math.max(acc, test.name.length), 0);
+
+    console.log(`${'Benchmark'.padEnd(len0, ' ')} | Iteration time | Relative performance | Overhead`);
+    console.log(`${'-'.padEnd(len0, '-')} | -------------- | -------------------- | --------`);
+    for (let test of tests) {
+        let time = format_time(test.time / test.iterations, unit);
+        let ratio = test.ratio.toFixed(test.ratio < 0.01 ? 3 : 2);
+        let overhead = (typeof test.overhead == 'number') ? `${test.overhead >= 0 ? '+' : ''}${test.overhead}%` : test.overhead;
+
+        console.log(`${test.name.padEnd(len0, ' ')} | ${('' + time).padEnd(14, ' ')} | x${('' + ratio).padEnd(19, ' ')} | ${overhead}`);
+    }
+
+    console.log('');
+}
+
+function format_time(time, unit) {
+    switch (unit) {
+        case 'ms': { return (time * 1).toFixed(1) + ' ms'; } break;
+        case 'us': { return (time * 1000).toFixed(1) + ' µs'; } break;
+        case 'ns': { return (time * 10000000).toFixed(0) + ' ns'; } break;
+    }
+}

package/src/koffi/benchmark/rand_koffi.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const koffi = require('./build/koffi.node');
+
+let sum = 0;
+
+main();
+
+function main() {
+    let time = 5000;
+
+    if (process.argv.length >= 3) {
+        time = parseFloat(process.argv[2]) * 1000;
+        if (Number.isNaN(time))
+            throw new Error('Not a valid number');
+        if (time < 0)
+            throw new Error('Time must be positive');
+    }
+
+    let lib = koffi.load(process.platform == 'win32' ? 'msvcrt.dll' : null);
+
+    const srand = lib.cdecl('srand', 'void', ['uint']);
+    const rand = lib.cdecl('rand', 'int', []);
+
+    srand(42);
+
+    let start = performance.now();
+    let iterations = 0;
+
+    while (performance.now() - start < time) {
+        for (let i = 0; i < 1000000; i++)
+            sum += rand();
+
+        iterations += 1000000;
+    }
+
+    time = performance.now() - start;
+    console.log(JSON.stringify({ iterations: iterations, time: Math.round(time) }));
+}

package/src/koffi/benchmark/rand_napi.cc

@@ -0,0 +1,69 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#include "src/core/libcc/libcc.hh"
+#include <napi.h>
+
+namespace RG {
+
+template <typename T, typename... Args>
+void ThrowError(Napi::Env env, const char *msg, Args... args)
+{
+    char buf[1024];
+    Fmt(buf, msg, args...);
+
+    auto err = T::New(env, buf);
+    err.ThrowAsJavaScriptException();
+}
+
+static Napi::Value RunSrand(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (RG_UNLIKELY(info.Length() < 1)) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+    if (RG_UNLIKELY(!info[0].IsNumber())) {
+        ThrowError<Napi::TypeError>(env, "Unexpected type for seed, expected number");
+        return env.Null();
+    }
+
+    unsigned int seed = (info[0].As<Napi::Number>()).Uint32Value();
+    srand(seed);
+
+    return env.Null();
+}
+
+static Napi::Value RunRand(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    int rnd = rand();
+
+    return Napi::Number::New(env, rnd);
+}
+
+}
+
+static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
+{
+    using namespace RG;
+
+    exports.Set("srand", Napi::Function::New(env, RunSrand));
+    exports.Set("rand", Napi::Function::New(env, RunRand));
+
+    return exports;
+}
+
+NODE_API_MODULE(koffi, InitModule);

package/src/koffi/benchmark/rand_napi.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const rand = require('./build/rand_napi.node');
+
+let sum = 0;
+
+main();
+
+function main() {
+    let time = 5000;
+
+    if (process.argv.length >= 3) {
+        time = parseFloat(process.argv[2]) * 1000;
+        if (Number.isNaN(time))
+            throw new Error('Not a valid number');
+        if (time < 0)
+            throw new Error('Time must be positive');
+    }
+
+    rand.srand(42);
+
+    let start = performance.now();
+    let iterations = 0;
+
+    while (performance.now() - start < time) {
+        for (let i = 0; i < 1000000; i++)
+            sum += rand.rand();
+
+        iterations += 1000000;
+    }
+
+    time = performance.now() - start;
+    console.log(JSON.stringify({ iterations: iterations, time: Math.round(time) }));
+}

package/src/koffi/benchmark/rand_node_ffi.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const ref = require('ref-napi');
+const ffi = require('ffi-napi');
+const struct = require('ref-struct-di')(ref);
+
+let sum = 0;
+
+main();
+
+async function main() {
+    let time = 5000;
+
+    if (process.argv.length >= 3) {
+        time = parseFloat(process.argv[2]) * 1000;
+        if (Number.isNaN(time))
+            throw new Error('Not a valid number');
+        if (time < 0)
+            throw new Error('Time must be positive');
+    }
+
+    const lib = ffi.Library(process.platform == 'win32' ? 'msvcrt.dll' : null, {
+        srand: ['void', ['uint']],
+        rand: ['int', []]
+    });
+
+    lib.srand(42);
+
+    let start = performance.now();
+    let iterations = 0;
+
+    while (performance.now() - start < time) {
+        for (let i = 0; i < 1000000; i++)
+            sum += lib.rand();
+
+        iterations += 1000000;
+    }
+
+    time = performance.now() - start;
+    console.log(JSON.stringify({ iterations: iterations, time: Math.round(time) }));
+}
+

package/{benchmark → src/koffi/benchmark}/raylib_cc.cc

@@ -11,8 +11,8 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see https://www.gnu.org/licenses/.
 
-#include "../vendor/libcc/libcc.hh"
-#include "../vendor/raylib/src/raylib.h"
+#include "src/core/libcc/libcc.hh"
+#include "vendor/raylib/src/raylib.h"
 
 namespace RG {