scheduling in a worker, draft

examples/worker-repl/worker.mjs

@@ -0,0 +1,116 @@
+// used to consistently schedule events
+const createClock = (
+  getTime,
+  callback, // called slightly before each cycle
+  duration = 0.05, // duration of each cycle
+  interval = 0.1, // interval between callbacks
+  overlap = 0.1, // overlap between callbacks
+) => {
+  let tick = 0; // counts callbacks
+  let phase = 0; // next callback time
+  let precision = 10 ** 4; // used to round phase
+  let minLatency = 0;
+  const setDuration = (setter) => (duration = setter(duration));
+  overlap = overlap || interval / 2;
+  const onTick = () => {
+    const t = getTime();
+    const lookahead = t + interval + overlap; // the time window for this tick
+    if (phase === 0) {
+      phase = t + minLatency;
+    }
+    // callback as long as we're inside the lookahead
+    while (phase < lookahead) {
+      // phase = Math.round(phase * precision) / precision;
+      phase >= t && callback(phase, duration, tick, t);
+      phase < t && console.log('TOO LATE', phase); // what if latency is added from outside?
+      phase += duration; // increment phase by duration
+      tick++;
+    }
+  };
+  let intervalID;
+  const start = () => {
+    clear(); // just in case start was called more than once
+    onTick();
+    intervalID = setInterval(onTick, interval * 1000);
+  };
+  const clear = () => intervalID !== undefined && clearInterval(intervalID);
+  const pause = () => clear();
+  const stop = () => {
+    tick = 0;
+    phase = 0;
+    clear();
+  };
+  const getPhase = () => phase;
+  // setCallback
+  return { setDuration, start, stop, pause, duration, interval, getPhase, minLatency };
+};
+
+onmessage = async function (e) {
+  console.log('Worker: Message received from main script', e);
+
+  /* const { seq } = await import('@strudel/core');
+  let pat = seq('bd').fast(4).s(); */
+  if (!e.data.origin) {
+    console.log('no origin');
+    return;
+  }
+  console.log('start!', e.data.origin);
+  // e.data.origin = unix ms when main document was created
+  // performance.timeOrigin = unix ms when worker was created
+  let originDiff = (performance.timeOrigin - e.data.origin) / 1000;
+  let firstTick;
+  console.log('originDiff', originDiff);
+
+  let precision = 10 ** 4;
+  let cps = 0.5;
+  let interval = 0.05;
+  let tickOrigin;
+  let lastEnd = 0;
+  let bag = [];
+  let clock = createClock(
+    () => performance.now() / 1000,
+    (phase, duration, tick, t) => {
+      if (tick === 0) {
+        firstTick = t;
+        console.log('firstTick', t);
+      }
+      // let durationInCycles = duration * cps;
+      /* phase = lastEnd; */
+      // phase = Math.round(phase * precision) / precision;
+
+      bag.push({ tick, duration, phase, cps, origin: performance.timeOrigin });
+      //postMessage({ tick, phase, cps, origin: performance.timeOrigin });
+      let pack = 4;
+      if (bag.length === pack) {
+        console.log('send', performance.now());
+        postMessage(bag);
+        bag = [];
+      }
+
+      /* phase += duration;
+      lastEnd = phase; */
+      /*if (tick === 0) {
+        tickOrigin = performance.now();
+      }
+      let begin = lastEnd || 0;
+      let end = begin + duration * cps;
+      lastEnd = end;
+      //console.log('query', begin, phase);
+      const haps = pat.queryArc(begin, end).filter((hap) => hap.hasOnset()); 
+      if (haps.length) {
+        postMessage({ tick, phase, begin, end, haps, cps, tickOrigin, origin: performance.timeOrigin });
+      }
+      */
+      /* console.log(
+        'tick',
+        phase,
+        `${begin.toFixed(2)}-${end.toFixed(2)}: ${haps
+          .map((h) => `${h.value.s}:${(h.whole.begin + 0).toFixed(2)}`)
+          .join(' ')}`,
+      ); */
+    },
+    interval,
+    interval,
+  );
+  clock.start();
+};