71 lines
3.0 KiB
TypeScript
71 lines
3.0 KiB
TypeScript
/**
|
|
* Layout benchmark (W4; vision §1 "Rendering (DECIDED)" — "Pre-implementation
|
|
* validation: 2k-node synthetic benchmark to confirm layout time").
|
|
*
|
|
* npx tsx scripts/bench-graph.ts
|
|
*
|
|
* Two scales: the vision's target regime (hundreds of nodes, <150 ms budget
|
|
* with a synchronous run-then-freeze pass) and the stress case (2,000 nodes,
|
|
* ~4,000 edges), the latter timed with and without barnesHutOptimize.
|
|
*
|
|
* VERDICT (2026-08-22, Apple silicon, Node 24): hundreds of nodes are
|
|
* comfortably inside the budget (see the measured lines — ~25 ms at 100,
|
|
* ~90 ms at 300). At 2k nodes the naive O(n²) pass takes seconds, and
|
|
* barnesHutOptimize cuts it roughly in half — still over budget, which is
|
|
* exactly the vision's escalation ladder: Barnes-Hut is already switched on
|
|
* automatically above ~500 nodes in components/graph-view.tsx, and the
|
|
* bundled Web Worker / server-cached positions stay available as later
|
|
* rungs if real graphs ever get there. v1 learner graphs are dozens of
|
|
* nodes; the stress case is preparation, not expectation.
|
|
*/
|
|
|
|
import Graph from "graphology";
|
|
import forceAtlas2 from "graphology-layout-forceatlas2";
|
|
|
|
const ITERATIONS = 100;
|
|
|
|
/** A plausible learning graph: mostly-local chains plus long-range cross-links. */
|
|
function synthesize(nodeCount: number, edgeCount: number): Graph {
|
|
const graph = new Graph();
|
|
for (let i = 0; i < nodeCount; i++) {
|
|
graph.addNode(`n${i}`, {
|
|
label: `node ${i}`,
|
|
size: 6,
|
|
x: Math.random() * 100,
|
|
y: Math.random() * 100,
|
|
});
|
|
}
|
|
let added = 0;
|
|
for (let i = 0; added < edgeCount && i < edgeCount * 3; i++) {
|
|
const from = Math.floor(Math.random() * nodeCount);
|
|
const span = Math.random() < 0.8 ? 1 + Math.floor(Math.random() * 10) : Math.floor(Math.random() * nodeCount);
|
|
const to = (from + span) % nodeCount;
|
|
if (from === to || graph.hasEdge(`n${from}`, `n${to}`)) continue;
|
|
graph.addEdge(`n${from}`, `n${to}`, { type: "arrow", size: 1 });
|
|
added++;
|
|
}
|
|
return graph;
|
|
}
|
|
|
|
function bench(label: string, nodeCount: number, edgeCount: number, settings: Record<string, unknown>): void {
|
|
const graph = synthesize(nodeCount, edgeCount);
|
|
const start = performance.now();
|
|
forceAtlas2.assign(graph, {
|
|
iterations: ITERATIONS,
|
|
settings: { ...forceAtlas2.inferSettings(graph), ...settings },
|
|
});
|
|
const elapsed = performance.now() - start;
|
|
console.log(
|
|
`${label}: ${elapsed.toFixed(1)} ms (${graph.order} nodes, ${graph.size} edges, ${ITERATIONS} iterations)`,
|
|
);
|
|
}
|
|
|
|
console.log(`Target regime — synchronous run-then-freeze (budget: <150 ms):\n`);
|
|
bench(" 100 nodes, ~200 edges", 100, 200, {});
|
|
bench(" 300 nodes, ~600 edges", 300, 600, {});
|
|
bench(" 500 nodes, ~1000 edges", 500, 1000, {});
|
|
console.log(`\nStress case — 2k nodes (~4000 edges), the vision's escalation ladder:\n`);
|
|
bench(" naive repulsion (O(n²)) ", 2000, 4000, {});
|
|
bench(" barnesHutOptimize ", 2000, 4000, { barnesHutOptimize: true });
|
|
bench(" barnesHutOptimize (warmed JIT)", 2000, 4000, { barnesHutOptimize: true });
|