diff --git a/CHANGELOG.md b/CHANGELOG.md index f8e6113..89ef1ff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,7 @@ All notable changes to this project are documented here. The project follows - Working out where traffic goes takes about a fifth less work on big networks, with exactly the same result. - The game no longer freezes while it routes each day's traffic on big networks. A background thread of the game does the routing, so the map, panels and buttons keep responding while days go by; what the day brings is exactly what it was before. Clicks that change your network still route right away. - A plug-in optic that is too short for your subsea cable no longer sends you to submarine terminals and optical engineering, which cannot stretch it (#253). The hint now names the optics that do reach, such as the Sienna WaveMagic 1.6T for Perth to Cape Town. Optics the upgrades can stretch still get the advice. +- Big networks use about half the battery they did: each day's routing takes half the processor time, and reuses what it worked out the day before when only demand has changed. Where traffic goes does not change. ## [2.4.0] — 2026-11-01 diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 9658c3d..cbae642 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -140,6 +140,20 @@ It runs every day and after every action, so it is built for big networks: the g indices (`CIDX`), each exit is asked once per network what it can reach, and `R.ef` (what crosses each link) is only put together for a link when something reads it. +What follows from the network's shape alone is kept from one call to the next (`29-route-cache.js`): the shortest +paths from every POP, and who reaches whom with each network's exit lists. Each has a key made of everything it is +built from (the live graph with its weights; every exit with what it reaches and how it is preferred, RouteScript and +the events that move routes), so most days, when only demand changes, they are reused, and any other change rebuilds +them. Only indices are kept: exits, lists and paths are made fresh every call, because routing writes on them. +`tests/route-cache.test.js` checks the keys, and the equivalence tests route with and without the kept tables. +`scripts/route-fuzz.js` plays hundreds of random seeded games on main's page and this checkout's at once, comparing all +of R and S after every move and day, with the kept tables and without (`tests/route-fuzz.test.js` plays a few). + +Each loop of `compute()` runs in a function of its own (the stages are closures, the busiest is `rankPass`; +the money is `computeMoney()`). V8 optimises a small function quickly and keeps it; `compute()` as one 33 KB function +never stayed optimised: it ran in baseline code, boxing every number, and was compiled again and again in the background +only to be thrown away, which cost more CPU than the routing itself. Keep it that way: a new loop goes in a function. + Served share per city (`sfOf`) drives eyeball revenue and customer mood. ## Routing in a worker diff --git a/scripts/lib/fuzz-page.js b/scripts/lib/fuzz-page.js new file mode 100644 index 0000000..c495355 --- /dev/null +++ b/scripts/lib/fuzz-page.js @@ -0,0 +1,167 @@ +// Runs inside a game page (scripts/route-fuzz.js loads two: main's and this checkout's), next to scripts/lib/mcp-page.js. +// The driver picks every move with its own seeded random numbers and sends the same calls to both pages, so the pages +// stay in lockstep; this file only offers what a player could do now (buttons on screen, POPs, cities) and digests what +// routing gave, as strings the driver compares. +(() => { + const DENY = new Set(['animSet', 'cont', 'exportSave', 'importGo', 'importPick', 'install', 'langSet', 'menu', 'mute', 'newgame', 'phonePlay', 'phoneSpeed', + 'prefSet', 'pzShare', 'resetAsk', 'settings', 'settingsClose', 'share', 'shareDl', 'shareGo', 'slotBack', 'slotDel', 'slotDelGo', 'slotExport', 'slotMenu', + 'slotRetry', 'slotSpace', 'slotSwitch', 'slotTake', 'soundSet', 'speed', 'start', 'toTitle', 'traceCopy', 'updateLater', 'updateNow', 'vpSet', 'wsShare', + // Leave the game or open what is not this game: the title screen, menus of other modes, AI helpers that fetch. + 'closePanel', 'puzzleMenu', 'puzzleDoor', 'scnMenu', 'startScn', 'startWeekly', 'pzStart', 'pzArStart', 'arMenu', 'teSlop', 'help', 'helpClose', 'keepPlaying', + 'logOpen', 'pitchSkip', 'pitchGo', 'feedback', 'tutSkip', 'tutNext']); + const sig = (b) => b.act + ' ' + JSON.stringify(b.args); + const btns = (root) => (root ? [...root.querySelectorAll('[data-act]')] : []).filter((b) => !b.disabled && !DENY.has(b.dataset.act) && typeof ACT[b.dataset.act] === 'function') + .map((b) => { let args = {}; try { args = JSON.parse(b.dataset.args || '{}'); } catch (e) {} return { act: b.dataset.act, args }; }); + const modalOpen = () => !$('modal').hidden; + const errs = []; + const call = (act, args) => { + try { const r = ACT[act](args || {}); if (r && typeof r.then === 'function') r.catch((e) => errs.push(act + ': ' + e.message)); return ''; } catch (e) { return act + ': ' + (e && e.message); } + }; + const fixClock = (t) => { Date.now = () => t; }; + + // ---------- starts ---------- + const homes = () => CITIES.filter((c) => homeOk(c.id)).map((c) => c.id); + // Home cities with rules of their own: China, Korea, Russia, Australia, the Philippines, islands and far places. + const special = () => CITIES.filter((c) => homeOk(c.id) && (c.cn || c.kr || c.ru || ['AU', 'PH', 'NZ', 'JP', 'ID', 'IS', 'FJ', 'PF', 'MU', 'MV', 'CL', 'ZA', 'BR', 'IN', 'SG', 'HK', 'TW', 'KR', 'CN'].includes(c.cc))).map((c) => c.id); + const lists = () => ({ homes: homes(), special: special(), scn: SCN.map((s) => s.id), pz: PZ.map((p) => p.id), ar: AR_RUNS.map((r) => r.id) }); + const settle = () => { UI.started = true; UI.pitched = true; UI.speed = 0; if (UI.pendGame) ACT.pitchSkip(); closeModal(); if (S && !pzOn()) compute(); renderAll(); }; + const start = ({ kind, id, city, preset, seed, name }) => { + if (window.__reseed) window.__reseed(seed); + fixClock(1.7e12 + seed * 1000); + UI.pitched = true; UI.pendGame = null; + if (pzOn()) pzLeave(); + if (kind === 'normal') beginGame(name, city, { mode: 'normal', preset }); + else if (kind === 'sandbox') beginGame(name, city, { mode: 'sandbox', rules: { chaos: preset } }); + else if (kind === 'scenario') { const sc = SCN.find((x) => x.id === id); beginGame(name, sc.city, { scn: sc }); } + else if (kind === 'weekly') { const wk = weekly(); beginGame(name, wk.city, { scn: wk, seed: wk.seed }); } + else if (kind === 'puzzle') pzBegin(pzDef(id)); + else if (kind === 'architect') arBegin(arRunDef(id)); + // A saved network (the big fixture): loaded and migrated as an import is, with its incidents and events still on. + else if (kind === 'save') { S = migrate(JSON.parse(window.__fzSave)); } + settle(); + return { mode: S.mode, home: S.home, puzzle: pzOn() }; + }; + + // ---------- what a player could do now ---------- + // The nearest cities, and those a cable lands from here (subsea seats, IRUs and own cables start there). + const near = (c, n) => CITIES.filter((x) => x.id !== c).map((x) => [x.id, kmBetween(c, x.id)]).sort((a, b) => a[1] - b[1]).slice(0, n).map((x) => x[0]) + .concat(CABLE_PAIRS.filter((p) => p.a === c || p.b === c).slice(0, 4).map((p) => (p.a === c ? p.b : p.a))); + const state = () => { + const pops = Object.keys(S.pops), nb = new Set(); + for (const p of pops.slice(0, 12)) for (const c of near(p, 8)) if (!S.pops[c]) nb.add(c); + return { pops, near: [...nb], cities: CITIES.length, links: S.links.map((l) => l.id), day: S.day, puzzle: pzOn(), modal: modalOpen(), lost: !!S.lost, + clock: !!rule('clock'), core: S.core ? S.core.lv : 0, nets: NET_IDS.length, transit: S.transit.map((t) => t.id), pni: S.pni.map((p) => p.id), biz: S.biz.map((b) => b.id), offers: (S.offers || []).map((o) => o.id) }; + }; + // The buttons of one place on screen, after opening it. + const screen = (w) => { + if (w.where === 'modal') return btns($('modal')); + if (w.where === 'city') { UI.sel = { type: 'city', id: w.city }; UI.tab = w.tab; renderAll(); return btns($('panel')); } + if (w.where === 'link') { if (!S.links.some((l) => l.id === w.id)) return []; UI.sel = { type: 'link', id: w.id }; renderAll(); return btns($('panel')); } + if (w.where === 'dash') { $('dash').hidden = false; UI.dtab = w.tab; renderDash(); const b = btns($('dash')); return b; } + if (w.where === 'left') { UI.left = w.tab; UI.leftOpen = true; renderLeft(); return btns($('leftBody')); } + if (w.where === 'openLink') { if (!S.pops[w.a]) return []; openLinkModal(w.a, w.b); return modalOpen() ? btns($('modal')) : []; } + return []; + }; + const press = (b) => { const e = call(b.act, b.args); return e; }; + const close = () => { if (modalOpen()) closeModal(); $('dash').hidden = true; }; + + // ---------- things a player does with no button handy here ---------- + const RS = ['spill at 80%', 'spill at 60%', 'protect customers', 'blackhole ddos']; + const script = (rules) => { + const L = []; + for (const r of rules) { + const [k, a, b] = r; + const net = NETS[a % NETS.length], t = S.transit.length ? NET[S.transit[a % S.transit.length].net] : net; + const pops = Object.keys(S.pops), l = S.links.length ? S.links[a % S.links.length] : null; + if (k === 0) L.push(RS[a % RS.length]); + else if (k === 1) L.push(`${b % 2 ? 'prefer' : 'avoid'} ${['pni', 'ix', 'transit'][b % 3]} for ${net.name.toLowerCase()}`); + else if (k === 2) L.push(`cap transit ${t.name.toLowerCase()} at ${10 + (b % 50)} gbps`); + else if (k === 3) L.push(`${b % 2 ? 'prefer' : 'avoid'} transit ${t.name.toLowerCase()}`); + else if (k === 4) L.push(`prepend transit ${t.name.toLowerCase()} ${1 + (b % 3)}`); + else if (k === 5 && pops.length) L.push(`drain ${CITY[pops[a % pops.length]].name.toLowerCase()}`); + else if (k === 6 && l) L.push(`avoid link ${CITY[l.a].name.toLowerCase()}-${CITY[l.b].name.toLowerCase()}`); + } + return L.join('\n'); + }; + const poke = (p) => { + const [k, a, b] = p; + if (k === 'te') { if (!S.te) return 'no te'; S.te.script = script(a); S.te.on = !!b; S.core = S.core || { lv: 0, run: 0 }; after(); return S.te.script; } + if (k === 'teOff') { if (S.te) { S.te.on = false; after(); } return ''; } + if (k === 'core') { if (S.core) { const v = a % (S.core.lv + 1); return call('coreSet', { v }); } return ''; } + if (k === 'fail') { S.nextFail = S.day + 1; return ''; } + if (k === 'event') { S.nextEvent = S.day + 1; return ''; } + if (k === 'cash') { S.cash += a; after(); return ''; } + if (k === 'lvl') { S.lvl = Math.min(LEVELS.length, (S.lvl || 0) + 1); after(); return ''; } + // Events that move routes, as the game's own events set them. + if (k === 'ev') { + const n = NETS[a % NETS.length].id; + if (b === 0) S.ev.leak = { net: n, until: S.day + 3 }; + else if (b === 1) S.ev.rpki = { nets: [n, NETS[(a * 7) % NETS.length].id], until: S.day + 3 }; + else if (b === 2) S.ev.depeer = S.day + 3; + else if (b === 3) { const x = Object.keys(S.ixp); if (x.length) { S.ev.ixdown = S.ev.ixdown || {}; S.ev.ixdown[x[a % x.length]] = S.day + 2; } } + else if (b === 4 && S.links.length) S.links[a % S.links.length].cut = S.day + 2; + else if (b === 5 && S.transit.length) S.transit[a % S.transit.length].down = S.day + 2; + // After an update brings networks: the courtesy route to them (sanitize() sets it on load). + else if (b === 7) S.grace = { until: S.day + 4, nets: [n, NETS[(a * 13) % NETS.length].id, NETS[(a * 31) % NETS.length].id], fresh: 0 }; + else if (b === 8) S.krExit = S.day + 2; + else if (b === 6) { const p = Object.keys(S.pops); if (p.length > 1) S.pops[p[1 + (a % (p.length - 1))]].down = S.day + 2; } + after(); return ''; + } + return 'unknown poke'; + }; + + /* Actions on what the network already has, with arguments a button somewhere would give (some sit in collapsed + lists, or on screens the walker rarely reaches): one list of calls, the driver picks one. */ + const direct = () => { + const o = [], add = (act, args) => { if (typeof ACT[act] === 'function') o.push({ act, args }); }; + const pops = Object.keys(S.pops), PR = ['high', 'low', 'normal']; + for (const t of S.transit) { add('setPref', { kind: 't', id: t.id, v: PR[(t.id.length + S.day) % 3] }); add('setCarry', { id: t.id, on: !t.carry }); add('lagT', { id: t.id, d: (S.day % 3) ? 1 : -1 }); add('cancelTransit', { id: t.id, ok: true }); add('togglePrem', { id: t.id }); add('cleanPipe', { id: t.id }); } + for (const p of S.pni) { add('setPref', { kind: 'p', id: p.id, v: PR[(p.id.length + S.day) % 3] }); add('lagP', { id: p.id, d: (S.day % 3) ? 1 : -1 }); add('cancelPni', { id: p.id, ok: true }); add('sacrif', { id: p.id }); } + for (const x of Object.keys(S.ixp)) { add('setPref', { kind: 'ix', id: x, v: PR[(x.length + S.day) % 3] }); add('lagIx', { city: x, d: (S.day % 3) ? 1 : -1 }); add('peerAll', { city: x }); add('rs', { city: x }); add('cancelIx', { city: x, sure: true, ok: true }); + for (const n of ixMembers(x).slice(0, 30)) add(ixSessions(x).has(n) ? 'unpeer' : 'peer', { city: x, net: n }); } + for (const c of pops) { + for (const x of ixIdsIn(c)) if (S.ixp[x] === undefined) add('buyIx', { city: x, tier: S.day % 3 }); + for (const n of NETS) if (n.pops.includes(c)) { if (S.day % 2 === 0 || n.cache) add('pni', { city: c, net: n.id, tier: n.id.length % 3 }); if (n.cache) add('cache', { city: c, net: n.id }); } + for (const n of NETS) if (sellsAt(n, c) && (n.id.length + S.day) % 4 === 0) add('buyTransit', { city: c, net: n.id, tier: (S.day >> 2) % 3 }); + add('addRouter', { city: c }); add('upRouter', { city: c, g: 1 + (S.day % 4) }); add('foundIx', { city: c }); add('launchBB', { city: c }); add('addSite', { city: c }); + } + for (const c of S.caches) add('rmCache', { id: c.id }); + for (const l of S.links) { add('setStandby', { id: l.id, on: !l.standby }); add('setMetric', { id: l.id, v: ['backup', 'avoid', 'prefer', 'normal'][(l.id.length + S.day) % 4] }); add('upLink', { id: l.id, tier: (S.day % 4) }); add('rmLink', { id: l.id }); add('addParallel', { id: l.id }); } + for (const b of S.offers || []) add('accept', { id: b.id }); + for (const b of S.biz) add('dropBiz', { id: b.id }); + for (const l of S.loanOffers || []) add('takeLoan', { id: l.id }); + for (const l of S.loans || []) add('repayLoan', { id: l.id }); + return o; + }; + + // ---------- time ---------- + const day = () => { if (S.lost || !rule('clock')) return 'no clock'; if (modalOpen()) closeModal(); try { dayTick(); } catch (e) { return 'dayTick: ' + e.message; } return ''; }; + + // ---------- digests ---------- + // Everything routing produced: R in full (with every link's R.ef), the flows (R.fl), and what the PNI lists read. + const routing = () => { + if (!R) return 'noR'; + const r = JSON.stringify(R), fl = R.fl ? JSON.stringify(R.fl) : ''; + let pf = ''; + if (typeof pniFlows === 'function' && S && !pzOn()) for (const c of Object.keys(S.pops).slice(0, 4)) try { pf += c + JSON.stringify(pniFlows(c)); } catch (e) { pf += c + 'E' + e.message; } + return r + '\n' + fl + '\n' + pf; + }; + const parts = () => { const o = {}; if (!R) return o; for (const k of Object.keys(R)) o[k] = JSON.stringify(R[k]); o.fl = R.fl ? JSON.stringify(R.fl) : ''; return o; }; + const sDigest = () => JSON.stringify(S); + const sParts = () => { const o = {}; for (const k of Object.keys(S)) o[k] = JSON.stringify(S[k]); return o; }; + /* After a move: what the move routed (a), routing again from the same state (b: on this checkout's page the kept + tables are used), and routing from that state with the cache off (c: RC.on=false where there is an RC). b and c + route from the same previous R; c's R is kept, as a plain compute would. */ + const check = () => { + if (!S || pzOn() && !R) return { a: routing() }; + const a = routing(), prior = R, keep = UI.rkR === prior; + compute(); const b = routing(); + R = prior; const rc = typeof RC !== 'undefined'; + if (rc) RC.on = false; + try { compute(); } finally { if (rc) RC.on = true; } + const c = routing(); + if (keep) UI.rkR = R; + return { a, b, c }; + }; + window.__fz = { direct, lists, start, state, screen, press, close, poke, day, routing, parts, sDigest, sParts, check, errs, modalOpen }; +})(); diff --git a/scripts/lib/route-fuzz.js b/scripts/lib/route-fuzz.js new file mode 100644 index 0000000..b5b5eb2 --- /dev/null +++ b/scripts/lib/route-fuzz.js @@ -0,0 +1,188 @@ +// Differential games (scripts/route-fuzz.js, tests/route-fuzz.test.js): two game pages in one process, a base page +// (main's) and this checkout's, play the same seeded game move for move. After every move and every day both must +// have routed identically (all of R, R.fl, R.ef, the PNI lists), and this checkout must route the same with the +// routing cache (RC) on and off. The whole game state S must match too, so the two games stay in lockstep. +// Every move is picked here, from what the base page offers right now, with the game's seed: the seed alone +// replays a game. +const fs = require('node:fs'); +const path = require('node:path'); +const { load } = require('../../tests/harness'); + +const FUZZ_JS = fs.readFileSync(path.join(__dirname, 'fuzz-page.js'), 'utf8'); + +function openPage(file, label) { + const g = load({ seed: 1, file }); + g.ev(FUZZ_JS); + g.label = label; + g.call = (fn, ...args) => { + g.dom.window.__fzA = JSON.parse(JSON.stringify(args)); + const out = g.ev(`JSON.stringify(__fz.${fn}(...window.__fzA))`); + return out === undefined ? undefined : JSON.parse(out); + }; + return g; +} + +// mulberry32: the driver's own numbers, apart from the pages' Math.random. +function rng(seed) { + let a = seed >>> 0; + const f = () => { a = (a + 0x6D2B79F5) >>> 0; let t = a; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; + f.int = (n) => Math.floor(f() * n); + f.pick = (a) => a[f.int(a.length)]; + // A button by its action's weight (w), then any button of that action: 38 transit sellers count as one choice. + f.wp = (a, w) => { const g = new Map(); for (const x of a) { const l = g.get(x.act); if (l) l.push(x); else g.set(x.act, [x]); } + const ks = [...g.keys()]; let s = 0; for (const k of ks) s += w(g.get(k)[0]); let t = f() * s; + for (const k of ks) { t -= w(g.get(k)[0]); if (t < 0) return f.pick(g.get(k)); } return f.pick(g.get(ks[ks.length - 1])); }; + f.w = (o) => { let s = 0; for (const k in o) s += o[k]; let x = f() * s; for (const k in o) { x -= o[k]; if (x < 0) return k; } return Object.keys(o)[0]; }; + return f; +} + +// The first key of two {key: json} maps that differs, with a short look at where. +function firstDiff(A, B) { + const keys = [...new Set([...Object.keys(A), ...Object.keys(B)])]; + const out = []; + for (const k of keys) { + if (A[k] === B[k]) continue; + const a = A[k] || '', b = B[k] || ''; + let i = 0; while (i < a.length && a[i] === b[i]) i++; + out.push({ key: k, at: i, base: a.slice(Math.max(0, i - 80), i + 120), head: b.slice(Math.max(0, i - 80), i + 120) }); + if (out.length >= 4) break; + } + return out; +} + +const DTABS = ['overview', 'cust', 'conn', 'traffic', 'infra', 'lease']; +const TABS = ['cust', 'up', 'peer', 'links']; +const LEFT = ['nets', 'noc', 'deals', 'goals']; +const PRESETS = ['freeze', 'oncall', 'bgp']; +// How often a button is pressed against the others on screen: what changes the network often, looking around rarely. +const BUILD = /^(buy\w*|pni\w*All|pni|peer|peerAll|unpeer|cache|cacheSite|rmCache|buildLink|buildPop|launchBB|accept|decline|dropBiz|takeLoan|repayLoan|lag[TPI]x?|setPref|setCarry|setStandby|setMetric|togglePrem|cleanPipe|sacrif|rs|foundIx|myIxUp|addRouter|rmRouter|upRouter|addSite|rmSite|siteSet|decomToggle|rmLink|upLink|addParallel|cancel\w*|upVxc|buyNni|rmNni|buildScrub|scrubUp|rmScrub|addGen|regen|addCh|rmCh|addPair|upSys|spares|layShip|crews|fixInc|seaPackage|subUpgrade|orderCable|orderDf|ownCab|opsHire|opsToggle|opsParam|opsCap|opsPop|opsTpl|opsNewPop|popStdSet|coreSet|teRecipe|dkOptOut|dkStay|utility\w*|listFiber|unlistFiber|leaseSwap|custGo|confGo|confSponsor|seatBuy|charter|cnPrem|applyCn|ad|ddosAuto|pz(Pop|RmPop|Link|AddPar|Tier|RmLink|RtAdd|RtRm|RtModel|Route|Via|Div)|setRoute|route|via|metricSet)$/; +const UIACT = /^(tab|dashTab|leftTab|\w*Sort|\w*Filter|pniGrp|trace\w*|focusCity|findGo|selLink|dashLink|logAll|tailTog|listMore|netFocus|netFilter|meetGo|phoneTab|dashClose|connF|connCity|connNet|connFor|custF|custCity|opsOpen|decomOpen|linkCheck)$/; +const DW = { launchBB: 4, accept: 4, buyTransit: 3, pni: 3, buyIx: 3, setPref: 4, cache: 2, peerAll: 2, setCarry: 2, takeLoan: 2 }; +const weight = (b) => (BUILD.test(b.act) ? 8 : UIACT.test(b.act) ? 0.3 : 1); + +/* One game. pages: {base, head}. Returns {seed, start, moves, days, log, div} where div is the first divergence (or null). + opts: moves (count, default 50 to 200 by seed), maxDays per day-move, onMove(i, move) */ +function playGame(pages, seed, opts = {}) { + const { base, head } = pages; + const r = rng(seed * 2654435761); + const both = (fn, ...a) => [base.call(fn, ...a), head.call(fn, ...a)]; + const L = base.call('lists'); + const log = [], acts = {}; + let div = null, days = 0; + const note = (m) => { log.push(m); }; + const fail = (where, info) => { if (!div) div = { seed, where, move: log.length, last: log.slice(-6), ...info }; }; + const same = (where, a, b) => { if (JSON.stringify(a) !== JSON.stringify(b)) fail(where, { base: a, head: b }); }; + + // Compare everything: routing on both pages (a: the move's, b: again, c: cache off) and the game state. + const compare = (where) => { + const [x, y] = both('check'); + for (const k of ['a', 'b', 'c']) if (x[k] !== y[k]) { fail(where + ': routing (' + k + ') base vs head', { diff: firstDiff(base.call('parts'), head.call('parts')) }); return false; } + if (y.b !== y.c) { fail(where + ': head cached vs uncached', { diff: 'R from the kept tables differs from a fresh route' }); return false; } + const [s1, s2] = both('sDigest'); + if (s1 !== s2) { fail(where + ': game state S', { diff: firstDiff(base.call('sParts'), head.call('sParts')) }); return false; } + return true; + }; + + // The start. + const kind = opts.save ? 'save' : r.w({ normal: 44, sandbox: 14, scenario: 20, weekly: 3, puzzle: 11, architect: 8 }); + if (opts.save) for (const p of [base, head]) p.dom.window.__fzSave = opts.save; + const home = r() < 0.4 ? r.pick(L.special) : r.pick(L.homes); + const st = { kind, seed: (seed % 2147483646) + 1, name: 'Fuzz ' + seed, city: home, + preset: kind === 'sandbox' ? r.pick(['none', 'calm', 'normal', 'spicy']) : r.pick(PRESETS), + id: kind === 'scenario' ? r.pick(L.scn) : kind === 'puzzle' ? r.pick(L.pz) : kind === 'architect' ? r.pick(L.ar) : undefined }; + const [s0, s1] = both('start', st); + same('start', s0, s1); + note('start ' + JSON.stringify(st)); + if (!div) compare('start'); + + // A screen's buttons on both pages; the same list or a divergence. + const screen = (w) => { const [a, b] = both('screen', w); same('buttons of ' + JSON.stringify(w), a, b); return a || []; }; + const press = (b, where) => { acts[b.act] = (acts[b.act] || 0) + 1; const [e1, e2] = both('press', b); same('press ' + where, e1, e2); note(where + ' ' + b.act + JSON.stringify(b.args) + (e1 ? ' !' + e1 : '')); }; + // Answer whatever window opened, a few levels deep, then close it. + const modal = (bias) => { + for (let k = 0; k < 4 && !div; k++) { + if (!base.call('modalOpen')) return; + let bs = screen({ where: 'modal' }); + if (bias) { const pref = bs.filter((b) => bias.test(b.act)); if (pref.length && r() < 0.7) bs = pref; } + const real = bs.filter((b) => !/^(closeModal|x)$/.test(b.act)); + if (!real.length || r() < 0.12) break; + press(r.wp(real, weight), ' modal'); + if (!div) compare('modal button'); + } + both('close'); + }; + + const N = opts.moves || 50 + (seed % 151); + for (let i = 0; i < N && !div; i++) { + const s = base.call('state'); + if (s.lost) { note('bankrupt'); break; } + const mv = r.w(s.puzzle ? { city: 40, openLink: 30, link: 15, modal: 5 } : { city: 22, direct: 22, openLink: 13, link: 5, dash: 5, left: 3, poke: 8, day: s.clock ? 20 : 0, build: 4 }); + if (opts.onMove) opts.onMove(i, mv); + if (mv === 'city' || mv === 'build') { + const city = mv === 'build' || !s.pops.length || r() < 0.3 ? (s.near.length ? r.pick(s.near) : r.pick(L.homes)) : r.pick(s.pops); + const tab = r.pick(TABS); + let bs = screen({ where: 'city', city, tab }); + if (mv === 'build') { const p = bs.filter((b) => /^(buildPop|launchBB|opsNewPop|popStdSet)$/.test(b.act)); if (p.length) bs = p; } + if (bs.length) press(r.wp(bs, weight), `city ${city}/${tab}`); + if (!div) compare('city button'); + modal(); + } else if (mv === 'openLink') { + if (!s.pops.length) continue; + const a = r.pick(s.pops), b = r() < 0.75 && s.near.length ? r.pick(s.near) : r() < 0.5 && s.pops.length > 1 ? r.pick(s.pops) : r.pick(L.homes); + const bs = screen({ where: 'openLink', a, b }); + note(`openLink ${a}-${b} (${bs.length})`); + if (bs.length) { + // Pick a route or a kind first sometimes (dark fiber, subsea seat, own cable...), then build. + const opt = bs.filter((x) => !/^(buildLink|closeModal)$/.test(x.act)); + if (opt.length && r() < 0.4) { press(r.pick(opt), ' link option'); if (!div) compare('link option'); } + modal(/^(buildLink|pzLink|seaPackage|layShip|buyVxc|dfSys|seaDesign)$/); + } else both('close'); + if (!div) compare('openLink'); + } else if (mv === 'link') { + if (!s.links.length) continue; + const id = r.pick(s.links); + const bs = screen({ where: 'link', id }); + if (bs.length) press(r.wp(bs, weight), 'link ' + id); + if (!div) compare('link button'); + modal(); + } else if (mv === 'dash' || mv === 'left') { + const w = mv === 'dash' ? { where: 'dash', tab: r.pick(DTABS) } : { where: 'left', tab: r.pick(LEFT) }; + const bs = screen(w); + if (bs.length) press(r.wp(bs, weight), mv + ' ' + w.tab); + both('close'); + if (!div) compare(mv + ' button'); + modal(); + } else if (mv === 'direct') { + const [a, b] = both('direct'); + same('direct calls', a, b); + if (a.length) press(r.wp(a, (x) => DW[x.act] || (/^(cancel|rm|drop|unpeer)/.test(x.act) ? 0.4 : 1)), 'direct'); + if (!div) compare('direct'); + modal(); + } else if (mv === 'modal') { + modal(); + } else if (mv === 'poke') { + const k = r.w({ te: 3, teOff: 1, core: 2, fail: 2, event: 3, cash: 3, lvl: 2, ev: 4 }); + let p; + if (k === 'te') { const rules = []; for (let j = 0, n = 1 + r.int(4); j < n; j++) rules.push([r.int(7), r.int(1000), r.int(1000)]); p = [k, rules, r() < 0.85]; } + else p = [k, k === 'cash' ? r.int(3e7) : r.int(1e6), r.int(9)]; + const [e1, e2] = both('poke', p); + same('poke', e1, e2); + note('poke ' + JSON.stringify(p)); + if (!div) compare('poke ' + k); + } else if (mv === 'day') { + const n = 1 + r.int(opts.maxDays || 12); + note('days ' + n); + for (let d = 0; d < n && !div; d++) { + const [e1, e2] = both('day'); + same('day', e1, e2); + days++; + if (!div) compare('day ' + d); + // A window that opened over the day (an offer, a loan, a crisis) gets an answer. + if (!div && base.call('modalOpen')) modal(); + } + } + } + return { seed, start: st, moves: log.length, days, log, div, acts, errors: [...base.errors, ...head.errors] }; +} + +module.exports = { openPage, playGame, rng }; diff --git a/scripts/route-fuzz.js b/scripts/route-fuzz.js new file mode 100644 index 0000000..e202785 --- /dev/null +++ b/scripts/route-fuzz.js @@ -0,0 +1,84 @@ +#!/usr/bin/env node +// Many random games, played move for move on main's page and on this checkout's, compared after every move and day +// (scripts/lib/route-fuzz.js). For refactors that promise identical routing. +// +// node scripts/route-fuzz.js 300 games against origin/main +// node scripts/route-fuzz.js --games 50 --from 1000 games with seeds 1000..1049 +// node scripts/route-fuzz.js --seed 1234 -v one game, every move printed (to replay a divergence) +// node scripts/route-fuzz.js --save tests/fixtures/big-network.json --games 10 --moves 30 from a big network +// node scripts/route-fuzz.js --jobs 2 --base OLD.html --out fuzz.json +// Exit code 1 when any game diverged; each divergence is printed with its seed and its last moves. +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const { fork } = require('node:child_process'); + +const args = process.argv.slice(2); +const opt = (k, d) => { const i = args.indexOf(k); return i >= 0 ? args[i + 1] : d; }; +const has = (k) => args.includes(k); + +function child() { + const { openPage, playGame } = require('./lib/route-fuzz'); + const base = openPage(opt('--base'), 'base'), head = openPage(opt('--head'), 'head'); + process.on('message', (m) => { + if (m.stop) process.exit(0); + const t = Date.now(); + let res; + try { res = playGame({ base, head }, m.seed, { moves: m.moves, save: m.save }); } catch (e) { res = { seed: m.seed, div: { where: 'driver crashed', error: String(e.stack || e) }, log: [] }; } + process.send({ seed: m.seed, ms: Date.now() - t, start: res.start, moves: res.moves, days: res.days, div: res.div, acts: res.acts, log: m.verbose || res.div ? res.log : null, errors: res.errors }); + }); + process.send({ ready: true }); +} + +function parent() { + const page = require('./lib/page'); + const tmp = (n) => path.join(os.tmpdir(), `tubes-fuzz-${process.pid}-${n}.html`); + const BASE = opt('--base', null) || (() => { const f = tmp('base'); fs.writeFileSync(f, page.assembleRef(opt('--base-ref', 'origin/main'))); return f; })(); + const HEAD = opt('--head', null) || (() => { const f = tmp('head'); fs.writeFileSync(f, page.assemble().html); return f; })(); + const one = opt('--seed', null); + const from = +opt('--from', 1), games = one ? 1 : +opt('--games', 300); + const seeds = one ? [+one] : Array.from({ length: games }, (_, i) => from + i); + const jobs = Math.max(1, Math.min(+opt('--jobs', Math.max(1, os.cpus().length)), seeds.length)); + const verbose = has('-v'); + const moves = opt('--moves', null) ? +opt('--moves') : undefined; + // --save FILE: every game starts from this save (a plain one, or an export from the menu) instead of a new network. + const RAW = opt('--save', null) ? JSON.parse(fs.readFileSync(opt('--save'), 'utf8')) : null; + const save = RAW ? JSON.stringify(RAW.app === 'series-of-tubes' && RAW.S ? RAW.S : RAW) : undefined; + const results = []; + let next = 0, live = 0; + const t0 = Date.now(); + const done = () => { + const div = results.filter((r) => r.div), tot = (k) => results.reduce((a, r) => a + (r[k] || 0), 0); + const kinds = {}; + for (const r of results) if (r.start) { const k = r.start.kind + (r.start.kind === 'normal' || r.start.kind === 'sandbox' ? ':' + r.start.preset : ''); kinds[k] = (kinds[k] || 0) + 1; } + console.log(`\n${results.length} games, ${tot('moves')} moves, ${tot('days')} days in ${((Date.now() - t0) / 1000).toFixed(0)} s. Starts: ${JSON.stringify(kinds)}`); + const acts = {};for (const r of results) for (const k in r.acts || {}) acts[k] = (acts[k] || 0) + r.acts[k]; + if (has('--acts')) console.log('Actions pressed: ' + Object.entries(acts).sort((a, b) => b[1] - a[1]).map(([k, n]) => k + ' ' + n).join(', ')); + const errs = [...new Set(results.flatMap((r) => r.errors || []))]; + if (errs.length) console.log('Page errors:\n' + errs.slice(0, 10).map((e) => ' ' + e.slice(0, 200)).join('\n')); + if (div.length) { + console.log(`\n${div.length} games diverged:`); + for (const r of div) console.log(JSON.stringify({ seed: r.seed, start: r.start, ...r.div }, null, 1).slice(0, 4000)); + } else console.log('No divergence: identical routing and game state in every game, cached and uncached.'); + const out = opt('--out', null); + if (out) fs.writeFileSync(out, JSON.stringify(results, null, 1)); + process.exit(div.length ? 1 : 0); + }; + for (let j = 0; j < jobs; j++) { + const c = fork(__filename, ['--child', '--base', BASE, '--head', HEAD], { stdio: ['ignore', 'inherit', 'inherit', 'ipc'] }); + live++; + const feed = () => { if (next < seeds.length) c.send({ seed: seeds[next++], moves, verbose, save }); else c.send({ stop: true }); }; + c.on('message', (m) => { + if (!m.ready) { + results.push(m); + const tag = m.div ? 'DIVERGED at ' + m.div.where : 'ok'; + console.log(`seed ${m.seed} ${m.start ? m.start.kind + ' ' + (m.start.id || m.start.preset) + ' ' + m.start.city : ''}: ${m.moves} moves, ${m.days} days, ${(m.ms / 1000).toFixed(1)} s, ${tag}`); + if (verbose && m.log) console.log(m.log.map((l) => ' ' + l).join('\n')); + } + feed(); + }); + c.on('exit', () => { if (--live === 0) done(); }); + } +} + +if (has('--child')) child(); else parent(); diff --git a/src/game/80-simulation/10-dijkstra.js b/src/game/80-simulation/10-dijkstra.js index 1ef9be7..5b53685 100644 --- a/src/game/80-simulation/10-dijkstra.js +++ b/src/game/80-simulation/10-dijkstra.js @@ -15,3 +15,5 @@ function dijkstra(adj,src,wf,skip,stop){const n=adj.length,D=new Float64Array(n) return {D,P};} // The edges of a dijkstra() path back from city index B to A, and the cities on it (B first), as indices. function walkI(P,A,B){const path=[],ni=[B];let v=B;while(v!==A){const l=P[v];path.push(l);v=l.ai===v?l.bi:l.ai;ni.push(v);}return {path,ni};} +// The same for compute()'s sender, with the marks it keeps on a path (full, its latency, its far-exit traffic) there from the start: one object shape. +function walkP(P,A,B){const path=[],ni=[B];let v=B;while(v!==A){const l=P[v];path.push(l);v=l.ai===v?l.bi:l.ai;ni.push(v);}return {path,ni,dead:0,ms:-1,fg:0};} diff --git a/src/game/80-simulation/29-route-cache.js b/src/game/80-simulation/29-route-cache.js new file mode 100644 index 0000000..7f134dc --- /dev/null +++ b/src/game/80-simulation/29-route-cache.js @@ -0,0 +1,52 @@ +/* What compute() works out from the network's shape alone, kept from one call to the next: most days only demand moves, + and on a big network these are a third of the work. Each part has a key made of everything it is built from, and any + other key rebuilds it, so it is never stale: + - the graph (RC.gk): the POPs, the remote cities and every edge with its ends and weight, in the order compute() made + them. Kept: the shortest-path tables from every POP, ALONE and the islands (COMP). + - the exits (RC.xk): the graph key, RouteScript, the events that change who reaches whom, and every exit in order with + its kind, id, network, city, preference, rank, carry and prepend marks and what it can reach. Kept: okBy, what is + reachable, and each network's exit lists by rank (BRJ, with the lists networks share) with DSEL and RSET. + Only numbers are kept (exit and edge indices): compute() makes fresh exits, lists and paths from them every call, + since routing writes on those. RC.on=false (the equivalence tests) always rebuilds. */ +const RC={on:true,gk:null,g:null,xk:null,x:null}; +// The graph key: EA lists the edges in the order compute() made them (so adj, and the order Dijkstra settles ties, follow). +function rcGraphKey(pops,remote,EA){let k=pops.join(',')+'|'+remote.join(',');for(let i=0;i=0)P[x]=EA[k];}SDi[i]=SPD[s]=G.D[i];SPi[i]=SPP[s]=P;} + return {SPD,SPP,SDi,SPi,ALONE:G.ALONE,COMP:G.COMP,NCOMP:G.NCOMP};} + // ALONE[i]: no other city lies within 1e-6 of POP i (so only its own exits can be at distance 0 from it). + const ALONE=new Uint8Array(NC),PIs=[]; + for(const s of pops){const i=CIDX[s],r=dijkstra(adj,i,wW);SDi[i]=SPD[s]=r.D;SPi[i]=SPP[s]=r.P;ALONE[i]=1;for(let x=0;x=0)continue;const D=SDi[i],k=NCOMP++;for(let x=0;x{k+=n+(d&&!d.has(n)?'^,':',');});}else if(e.k==='c')k+=e.nets[0];} + return k;} +// The exits' lists, with a sort key: an exit's index in E. +const rcIx=(L,E)=>{const a=new Int32Array(L.length);for(let i=0;i{const L=new Array(a.length);for(let i=0;ie.hp===0);L.at=new Map();for(const e of L){const h=L.at.get(e.ci);if(h)h.push(e);else L.at.set(e.ci,[e]);}} +// What reaching networks gave R (taken right after compute() worked it out, before anything else adds to R). +function rcReachTake(R2){return {reachable:{...R2.reachable},nt:{...R2.nt},cone:{...R2.cone},reach:R2.reach,reachNT:R2.reachNT};} +function rcReachPut(X,R2){const r=X.reach;Object.assign(R2.reachable,r.reachable);Object.assign(R2.nt,r.nt);Object.assign(R2.cone,r.cone);R2.reach=r.reach;R2.reachNT=r.reachNT;} +// Keep what was built (on a miss): okBy, the exit lists (each shared list once), each network's lists by rank, DSEL, RSET. +function rcExitKeep(key,E,okBy,reach,LIST,BRJ,DSEL,RSET){const ok=[];for(let j=0;j{const o=[];for(const r in m)o.push(r,id.get(m[r]));return o;}); + RC.xk=key;RC.x={ok,reach,lists,brj,DSEL,RSET:[...RSET]};} +// Fresh lists for today's exits from a kept build. +function rcExitLists(X,E,BRJ,DSEL,RSET){const V=X.lists.map(d=>{if(d.cs){const cs={cs:[]};for(let k=0;kadj[CIDX[p]]=[]); - const edges={},TRX=teRules(),live=[];let NE=0;R2.bizDem={};R2.bizSrv={}; + const edges={},EA=[],TRX=teRules(),live=[];let NE=0;R2.bizDem={};R2.bizSrv={}; for(const l of S.links){const ai=CIDX[l.a],bi=CIDX[l.b];if(linkDown(l)||!adj[ai]||!adj[bi])continue;live.push(l);const key=l.ae.w,wLat=e=>e.lat+0.05; - for(const s of pops){const i=CIDX[s],r=dijkstra(adj,i,wW);SDi[i]=SPD[s]=r.D;SPi[i]=SPP[s]=r.P;ALONE[i]=1;for(let x=0;x=0)continue;const D=SDi[i],k=NCOMP++;for(let x=0;xe.w,wLat=e=>e.lat+0.05,RCON=RC.on,GK=RCON?rcGraphKey(pops,remote,EA):null, + {SPD,SPP,SDi,SPi,ALONE,COMP,NCOMP}=rcGraph(GK,pops,adj,EA,NC,wW); + const ev=S.ev; const depeer=ev.depeer>day||scnRule('spat'), leak=ev.leak&&ev.leak.until>day?ev.leak.net:null; // Sender pays (Gangnam Style Peering): no carrier hands traffic to the Korean incumbents for you, only a paid PNI does. const snd=scnRule('sender'); + // Stages with loops run as functions of their own (see rankPass below), here the exits. + const E=(()=>{const E=[]; for(const t of S.transit){if(!popUp(t.city)||t.down>day||!liveN(t.city,t.site,t.n))continue; // AS-path prepending (#96) moves part of the port to a last-resort exit of its own. const cap=Math.min(liveCap(PORT[t.tier].g,t.city,t.site,t.n)*lagF(t),TRX&&TRX.cap[t.net]!==undefined?TRX.cap[t.net]:Infinity),pf=TRX&&TRX.prep[t.net]?PREPEND_F[TRX.prep[t.net]]:0; - const ex={k:'t',net:t.net,clean:!!t.clean,prem:premOn(t),pref:t.pref||'normal',carry:!!t.carry,lab:labOf(N_('common.net_transit'),'net',NET[t.net].name),id:t.id,city:t.city,cap:cap*(1-pf),used:0,rank:3,ok:n=>!(depeer&&t.net==='cog'&&n==='ggl')&&n!==leak&&!(snd&&NET[n].kr)}; - E.push(ex);if(pf)E.push({...ex,cap:cap*pf,prep:true});} + const ex=mkEx('t',t.id,t.city,cap*(1-pf),3,t.pref||'normal',labOf(N_('common.net_transit'),'net',NET[t.net].name),n=>!(depeer&&t.net==='cog'&&n==='ggl')&&n!==leak&&!(snd&&NET[n].kr),null,t.net); + ex.clean=!!t.clean;ex.prem=premOn(t);ex.carry=!!t.carry;E.push(ex);if(pf){const x=Object.assign(mkEx(),ex);x.cap=cap*pf;x.prep=true;E.push(x);}} // `nets`: every network ok() can say yes to, so it need not be asked about the other hundred. for(const c in S.ixp){const ct=ixCity(c);if(!(popUp(ct)||remote.includes(ct))||(S.ev.ixdown&&S.ev.ixdown[c]>day)||!(S.myIx[c]?myIxLive(c):liveN(ct,(S.ixSite||{})[c],(S.ixn||{})[c])))continue;const set=ixSessions(c);R2.sessions+=set.size; // A peer announces its customers too (#85): the session reaches its cone, after the networks peering directly. let all=set;for(const id of set)if(DOWN[id].length){if(all===set)all=new Set(set);for(const x of DOWN[id])all.add(x);} - E.push({k:'ix',pref:(S.ixPref&&S.ixPref[c])||'normal',lab:labOf(N_('common.ix_peering'),'ix',ixName(c)),id:c,city:ct,cap:ixCap(c),used:0,rank:2,ok:n=>all.has(n),nets:all,dir:all===set?null:set});} - for(const p of S.pni){if(!pniOn(p)||!popUp(p.city)||!liveN(p.city,p.site,p.n))continue;R2.sessions++;E.push({k:'p',sac:!!p.sacrif,pnc:!!NET[p.net].cn,pref:p.pref||'normal',lab:labOf(N_('common.pni_with_net'),'net',NET[p.net].name),id:p.id,city:p.city,cap:liveCap(pniG(p),p.city,p.site,p.n)*lagF(p)*(p.sacrif?0.5:1),used:0,rank:1,net:p.net,ok:n=>CONE_S[p.net].has(n),nets:CONE[p.net]});} - for(const c of S.caches){if(!popUp(c.city)||siteDown(c.city,c.site==='b'?'b':'a'))continue;E.push({k:'c',pref:'normal',lab:labOf(N_('common.name_cache'),'name',NET[c.net].cache.name),id:c.id,city:c.city,cap:cacheG(c),used:0,rank:0,ok:n=>n===c.net,nets:[c.net]});} + const x=mkEx('ix',c,ct,ixCap(c),2,(S.ixPref&&S.ixPref[c])||'normal',labOf(N_('common.ix_peering'),'ix',ixName(c)),n=>all.has(n),all);x.dir=all===set?null:set;E.push(x);} + for(const p of S.pni){if(!pniOn(p)||!popUp(p.city)||!liveN(p.city,p.site,p.n))continue;R2.sessions++; + const x=mkEx('p',p.id,p.city,liveCap(pniG(p),p.city,p.site,p.n)*lagF(p)*(p.sacrif?0.5:1),1,p.pref||'normal',labOf(N_('common.pni_with_net'),'net',NET[p.net].name),n=>CONE_S[p.net].has(n),CONE[p.net],p.net);x.sac=!!p.sacrif;x.pnc=!!NET[p.net].cn;E.push(x);} + for(const c of S.caches){if(!popUp(c.city)||siteDown(c.city,c.site==='b'?'b':'a'))continue;E.push(mkEx('c',c.id,c.city,cacheG(c),0,'normal',labOf(N_('common.name_cache'),'name',NET[c.net].cache.name),n=>n===c.net,[c.net]));} // After an update adds networks, a free courtesy route reaches the new ones you have no other way to (#46). R2.graceNets=0;if(S.grace&&S.grace.until>day){const gs=new Set(S.grace.nets.filter(n=>NET[n]&&!E.some(e=>e.k!=='c'&&e.ok(n)))),hc=popUp(S.home)?S.home:pops.find(popUp); - R2.graceNets=gs.size;if(gs.size&&hc)E.push({k:'ix',pref:'normal',lab:tr('compute.courtesy_route_to_new_networks'),id:'~grace',city:hc,cap:1e9,used:0,rank:2,ok:n=>gs.has(n),nets:gs});} - {const rp=ev.rpki&&ev.rpki.until>day?new Set(ev.rpki.nets):null;if(rp)for(const e of E){if(e.k==='c')continue;const o=e.ok;e.ok=n=>!rp.has(n)&&o(n);}} + R2.graceNets=gs.size;if(gs.size&&hc)E.push(mkEx('ix','~grace',hc,1e9,2,'normal',tr('compute.courtesy_route_to_new_networks'),n=>gs.has(n),gs));} + return E;})(); + const rp=ev.rpki&&ev.rpki.until>day?new Set(ev.rpki.nets):null;if(rp)for(const e of E){if(e.k==='c')continue;const o=e.ok;e.ok=n=>!rp.has(n)&&o(n);} + // Who reaches whom and each network's exit lists, kept while the exits are the same (XC, 29-route-cache.js). + const XK=RCON?rcExitKey(GK,E,(depeer?1:0)+'|'+leak+'|'+(snd?1:0)+'|'+(rp?ev.rpki.nets.join(','):'')+'|'+(TRX?S.te.script:'')):null,XC=XK!==null&&RC.xk===XK?RC.x:null; // coneOf: does exit e reach network n only through a peer's customer cone (#85)? const coneOf=(e,n)=>e.k==='p'?e.net!==n:!!e.dir&&!e.dir.has(n); // ok() cannot change during one compute, so ask each exit once per network, not once per flow and rank. // okBy[net] lists the exits that reach it in E's order, like E.filter(e=>e.ok(net)). - const okBy={};for(const id of NET_IDS)okBy[id]=[]; + const okBy=XC?rcOkBy(XC,E):{};if(!XC)for(const id of NET_IDS)okBy[id]=[]; const okAdd=(e,n)=>{const L=okBy[n];if(L&&L[L.length-1]!==e&&e.ok(n))L.push(e);}; // TSL: a slot per transit port id, for what it carries to each network (R.tNet, added up in TNA). - const ekN={},TSL=new Map();for(const e of E){e.ek=e.k+':'+e.id;ekN[e.ek]=(ekN[e.ek]||0)+1;} + const ekN={},TSL=new Map();(()=>{for(const e of E){e.ek=e.k+':'+e.id;ekN[e.ek]=(ekN[e.ek]||0)+1;} // dup: shares its key with another exit (a hand-edited save), so R.egDesc shows whichever pushed last. - for(const e of E){e.J=0;e.byC=null;e.desc=null;e.dup=ekN[e.ek]>1;e.told=false;e.hp=e.pref==='high'?0:1;e.ci=CIDX[e.city];e.cn=cnCity(e.city);e.vis=0;e.ts=-1;if(e.k==='t'){let t=TSL.get(e.id);if(t===undefined)TSL.set(e.id,t=TSL.size);e.ts=t;} + for(let i=0;i1;e.told=false;e.hp=e.pref==='high'?0:1;e.ci=CIDX[e.city];e.cn=cnCity(e.city);e.vis=0;e.ts=-1;if(e.k==='t'){let t=TSL.get(e.id);if(t===undefined)TSL.set(e.id,t=TSL.size);e.ts=t;} + if(XC)continue; // Index loops or forEach (same order): for…of here made an iterator result per exit and network. const ns=e.nets||NET_IDS;if(Array.isArray(ns)){for(let q=0;qokAdd(e,n));} - for(const n of NETS){let any=false,nt=false;for(const e of okBy[n.id])if(e.rank>0){any=true;if(e.k!=='t'){nt=true;break;}}R2.reachable[n.id]=any;if(any)R2.reach+=NSH[n.id];if(nt){R2.nt[n.id]=1;R2.reachNT+=NSH[n.id]; + if(XC)rcReachPut(XC,R2);else for(const n of NETS){let any=false,nt=false;for(const e of okBy[n.id])if(e.rank>0){any=true;if(e.k!=='t'){nt=true;break;}}R2.reachable[n.id]=any;if(any)R2.reach+=NSH[n.id];if(nt){R2.nt[n.id]=1;R2.reachNT+=NSH[n.id]; // Reached without transit only through the customers of networks you peer with (#85). R.cone[id]: the peer that // carries it, the first PNI's network or else the nearest upstream that is a member of an exchange you are on. - if(!okBy[n.id].some(e=>(e.k==='p'||e.k==='ix')&&!coneOf(e,n.id)))R2.cone[n.id]=coneBy(okBy[n.id],n.id);}} + if(!okBy[n.id].some(e=>(e.k==='p'||e.k==='ix')&&!coneOf(e,n.id)))R2.cone[n.id]=coneBy(okBy[n.id],n.id);}}})(); + const RCH=XK!==null&&!XC?rcReachTake(R2):null; const cacheNets=new Set(S.caches.filter(c=>popUp(c.city)).map(c=>c.net)); const viral=(ev.viral>day?1.25:1)*(ev.php&&ev.php>day?0.7:1); /* Flows are columns, not objects (tens of thousands of them on a big network): flow F starts in city FCI[F] for network @@ -80,7 +92,7 @@ function compute(){RW.gen++; const bizBw={};for(const b of S.biz){const T=BIZ_T[b.type];if(!T.l2&&!T.fiber&&(!T.event||eventLive(b))){const v=bizBw[b.city];bizBw[b.city]=(v===undefined?0:v)+b.bw;}} // Traffic shares by network index, and their sums, for each share table (and with Russia's throttle). const shArr=new Map(),shSum=new Map(),DEMTO=new Float64Array(NN),loc=scnRule('local'); - for(const c of Object.keys(S.pops)){ + (()=>{for(const c of Object.keys(S.pops)){ const p=S.pops[c],ci=CIDX[c],cn=cnCity(c),SH=cn?NSH_CN:ruCity(c)?NSH_RU:CITY[c].kr&&S.krExit?NSH_KRX:NSH;const eye=(p.bb?p.bb.d:0)*viral*(cn&&ev.golden>day?1.4:1);const biz=bizBw[c]??0;const d0=eye+biz; // Goggle video is throttled in Russia (#70): people there get half of it, so they ask for half. It is not // traffic you failed to deliver, and it does not cross your links only to be thrown away. @@ -97,7 +109,7 @@ function compute(){RW.gen++; for(let q=0;q<(sp?2:1);q++){const x=sp?(q?a*(1-bf):a*bf):a,bz=sp&&!q;if(x<=0)continue;if(cn2){flow(ci,j,x*0.85,true,bz);flow(ci,j,x*0.15,false,bz);} else flow(ci,j,x,false,bz);}} R2.bizDem[c]=biz*d/(d0||1);R2.bizSrv[c]=0; - } + }})(); if(Object.keys(S.pops).length)for(let j=0;jr.keys.every(k=>edges[k]))){const prev=old.map(r=>{const path=r.keys.map(k=>edges[k]);return {path,ni:r.ns.map(c=>CIDX[c]),share:r.share};}); if(prev.reduce((x,r)=>x+cost(r),0)<=pick2.reduce((x,r)=>x+cost(r),0)*1.1)out=prev;} R2.l2route[key]=out.map(r=>({keys:r.path.map(e=>e.id),ns:cityIds(r.ni),share:r.share}));return out;}; - for(const b of S.biz){if(!BIZ_T[b.type].l2)continue; + (()=>{for(const b of S.biz){if(!BIZ_T[b.type].l2)continue; // An SD-WAN is hub-and-spoke: one circuit from the first site to each of the others. const pairs=b.sites?b.sites.slice(1).map(x=>[b.sites[0],x]):[[b.city,b.city2]];let minF=1,maxLat=0,tot=0,noPath=false; for(const [A,B] of pairs){let amt=0; @@ -158,7 +170,7 @@ function compute(){RW.gen++; minF=Math.min(minF,amt/b.bw);tot+=amt;} R2.l2lat[b.id]=noPath?Infinity:maxLat;R2.l2[b.id]=b.bw*minF;R2.egT.l2=(R2.egT.l2||0)+tot; // Same answer as diversePaths(), which would rebuild today's live links for every customer. - if((b.reqs||[]).includes('diverse')){const k=b.city+'>'+b.city2;R2.div[b.id]=divMemo[k]??(divMemo[k]=disjointI(b.city,b.city2));}} + if((b.reqs||[]).includes('diverse')){const k=b.city+'>'+b.city2;R2.div[b.id]=divMemo[k]??(divMemo[k]=disjointI(b.city,b.city2));}}})(); /* Floods ride the backbone ahead of everyone's traffic (25-ddos-flood.js). haul: up to g from city A to POP B over the shortest path, as far as links and routers have room. */ const msOf=(A,B)=>{const Bi=CIDX[B],Ai=CIDX[A];return SPD[B]&&SPD[B][Ai]n+e.lat,0):0;}; @@ -172,7 +184,7 @@ function compute(){RW.gen++; if(c0===false)return null;if(c0&&c0.path.every(l=>l.res>1e-3)&&c0.ni.every(i=>!HAS[i]||NRES[i]>1e-3))return c0; const {D,P}=dijkstra(adj,src,wW,(v,e)=>e.res<=1e-3||(HAS[v]&&NRES[v]<=1e-3)||(CORE&&OUT[v]&&v!==dst),dst); if(D[dst]===Infinity||D[dst]>REACH*base+60){teCache.set(key,false);return null;} - const Q=walkI(P,src,dst);teCache.set(key,Q);return Q;}; + const Q=walkP(P,src,dst);teCache.set(key,Q);return Q;}; /* A network in a peer's customer cone, reached through that peer (#85): after every network you peer with directly (its AS path is one hop longer) and before transit. */ const base=(e,n)=>e.pref==='low'?4:e.rank>0&&e.rank<3&&coneOf(e,n)?CONE_RANK:e.rank; @@ -190,16 +202,20 @@ function compute(){RW.gen++; // Each network's exits by the rank they route at (RouteScript can move an exit per network), in E's order. // Each list also knows whether it holds a preferred exit (hi) and its exits by city (at), in list order. // With several islands (POPs no backbone joins), each list is split by island: a flow only scans exits it can reach. - const idx=L=>{L.hi=L.some(e=>e.hp===0);L.at=new Map();for(const e of L){const h=L.at.get(e.ci);if(h)h.push(e);else L.at.set(e.ci,[e]);}}; // Networks with the same exits at a rank share one list (LIST, by content), so what one flow learns serves them all. - const LIST=new Map();for(let i=0;i{for(let j=0;je.xi).join(','),o=LIST.get(key);if(o){m[r]=o;continue;} let V=L;if(NCOMP>1){const cs=[];for(const e of L){const k=COMP[e.ci];if(k>=0)(cs[k]||(cs[k]=[])).push(e);}for(const s of cs)if(s)idx(s);V={cs};}else idx(L);LIST.set(key,V);m[r]=V;}} + if(RCH)rcExitKeep(XK,E,okBy,RCH,LIST,BRJ,DSEL,RSET);})(); // The flow being routed, and from its POP: distances, arriving edges and the paths walked so far, by city index. // F: its index; fci, fnj: its city and network index. - let F=0,fci=0,fnj=0,Dv=null,Pv=null,PP=null,vis=0;const walked=[],G=[],REST=[],NEG=[]; + let F=0,fci=0,fnj=0,Dv=null,Pv=null,PP=null,vis=0;const walked=[],G=[],REST=[],NEG=[];let GN=0; + /* What each kind of exit served, in all (EGT) and per network (NEA, by network index and kind): numbers in typed arrays, + where a sum by key would box every new value. EGO and NEO keep the order each first got traffic, which is the order + R.egT and R.netEg list them in; both are written back after routing. */ + const EGT=new Float64Array(4),EGO=[],NEA=new Float64Array(NN*4),NEO=[]; // An exit the flow can still try: not visited yet, not full when the flow started, reachable, and not on a saturated path. const usable=e=>e.vis!==vis&&e.useda.hp-b.hp||Dv[a.ci]-Dv[b.ci]; // Push up to `want` along one path to exit e; returns what fitted. Index loops: for…of allocates an iterator until optimised. Capacity only shrinks while routing, so a @@ -220,8 +236,8 @@ function compute(){RW.gen++; // Backhaul to transit: users notice the round trip to the exit. Up to 20 ms (about 1,500 km) is free, then // it gets worse, and past 50 ms broadband and internet services count as bad service (#…). Under sender pays, // Korean users notice any exit far away, transit or not, and much sooner. - if(path.length&&(e.k==='t'||snd&&CITIES[ci].kr)){let ms=P.ms;if(ms===undefined){ms=0;for(let k=0;k(kl?KR_LAT_OK:LAT_OK)){LATP[ci]+=ok*(kl?krLatLoss(rtt):latLoss(rtt));if(!P.fg){P.fg=0;FARL.push(P,ci,e.ci);}P.fg+=ok;}}R2.egT[e.k]=(R2.egT[e.k]||0)+ok;const ne=NEG[nr]||(NEG[nr]=R2.netEg[NET_IDS[nr]]={c:0,p:0,ix:0,t:0});ne[e.k]+=ok; + if(path.length&&(e.k==='t'||snd&&CITIES[ci].kr)){let ms=P.ms;if(ms<0){ms=0;for(let k=0;k(kl?KR_LAT_OK:LAT_OK)){LATP[ci]+=ok*(kl?krLatLoss(rtt):latLoss(rtt));if(!P.fg){P.fg=0;FARL.push(P,ci,e.ci);}P.fg+=ok;}}const kx=e.kx;if(EGT[kx]===0&&!EGO.includes(kx))EGO.push(kx);EGT[kx]+=ok;if(!NEG[nr]){NEG[nr]=R2.netEg[NET_IDS[nr]]={c:0,p:0,ix:0,t:0};NEO.push(nr);}NEA[nr*4+kx]+=ok; // Where each flow left (the PNI list asks what a PNI here would take over, #175). if(e.J>0){const m=e.byC||(e.byC=new Map()),v=m.get(ci);if(v){v[0]+=ok;if(bz)v[1]+=ok;}else m.set(ci,[ok,bz?ok:0]);} if(e.k==='t'){FGT[F]+=ok;FTI[F]=e.xi;}else if(e.k==='ix'){FGI[F]+=ok;FII[F]=e.xi;}else if(e.k==='p'){if(e.ci===ci&&e.net===NET_IDS[nr])FGH[F]+=ok;else FGP[F]+=ok;}} @@ -231,7 +247,7 @@ function compute(){RW.gen++; // with free capacity, as long as they are no more than twice as long. const send=(e,want)=>{ let room=Math.min(want,FREM[F],e.cap-e.used);if(room<=1e-6)return; - const P=PP[e.ci]||(PP[e.ci]=walkI(Pv,fci,e.ci));if(!P.dead)room-=push(e,P,room,TE&&SPILL<1?1-SPILL:0); + const P=PP[e.ci]||(PP[e.ci]=walkP(Pv,fci,e.ci));if(!P.dead)room-=push(e,P,room,TE&&SPILL<1?1-SPILL:0); if(TE&&room>1e-6&&FREM[F]>1e-6&&e.used1e-6;k++){const P=altPath(fci,e.ci,Dv[e.ci]);if(!P)break;const m=push(e,P,Math.min(room,e.cap-e.used));if(m<=1e-6)break;room-=m;R2.teMoved+=m;} }; // Exits with the same preference and the same IGP distance form an ECMP group: spread the flow over @@ -246,7 +262,8 @@ function compute(){RW.gen++; for(let k=i0;k{const n=a.length;if(n>24){a.sort(byDist);return;}for(let i=1;i=0&&byDist(a[j],x)>0){a[j+1]=a[j];j--;}a[j+1]=x;}}; + // n: sort only a[0..n) (the group G holds GN exits). + const sortD=(a,n=a.length)=>{if(n>24){if(n===a.length)a.sort(byDist);else{const t=a.slice(0,n).sort(byDist);for(let i=0;i=0&&byDist(a[j],x)>0){a[j+1]=a[j];j--;}a[j+1]=x;}}; // The direct ranks (25-direct-egress.js) have short lists, one carrier's ports, so they take the plain way: the usable exits // nearest first, tried in groups of equal distance, as the reference loop in the tests does. A direct rank only concerns the // networks that have an exit there, and nothing from a POP where Prefer has the say; a port that is not set to carry only takes @@ -261,11 +278,11 @@ function compute(){RW.gen++; else for(let li=0;li1e-6;){let j=i+1;while(j{ for(F=0;F=e.cap||gone(e)){full++;continue;}const d=Dv[e.ci];if(d===Infinity)continue;const h=e.hp; - if(h=lst.length&&full){let k=0;for(let li=0;li1){gc[fci]=NOG;continue;} - if(G.length>1)sortD(G);gc[fci]=G.slice();}} - sendGroup(G,0,G.length); + if(GN>1)sortD(G,GN);gc[fci]=G.slice(0,GN);}} + sendGroup(G,0,GN); if(FREM[F]<=1e-6)continue; REST.length=0;for(let li=0;li1e-6;){ let j=i+1;while(j{ if(DD){let rem=0,jf=0;for(let i=0;i1e-6)rem+=FREM[i];if(JK)for(const k in edges){const e=edges[k];if(e.res<=1e-6&&e.jk)jf+=e.jk;} ddosAfter(DD,{E,R2,squeeze:Math.min(rem,jf), lost:(ci,x,y,e)=>{SRV[ci]-=x;R2.served-=x;const c=CITIES[ci].id;if(y)R2.bizSrv[c]-=y;R2.egT[e.k]-=x;if(e.rank<=2)R2.peered-=x;}});} @@ -318,8 +342,14 @@ function compute(){RW.gen++; for(const k in edges){const e=edges[k],ld=e.ld||0,ac=e.cap-e.scap,a=Math.min(ld,ac),sp=ld-a;for(const l of e.links){const c=capOf(l);R2.load[l.id]=l.standby?(e.scap>0?sp*c/e.scap:0):(ac>0?a*c/ac:0);}} for(const e of TORD){const m=R2.tNet[e.id]={},b=e.ts*NN;for(const j of TNK[e.ts])m[NET_IDS[j]]=TNA[b+j];} R2.peerShare=R2.served>0?R2.peered/R2.served:0; - for(const e of E){if(e.k==='t')R2.useT[e.id]=(R2.useT[e.id]||0)+e.used;else if(e.k==='ix')R2.useIx[e.id]=e.used;else if(e.k==='p')R2.usePni[e.id]=e.used;else R2.useCache[e.id]=e.used;} - // money + for(const e of E){if(e.k==='t')R2.useT[e.id]=(R2.useT[e.id]||0)+e.used;else if(e.k==='ix')R2.useIx[e.id]=e.used;else if(e.k==='p')R2.usePni[e.id]=e.used;else R2.useCache[e.id]=e.used;}})(); + computeMoney(R2); + // R.fl: from this call's own columns, made into objects only when something asks. + flDefine(R2,{NF,FREM,FCI,FNJ,FCA,FBZ,FGT,FGI,FGP,FGH,FTI,FII,E,CNB,NCN}); + R=R2;UI.hotMap=hotByCity(); +} +// What the network costs and earns per month, from what compute() routed. +function computeMoney(R2){ const C=R2.cost,V=R2.rev,pm=S.priceMul; C.pops=Object.entries(S.pops).reduce((a,[c,p])=>a+popMo(c)+((p.routers||1)-1)*ROUTER_MO+cageMo(p.routers)+(p.routers||1)*RG[p.rgen||0].mo+(p.gen?GEN_MO:0),0); C.optical=S.links.filter(l=>l.kind==='df').reduce((a,l)=>a+(l.ready>S.day?0:ampCount(l.km)*AMP_MO*(l.own&&isRdm(l.sys)&&!l.sub?Math.max(1,l.pairs|0):1)+(l.regen|0)*REGEN_MO)+(l.spares?Math.round(150+(l.ch||[]).length*80):0),0); @@ -338,7 +368,4 @@ function compute(){RW.gen++; C.revshare=(S.loans||[]).reduce((a,l)=>a+(BANKS[l.bank].equity||l.bal>0?l.share||0:0),0)*(V.eyeballs+V.business+V.ix); R2.costMo=Object.values(C).reduce((a,b)=>a+b,0); R2.revMo=V.eyeballs+V.business+V.ix+V.grant; - // R.fl: from this call's own columns, made into objects only when something asks. - flDefine(R2,{NF,FREM,FCI,FNJ,FCA,FBZ,FGT,FGI,FGP,FGH,FTI,FII,E,CNB,NCN}); - R=R2;UI.hotMap=hotByCity(); } diff --git a/tests/route-cache.test.js b/tests/route-cache.test.js new file mode 100644 index 0000000..0516672 --- /dev/null +++ b/tests/route-cache.test.js @@ -0,0 +1,87 @@ +// What compute() keeps between calls (src/game/80-simulation/29-route-cache.js): the shortest paths and the exit lists, +// rebuilt only when their key changes. These tests make sure every kind of change that can matter changes the key (a +// stale table would route yesterday's network), that demand alone does not (or nothing is gained), and that routing +// with the kept tables is exactly routing without them. +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { load } = require('./harness'); + +const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8'); + +function open() { + const h = load({ seed: 777 }); + h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();S.nextFail=S.day+999;S.nextEvent=S.day+999;compute();compute();`); + return h; +} + +// Applies a change, routes once with the kept tables and once without (from the same yesterday), and says which keys moved. +function step(ev, change) { + ev(change); + return JSON.parse(ev(`(()=>{const gk=RC.gk,xk=RC.xk,prior=R;compute();const a=JSON.stringify(R)+JSON.stringify(R.fl); + const g=RC.gk!==gk,x=RC.xk!==xk;R=prior;RC.on=false;try{compute();}finally{RC.on=true;}const b=JSON.stringify(R)+JSON.stringify(R.fl); + return JSON.stringify({g,x,same:a===b,len:a.length});})()`)); +} + +test('a change to links, POPs, ports, peering, events or RouteScript rebuilds what routing keeps; demand alone does not', () => { + const { ev, errors } = open(); + assert.ok(ev('RC.gk!==null&&RC.xk!==null'), 'routing keeps its tables after a compute'); + // [what changes, the graph key moves, the exits key moves] + const changes = [ + // Demand and capacity only: nothing structural, the kept tables are used. + ['for(const c in S.pops)if(S.pops[c].bb)S.pops[c].bb.d*=1.07', false, false], + ['S.biz.forEach(b=>b.bw*=1.1)', false, false], + ["S.links.find(l=>l.kind==='wave').tier=1", false, false], + ['S.transit[0].tier=Math.max(0,S.transit[0].tier-1)', false, false], + ['S.day++', false, false], + // The graph: a cut, a link gone, a link back, a metric, a POP down and up again, RouteScript's avoid. + ['S.links[3].cut=S.day+3', true, true], + ['S.links[3].cut=0', true, true], + ['window.__l=S.links.splice(7,1)[0]', true, true], + ['S.links.push(__l)', true, true], + ["S.pairMet=S.pairMet||{};{const l=S.links[10];S.pairMet[l.a!linkDown(x));S.te.script+='\\navoid link '+CITY[l.a].name.toLowerCase()+'-'+CITY[l.b].name.toLowerCase();}", true, true], + ]; + for (const [change, g, x] of changes) { + const r = step(ev, change); + assert.ok(r.same, `${change}: routing with the kept tables is routing without them`); + if (g !== null) assert.equal(r.g, g, `${change}: the graph key ${g ? 'moves' : 'stays'}`); + assert.equal(r.x, x, `${change}: the exits key ${x ? 'moves' : 'stays'}`); + assert.ok(r.len > 1e5, 'a big network was routed'); + } + assert.deepEqual(errors, []); +}); + +test('days in a row reuse the kept tables and route like a fresh start every day', () => { + const { ev, errors } = open(); + for (let d = 0; d < 4; d++) { + ev('dayTick()'); + const r = step(ev, ''); + assert.ok(r.same, `day ${d}: the same routing with and without the kept tables`); + assert.ok(!r.g && !r.x, `day ${d}: a day of demand only keeps the tables`); + } + assert.deepEqual(errors, []); +}); diff --git a/tests/route-fuzz.test.js b/tests/route-fuzz.test.js new file mode 100644 index 0000000..5958b27 --- /dev/null +++ b/tests/route-fuzz.test.js @@ -0,0 +1,30 @@ +// A few seeded random games (scripts/lib/route-fuzz.js), played move for move on main's page and on this checkout's: +// after every move and day both route identically and keep the same game state, and this checkout routes the same with +// the routing cache (RC) on and off. scripts/route-fuzz.js plays hundreds of these; here a handful, so CI stays quick. +// Without git's origin/main (a bare tarball), the base is this checkout's own page: the cache on/off check still runs. +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const page = require('../scripts/lib/page'); +const { openPage, playGame } = require('../scripts/lib/route-fuzz'); + +function pages() { + const head = path.join(os.tmpdir(), `tubes-fuzz-test-${process.pid}-head.html`); + fs.writeFileSync(head, page.assemble().html); + let base = head; + try { const b = path.join(os.tmpdir(), `tubes-fuzz-test-${process.pid}-base.html`); fs.writeFileSync(b, page.assembleRef('origin/main')); base = b; } catch (e) {} + return { base: openPage(base, 'base'), head: openPage(head, 'head') }; +} + +test('random games route the same as main, with and without the routing cache, move for move', () => { + const P = pages(); + // Seeds that start a normal game, a sandbox, a scenario and a puzzle, with transit, exchanges, PNIs and RouteScript. + for (const seed of [20, 23, 27, 26]) { + const g = playGame(P, seed, { moves: 35 }); + assert.equal(g.div, null, `seed ${seed} diverged: ${JSON.stringify(g.div, null, 1)}`); + assert.ok(g.moves >= 35, `seed ${seed} played its moves`); + assert.deepEqual(g.errors, [], `seed ${seed}: no page errors`); + } +}); diff --git a/tests/routing-reference.test.js b/tests/routing-reference.test.js index 850a21a..1c2622d 100644 --- a/tests/routing-reference.test.js +++ b/tests/routing-reference.test.js @@ -26,7 +26,10 @@ function network(ev) { const start = source.indexOf(' for(const pass of PASSES)for(const rank of RANKS){'); const end = source.indexOf(' for(const i of NORD)', start); assert.ok(start >= 0 && end > start, 'allocation loop boundaries must exist'); - ev(`window.referenceCompute=eval('('+${JSON.stringify(source.slice(0,start)+referenceAllocation+source.slice(end))}+')')`); + // The reference also builds every table afresh, so the comparison covers what routing keeps between calls. + assert.ok(source.includes('RCON=RC.on'), 'compute() can be told not to keep its tables'); + const ref = (source.slice(0,start)+referenceAllocation+source.slice(end)).replace('RCON=RC.on', 'RCON=false'); + ev(`window.referenceCompute=eval('('+${JSON.stringify(ref)}+')')`); } test('indexed routing matches the simple allocation loop across network changes', () => { diff --git a/tests/speed.test.js b/tests/speed.test.js index dc6a7d3..ce97654 100644 --- a/tests/speed.test.js +++ b/tests/speed.test.js @@ -273,21 +273,24 @@ function plainCompute(ev) { const src = ev('compute.toString()'); let plain = src .replace('if(!lst.hi&&ALONE[fci])', 'if(false)') - .replace('if(!G.length){\n // One scan', 'if(false){\n // One scan') + .replace('if(!GN){\n // One scan', 'if(false){\n // One scan') .replace('const ns=e.nets||NET_IDS;', 'const ns=NET_IDS;') .replace('if(P.dead)return 0;', '').replaceAll('if(r<=1e-6){P.dead=1;return 0;}', '') - .replace('if(!P.dead)room-=push(', 'room-=push(').replace(/const gone=e=>\{[^\n]*\};/, 'const gone=e=>false;'); + .replace('if(!P.dead)room-=push(', 'room-=push(').replace(/const gone=e=>\{[^\n]*\};/, 'const gone=e=>false;') + // ...and without what routing keeps between calls (29-route-cache.js): the plain path builds everything afresh. + .replace('RCON=RC.on', 'RCON=false'); // ...and the group split and sorting written the plain way, with array copies, as before they were made allocation-free const sg = plain.indexOf('const ROOM=[],sendGroup='), sd = plain.indexOf('const sortD='); assert.ok(sg > 0 && sd > sg, 'found the group sender and the sort'); plain = plain.slice(0, sg) + `const ROOM=[],sendGroup=(g0,i0=0,i1=g0.length)=>{const g=g0.slice(i0,i1);for(const e of g)e.vis=vis; if(g.length>1){const room=g.map(e=>Math.max(0,e.cap-e.used)),tot=room.reduce((a,b)=>a+b,0),want=FREM[F];if(tot>1e-6)g.forEach((e,k)=>send(e,want*room[k]/tot));} - for(const e of g){if(FREM[F]<=1e-6)break;send(e,FREM[F]);}};\n ` + plain.slice(sd).replace(/^const sortD=a=>\{[^\n]*\};/, 'const sortD=a=>a.sort(byDist);'); + for(const e of g){if(FREM[F]<=1e-6)break;send(e,FREM[F]);}};\n ` + plain.slice(sd).replace(/^const sortD=\(a,n=a\.length\)=>\{[^\n]*\};/, 'const sortD=(a,n=a.length)=>{const t=a.slice(0,n).sort(byDist);for(let i=0;ia.sort(byDist);') && plain.includes('g.forEach('), 'the plain group split and sort are in'); + assert.ok(plain.includes('RCON=false') && !plain.includes('RC.on'), 'the kept routing tables were switched off'); + assert.ok(plain.includes('const sortD=(a,n=a.length)=>{const t=a.slice(0,n).sort(byDist);') && plain.includes('g.forEach('), 'the plain group split and sort are in'); ev('window.__plain=' + plain.replace(/^function compute/, 'function')); }