Files
bchanot 4439fd2420 test(tests): R4.1e browser harness and TS baselines (Chromium, Firefox, WebKit)
Playwright harness under scripts/browser: 127.0.0.1 server with the DEPLOY
CSP, export and import baselines of the TypeScript engine under a 4 GiB RSS
watchdog (not a guaranteed memory limit), O9 browser columns in
inflate.browsers.json (26 rows agree with Node in all three engines).
Results of 2026-10-18 committed; the O9 Node test no longer expects browser
columns in inflate.json.
2026-10-18 15:05:28 +02:00

126 lines
4.1 KiB
JavaScript

import { Worker } from 'node:worker_threads'
import { delay } from './async.mjs'
import { killAll, treeOf } from './proc.mjs'
/**
* Memory ceiling of one launched browser. A worker thread samples the summed
* VmRSS of every process below the browser's root pid every 50 ms and, above
* the ceiling, SIGKILLs that tree (the shared host must never reach the
* kernel OOM killer). The sampler lives in its own thread so a busy main
* event loop cannot delay it.
*/
export const CEILING_BYTES = 4 * 1024 ** 3
export const SAMPLE_INTERVAL_MS = 50
export const WATCHDOG_CAVEAT =
'The 4 GiB RSS watchdog is not a guaranteed memory limit: it samples ' +
'every 50 ms, so a faster allocation can overshoot it before the kill; ' +
'summed VmRSS counts shared pages once per process; a process outside ' +
"the browser's tree is not seen."
/** Shared Int32 slots, sizes in KiB. */
export const SLOT = {
currentKib: 0,
currentMaxKib: 1,
peakKib: 2,
peakMaxKib: 3,
samples: 4,
stopped: 5,
resetRequested: 6,
stoppedAtKib: 7,
currentContentKib: 8,
peakContentKib: 9,
}
const SLOT_COUNT = 10
const RESET_WAIT_MS = 1000
const POLL_MS = 5
export const watchdogFacts = () => ({
ceilingBytes: CEILING_BYTES,
sampleIntervalMs: SAMPLE_INTERVAL_MS,
measure:
'summed VmRSS (/proc/<pid>/status) of the browser process tree; ' +
'content = renderer / Web Content / WPEWebProcess processes only',
onCeiling: 'SIGKILL of the tree, run recorded as stopped_by_ceiling',
caveat: WATCHDOG_CAVEAT,
})
const kib = (stats, slot) => Atomics.load(stats, slot) * 1024
function snapshotOf(stats) {
return {
currentBytes: kib(stats, SLOT.currentKib),
currentMaxProcessBytes: kib(stats, SLOT.currentMaxKib),
peakBytes: kib(stats, SLOT.peakKib),
peakMaxProcessBytes: kib(stats, SLOT.peakMaxKib),
currentContentBytes: kib(stats, SLOT.currentContentKib),
peakContentBytes: kib(stats, SLOT.peakContentKib),
samples: Atomics.load(stats, SLOT.samples),
stopped: Atomics.load(stats, SLOT.stopped) === 1,
stoppedAtBytes: kib(stats, SLOT.stoppedAtKib),
}
}
async function waitUntil(test, timeoutMs, what) {
const end = performance.now() + timeoutMs
while (!test()) {
if (performance.now() > end) throw new Error(`watchdog: ${what}`)
await delay(POLL_MS)
}
}
/** Starts a peak window at the next sample (the sampler owns the write). */
async function resetPeak(stats) {
Atomics.store(stats, SLOT.resetRequested, 1)
const done = () => Atomics.load(stats, SLOT.resetRequested) === 0
await waitUntil(done, RESET_WAIT_MS, 'peak reset not acknowledged')
}
/**
* `stopped` resolves when the sampler killed the tree, or when the sampler
* itself died: the tree is then killed here, so no browser runs unwatched.
*/
function stoppedPromise(worker, rootPid, stats, isStopping) {
return new Promise((resolve) => {
let settled = false
const settle = (message) => {
settled = true
resolve(message)
}
const failed = (error) => {
if (settled || isStopping()) return
if (Atomics.load(stats, SLOT.stopped) === 1) {
return settle({
type: 'ceiling',
totalBytes: kib(stats, SLOT.stoppedAtKib),
})
}
killAll(treeOf(rootPid))
settle({ type: 'watchdog_failed', error: String(error) })
}
worker.on('message', (m) => m.type === 'ceiling' && settle(m))
worker.on('error', failed)
worker.on('exit', (code) => failed(`sampler exited (${code})`))
})
}
export function startWatchdog({ rootPid, ceilingBytes = CEILING_BYTES }) {
const shared = new SharedArrayBuffer(SLOT_COUNT * 4)
const stats = new Int32Array(shared)
const worker = new Worker(new URL('./watchdog-worker.mjs', import.meta.url), {
workerData: { rootPid, ceilingBytes, shared },
})
let stopping = false
const sampled = () => Atomics.load(stats, SLOT.samples) > 0
return {
ready: waitUntil(sampled, RESET_WAIT_MS, 'no first sample'),
stopped: stoppedPromise(worker, rootPid, stats, () => stopping),
snapshot: () => snapshotOf(stats),
resetPeak: () => resetPeak(stats),
stop: () => {
stopping = true
return worker.terminate()
},
}
}