emnapi 1.2.0 → 1.3.0

package/include/node/uv.h

@@ -3,13 +3,21 @@
 
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 
-#include <stddef.h>
-#include "uv/unix.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#include <stddef.h>
+#include <stdint.h>
+
+/* Internal type, do not use. */
+struct uv__queue {
+  struct uv__queue* next;
+  struct uv__queue* prev;
+};
+
+#include "uv/unix.h"
+
 #define UV_EXTERN /* nothing */
 
 typedef enum {
@@ -29,6 +37,8 @@ typedef struct uv_work_s uv_work_t;
 typedef struct uv_handle_s uv_handle_t;
 typedef struct uv_async_s uv_async_t;
 
+typedef struct uv_metrics_s uv_metrics_t;
+
 typedef void (*uv_work_cb)(uv_work_t* req);
 typedef void (*uv_after_work_cb)(uv_work_t* req, int status);
 
@@ -40,10 +50,22 @@ struct uv_req_s {
   UV_REQ_FIELDS
 };
 
+typedef void* (*uv_malloc_func)(size_t size);
+typedef void* (*uv_realloc_func)(void* ptr, size_t size);
+typedef void* (*uv_calloc_func)(size_t count, size_t size);
+typedef void (*uv_free_func)(void* ptr);
+
 UV_EXTERN void uv_library_shutdown(void);
+
+UV_EXTERN int uv_replace_allocator(uv_malloc_func malloc_func,
+                                   uv_realloc_func realloc_func,
+                                   uv_calloc_func calloc_func,
+                                   uv_free_func free_func);
+
 UV_EXTERN uv_loop_t* uv_default_loop(void);
 UV_EXTERN int uv_loop_init(uv_loop_t* loop);
 UV_EXTERN int uv_loop_close(uv_loop_t* loop);
+UV_EXTERN uint64_t uv_hrtime(void);
 UV_EXTERN void uv_sleep(unsigned int msec);
 
 UV_EXTERN int uv_sem_init(uv_sem_t* sem, unsigned int value);
@@ -111,6 +133,12 @@ typedef void (*uv_async_cb)(uv_async_t* handle);
   uv_loop_t* loop;                                                            \
   uv_handle_type type;                                                        \
   uv_close_cb close_cb;                                                       \
+  struct uv__queue handle_queue;                                              \
+  union {                                                                     \
+    int fd;                                                                   \
+    void* reserved[4];                                                        \
+  } u;                                                                        \
+  UV_HANDLE_PRIVATE_FIELDS                                                    \
 
 struct uv_handle_s {
   UV_HANDLE_FIELDS
@@ -119,7 +147,7 @@ struct uv_handle_s {
 struct uv_async_s {
   UV_HANDLE_FIELDS
   uv_async_cb async_cb;
-  void* queue[2];
+  struct uv__queue queue;
   int pending;
 };
 
@@ -129,18 +157,33 @@ UV_EXTERN int uv_async_init(uv_loop_t*,
 UV_EXTERN int uv_async_send(uv_async_t* async);
 
 UV_EXTERN void uv_close(uv_handle_t* handle, uv_close_cb close_cb);
+UV_EXTERN int uv_is_closing(const uv_handle_t* handle);
+
+struct uv_metrics_s {
+  uint64_t loop_count;
+  uint64_t events;
+  uint64_t events_waiting;
+  /* private */
+  uint64_t* reserved[13];
+};
+
+UV_EXTERN int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics);
+UV_EXTERN uint64_t uv_metrics_idle_time(uv_loop_t* loop);
 
 struct uv_loop_s {
   void* data;
+  unsigned int active_handles;
+  struct uv__queue handle_queue;
   union {
     void* unused;
     unsigned int count;
   } active_reqs;
-  void* wq[2];
+  void* internal_fields;
 
+  struct uv__queue wq;
   uv_mutex_t wq_mutex;
   uv_async_t wq_async;
-  void* async_handles[2];
+  struct uv__queue async_handles;
   void* em_queue;
 };
 

package/package.json

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

package/src/async_cleanup_hook.c

@@ -101,7 +101,7 @@ _emnapi_ach_handle_delete(napi_async_cleanup_hook_handle handle) {
 }
 
 napi_status
-napi_add_async_cleanup_hook(napi_env env,
+napi_add_async_cleanup_hook(node_api_basic_env env,
                             napi_async_cleanup_hook hook,
                             void* arg,
                             napi_async_cleanup_hook_handle* remove_handle) {

package/src/async_work.c

@@ -198,7 +198,7 @@ napi_status napi_delete_async_work(napi_env env, napi_async_work work) {
 #endif
 }
 
-napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
+napi_status napi_queue_async_work(node_api_basic_env env, napi_async_work work) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
   CHECK_ARG(env, work);
@@ -220,7 +220,7 @@ napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
     }                                                                   \
   } while (0)
 
-napi_status napi_cancel_async_work(napi_env env, napi_async_work work) {
+napi_status napi_cancel_async_work(node_api_basic_env env, napi_async_work work) {
 #if EMNAPI_HAVE_THREADS
   CHECK_ENV(env);
   CHECK_ARG(env, work);

package/src/emnapi_internal.h

@@ -72,11 +72,11 @@ EXTERN_C_END
 
 EXTERN_C_START
 
-EMNAPI_INTERNAL_EXTERN napi_status napi_set_last_error(node_api_nogc_env env,
+EMNAPI_INTERNAL_EXTERN napi_status napi_set_last_error(node_api_basic_env env,
                                        napi_status error_code,
                                        uint32_t engine_error_code,
                                        void* engine_reserved);
-EMNAPI_INTERNAL_EXTERN napi_status napi_clear_last_error(node_api_nogc_env env);
+EMNAPI_INTERNAL_EXTERN napi_status napi_clear_last_error(node_api_basic_env env);
 
 #ifdef __EMSCRIPTEN__
 #if __EMSCRIPTEN_major__ * 10000 + __EMSCRIPTEN_minor__ * 100 + __EMSCRIPTEN_tiny__ >= 30114  // NOLINT

package/src/js_native_api.c

@@ -35,8 +35,9 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_get_last_error_info(napi_env env,
                                         void** engine_reserved);
 
 napi_status napi_get_last_error_info(
-    napi_env env, const napi_extended_error_info** result) {
+    node_api_basic_env basic_env, const napi_extended_error_info** result) {
   static napi_extended_error_info last_error;
+  napi_env env = (napi_env) basic_env;
   CHECK_ENV(env);
   CHECK_ARG(env, result);
 

package/src/node_api.c

@@ -1,7 +1,7 @@
 #include "node_api.h"
 #include "emnapi_internal.h"
 
-#if EMNAPI_HAVE_THREADS
+#if EMNAPI_HAVE_THREADS && !defined(EMNAPI_DISABLE_UV)
 #include "uv.h"
 #endif
 
@@ -12,7 +12,7 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_get_node_version(uint32_t* major,
                                      uint32_t* patch);
 
 napi_status
-napi_get_node_version(napi_env env,
+napi_get_node_version(node_api_basic_env env,
                       const napi_node_version** version) {
   CHECK_ENV(env);
   CHECK_ARG(env, version);
@@ -29,9 +29,9 @@ napi_get_node_version(napi_env env,
   return napi_clear_last_error(env);
 }
 
-napi_status napi_get_uv_event_loop(napi_env env,
+napi_status napi_get_uv_event_loop(node_api_basic_env env,
                                    struct uv_loop_s** loop) {
-#if EMNAPI_HAVE_THREADS
+#if EMNAPI_HAVE_THREADS && !defined(EMNAPI_DISABLE_UV)
   CHECK_ENV(env);
   CHECK_ARG(env, loop);
   // Though this is fake libuv loop
@@ -44,7 +44,7 @@ napi_status napi_get_uv_event_loop(napi_env env,
 
 EMNAPI_INTERNAL_EXTERN int _emnapi_get_filename(napi_env env, char* buf, int len);
 
-napi_status node_api_get_module_file_name(napi_env env,
+napi_status node_api_get_module_file_name(node_api_basic_env env,
                                           const char** result) {
   CHECK_ENV(env);
   CHECK_ARG(env, result);

package/src/threadsafe_function.c

@@ -5,9 +5,8 @@
 #include <stdatomic.h>
 #include <pthread.h>
 #include <errno.h>
-#include "uv/queue.h"
-
 #include "uv.h"
+#include "uv/queue.h"
 
 EXTERN_C_START
 
@@ -21,7 +20,7 @@ static const unsigned int kMaxIterationCount = 1000;
 
 struct data_queue_node {
   void* data;
-  void* q[2];
+  struct uv__queue q;
 };
 
 struct napi_threadsafe_function__ {
@@ -30,7 +29,7 @@ struct napi_threadsafe_function__ {
   pthread_mutex_t mutex;
   pthread_cond_t* cond;
   size_t queue_size;
-  void* queue[2];
+  struct uv__queue queue;
   uv_async_t async;
   size_t thread_count;
   bool is_closing;
@@ -92,7 +91,7 @@ _emnapi_tsfn_create(napi_env env,
   pthread_mutex_init(&ts_fn->mutex, NULL);
   ts_fn->cond = NULL;
   ts_fn->queue_size = 0;
-  QUEUE_INIT(&ts_fn->queue);
+  uv__queue_init(&ts_fn->queue);
   ts_fn->thread_count = initial_thread_count;
   ts_fn->is_closing = false;
   ts_fn->dispatch_state = kDispatchIdle;
@@ -125,13 +124,13 @@ static void _emnapi_tsfn_destroy(napi_threadsafe_function func) {
     func->cond = NULL;
   }
 
-  QUEUE* tmp;
+  struct uv__queue* tmp;
   struct data_queue_node* node;
-  QUEUE_FOREACH(tmp, &func->queue) {
-    node = QUEUE_DATA(tmp, struct data_queue_node, q);
+  uv__queue_foreach(tmp, &func->queue) {
+    node = uv__queue_data(tmp, struct data_queue_node, q);
     free(node);
   }
-  QUEUE_INIT(&func->queue);
+  uv__queue_init(&func->queue);
 
   if (func->ref != NULL) {
     EMNAPI_ASSERT_CALL(napi_delete_reference(func->env, func->ref));
@@ -187,14 +186,14 @@ static napi_status _emnapi_tsfn_init(napi_threadsafe_function func) {
 }
 
 static void _emnapi_tsfn_empty_queue_and_delete(napi_threadsafe_function func) {
-  while (!QUEUE_EMPTY(&func->queue)) {
-    QUEUE* q = QUEUE_HEAD(&func->queue);
-    struct data_queue_node* node = QUEUE_DATA(q, struct data_queue_node, q);
+  while (!uv__queue_empty(&func->queue)) {
+    struct uv__queue* q = uv__queue_head(&func->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);
 
-    QUEUE_REMOVE(q);
-    QUEUE_INIT(q);
+    uv__queue_remove(q);
+    uv__queue_init(q);
     func->queue_size--;
     free(node);
   }
@@ -295,10 +294,10 @@ static bool _emnapi_tsfn_dispatch_one(napi_threadsafe_function func) {
     } else {
       size_t size = func->queue_size;
       if (size > 0) {
-        QUEUE* q = QUEUE_HEAD(&func->queue);
-        struct data_queue_node* node = QUEUE_DATA(q, struct data_queue_node, q);
-        QUEUE_REMOVE(q);
-        QUEUE_INIT(q);
+        struct uv__queue* q = uv__queue_head(&func->queue);
+        struct data_queue_node* node = uv__queue_data(q, struct data_queue_node, q);
+        uv__queue_remove(q);
+        uv__queue_init(q);
         func->queue_size--;
         data = node->data;
         free(node);
@@ -519,7 +518,7 @@ napi_call_threadsafe_function(napi_threadsafe_function func,
       return napi_generic_failure;
     }
     queue_node->data = data;
-    QUEUE_INSERT_TAIL(&func->queue, &queue_node->q);
+    uv__queue_insert_tail(&func->queue, &queue_node->q);
     func->queue_size++;
     _emnapi_tsfn_send(func);
     pthread_mutex_unlock(&func->mutex);
@@ -584,7 +583,7 @@ napi_release_threadsafe_function(napi_threadsafe_function func,
 }
 
 napi_status
-napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func) {
+napi_unref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func) {
 #if EMNAPI_HAVE_THREADS
   if (func->async_ref) {
     EMNAPI_KEEPALIVE_POP();
@@ -598,7 +597,7 @@ napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func) {
 }
 
 napi_status
-napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func) {
+napi_ref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func) {
 #if EMNAPI_HAVE_THREADS
   if (!func->async_ref) {
     EMNAPI_KEEPALIVE_PUSH();

package/src/uv/queue.h

@@ -18,91 +18,73 @@
 
 #include <stddef.h>
 
-typedef void *QUEUE[2];
-
-/* Private macros. */
-#define QUEUE_NEXT(q)       (*(QUEUE **) &((*(q))[0]))
-#define QUEUE_PREV(q)       (*(QUEUE **) &((*(q))[1]))
-#define QUEUE_PREV_NEXT(q)  (QUEUE_NEXT(QUEUE_PREV(q)))
-#define QUEUE_NEXT_PREV(q)  (QUEUE_PREV(QUEUE_NEXT(q)))
-
-/* Public macros. */
-#define QUEUE_DATA(ptr, type, field)                                          \
-  ((type *) ((char *) (ptr) - offsetof(type, field)))
-
-/* Important note: mutating the list while QUEUE_FOREACH is
- * iterating over its elements results in undefined behavior.
- */
-#define QUEUE_FOREACH(q, h)                                                   \
-  for ((q) = QUEUE_NEXT(h); (q) != (h); (q) = QUEUE_NEXT(q))
-
-#define QUEUE_EMPTY(q)                                                        \
-  ((const QUEUE *) (q) == (const QUEUE *) QUEUE_NEXT(q))
-
-#define QUEUE_HEAD(q)                                                         \
-  (QUEUE_NEXT(q))
-
-#define QUEUE_INIT(q)                                                         \
-  do {                                                                        \
-    QUEUE_NEXT(q) = (q);                                                      \
-    QUEUE_PREV(q) = (q);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_ADD(h, n)                                                       \
-  do {                                                                        \
-    QUEUE_PREV_NEXT(h) = QUEUE_NEXT(n);                                       \
-    QUEUE_NEXT_PREV(n) = QUEUE_PREV(h);                                       \
-    QUEUE_PREV(h) = QUEUE_PREV(n);                                            \
-    QUEUE_PREV_NEXT(h) = (h);                                                 \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_SPLIT(h, q, n)                                                  \
-  do {                                                                        \
-    QUEUE_PREV(n) = QUEUE_PREV(h);                                            \
-    QUEUE_PREV_NEXT(n) = (n);                                                 \
-    QUEUE_NEXT(n) = (q);                                                      \
-    QUEUE_PREV(h) = QUEUE_PREV(q);                                            \
-    QUEUE_PREV_NEXT(h) = (h);                                                 \
-    QUEUE_PREV(q) = (n);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_MOVE(h, n)                                                      \
-  do {                                                                        \
-    if (QUEUE_EMPTY(h))                                                       \
-      QUEUE_INIT(n);                                                          \
-    else {                                                                    \
-      QUEUE* q = QUEUE_HEAD(h);                                               \
-      QUEUE_SPLIT(h, q, n);                                                   \
-    }                                                                         \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_INSERT_HEAD(h, q)                                               \
-  do {                                                                        \
-    QUEUE_NEXT(q) = QUEUE_NEXT(h);                                            \
-    QUEUE_PREV(q) = (h);                                                      \
-    QUEUE_NEXT_PREV(q) = (q);                                                 \
-    QUEUE_NEXT(h) = (q);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_INSERT_TAIL(h, q)                                               \
-  do {                                                                        \
-    QUEUE_NEXT(q) = (h);                                                      \
-    QUEUE_PREV(q) = QUEUE_PREV(h);                                            \
-    QUEUE_PREV_NEXT(q) = (q);                                                 \
-    QUEUE_PREV(h) = (q);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_REMOVE(q)                                                       \
-  do {                                                                        \
-    QUEUE_PREV_NEXT(q) = QUEUE_NEXT(q);                                       \
-    QUEUE_NEXT_PREV(q) = QUEUE_PREV(q);                                       \
-  }                                                                           \
-  while (0)
+#define uv__queue_data(pointer, type, field)                                  \
+  ((type*) ((char*) (pointer) - offsetof(type, field)))
+
+#define uv__queue_foreach(q, h)                                               \
+  for ((q) = (h)->next; (q) != (h); (q) = (q)->next)
+
+static inline void uv__queue_init(struct uv__queue* q) {
+  q->next = q;
+  q->prev = q;
+}
+
+static inline int uv__queue_empty(const struct uv__queue* q) {
+  return q == q->next;
+}
+
+static inline struct uv__queue* uv__queue_head(const struct uv__queue* q) {
+  return q->next;
+}
+
+static inline struct uv__queue* uv__queue_next(const struct uv__queue* q) {
+  return q->next;
+}
+
+static inline void uv__queue_add(struct uv__queue* h, struct uv__queue* n) {
+  h->prev->next = n->next;
+  n->next->prev = h->prev;
+  h->prev = n->prev;
+  h->prev->next = h;
+}
+
+static inline void uv__queue_split(struct uv__queue* h,
+                                   struct uv__queue* q,
+                                   struct uv__queue* n) {
+  n->prev = h->prev;
+  n->prev->next = n;
+  n->next = q;
+  h->prev = q->prev;
+  h->prev->next = h;
+  q->prev = n;
+}
+
+static inline void uv__queue_move(struct uv__queue* h, struct uv__queue* n) {
+  if (uv__queue_empty(h))
+    uv__queue_init(n);
+  else
+    uv__queue_split(h, h->next, n);
+}
+
+static inline void uv__queue_insert_head(struct uv__queue* h,
+                                         struct uv__queue* q) {
+  q->next = h->next;
+  q->prev = h;
+  q->next->prev = q;
+  h->next = q;
+}
+
+static inline void uv__queue_insert_tail(struct uv__queue* h,
+                                         struct uv__queue* q) {
+  q->next = h;
+  q->prev = h->prev;
+  q->prev->next = q;
+  h->prev = q;
+}
+
+static inline void uv__queue_remove(struct uv__queue* q) {
+  q->prev->next = q->next;
+  q->next->prev = q->prev;
+}
 
 #endif /* QUEUE_H_ */