awaitable inlined js

hedwigz · hedwigz · commit f02fff26338c · 2025-02-08T22:26:28.000+02:00
diff --git a/src/jsifier.mjs b/src/jsifier.mjs
@@ -357,7 +357,7 @@ function(${args}) {
             return `
 ${async_}function(${args}) {
 if (ENVIRONMENT_IS_PTHREAD)
-  return ${proxyFunc}(${proxiedFunctionTable.length}, 0, ${+sync}${args ? ', ' : ''}${args});
+  return ${proxyFunc}(${proxiedFunctionTable.length}, 0, ${+sync}, 0${args ? ', ' : ''}${args});
 ${body}
 }\n`;
           });
diff --git a/src/lib/libcore.js b/src/lib/libcore.js
@@ -1594,12 +1594,13 @@ addToLibrary({
     return runEmAsmFunction(code, sigPtr, argbuf);
   },
 
+  $runMainThreadEmAsm__docs: '/** @param {number=} asyncAwait */',
   $runMainThreadEmAsm__deps: ['$readEmAsmArgs',
 #if PTHREADS
     '$proxyToMainThread'
 #endif
   ],
-  $runMainThreadEmAsm: (emAsmAddr, sigPtr, argbuf, sync) => {
+  $runMainThreadEmAsm: (emAsmAddr, sigPtr, argbuf, sync, asyncAwait) => {
     var args = readEmAsmArgs(sigPtr, argbuf);
 #if PTHREADS
     if (ENVIRONMENT_IS_PTHREAD) {
@@ -1612,7 +1613,7 @@ addToLibrary({
       // of using __proxy. (And dor simplicity, do the same in the sync
       // case as well, even though it's not strictly necessary, to keep the two
       // code paths as similar as possible on both sides.)
-      return proxyToMainThread(0, emAsmAddr, sync, ...args);
+      return proxyToMainThread(0, emAsmAddr, sync, asyncAwait, ...args);
     }
 #endif
 #if ASSERTIONS
@@ -1623,6 +1624,19 @@ addToLibrary({
   emscripten_asm_const_int_sync_on_main_thread__deps: ['$runMainThreadEmAsm'],
   emscripten_asm_const_int_sync_on_main_thread: (emAsmAddr, sigPtr, argbuf) => runMainThreadEmAsm(emAsmAddr, sigPtr, argbuf, 1),
 
+  emscripten_asm_const_int_await_on_main_thread__deps: ['$runMainThreadEmAsm'],
+  emscripten_asm_const_int_await_on_main_thread: (emAsmAddr, sigPtr, argbuf) => {
+    #if PTHREADS
+    if (ENVIRONMENT_IS_PTHREAD) {
+      return runMainThreadEmAsm(emAsmAddr, sigPtr, argbuf, /*sync=*/1, /*asyncAwait=*/1);
+    }
+    #endif
+    #if ASSERTIONS
+    assert((typeof ENVIRONMENT_IS_PTHREAD !== 'undefined' && ENVIRONMENT_IS_PTHREAD), "emscripten_asm_const_int_await_on_main_thread is not available on the main thread");
+    #endif
+    return runMainThreadEmAsm(emAsmAddr, sigPtr, argbuf, /*sync*/1, /*asyncAwait=*/1);
+  },
+
   emscripten_asm_const_ptr_sync_on_main_thread__deps: ['$runMainThreadEmAsm'],
   emscripten_asm_const_ptr_sync_on_main_thread: (emAsmAddr, sigPtr, argbuf) => runMainThreadEmAsm(emAsmAddr, sigPtr, argbuf, 1),
 
diff --git a/src/lib/libpthread.js b/src/lib/libpthread.js
@@ -894,9 +894,9 @@ var LibraryPThread = {
   $proxyToMainThreadPtr: (...args) => BigInt(proxyToMainThread(...args)),
 #endif
 
-  $proxyToMainThread__deps: ['$stackSave', '$stackRestore', '$stackAlloc', '_emscripten_run_on_main_thread_js', ...i53ConversionDeps],
-  $proxyToMainThread__docs: '/** @type{function(number, (number|boolean), ...number)} */',
-  $proxyToMainThread: (funcIndex, emAsmAddr, sync, ...callArgs) => {
+  $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, (number|undefined), ...number)} */',
+  $proxyToMainThread: (funcIndex, emAsmAddr, sync, asyncAwait, ...callArgs) => {
     // EM_ASM proxying is done by passing a pointer to the address of the EM_ASM
     // content as `emAsmAddr`.  JS library proxying is done by passing an index
     // into `proxiedJSCallArgs` as `funcIndex`. If `emAsmAddr` is non-zero then
@@ -934,7 +934,12 @@ var LibraryPThread = {
       HEAPF64[b + i] = arg;
 #endif
     }
-    var rtn = __emscripten_run_on_main_thread_js(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync);
+    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;
   },
@@ -945,7 +950,11 @@ var LibraryPThread = {
   _emscripten_receive_on_main_thread_js__deps: [
     '$proxyToMainThread',
     '$proxiedJSCallArgs'],
-  _emscripten_receive_on_main_thread_js: (funcIndex, emAsmAddr, callingThread, numCallArgs, args) => {
+  /**
+   * @param {number=} promiseCtx Optionally, when set, expect func to return a Promise
+   * and use promiseCtx to signal awaiting pthread.
+   */
+  _emscripten_receive_on_main_thread_js: (funcIndex, emAsmAddr, callingThread, numCallArgs, args, promiseCtx) => {
     // Sometimes we need to backproxy events to the calling thread (e.g.
     // HTML5 DOM events handlers such as
     // emscripten_set_mousemove_callback()), so keep track in a globally
@@ -984,6 +993,24 @@ var LibraryPThread = {
     PThread.currentProxiedOperationCallerThread = callingThread;
     var rtn = func(...proxiedJSCallArgs);
     PThread.currentProxiedOperationCallerThread = 0;
+    if (promiseCtx) {
+#if ASSERTIONS
+      assert(!!rtn.then, 'Return value of proxied function expected to be a Promise but got' + rtn);
+#endif
+      rtn.then(res => {
+#if MEMORY64
+    // In memory64 mode some proxied functions return bigint/pointer but
+    // our return type is i53/double.
+    if (typeof res == "bigint") {
+      res = bigintToI53Checked(res);
+    }
+#endif
+      __emscripten_proxy_promise_finish(promiseCtx, res);
+      }).catch(err => {
+        __emscripten_proxy_promise_finish(promiseCtx, 0);
+      });
+      return;
+    }
 #if MEMORY64
     // In memory64 mode some proxied functions return bigint/pointer but
     // our return type is i53/double.
diff --git a/src/lib/libsigs.js b/src/lib/libsigs.js
@@ -324,7 +324,7 @@ sigs = {
   _emscripten_notify_mailbox_postmessage__sig: 'vpp',
   _emscripten_push_main_loop_blocker__sig: 'vppp',
   _emscripten_push_uncounted_main_loop_blocker__sig: 'vppp',
-  _emscripten_receive_on_main_thread_js__sig: 'dippip',
+  _emscripten_receive_on_main_thread_js__sig: 'dippipp',
   _emscripten_runtime_keepalive_clear__sig: 'v',
   _emscripten_system__sig: 'ip',
   _emscripten_thread_cleanup__sig: 'vp',
@@ -571,6 +571,7 @@ sigs = {
   emscripten_asm_const_double__sig: 'dppp',
   emscripten_asm_const_double_sync_on_main_thread__sig: 'dppp',
   emscripten_asm_const_int__sig: 'ippp',
+  emscripten_asm_const_int_await_on_main_thread__sig: 'ippp',
   emscripten_asm_const_int_sync_on_main_thread__sig: 'ippp',
   emscripten_asm_const_ptr__sig: 'pppp',
   emscripten_asm_const_ptr_sync_on_main_thread__sig: 'pppp',
diff --git a/system/include/emscripten/em_asm.h b/system/include/emscripten/em_asm.h
@@ -28,6 +28,9 @@ __attribute__((nothrow))
 int emscripten_asm_const_int_sync_on_main_thread(
   const char* code, const char* arg_sigs, ...);
 __attribute__((nothrow))
+int emscripten_asm_const_int_await_on_main_thread(
+  const char* code, const char* arg_sigs, ...);
+__attribute__((nothrow))
 void* emscripten_asm_const_ptr_sync_on_main_thread(
   const char* code, const char* arg_sigs, ...);
 __attribute__((nothrow))
@@ -51,6 +54,7 @@ void emscripten_asm_const_async_on_main_thread(
 #define EM_ASM_PTR(...) EM_ASM_ERROR
 #define EM_ASM_DOUBLE(...) EM_ASM_ERROR
 #define MAIN_THREAD_EM_ASM(...) EM_ASM_ERROR
+#define MAIN_THREAD_EM_ASM_AWAIT(...) EM_ASM_ERROR
 #define MAIN_THREAD_EM_ASM_INT(...) EM_ASM_ERROR
 #define MAIN_THREAD_EM_ASM_PTR(...) EM_ASM_ERROR
 #define MAIN_THREAD_EM_ASM_DOUBLE(...) EM_ASM_ERROR
@@ -250,6 +254,13 @@ const char __em_asm_sig_builder<__em_asm_type_tuple<Args...> >::buffer[] = { __e
 // functions.
 #define MAIN_THREAD_EM_ASM(code, ...) ((void)emscripten_asm_const_int_sync_on_main_thread(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__)))
 
+// Runs the given Javascript code on the main browser thread.
+// It must be called from a non-main thread.
+// The code must return a promise, and this function will wait for the promise
+// to resolve or reject, essentially blocking the calling thread until then.
+// In either case the function will return an integer, which is the result of the promise.
+#define MAIN_THREAD_EM_ASM_AWAIT(code, ...) emscripten_asm_const_int_await_on_main_thread(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__))
+
 // Runs the given JavaScript code synchronously on the main browser thread, and
 // returns an integer back.
 // The same considerations apply as with MAIN_THREAD_EM_ASM().
diff --git a/system/lib/pthread/proxying.c b/system/lib/pthread/proxying.c
@@ -591,12 +591,15 @@ typedef struct proxied_js_func_t {
   double* argBuffer;
   double result;
   bool owned;
+  // Only used when the underlying js func is async.
+  // Can be null when the function is sync.
+  em_proxying_ctx * ctx;
 } proxied_js_func_t;
 
 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);
+    f->funcIndex, f->emAsmAddr, f->callingThread, f->numArgs, f->argBuffer, f->ctx);
   if (f->owned) {
     free(f->argBuffer);
     free(f);
@@ -615,6 +618,7 @@ double _emscripten_run_on_main_thread_js(int func_index,
     .numArgs = num_args,
     .argBuffer = buffer,
     .owned = false,
+    .ctx = NULL,
   };
 
   em_proxying_queue* q = emscripten_proxy_get_system_queue();
@@ -642,3 +646,41 @@ double _emscripten_run_on_main_thread_js(int func_index,
   }
   return 0;
 }
+
+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);
+}
+
+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;
+  func->result = (double)(intptr_t)res;
+  emscripten_proxy_finish(ctx);
+}
diff --git a/system/lib/pthread/threading_internal.h b/system/lib/pthread/threading_internal.h
@@ -96,7 +96,7 @@ int __pthread_create_js(struct __pthread *thread, const pthread_attr_t *attr, vo
 int _emscripten_default_pthread_stack_size();
 void __set_thread_state(pthread_t ptr, int is_main, int is_runtime, int can_block);
 
-double _emscripten_receive_on_main_thread_js(int funcIndex, void* emAsmAddr, pthread_t callingThread, int numCallArgs, double* args);
+double _emscripten_receive_on_main_thread_js(int funcIndex, void* emAsmAddr, pthread_t callingThread, int numCallArgs, double* args, void *ctx);
 
 // Return non-zero if the calling thread supports Atomic.wait (For example
 // if called from the main browser thread, this function will return zero
diff --git a/test/core/test_main_thread_async_em_asm_await.cpp b/test/core/test_main_thread_async_em_asm_await.cpp
@@ -0,0 +1,25 @@
+// Copyright 2024 The Emscripten Authors.  All rights reserved.
+// Emscripten is available under two separate licenses, the MIT license and the
+// University of Illinois/NCSA Open Source License.  Both these licenses can be
+// found in the LICENSE file.
+
+#include <emscripten.h>
+#include <stdio.h>
+
+int main()
+{
+  printf("Before MAIN_THREAD_EM_ASM_AWAIT\n");
+  int res = MAIN_THREAD_EM_ASM_AWAIT({
+    out('Inside MAIN_THREAD_EM_ASM_AWAIT: ' + $0 + ' ' + $1);
+    const asyncOp = new Promise((resolve,reject) => {
+      setTimeout(() => {
+        out('Inside asyncOp');
+        resolve(2);
+      }, 1000);
+    });
+    return asyncOp;
+  }, 42, 3.5);
+  printf("After MAIN_THREAD_EM_ASM_AWAIT\n");
+  printf("result: %d\n", res);
+  return 0;
+}
diff --git a/test/core/test_main_thread_async_em_asm_await.out b/test/core/test_main_thread_async_em_asm_await.out
@@ -0,0 +1,5 @@
+Before MAIN_THREAD_EM_ASM_AWAIT
+Inside MAIN_THREAD_EM_ASM_AWAIT: 42 3.5
+Inside asyncOp
+After MAIN_THREAD_EM_ASM_AWAIT
+result: 2
diff --git a/test/core/test_main_thread_async_em_asm_await_reject.cpp b/test/core/test_main_thread_async_em_asm_await_reject.cpp
@@ -0,0 +1,34 @@
+// Copyright 2024 The Emscripten Authors.  All rights reserved.
+// Emscripten is available under two separate licenses, the MIT license and the
+// University of Illinois/NCSA Open Source License.  Both these licenses can be
+// found in the LICENSE file.
+
+#include <emscripten.h>
+#include <stdio.h>
+#include <pthread.h>
+
+int main()
+{
+  // start new thread
+  pthread_t thread;
+  pthread_create(&thread, NULL, [](void*) -> void* {
+    printf("Before MAIN_THREAD_EM_ASM_AWAIT\n");
+    int res = MAIN_THREAD_EM_ASM_AWAIT({
+      out('Inside MAIN_THREAD_EM_ASM_AWAIT: ' + $0 + ' ' + $1);
+      const asyncOp = new Promise((resolve,reject) => {
+        setTimeout(() => {
+          out('Inside asyncOp');
+          reject(2);
+        }, 1000);
+      });
+      return asyncOp;
+    }, 42, 3.5);
+    printf("After MAIN_THREAD_EM_ASM_AWAIT rejected\n");
+    printf("result: %d\n", res);
+    return NULL;
+  }, NULL);
+
+  // wait for thread to finish
+  pthread_join(thread, NULL);
+  return 0;
+}
diff --git a/test/core/test_main_thread_async_em_asm_await_reject.out b/test/core/test_main_thread_async_em_asm_await_reject.out
@@ -0,0 +1,5 @@
+Before MAIN_THREAD_EM_ASM_AWAIT
+Inside MAIN_THREAD_EM_ASM_AWAIT: 42 3.5
+Inside asyncOp
+After MAIN_THREAD_EM_ASM_AWAIT rejected
+result: 2
diff --git a/test/other/codesize/test_codesize_minimal_pthreads.exports b/test/other/codesize/test_codesize_minimal_pthreads.exports
@@ -1,9 +1,11 @@
-A (_emscripten_thread_exit)
-B (_emscripten_check_mailbox)
-C (emscripten_stack_set_limits)
-D (_emscripten_stack_restore)
-E (_emscripten_stack_alloc)
-F (emscripten_stack_get_current)
+A (_emscripten_proxy_promise_finish)
+B (_emscripten_thread_free_data)
+C (_emscripten_thread_exit)
+D (_emscripten_check_mailbox)
+E (emscripten_stack_set_limits)
+F (_emscripten_stack_restore)
+G (_emscripten_stack_alloc)
+H (emscripten_stack_get_current)
 p (__wasm_call_ctors)
 q (add)
 r (main)
@@ -14,4 +16,4 @@ v (_emscripten_proxy_main)
 w (_emscripten_thread_init)
 x (_emscripten_thread_crashed)
 y (_emscripten_run_on_main_thread_js)
-z (_emscripten_thread_free_data)
+z (_emscripten_await_on_main_thread_js)
diff --git a/test/other/codesize/test_codesize_minimal_pthreads.funcs b/test/other/codesize/test_codesize_minimal_pthreads.funcs
@@ -25,8 +25,10 @@ $__wasi_syscall_ret
 $__wasm_call_ctors
 $__wasm_init_memory
 $__wasm_init_tls
+$_emscripten_await_on_main_thread_js
 $_emscripten_check_mailbox
 $_emscripten_proxy_main
+$_emscripten_proxy_promise_finish
 $_emscripten_run_on_main_thread_js
 $_emscripten_stack_alloc
 $_emscripten_stack_restore
@@ -50,6 +52,7 @@ $a_swap
 $add
 $call_callback_then_free_ctx
 $call_cancel_then_free_ctx
+$call_proxied_js_task_with_ctx
 $call_then_finish_task
 $call_with_ctx
 $cancel_active_ctxs
@@ -69,6 +72,8 @@ $emscripten_builtin_free
 $emscripten_builtin_malloc
 $emscripten_futex_wait
 $emscripten_futex_wake
+$emscripten_proxy_finish
+$emscripten_proxy_sync_with_ctx
 $emscripten_stack_get_current
 $emscripten_stack_set_limits
 $free_ctx
diff --git a/test/test_core.py b/test/test_core.py
@@ -1886,6 +1886,26 @@ def test_main_thread_em_asm(self, args):
   def test_main_thread_async_em_asm(self, args, force_c=False):
     self.do_core_test('test_main_thread_async_em_asm.cpp', emcc_args=args, force_c=force_c)
 
+  @needs_dylink
+  @parameterized({
+    '': (['-sASSERTIONS'], False),
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'], False),
+  })
+  def test_main_thread_async_em_asm_await(self, args, force_c=False):
+    if '-sPROXY_TO_PTHREAD' not in args:
+      # expect runtime to error
+      output = self.do_runf('core/test_main_thread_async_em_asm_await.cpp', expected_output=None, assert_returncode=NON_ZERO, emcc_args=args)
+      self.assertContained('emscripten_asm_const_int_await_on_main_thread is not available on the main thread', output)
+    else:
+      self.do_core_test('test_main_thread_async_em_asm_await.cpp', emcc_args=args, force_c=force_c)
+
+  @needs_dylink
+  @parameterized({
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME', '-sASSERTIONS'], False),
+  })
+  def test_main_thread_async_em_asm_await_reject(self, args, force_c=False):
+    self.do_core_test('test_main_thread_async_em_asm_await_reject.cpp', emcc_args=args, force_c=force_c)
+
   # Tests MAIN_THREAD_EM_ASM_INT() function call with different signatures.
   def test_main_thread_em_asm_signatures(self):
     self.do_core_test('test_em_asm_signatures.cpp')
diff --git a/test/third_party/googletest b/test/third_party/googletest
@@ -1 +1 @@
-Subproject commit b514bdc898e2951020cbdca1304b75f5950d1f59
+Subproject commit 4fb7039fda3f6588c7ca9664176f8c9e0a023b4a
diff --git a/tools/emscripten.py b/tools/emscripten.py
diff --git a/tools/link.py b/tools/link.py
