Milestone 3 Build

index.html

@@ -137,7 +137,7 @@
 
 		<script src="index.js"></script>
 		<script>
-const GODOT_CONFIG = {"args":[],"canvasResizePolicy":2,"executable":"index","experimentalVK":false,"fileSizes":{"index.pck":376560,"index.wasm":1642372},"focusCanvas":true,"gdextensionLibs":["libgodot-solana-sdk.web.template_release.wasm32.wasm"]};
+const GODOT_CONFIG = {"args":[],"canvasResizePolicy":2,"executable":"index","experimentalVK":false,"fileSizes":{"index.pck":645456,"index.wasm":1758196},"focusCanvas":true,"gdextensionLibs":["libgodot-solana-sdk.web.template_release.wasm32.wasm"]};
 const engine = new Engine(GODOT_CONFIG);
 
 (function () {

index.worker.js

@@ -15,10 +15,6 @@ var Module = {};
 // Thread-local guard variable for one-time init of the JS state
 var initializedJS = false;
 
-// Proxying queues that were notified before the thread started and need to be
-// executed as part of startup.
-var pendingNotifiedProxyingQueues = [];
-
 function assert(condition, text) {
   if (!condition) abort('Assertion failed: ' + text);
 }
@@ -41,26 +37,59 @@ self.alert = threadAlert;
 Module['instantiateWasm'] = (info, receiveInstance) => {
   // Instantiate from the module posted from the main thread.
   // We can just use sync instantiation in the worker.
-  var instance = new WebAssembly.Instance(Module['wasmModule'], info);
-  receiveInstance(instance, Module['wasmModule']);
+  var module = Module['wasmModule'];
   // We don't need the module anymore; new threads will be spawned from the main thread.
   Module['wasmModule'] = null;
-  return instance.exports;
+  var instance = new WebAssembly.Instance(module, info);
+  return receiveInstance(instance, module);
 }
 
-self.onmessage = (e) => {
+// Turn unhandled rejected promises into errors so that the main thread will be
+// notified about them.
+self.onunhandledrejection = (e) => {
+  throw e.reason ?? e;
+};
+
+function handleMessage(e) {
   try {
     if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
 
+    // Until we initialize the runtime, queue up any further incoming messages.
+    let messageQueue = [];
+    self.onmessage = (e) => messageQueue.push(e);
+
+    // And add a callback for when the runtime is initialized.
+    self.startWorker = (instance) => {
+      Module = instance;
+      // Notify the main thread that this thread has loaded.
+      postMessage({ 'cmd': 'loaded' });
+      // Process any messages that were queued before the thread was ready.
+      for (let msg of messageQueue) {
+        handleMessage(msg);
+      }
+      // Restore the real message handler.
+      self.onmessage = handleMessage;
+    };
+
       // Module and memory were sent from main thread
       Module['wasmModule'] = e.data.wasmModule;
 
       Module['dynamicLibraries'] = e.data.dynamicLibraries;
 
+      // Use `const` here to ensure that the variable is scoped only to
+      // that iteration, allowing safe reference from a closure.
+      for (const handler of e.data.handlers) {
+        Module[handler] = function() {
+          postMessage({ cmd: 'callHandler', handler, args: [...arguments] });
+        }
+      }
+
       Module['wasmMemory'] = e.data.wasmMemory;
 
       Module['buffer'] = Module['wasmMemory'].buffer;
 
+      Module['workerID'] = e.data.workerID;
+
       Module['ENVIRONMENT_IS_PTHREAD'] = true;
 
       if (typeof e.data.urlOrBlob == 'string') {
@@ -70,83 +99,49 @@ self.onmessage = (e) => {
         importScripts(objectUrl);
         URL.revokeObjectURL(objectUrl);
       }
-      Godot(Module).then(function (instance) {
-        Module = instance;
-      });
+      Godot(Module);
     } else if (e.data.cmd === 'run') {
-      // This worker was idle, and now should start executing its pthread entry
-      // point.
-      // performance.now() is specced to return a wallclock time in msecs since
-      // that Web Worker/main thread launched. However for pthreads this can
-      // cause subtle problems in emscripten_get_now() as this essentially
-      // would measure time from pthread_create(), meaning that the clocks
-      // between each threads would be wildly out of sync. Therefore sync all
-      // pthreads to the clock on the main browser thread, so that different
-      // threads see a somewhat coherent clock across each of them
-      // (+/- 0.1msecs in testing).
-      Module['__performance_now_clock_drift'] = performance.now() - e.data.time;
-
       // 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);
 
+      // Await mailbox notifications with `Atomics.waitAsync` so we can start
+      // using the fast `Atomics.notify` notification path.
+      Module['__emscripten_thread_mailbox_await'](e.data.pthread_ptr);
+
       assert(e.data.pthread_ptr);
       // Also call inside JS module to set up the stack frame for this pthread in JS module scope
       Module['establishStackSpace']();
       Module['PThread'].receiveObjectTransfer(e.data);
       Module['PThread'].threadInitTLS();
 
       if (!initializedJS) {
-
-        // Execute any proxied work that came in before the thread was
-        // initialized. Only do this once because it is only possible for
-        // proxying notifications to arrive before thread initialization on
-        // fresh workers.
-        pendingNotifiedProxyingQueues.forEach(queue => {
-          Module['executeNotifiedProxyingQueue'](queue);
-        });
-        pendingNotifiedProxyingQueues = [];
         initializedJS = true;
       }
 
       try {
         Module['invokeEntryPoint'](e.data.start_routine, e.data.arg);
       } catch(ex) {
         if (ex != 'unwind') {
-          // ExitStatus not present in MINIMAL_RUNTIME
-          if (ex instanceof Module['ExitStatus']) {
-            if (Module['keepRuntimeAlive']()) {
-              err('Pthread 0x' + Module['_pthread_self']().toString(16) + ' called exit(), staying alive due to noExitRuntime.');
-            } else {
-              err('Pthread 0x' + Module['_pthread_self']().toString(16) + ' called exit(), calling _emscripten_thread_exit.');
-              Module['__emscripten_thread_exit'](ex.status);
-            }
-          }
-          else
-          {
-            // The pthread "crashed".  Do not call `_emscripten_thread_exit` (which
-            // would make this thread joinable.  Instead, re-throw the exception
-            // and let the top level handler propagate it back to the main thread.
-            throw ex;
-          }
-        } else {
-          // else e == 'unwind', and we should fall through here and keep the pthread alive for asynchronous events.
-          err('Pthread 0x' + Module['_pthread_self']().toString(16) + ' completed its main entry point with an `unwind`, keeping the worker alive for asynchronous operation.');
+          // The pthread "crashed".  Do not call `_emscripten_thread_exit` (which
+          // would make this thread joinable).  Instead, re-throw the exception
+          // and let the top level handler propagate it back to the main thread.
+          throw ex;
         }
       }
     } else if (e.data.cmd === 'cancel') { // Main thread is asking for a pthread_cancel() on this thread.
       if (Module['_pthread_self']()) {
-        Module['__emscripten_thread_exit'](-1/*PTHREAD_CANCELED*/);
+        Module['__emscripten_thread_exit'](-1);
       }
     } else if (e.data.target === 'setimmediate') {
       // no-op
-    } else if (e.data.cmd === 'processProxyingQueue') {
+    } else if (e.data.cmd === 'checkMailbox') {
       if (initializedJS) {
-        Module['executeNotifiedProxyingQueue'](e.data.queue);
-      } else {
-        // Defer executing this queue until the runtime is initialized.
-        pendingNotifiedProxyingQueues.push(e.data.queue);
+        Module['checkMailbox']();
       }
-    } else {
+    } else if (e.data.cmd) {
+      // The received message looks like something that should be handled by this message
+      // handler, (since there is a e.data.cmd field present), but is not one of the
+      // recognized commands:
       err('worker.js received unknown command ' + e.data.cmd);
       err(e.data);
     }
@@ -160,4 +155,6 @@ self.onmessage = (e) => {
   }
 };
 
+self.onmessage = handleMessage;
+