Files
faunosteo/scripts/browser/lib/r4-summary.mjs
T
bchanot c84186b032 test(tests): R4.2e browser measurements of the Rust import (module worker page, same perimeter as the TS baseline)
r4-import.mjs runs the 226 baseline files and the hostile classes through a disposable
module worker calling SheetHandle.import_pdf in Chromium 156, Firefox 157 and WebKit 27.2
under the RSS watchdog (not a guaranteed limit); compare-imports.mjs prints TS vs Rust;
serve.mjs gains opt-in mounts (/r4/, /pkg/). Results 2026-10-18-r4-import.json: 666/678
agreements, the 12 others are the 4 declared files; W4 met (max 68 MiB linear); the
1 GiB ceiling traps in every engine.
2026-10-18 16:58:42 +02:00

283 lines
7.8 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.
import { median, spread } from './stats.mjs'
import { importGroupTable } from './summary.mjs'
/** Markdown tables of a results file r4-import.mjs wrote. */
const MiB = 1024 * 1024
const W2_MS = 1000
const orDash = (format) => (value) =>
value === null || value === undefined || Number.isNaN(value)
? '–'
: format(value)
const mb = orDash((bytes) => (bytes / MiB).toFixed(1))
const ms = orDash((value) => value.toFixed(0))
function table(header, rows) {
const line = (cells) => `| ${cells.join(' | ')} |`
const rule = line(header.map(() => '---'))
return [line(header), rule, ...rows.map(line)].join('\n')
}
function groupBy(items, keyOf) {
const groups = new Map()
for (const item of items) {
const key = keyOf(item)
groups.set(key, [...(groups.get(key) ?? []), item])
}
return groups
}
const values = (runs, pick) => runs.map(pick).filter(Number.isFinite)
const maxOf = (list) => (list.length ? Math.max(...list) : null)
/** "median (min–max)" or the single value. */
function range(list, format) {
const stats = spread(list)
if (!stats) return '–'
if (stats.n === 1) return format(stats.median)
return `${format(stats.median)} (${format(stats.min)}–${format(stats.max)})`
}
const growth = (r) => r.rssPeakBytes - r.rssBeforeBytes
const contentGrowth = (r) => r.rssPeakContentBytes - r.rssBeforeContentBytes
const linearGrowth = (r) => r.linear?.afterBytes - r.linear?.beforeRunBytes
export const outcomeOf = (r) =>
r.resultKind ? `${r.outcome} ${r.resultKind}` : r.outcome
function rustTimingRow([key, runs]) {
const [engine, group] = key.split(' ')
return [
engine,
group,
String(runs.length),
range(
values(runs, (r) => r.pageMs),
ms,
),
range(
values(runs, (r) => r.startMs),
ms,
),
range(
values(runs, (r) => r.taskMs),
ms,
),
ms(maxOf(values(runs, (r) => r.parseMs))),
mb(maxOf(values(runs, linearGrowth))),
range(
values(runs, (r) => r.compileMs),
ms,
),
]
}
export function rustTimingTable(runs) {
const header = [
'Engine',
'Group',
'Files',
'Page ms',
'Worker start ms',
'Worker task ms',
'Max parse ms',
'Max linear growth MiB',
'Compile ms (page load)',
]
const groups = groupBy(runs, (r) => `${r.engine} ${r.group}`)
return table(header, [...groups].map(rustTimingRow))
}
function hostileRow(r) {
return [
r.engine,
r.class,
mb(r.fileBytes),
outcomeOf(r),
ms(r.pageMs),
ms(r.startMs),
ms(r.taskMs),
mb(growth(r)),
mb(contentGrowth(r)),
mb(r.linear?.afterBytes),
mb(linearGrowth(r)),
mb(r.settled?.contentDeltaBytes),
]
}
export function hostileTable(runs) {
const header = [
'Engine',
'Class',
'File MiB',
'Outcome',
'Page ms',
'Start ms',
'Task ms',
'Summed peak growth MiB',
'Content peak growth MiB',
'Linear MiB',
'Linear growth MiB',
'Settled content delta MiB',
]
return table(header, runs.map(hostileRow))
}
function proofCell(r) {
const p = r.proofValue
if (!p) return r.detail ?? '–'
const linear = `linear ${mb(p.linearBytes)} MiB`
if ('second' in p) {
const first = p.first.returned ?? p.first.threw
const second = p.second.returned ?? p.second.threw
return `256 MiB → ${first}; 1100 MiB → ${second}; ${linear}`
}
const run = p.run.returned ?? p.run.threw
return `${run} after ${ms(p.run.ms)} ms; ${linear}`
}
export function proofsTable(runs) {
const header = [
'Engine',
'Proof',
'Outcome',
'Result',
'Summed peak growth MiB',
'Content peak growth MiB',
'Settled content delta MiB',
]
const rows = runs.map((r) => [
r.engine,
r.proof,
r.outcome,
proofCell(r),
mb(growth(r)),
mb(contentGrowth(r)),
mb(r.settled?.contentDeltaBytes),
])
return table(header, rows)
}
/** Settled content level before and after each import of one page. */
export function repeatTable(runs) {
const header = [
'Engine',
'Class',
'Settle',
'Outcomes',
'Content levels MiB',
'Delta per import MiB',
]
const list = (bytes) => (bytes ?? []).map(mb).join(' → ')
const rows = runs.map((r) => [
r.engine,
r.class,
r.settleMode ?? '–',
(r.outcomes ?? []).join(', ') || r.outcome,
list(r.contentLevels),
(r.contentDeltas ?? []).map(mb).join(', ') || r.error || '–',
])
return table(header, rows)
}
export function workerFactsTable(facts) {
const header = [
'Engine',
'Module cloned',
'URL fallback',
'Clone errors',
'Workers ready',
'Not ready',
'CSP violations (page + worker)',
]
const rows = Object.entries(facts).map(([engine, f]) => [
engine,
String(f.clone),
String(f.fetch),
f.cloneErrors.join('; ') || 'none',
String(f.started),
String(f.notStarted),
f.csp.join('; ') || 'none',
])
return table(header, rows)
}
/** Plan §B.3: back within 10 MiB of the pre-import level after GC. */
export function settledCheck(runs) {
const checked = runs.filter((r) => r.settled?.mode === 'gc')
if (!checked.length) return 'No run was settled by a forced GC.'
const over = checked.filter((r) => !r.settled.contentWithin10MiB)
const deltas = checked.map((r) => r.settled.contentDeltaBytes)
const lines = [
`${checked.length} Chromium runs settled by a forced GC: ` +
`${checked.length - over.length} within 10 MiB of the pre-import ` +
`content level; delta median ${mb(median(deltas))} MiB, ` +
`max ${mb(maxOf(deltas))} MiB, min ${mb(Math.min(...deltas))} MiB.`,
]
for (const r of over) {
const what = r.file ?? r.class ?? r.proof
lines.push(`- over: ${what} ${mb(r.settled.contentDeltaBytes)} MiB`)
}
return lines.join('\n')
}
/** W2: worker start + the L-size import ≤ 1 s (Chromium, this machine). */
export function w2Line(runs) {
const l = runs.find(
(r) => r.engine === 'chromium' && r.class === 'L-envelope',
)
if (!l) return 'W2: no Chromium L-envelope run.'
const verdict = l.pageMs <= W2_MS ? 'within' : 'over'
return (
`W2 (Chromium, L envelope): page ${ms(l.pageMs)} ms = start ` +
`${ms(l.startMs)} ms + task ${ms(l.taskMs)} ms + routing, transfer ` +
`and parse; ${verdict} the 1 s budget (${outcomeOf(l)}).`
)
}
function headLines(result) {
const engines = Object.entries(result.engines)
.map(([e, v]) => `${e} ${v}`)
.join(', ')
const pkg = result.module.pkg
const max = pkg.memory?.maximumBytes
return [
`Host: ${result.host.cpuModel}, ${result.host.logicalCpus} threads, ` +
`${mb(result.host.ramBytes)} MiB RAM.`,
`Engines: ${engines} (playwright-core ${result.playwrightCore}), headless.`,
`Module: ${pkg.dir}/faunosteo_wasm_bg.wasm ${pkg.wasmBytes} bytes, ` +
`sha256 ${pkg.wasmSha256}, memory maximum ${mb(max)} MiB, ` +
`stamp current: ${result.module.pkgStampCurrent}.`,
`CSP served: ${result.server.csp}`,
`Watchdog: ${result.watchdog.caveat}`,
]
}
export function r4Summary(result) {
const parts = [...headLines(result)]
if (result.import.runs.length) {
parts.push(
'Import by group (Rust worker):',
importGroupTable(result.import),
)
parts.push('Rust worker timings:', rustTimingTable(result.import.runs))
}
if (result.hostileClasses.runs.length) {
parts.push('Hostile classes:', hostileTable(result.hostileClasses.runs))
parts.push(w2Line(result.hostileClasses.runs))
}
if (result.repeat.runs.length) {
parts.push('Repeated imports, one page:', repeatTable(result.repeat.runs))
}
if (result.proofs.runs.length) {
parts.push('Memory proofs (pkg-proofs):', proofsTable(result.proofs.runs))
}
parts.push('Worker facts:', workerFactsTable(result.workerFacts))
const all = [
...result.import.runs,
...result.hostileClasses.runs,
...result.proofs.runs,
]
parts.push(settledCheck(all))
return parts.join('\n\n')
}