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.
This commit is contained in:
1 parent
8924d50edf
commit
49591c53cd
14 files changed
+3002
-387
No files matched your search
@@ -0,0 +1,335 @@
|
||||
// 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()
|
||||
Reference in new issue
Block a user