Fix Atomics.wait usage, do it in worker thread + use Int32Array + use timeout 10ms

Author: dfordivam

jsaddleJS/jsaddle.js

@@ -328,6 +328,9 @@ function jsaddleHandlerMsgs (msgs) {
 var jsaddleMsgSharedBuf = new SharedArrayBuffer(10*1024*1024);
 var jsaddleMsgBufArray = new Uint8Array(jsaddleMsgSharedBuf);
 var jsaddleMsgBufArray32 = new Uint32Array(jsaddleMsgSharedBuf);
+// Atomics.wait need Int32
+var jsaddleMsgBufArrayInt32 = new Int32Array(jsaddleMsgSharedBuf);
+var jsaddle_sendMsgWorker = new Worker('jsaddle_sendMsgWorker.js');
 
 function sendAPI (msg) {
   var str = JSON.stringify(msg);
@@ -338,32 +341,19 @@ function sendAPI (msg) {
   dataview.setUint32(0, size);
   const uint8 = new Uint8Array(b);
   uint8.set(a, 4);
-  // non-blocking
-  appendMsgToSharedBuf(uint8);
-}
-
-async function appendMsgToSharedBuf(buf) {
-  var isAlreadyLocked = Atomics.compareExchange(jsaddleMsgBufArray32, 0, 0, 1);
-  if (isAlreadyLocked === 1) {
-    Atomics.wait(jsaddleMsgBufArray32, 0, 0);
-    appendMsgToSharedBuf(buf);
-  } else {
-    var len = buf.byteLength;
-    var prevLen = jsaddleMsgBufArray32[1];
-    var totalLen = len + prevLen;
-    var startOffset = prevLen + 8; // Two 32 bit uint
-    var i = len;
-    while (i--) jsaddleMsgBufArray[startOffset + i] = buf[i];
-    jsaddleMsgBufArray32[1] = totalLen;
-    // Release the lock
-    jsaddleMsgBufArray32[0] = 0;
-  }
+  jsaddle_sendMsgWorker.postMessage({
+    buf: b,
+    jsaddleMsgBufArrayInt32: jsaddleMsgBufArrayInt32,
+    jsaddleMsgBufArray32: jsaddleMsgBufArray32,
+    jsaddleMsgBufArray: jsaddleMsgBufArray
+  }, [b]);
 }
 
 function jsaddleJsInit() {
   return {
     jsaddleListener: channel.port2,
     jsaddleMsgBufArray: jsaddleMsgBufArray,
-    jsaddleMsgBufArray32: jsaddleMsgBufArray32
+    jsaddleMsgBufArray32: jsaddleMsgBufArray32,
+    jsaddleMsgBufArrayInt32: jsaddleMsgBufArrayInt32
   };
 }

jsaddleJS/jsaddle_sendMsgWorker.js

@@ -0,0 +1,27 @@
+// Atomics.wait is not possible on main thread
+// so this worker takes the messages from jsaddle.js and appends to the SharedArrayBuffer
+
+onmessage = function (msg) {
+  var jsaddleMsgBufArrayInt32 = msg.data.jsaddleMsgBufArrayInt32;
+  var jsaddleMsgBufArray32 = msg.data.jsaddleMsgBufArray32;
+  var jsaddleMsgBufArray = msg.data.jsaddleMsgBufArray;
+  const uint8 = new Uint8Array(msg.data.buf);
+  var appendMsgToSharedBuf = function () {
+    var isAlreadyLocked = Atomics.compareExchange(jsaddleMsgBufArrayInt32, 0, 0, 10);
+    if (isAlreadyLocked === 1) {
+      Atomics.wait(jsaddleMsgBufArrayInt32, 0, 0, 10);
+      appendMsgToSharedBuf();
+    } else {
+      var len = uint8.length;
+      var prevLen = jsaddleMsgBufArray32[1];
+      var totalLen = len + prevLen;
+      var startOffset = prevLen + 8; // Two 32 bit uint
+      var i = len;
+      while (i--) jsaddleMsgBufArray[startOffset + i] = uint8[i];
+      jsaddleMsgBufArray32[1] = totalLen;
+      // Release the lock
+      jsaddleMsgBufArrayInt32[0] = 0;
+    }
+  };
+  appendMsgToSharedBuf();
+}

src/JSaddleDevice.ts

@@ -11,9 +11,11 @@ export class JSaddleDevice implements Device {
   constructor(
     jsaddleListener: MessagePort,
     jsaddleMsgBufArray: Uint8Array,
-    jsaddleMsgBufArray32: Uint32Array) {
+    jsaddleMsgBufArray32: Uint32Array,
+    jsaddleMsgBufArrayInt32: Int32Array
+  ) {
     this._file = new JSaddleDeviceFile(this, jsaddleListener
-                                  , jsaddleMsgBufArray, jsaddleMsgBufArray32);
+                                  , jsaddleMsgBufArray, jsaddleMsgBufArray32, jsaddleMsgBufArrayInt32);
   }
 
   public open(flag: FileFlag): File {
@@ -31,7 +33,8 @@ export class JSaddleDeviceFile extends BaseFile implements File {
     private _Device: JSaddleDevice,
     private _jsaddleListener: MessagePort,
     private _jsaddleMsgBufArray: Uint8Array,
-    private _jsaddleMsgBufArray32: Uint32Array) {
+    private _jsaddleMsgBufArray32: Uint32Array,
+    private _jsaddleMsgBufArrayInt32: Int32Array) {
     super();
   }
   public getPos(): number | undefined {
@@ -94,7 +97,7 @@ export class JSaddleDeviceFile extends BaseFile implements File {
   }
   public readSync(buffer: Buffer, offset: number, length: number, position: number | null): number {
     var bytes_read = 0;
-    var isAlreadyLocked = Atomics.compareExchange(this._jsaddleMsgBufArray32, 0, 0, 1);
+    var isAlreadyLocked = Atomics.compareExchange(this._jsaddleMsgBufArrayInt32, 0, 0, 1);
     if (isAlreadyLocked === 0) {
       var bytes_available = this._jsaddleMsgBufArray32[1];
       if (bytes_available > 0) {
@@ -118,7 +121,7 @@ export class JSaddleDeviceFile extends BaseFile implements File {
         }
       }
       // Release the lock
-      this._jsaddleMsgBufArray32[0] = 0;
+      this._jsaddleMsgBufArrayInt32[0] = 0;
     }
     return bytes_read;
   }

src/worker_runner.ts

@@ -9,7 +9,8 @@ connectParent({ onMessage: async msg1 => {
   const jsaddleDevice = new JSaddleDevice(
     msg.jsaddleVals.jsaddleListener,
     msg.jsaddleVals.jsaddleMsgBufArray,
-    msg.jsaddleVals.jsaddleMsgBufArray32);
+    msg.jsaddleVals.jsaddleMsgBufArray32,
+    msg.jsaddleVals.jsaddleMsgBufArrayInt32);
   const fs = await configureFileSystem({ devices: { ["/jsaddle_inout"]: jsaddleDevice } });
   (await Process.instantiateProcess(fs, msg.url)).start([],[]);
 }});

www/jsaddle_sendMsgWorker.js

@@ -0,0 +1 @@
+../jsaddleJS/jsaddle_sendMsgWorker.js