// 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 ] [--out ] import { tmpdir } from 'node:os' import { join } from 'node:path' import { pathToFileURL } from 'node:url' 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. */ export 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() } } if (import.meta.url === pathToFileURL(process.argv[1]).href) await main()