emnapi 0.33.1 → 0.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "0.33.1",
+  "version": "0.35.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "devDependencies": {

package/src/malloc/dlmalloc/malloc.c

@@ -2859,7 +2859,7 @@ static size_t traverse_and_check(mstate m);
 #define treebin_at(M,i)     (&((M)->treebins[i]))
 
 /* assign tree index for size S to variable I. Use x86 asm if possible  */
-#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__) || defined(__wasm__))
 #define compute_tree_index(S, I)\
 {\
   unsigned int X = S >> TREEBIN_SHIFT;\
@@ -2962,7 +2962,7 @@ static size_t traverse_and_check(mstate m);
 
 /* index corresponding to given bit. Use x86 asm if possible */
 
-#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__) || defined(__wasm__))
 #define compute_bit2idx(X, I)\
 {\
   unsigned int J;\

package/src/thread/async_worker_create.c

@@ -0,0 +1,76 @@
+#include <stddef.h>
+#include <stdint.h>
+
+void* calloc(size_t n, size_t size);
+
+extern unsigned char __heap_base;
+extern unsigned char __data_end;
+extern unsigned char __global_base;
+extern __attribute__((__weak__)) unsigned char __stack_high;
+extern __attribute__((__weak__)) unsigned char __stack_low;
+
+#define ROUND_UP(x, ALIGNMENT) (((x)+ALIGNMENT-1)&-ALIGNMENT)
+#define STACK_ALIGN 16
+#define DEFAULT_STACK_MAX (8<<20)
+
+struct worker_args {
+  void* stack_base;
+  void* tls_base;
+};
+
+extern void __wasm_init_tls(void*);
+
+void* __copy_tls(unsigned char *mem) {
+	size_t tls_align = __builtin_wasm_tls_align();
+	volatile void* tls_base = __builtin_wasm_tls_base();
+	mem += tls_align;
+	mem -= (uintptr_t)mem & (tls_align-1);
+	__wasm_init_tls(mem);
+  	__asm__("local.get %0\n"
+			"global.set __tls_base\n"
+			:: "r"(tls_base));
+	return mem;
+}
+
+__attribute__((visibility("default")))
+void* emnapi_async_worker_create() {
+  size_t args_size = sizeof(struct worker_args);
+  size_t size = args_size;
+
+  size_t tls_size = __builtin_wasm_tls_size();
+
+  size_t tls_block_size = 0;
+  if (tls_size) {
+    size_t tls_align = __builtin_wasm_tls_align();
+    tls_block_size = ROUND_UP(tls_size + tls_align - 1, tls_align);
+    size += tls_block_size;
+  }
+
+  ptrdiff_t stack_size = 0;
+  if (&__stack_high) {
+		stack_size = &__stack_high - &__stack_low;
+  } else {
+		unsigned char *sp;
+		__asm__(
+			".globaltype __stack_pointer, i32\n"
+			"global.get __stack_pointer\n"
+			"local.set %0\n"
+			: "=r"(sp));
+		stack_size = sp > &__global_base ? &__heap_base - &__data_end : (ptrdiff_t)&__global_base;
+	}
+
+  stack_size = ROUND_UP(stack_size, STACK_ALIGN);
+  stack_size = stack_size < DEFAULT_STACK_MAX ? stack_size : DEFAULT_STACK_MAX;
+  size += stack_size;
+
+  void* block = calloc(1, size);
+  if (!block) return 0;
+
+  void* tls_base = tls_size ? __copy_tls(block + args_size) : 0;
+
+  struct worker_args* args = (struct worker_args*)block;
+
+  args->stack_base = block + args_size + tls_block_size + stack_size;
+  args->tls_base = tls_base;
+  return block;
+}

package/src/thread/async_worker_init.S

@@ -0,0 +1,33 @@
+#ifdef __wasm64__
+#define PTR i64
+#else
+#define PTR i32
+#endif
+
+  .text
+
+  .export_name  emnapi_async_worker_init, emnapi_async_worker_init
+
+  .globaltype  __stack_pointer, PTR
+  .globaltype  __tls_base, PTR
+
+  .hidden  emnapi_async_worker_init
+  .globl  emnapi_async_worker_init
+  .type  emnapi_async_worker_init,@function
+
+emnapi_async_worker_init:
+  .functype  emnapi_async_worker_init (PTR) -> ()
+
+  local.get   0
+  PTR.load    0
+  global.set  __stack_pointer
+
+  local.get   0
+#ifdef __wasm64__
+  PTR.load    8
+#else
+  PTR.load    4
+#endif
+  global.set  __tls_base
+
+  end_function

package/src/threadsafe_function.c

@@ -362,7 +362,7 @@ static void _emnapi_tsfn_send(napi_threadsafe_function func) {
   if ((current_state & kDispatchRunning) == kDispatchRunning) {
     return;
   }
-  uv_async_send(&func->async);
+  CHECK_EQ(0, uv_async_send(&func->async));
 }
 
 // only main thread
@@ -373,7 +373,7 @@ static void _emnapi_tsfn_dispatch(napi_threadsafe_function func) {
   // starvation. See `src/node_messaging.cc` for an inspiration.
   unsigned int iterations_left = kMaxIterationCount;
   while (has_more && --iterations_left != 0) {
-    func->dispatch_state = kDispatchRunning;
+    atomic_store(&func->dispatch_state, kDispatchRunning);
     has_more = _emnapi_tsfn_dispatch_one(func);
 
     // Send() was called while we were executing the JS function
@@ -409,7 +409,7 @@ napi_create_threadsafe_function(napi_env env,
                                 napi_threadsafe_function* result) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
-  // CHECK_ARG(env, async_resource_name);
+  CHECK_ARG(env, async_resource_name);
   RETURN_STATUS_IF_FALSE(env, initial_thread_count > 0, napi_invalid_arg);
   CHECK_ARG(env, result);
 
@@ -439,7 +439,6 @@ napi_create_threadsafe_function(napi_env env,
     if (status != napi_ok) return status;
   }
 
-  CHECK_ARG(env, async_resource_name);
   status = napi_coerce_to_string(env, async_resource_name, &resource_name);
   if (status != napi_ok) return status;
 

package/src/uv/threadpool.c

@@ -209,6 +209,7 @@ static void post(QUEUE* q, enum uv__work_kind kind) {
 //   nthreads = 0;
 // }
 
+EMNAPI_EXTERN int _emnapi_async_work_pool_size();
 
 static void init_threads(void) {
   unsigned int i;
@@ -223,9 +224,14 @@ static void init_threads(void) {
   nthreads = EMNAPI_WORKER_POOL_SIZE;
 #else
   nthreads = ARRAY_SIZE(default_threads);
-  val = getenv("UV_THREADPOOL_SIZE");
-  if (val != NULL)
-    nthreads = atoi(val);
+  int async_work_pool_size = _emnapi_async_work_pool_size();
+  if (async_work_pool_size > 0) {
+    nthreads = (unsigned int) async_work_pool_size;
+  } else {
+    val = getenv("UV_THREADPOOL_SIZE");
+    if (val != NULL)
+      nthreads = atoi(val);
+  }
 #endif
   if (nthreads == 0)
     nthreads = 1;