Synchronize wallclock times reported by emscripten_get_now() across all pthreads for consistency.

Author: juj

src/library.js

@@ -3979,6 +3979,11 @@ LibraryManager.library = {
                                "    var t = process['hrtime']();\n" +
                                "    return t[0] * 1e3 + t[1] / 1e6;\n" +
                                "  };\n" +
+#if USE_PTHREADS
+// Pthreads need their clocks synchronized to the execution of the main thread, so give them a special form of the function.
+                               "} else if (ENVIRONMENT_IS_PTHREAD) {\n" +
+                               "  _emscripten_get_now = function() { return performance['now']() - __performance_now_clock_drift; };\n" +
+#endif
                                "} else if (typeof dateNow !== 'undefined') {\n" +
                                "  _emscripten_get_now = dateNow;\n" +
                                "} else if (typeof self === 'object' && self['performance'] && typeof self['performance']['now'] === 'function') {\n" +

src/library_pthread.js

@@ -322,6 +322,12 @@ var LibraryPThread = {
           } else if (d.cmd === 'cancelThread') {
             __cancel_thread(d.thread);
           } else if (d.cmd === 'loaded') {
+            worker.loaded = true;
+            // If this Worker is already pending to start running a thread, launch the thread now
+            if (worker.runPthread) {
+              worker.runPthread();
+              delete worker.runPthread;
+            }
             ++numWorkersLoaded;
             if (numWorkersLoaded === numWorkers && onFinishedLoading) {
               onFinishedLoading();
@@ -477,22 +483,29 @@ var LibraryPThread = {
 #endif
 
     worker.pthread = pthread;
-
-    // Ask the worker to start executing its pthread entry point function.
-    worker.postMessage({
-      cmd: 'run',
-      start_routine: threadParams.startRoutine,
-      arg: threadParams.arg,
-      threadInfoStruct: threadParams.pthread_ptr,
-      selfThreadId: threadParams.pthread_ptr, // TODO: Remove this since thread ID is now the same as the thread address.
-      parentThreadId: threadParams.parent_pthread_ptr,
-      stackBase: threadParams.stackBase,
-      stackSize: threadParams.stackSize,
+    var msg = {
+        cmd: 'run',
+        start_routine: threadParams.startRoutine,
+        arg: threadParams.arg,
+        threadInfoStruct: threadParams.pthread_ptr,
+        selfThreadId: threadParams.pthread_ptr, // TODO: Remove this since thread ID is now the same as the thread address.
+        parentThreadId: threadParams.parent_pthread_ptr,
+        stackBase: threadParams.stackBase,
+        stackSize: threadParams.stackSize,
 #if OFFSCREENCANVAS_SUPPORT
-      moduleCanvasId: threadParams.moduleCanvasId,
-      offscreenCanvases: threadParams.offscreenCanvases,
+        moduleCanvasId: threadParams.moduleCanvasId,
+        offscreenCanvases: threadParams.offscreenCanvases,
 #endif
-    }, threadParams.transferList);
+      };
+    worker.runPthread = function() {
+      // Ask the worker to start executing its pthread entry point function.
+      msg.time = performance.now();
+      worker.postMessage(msg, threadParams.transferList);
+    };
+    if (worker.loaded) {
+      worker.runPthread();
+      delete worker.runPthread;
+    }
   },
 
 #if USE_PTHREADS

src/pthread-main.js

@@ -23,6 +23,12 @@ var DYNAMIC_BASE = 0;
 
 var ENVIRONMENT_IS_PTHREAD = true;
 
+// 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)
+var __performance_now_clock_drift = 0;
+
 // Cannot use console.log or console.error in a web worker, since that would risk a browser deadlock! https://bugzilla.mozilla.org/show_bug.cgi?id=1049091
 // Therefore implement custom logging facility for threads running in a worker, which queue the messages to main thread to print.
 var Module = {};
@@ -106,6 +112,7 @@ this.onmessage = function(e) {
     } 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.
       assert(threadInfoStruct);
@@ -126,17 +133,18 @@ this.onmessage = function(e) {
 //#endif
 
       PThread.receiveObjectTransfer(e.data);
-
       PThread.setThreadStatus(_pthread_self(), 1/*EM_THREAD_STATUS_RUNNING*/);
 
       try {
-        // HACK: Some code in the wild has instead signatures of form 'void *ThreadMain()', which seems to be ok in native code.
-        // To emulate supporting both in test suites, use the following form. This is brittle!
-        if (typeof Module['asm']['dynCall_ii'] !== 'undefined') {
-          result = Module['asm'].dynCall_ii(e.data.start_routine, e.data.arg); // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
-        } else {
-          result = Module['asm'].dynCall_i(e.data.start_routine); // as a hack, try signature 'i' as fallback.
-        }
+      // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
+      // Native codebases sometimes spawn threads with other thread entry point signatures,
+      // such as void ThreadMain(void *arg), void *ThreadMain(), or void ThreadMain().
+      // That is not acceptable per C/C++ specification, but x86 compiler ABI extensions
+      // enable that to work. If you find the following line to crash, either change the signature
+      // to "proper" void *ThreadMain(void *arg) form, or try linking with the Emscripten linker
+      // flag -s EMULATE_FUNCTION_POINTER_CASTS=1 to add in emulation for this x86 ABI extension.
+      result = Module['asm'].dynCall_ii(e.data.start_routine, e.data.arg);
+
 //#if STACK_OVERFLOW_CHECK
         if (typeof checkStackCookie === 'function') checkStackCookie();
 //#endif
@@ -163,6 +171,10 @@ this.onmessage = function(e) {
       }
     } else if (e.data.target === 'setimmediate') {
       // no-op
+    } else if (e.data.cmd === 'processThreadQueue') {
+      if (threadInfoStruct) { // If this thread is actually running?
+        _emscripten_current_thread_process_queued_calls();
+      }
     } else {
       Module['printErr']('pthread-main.js received unknown command ' + e.data.cmd);
       console.error(e.data);

tests/pthread/test_pthread_clock_drift.cpp

@@ -0,0 +1,55 @@
+#include <pthread.h>
+#include <emscripten.h>
+#include <emscripten/threading.h>
+#include <math.h>
+
+volatile int threadStarted = 0;
+volatile int timeReceived = 0;
+volatile double mainThreadTime;
+
+void wait(volatile int *address)
+{
+	int state = emscripten_atomic_load_u32((void*)address);
+	while(state == 0)
+		state = emscripten_atomic_load_u32((void*)address);
+}
+
+void wake(volatile int *address)
+{
+	emscripten_atomic_store_u32((void*)address, 1);
+}
+
+void *thread_main(void *arg)
+{
+	wake(&threadStarted);
+	wait(&timeReceived);
+	double pthreadTime = emscripten_get_now();
+	double timeDifference = pthreadTime - mainThreadTime;
+	printf("Time difference between pthread and main thread is %f msecs.\n", timeDifference);
+
+#ifdef REPORT_RESULT
+	REPORT_RESULT(fabs(timeDifference) < 200); // The time difference here should be well less than 1 msec, but test against 200msecs to be super-sure.
+#endif
+	return 0;
+}
+
+void busy_sleep(double msecs)
+{
+	double end = emscripten_get_now() + msecs;
+	while(emscripten_get_now() < end)
+		;
+}
+
+int main()
+{
+	// Cause a one second delay between main() and pthread start that might have a chance to drift the wallclocks on emscripten_get_now().
+	busy_sleep(1000);
+
+	pthread_t thread;
+	pthread_create(&thread, NULL, thread_main, NULL);
+	wait(&threadStarted);
+	mainThreadTime = emscripten_get_now();
+	wake(&timeReceived);
+
+	EM_ASM(Module['noExitRuntime']=true);
+}

tests/test_browser.py

@@ -3349,6 +3349,10 @@ def test_pthread_global_data_initialization(self):
       for args in [[], ['-O3']]:
         self.btest(path_from_root('tests', 'pthread', 'test_pthread_global_data_initialization.c'), expected='20', args=args+mem_init_mode+['-s', 'USE_PTHREADS=1', '-s', 'PROXY_TO_PTHREAD=1'], also_wasm=False)
 
+  # Test that emscripten_get_now() reports coherent wallclock times across all pthreads, instead of each pthread independently reporting wallclock times since the launch of that pthread.
+  def test_pthread_clock_drift(self):
+    self.btest(path_from_root('tests', 'pthread', 'test_pthread_clock_drift.cpp'), expected='1', args=['-O3', '-s', 'USE_PTHREADS=1', '-s', 'PROXY_TO_PTHREAD=1'])
+
   # test atomicrmw i64
   def test_atomicrmw_i64(self):
     Popen([PYTHON, EMCC, path_from_root('tests', 'atomicrmw_i64.ll'), '-s', 'USE_PTHREADS=1', '-s', 'IN_TEST_HARNESS=1', '-o', 'test.html']).communicate()