Add support for MODULARIZE with USE_PTHREADS

Author: juj

emcc.py

@@ -1199,11 +1199,6 @@ def check(input_file):
           exit_with_error('USE_PTHREADS=2 is not longer supported')
         if shared.Settings.ALLOW_MEMORY_GROWTH:
           exit_with_error('Memory growth is not yet supported with pthreads')
-        if shared.Settings.MODULARIZE:
-          # currently worker.js uses the global namespace, so it's setting of
-          # ENVIRONMENT_IS_PTHREAD is not picked up, in addition to all the other
-          # modifications it performs.
-          exit_with_error('MODULARIZE is not yet supported with pthreads')
         # UTF8Decoder.decode doesn't work with a view of a SharedArrayBuffer
         shared.Settings.TEXTDECODER = 0
         options.js_libraries.append(shared.path_from_root('src', 'library_pthread.js'))
@@ -1230,7 +1225,20 @@ def check(input_file):
           'FS_unlink',
           'getMemory',
           'addRunDependency',
-          'removeRunDependency',
+          'removeRunDependency'
+        ]
+
+      if shared.Settings.STACK_OVERFLOW_CHECK:
+        shared.Settings.EXPORTED_RUNTIME_METHODS += [
+          'writeStackCookie',
+          'checkStackCookie'
+        ]
+
+      if shared.Settings.USE_PTHREADS:
+        shared.Settings.EXPORTED_RUNTIME_METHODS += [
+          'PThread',
+          'ExitStatus',
+          'establishStackSpaceInModule'
         ]
 
       if shared.Settings.USE_PTHREADS:
@@ -1935,7 +1943,7 @@ def repl(m):
 
       if shared.Settings.USE_PTHREADS:
         target_dir = os.path.dirname(os.path.abspath(target))
