Simplify code for managing pthreads/workers in JS. NFC (#17492)

We no longer need to track each pthread as a JS object, we can just map
pthread pointer to workers, and have each worker contain reverse mapping
to its current pthread_ptr.

Author: sbc100

src/library_pthread.js

@@ -51,6 +51,10 @@ var LibraryPThread = {
     // Contains all Workers that are currently hosting an active pthread.
     runningWorkers: [],
     tlsInitFunctions: [],
+    // Maps pthread_t pointers to the workers on which they are running.  For
+    // the reverse mapping, each worker has a `pthread_ptr` when its running a
+    // pthread.
+    pthreads: {},
 #if PTHREADS_DEBUG
     nextWorkerID: 1,
     debugInit: function() {
@@ -114,8 +118,6 @@ var LibraryPThread = {
       noExitRuntime = false;
 #endif
     },
-    // Maps pthread_t to pthread info objects
-    pthreads: {},
 
 #if PTHREADS_PROFILING
     getThreadName: function(pthreadPtr) {
@@ -158,9 +160,9 @@ var LibraryPThread = {
       err('terminateAllThreads');
 #endif
       for (var t in PThread.pthreads) {
-        var pthread = PThread.pthreads[t];
-        if (pthread && pthread.worker) {
-          PThread.returnWorkerToPool(pthread.worker);
+        var worker = PThread.pthreads[t];
+        if (worker) {
+          PThread.returnWorkerToPool(worker);
         }
       }
 
@@ -175,7 +177,7 @@ var LibraryPThread = {
         var worker = PThread.unusedWorkers[i];
 #if ASSERTIONS
         // This Worker should not be hosting a pthread at this time.
-        assert(!worker.pthread);
+        assert(!worker.pthread_ptr);
 #endif
         worker.terminate();
       }
@@ -188,7 +190,7 @@ var LibraryPThread = {
       // queued pthread_create which looks at the global data structures we are
       // modifying). To achieve that, defer the free() til the very end, when
       // we are all done.
-      var pthread_ptr = worker.pthread.threadInfoStruct;
+      var pthread_ptr = worker.pthread_ptr;
       delete PThread.pthreads[pthread_ptr];
       // Note: worker is intentionally not terminated so the pool can
       // dynamically grow.
@@ -197,7 +199,7 @@ var LibraryPThread = {
       // Not a running Worker anymore
       // Detach the worker from the pthread object, and return it to the
       // worker pool as an unused worker.
-      worker.pthread = undefined;
+      worker.pthread_ptr = 0;
 
       // Finally, free the underlying (and now-unused) pthread structure in
       // linear memory.
@@ -237,13 +239,13 @@ var LibraryPThread = {
         // HTML5 DOM events handlers such as
         // emscripten_set_mousemove_callback()), so keep track in a globally
         // accessible variable about the thread that initiated the proxying.
-        if (worker.pthread) PThread.currentProxiedOperationCallerThread = worker.pthread.threadInfoStruct;
+        if (worker.pthread_ptr) PThread.currentProxiedOperationCallerThread = worker.pthread_ptr;
 
         // If this message is intended to a recipient that is not the main thread, forward it to the target thread.
         if (d['targetThread'] && d['targetThread'] != _pthread_self()) {
-          var thread = PThread.pthreads[d.targetThread];
-          if (thread) {
-            thread.worker.postMessage(d, d['transferList']);
+          var targetWorker = PThread.pthreads[d.targetThread];
+          if (targetWorker) {
+            targetWorker.postMessage(d, d['transferList']);
           } else {
             err('Internal error! Worker sent a message "' + cmd + '" to target pthread ' + d['targetThread'] + ', but that thread no longer exists!');
           }
@@ -295,11 +297,8 @@ var LibraryPThread = {
       worker.onerror = (e) => {
         var message = 'worker sent an error!';
 #if ASSERTIONS
-        if (worker.pthread) {
-          var pthread_ptr = worker.pthread.threadInfoStruct;
-          if (pthread_ptr) {
-            message = 'Pthread ' + ptrToString(pthread_ptr) + ' sent an error!';
-          }
+        if (worker.pthread_ptr) {
+          message = 'Pthread ' + ptrToString(worker.pthread_ptr) + ' sent an error!';
         }
 #endif
         err(message + ' ' + e.filename + ':' + e.lineno + ': ' + e.message);
@@ -444,14 +443,14 @@ var LibraryPThread = {
     assert(!ENVIRONMENT_IS_PTHREAD, 'Internal Error! killThread() can only ever be called from main application thread!');
     assert(pthread_ptr, 'Internal Error! Null pthread_ptr in killThread!');
 #endif
-    var pthread = PThread.pthreads[pthread_ptr];
+    var worker = PThread.pthreads[pthread_ptr];
     delete PThread.pthreads[pthread_ptr];
-    pthread.worker.terminate();
+    worker.terminate();
     __emscripten_thread_free_data(pthread_ptr);
     // The worker was completely nuked (not just the pthread execution it was hosting), so remove it from running workers
     // but don't put it back to the pool.
-    PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(pthread.worker), 1); // Not a running Worker anymore.
-    pthread.worker.pthread = undefined;
+    PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); // Not a running Worker anymore.
+    worker.pthread_ptr = 0;
   },
 
   __emscripten_thread_cleanup: function(thread) {
@@ -469,9 +468,8 @@ var LibraryPThread = {
     assert(!ENVIRONMENT_IS_PTHREAD, 'Internal Error! cleanupThread() can only ever be called from main application thread!');
     assert(pthread_ptr, 'Internal Error! Null pthread_ptr in cleanupThread!');
 #endif
-    var pthread = PThread.pthreads[pthread_ptr];
-    assert(pthread);
-    var worker = pthread.worker;
+    var worker = PThread.pthreads[pthread_ptr];
+    assert(worker);
     PThread.returnWorkerToPool(worker);
   },
 
@@ -522,8 +520,8 @@ var LibraryPThread = {
     assert(!ENVIRONMENT_IS_PTHREAD, 'Internal Error! cancelThread() can only ever be called from main application thread!');
     assert(pthread_ptr, 'Internal Error! Null pthread_ptr in cancelThread!');
 #endif
-    var pthread = PThread.pthreads[pthread_ptr];
-    pthread.worker.postMessage({ 'cmd': 'cancel' });
+    var worker = PThread.pthreads[pthread_ptr];
+    worker.postMessage({ 'cmd': 'cancel' });
   },
 
   $spawnThread: function(threadParams) {
@@ -538,24 +536,20 @@ var LibraryPThread = {
       return {{{ cDefine('EAGAIN') }}};
     }
 #if ASSERTIONS
-    assert(!worker.pthread, 'Internal error!');
+    assert(!worker.pthread_ptr, 'Internal error!');
 #endif
 
     PThread.runningWorkers.push(worker);
 
-    // Create a pthread info object to represent this thread.
-    var pthread = PThread.pthreads[threadParams.pthread_ptr] = {
-      worker: worker,
-      // Info area for this thread in Emscripten HEAP (shared)
-      threadInfoStruct: threadParams.pthread_ptr
-    };
+    // Add to pthreads map
+    PThread.pthreads[threadParams.pthread_ptr] = worker;
 
-    worker.pthread = pthread;
+    worker.pthread_ptr = threadParams.pthread_ptr;
     var msg = {
         'cmd': 'run',
         'start_routine': threadParams.startRoutine,
         'arg': threadParams.arg,
-        'threadInfoStruct': threadParams.pthread_ptr,
+        'pthread_ptr': threadParams.pthread_ptr,
     };
 #if OFFSCREENCANVAS_SUPPORT
     // Note that we do not need to quote these names because they are only used
@@ -1017,8 +1011,7 @@ var LibraryPThread = {
     } else if (ENVIRONMENT_IS_PTHREAD) {
       postMessage({'targetThread' : targetThreadId, 'cmd' : 'processProxyingQueue', 'queue' : queue});
     } else {
-      var pthread = PThread.pthreads[targetThreadId];
-      var worker = pthread && pthread.worker;
+      var worker = PThread.pthreads[targetThreadId];
       if (!worker) {
 #if ASSERTIONS
         err('Cannot send message to thread with ID ' + targetThreadId + ', unknown thread ID!');

src/threadprofiler.js

@@ -35,7 +35,7 @@ var emscriptenThreadProfiler = {
 
     var threads = [mainThread];
     for (var i in PThread.pthreads) {
-      threads.push(PThread.pthreads[i].threadInfoStruct);
+      threads.push(PThread.pthreads[i].pthread_ptr);
     }
     for (var i = 0; i < threads.length; ++i) {
       var threadPtr = threads[i];
@@ -62,7 +62,7 @@ var emscriptenThreadProfiler = {
 
     var threads = [mainThread];
     for (var i in PThread.pthreads) {
-      threads.push(PThread.pthreads[i].threadInfoStruct);
+      threads.push(PThread.pthreads[i].pthread_ptr);
     }
 
     for (var i = 0; i < threads.length; ++i) {

src/worker.js

@@ -200,11 +200,11 @@ self.onmessage = (e) => {
       // (+/- 0.1msecs in testing).
       Module['__performance_now_clock_drift'] = performance.now() - e.data.time;
 
-      // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
-      Module['__emscripten_thread_init'](e.data.threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0, /*canBlock=*/1);
+      // Pass the thread address to wasm to store it for fast access.
+      Module['__emscripten_thread_init'](e.data.pthread_ptr, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0, /*canBlock=*/1);
 
 #if ASSERTIONS
-      assert(e.data.threadInfoStruct);
+      assert(e.data.pthread_ptr);
 #endif
       // Also call inside JS module to set up the stack frame for this pthread in JS module scope
       Module['establishStackSpace']();

tests/other/metadce/test_metadce_minimal_pthreads.jssize

@@ -1 +1 @@
-16000
+15892