Rename emscripten_main_browser_thread_id to emscripten_main_runtime_thread_id. NFC (#18872)

sbc100 · web-flow · commit f641d74ba51b · 2023-02-28T13:30:50.000-08:00
The better reflects that is actually being returned here.  In fact,
there may be no main browser thread at all, and we have never tracked
the thread ID of the main browser thread, only the main runtime
thread.

Use a macro to continue to support the old name, but mark is as
deprecated so folks will get a warning.

Also, update the corresponding
EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD macro.
diff --git a/emcc.py b/emcc.py
@@ -1682,7 +1682,7 @@ def setup_pthreads(target):
   settings.REQUIRED_EXPORTS += [
     'emscripten_dispatch_to_thread_',
     '_emscripten_thread_free_data',
-    'emscripten_main_browser_thread_id',
+    'emscripten_main_runtime_thread_id',
     'emscripten_main_thread_process_queued_calls',
     '_emscripten_run_in_main_runtime_thread_js',
     'emscripten_stack_set_limits',
diff --git a/src/library_html5.js b/src/library_html5.js
@@ -202,7 +202,7 @@ var LibraryHTML5 = {
 #if USE_PTHREADS
     getTargetThreadForEventCallback: function(targetThread) {
       switch (targetThread) {
-        case {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD') }}}: return 0; // The event callback for the current event should be called on the main browser thread. (0 == don't proxy)
+        case {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD') }}}: return 0; // The event callback for the current event should be called on the main browser thread. (0 == don't proxy)
         case {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD') }}}: return PThread.currentProxiedOperationCallerThread; // The event callback for the current event should be backproxied to the thread that is registering the event.
         default: return targetThread; // The event callback for the current event should be proxied to the given specific thread.
       }
@@ -2311,7 +2311,7 @@ var LibraryHTML5 = {
     if (typeof onbeforeunload == 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     // beforeunload callback can only be registered on the main browser thread, because the page will go away immediately after returning from the handler,
     // and there is no time to start proxying it anywhere.
-    if (targetThread !== {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD') }}}) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    if (targetThread !== {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD') }}}) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
     registerBeforeUnloadEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BEFOREUNLOAD') }}}, "beforeunload");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
diff --git a/src/library_pthread.js b/src/library_pthread.js
@@ -916,7 +916,6 @@ var LibraryPThread = {
 #endif
   },
 
-  __pthread_kill_js__deps: ['emscripten_main_browser_thread_id'],
   __pthread_kill_js: function(thread, signal) {
     if (signal === {{{ cDefine('SIGCANCEL') }}}) { // Used by pthread_cancel in musl
       if (!ENVIRONMENT_IS_PTHREAD) cancelThread(thread);
diff --git a/src/struct_info.json b/src/struct_info.json
@@ -738,7 +738,7 @@
             "EMSCRIPTEN_WEBGL_CONTEXT_PROXY_FALLBACK",
             "EMSCRIPTEN_WEBGL_CONTEXT_PROXY_ALWAYS",
 
-            "EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD",
+            "EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD",
             "EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD",
 
             "EMSCRIPTEN_DEVICE_MOTION_EVENT_SUPPORTS_ACCELERATION",
diff --git a/src/threadprofiler.js b/src/threadprofiler.js
@@ -33,7 +33,7 @@ var emscriptenThreadProfiler = {
   },
 
   dumpState: function dumpState() {
-    var mainThread = _emscripten_main_browser_thread_id();
+    var mainThread = _emscripten_main_runtime_thread_id();
 
     var threads = [mainThread];
     for (var i in PThread.pthreads) {
@@ -60,7 +60,7 @@ var emscriptenThreadProfiler = {
       return;
     }
     var str = '';
-    var mainThread = _emscripten_main_browser_thread_id();
+    var mainThread = _emscripten_main_runtime_thread_id();
 
     var threads = [mainThread];
     for (var i in PThread.pthreads) {
diff --git a/system/include/emscripten/html5.h b/system/include/emscripten/html5.h
@@ -434,9 +434,12 @@ EMSCRIPTEN_RESULT emscripten_get_element_css_size(const char *target, double *wi
 
 void emscripten_html5_remove_all_event_listeners(void);
 
-#define EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD ((pthread_t)0x1)
+#define EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD ((pthread_t)0x1)
 #define EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD ((pthread_t)0x2)
 
+// Legacy name for EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD
+#define EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD
+
 #define emscripten_set_keypress_callback(target, userData, useCapture, callback)              emscripten_set_keypress_callback_on_thread(             (target), (userData), (useCapture), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
 #define emscripten_set_keydown_callback(target, userData, useCapture, callback)               emscripten_set_keydown_callback_on_thread(              (target), (userData), (useCapture), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
 #define emscripten_set_keyup_callback(target, userData, useCapture, callback)                 emscripten_set_keyup_callback_on_thread(                (target), (userData), (useCapture), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
@@ -471,7 +474,7 @@ void emscripten_html5_remove_all_event_listeners(void);
 #define emscripten_set_gamepaddisconnected_callback(userData, useCapture, callback)           emscripten_set_gamepaddisconnected_callback_on_thread(            (userData), (useCapture), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
 #define emscripten_set_batterychargingchange_callback(userData, callback)                     emscripten_set_batterychargingchange_callback_on_thread(          (userData),               (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
 #define emscripten_set_batterylevelchange_callback(userData, callback)                        emscripten_set_batterylevelchange_callback_on_thread(             (userData),               (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
-#define emscripten_set_beforeunload_callback(userData, callback)                              emscripten_set_beforeunload_callback_on_thread(                   (userData),               (callback), EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD)
+#define emscripten_set_beforeunload_callback(userData, callback)                              emscripten_set_beforeunload_callback_on_thread(                   (userData),               (callback), EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD)
 
 long emscripten_request_animation_frame(EM_BOOL (*cb)(double time, void *userData), void *userData);
 void emscripten_cancel_animation_frame(long requestAnimationFrameId);
diff --git a/system/include/emscripten/threading.h b/system/include/emscripten/threading.h
@@ -218,10 +218,13 @@ int emscripten_dispatch_to_thread_async_(pthread_t target_thread,
   emscripten_dispatch_to_thread_async_(                                        \
     (target_thread), (sig), (void*)(func_ptr), (satellite), ##__VA_ARGS__)
 
-// Returns 1 if the current thread is the thread that hosts the Emscripten runtime.
+// Returns 1 if the current thread is the thread that hosts the Emscripten
+// runtime.
 int emscripten_is_main_runtime_thread(void);
 
-// Returns 1 if the current thread is the main browser thread.
+// Returns 1 if the current thread is the main browser thread.  In the case that
+// the emscripten module is run in a worker there may be no pthread for which
+// this returns 1.
 int emscripten_is_main_browser_thread(void);
 
 // A temporary workaround to issue
@@ -233,7 +236,11 @@ void emscripten_main_thread_process_queued_calls(void);
 
 void emscripten_current_thread_process_queued_calls(void);
 
-pthread_t emscripten_main_browser_thread_id(void);
+// Returns the thread ID of the thread that hosts the Emscripten runtime.
+pthread_t emscripten_main_runtime_thread_id(void);
+
+#define emscripten_main_browser_thread_id() emscripten_main_runtime_thread_id()
+#pragma clang deprecated(emscripten_main_browser_thread_id, "use emscripten_main_runtime_thread_id instead")
 
 // Synchronously sleeps the calling thread for the given number of milliseconds.
 // Note: Calling this on the main browser thread is _very_ _very_ bad for
diff --git a/system/lib/libc/dynlink.c b/system/lib/libc/dynlink.c
@@ -400,9 +400,8 @@ static void run_dlsync_async(em_proxying_ctx* ctx, void* arg) {
 static void dlsync() {
   // Call dlsync process.  This call will block until all threads are in sync.
   // This gets called after a shared library is loaded by a worker.
-  pthread_t main_thread = emscripten_main_browser_thread_id();
-  dbg("dlsync main=%p", main_thread);
-  if (pthread_self() == main_thread) {
+  dbg("dlsync main=%p", emscripten_main_runtime_thread_id());
+  if (emscripten_is_main_runtime_thread()) {
     // dlsync was called on the main thread.  In this case we have no choice by
     // to run the blocking version of emscripten_dlsync_threads.
     _emscripten_dlsync_threads();
@@ -411,7 +410,7 @@ static void dlsync() {
     // thread.
     em_proxying_queue* q = emscripten_proxy_get_system_queue();
     int success = emscripten_proxy_sync_with_ctx(
-      q, main_thread, run_dlsync_async, pthread_self());
+      q, emscripten_main_runtime_thread_id(), run_dlsync_async, pthread_self());
     assert(success);
   }
 }
diff --git a/system/lib/libc/musl/src/thread/pthread_cond_timedwait.c b/system/lib/libc/musl/src/thread/pthread_cond_timedwait.c
@@ -77,7 +77,7 @@ int __pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restri
 
 #ifdef __EMSCRIPTEN__
 	// TODO: Optimize this away in MINIMAL_RUNTIME.
-	if (pthread_self() == emscripten_main_browser_thread_id()) {
+	if (emscripten_is_main_browser_thread()) {
 		emscripten_check_blocking_allowed();
 	}
 #endif
diff --git a/system/lib/pthread/em_task_queue.c b/system/lib/pthread/em_task_queue.c
@@ -124,7 +124,7 @@ void em_task_queue_notify(em_task_queue* queue) {
   if (previous != NOTIFICATION_PENDING) {
     _emscripten_notify_task_queue(queue->thread,
                                   pthread_self(),
-                                  emscripten_main_browser_thread_id(),
+                                  emscripten_main_runtime_thread_id(),
                                   queue);
   }
 }
diff --git a/system/lib/pthread/library_pthread.c b/system/lib/pthread/library_pthread.c
@@ -352,14 +352,14 @@ EMSCRIPTEN_RESULT emscripten_wait_for_call_i(
 
 static struct pthread __main_pthread;
 
-pthread_t emscripten_main_browser_thread_id() {
+pthread_t emscripten_main_runtime_thread_id() {
   return &__main_pthread;
 }
 
 static pthread_t normalize_thread(pthread_t target_thread) {
   assert(target_thread);
-  if (target_thread == EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD) {
-    return emscripten_main_browser_thread_id();
+  if (target_thread == EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD) {
+    return emscripten_main_runtime_thread_id();
   }
   if (target_thread == EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD) {
     return pthread_self();
@@ -392,7 +392,7 @@ static int do_dispatch_to_thread(pthread_t target_thread,
 }
 
 void emscripten_async_run_in_main_thread(em_queued_call* call) {
-  do_dispatch_to_thread(emscripten_main_browser_thread_id(), call);
+  do_dispatch_to_thread(emscripten_main_runtime_thread_id(), call);
 }
 
 static void sync_run_in_main_thread(em_queued_call* call) {
diff --git a/system/lib/pthread/pthread_create.c b/system/lib/pthread/pthread_create.c
@@ -319,7 +319,7 @@ void _emscripten_thread_exit(void* result) {
 
   __tl_unlock();
 
-  if (self == emscripten_main_browser_thread_id()) {
+  if (emscripten_is_main_runtime_thread()) {
     exit(0);
     return;
   }
diff --git a/system/lib/pthread/pthread_kill.c b/system/lib/pthread/pthread_kill.c
@@ -16,7 +16,7 @@ int pthread_kill(pthread_t t, int sig) {
   if (sig < 0 || sig >= _NSIG) {
     return EINVAL;
   }
-  if (t == emscripten_main_browser_thread_id()) {
+  if (t == emscripten_main_runtime_thread_id()) {
     if (sig == 0) return 0; // signal == 0 is a no-op.
     return ESRCH;
   }
diff --git a/system/lib/pthread/pthread_self_stub.c b/system/lib/pthread/pthread_self_stub.c
@@ -20,7 +20,7 @@ static int dummy_getpid() {
 }
 weak_alias(dummy_getpid, __syscall_getpid);
 
-pthread_t emscripten_main_browser_thread_id() {
+pthread_t emscripten_main_runtime_thread_id() {
   return &__main_pthread;
 }
 
diff --git a/system/lib/websocket/websocket_to_posix_socket.c b/system/lib/websocket/websocket_to_posix_socket.c
@@ -216,7 +216,7 @@ EMSCRIPTEN_WEBSOCKET_T emscripten_init_websocket_to_posix_socket_bridge(const ch
   emscripten_websocket_init_create_attributes(&attr);
   attr.url = bridgeUrl;
   bridgeSocket = emscripten_websocket_new(&attr);
-  emscripten_websocket_set_onmessage_callback_on_thread(bridgeSocket, 0, bridge_socket_on_message, EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD);
+  emscripten_websocket_set_onmessage_callback_on_thread(bridgeSocket, 0, bridge_socket_on_message, EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD);
 
   pthread_mutex_unlock(&bridgeLock);
   return bridgeSocket;
diff --git a/test/html5_callbacks_on_calling_thread.c b/test/html5_callbacks_on_calling_thread.c
@@ -17,7 +17,13 @@ EM_BOOL mouse_callback(int eventType, const EmscriptenMouseEvent *e, void *userD
   static int once;
 
   void *threadId = pthread_self();
-  if (!once) printf("pthread_self()=%p, registeringThreadId=%p, mainRuntimeThreadId=%p, emscripten_main_browser_thread_id()=%p\n", threadId, registeringThreadId, mainRuntimeThreadId, emscripten_main_browser_thread_id());
+  if (!once)
+    printf("pthread_self()=%p, registeringThreadId=%p, mainRuntimeThreadId=%p, "
+           "emscripten_main_runtime_thread_id()=%p\n",
+           threadId,
+           registeringThreadId,
+           mainRuntimeThreadId,
+           emscripten_main_runtime_thread_id());
   printf("eventType: %d, mouseEvent: %p, userData: %p, screen: (%ld,%ld), client: (%ld,%ld),%s%s%s%s button: %hu, buttons: %hu, movement: (%ld,%ld), canvas: (%ld,%ld)\n",
     eventType, e, userData,
     e->screenX, e->screenY, e->clientX, e->clientY,
diff --git a/test/html5_event_callback_in_two_threads.c b/test/html5_event_callback_in_two_threads.c
@@ -99,14 +99,14 @@ EM_BOOL keyup_callback_on_application_main_thread(int eventType, const Emscripte
 
 int main()
 {
-  main_browser_thread_id = emscripten_main_browser_thread_id();
-  assert(main_browser_thread_id);
+  main_runtime_thread_id = emscripten_main_runtime_thread_id();
+  assert(main_runtime_thread_id);
   application_main_thread_id = (void*)pthread_self();
   assert(application_main_thread_id);
 
-  printf("Main browser thread ID: %p, application main thread ID: %p\n", main_browser_thread_id, application_main_thread_id);
+  printf("Main runtime thread ID: %p, application main thread ID: %p\n", main_runtime_thread_id, application_main_thread_id);
 
-  emscripten_set_keydown_callback_on_thread(0, 0, 1, keydown_callback_on_main_browser_thread, EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD);
+  emscripten_set_keydown_callback_on_thread(0, 0, 1, keydown_callback_on_main_browser_thread, EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD);
   emscripten_set_keypress_callback_on_thread(0, 0, 1, keypress_callback_on_application_main_thread, EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD);
   emscripten_set_keyup_callback_on_thread(0, 0, 1, keyup_callback_on_application_main_thread, EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD);
 
diff --git a/test/pthread/call_async.c b/test/pthread/call_async.c
@@ -25,13 +25,13 @@ int main() {
   assert(state == 0);
   // This dispatch_to_thread call will be synchronous since we are on the right
   // thread already.
-  int called_now = emscripten_dispatch_to_thread(emscripten_main_browser_thread_id(), EM_FUNC_SIG_V, &increment, 0);
+  int called_now = emscripten_dispatch_to_thread(emscripten_main_runtime_thread_id(), EM_FUNC_SIG_V, &increment, 0);
   assert(called_now);
   assert(state == 1);
   // This async call will actually be async.
-  emscripten_dispatch_to_thread_async(emscripten_main_browser_thread_id(), EM_FUNC_SIG_V, &increment, 0);
+  emscripten_dispatch_to_thread_async(emscripten_main_runtime_thread_id(), EM_FUNC_SIG_V, &increment, 0);
   assert(state == 1);
-  emscripten_dispatch_to_thread_async(emscripten_main_browser_thread_id(), EM_FUNC_SIG_V, &finish, 0);
+  emscripten_dispatch_to_thread_async(emscripten_main_runtime_thread_id(), EM_FUNC_SIG_V, &finish, 0);
   emscripten_exit_with_live_runtime();
   __builtin_trap();
 }
diff --git a/test/reference_struct_info.json b/test/reference_struct_info.json
@@ -186,7 +186,7 @@
         "EMSGSIZE": 35,
         "EMULTIHOP": 36,
         "EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD": 2,
-        "EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD": 1,
+        "EM_CALLBACK_THREAD_CONTEXT_MAIN_RUNTIME_THREAD": 1,
         "EM_FUNC_SIG_I": 536870912,
         "EM_FUNC_SIG_II": 570425344,
         "EM_FUNC_SIG_III": 603979776,
diff --git a/test/test_other.py b/test/test_other.py
@@ -13059,3 +13059,19 @@ def test_min_node_version(self):
     self.set_setting('MIN_NODE_VERSION', 210000)
     expected = 'This emscripten-generated code requires node v21.0.0 (detected v%s)' % node_version
     self.do_runf(test_file('hello_world.c'), expected, assert_returncode=NON_ZERO)
+
+  def test_deprecated_macros(self):
+    create_file('main.c', '''
+    #include <assert.h>
+    #include <stdio.h>
+    #include <emscripten/threading.h>
+
+    int main() {
+      printf("%d\\n", emscripten_main_browser_thread_id());
+      assert(emscripten_main_browser_thread_id());
+      return 0;
+    }
+    ''')
+    err = self.run_process([EMCC, 'main.c'], stderr=PIPE).stderr
+    expected = "warning: macro 'emscripten_main_browser_thread_id' has been marked as deprecated: use emscripten_main_runtime_thread_id instead [-Wdeprecated-pragma]"
+    self.assertContained(expected, err)

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ int __pthread_cond_timedwait(pthread_cond_t restrict c, pthread_mutex_t restri`
`77`	`77`
`78`	`78`	`#ifdef __EMSCRIPTEN__`
`79`	`79`	`// TODO: Optimize this away in MINIMAL_RUNTIME.`
`80`		`- if (pthread_self() == emscripten_main_browser_thread_id()) {`
	`80`	`+ if (emscripten_is_main_browser_thread()) {`
`81`	`81`	`emscripten_check_blocking_allowed();`
`82`	`82`	`}`
`83`	`83`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ void em_task_queue_notify(em_task_queue* queue) {`
`124`	`124`	`if (previous != NOTIFICATION_PENDING) {`
`125`	`125`	`_emscripten_notify_task_queue(queue->thread,`
`126`	`126`	`pthread_self(),`
`127`		`- emscripten_main_browser_thread_id(),`
	`127`	`+ emscripten_main_runtime_thread_id(),`
`128`	`128`	`queue);`
`129`	`129`	`}`
`130`	`130`	`}`