Convert JS function proxying to use new proxying API. NFC (#19947)

Author: sbc100

emcc.py

@@ -1706,7 +1706,6 @@ def setup_pthreads(target):
 
   # Functions needs to be exported from the module since they are used in worker.js
   settings.REQUIRED_EXPORTS += [
-    'emscripten_dispatch_to_thread_',
     '_emscripten_thread_free_data',
     'emscripten_main_runtime_thread_id',
     'emscripten_main_thread_process_queued_calls',

src/generated_struct_info32.json

@@ -230,7 +230,6 @@
         "EM_PROMISE_MATCH_RELEASE": 2,
         "EM_PROMISE_REJECT": 3,
         "EM_PROXIED_RESIZE_OFFSCREENCANVAS": 654311424,
-        "EM_QUEUED_JS_CALL_MAX_ARGS": 20,
         "EM_TIMING_RAF": 1,
         "EM_TIMING_SETIMMEDIATE": 2,
         "EM_TIMING_SETTIMEOUT": 0,

src/generated_struct_info64.json

@@ -230,7 +230,6 @@
         "EM_PROMISE_MATCH_RELEASE": 2,
         "EM_PROMISE_REJECT": 3,
         "EM_PROXIED_RESIZE_OFFSCREENCANVAS": 654311424,
-        "EM_QUEUED_JS_CALL_MAX_ARGS": 20,
         "EM_TIMING_RAF": 1,
         "EM_TIMING_SETIMMEDIATE": 2,
         "EM_TIMING_SETTIMEOUT": 0,

src/library_html5.js

@@ -5,7 +5,11 @@
  */
 
 var LibraryHTML5 = {
-  $JSEvents__deps: ['$withStackSave'],
+  $JSEvents__deps: ['$withStackSave',
+#if PTHREADS
+    'emscripten_dispatch_to_thread_',
+#endif
+  ],
   $JSEvents: {
 
 /* We do not depend on the exact initial values of falsey member fields - these fields can be populated on-demand

src/library_pthread.js

@@ -965,12 +965,6 @@ var LibraryPThread = {
     // We also pass 'sync' to C separately, since C needs to look at it.
     var numCallArgs = arguments.length - 2;
     var outerArgs = arguments;
-#if ASSERTIONS
-    var maxArgs = {{{ cDefs.EM_QUEUED_JS_CALL_MAX_ARGS - 1 }}};
-    if (numCallArgs > maxArgs) {
-      throw 'proxyToMainThread: Too many arguments ' + numCallArgs + ' to proxied function idx=' + index + ', maximum supported is ' + maxArgs;
-    }
-#endif
     // Allocate a buffer, which will be copied by the C code.
     return withStackSave(() => {
       // First passed parameter specifies the number of arguments to the function.

src/struct_info_internal.json

@@ -24,12 +24,6 @@
           "SIGCANCEL"
         ]
     },
-    {
-        "file": "threading_internal.h",
-        "defines": [
-            "EM_QUEUED_JS_CALL_MAX_ARGS"
-        ]
-    },
     {
         "file": "dynlink.h",
         "structs": {

system/include/emscripten/threading_legacy.h

@@ -27,6 +27,10 @@ typedef struct em_queued_call em_queued_call;
 // in the future. Do not depend on the exact numbers in this scheme.
 #define EM_FUNC_SIGNATURE unsigned int
 
+// Proxied JS function can support a few more arguments than proxied C/C++
+// functions, because the dispatch is variadic and signature independent.
+#define EM_QUEUED_JS_CALL_MAX_ARGS 20
+
 // The encoding scheme is as follows:
 // - highest three bits identify the type of the return value
 #define EM_FUNC_SIG_RETURN_VALUE_MASK (0x7U << 29)
@@ -115,7 +119,6 @@ typedef struct em_queued_call em_queued_call;
 #define EM_PROXIED_FUNC_SPECIAL(x) (EM_FUNC_SIG_SPECIAL_INTERNAL | ((x) << 20))
 
 #define EM_PROXIED_RESIZE_OFFSCREENCANVAS (EM_PROXIED_FUNC_SPECIAL(0) | EM_FUNC_SIG_IIII)
-#define EM_PROXIED_JS_FUNCTION (EM_PROXIED_FUNC_SPECIAL(1) | EM_FUNC_SIG_D)
 
 // Runs the given function synchronously on the main Emscripten runtime thread.
 // If this thread is the main thread, the operation is immediately performed,

system/lib/pthread/proxying.c

@@ -10,11 +10,13 @@
 #include <emscripten/threading.h>
 #include <pthread.h>
 #include <stdatomic.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "em_task_queue.h"
 #include "thread_mailbox.h"
+#include "threading_internal.h"
 
 struct em_proxying_queue {
   // Protects all accesses to em_task_queues, size, and capacity.
@@ -580,3 +582,60 @@ em_promise_t emscripten_proxy_promise(em_proxying_queue* q,
                           &block->ctx,
                           &block->promise_ctx);
 }
+
+typedef struct proxied_js_func_t {
+  int funcIndex;
+  pthread_t callingThread;
+  int numArgs;
+  double* argBuffer;
+  double result;
+  bool owned;
+} 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->callingThread, f->numArgs, f->argBuffer);
+  if (f->owned) {
+    free(f->argBuffer);
+    free(f);
+  }
+}
+
+double _emscripten_run_on_main_thread_js(int index,
+                                         int num_args,
+                                         double* buffer,
+                                         int sync) {
+  proxied_js_func_t f = {
+    .funcIndex = index,
+    .callingThread = pthread_self(),
+    .numArgs = num_args,
+    .argBuffer = buffer,
+    .owned = false,
+  };
+
+  em_proxying_queue* q = emscripten_proxy_get_system_queue();
+  pthread_t target = emscripten_main_runtime_thread_id();
+
+  if (sync) {
+    if (!emscripten_proxy_sync(q, target, run_js_func, &f)) {
+      assert(false && "emscripten_proxy_sync failed");
+      return 0;
+    }
+    return f.result;
+  }
+
+  // Make a heap-heap allocated copy of the proxied_js_func_t
+  proxied_js_func_t* arg = malloc(sizeof(proxied_js_func_t));
+  *arg = f;
+  arg->owned = true;
+
+  // Also make a copyh of the argBuffer.
+  arg->argBuffer = malloc(num_args*sizeof(double));
+  memcpy(arg->argBuffer, buffer, num_args*sizeof(double));
+
+  if (!emscripten_proxy_async(q, target, run_js_func, arg)) {
+    assert(false && "emscripten_proxy_async failed");
+  }
+  return 0;
+}

system/lib/pthread/proxying_legacy.c

@@ -153,10 +153,6 @@ static void _do_call(void* arg) {
       q->returnValue.i =
         _emscripten_set_offscreencanvas_size(q->args[0].cp, q->args[1].i, q->args[2].i);
       break;
-    case EM_PROXIED_JS_FUNCTION:
-      q->returnValue.d =
-        _emscripten_receive_on_main_thread_js((intptr_t)q->functionPtr, q->callingThread, q->args[0].i, &q->args[1].d);
-      break;
     case EM_FUNC_SIG_V:
       ((em_func_v)q->functionPtr)();
       break;
@@ -413,44 +409,6 @@ int emscripten_sync_run_in_main_runtime_thread_(EM_FUNC_SIGNATURE sig, void* fun
   return q.returnValue.i;
 }
 
-double _emscripten_run_on_main_thread_js(int index, int num_args, int64_t* buffer, int sync) {
-  em_queued_call q;
-  em_queued_call *c;
-  if (sync) {
-    q.operationDone = 0;
-    q.satelliteData = 0;
-    c = &q;
-  } else {
-    c = em_queued_call_malloc();
-  }
-  c->calleeDelete = !sync;
-  c->functionEnum = EM_PROXIED_JS_FUNCTION;
-  // Index not needed to ever be more than 32-bit.
-  c->functionPtr = (void*)(intptr_t)index;
-  c->callingThread = pthread_self();
-  assert(num_args+1 <= EM_QUEUED_JS_CALL_MAX_ARGS);
-  // The types are only known at runtime in these calls, so we store values that
-  // must be able to contain any valid JS value, including a 64-bit BigInt if
-  // BigInt support is enabled. We store to an i64, which can contain both a
-  // BigInt and a JS Number which is a 64-bit double.
-  c->args[0].i = num_args;
-  for (int i = 0; i < num_args; i++) {
-    c->args[i+1].i64 = buffer[i];
-  }
-
-  if (sync) {
-    sync_run_in_main_thread(&q);
-    // TODO: support BigInt return values somehow.
-    return q.returnValue.d;
-  } else {
-    // 'async' runs are fire and forget, where the caller detaches itself from the call object after
-    // returning here, and it is the callee's responsibility to free up the memory after the call
-    // has been performed.
-    emscripten_async_run_in_main_thread(c);
-    return 0;
-  }
-}
-
 void emscripten_async_run_in_main_runtime_thread_(EM_FUNC_SIGNATURE sig, void* func_ptr, ...) {
   em_queued_call* q = em_queued_call_malloc();
   if (!q)

system/lib/pthread/threading_internal.h

@@ -9,10 +9,6 @@
 
 #include <pthread.h>
 
-// Proxied JS function can support a few more arguments than proxied C/C++
-// functions, because the dispatch is variadic and signature independent.
-#define EM_QUEUED_JS_CALL_MAX_ARGS 20
-
 #define EM_THREAD_NAME_MAX 32
 
 #define EM_THREAD_STATUS int