1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
// Reproduce the fixed charge workload in the Wasm-host runtime and handwritten JS.
// This compares full host calls, not VM instructions or feature-equivalent products.
import { readFile, writeFile } from 'node:fs/promises';
import { createHash } from 'node:crypto';
import { cpus, platform, release, arch, availableParallelism } from 'node:os';
import { performance } from 'node:perf_hooks';
import { fileURLToPath } from 'node:url';
import { createRuntime } from './web/runtime.mjs';
import { createChargeModel } from './web/baseline.mjs';
const args = process.argv.slice(2);
if (args.length && !(args.length === 2 && args[0] === '--output')) {
throw new Error('Usage: node compare.mjs [--output report.json]');
}
const startedAt = new Date().toISOString();
const seed = 20260922;
const trials = 7;
const warmupTraces = 5;
const targetTrialMs = 12;
const absoluteTolerance = 1e-11;
const relativeTolerance = 1e-12;
const files = {
charge: new URL('./examples/charge.pure', import.meta.url),
baseline: new URL('./web/baseline.mjs', import.meta.url),
runtime: new URL('./web/runtime.mjs', import.meta.url),
compiler: new URL('./web/compiler.mjs', import.meta.url),
wasm: new URL('./web/core.wasm', import.meta.url),
harness: new URL('./compare.mjs', import.meta.url),
};
const contents = Object.fromEntries(await Promise.all(
Object.entries(files).map(async ([name, path]) => [name, await readFile(path)]),
));
const hash = bytes => createHash('sha256').update(bytes).digest('hex');
const sourceInfo = name => {
const text = contents[name].toString('utf8');
return {
bytes: contents[name].length,
physicalLines: text === '' ? 0 : text.split('\n').length - Number(text.endsWith('\n')),
nonblankLines: text.split('\n').filter(line => line.trim().length).length,
sha256: hash(contents[name]),
};
};
function makeTrace() {
const trace = [];
const action = (method, source = undefined) => trace.push({ method, ...(source === undefined ? {} : { source }) });
const frames = count => {
// Individual calls let correctness checks inspect every frame, not just a batch end.
for (let i = 0; i < count; i++) action('frame');
};
action('reset'); action('up', 'unknown');
action('down', 'keyboard'); action('down', 'keyboard'); frames(1);
action('down', 'pointer:1'); frames(59); action('up', 'keyboard'); frames(10);
action('up', 'pointer:1'); frames(6);
action('down', 'keyboard'); frames(2); action('up', 'keyboard'); frames(120);
action('down', 'pointer:1'); frames(600); action('releaseAll'); frames(120);
action('down', 'keyboard'); action('reset'); action('up', 'keyboard'); frames(1);
let random = seed >>> 0;
const next = limit => {
random = (Math.imul(random, 1664525) + 1013904223) >>> 0;
return random % limit;
};
for (let cycle = 0; cycle < 48; cycle++) {
const source = next(2) ? 'keyboard' : 'pointer:1';
action('down', source); frames(next(91)); action('down', source);
if (cycle % 3 === 0) action('down', 'pointer:2');
frames(next(11)); action('up', source);
if (cycle % 3 === 0) { frames(next(17)); action('up', 'pointer:2'); }
if (cycle % 7 === 0) action('reset');
else if (cycle % 5 === 0) action('releaseAll');
frames(next(121));
}
action('releaseAll'); frames(180);
return trace;
}
const trace = makeTrace();
function traceCounts() {
const counts = { hostActions: trace.length, frames: 0, logicalDown: 0,
logicalUp: 0, resets: 0, releaseAllCalls: 0, downCalls: 0, upCalls: 0 };
const held = new Set();
for (const action of trace) {
if (action.method === 'frame') counts.frames++;
else if (action.method === 'reset') { counts.resets++; held.clear(); }
else if (action.method === 'releaseAll') {
counts.releaseAllCalls++;
if (held.size) counts.logicalUp++;
held.clear();
} else if (action.method === 'down') {
counts.downCalls++;
if (!held.size) counts.logicalDown++;
held.add(action.source);
} else {
counts.upCalls++;
if (held.delete(action.source) && !held.size) counts.logicalUp++;
}
}
counts.dispatchedEvents = counts.frames + counts.logicalDown + counts.logicalUp;
return counts;
}
const counts = traceCounts();
const pure = await createRuntime(contents.wasm);
const program = pure.apply(contents.charge.toString('utf8'));
const baseline = createChargeModel();
function perform(model, action) {
switch (action.method) {
case 'frame': return model.frame(1);
case 'down': return model.down('jump', action.source);
case 'up': return model.up('jump', action.source);
case 'reset': model.reset(); return 0;
case 'releaseAll': return model.releaseAll();
default: throw new Error(`Unknown trace action ${action.method}`);
}
}
let checkedNumbers = 0, maxAbsoluteDifference = 0;
function compare(actual, expected, path) {
if (typeof expected === 'number') {
if (!Number.isFinite(actual) || !Number.isFinite(expected)) throw new Error(`${path}: non-finite value`);
const difference = Math.abs(actual - expected);
maxAbsoluteDifference = Math.max(maxAbsoluteDifference, difference);
checkedNumbers++;
if (difference > absoluteTolerance + relativeTolerance * Math.max(Math.abs(actual), Math.abs(expected))) {
throw new Error(`${path}: ${actual} != ${expected}`);
}
} else if (Array.isArray(expected)) {
if (!Array.isArray(actual) || actual.length !== expected.length) throw new Error(`${path}: array shape mismatch`);
expected.forEach((item, index) => compare(actual[index], item, `${path}[${index}]`));
} else if (expected && typeof expected === 'object') {
if (!actual || typeof actual !== 'object') throw new Error(`${path}: object missing`);
const actualKeys = Object.keys(actual).filter(key => actual[key] !== undefined).sort();
const expectedKeys = Object.keys(expected).filter(key => expected[key] !== undefined).sort();
if (JSON.stringify(actualKeys) !== JSON.stringify(expectedKeys)) throw new Error(`${path}: object keys mismatch`);
for (const key of expectedKeys) compare(actual[key], expected[key], `${path}.${key}`);
} else if (actual !== expected) throw new Error(`${path}: ${JSON.stringify(actual)} != ${JSON.stringify(expected)}`);
}
function checkSnapshots(index) {
const actual = pure.snapshot(), expected = baseline.snapshot();
if (actual.lastError) throw new Error(`Action ${index}: ${actual.errorMessage}`);
compare(actual.states, expected.states, `action[${index}].states`);
compare(actual.views, expected.views, `action[${index}].views`);
compare(actual.tick, expected.tick, `action[${index}].tick`);
compare(actual.held, expected.held, `action[${index}].held`);
}
checkSnapshots(-1);
for (let index = 0; index < trace.length; index++) {
for (const model of [pure, baseline]) {
const code = perform(model, trace[index]);
if (code !== 0) throw new Error(`Action ${index}: execution status ${code}`);
}
checkSnapshots(index);
}
const correctness = { passed: true, checkedSnapshots: trace.length + 1,
checkedNumbers, maxAbsoluteDifference, absoluteTolerance, relativeTolerance,
checkedFields: ['states', 'all view fields', 'tick', 'held input names'],
traceSha256: hash(JSON.stringify(trace)), counts };
const memory = pure.snapshot().memory;
// Snapshot construction, binding evaluation, compilation, Wasm loading, and DOM
// rendering are deliberately outside these timed loops. Host dispatch is inside.
function run(model, repetitions) {
for (let repeat = 0; repeat < repetitions; repeat++) {
for (const action of trace) {
const code = perform(model, action);
if (code !== 0) throw new Error(`Timing run failed with execution status ${code}`);
}
}
}
const models = { pureHostWasm: pure, handwrittenJavaScript: baseline };
for (const model of Object.values(models)) run(model, warmupTraces);
const repetitions = {};
const calibration = {};
for (const [name, model] of Object.entries(models)) {
const start = performance.now(); run(model, 3);
const elapsedMs = performance.now() - start;
repetitions[name] = Math.max(1, Math.min(2048, Math.ceil(targetTrialMs / Math.max(elapsedMs / 3, .001))));
calibration[name] = { elapsedMs, traces: 3, selectedRepetitions: repetitions[name] };
}
const samples = [];
for (let trial = 0; trial < trials; trial++) {
const order = trial % 2 === 0 ? Object.keys(models) : Object.keys(models).reverse();
for (const [position, name] of order.entries()) {
const start = performance.now(); run(models[name], repetitions[name]);
const elapsedMs = performance.now() - start;
const nsPerTrace = elapsedMs * 1e6 / repetitions[name];
samples.push({ trial: trial + 1, position: position + 1, implementation: name,
repetitions: repetitions[name], elapsedMs, nsPerTrace,
nsPerHostAction: nsPerTrace / counts.hostActions,
nsPerDispatchedEvent: nsPerTrace / counts.dispatchedEvents });
}
}
// Each trace begins with reset. Both timing implementations must still agree.
checkSnapshots('after timing');
const summary = {};
for (const name of Object.keys(models)) {
const values = samples.filter(sample => sample.implementation === name)
.map(sample => sample.nsPerHostAction).sort((a, b) => a - b);
summary[name] = { medianNsPerHostAction: values[Math.floor(values.length / 2)],
minNsPerHostAction: values[0], maxNsPerHostAction: values.at(-1) };
}
summary.pureOverJavaScriptMedianRatio = summary.pureHostWasm.medianNsPerHostAction
/ summary.handwrittenJavaScript.medianNsPerHostAction;
const report = {
experiment: 'Pure Workbench charge / handwritten JavaScript reference',
environment: { startedAt, completedAt: new Date().toISOString(),
node: process.version, v8: process.versions.v8, platform: platform(), osRelease: release(),
architecture: arch(), cpuModel: cpus()[0]?.model ?? 'unknown',
logicalCPUs: cpus().length, availableParallelism: availableParallelism(),
affinityControlled: false, powerControlled: false,
command: `node ${fileURLToPath(import.meta.url)}${args.length ? ` --output ${args[1]}` : ''}` },
artifacts: Object.fromEntries(Object.keys(files).map(name => [name,
{ bytes: contents[name].length, sha256: hash(contents[name]) }])),
correctness,
sources: { chargePure: sourceInfo('charge'), fixedJavaScriptModel: sourceInfo('baseline'),
note: 'Raw file size and line counts only; excludes HTML/host/compiler and does not establish authoring effort or DX quality.' },
compilerMetrics: program.metrics,
memory: { pure: memory,
note: 'Wasm linear capacity and core layout counters; not process RSS or browser memory. No equivalent JS heap measurement collected. Do not add overlapping counters.' },
timing: { seed, warmupTracesPerImplementation: warmupTraces,
trialsPerImplementation: trials, targetTrialMs, calibration, traceCounts: counts,
order: 'Alternated each trial; Pure first on odd trials, JavaScript first on even trials.',
included: 'Host method dispatch, source-latch aggregation, state logic, and resets in the fixed trace. Pure additionally maintains generic VM/event diagnostics.',
excluded: 'Compilation, loading, snapshots, binding evaluation, DOM rendering, scene editing, and live apply.',
normalization: 'nsPerHostAction divides total time by calls including repeats, releaseAll and reset; nsPerDispatchedEvent also amortizes that host overhead.',
limitations: 'Single-machine batch throughput; no CPU pinning or energy/thermal control. Seven trial averages are not event latency percentiles. Fixed JS has no live program replacement, general compiler, or state migration; not feature-equivalent whole-product timing.',
samples, summary },
};
const json = JSON.stringify(report, null, 2) + '\n';
if (args.length) await writeFile(args[1], json, { flag: 'wx' });
process.stdout.write(json);
|
