backup

resources/workers/encWW.js

 
+let ident         = undefined;
 let encoder       = null;
 let isInited      = false;
 let isBridged     = false;
@@ -28,11 +29,10 @@ createParaEncoder().then(m => {
 
 // Init
 onmessage = async e => {
-  await main(e.data);
+  await eventloop(e.data);
 }
 
-async function main(msg) {
-
+async function eventloop(msg) {
   if (!isEncGrpMsg(msg)) return;
 
   switch (typeOfMsg(msg)) {
@@ -48,7 +48,7 @@ async function main(msg) {
       if (isBridged) await deBridging();
       break;
     case MESSAGE_TYPE.DATA:
-      if (isInited && isBridged) {
+      if (isBridged) {
         await steps();
       }
       break;
@@ -71,6 +71,7 @@ async function bridging(msg) {
   }
 
   bridge = new Channel(info.size, SharedArrayBuffer, info.shm);
+  postMessage(makeMsg(MESSAGE_TYPE.BRIDGE, {}));
   isBridged = true;
 }
 
@@ -82,6 +83,7 @@ async function deBridging() {
 async function init(msg) {
   let info = getInfoFromMsg(msg), ret;
   src = new Channel(info.size, SharedArrayBuffer, info.shm);
+  ident = info.ident;
 
   // Wait encoder init
   while (encoder == null)
@@ -131,10 +133,13 @@ async function steps() {
     if (await step() === false) {
       await sleep(SLEEP_INTERVAL);
       timeout -= SLEEP_INTERVAL;
+    } else {
+      timeout = SPIN_TIMEOUT;
     }
   }
 
   src.unsetPriv(PRIV_FLAGS.EXECUTING);
+  postMessage(makeMsg(MESSAGE_TYPE.DATA_REQUIRE, {ident:ident}))
 }
 
 ///////////////////////////////////////////////////////////////////////////////

resources/workers/muxWW.js

 
 // Status
+let ident = undefined;
 let isInited = false;
 let isBridged = false;
 let bridge = null;
@@ -118,4 +119,6 @@ async function steps() {
   }
 
   src.unsetPriv(MSG.PRIV_FLAGS.EXECUTING);
+  postMessage(makeMsg(MESSAGE_TYPE.DATA_REQUIRE, {}))
+
 }

src/WW.js

 
+import { MESSAGE_TYPE, typeOfMsg } from './encGrooupMsg';
 import { Observable, filter } from './rxjs';
 
 
@@ -9,6 +10,13 @@ export class WWInitError extends Error {
 }
 
 
+export const WW_STATE = Object.freeze({
+  UNINITIALIZED : 0,
+  READY         : 1,
+  RUNNING       : 2,
+});
+
+
 export class WW extends Observable {
 
   #ident = undefined;
@@ -18,7 +26,19 @@ export class WW extends Observable {
   #ww = undefined;
   #connected = {};
 
+  #remoteInited = false;
+  #remoteBridged = false;
+
+  #state = WW_STATE.UNINITIALIZED;
+
   constructor(name, path) {
+
+    if (typeof(name) != "string" ||
+        typeof(path) != "string") {
+
+      throw new TypeError("Mismatch arguments", "WW.js");
+    }
+
     super(subscriber => {
       this.#ww.onmessage =
         e => { subscriber.next(e.data); };
@@ -26,6 +46,8 @@ export class WW extends Observable {
 
     this.#ident = name;
     this.#ww = new Worker(path);
+
+    this.#monitor();
   }
 
   async start(initWork) {
@@ -85,9 +107,29 @@ export class WW extends Observable {
     return this.#ww.terminate();
   }
 
-  monitor() {
-    this.subscribe(msg => {
+  getState() {
+    return this.#state;
+  }
 
+  // Enable status tracking for WW,
+  // status of WW will map to local variables.
+  #monitor() {
+    this.subscribe(msg => {
+      switch (typeOfMsg(msg)) {
+        case MESSAGE_TYPE.INIT:
+          this.#remoteInited = true;
+          break;
+        case MESSAGE_TYPE.BRIDGE:
+          this.#remoteBridged = true;
+          break;
+      }
+
+      // Update State
+      if (this.#remoteInited && this.#remoteBridged) {
+        this.#state = WW_STATE.READY;
+      }
     });
+
   }
+
 }

src/encGrooupMsg.js

@@ -42,8 +42,8 @@ export function makeMsg(type, info_) {
   return { type: type, info: info_ };
 }
 
-export function makeInitMsg(shm, size) {
-  return makeMsg(MESSAGE_TYPE.INIT, {shm: shm, size:size})
+export function makeInitMsg(shm, size, ident) {
+  return makeMsg(MESSAGE_TYPE.INIT, {shm: shm, size:size, ident: ident})
 }
 
 export function typeOfMsg(msg) {

src/encGroup.js

@@ -182,7 +182,7 @@ async function muxInit(chnls, ww) {
   let channel = new Channel(Math.pow(2, 20));
 
   ww.postMessage(
-    makeInitMsg(channel.getShMem(), Math.pow(2, 20)));
+    makeInitMsg(channel.getShMem(), Math.pow(2, 20), ww.ident()));
   chnls[ww.ident()] = channel;
 
   return true;

tests/WW.spec.js

-import { WW } from '../src/WW.js';
+import { WW, WW_STATE } from '../src/WW.js';
 import { Channel } from '../src/channel.js';
 import { makeMsg, MESSAGE_TYPE } from '../src/encGrooupMsg.js';
 import { sleep, assert } from '../src/utils.js';
@@ -162,9 +162,32 @@ describe("EncWW Specifications", () => {
       }, 1000);
     });
 
-
     expect(ch2.dataSize()).toBe(26597);
     expect(ch2_.dataSize()).toBe(26597);
 
   }, 100000);
-})
+
+  it("Enc WW Spec", async () => {
+    let enc = new WW("ENC", "../resources/workers/encWW.js");
+
+    let mem = new SharedArrayBuffer(1024);
+    enc.postMessage(makeMsg(MESSAGE_TYPE.INIT, {shm: mem, size: 1024, ident: "ENC" }));
+
+    let memB = new SharedArrayBuffer(1024);
+    enc.postMessage(makeMsg(MESSAGE_TYPE.BRIDGE, { shm: memB, size: 1024 }));
+
+    await sleep(500);
+    expect(enc.getState() == WW_STATE.READY).toBe(true);
+
+    await sleep(1000);
+  });
+
+  fit("Mux WW Spec", async () => {
+    let mux = new WW("MUX", "../resources/workers/muxWW.js");
+
+    let mem = new SharedArrayBuffer(1024);
+    mux.postMessage(makeMsg(MESSAGE_TYPE.INIT, {shm: mem, size: 1024 }));
+
+    await sleep(1000);
+  });
+});