-        shutil.copyfile(shared.path_from_root('src', 'worker.js'),
+        shared.run_c_preprocessor_on_file(shared.path_from_root('src', 'worker.js'),
                         os.path.join(target_dir, shared.Settings.PTHREAD_WORKER_FILE))
 
       # Generate the fetch-worker.js script for multithreaded emscripten_fetch() support if targeting pthreads.
@@ -2464,7 +2472,7 @@ def emit_js_source_maps(target, js_transform_tempfiles):
 def separate_asm_js(final, asm_target):
   """Separate out the asm.js code, if asked. Or, if necessary for another option"""
   logger.debug('separating asm')
-  shared.check_call([shared.PYTHON, shared.path_from_root('tools', 'separate_asm.py'), final, asm_target, final])
+  shared.check_call([shared.PYTHON, shared.path_from_root('tools', 'separate_asm.py'), final, asm_target, final, shared.Settings.ASM_MODULE_NAME])
 
   # extra only-my-code logic
   if shared.Settings.ONLY_MY_CODE:

src/library_pthread.js

@@ -397,6 +397,7 @@ var LibraryPThread = {
             wasmModule: Module['wasmModule'],
 #else
             buffer: HEAPU8.buffer,
+            asmJsUrlOrBlob: Module["asmJsUrlOrBlob"],
 #endif
             tempDoublePtr: tempDoublePtr,
             TOTAL_MEMORY: TOTAL_MEMORY,
@@ -1177,3 +1178,8 @@ var LibraryPThread = {
 
 autoAddDeps(LibraryPThread, '$PThread');
 mergeInto(LibraryManager.library, LibraryPThread);
+
+if (USE_PTHREADS) {
+  DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.push('emscripten_futex_wake');
+  DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.push('emscripten_futex_wait');
+}

src/modules.js

@@ -417,6 +417,18 @@ function exportRuntime() {
     'print',
     'printErr',
   ];
+  if (STACK_OVERFLOW_CHECK) {
+    runtimeElements.push('writeStackCookie');
+    runtimeElements.push('checkStackCookie');
+    runtimeElements.push('abortStackOverflow');
+  }
+  if (USE_PTHREADS) {
+    runtimeElements.push('PThread');
+    runtimeElements.push('ExitStatus');
+    if (MODULARIZE) {
+      runtimeElements.push('establishStackSpaceInModule');
+    }
+  }
   if (SUPPORT_BASE64_EMBEDDING) {
     runtimeElements.push('intArrayFromBase64');
     runtimeElements.push('tryParseAsDataURI');

src/postamble.js

@@ -464,6 +464,9 @@ if (!ENVIRONMENT_IS_PTHREAD) // EXIT_RUNTIME=0 only applies to default behavior
 
 #if USE_PTHREADS
 if (!ENVIRONMENT_IS_PTHREAD) run();
+
+Module._emscripten_futex_wake = _emscripten_futex_wake;
+
 #else
 run();
 #endif

src/preamble.js

@@ -921,9 +921,6 @@ if (!ENVIRONMENT_IS_PTHREAD) { // Pthreads have already initialized these variab
 #if USE_PTHREADS
 if (ENVIRONMENT_IS_PTHREAD) {
   staticSealed = true; // The static memory area has been initialized already in the main thread, pthreads skip this.
-#if SEPARATE_ASM != 0
-  importScripts('{{{ SEPARATE_ASM }}}'); // load the separated-out asm.js
-#endif
 }
 #endif
 
@@ -948,6 +945,13 @@ function abortStackOverflow(allocSize) {
 }
 #endif
 
+#if USE_PTHREADS && MODULARIZE
+function establishStackSpaceInModule(stackBase, stackMax) {
+  STACK_BASE = STACKTOP = stackBase;
+  STACK_MAX = stackMax;
+}
+#endif
+
 #if EMTERPRETIFY
 function abortStackOverflowEmterpreter() {
   abort("Emterpreter stack overflow! Decrease the recursion level or increase EMT_STACK_MAX in tools/emterpretify.py (current value " + EMT_STACK_MAX + ").");

src/settings.js

@@ -829,6 +829,12 @@ var MODULARIZE = 0;
 // (since you arean't creating the instance yourself).
 var MODULARIZE_INSTANCE = 0;
 
+// If we separate out asm.js with the --separate-asm option,
+// this is the name of the variable where the generated asm.js
+// Module is assigned to. This name can either be a property
+// of Module, or a freestanding variable name, like "var asmJsModule".
+var ASM_MODULE_NAME = 'Module["asm"]';
+
 // Export using an ES6 Module export rather than a UMD export.  MODULARIZE must
 // be enabled for ES6 exports.
 var EXPORT_ES6 = 0;

src/shell.js

@@ -81,11 +81,26 @@ if (Module['ENVIRONMENT']) {
 // 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)
 // 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)
 #if USE_PTHREADS
-var ENVIRONMENT_IS_PTHREAD;
-if (!ENVIRONMENT_IS_PTHREAD) ENVIRONMENT_IS_PTHREAD = false; // ENVIRONMENT_IS_PTHREAD=true will have been preset in worker.js. Make it false in the main runtime thread.
-var PthreadWorkerInit; // Collects together variables that are needed at initialization time for the web workers that host pthreads.
-if (!ENVIRONMENT_IS_PTHREAD) PthreadWorkerInit = {};
-var currentScriptUrl = (typeof document !== 'undefined' && document.currentScript) ? document.currentScript.src : undefined;
+
+if (typeof ENVIRONMENT_IS_PTHREAD === 'undefined') {
+  // ENVIRONMENT_IS_PTHREAD=true will have been preset in pthread-main.js. Make it false in the main runtime thread. 
+  // N.B. this line needs to appear without 'var' keyword to avoid 'var hoisting' from occurring. (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var)
+  ENVIRONMENT_IS_PTHREAD = false;
+  var PthreadWorkerInit = {}; // Collects together variables that are needed at initialization time for the web workers that host pthreads.
+} else {
+  var buffer = {{{EXPORT_NAME}}}.buffer;
+  var tempDoublePtr = {{{EXPORT_NAME}}}.tempDoublePtr;
+  var TOTAL_MEMORY = {{{EXPORT_NAME}}}.TOTAL_MEMORY;
+  var STATICTOP = {{{EXPORT_NAME}}}.STATICTOP;
+  var DYNAMIC_BASE = {{{EXPORT_NAME}}}.DYNAMIC_BASE;
+  var DYNAMICTOP_PTR = {{{EXPORT_NAME}}}.DYNAMICTOP_PTR;
+  var PthreadWorkerInit = {{{EXPORT_NAME}}}.PthreadWorkerInit;
+  var STACK_BASE = {{{EXPORT_NAME}}}.STACK_BASE;
+  var STACKTOP = {{{EXPORT_NAME}}}.STACKTOP;
+  var STACK_MAX = {{{EXPORT_NAME}}}.STACK_MAX;
+}
+
+var currentScriptUrl = typeof _scriptDir !== 'undefined' ? _scriptDir : ((typeof document !== 'undefined' && document.currentScript) ? document.currentScript.src : undefined);
 #endif // USE_PTHREADS
 
 // `/` should be present at the end if `scriptDirectory` is not empty

src/worker.js

@@ -38,6 +38,10 @@ var __performance_now_clock_drift = 0;
 // Therefore implement custom logging facility for threads running in a worker, which queue the messages to main thread to print.
 var Module = {};
 
+function assert(condition, text) {
+  if (!condition) abort('Assertion failed: ' + text);
+}
+
 // When error objects propagate from Web Worker to main thread, they lose helpful call stack and thread ID information, so print out errors early here,
 // before that happens.
 this.addEventListener('error', function(e) {
@@ -65,7 +69,7 @@ out = threadPrint;
 err = threadPrintErr;
 this.alert = threadAlert;
 
-// #if WASM
+#if WASM
 Module['instantiateWasm'] = function(info, receiveInstance) {
   // Instantiate from the module posted from the main thread.
   // We can just use sync instantiation in the worker.
@@ -75,71 +79,101 @@ Module['instantiateWasm'] = function(info, receiveInstance) {
   receiveInstance(instance); // The second 'module' parameter is intentionally null here, we don't need to keep a ref to the Module object from here.
   return instance.exports;
 }
-//#endif
+#endif
 
 this.onmessage = function(e) {
   try {
     if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
       // Initialize the thread-local field(s):
-      tempDoublePtr = e.data.tempDoublePtr;
+      Module['tempDoublePtr'] = e.data.tempDoublePtr;
 
       // Initialize the global "process"-wide fields:
-      Module['TOTAL_MEMORY'] = TOTAL_MEMORY = e.data.TOTAL_MEMORY;
-      STATICTOP = e.data.STATICTOP;
-      DYNAMIC_BASE = e.data.DYNAMIC_BASE;
-      DYNAMICTOP_PTR = e.data.DYNAMICTOP_PTR;
-
-
-//#if WASM
-      if (e.data.wasmModule) {
-        // Module and memory were sent from main thread
-        Module['wasmModule'] = e.data.wasmModule;
-        Module['wasmMemory'] = e.data.wasmMemory;
-        buffer = Module['wasmMemory'].buffer;
+      TOTAL_MEMORY = Module['TOTAL_MEMORY'] = TOTAL_MEMORY = e.data.TOTAL_MEMORY;
+      STATICTOP = Module['STATICTOP'] = e.data.STATICTOP;
+      DYNAMIC_BASE = Module['DYNAMIC_BASE'] = e.data.DYNAMIC_BASE;
+      DYNAMICTOP_PTR = Module['DYNAMICTOP_PTR'] = e.data.DYNAMICTOP_PTR;
+
+#if WASM
+      // The Wasm module will have import fields for STACKTOP and STACK_MAX. At 'load' stage of Worker startup, we are just
+      // spawning this Web Worker to act as a host for future created pthreads, i.e. we do not have a pthread to start up here yet.
+      // (A single Worker can also host multiple pthreads throughout its lifetime, shutting down a pthread will not shut down its hosting Worker,
+      // but the Worker is reused for later spawned pthreads). The 'run' stage below will actually start running a pthread.
+      // The stack space for a pthread is allocated and deallocated when a pthread is actually run, not yet at Worker 'load' stage.
+      // However, the WebAssembly module we are loading up here has import fields for STACKTOP and STACK_MAX, which it needs to get filled in
+      // immediately at Wasm Module instantiation time. The values of these will not get used until pthread is actually running some code, so
+      // we'll proceed to set up temporary invalid values for these fields for import purposes. Then whenever a pthread is launched at 'run' stage
+      // below, these values are rewritten to establish proper stack area for the particular pthread.
+      Module['STACK_MAX'] = Module['STACKTOP'] = 0x7FFFFFFF;
+
+      // Module and memory were sent from main thread
+      Module['wasmModule'] = e.data.wasmModule;
+      Module['wasmMemory'] = e.data.wasmMemory;
+      buffer = Module['buffer'] = Module['wasmMemory'].buffer;
+#else
+      buffer = Module['buffer'] = e.data.buffer;
+
+#if SEPARATE_ASM != 0
+      // load the separated-out asm.js
+      e.data.asmJsUrlOrBlob = e.data.asmJsUrlOrBlob || '{{{ SEPARATE_ASM }}}';
+      if (typeof e.data.asmJsUrlOrBlob === 'string') {
+        importScripts(e.data.asmJsUrlOrBlob);
       } else {
-//#else
-        buffer = e.data.buffer;
+        var objectUrl = URL.createObjectURL(e.data.asmJsUrlOrBlob);
+        importScripts(objectUrl);
+        URL.revokeObjectURL(objectUrl);
       }
-//#endif
+#endif
+
+#endif
 
-      PthreadWorkerInit = e.data.PthreadWorkerInit;
+      Module['PthreadWorkerInit'] = e.data.PthreadWorkerInit;
       if (typeof e.data.urlOrBlob === 'string') {
         importScripts(e.data.urlOrBlob);
       } else {
         var objectUrl = URL.createObjectURL(e.data.urlOrBlob);
         importScripts(objectUrl);
         URL.revokeObjectURL(objectUrl);
       }
-//#if !ASMFS
+
+#if MODULARIZE
+      Module = {{{EXPORT_NAME}}}(Module);
+      PThread = Module.PThread;
+      HEAPU32 = Module.HEAPU32;
+#endif
+
+#if !ASMFS
       if (typeof FS !== 'undefined' && typeof FS.createStandardStreams === 'function') FS.createStandardStreams();
-//#endif
+#endif
       postMessage({ cmd: 'loaded' });
     } else if (e.data.cmd === 'objectTransfer') {
       PThread.receiveObjectTransfer(e.data);
     } else if (e.data.cmd === 'run') { // This worker was idle, and now should start executing its pthread entry point.
       __performance_now_clock_drift = performance.now() - e.data.time; // Sync up to the clock of the main thread.
       threadInfoStruct = e.data.threadInfoStruct;
-      __register_pthread_ptr(threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0); // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
+      Module.__register_pthread_ptr(threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0); // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
       assert(threadInfoStruct);
       selfThreadId = e.data.selfThreadId;
       parentThreadId = e.data.parentThreadId;
       assert(selfThreadId);
       assert(parentThreadId);
       // TODO: Emscripten runtime has these variables twice(!), once outside the asm.js module, and a second time inside the asm.js module.
       //       Review why that is? Can those get out of sync?
-      STACK_BASE = STACKTOP = e.data.stackBase;
-      STACK_MAX = STACK_BASE + e.data.stackSize;
+      STACK_BASE = STACKTOP = Module['STACK_BASE'] = Module['STACKTOP'] = e.data.stackBase;
+      STACK_MAX = Module['STACK_MAX'] = STACK_BASE + e.data.stackSize;
       assert(STACK_BASE != 0);
       assert(STACK_MAX > STACK_BASE);
       Module['establishStackSpace'](e.data.stackBase, e.data.stackBase + e.data.stackSize);
-      var result = 0;
-//#if STACK_OVERFLOW_CHECK
-      if (typeof writeStackCookie === 'function') writeStackCookie();
-//#endif
+#if MODULARIZE
+      Module['establishStackSpaceInModule'](e.data.stackBase, e.data.stackBase + e.data.stackSize);
+#endif
+#if STACK_OVERFLOW_CHECK
+      Module.writeStackCookie();
+#endif
 
       PThread.receiveObjectTransfer(e.data);
-      PThread.setThreadStatus(_pthread_self(), 1/*EM_THREAD_STATUS_RUNNING*/);
+      PThread.setThreadStatus(Module._pthread_self(), 1/*EM_THREAD_STATUS_RUNNING*/);
 
+      var result = 0;
       try {
         // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
         // Native codebases sometimes spawn threads with other thread entry point signatures,
@@ -150,9 +184,9 @@ this.onmessage = function(e) {
         // flag -s EMULATE_FUNCTION_POINTER_CASTS=1 to add in emulation for this x86 ABI extension.
         result = Module['dynCall_ii'](e.data.start_routine, e.data.arg);
 
-//#if STACK_OVERFLOW_CHECK
-        if (typeof checkStackCookie === 'function') checkStackCookie();
-//#endif
+#if STACK_OVERFLOW_CHECK
+        Module.checkStackCookie();
+#endif
 
       } catch(e) {
         if (e === 'Canceled!') {
@@ -161,10 +195,10 @@ this.onmessage = function(e) {
         } else if (e === 'SimulateInfiniteLoop') {
           return;
         } else {
-          Atomics.store(HEAPU32, (threadInfoStruct + 4 /*{{{ C_STRUCTS.pthread.threadExitCode }}}*/ ) >> 2, (e instanceof ExitStatus) ? e.status : -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
-          Atomics.store(HEAPU32, (threadInfoStruct + 0 /*{{{ C_STRUCTS.pthread.threadStatus }}}*/ ) >> 2, 1); // Mark the thread as no longer running.
-          _emscripten_futex_wake(threadInfoStruct + 0 /*{{{ C_STRUCTS.pthread.threadStatus }}}*/, 0x7FFFFFFF/*INT_MAX*/); // Wake all threads waiting on this thread to finish.
-          if (!(e instanceof ExitStatus)) throw e;
+          Atomics.store(HEAPU32, (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, (e instanceof Module.ExitStatus) ? e.status : -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
+          Atomics.store(HEAPU32, (threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/ ) >> 2, 1); // Mark the thread as no longer running.
+          Module._emscripten_futex_wake(threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/, 0x7FFFFFFF/*INT_MAX*/); // Wake all threads waiting on this thread to finish.
+          if (!(e instanceof Module.ExitStatus)) throw e;
         }
       }
       // The thread might have finished without calling pthread_exit(). If so, then perform the exit operation ourselves.
@@ -178,7 +212,7 @@ this.onmessage = function(e) {
       // no-op
     } else if (e.data.cmd === 'processThreadQueue') {
       if (threadInfoStruct) { // If this thread is actually running?
-        _emscripten_current_thread_process_queued_calls();
+        Module['_emscripten_current_thread_process_queued_calls']();
       }
     } else {
       err('worker.js received unknown command ' + e.data.cmd);

tools/preprocessor.js

@@ -132,11 +132,12 @@ set = function() {}
 
 var settings_file = arguments_[0];
 var shell_file = arguments_[1];
+var process_macros = arguments_.length >= 3 && arguments_[2];
 
 load(settings_file);
 load('parseTools.js');
 
 var from_html = read(shell_file);
-var to_html = preprocess(from_html);
+var to_html = process_macros ? processMacros(preprocess(from_html)) : preprocess(from_html);
 
 print(to_html);

tools/separate_asm.py

@@ -18,13 +18,19 @@
 infile = sys.argv[1]
 asmfile = sys.argv[2]
 otherfile = sys.argv[3]
+asm_module_name = sys.argv[4]
+if asm_module_name.startswith('var ') or asm_module_name.startswith('let '):
+  asm_module_name_without_var = asm_module_name[4:]
+else:
+  asm_module_name_without_var = asm_module_name
+
 
 everything = open(infile).read()
 module = asm_module.AsmModule(infile).asm_js
 
 module = module[module.find('=')+1:] # strip the initial "var asm =" bit, leave just the raw module as a function
 if 'var Module' in everything:
-  everything = everything.replace(module, 'Module["asm"]')
+  everything = everything.replace(module, asm_module_name_without_var)
 else:
   # closure compiler removes |var Module|, we need to find the closured name
   # seek a pattern like (e.ENVIRONMENT), which is in the shell.js if-cascade for the ENVIRONMENT override
@@ -37,7 +43,7 @@
   everything = everything.replace(module, closured_name + '["asm"]')
 
 o = open(asmfile, 'w')
-o.write('Module["asm"] = ')
+o.write(asm_module_name + ' = ')
 o.write(module)
 o.write(';')
 o.close()