Make Node.js pthreads behavior in line with native (emscripten-core#19073)

By marking workers as weakly referenced. This corresponds to the
ideal scenario as mentioned in commit a9cbf47.

Author: kleisauke

ChangeLog.md

@@ -30,6 +30,7 @@ See docs/process.md for more on how version tagging works.
   completely removes the need for the `REVERSE_DEPS` settings which has now
   been deprecated. (#18905)
 - Bump the default minimum Firefox version from 65 to 68 (#19191).
+- Background pthreads no longer prevent a Node.js app from exiting. (#19073)
 
 3.1.36 - 04/16/23
 -----------------

src/library_pthread.js

@@ -211,11 +211,12 @@ var LibraryPThread = {
       // worker pool as an unused worker.
       worker.pthread_ptr = 0;
 
-#if ENVIRONMENT_MAY_BE_NODE
+#if ENVIRONMENT_MAY_BE_NODE && PROXY_TO_PTHREAD
       if (ENVIRONMENT_IS_NODE) {
-        // Once a pthread has finished and the worker becomes idle, mark it
-        // as weakly referenced so that its existence does not prevent Node.js
-        // from exiting.
+        // Once the proxied main thread has finished, mark it as weakly
+        // referenced so that its existence does not prevent Node.js from
+        // exiting.  This has no effect if the worker is already weakly
+        // referenced.
         worker.unref();
       }
 #endif
@@ -286,7 +287,7 @@ var LibraryPThread = {
           cancelThread(d['thread']);
         } else if (cmd === 'loaded') {
           worker.loaded = true;
-#if ENVIRONMENT_MAY_BE_NODE
+#if ENVIRONMENT_MAY_BE_NODE && PTHREAD_POOL_SIZE
           // Check that this worker doesn't have an associated pthread.
           if (ENVIRONMENT_IS_NODE && !worker.pthread_ptr) {
             // Once worker is loaded & idle, mark it as weakly referenced,
@@ -571,6 +572,19 @@ var LibraryPThread = {
     else postMessage({ 'cmd': 'cleanupThread', 'thread': thread });
   },
 
+  _emscripten_thread_set_strongref: function(thread) {
+    // Called when a thread needs to be strongly referenced.
+    // Currently only used for:
+    // - keeping the "main" thread alive in PROXY_TO_PTHREAD mode;
+    // - crashed threads that needs to propagate the uncaught exception 
+    //   back to the main thread.
+#if ENVIRONMENT_MAY_BE_NODE
+    if (ENVIRONMENT_IS_NODE) {
+      PThread.pthreads[thread].ref();
+    }
+#endif
+  },
+
   $cleanupThread: function(pthread_ptr) {
 #if PTHREADS_DEBUG
     dbg('cleanupThread: ' + ptrToString(pthread_ptr))
@@ -674,14 +688,16 @@ var LibraryPThread = {
     msg.moduleCanvasId = threadParams.moduleCanvasId;
     msg.offscreenCanvases = threadParams.offscreenCanvases;
 #endif
-    // Ask the worker to start executing its pthread entry point function.
 #if ENVIRONMENT_MAY_BE_NODE
     if (ENVIRONMENT_IS_NODE) {
-      // Mark worker as strongly referenced once we start executing a pthread,
-      // so that Node.js doesn't exit while the pthread is running.
-      worker.ref();
+      // Mark worker as weakly referenced once we start executing a pthread,
+      // so that its existence does not prevent Node.js from exiting.  This
+      // has no effect if the worker is already weakly referenced (e.g. if
+      // this worker was previously idle/unused).
+      worker.unref();
     }
 #endif
+    // Ask the worker to start executing its pthread entry point function.
     worker.postMessage(msg, threadParams.transferList);
     return 0;
   },

src/library_sigs.js

@@ -290,6 +290,7 @@ sigs = {
   _emscripten_set_offscreencanvas_size__sig: 'ipii',
   _emscripten_thread_exit_joinable__sig: 'vp',
   _emscripten_thread_mailbox_await__sig: 'vp',
+  _emscripten_thread_set_strongref__sig: 'vp',
   _emscripten_throw_longjmp__sig: 'v',
   _gmtime_js__sig: 'vpp',
   _localtime_js__sig: 'vpp',

system/lib/libc/crt1_proxy_main.c

@@ -13,6 +13,8 @@
 #include <emscripten/threading.h>
 #include <emscripten/eventloop.h>
 
+#include "threading_internal.h"
+
 static int _main_argc;
 static char** _main_argv;
 
@@ -49,5 +51,10 @@ EMSCRIPTEN_KEEPALIVE int _emscripten_proxy_main(int argc, char** argv) {
   pthread_t thread;
   int rc = pthread_create(&thread, &attr, _main_thread, NULL);
   pthread_attr_destroy(&attr);
+  if (rc == 0) {
+    // Mark the thread as strongly referenced, so that Node.js doesn't exit
+    // while the pthread is running.
+    _emscripten_thread_set_strongref(thread);
+  }
   return rc;
 }

system/lib/pthread/emscripten_yield.c

@@ -7,10 +7,10 @@
 #include "syscall.h"
 #include "threading_internal.h"
 
-static _Atomic bool thread_crashed = false;
+static _Atomic pthread_t crashed_thread_id = NULL;
 
 void _emscripten_thread_crashed() {
-  thread_crashed = true;
+  crashed_thread_id = pthread_self();
 }
 
 static void dummy(double now)
@@ -28,7 +28,11 @@ void _emscripten_yield(double now) {
   // allocate (or otherwise itself crash) so use a low level atomic primitive
   // for this signal.
   if (is_runtime_thread) {
-    if (thread_crashed) {
+    if (crashed_thread_id) {
+      // Mark the crashed thread as strongly referenced so that Node.js doesn't
+      // exit while the pthread is propagating the uncaught exception back to
+      // the main thread.
+      _emscripten_thread_set_strongref(crashed_thread_id);
       // Return the event loop so we can handle the message from the crashed
       // thread.
       emscripten_exit_with_live_runtime();

system/lib/pthread/threading_internal.h

@@ -118,6 +118,15 @@ void __emscripten_thread_cleanup(pthread_t thread);
 hidden void* _emscripten_tls_init(void);
 hidden void _emscripten_tls_free(void);
 
+// Marks the given thread as strongly referenced. This is used to prevent the
+// Node.js application from exiting as long as there are strongly referenced
+// threads still running. Normally you don't need to call this function, and
+// the pthread behaviour will match native in that background threads won't
+// keep runtime alive, but waiting for them via e.g. pthread_join will. 
+// However, this is useful for features like PROXY_TO_PTHREAD where we want to
+// keep running as long as the detached pthread is.
+void _emscripten_thread_set_strongref(pthread_t thread);
+
 // Checks certain structural invariants.  This allows us to detect when
 // already-freed threads are used in some APIs.  Technically this is undefined
 // behaviour, but we have a couple of places where we add these checks so that

test/core/pthread/test_pthread_weak_ref.c

@@ -0,0 +1,44 @@
+#include <assert.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <unistd.h>
+
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+bool running = false;
+
+void *worker_thread(void *arg) {
+  printf("worker_thread\n");
+
+  pthread_mutex_lock(&mutex);
+  running = true;
+  pthread_cond_signal(&cond);
+  pthread_mutex_unlock(&mutex);
+
+  // Infinite loop
+  while (1) {}
+
+  return NULL;
+}
+
+int main() {
+  pthread_t thread;
+
+  printf("main\n");
+  int rc = pthread_create(&thread, NULL, worker_thread, NULL);
+  assert(rc == 0);
+
+  pthread_mutex_lock(&mutex);
+
+  // Wait until the thread executes its entry point
+  while (!running) {
+    pthread_cond_wait(&cond, &mutex);
+  }
+
+  pthread_mutex_unlock(&mutex);
+
+  printf("done\n");
+  return 0;
+}

test/core/pthread/test_pthread_weak_ref.out

@@ -0,0 +1,3 @@
+main
+worker_thread
+done

test/other/metadce/test_metadce_minimal_pthreads.exports

@@ -4,7 +4,7 @@ C
 D
 E
 F
-p
+G
 q
 r
 s

test/other/metadce/test_metadce_minimal_pthreads.imports

@@ -13,3 +13,4 @@ a.l
 a.m
 a.n
 a.o
+a.p