Files
faunosteo/scripts/browser/r4-leak-series.mjs
T
bchanot 49591c53cd test(tests): R4.3a browser re-measure of large files, leak series, WebKit repetition (stream sink, BYOB)
Streaming into FileBytes removes the file's JavaScript copy in Chromium and Firefox
(50 MiB: 65 and 67 MiB summed growth against 56 and 79 for the TypeScript); WebKit keeps
about 180 MiB for any file read inside a worker (272 against 76), a main-thread BYOB read
feeding the worker's sink measured at 106. Corpus 666/678 on the stream path. Leak series
(3 engines × 3 documents × 3 repetitions): Chromium ≤ 0.5 MiB over the last 5, Firefox
within ±3 (idle only), WebKit copy +13 then level (12-import series −2.3). 20 dense
imports in WebKit: no worker error event.
2026-10-18 18:50:47 +02:00

336 lines
11 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Leak series of the Rust import worker (R4.3a, BDR-058 leak criterion):
// leak per engine, per document (the L envelope, the 16 MiB dense
// numbers refused by the value budget, the 16 MiB rescue
// copy), `--reps` times: ONE page, the file set once, then
// one import (init cost, counted apart) and `--imports`
// more, the worker terminated after each, 2 s idle between
// them, 5 s idle at the end; the content RSS read after
// each. Chromium: a forced GC (CDP) + 1 s before each
// reading; Firefox and WebKit: idle only (no forced GC
// there, so their levels are indicative).
// Recurring growth = level after the last import minus the
// level after the first import past init (L7 − L2 for 6),
// tolerance 10 MiB.
// webkit-repeat WebKit, one page, `--webkit-imports` consecutive imports
// of the 16 MiB dense document (a worker per import), every
// worker `error` / `messageerror` event kept with its text.
// The browser runs under the 4 GiB RSS watchdog (not a guaranteed limit).
//
// PLAYWRIGHT_NODE_MODULES=... node scripts/browser/r4-leak-series.mjs \
// [--engines chromium,firefox,webkit] [--sections leak,webkit-repeat] \
// [--reps 3] [--imports 6] [--webkit-imports 20] \
// [--read stream|arrayBuffer] [--scratch <dir>] [--out <file>]
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { parseArgs } from 'node:util'
import { delay } from './lib/async.mjs'
import { memAvailableBytes } from './lib/host.mjs'
import { RESULTS_DIR } from './lib/paths.mjs'
import { ENGINES, loadPlaywright } from './lib/playwright.mjs'
import { leakSummary } from './lib/r4-memory-summary.mjs'
import {
IDLE_SETTLE_MS,
engineRuns,
forcedGc,
levelNow,
listOf,
oneRun,
pageOutcome,
prepareModuleRun,
raceDrive,
runConditions,
today,
writeResult,
} from './lib/r4-runs.mjs'
import { startServer } from './serve.mjs'
const SECTIONS = ['leak', 'webkit-repeat']
const READ_PATHS = ['stream', 'arrayBuffer']
const DOCUMENTS = [
'L-envelope',
'dense-numbers-16mib',
'dense-numbers-copy-16mib',
]
const WEBKIT_DOCUMENT = 'dense-numbers-16mib'
const BETWEEN_MS = 2000
const FINAL_IDLE_MS = 5000
const READINGS =
'Readings: content RSS of the browser tree after each import, 2 s idle ' +
'after the worker is terminated; Chromium adds a forced GC (CDP ' +
'HeapProfiler.collectGarbage) + 1 s before each reading, Firefox and ' +
'WebKit are read after idle only (no forced GC: indicative). Start = ' +
'after the file is set (GC + 1 s, or 5 s idle); final = after 5 s more ' +
'idle. Init Δ = L1 − L0; recurring = L7 − L2 (the last 5 imports).'
const count = (text, name) => {
const value = Number(text)
if (!Number.isInteger(value) || value < 1) throw new Error(`bad --${name}`)
return value
}
function options() {
const { values } = parseArgs({
options: {
engines: { type: 'string', default: ENGINES.join(',') },
sections: { type: 'string', default: SECTIONS.join(',') },
reps: { type: 'string', default: '3' },
imports: { type: 'string', default: '6' },
'webkit-imports': { type: 'string', default: '20' },
read: { type: 'string', default: 'stream' },
scratch: { type: 'string', default: tmpdir() },
out: {
type: 'string',
default: join(RESULTS_DIR, `${today()}-r4-leak-series.json`),
},
},
})
const engines = listOf(values.engines)
const sections = listOf(values.sections)
const bad = [...engines.filter((e) => !ENGINES.includes(e))]
bad.push(...sections.filter((s) => !SECTIONS.includes(s)))
if (!READ_PATHS.includes(values.read)) bad.push(values.read)
if (bad.length) throw new Error(`unknown engines, sections or read: ${bad}`)
return {
...values,
engines,
sections,
reps: count(values.reps, 'reps'),
imports: count(values.imports, 'imports'),
webkitImports: count(values['webkit-imports'], 'webkit-imports'),
}
}
/** One reading: forced GC + 1 s first in Chromium, the level as it is else. */
async function reading(session, tab) {
if (tab.cdp) await forcedGc(tab)
return levelNow(session)
}
/** The start level: GC + 1 s (Chromium) or 5 s idle, the file already set. */
async function startLevel(session, tab, item) {
await tab.page.setInputFiles('#file', item.path)
if (!tab.cdp) await delay(IDLE_SETTLE_MS)
return reading(session, tab)
}
/** Init, per-import, recurring and final deltas of one level list. */
function deltasOf(levels, imports) {
const last = imports + 1
const at = (i) => levels[i]
const perImport = []
for (let i = 2; i <= last; i += 1) perImport.push(at(i) - at(i - 1))
return {
init: at(1) - at(0),
perImport,
last5: at(last) - at(Math.max(2, last - 5)),
finalIdle: at(last + 1) - at(last),
last5AtFinal: at(last + 1) - at(Math.max(2, last - 5)),
}
}
/** A series cut short: the harness end (timeout, stop) and what ran. */
const stopped = (item, end, outcomes) => ({
rep: item.rep,
outcome: end.kind,
error: end.error ?? null,
outcomes,
})
/** One import of the file already set, its row facts. */
async function importOnce(session, tab, item) {
const end = await raceDrive(session, tab, { ...item, path: null })
if (end.kind !== 'done') return { end }
const r = end.value
const facts = {
outcome: pageOutcome(r),
pageMs: r.pageMs,
events: r.workerEvents ?? [],
}
return { end, facts }
}
/**
* ONE page: the start level, the init import, `item.imports` more, each
* read after 2 s idle (+ GC in Chromium), then 5 s idle and a last reading.
*/
async function measureSeries(session, tab, item) {
const levels = [await startLevel(session, tab, item)]
await session.watchdog.resetPeak()
const outcomes = []
const pageMs = []
const workerEvents = []
for (let i = 0; i <= item.imports; i += 1) {
const { end, facts } = await importOnce(session, tab, item)
if (!facts) return stopped(item, end, outcomes)
outcomes.push(facts.outcome)
pageMs.push(facts.pageMs)
workerEvents.push(...facts.events.map((e) => ({ import: i, ...e })))
await delay(BETWEEN_MS)
levels.push(await reading(session, tab))
}
await delay(FINAL_IDLE_MS)
levels.push(await reading(session, tab))
return seriesRow(session, item, { levels, outcomes, pageMs, workerEvents })
}
function seriesRow(session, item, facts) {
const peak = session.watchdog.snapshot()
const content = facts.levels.map((l) => l.rssContentBytes)
const summed = facts.levels.map((l) => l.rssBytes)
return {
rep: item.rep,
outcome: 'series',
reading: item.reading,
outcomes: facts.outcomes,
pageMs: facts.pageMs,
workerEvents: facts.workerEvents,
levels: { content, summed },
deltas: {
content: deltasOf(content, item.imports),
summed: deltasOf(summed, item.imports),
},
peakBytes: peak.peakBytes,
peakContentBytes: peak.peakContentBytes,
}
}
/** WebKit: `item.imports` consecutive imports in one page, no idle. */
async function measureRepetition(session, tab, item) {
await tab.page.setInputFiles('#file', item.path)
await session.watchdog.resetPeak()
const outcomes = []
const pageMs = []
const workerEvents = []
const content = []
for (let i = 0; i < item.imports; i += 1) {
const { end, facts } = await importOnce(session, tab, item)
if (!facts) return stopped(item, end, outcomes)
outcomes.push(facts.outcome)
pageMs.push(facts.pageMs)
workerEvents.push(...facts.events.map((e) => ({ import: i, ...e })))
content.push(levelNow(session).rssContentBytes)
}
return repetitionRow(session, item, {
outcomes,
pageMs,
workerEvents,
content,
})
}
function repetitionRow(session, item, facts) {
const peak = session.watchdog.snapshot()
const { content } = facts
return {
outcome: 'repeated',
imports: item.imports,
outcomes: facts.outcomes,
pageMs: facts.pageMs,
workerEvents: facts.workerEvents,
contentAfter: {
first: content[0],
min: Math.min(...content),
max: Math.max(...content),
last: content[content.length - 1],
},
peakBytes: peak.peakBytes,
peakContentBytes: peak.peakContentBytes,
}
}
const classOf = (classes, id) => classes.find((c) => c.id === id)
function leakItems(engine, opts, classes) {
const reading = engine === 'chromium' ? 'gc + 1 s' : 'idle only'
return DOCUMENTS.flatMap((id) => {
const c = classOf(classes, id)
return Array.from({ length: opts.reps }, (_, i) => ({
section: 'leak',
classId: id,
fileBytes: c.bytes,
path: c.path,
readPath: opts.read,
imports: opts.imports,
rep: i + 1,
reading,
}))
})
}
function repetitionItem(opts, classes) {
const c = classOf(classes, WEBKIT_DOCUMENT)
return {
section: 'webkit-repeat',
classId: c.id,
fileBytes: c.bytes,
path: c.path,
readPath: opts.read,
imports: opts.webkitImports,
}
}
function enginePlan(engine, opts, classes) {
const plan = opts.sections.includes('leak')
? leakItems(engine, opts, classes)
: []
if (engine === 'webkit' && opts.sections.includes('webkit-repeat')) {
plan.push(repetitionItem(opts, classes))
}
return plan
}
function conditions(server, playwrightCore, module, opts) {
const harness = 'scripts/browser/r4-leak-series.mjs'
return {
...runConditions({ harness, server, playwrightCore, module }),
page: {
worker: 'module worker /r4/worker.js, one per import, terminated',
readPath: opts.read,
imports: { init: 1, then: opts.imports, reps: opts.reps },
betweenMs: BETWEEN_MS,
finalIdleMs: FINAL_IDLE_MS,
webkitImports: opts.webkitImports,
},
readings: READINGS,
}
}
async function main() {
const opts = options()
const { pw, version } = loadPlaywright()
const prepared = await prepareModuleRun({
scratchParent: opts.scratch,
classes: [...new Set([...DOCUMENTS, WEBKIT_DOCUMENT])],
})
const server = await startServer({ mounts: prepared.mounts })
try {
const result = conditions(server, version, prepared.module, opts)
const context = { ...prepared, baseUrl: server.url }
const runItem = (session, item) => {
const measureOf =
item.section === 'leak' ? measureSeries : measureRepetition
return oneRun(session, item, context, measureOf)
}
const runs = []
for (const engine of opts.engines) {
const plan = enginePlan(engine, opts, prepared.classes)
runs.push(...(await engineRuns(pw, engine, plan, runItem)))
}
result.host.memAvailableBytesAtEnd = memAvailableBytes()
result.endedAt = new Date().toISOString()
result.engines = Object.fromEntries(
runs.map((r) => [r.engine, r.engineVersion]),
)
result.leak = { runs: runs.filter((r) => r.section === 'leak') }
result.webkitRepeat = {
runs: runs.filter((r) => r.section === 'webkit-repeat'),
}
writeResult(opts.out, result, leakSummary)
} finally {
server.close()
prepared.cleanup()
}
}
await main()