emnapi 1.8.0 → 1.9.0

package/src/threadsafe_function.c

@@ -2,11 +2,7 @@
 #include "emnapi_internal.h"
 
 #if NAPI_VERSION >= 4 && EMNAPI_HAVE_THREADS
-#include <stdatomic.h>
-#include <pthread.h>
-#include <errno.h>
-#include "uv.h"
-#include "uv/queue.h"
+#include "threadsafe_function.h"
 
 EXTERN_C_START
 
@@ -23,33 +19,6 @@ struct data_queue_node {
   struct uv__queue q;
 };
 
-struct napi_threadsafe_function__ {
-  ASYNC_RESOURCE_FIELD
-  // These are variables protected by the mutex.
-  pthread_mutex_t mutex;
-  pthread_cond_t* cond;
-  size_t queue_size;
-  struct uv__queue queue;
-  uv_async_t async;
-  size_t thread_count;
-  bool is_closing;
-  atomic_uchar dispatch_state;
-
-  // These are variables set once, upon creation, and then never again, which
-  // means we don't need the mutex to read them.
-  void* context;
-  size_t max_queue_size;
-
-  // These are variables accessed only from the loop thread.
-  napi_ref ref;
-  napi_env env;
-  void* finalize_data;
-  napi_finalize finalize_cb;
-  napi_threadsafe_function_call_js call_js_cb;
-  bool handles_closing;
-  bool async_ref;
-};
-
 static void _emnapi_tsfn_default_call_js(napi_env env, napi_value cb, void* context, void* data) {
   if (!(env == NULL || cb == NULL)) {
     napi_value recv;
@@ -87,13 +56,14 @@ _emnapi_tsfn_create(napi_env env,
   napi_threadsafe_function ts_fn =
     (napi_threadsafe_function) calloc(1, sizeof(struct napi_threadsafe_function__));
   if (ts_fn == NULL) return NULL;
-  EMNAPI_ASYNC_RESOURCE_CTOR(env, async_resource, async_resource_name, (emnapi_async_resource*) ts_fn);
+  EMNAPI_ASYNC_RESOURCE_CTOR(env, async_resource, async_resource_name, (emnapi_async_resource*) &ts_fn->async_resource);
+  ts_fn->async_resource.is_some = true;
   pthread_mutex_init(&ts_fn->mutex, NULL);
   ts_fn->cond = NULL;
   ts_fn->queue_size = 0;
   uv__queue_init(&ts_fn->queue);
   ts_fn->thread_count = initial_thread_count;
-  ts_fn->is_closing = false;
+  ts_fn->state = napi_tsfn_state_open;
   ts_fn->dispatch_state = kDispatchIdle;
 
   ts_fn->context = context;
@@ -109,12 +79,29 @@ _emnapi_tsfn_create(napi_env env,
   EMNAPI_ASSERT_CALL(napi_add_env_cleanup_hook(env, _emnapi_tsfn_cleanup, ts_fn));
   _emnapi_env_ref(env);
 
-  EMNAPI_KEEPALIVE_PUSH();
-  _emnapi_ctx_increase_waiting_request_counter();
-  ts_fn->async_ref = true;
+  ts_fn->async_ref = 0;
   return ts_fn;
 }
 
+static void _emnapi_tsfn_release_resources(napi_threadsafe_function func) {
+  if (func->state != napi_tsfn_state_closed) {
+    func->state = napi_tsfn_state_closed;
+    if (func->ref != NULL) {
+      EMNAPI_ASSERT_CALL(napi_delete_reference(func->env, func->ref));
+      func->ref = NULL;
+    }
+    EMNAPI_ASYNC_RESOURCE_DTOR(func->env, (emnapi_async_resource*) &func->async_resource);
+    func->async_resource.is_some = false;
+    EMNAPI_ASSERT_CALL(napi_remove_env_cleanup_hook(func->env, _emnapi_tsfn_cleanup, func));
+    _emnapi_env_unref(func->env);
+    if (func->async_ref > 0) {
+      func->async_ref = 0;
+      EMNAPI_KEEPALIVE_POP();
+      _emnapi_ctx_decrease_waiting_request_counter();
+    }
+  }
+}
+
 static void _emnapi_tsfn_destroy(napi_threadsafe_function func) {
   if (func == NULL) return;
   pthread_mutex_destroy(&func->mutex);
@@ -131,20 +118,7 @@ static void _emnapi_tsfn_destroy(napi_threadsafe_function func) {
     free(node);
   }
   uv__queue_init(&func->queue);
-
-  if (func->ref != NULL) {
-    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) {
-    EMNAPI_KEEPALIVE_POP();
-    _emnapi_ctx_decrease_waiting_request_counter();
-    func->async_ref = false;
-  }
+  _emnapi_tsfn_release_resources(func);
 
   free(func);
 }
@@ -165,8 +139,12 @@ static void _emnapi_tsfn_async_cb(uv_async_t* data) {
 // only main thread
 static napi_status _emnapi_tsfn_init(napi_threadsafe_function func) {
   uv_loop_t* loop = uv_default_loop();
+  bool should_delete = true;
   if (uv_async_init(loop, &func->async, _emnapi_tsfn_async_cb) == 0) {
     int r;
+    func->async_ref = 1;
+    EMNAPI_KEEPALIVE_PUSH();
+    _emnapi_ctx_increase_waiting_request_counter();
     if (func->max_queue_size > 0) {
       func->cond = (pthread_cond_t*) malloc(sizeof(pthread_cond_t));
       if (func->cond != NULL) {
@@ -181,23 +159,44 @@ static napi_status _emnapi_tsfn_init(napi_threadsafe_function func) {
       return napi_ok;
     }
     uv_close((uv_handle_t*) &func->async, _emnapi_tsfn_do_destroy);
+    should_delete = false;
+  }
+  if (should_delete) {
+    _emnapi_tsfn_destroy(func);
   }
-  _emnapi_tsfn_destroy(func);
   return napi_generic_failure;
 }
 
-static void _emnapi_tsfn_empty_queue_and_delete(napi_threadsafe_function func) {
-  while (!uv__queue_empty(&func->queue)) {
-    struct uv__queue* q = uv__queue_head(&func->queue);
+static void _emnapi_tsfn_empty_queue(napi_threadsafe_function func) {
+  struct uv__queue drain_queue;
+  uv__queue_init(&drain_queue);
+  pthread_mutex_lock(&func->mutex);
+  uv__queue_move(&func->queue, &drain_queue);
+  uv__queue_init(&func->queue);
+  func->queue_size = 0;
+  pthread_mutex_unlock(&func->mutex);
+
+  while (!uv__queue_empty(&drain_queue)) {
+    struct uv__queue* q = uv__queue_head(&drain_queue);
     struct data_queue_node* node = uv__queue_data(q, struct data_queue_node, q);
 
     func->call_js_cb(NULL, NULL, func->context, node->data);
 
     uv__queue_remove(q);
     uv__queue_init(q);
-    func->queue_size--;
     free(node);
   }
+}
+
+static void _emnapi_tsfn_maybe_delete(napi_threadsafe_function func) {
+  pthread_mutex_lock(&func->mutex);
+  if (func->thread_count > 0) {
+    _emnapi_tsfn_release_resources(func);
+    pthread_mutex_unlock(&func->mutex);
+    return;
+  } else {
+    pthread_mutex_unlock(&func->mutex);
+  }
   _emnapi_tsfn_destroy(func);
 }
 
@@ -211,24 +210,25 @@ 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_open_handle_scope();
+  _emnapi_tsfn_empty_queue(func);
   if (func->finalize_cb) {
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
-      EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->resource_, &resource));
-      EMNAPI_ASSERT_CALL(napi_create_function(func->env, NULL, 0, _emnapi_tsfn_finalize_in_callback_scope, func, &cb));
+      EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->async_resource.resource_, &resource));
+      EMNAPI_ASSERT_CALL(_emnapi_create_function(func->env, NULL, 0, _emnapi_tsfn_finalize_in_callback_scope, func, &cb));
       _emnapi_node_make_callback(func->env,
                                 resource,
                                 cb,
                                 NULL,
                                 0,
-                                func->async_context_.async_id,
-                                func->async_context_.trigger_async_id,
+                                func->async_resource.async_context_.async_id,
+                                func->async_resource.async_context_.trigger_async_id,
                                 NULL);
     } else {
       _emnapi_call_finalizer(0, func->env, func->finalize_cb, func->finalize_data, func->context);
     }
   }
-  _emnapi_tsfn_empty_queue_and_delete(func);
+  _emnapi_tsfn_maybe_delete(func);
   _emnapi_close_handle_scope(scope);
 }
 
@@ -244,13 +244,14 @@ static void _emnapi_tsfn_close_handles_and_maybe_delete(
 
   if (set_closing) {
     pthread_mutex_lock(&func->mutex);
-    func->is_closing = true;
+    func->state = napi_tsfn_state_closing;
     if (func->max_queue_size > 0) {
       pthread_cond_signal(func->cond);
     }
     pthread_mutex_unlock(&func->mutex);
   }
   if (func->handles_closing) {
+    EMNAPI_ASSERT_CALL(napi_close_handle_scope(func->env, scope));
     return;
   }
   func->handles_closing = true;
@@ -289,9 +290,7 @@ static bool _emnapi_tsfn_dispatch_one(napi_threadsafe_function func) {
   {
     pthread_mutex_lock(&func->mutex);
 
-    if (func->is_closing) {
-      _emnapi_tsfn_close_handles_and_maybe_delete(func, false);
-    } else {
+    if (func->state == napi_tsfn_state_open) {
       size_t size = func->queue_size;
       if (size > 0) {
         struct uv__queue* q = uv__queue_head(&func->queue);
@@ -310,7 +309,7 @@ static bool _emnapi_tsfn_dispatch_one(napi_threadsafe_function func) {
 
       if (size == 0) {
         if (func->thread_count == 0) {
-          func->is_closing = true;
+          func->state = napi_tsfn_state_closing;
           if (func->max_queue_size > 0) {
             pthread_cond_signal(func->cond);
           }
@@ -319,6 +318,8 @@ static bool _emnapi_tsfn_dispatch_one(napi_threadsafe_function func) {
       } else {
         has_more = true;
       }
+    } else {
+      _emnapi_tsfn_close_handles_and_maybe_delete(func, false);
     }
     pthread_mutex_unlock(&func->mutex);
   }
@@ -335,15 +336,15 @@ static bool _emnapi_tsfn_dispatch_one(napi_threadsafe_function func) {
 
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
-      EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->resource_, &resource));
-      EMNAPI_ASSERT_CALL(napi_create_function(func->env, NULL, 0, _emnapi_tsfn_call_js_cb_in_callback_scope, jscb_data, &cb));
+      EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->async_resource.resource_, &resource));
+      EMNAPI_ASSERT_CALL(_emnapi_create_function(func->env, NULL, 0, _emnapi_tsfn_call_js_cb_in_callback_scope, jscb_data, &cb));
       _emnapi_node_make_callback(func->env,
                                 resource,
                                 cb,
                                 NULL,
                                 0,
-                                func->async_context_.async_id,
-                                func->async_context_.trigger_async_id,
+                                func->async_resource.async_context_.async_id,
+                                func->async_resource.async_context_.trigger_async_id,
                                 NULL);
     } else {
       _emnapi_callback_into_module(0, func->env, _emnapi_tsfn_call_js_cb, jscb_data, 1);
@@ -494,7 +495,7 @@ napi_call_threadsafe_function(napi_threadsafe_function func,
 
   while (func->queue_size >= func->max_queue_size &&
       func->max_queue_size > 0 &&
-      !func->is_closing) {
+      func->state == napi_tsfn_state_open) {
     if (mode == napi_tsfn_nonblocking) {
       pthread_mutex_unlock(&func->mutex);
       return napi_queue_full;
@@ -502,16 +503,7 @@ napi_call_threadsafe_function(napi_threadsafe_function func,
     pthread_cond_wait(func->cond, &func->mutex);
   }
 
-  if (func->is_closing) {
-    if (func->thread_count == 0) {
-      pthread_mutex_unlock(&func->mutex);
-      return napi_invalid_arg;
-    } else {
-      func->thread_count--;
-      pthread_mutex_unlock(&func->mutex);
-      return napi_closing;
-    }
-  } else {
+  if (func->state == napi_tsfn_state_open) {
     struct data_queue_node* queue_node = (struct data_queue_node*) malloc(sizeof(struct data_queue_node));
     if (queue_node == NULL) {
       pthread_mutex_unlock(&func->mutex);
@@ -524,6 +516,20 @@ napi_call_threadsafe_function(napi_threadsafe_function func,
     pthread_mutex_unlock(&func->mutex);
     return napi_ok;
   }
+
+  if (func->thread_count == 0) {
+    pthread_mutex_unlock(&func->mutex);
+    return napi_invalid_arg;
+  } 
+  func->thread_count--;
+
+  if (!(func->state == napi_tsfn_state_closed && func->thread_count == 0)) {
+    pthread_mutex_unlock(&func->mutex);
+    return napi_closing;
+  }
+  pthread_mutex_unlock(&func->mutex);
+  _emnapi_tsfn_destroy(func);
+  return napi_closing;
 #else
   return napi_generic_failure;
 #endif
@@ -535,15 +541,14 @@ napi_acquire_threadsafe_function(napi_threadsafe_function func) {
   CHECK_NOT_NULL(func);
   pthread_mutex_lock(&func->mutex);
 
-  if (func->is_closing) {
+  if (func->state == napi_tsfn_state_open) {
+    func->thread_count++;
     pthread_mutex_unlock(&func->mutex);
-    return napi_closing;
+    return napi_ok;
   }
 
-  func->thread_count++;
-
   pthread_mutex_unlock(&func->mutex);
-  return napi_ok;
+  return napi_closing;
 #else
   return napi_generic_failure;
 #endif
@@ -564,9 +569,11 @@ napi_release_threadsafe_function(napi_threadsafe_function func,
   func->thread_count--;
 
   if (func->thread_count == 0 || mode == napi_tsfn_abort) {
-    if (!func->is_closing) {
-      func->is_closing = (mode == napi_tsfn_abort);
-      if (func->is_closing && func->max_queue_size > 0) {
+    if (func->state == napi_tsfn_state_open) {
+      if (mode == napi_tsfn_abort) {
+        func->state = napi_tsfn_state_closing;
+      }
+      if (func->state == napi_tsfn_state_closing && func->max_queue_size > 0) {
         pthread_cond_signal(func->cond);
       }
 
@@ -574,7 +581,12 @@ napi_release_threadsafe_function(napi_threadsafe_function func,
     }
   }
 
+  if (!(func->state == napi_tsfn_state_closed && func->thread_count == 0)) {
+    pthread_mutex_unlock(&func->mutex);
+    return napi_ok;
+  }
   pthread_mutex_unlock(&func->mutex);
+  _emnapi_tsfn_destroy(func);
 
   return napi_ok;
 #else
@@ -585,10 +597,13 @@ napi_release_threadsafe_function(napi_threadsafe_function func,
 napi_status
 napi_unref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func) {
 #if EMNAPI_HAVE_THREADS
-  if (func->async_ref) {
-    EMNAPI_KEEPALIVE_POP();
-    _emnapi_ctx_decrease_waiting_request_counter();
-    func->async_ref = false;
+  CHECK_NOT_NULL(func);
+  if (func->async_ref > 0) {
+    func->async_ref--;
+    if (func->async_ref == 0) {
+      EMNAPI_KEEPALIVE_POP();
+      _emnapi_ctx_decrease_waiting_request_counter();
+    }
   }
   return napi_ok;
 #else
@@ -599,11 +614,12 @@ napi_unref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function
 napi_status
 napi_ref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func) {
 #if EMNAPI_HAVE_THREADS
+  CHECK_NOT_NULL(func);
   if (!func->async_ref) {
     EMNAPI_KEEPALIVE_PUSH();
     _emnapi_ctx_increase_waiting_request_counter();
-    func->async_ref = true;
   }
+  func->async_ref++;
   return napi_ok;
 #else
   return napi_generic_failure;

package/src/threadsafe_function.h

@@ -0,0 +1,51 @@
+#ifndef SRC_THREADSAFE_FUNCTION_H_
+#define SRC_THREADSAFE_FUNCTION_H_
+
+#include "node_api.h"
+#include "emnapi_internal.h"
+
+#include <stdatomic.h>
+#include <pthread.h>
+#include <errno.h>
+#include "uv.h"
+#include "uv/queue.h"
+
+typedef struct optional_async_resource {
+  ASYNC_RESOURCE_FIELD
+  bool is_some;
+} optional_async_resource;
+
+typedef enum napi_threadsafe_function_state {
+  napi_tsfn_state_open,
+  napi_tsfn_state_closing,
+  napi_tsfn_state_closed
+} napi_threadsafe_function_state;
+
+struct napi_threadsafe_function__ {
+  optional_async_resource async_resource;
+  // These are variables protected by the mutex.
+  pthread_mutex_t mutex;
+  pthread_cond_t* cond;
+  size_t queue_size;
+  struct uv__queue queue;
+  uv_async_t async;
+  size_t thread_count;
+  napi_threadsafe_function_state state;
+  atomic_uchar dispatch_state;
+
+  // These are variables set once, upon creation, and then never again, which
+  // means we don't need the mutex to read them.
+  void* context;
+  size_t max_queue_size;
+
+  // These are variables accessed only from the loop thread.
+  napi_ref ref;
+  napi_env env;
+  void* finalize_data;
+  napi_finalize finalize_cb;
+  napi_threadsafe_function_call_js call_js_cb;
+  bool handles_closing;
+  unsigned int async_ref;
+};
+
+#endif

package/src/uv/uv-common.c

@@ -1,7 +1,8 @@
+#include <stddef.h>
+
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 
 #include <errno.h>
-#include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include "uv-common.h"
@@ -183,4 +184,11 @@ uint64_t uv_metrics_idle_time(uv_loop_t* loop) {
   return idle_time;
 }
 
+#else
+
+typedef struct uv_loop_s uv_loop_t;
+uv_loop_t* uv_default_loop(void) {
+  return NULL;
+}
+
 #endif

package/src/wasi_wait.c

@@ -6,6 +6,8 @@
 #include <stdio.h>
 #include "emnapi_internal.h"
 
+EMNAPI_INTERNAL_EXTERN void _emnapi_worker_ref(pthread_t pid);
+
 struct __pthread {
   unsigned char _[32];
   volatile int cancel;
@@ -28,6 +30,7 @@ void emnapi_thread_crashed() {
 
 void _emnapi_yield() {
   if (crashed_thread_id) {
+    _emnapi_worker_ref(crashed_thread_id);
     _emnapi_runtime_keepalive_push();
     _emnapi_unwind();
   }