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.
This commit is contained in:
1 parent
cad485b13c
commit
c84186b032
14 files changed
+3135
-17
No files matched your search
@@ -0,0 +1,282 @@
|
||||
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')
|
||||
}
|
||||
Reference in new issue
Block a user