Enable gettid() under WASM_WORKERS (#26472)

This change doesn't look very useful but as followup to this (and
combined with #26468) this should allow us to enable more internal musl
locking code that currently depends on `pthread_self()->tid`.

Author: sbc100

src/lib/libwasm_worker.js

@@ -65,7 +65,16 @@
 
 addToLibrary({
   $_wasmWorkers: {},
+#if PTHREADS
+  // When the build contains both pthreads and Wasm Workers, offset the
+  // Wasm Worker ID space to avoid collisions with pthread TIDs (which start
+  // at 42). We use `1 << 30` since it's ~1/2 way through `pid_t` space,
+  // essentially giving pthreads the first 1/2 of the range and wasm workers the
+  // second half.
+  $_wasmWorkersID: {{{ 1 << 30 }}},
+#else
   $_wasmWorkersID: 1,
+#endif
 
   // Starting up a Wasm Worker is an asynchronous operation, hence if the parent
   // thread performs any postMessage()-based wasm function calls to the

system/lib/libc/musl/src/linux/gettid.c

@@ -2,7 +2,30 @@
 #include <unistd.h>
 #include "pthread_impl.h"
 
+#ifdef __EMSCRIPTEN_WASM_WORKERS__
+#include <emscripten/wasm_worker.h>
+#elif defined(__EMSCRIPTEN_PTHREADS__)
+weak int emscripten_wasm_worker_self_id();
+#endif
+
+#if defined(__EMSCRIPTEN_WASM_WORKERS__) && defined(__EMSCRIPTEN_PTHREADS__)
+#error "this file should be compiled with either wasm workers or pthreads but not both"
+#endif
+
 pid_t gettid(void)
 {
+#ifdef __EMSCRIPTEN_WASM_WORKERS__
+	// Offset the worker ID by 1 so we never return 0 from this function.
+	return emscripten_wasm_worker_self_id() + 1;
+#else
+#if defined(__EMSCRIPTEN_PTHREADS__)
+	// The pthread-variant of libc can also be used alongside wasm workers.
+	// We detect that via a weak reference to the self_id function.
+	if (emscripten_wasm_worker_self_id) {
+		pid_t rtn = emscripten_wasm_worker_self_id();
+		if (rtn) return rtn;
+	}
+#endif
 	return __pthread_self()->tid;
+#endif
 }

test/test_browser.py

@@ -5076,7 +5076,7 @@ def test_wasm_worker_malloc(self):
   # Tests Wasm Worker+pthreads simultaneously
   @also_with_minimal_runtime
   def test_wasm_worker_and_pthreads(self):
-    self.btest('wasm_worker/wasm_worker_and_pthread.c', expected='0', cflags=['-sWASM_WORKERS', '-pthread'])
+    self.btest('wasm_worker/wasm_worker_and_pthread.c', expected='0', cflags=['-sWASM_WORKERS', '-pthread', '-sPTHREAD_POOL_SIZE=1'])
 
   # Tests emscripten_wasm_worker_self_id() function
   @also_with_minimal_runtime

test/wasm_worker/lock_waitinf_acquire.c

@@ -4,6 +4,9 @@
 #include <emscripten/threading.h>
 #include <stdlib.h>
 
+#define _GNU_SOURCE
+#include <unistd.h> // for gettid
+
 // This test can be run under pthreads *or* Wasm Workers
 #ifdef __EMSCRIPTEN_PTHREADS__
 #include <pthread.h>
@@ -13,10 +16,7 @@
 #include <emscripten/wasm_worker.h>
 #else
 // When WASM_WORKERS is not defined we create dummy/fake version of
-// emscripten_wasm_worker_self_id and emscripten_wasm_worker_sleep.
-#define _GNU_SOURCE
-#include <unistd.h>
-int emscripten_wasm_worker_self_id() { return gettid(); }
+// emscripten_wasm_worker_sleep.
 void emscripten_wasm_worker_sleep(int64_t nsecs) {
   emscripten_thread_sleep(nsecs / 1000000);
 }
@@ -35,7 +35,7 @@ volatile int sharedState1 = 1;
 volatile int numWorkersAlive = NUM_THREADS;
 
 void test_ended() {
-  emscripten_outf("Worker %d last thread to finish. Reporting test end with sharedState0=%d, sharedState1=%d", emscripten_wasm_worker_self_id(), sharedState0, sharedState1);
+  emscripten_outf("Worker %d last thread to finish. Reporting test end with sharedState0=%d, sharedState1=%d", gettid(), sharedState0, sharedState1);
   assert(sharedState0 == sharedState1 + 1 || sharedState1 == sharedState0 + 1);
   assert(sharedState0 == 4000);
   emscripten_out("done");
@@ -47,7 +47,7 @@ void test_ended() {
 }
 
 void worker_main() {
-  emscripten_outf("Worker %d running...", emscripten_wasm_worker_self_id());
+  emscripten_outf("Worker %d running...", gettid());
   // Create contention on the lock from each thread, and stress the shared state
   // in a racy way that would show a breakage if the lock is not watertight.
   for (int i = 0; i < 1000; ++i) {
@@ -67,7 +67,7 @@ void worker_main() {
     emscripten_lock_release(&lock);
   }
 
-  emscripten_outf("Worker %d finished.", emscripten_wasm_worker_self_id());
+  emscripten_outf("Worker %d finished.", gettid());
 
   // Are we the last thread to finish? If so, test has ended.
   uint32_t v = emscripten_atomic_sub_u32((void*)&numWorkersAlive, 1);

test/wasm_worker/wasm_worker_and_pthread.c

@@ -4,8 +4,12 @@
 #include <emscripten/threading.h>
 #include <emscripten/console.h>
 #include <assert.h>
+#define _GNU_SOURCE // for gettid
+#include <unistd.h>
 
-volatile int pthread_ran = 0;
+_Atomic pid_t main_tid = 0;
+_Atomic pid_t pthread_tid = 0;
+_Atomic pid_t worker_tid = 0;
 
 EM_JS(int, am_i_pthread, (), {
   return ENVIRONMENT_IS_PTHREAD;
@@ -16,32 +20,37 @@ EM_JS(int, am_i_wasm_worker, (), {
 });
 
 void *thread_main(void *arg) {
-  emscripten_out("hello from pthread!");
+  pthread_tid = gettid();
+  emscripten_outf("hello from pthread! (tid=%d)", pthread_tid);
+  assert(pthread_tid && pthread_tid > main_tid);
   assert(am_i_pthread());
   assert(!am_i_wasm_worker());
   assert(!emscripten_current_thread_is_wasm_worker());
   assert(emscripten_wasm_worker_self_id() == 0);
-  pthread_ran = 1;
   return 0;
 }
 
 void worker_main() {
-  emscripten_out("hello from wasm worker!");
+  worker_tid = gettid();
+  emscripten_outf("hello from wasm worker! (tid=%d)", worker_tid);
+  assert(worker_tid && worker_tid > pthread_tid);
   assert(!am_i_pthread());
   assert(am_i_wasm_worker());
   assert(emscripten_current_thread_is_wasm_worker());
   assert(emscripten_wasm_worker_self_id() != 0);
 
-  while(!emscripten_atomic_cas_u32((void*)&pthread_ran, 0, 1))
-    emscripten_wasm_worker_sleep(10);
 #ifdef REPORT_RESULT
   REPORT_RESULT(0);
 #endif
 }
 
 int main() {
+  main_tid = gettid();
+  emscripten_outf("in main (tid=%d)", main_tid);
+  assert(main_tid > 0);
   pthread_t thread;
   pthread_create(&thread, NULL, thread_main, NULL);
+  pthread_join(thread, NULL);
 
   emscripten_wasm_worker_t worker = emscripten_malloc_wasm_worker(/*stack size: */1024);
   emscripten_wasm_worker_post_function_v(worker, worker_main);