Tests for webworker

Author: tilk

.github/workflows/nodejs.yml

@@ -9,7 +9,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [10.x, 12.x]
+        node-version: [12.x, 14.x, 16.x]
 
     steps:
     - uses: actions/checkout@v2

babel.config.json

@@ -11,5 +11,5 @@
       }
     ]
   ],
-  "plugins": ["babel-plugin-add-import-extension"]
+  "plugins": ["babel-plugin-add-import-extension", "babel-plugin-transform-import-meta"]
 }

package-lock.json

@@ -36,6 +36,7 @@
     "babel-jest": "^26.6.3",
     "babel-loader": "^8.2.2",
     "babel-plugin-add-import-extension": "^1.6.0",
+    "babel-plugin-transform-import-meta": "^2.0.0",
     "clean-webpack-plugin": "^2.0.2",
     "css-loader": "^6.2.0",
     "expose-loader": "^3.0.0",
@@ -47,7 +48,7 @@
     "webpack-cli": "^4.7.2"
   },
   "dependencies": {
-    "3vl": "^0.3.5",
+    "3vl": "^1.0.0",
     "babel-polyfill": "^6.26.0",
     "dagre": "^0.8.5",
     "elkjs": "^0.7.1",
@@ -58,7 +59,8 @@
     "jquery-ui": "^1.12.1",
     "regenerator-runtime": "^0.13.9",
     "resize-observer-polyfill": "^1.5.1",
-    "wavecanvas": "^0.2.5"
+    "wavecanvas": "^1.0.0",
+    "web-worker": "^1.0.0"
   },
   "homepage": "https://github.com/tilk/digitaljs",
   "repository": {

package.json

@@ -66,12 +66,13 @@ export function getCellType(tp) {
 }
 
 export class HeadlessCircuit {
-    constructor(data, {cellsNamespace = {}, engine = SynchEngine} = {}) {
+    constructor(data, {cellsNamespace = {}, engine = SynchEngine, engineOptions = {}} = {}) {
         this._cells = Object.assign(cells, cellsNamespace);
         this._display3vl = new Display3vl();
         this._display3vl.addDisplay(new help.Display3vlASCII());
         this._graph = this._makeGraph(data, data.subcircuits);
-        this._engine = new engine(this._graph, this._cells);
+        engineOptions.cells = this._cells;
+        this._engine = new engine(this._graph, engineOptions);
         this.makeLabelIndex();
         this.listenTo(this._engine, 'postUpdateGates', (tick, count) => {
             this.trigger('postUpdateGates', tick, count);
@@ -170,11 +171,14 @@ export class HeadlessCircuit {
         if (laid_out) graph.set('laid_out', true);
         return graph;
     }
-    updateGatesNext() {
-        this._engine.updateGatesNext();
+    updateGatesNext(opts) {
+        return this._engine.updateGatesNext(opts);
     }
-    updateGates() {
-        this._engine.updateGates();
+    updateGates(opts) {
+        return this._engine.updateGates(opts);
+    }
+    synchronize() {
+        return this._engine.synchronize();
     }
     get hasPendingEvents() {
         return this._engine.hasPendingEvents;
@@ -185,15 +189,15 @@ export class HeadlessCircuit {
     start() {
         if (this.hasWarnings())
             return; //todo: print/show error
-        this._engine.start();
+        return this._engine.start();
     }
     startFast() {
         if (this.hasWarnings())
             return; //todo: print/show error
-        this._engine.startFast();
+        return this._engine.startFast();
     }
-    stop() {
-        this._engine.stop();
+    stop(opts) {
+        return this._engine.stop(opts);
     }
     get interval() {
         return this._engine.interval;
@@ -229,7 +233,8 @@ export class HeadlessCircuit {
                 devices: {},
                 subcircuits: {},
                 inputs: {},
-                outputs: {}
+                outputs: {},
+                graph
             };
             for (const elem of graph.getElements()) {
                 if (elem.has('net')) {
@@ -311,6 +316,12 @@ export class HeadlessCircuit {
     unmonitor(monitorId) {
         this._engine.unmonitor(monitorId);
     }
+    observeGraph(path = []) {
+        this._engine.observeGraph(this.getLabelIndex(path).graph);
+    }
+    unobserveGraph(path = []) {
+        this._engine.observeGraph(this.getLabelIndex(path).graph);
+    }
 };
 
 _.extend(HeadlessCircuit.prototype, Backbone.Events);

src/circuit.mjs

@@ -2,8 +2,8 @@
 import { SynchEngine } from './synch.mjs';
 
 export class BrowserSynchEngine extends SynchEngine {
-    constructor(graph, cells) {
-        super(graph, cells);
+    constructor(graph, opts) {
+        super(graph, opts);
         this._interval_ms = 10;
         this._interval = null;
         this._idle = null;
@@ -37,6 +37,7 @@ export class BrowserSynchEngine extends SynchEngine {
             this._idle = null;
         }
         this.trigger('changeRunning');
+        return Promise.resolve();
     }
     get interval() {
         return this._interval_ms;

src/engines/browsersynch.mjs

@@ -5,7 +5,7 @@ import * as help from '../help.mjs';
 import { BaseEngine } from './base.mjs';
 
 export class SynchEngine extends BaseEngine {
-    constructor(graph, cells) {
+    constructor(graph, {cells}) {
         super(graph);
         this._queue = new Map();
         this._pq = new FastPriorityQueue();
@@ -102,24 +102,28 @@ export class SynchEngine extends BaseEngine {
         this._queue.delete(k);
         this._tick = (k + 1) | 0;
         this.trigger('postUpdateGates', k, count);
-        return count;
+        return Promise.resolve(count);
     }
     updateGates() {
         if (this._pq.peek() == this._tick) return this.updateGatesNext();
         else {
             const k = this._tick | 0;
             this._tick = (k + 1) | 0;
             this.trigger('postUpdateGates', k, 0);
-            return 0;
+            return Promise.resolve(0);
         }
     }
+    synchronize() {
+        return Promise.resolve();
+    }
     start() {
         throw new Error("start() not supported");
     }
     startFast() {
         throw new Error("startFast() not supported");
     }
     stop() {
+        return Promise.resolve()
     }
     get interval() {
         throw new Error("interval not supported");

src/engines/synch.mjs

@@ -162,18 +162,30 @@ class WorkerEngineWorker {
     interval(ms) {
         this._interval = ms;
     }
-    updateGates() {
-        if (this._pq.peek() == this._tick) this.updateGatesNext();
+    updateGates(reqid, sendUpdates) {
+        const count = this._updateGates();
+        if (sendUpdates) this._sendUpdates();
+        this._sendAck(reqid, count);
+    }
+    _updateGates() {
+        if (this._pq.peek() == this._tick) return this._updateGatesNext();
         else {
             const k = this._tick | 0;
             this._tick = (k + 1) | 0;
+            return 0;
         }
     }
-    updateGatesNext() {
+    updateGatesNext(reqid, sendUpdates) {
+        const count = this._updateGatesNext();
+        if (sendUpdates) this._sendUpdates();
+        this._sendAck(reqid, count);
+    }
+    _updateGatesNext() {
         const k = this._pq.poll() | 0;
         console.assert(k >= this._tick);
         this._tick = k;
         const q = this._queue.get(k);
+        let count = 0;
         while (q.size) {
             const [gate, args] = q.entries().next().value;
             q.delete(gate);
@@ -186,25 +198,36 @@ class WorkerEngineWorker {
                 this._enqueue(gate);
             }
             this._setGateOutputSignals(gate, newOutputs);
+            count++;
         }
         this._queue.delete(k);
         this._tick = (k + 1) | 0;
+        return count;
+    }
+    ping(reqid, sendUpdates) {
+        if (sendUpdates) this._sendUpdates();
+        this._sendAck(reqid);
     }
     start() {
-        this.stop();
+        this._stop();
         this._updater = setInterval(() => {
-            this.updateGates();
+            this._updateGates();
         }, this._interval);
     }
     startFast() {
-        this.stop();
+        this._stop();
         this._updater = setInterval(() => {
             const startTime = Date.now();
             while (Date.now() - startTime < 10 && this._hasPendingEvents() && this._updater)
-                this.updateGatesNext();
+                this._updateGatesNext();
         }, 10);
     }
-    stop() {
+    stop(reqid, sendUpdates) {
+        this._stop();
+        if (sendUpdates) this._sendUpdates();
+        this._sendAck(reqid);
+    }
+    _stop() {
         if (this._updater) {
             clearInterval(this._updater);
             this._updater = null;
@@ -326,7 +349,7 @@ class WorkerEngineWorker {
                     triggered = triggerValues.some((triggerValue) => sig.eq(triggerValue));
                 if (triggered) {
                     postMessage({ type: 'monitorValue', args: [monitorId, this._tick, sig, stopOnTrigger] });
-                    if (stopOnTrigger) this.stop();
+                    if (stopOnTrigger) this._stop();
                 }
             }
         }
@@ -394,14 +417,17 @@ class WorkerEngineWorker {
             this._toUpdateParam = new Map();
         }
     }
+    _sendAck(reqid, response) {
+        postMessage({ type: 'ack', args: [reqid, response] });
+    }
     _hasPendingEvents() {
         return this._queue.size > 0;
     }
 };
 
 const worker = new WorkerEngineWorker();
 
-onmessage = (e) => {
+self.onmessage = (e) => {
     const msg = e.data;
     if ('arg' in msg)
         worker[msg.type](msg.arg);

src/engines/worker-worker.mjs

@@ -3,18 +3,20 @@ import _ from 'lodash';
 import { BaseEngine } from './base.mjs';
 import { Vector3vl } from '3vl';
 import * as cells from '../cells.mjs';
+import Worker from 'web-worker';
 
 export class WorkerEngine extends BaseEngine {
-    constructor(graph) {
+    constructor(graph, { workerURL }) {
         super(graph);
         this._running = false;
         this._tickCache = 0;
         this._pendingEventsCache = false;
         this._observers = Object.create(null);
         this._graphs = Object.create(null);
         this._monitors = Object.create(null);
+        this._promises = Object.create(null);
         this._uniqueCounter = 0;
-        this._worker = new Worker(new URL('./worker-worker.mjs', import.meta.url));
+        this._worker = workerURL ? new Worker(workerURL) : new Worker(new URL('./worker-worker.mjs', import.meta.url));
         this._worker.onmessage = (e) => this._handleMessage(e.data);
         this.interval = 10;
         this._addGraph(this._graph);
@@ -103,15 +105,24 @@ export class WorkerEngine extends BaseEngine {
     shutdown() {
         this._worker.terminate();
     }
-    updateGatesNext() {
+    synchronize() {
+        const [reqid, promise] = this._generatePromise();
+        this._worker.postMessage({ type: 'ping', args: [reqid, true] });
+        return promise;
+    }
+    updateGatesNext({ synchronous = false } = {}) {
         if (this._running)
             throw new Error("updateGatesNext while running");
-        this._worker.postMessage({ type: 'updateGatesNext' });
+        const [reqid, promise] = this._generatePromise();
+        this._worker.postMessage({ type: 'updateGatesNext', args: [reqid, synchronous] });
+        return promise;
     }
-    updateGates() {
+    updateGates({ synchronous = false } = {}) {
         if (this._running)
             throw new Error("updateGates while running");
-        this._worker.postMessage({ type: 'updateGates' });
+        const [reqid, promise] = this._generatePromise();
+        this._worker.postMessage({ type: 'updateGates', args: [reqid, synchronous] });
+        return promise;
     }
     start() {
         if (this.running)
@@ -127,11 +138,13 @@ export class WorkerEngine extends BaseEngine {
         this._running = 'fast';
         this.trigger('changeRunning');
     }
-    stop() {
+    stop({ synchronous = false } = {}) {
         if (!this._running) return;
-        this._worker.postMessage({ type: 'stop' });
+        const [reqid, promise] = this._generatePromise();
+        this._worker.postMessage({ type: 'stop', args: [reqid, synchronous] });
         this._running = false;
         this.trigger('changeRunning');
+        return promise;
     }
     get interval() {
         return this._interval;
@@ -219,6 +232,9 @@ export class WorkerEngine extends BaseEngine {
                 this._worker.postMessage({ type: this._running == 'fast' ? 'startFast' : 'start' });
         }
     }
+    _handle_ack(reqid, response) {
+        this._resolvePromise(reqid, response);
+    }
     _findGateByIds(graphId, gateId) {
             const graph = this._graphs[graphId];
             if (graph === undefined) return undefined;
@@ -227,5 +243,17 @@ export class WorkerEngine extends BaseEngine {
     _generateUniqueId() {
         return this._uniqueCounter++;
     }
+    _generatePromise() {
+        const reqid = this._generateUniqueId();
+        return [reqid, new Promise((resolve) => { this._promises[reqid] = resolve; })];
+    }
+    _resolvePromise(reqid, value) {
+        if (!this._promises[reqid]) {
+            console.warn("Missing promise", reqid);
+            return;
+        }
+        this._promises[reqid](value);
+        delete this._promises[reqid];
+    }
 };