simplified

Author: hedwigz

src/library_pthread.js

@@ -893,7 +893,7 @@ var LibraryPThread = {
   $proxyToMainThreadPtr: (...args) => BigInt(proxyToMainThread(...args)),
 #endif
 
-  $proxyToMainThread__deps: ['$stackSave', '$stackRestore', '$stackAlloc', '_emscripten_run_on_main_thread_js', ...i53ConversionDeps],
+  $proxyToMainThread__deps: ['$stackSave', '$stackRestore', '$stackAlloc', '_emscripten_run_on_main_thread_js', '_emscripten_await_on_main_thread_js', ...i53ConversionDeps],
   $proxyToMainThread__docs: '/** @type{function(number, (number|boolean), ...number)} */',
   $proxyToMainThread: (funcIndex, emAsmAddr, sync, asyncAwait, ...callArgs) => {
     // EM_ASM proxying is done by passing a pointer to the address of the EM_ASM
@@ -933,7 +933,12 @@ var LibraryPThread = {
       HEAPF64[b + i] = arg;
 #endif
     }
-    var rtn = __emscripten_run_on_main_thread_js(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync, asyncAwait);
+    var rtn;
+    if (asyncAwait) {
+      rtn = __emscripten_await_on_main_thread_js(funcIndex, emAsmAddr, serializedNumCallArgs, args);
+    } else {
+      rtn = __emscripten_run_on_main_thread_js(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync);
+    }
     stackRestore(sp);
     return rtn;
   },

system/lib/pthread/proxying.c

@@ -402,38 +402,17 @@ int emscripten_proxy_sync_with_ctx(em_proxying_queue* q,
   return ret;
 }
 
-int emscripten_proxy_async_await_with_ctx(em_proxying_queue* q,
-                                   pthread_t target_thread,
-                                   void (*func)(em_proxying_ctx*, void*),
-                                   void* arg, proxied_js_func_t* f) {
-  assert(!pthread_equal(target_thread, pthread_self()) &&
-         "Cannot synchronously wait for work proxied to the current thread");
-  em_proxying_ctx ctx;
-  em_proxying_ctx_init_sync(&ctx, func, arg);
-  f->ctx = &ctx;
-  if (!do_proxy(q, target_thread, (task){call_with_ctx, cancel_ctx, &ctx})) {
-    em_proxying_ctx_deinit(&ctx);
-    return 0;
-  }
-  pthread_mutex_lock(&ctx.sync.mutex);
-  while (ctx.sync.state == PENDING) {
-    pthread_cond_wait(&ctx.sync.cond, &ctx.sync.mutex);
-  }
-  pthread_mutex_unlock(&ctx.sync.mutex);
-  int ret = ctx.sync.state == DONE;
-  em_proxying_ctx_deinit(&ctx);
-  return ret;
-}
-
 // Helper for signaling the end of the task after the user function returns.
 static void call_then_finish_task(em_proxying_ctx* ctx, void* arg) {
   task* t = arg;
   t->func(t->arg);
   emscripten_proxy_finish(ctx);
 }
 
-static void call_task(em_proxying_ctx* ctx, void* arg) {
+static void call_proxied_js_task_with_ctx(em_proxying_ctx* ctx, void* arg) {
   task* t = arg;
+  proxied_js_func_t* p = t->arg;
+  p->ctx = ctx;
   t->func(t->arg);
 }
 
@@ -446,15 +425,6 @@ int emscripten_proxy_sync(em_proxying_queue* q,
     q, target_thread, call_then_finish_task, &t);
 }
 
-int emscripten_proxy_async_await(em_proxying_queue* q,
-                          pthread_t target_thread,
-                          void (*func)(void*),
-                          proxied_js_func_t* f) {
-  task t = {.func = func, .arg = (void*)f};
-  return emscripten_proxy_async_await_with_ctx(
-    q, target_thread, call_task, &t, f);
-}
-
 static int do_proxy_callback(em_proxying_queue* q,
                              pthread_t target_thread,
                              void (*func)(em_proxying_ctx* ctx, void*),
@@ -635,25 +605,18 @@ em_promise_t emscripten_proxy_promise(em_proxying_queue* q,
 static void run_js_func(void* arg) {
   proxied_js_func_t* f = (proxied_js_func_t*)arg;
   f->result = _emscripten_receive_on_main_thread_js(
-    f->funcIndex, f->emAsmAddr, f->callingThread, f->numArgs, f->argBuffer, NULL);
+    f->funcIndex, f->emAsmAddr, f->callingThread, f->numArgs, f->argBuffer, f->ctx);
   if (f->owned) {
     free(f->argBuffer);
     free(f);
   }
 }
 
-static void run_js_async_await(void* arg) {
-  proxied_js_func_t* f = (proxied_js_func_t*)arg;
-  f->result = _emscripten_receive_on_main_thread_js(
-    f->funcIndex, f->emAsmAddr, f->callingThread, f->numArgs, f->argBuffer, (void*)f->ctx);
-}
-
 double _emscripten_run_on_main_thread_js(int func_index,
                                          void* em_asm_addr,
                                          int num_args,
                                          double* buffer,
-                                         int sync,
-                                         int asyncAwait) {
+                                         int sync) {
   proxied_js_func_t f = {
     .funcIndex = func_index,
     .emAsmAddr = em_asm_addr,
@@ -666,15 +629,8 @@ double _emscripten_run_on_main_thread_js(int func_index,
   em_proxying_queue* q = emscripten_proxy_get_system_queue();
   pthread_t target = emscripten_main_runtime_thread_id();
 
-  // make sure it is not the case that sync==false and asyncAwait==true
-  assert(!(sync == 0 && asyncAwait == 1) && "asyncAwait cannot be true if sync is false");
   if (sync) {
-    if (asyncAwait) {
-      if (!emscripten_proxy_async_await(q, target, run_js_async_await, &f)) {
-        assert(false && "emscripten_proxy_promise failed");
-        return 0;
-      }
-    } else if (!emscripten_proxy_sync(q, target, run_js_func, &f)) {
+    if (!emscripten_proxy_sync(q, target, run_js_func, &f)) {
       assert(false && "emscripten_proxy_sync failed");
       return 0;
     }
@@ -696,6 +652,30 @@ double _emscripten_run_on_main_thread_js(int func_index,
   return 0;
 }
 
+double _emscripten_await_on_main_thread_js(int func_index,
+                                           void* em_asm_addr,
+                                           int num_args,
+                                           double* buffer) {
+  em_proxying_queue* q = emscripten_proxy_get_system_queue();
+  pthread_t target = emscripten_main_runtime_thread_id();
+
+  proxied_js_func_t f = {
+    .funcIndex = func_index,
+    .emAsmAddr = em_asm_addr,
+    .callingThread = pthread_self(),
+    .numArgs = num_args,
+    .argBuffer = buffer,
+    .owned = false,
+  };
+  task t = {.func = run_js_func, .arg = &f};
+
+  if (!emscripten_proxy_sync_with_ctx(q, target, call_proxied_js_task_with_ctx, &t)) {
+    assert(false && "emscripten_proxy_sync_with_ctx failed");
+    return 0;
+  }
+  return f.result;
+}
+
 void _emscripten_proxy_promise_finish(em_proxying_ctx* ctx, void* res) {
   task* t = (task*)ctx->arg;
   proxied_js_func_t* func = (proxied_js_func_t*)t->arg;

tools/emscripten.py

@@ -1064,6 +1064,7 @@ def create_pointer_conversion_wrappers(metadata):
     '_wasmfs_read_file': 'pp',
     '__dl_seterr': '_pp',
     '_emscripten_run_on_main_thread_js': '__p_p_',
+    '_emscripten_await_on_main_thread_js': '__p_p_',
     '_emscripten_proxy_promise_finish': 'pp',
     '_emscripten_proxy_execute_task_queue': '_p',
     '_emscripten_thread_exit': '_p',

tools/link.py

@@ -502,6 +502,7 @@ def setup_pthreads():
     'emscripten_main_runtime_thread_id',
     'emscripten_main_thread_process_queued_calls',
     '_emscripten_run_on_main_thread_js',
+    '_emscripten_await_on_main_thread_js',
     '_emscripten_proxy_promise_finish',
     'emscripten_stack_set_limits',
   ]