Files
faunosteo/scripts/browser/r4-memory-bench.mjs

369 lines
13 KiB
JavaScript
Raw Permalink 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.
// Memory bench of the application export (R4.9, owner §3: the R4.6
// Chromium reserve is answered by measures, not by the R4.8 cleanup).
// ONE editor tab per engine and report; the start level, the init export
// (module, fonts, first decode: counted apart), `--exports` more by the
// same button, then four rest windows: settled (5 s idle), after the 30 s
// `downloadBlob` revocation window, Home (the editor left by its link, the
// page kept), Home idle (10 s). Every reading tells apart:
// (1) the module's linear memory (`WebAssembly.Memory.buffer.byteLength`),
// (2) the content-process RSS and the summed RSS of the browser tree,
// (3) the objects alive: canvases, images, bitmaps, blobs, the PDF blobs
// (created − collected after a GC) and the object URLs (created −
// revoked); Chromium adds the JS heap, the DOM counters and, at three
// points, a heap-snapshot census of the same classes,
// (4) the transient peak of the content RSS during each export,
// (5) what each rest window keeps against the level after the init export;
// Chromium ends with a simulated critical memory pressure (CDP), which
// asks the renderer to drop its caches and return free pages.
// `--mode raster` is the control: after the init export, each step replays
// the rasteriser's own steps on the views the init export drew, with no
// core call, to tell the browser's raster path apart from the session.
// Chromium readings follow a forced GC (CDP) + 1 s; Firefox and WebKit are
// read after idle only (no forced GC: the collected counts are indicative).
//
// PLAYWRIGHT_NODE_MODULES=... node scripts/browser/r4-memory-bench.mjs \
// [--engines chromium,firefox,webkit] [--reports demo,L] [--exports 6] \
// [--mode export|raster] [--no-pressure] [--no-snapshots] [--out <file>]
import { mkdirSync, writeFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { parseArgs } from 'node:util'
import { pathToFileURL } from 'node:url'
import { checkBuild } from './lib/app-build.mjs'
import { delay, firstLine } from './lib/async.mjs'
import { readProbe } from './lib/page-probes.mjs'
import { hostFacts } from './lib/host.mjs'
import {
KINDS,
domMetrics,
heapCensus,
installMemoryProbes,
rasterControl,
readMemoryProbe,
} from './lib/memory-probes.mjs'
import { RESULTS_DIR } from './lib/paths.mjs'
import {
ENGINES,
closeEngine,
launchEngine,
loadPlaywright,
} from './lib/playwright.mjs'
import { forcedGc, levelNow, listOf, log, today } from './lib/r4-runs.mjs'
import { watchdogFacts } from './lib/watchdog.mjs'
import { REPORTS, exportOnce, openEditor } from './r4-export-series.mjs'
import { startServer } from './serve.mjs'
const HOME_LINK = 'Accueil' // fr.ts common.home (AppHeader)
const BETWEEN_MS = 2000
const SETTLE_MS = 5000
const REVOKE_WINDOW_MS = 31_000 // downloadBlob revokes after 30 s
const HOME_IDLE_MS = 10_000
const PRESSURE_SETTLE_MS = 3000
const VIEW_WIDTH_PX = 1200 // the core's raster width for a view
const MODES = ['export', 'raster']
const MIB = 1024 * 1024
const READINGS =
'Readings after each step: linear = sum of the live WebAssembly.Memory ' +
'buffers of the page; rssContent / rssSummed = watchdog (VmRSS of the ' +
'renderer processes / the whole tree); live = created − collected per ' +
'kind (FinalizationRegistry, valid after a GC), urlsLive = created − ' +
'revoked; Chromium: jsHeap (performance.memory), dom (Performance.' +
'getMetrics), census (heap snapshot) at start, after the series and at ' +
'Home idle. Chromium readings follow HeapProfiler.collectGarbage + 1 s; ' +
'Firefox and WebKit are read after idle only. peakContent = watchdog ' +
'peak of the content RSS between two readings (the export in between).'
function options() {
const { values } = parseArgs({
options: {
engines: { type: 'string', default: ENGINES.join(',') },
reports: { type: 'string', default: 'demo,L' },
exports: { type: 'string', default: '6' },
mode: { type: 'string', default: 'export' },
'no-pressure': { type: 'boolean', default: false },
'no-snapshots': { type: 'boolean', default: false },
out: {
type: 'string',
default: join(RESULTS_DIR, `${today()}-r4-memory-bench.json`),
},
},
})
const reports = listOf(values.reports)
for (const r of reports) {
if (!REPORTS[r]) throw new Error(`unknown report ${r}`)
}
if (!MODES.includes(values.mode))
throw new Error(`unknown mode ${values.mode}`)
return {
engines: listOf(values.engines),
reports,
exports: Number(values.exports),
mode: values.mode,
pressure: !values['no-pressure'],
snapshots: !values['no-snapshots'],
out: values.out,
}
}
/** One reading of every dimension at `step`, after the engine's settle. */
async function reading(session, tab, step, { census }) {
if (tab.cdp) await forcedGc(tab)
const rss = levelNow(session)
const probe = await tab.page.evaluate(readMemoryProbe)
const live = Object.fromEntries(
KINDS.map((k) => [k, probe.created[k] - probe.collected[k]]),
)
const peak = session.watchdog.snapshot()
const row = {
step,
linear: probe.linearBytes,
instances: probe.instances,
instancesEver: probe.instancesEver,
rssContent: rss.rssContentBytes,
rssSummed: rss.rssBytes,
peakContent: peak.peakContentBytes,
created: probe.created,
collected: probe.collected,
live,
urls: probe.urls,
urlsLive: probe.urls.created - probe.urls.revoked,
jsHeap: probe.jsHeap,
dom: tab.cdp ? await domMetrics(tab.cdp) : null,
census: tab.cdp && census ? await heapCensus(tab.cdp) : null,
}
await session.watchdog.resetPeak()
return row
}
/** The view sizes the init export drew (logos excluded). */
async function viewSizes(tab) {
const probe = await tab.page.evaluate(readProbe)
return probe.png
.filter((p) => p.width === VIEW_WIDTH_PX)
.map(({ width, height }) => ({ width, height }))
}
/** One step of the series: an export, or the raster control after the init. */
async function seriesStep(tab, { name, mode, sizes }) {
if (mode === 'export' || sizes === null) {
return exportOnce(tab, REPORTS[name].timeoutMs)
}
const started = performance.now()
const drawn = await tab.page.evaluate(rasterControl, { sizes })
const ms = Math.round(performance.now() - started)
return { outcome: 'downloaded', control: 'raster', drawn, clickToEndMs: ms }
}
/** The init export and `count` more steps, a reading after each. */
async function exportSeries(session, tab, { name, mode, count }, rows) {
const exports = []
let sizes = null
for (let i = 0; i <= count; i += 1) {
const row = await seriesStep(tab, { name, mode, sizes })
if (i === 0 && mode === 'raster') sizes = await viewSizes(tab)
exports.push(row)
if (row.outcome !== 'downloaded') return { exports, failed: row }
await delay(BETWEEN_MS)
const step = i === 0 ? 'init' : `export ${i}`
rows.push(await reading(session, tab, step, { census: false }))
}
return { exports, failed: null }
}
/** Leaves the editor through its own link: the page and its runtime stay. */
async function goHome(tab) {
await tab.page.getByRole('link', { name: HOME_LINK }).click()
await tab.page.waitForURL(/\/$/)
}
/** Chromium: a critical memory pressure notification, then a reading. */
async function underPressure(session, tab, rows) {
await tab.cdp.send('Memory.simulatePressureNotification', {
level: 'critical',
})
await delay(PRESSURE_SETTLE_MS)
rows.push(await reading(session, tab, 'pressure', { census: false }))
}
/** The rest windows after the series. */
async function restWindows(session, tab, rows, { seriesEndAt, census }) {
await delay(SETTLE_MS)
rows.push(await reading(session, tab, 'settled', { census }))
const elapsed = performance.now() - seriesEndAt
await delay(Math.max(0, REVOKE_WINDOW_MS - elapsed))
rows.push(await reading(session, tab, 'after revoke', { census: false }))
await goHome(tab)
await delay(BETWEEN_MS)
rows.push(await reading(session, tab, 'home', { census: false }))
await delay(HOME_IDLE_MS)
rows.push(await reading(session, tab, 'home idle', { census }))
}
const bytesAt = (rows, step, key) => rows.find((r) => r.step === step)?.[key]
const delta = (rows, from, to, key) =>
bytesAt(rows, to, key) - bytesAt(rows, from, key)
/** The derived figures (bytes): init, per export, recurring, transient, kept. */
function derive(rows, count) {
const after = rows.filter((r) => r.step.startsWith('export '))
const perExport = (key) =>
after.map(
(r, i) =>
r[key] - (i === 0 ? bytesAt(rows, 'init', key) : after[i - 1][key]),
)
const last5 = (key) => {
const from =
after[Math.max(0, after.length - 5) - 1] ??
rows.find((r) => r.step === 'init')
return after.at(-1)[key] - from[key]
}
const kept = (step, key) => delta(rows, 'init', step, key)
const dims = ['linear', 'rssContent']
const out = { exportsAfterInit: after.length, requested: count }
for (const key of dims) {
out[key] = {
init: delta(rows, 'start', 'init', key),
perExport: perExport(key),
last5: last5(key),
settled: kept('settled', key),
afterRevoke: kept('after revoke', key),
home: kept('home', key),
homeIdle: kept('home idle', key),
pressure:
bytesAt(rows, 'pressure', key) === undefined
? null
: kept('pressure', key),
}
}
// The peak between two readings against the level before the export.
out.transientPeak = after.map(
(r, i) =>
r.peakContent -
(i === 0 ? bytesAt(rows, 'init', 'rssContent') : after[i - 1].rssContent),
)
const homeIdle = rows.find((r) => r.step === 'home idle')
out.liveAtHomeIdle = homeIdle?.live ?? null
out.urlsLiveAtHomeIdle = homeIdle?.urlsLive ?? null
return out
}
async function benchRun(pw, run) {
const { engine, baseUrl, report, count, mode, pressure, snapshots } = run
const session = await launchEngine(pw, engine)
const head = { engine, engineVersion: session.version, report, mode }
const rows = []
try {
const tab = await openEditor(session, baseUrl, report, [
installMemoryProbes,
])
if (tab.cdp) await tab.cdp.send('Performance.enable')
if (!tab.cdp) await delay(SETTLE_MS)
rows.push(await reading(session, tab, 'start', { census: snapshots }))
const series = await exportSeries(
session,
tab,
{ name: report, mode, count },
rows,
)
if (series.failed) {
return {
...head,
outcome: series.failed.outcome,
error: series.failed.error,
rows,
}
}
await restWindows(session, tab, rows, {
seriesEndAt: performance.now(),
census: snapshots,
})
if (tab.cdp && pressure) await underPressure(session, tab, rows)
return {
...head,
outcome: 'bench',
exports: series.exports,
rows,
derived: derive(rows, count),
pageErrors: tab.events.pageErrors,
consoleErrors: tab.events.consoleErrors.slice(0, 20),
}
} catch (error) {
const stopped = session.watchdog.snapshot().stopped
const outcome = stopped ? 'stopped_by_ceiling' : 'error'
return { ...head, outcome, error: firstLine(error), rows }
} finally {
await closeEngine(session)
}
}
const mib = (bytes) => (bytes / MIB).toFixed(1)
const list = (values) => values.map(mib).join(' / ')
function table(runs) {
const lines = [
'| Engine | Report | Mode | Dim | Init | Per step | Last 5 | Settled | After revoke | Home | Home idle | Pressure |',
'|---|---|---|---|---|---|---|---|---|---|---|---|',
]
for (const run of runs) {
if (run.outcome !== 'bench') {
lines.push(
`| ${run.engine} | ${run.report} | ${run.mode} | ${run.outcome} | | | | | | | | |`,
)
continue
}
for (const dim of ['linear', 'rssContent']) {
const d = run.derived[dim]
lines.push(
`| ${run.engine} | ${run.report} | ${run.mode} | ${dim} | ${mib(d.init)} | ${list(d.perExport)} | ${mib(d.last5)} | ${mib(d.settled)} | ${mib(d.afterRevoke)} | ${mib(d.home)} | ${mib(d.homeIdle)} | ${d.pressure === null ? '' : mib(d.pressure)} |`,
)
}
const live = run.derived.liveAtHomeIdle
lines.push(
`| ${run.engine} | ${run.report} | ${run.mode} | transient peak | | ${list(run.derived.transientPeak)} | | | | live at home idle: ${JSON.stringify(live)}, urls ${run.derived.urlsLiveAtHomeIdle} | | |`,
)
}
return lines.join('\n')
}
async function main() {
const opts = options()
const build = checkBuild()
const { pw } = loadPlaywright()
const server = await startServer({ csp: 'with' })
const runs = []
try {
for (const engine of opts.engines) {
for (const report of opts.reports) {
const run = await benchRun(pw, {
engine,
baseUrl: server.url,
report,
count: opts.exports,
mode: opts.mode,
pressure: opts.pressure,
snapshots: opts.snapshots,
})
log(`bench ${engine} ${report} ${opts.mode}: ${run.outcome}`)
runs.push(run)
}
}
} finally {
await server.close()
}
const result = {
harness: 'scripts/browser/r4-memory-bench.mjs',
startedAt: new Date().toISOString(),
readings: READINGS,
watchdog: watchdogFacts(),
host: hostFacts(),
build,
options: opts,
runs,
}
mkdirSync(dirname(opts.out), { recursive: true })
writeFileSync(opts.out, `${JSON.stringify(result, null, 2)}\n`)
log(`results written to ${opts.out}`)
console.log(table(runs))
}
if (import.meta.url === pathToFileURL(process.argv[1]).href) await main()