emnapi 1.4.5 → 1.5.0

package/CMakeLists.txt

@@ -44,6 +44,7 @@ set(ENAPI_BASIC_SRC
   "${CMAKE_CURRENT_SOURCE_DIR}/src/node_api.c"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/async_cleanup_hook.c"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/async_context.c"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/wasi_wait.c"
 )
 set(EMNAPI_THREADS_SRC
   "${CMAKE_CURRENT_SOURCE_DIR}/src/async_work.c"
@@ -70,6 +71,10 @@ set(EMNAPI_BASIC_TARGET_NAME "emnapi-basic")
 set(EMNAPI_BASIC_MT_TARGET_NAME "emnapi-basic-mt")
 set(EMNAPI_TARGET_NAME "emnapi")
 set(EMNAPI_MT_TARGET_NAME "emnapi-mt")
+
+set(EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME "emnapi-basic-napi-rs-mt")
+set(EMNAPI_NAPI_RS_MT_TARGET_NAME "emnapi-napi-rs-mt")
+
 set(DLMALLOC_TARGET_NAME "dlmalloc")
 set(DLMALLOC_MT_TARGET_NAME "dlmalloc-mt")
 set(EMMALLOC_TARGET_NAME "emmalloc")
@@ -155,6 +160,31 @@ else()
   set(EMNAPI_BUILD_BASIC_MT OFF)
 endif()
 
+if(IS_WASM32_WASIP1_THREADS)
+  set(EMNAPI_BUILD_FOR_NAPI_RS ON)
+else()
+  set(EMNAPI_BUILD_FOR_NAPI_RS OFF)
+endif()
+
+if(EMNAPI_BUILD_FOR_NAPI_RS)
+  add_library(${EMNAPI_NAPI_RS_MT_TARGET_NAME} STATIC ${EMNAPI_SRC} ${UV_SRC})
+  target_include_directories(${EMNAPI_NAPI_RS_MT_TARGET_NAME} PUBLIC ${EMNAPI_INCLUDE})
+  target_compile_definitions(${EMNAPI_NAPI_RS_MT_TARGET_NAME}
+    PUBLIC ${EMNAPI_DEFINES} "NAPI_EXTERN=__attribute__((__import_module__(\"env\")))"
+  )
+
+  add_library(${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME} STATIC
+    ${ENAPI_BASIC_SRC}
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/thread/async_worker_create.c"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/thread/async_worker_init.S"
+  )
+  target_include_directories(${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME} PUBLIC ${EMNAPI_INCLUDE})
+  target_compile_definitions(${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME}
+    PUBLIC ${EMNAPI_DEFINES} "NAPI_EXTERN=__attribute__((__import_module__(\"env\")))"
+    PRIVATE "EMNAPI_DISABLE_UV"
+  )
+endif()
+
 if(EMNAPI_BUILD_BASIC_MT)
   add_library(${EMNAPI_BASIC_MT_TARGET_NAME} STATIC
     ${ENAPI_BASIC_SRC}
@@ -222,6 +252,10 @@ if(LIB_ARCH)
   if(EMNAPI_BUILD_BASIC_MT)
     install(TARGETS ${EMNAPI_BASIC_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
   endif()
+  if(EMNAPI_BUILD_FOR_NAPI_RS)
+    install(TARGETS ${EMNAPI_NAPI_RS_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+    install(TARGETS ${EMNAPI_BASIC_NAPI_RS_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+  endif()
   if(IS_WASM32)
     install(TARGETS ${DLMALLOC_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
     install(TARGETS ${DLMALLOC_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")

package/README.md

@@ -816,8 +816,9 @@ Now emnapi has 3 implementations of async work and 2 implementations of TSFN:
 There are some limitations on browser about wasi-libc's pthread implementation, for example
 `pthread_mutex_lock` may call `__builtin_wasm_memory_atomic_wait32`(`memory.atomic.wait32`)
 which is disallowed in browser JS main thread. While Emscripten's pthread implementation
-has considered usage in browser. If you need to run your addon with multithreaded features on browser,
-we recommend you use Emscripten A & D, or bare wasm32 C & E.
+has considered usage in browser. This issue can be solved by upgrading `wasi-sdk` to v26+
+and emnapi v1.5.0+ then pass `--export=emnapi_thread_crashed` to the linker. If you need to
+run your addon with multithreaded features, we recommend you use A & D or C & E.
 
 Note: For browsers, all the multithreaded features relying on Web Workers (Emscripten pthread also relying on Web Workers)
 require cross-origin isolation to enable `SharedArrayBuffer`. You can make a page cross-origin isolated
@@ -879,6 +880,7 @@ elseif(CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads")
     "-Wl,--export-if-defined=node_api_module_get_api_version_v1"
     "-Wl,--export=malloc"
     "-Wl,--export=free"
+    "-Wl,--export=emnapi_thread_crashed"
     "-Wl,--import-undefined"
     "-Wl,--export-table"
   )

package/common.gypi

@@ -308,6 +308,7 @@
               'src/async_cleanup_hook.c',
               'src/async_context.c',
               'src/async_work.c',
+              'src/wasi_wait.c',
               'src/threadsafe_function.c',
               'src/uv/uv-common.c',
               'src/uv/threadpool.c',
@@ -370,6 +371,16 @@
                       ]
                     },
                   }],
+                  ['OS == "wasi"', {
+                    'ldflags': [
+                      '-Wl,--export=emnapi_thread_crashed',
+                    ],
+                    'xcode_settings': {
+                      'OTHER_LDFLAGS': [
+                        '-Wl,--export=emnapi_thread_crashed',
+                      ],
+                    },
+                  }],
                   ['OS != "wasi"', {
                     'defines': [
                       'PAGESIZE=65536'

package/dist/library_napi.js

@@ -61,10 +61,13 @@ function emnapiInit(options) {
         });
     }
     catch (err) {
+        if (err !== 'unwind') {
+            throw err;
+        }
+    }
+    finally {
         emnapiCtx.closeScope(envObject, scope);
-        throw err;
     }
-    emnapiCtx.closeScope(envObject, scope);
     emnapiModule.loaded = true;
     delete emnapiModule.envObject;
     return emnapiModule.exports;
@@ -75,7 +78,6 @@ function emnapiInit(options) {
 function __emnapi_async_work_pool_size() {
     return Math.abs(emnapiAsyncWorkPoolSize);
 }
-/* eslint-disable @typescript-eslint/indent */
 /**
  * @__sig ipiip
  */
@@ -180,6 +182,31 @@ function __emnapi_ctx_increase_waiting_request_counter() {
 function __emnapi_ctx_decrease_waiting_request_counter() {
     emnapiCtx.decreaseWaitingRequestCounter();
 }
+/**
+ * @__sig i
+ */
+function __emnapi_is_main_runtime_thread() {
+    return ENVIRONMENT_IS_PTHREAD ? 0 : 1;
+}
+/**
+ * @__sig i
+ */
+function __emnapi_is_main_browser_thread() {
+    return (typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE) ? 1 : 0;
+}
+/**
+ * @__sig v
+ */
+function __emnapi_unwind() {
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw 'unwind';
+}
+/**
+ * @__sig d
+ */
+function __emnapi_get_now() {
+    return performance.timeOrigin + performance.now();
+}
 function emnapiSetValueI64(result, numberValue) {
     var tempDouble;
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -190,6 +217,20 @@ function emnapiSetValueI64(result, numberValue) {
     {{{ makeSetValue('result', 0, 'tempI64[0]', 'i32') }}};
     {{{ makeSetValue('result', 4, 'tempI64[1]', 'i32') }}};
 }
+/**
+ * @__deps $emnapiCtx
+ * @__sig p
+ */
+function __emnapi_open_handle_scope() {
+    return emnapiCtx.openScope().id;
+}
+/**
+ * @__deps $emnapiCtx
+ * @__sig vp
+ */
+function __emnapi_close_handle_scope(_scope) {
+    return emnapiCtx.closeScope();
+}
 /* eslint-disable eqeqeq */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/indent */
@@ -6655,6 +6696,9 @@ function _napi_get_version(env, result) {
     _emnapi_callback_into_module: __emnapi_callback_into_module,
     _emnapi_callback_into_module__deps: ["$emnapiCtx"],
     _emnapi_callback_into_module__sig: "vipppi",
+    _emnapi_close_handle_scope: __emnapi_close_handle_scope,
+    _emnapi_close_handle_scope__deps: ["$emnapiCtx", "$emnapiCtx"],
+    _emnapi_close_handle_scope__sig: "vp",
     _emnapi_ctx_decrease_waiting_request_counter: __emnapi_ctx_decrease_waiting_request_counter,
     _emnapi_ctx_decrease_waiting_request_counter__deps: ["$emnapiCtx"],
     _emnapi_ctx_decrease_waiting_request_counter__sig: "v",
@@ -6681,6 +6725,12 @@ function _napi_get_version(env, result) {
     _emnapi_get_last_error_info__sig: "vpppp",
     _emnapi_get_node_version: __emnapi_get_node_version,
     _emnapi_get_node_version__sig: "vppp",
+    _emnapi_get_now: __emnapi_get_now,
+    _emnapi_get_now__sig: "d",
+    _emnapi_is_main_browser_thread: __emnapi_is_main_browser_thread,
+    _emnapi_is_main_browser_thread__sig: "i",
+    _emnapi_is_main_runtime_thread: __emnapi_is_main_runtime_thread,
+    _emnapi_is_main_runtime_thread__sig: "i",
     _emnapi_node_emit_async_destroy: __emnapi_node_emit_async_destroy,
     _emnapi_node_emit_async_destroy__deps: ["$emnapiNodeBinding"],
     _emnapi_node_emit_async_destroy__sig: "vdd",
@@ -6690,12 +6740,17 @@ function _napi_get_version(env, result) {
     _emnapi_node_make_callback: __emnapi_node_make_callback,
     _emnapi_node_make_callback__deps: ["$emnapiNodeBinding", "$emnapiCtx"],
     _emnapi_node_make_callback__sig: "ipppppddp",
+    _emnapi_open_handle_scope: __emnapi_open_handle_scope,
+    _emnapi_open_handle_scope__deps: ["$emnapiCtx", "$emnapiCtx"],
+    _emnapi_open_handle_scope__sig: "p",
     _emnapi_runtime_keepalive_pop: __emnapi_runtime_keepalive_pop,
     _emnapi_runtime_keepalive_pop__deps: ["$runtimeKeepalivePop"],
     _emnapi_runtime_keepalive_pop__sig: "v",
     _emnapi_runtime_keepalive_push: __emnapi_runtime_keepalive_push,
     _emnapi_runtime_keepalive_push__deps: ["$runtimeKeepalivePush"],
     _emnapi_runtime_keepalive_push__sig: "v",
+    _emnapi_unwind: __emnapi_unwind,
+    _emnapi_unwind__sig: "v",
     _emnapi_worker_unref: __emnapi_worker_unref,
     _emnapi_worker_unref__deps: ["$PThread"],
     _emnapi_worker_unref__sig: "vp",

package/emnapi.gyp

@@ -55,6 +55,7 @@
         'src/node_api.c',
         'src/async_cleanup_hook.c',
         'src/async_context.c',
+        'src/wasi_wait.c',
       ],
       'link_settings': {
         'target_conditions': [
@@ -88,6 +89,22 @@
             ]
           },
         }],
+        ['OS == "wasi"', {
+          'link_settings': {
+            'target_conditions': [
+              ['_type == "executable"', {
+                'ldflags': [
+                  '-Wl,--export=emnapi_thread_crashed',
+                ],
+                'xcode_settings': {
+                  'OTHER_LDFLAGS': [
+                    '-Wl,--export=emnapi_thread_crashed',
+                  ],
+                },
+              }],
+            ]
+          },
+        }],
       ]
     },
     {
@@ -98,6 +115,7 @@
         'src/node_api.c',
         'src/async_cleanup_hook.c',
         'src/async_context.c',
+        'src/wasi_wait.c',
 
         'src/uv/uv-common.c',
         'src/uv/threadpool.c',

package/include/node/emnapi.h

@@ -6,8 +6,8 @@
 #include "emnapi_common.h"
 
 #define EMNAPI_MAJOR_VERSION 1
-#define EMNAPI_MINOR_VERSION 4
-#define EMNAPI_PATCH_VERSION 5
+#define EMNAPI_MINOR_VERSION 5
+#define EMNAPI_PATCH_VERSION 0
 
 typedef enum {
   emnapi_runtime,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "1.4.5",
+  "version": "1.5.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "gypfile": false,

package/src/emnapi_internal.h

@@ -98,11 +98,18 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_pop();
 #define EMNAPI_KEEPALIVE_POP _emnapi_runtime_keepalive_pop
 #endif
 
+EMNAPI_INTERNAL_EXTERN napi_handle_scope _emnapi_open_handle_scope();
+EMNAPI_INTERNAL_EXTERN void _emnapi_close_handle_scope(napi_handle_scope scope);
 EMNAPI_INTERNAL_EXTERN void _emnapi_env_ref(napi_env env);
 EMNAPI_INTERNAL_EXTERN void _emnapi_env_unref(napi_env env);
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_increase_waiting_request_counter();
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_decrease_waiting_request_counter();
 
+EMNAPI_INTERNAL_EXTERN int _emnapi_is_main_browser_thread();
+EMNAPI_INTERNAL_EXTERN int _emnapi_is_main_runtime_thread();
+EMNAPI_INTERNAL_EXTERN double _emnapi_get_now();
+EMNAPI_INTERNAL_EXTERN void _emnapi_unwind();
+
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 #define EMNAPI_HAVE_THREADS 1
 #else

package/src/threadsafe_function.c

@@ -136,6 +136,8 @@ static void _emnapi_tsfn_destroy(napi_threadsafe_function func) {
     EMNAPI_ASSERT_CALL(napi_delete_reference(func->env, func->ref));
   }
 
+  EMNAPI_ASYNC_RESOURCE_DTOR(func->env, (emnapi_async_resource*) func);
+
   EMNAPI_ASSERT_CALL(napi_remove_env_cleanup_hook(func->env, _emnapi_tsfn_cleanup, func));
   _emnapi_env_unref(func->env);
   if (func->async_ref) {
@@ -144,7 +146,6 @@ static void _emnapi_tsfn_destroy(napi_threadsafe_function func) {
     func->async_ref = false;
   }
 
-  EMNAPI_ASYNC_RESOURCE_DTOR(func->env, (emnapi_async_resource*) func);
   free(func);
 }
 
@@ -209,8 +210,7 @@ static napi_value _emnapi_tsfn_finalize_in_callback_scope(napi_env env, napi_cal
 }
 
 static void _emnapi_tsfn_finalize(napi_threadsafe_function func) {
-  napi_handle_scope scope;
-  EMNAPI_ASSERT_CALL(napi_open_handle_scope(func->env, &scope));
+  napi_handle_scope scope = _emnapi_open_handle_scope();
   if (func->finalize_cb) {
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
@@ -229,7 +229,7 @@ static void _emnapi_tsfn_finalize(napi_threadsafe_function func) {
     }
   }
   _emnapi_tsfn_empty_queue_and_delete(func);
-  EMNAPI_ASSERT_CALL(napi_close_handle_scope(func->env, scope));
+  _emnapi_close_handle_scope(scope);
 }
 
 static void _emnapi_tsfn_do_finalize(uv_handle_t* data) {

package/src/wasi_wait.c

@@ -0,0 +1,106 @@
+#if defined(__wasi__)
+
+#include <time.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include "emnapi_internal.h"
+
+struct __pthread {
+  unsigned char _[32];
+  volatile int cancel;
+  volatile unsigned char canceldisable, cancelasync;
+	unsigned char tsd_used:1;
+	unsigned char dlerror_flag:1;
+  unsigned char __[68];
+};
+
+#define INFINITY __builtin_inff()
+
+int __wasilibc_futex_wait_atomic_wait(volatile void *addr, int op, int val, int64_t max_wait_ns);
+
+static _Atomic pthread_t crashed_thread_id = NULL;
+
+__attribute__((visibility("default")))
+void emnapi_thread_crashed() {
+  crashed_thread_id = pthread_self();
+}
+
+void _emnapi_yield() {
+  if (crashed_thread_id) {
+    _emnapi_runtime_keepalive_push();
+    _emnapi_unwind();
+  }
+}
+
+static int _emnapi_wait_main_browser_thread(int is_runtime_thread, volatile void *addr, int op, int val, double max_wait_ms) {
+  double now = _emnapi_get_now();
+  double end = now + max_wait_ms;
+
+  while (1) {
+    now = _emnapi_get_now();
+    if (now >= end) {
+      return -ETIMEDOUT;
+    }
+
+    if (is_runtime_thread) {
+      _emnapi_yield();
+    }
+
+    if (__c11_atomic_load((_Atomic int *)addr, __ATOMIC_SEQ_CST) != val) {
+      break;
+    }
+  }
+
+  return 0;
+}
+
+int _emnapi_wait(int is_runtime_thread, volatile void *addr, int op, int val, double max_wait_ms) {
+  if (is_runtime_thread) {
+    _emnapi_yield();
+  }
+
+  // https://github.com/WebAssembly/wasi-libc/blob/3f7eb4c7d6ede4dde3c4bffa6ed14e8d656fe93f/libc-top-half/musl/src/thread/wasm32/__wasilibc_busywait.c#L42
+  if (!_emnapi_is_main_browser_thread()) {
+    int64_t max_wait_ns = -1;
+    if (max_wait_ms != INFINITY) {
+      max_wait_ns = (int64_t)(max_wait_ms*1000*1000);
+    }
+    return __wasilibc_futex_wait_atomic_wait(addr, op, val, max_wait_ns);
+  }
+
+  return _emnapi_wait_main_browser_thread(is_runtime_thread, addr, op, val, max_wait_ms);
+}
+
+int __wasilibc_futex_wait_maybe_busy(volatile void *addr, int op, int val, int64_t max_wait_ns) {
+  // https://github.com/emscripten-core/emscripten/blob/89ce854a99238d04116a3d9b5afe241eec90c6c3/system/lib/libc/musl/src/thread/__timedwait.c#L60
+  int r = 0;
+  double msecsToSleep = max_wait_ns >= 0 ? (max_wait_ns / 1000000.0) : INFINITY;
+  int is_runtime_thread = _emnapi_is_main_runtime_thread();
+	double max_ms_slice_to_sleep = is_runtime_thread ? 1 : 100;
+
+  if (is_runtime_thread ||
+	    pthread_self()->canceldisable != PTHREAD_CANCEL_DISABLE ||
+	    pthread_self()->cancelasync) {
+    double sleepUntilTime = _emnapi_get_now() + msecsToSleep;
+		do {
+      if (pthread_self()->cancel) {
+				pthread_testcancel();
+				return ECANCELED;
+			}
+			msecsToSleep = sleepUntilTime - _emnapi_get_now();
+			if (msecsToSleep <= 0) {
+				r = ETIMEDOUT;
+				break;
+			}
+			if (msecsToSleep > max_ms_slice_to_sleep)
+				msecsToSleep = max_ms_slice_to_sleep;
+			r = -_emnapi_wait(is_runtime_thread, (void*)addr, op, val, msecsToSleep);
+		} while (r == ETIMEDOUT);
+  } else {
+    r = -_emnapi_wait(is_runtime_thread, (void*)addr, op, val, msecsToSleep);
+  }
+  return r;
+}
+
+#endif