@threadedstack/wmd-web 0.0.0-stage → 0.1.13

package/src/host/clock.js

@@ -0,0 +1,111 @@
+// Clocks shared by every Worker of one machine.
+//
+// performance.now() is relative to each Worker's own timeOrigin, so two Workers
+// disagree by however far apart they started. The guest compares deadlines one
+// thread computed against "now" read on another (the timer thread vs a vCPU), so
+// all Workers use the absolute time performance.timeOrigin + performance.now() and
+// subtract one start time kept in the control buffer. A shared high-water mark keeps
+// CLOCK_MONOTONIC from ever going backwards across Workers (timeOrigin values can
+// differ by a fraction of a millisecond between agents). CLOCK_REALTIME is the start
+// time plus CLOCK_MONOTONIC, so it never goes backwards either.
+
+import { CTL_MONO_LOCK, F64_LAST_MONO, F64_START_MS } from './layout.js'
+
+export const absMs = () => performance.timeOrigin + performance.now()
+
+/** One tick of the arm64 guest's 62.5 MHz counter (arm_timer.c: ticks = ns / 16). */
+export const TICK_NS = 16n
+const TICK = 16
+const TWO32 = 4294967296
+
+export function createClock(ctlSab) {
+  const f64 = new Float64Array(ctlSab, F64_START_MS, 1)
+  const last = new Float64Array(ctlSab, F64_LAST_MONO, 1)
+  const ctl = new Int32Array(ctlSab, 0, CTL_MONO_LOCK + 1)
+
+  const startMs = () => f64[0]
+
+  // W40: the clock allocates nothing. vm.wasm reads it about 9,000 times a second on an idle
+  // guest, and WebKit collects garbage late in a thread holding the guest's memory (D-419,
+  // gcnudge.js), so the garbage this made (BigInts, argument arrays) piled up: the content process grew
+  // about 0.7 MiB/s from this clock alone. So the values are Numbers (exact up to 2^53 ns,
+  // 104 days of uptime), the shared high-water mark is a Float64 under a spin lock instead
+  // of a BigInt64 compare-exchange, and writeNs stores the 64-bit result as two words.
+  // Workers are terminated only when the machine ends (or before they ever ran), so no
+  // Worker dies holding the lock.
+
+  // ns since machine start, strictly increasing: every read returns at least TICK_NS more
+  // than the read before it, on any Worker. Browsers coarsen performance.now() (5 us in
+  // Chromium, more elsewhere), so two reads of the guest's counter (CNTVCT = ns / 16)
+  // were usually equal. Linux's jitter entropy (try_to_generate_entropy, which a blocked
+  // getrandom() runs) then counts too few distinct samples in 8,192 reads and gives up, the
+  // crng never initialises on an idle guest, and getrandom() blocks for good: crun hung
+  // in the container boot (P-B4). The step cannot run ahead of real time by more than
+  // TICK_NS per read made within one coarsened step of the browser's clock.
+  function mono() {
+    const ns = Math.max(0, Math.round((absMs() - f64[0]) * 1e6))
+    while (Atomics.compareExchange(ctl, CTL_MONO_LOCK, 0, 1) !== 0);
+    const prev = last[0]
+    const next = ns > prev ? ns : prev + TICK
+    last[0] = next
+    Atomics.store(ctl, CTL_MONO_LOCK, 0)
+    return next
+  }
+
+  // ns since the Unix epoch: the machine's start time (one value, in the shared control
+  // block) plus CLOCK_MONOTONIC. Reading each Worker's own timeOrigin + now() instead
+  // stepped back by up to ~20 us across Workers (adversarial review, clock.wat). Split
+  // into whole ms and the fraction so the result keeps sub-microsecond digits. The start
+  // in ns does not fit a Number exactly, so it is kept as two words, worked out again
+  // only when the start changes.
+  let baseMs = NaN
+  let baseHi = 0
+  let baseLo = 0
+  function base() {
+    const ms = f64[0]
+    if (ms === baseMs) return
+    const whole = Math.floor(ms)
+    const b = BigInt(whole) * 1000000n + BigInt(Math.round((ms - whole) * 1e6))
+    baseHi = Number(b >> 32n)
+    baseLo = Number(b & 0xffffffffn)
+    baseMs = ms
+  }
+
+  /** Store clock id's time (0 realtime, 1-3 monotonic) at dv[off] as a little-endian u64. */
+  function writeNs(dv, off, id) {
+    const m = mono()
+    let lo = m % TWO32
+    let hi = (m - lo) / TWO32
+    if (id === 0) {
+      base()
+      lo += baseLo
+      hi += baseHi
+      if (lo >= TWO32) {
+        lo -= TWO32
+        hi++
+      }
+    }
+    dv.setUint32(off, lo, true)
+    dv.setUint32(off + 4, hi, true)
+  }
+
+  /** Clock id's time in ns as a Number (realtime to within a few hundred ns): for timeouts. */
+  function nowNum(id) {
+    const m = mono()
+    if (id !== 0) return m
+    base()
+    return baseHi * TWO32 + baseLo + m
+  }
+
+  const monoNs = () => BigInt(mono())
+  function realNs() {
+    base()
+    return (BigInt(baseHi) << 32n) + BigInt(baseLo) + BigInt(mono())
+  }
+
+  return { monoNs, realNs, writeNs, nowNum, startMs }
+}
+
+export function markStart(ctlSab, ms = absMs()) {
+  new Float64Array(ctlSab, F64_START_MS, 1)[0] = ms
+}