From 121b69561a3edf50f7a5223e922acf917ce88c44 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sun, 15 Nov 2026 16:13:28 -0800 Subject: [PATCH] timeline: read each entry's time once when merging runs mergeTimelineRuns read an entry's time again on every comparison, and the vessel layer passed a new arrow for every vessel. Times are now read once into arrays, the leading older entries the loop would keep one by one are sliced in one step, and the layer passes one function. The result is the same entries in the same order; a test checks 3,000 random merges against the previous algorithm. Measured in the browser, one implementation per page, 9,000 vessels with 240 kept fixes each, 5 alternating pairs: 65-87 ms -> 57-61 ms per snapshot. --- src/layers/vessels/records.js | 5 +- src/time/timelineFixes.js | 47 ++++++++++++----- src/time/timelineFixes.test.mjs | 93 +++++++++++++++++++++++++++++++++ 3 files changed, 132 insertions(+), 13 deletions(-) diff --git a/src/layers/vessels/records.js b/src/layers/vessels/records.js index c0ad357e8..e18d380db 100644 --- a/src/layers/vessels/records.js +++ b/src/layers/vessels/records.js @@ -58,6 +58,9 @@ function stampFix(record, receivedAtMs, feedLatestEpoch) { record.fixFeedEpoch = feedLatestEpoch; } +/** A fix's time, as the fixes are merged (one function for every vessel). */ +const fixTime = (fix) => fix.atMs; + function positiveNumber(value) { const number = finiteNumber(value); return number !== null && number > 0 ? number : null; @@ -164,7 +167,7 @@ export class VesselRecords { ? mergeTimelineRuns( record.fixes ?? [], next.fixes, - (fix) => fix.atMs, + fixTime, (next.lastPositionEpoch ?? 0) * 1000, ) : null; diff --git a/src/time/timelineFixes.js b/src/time/timelineFixes.js index e8b078cc3..5ba1c24e3 100644 --- a/src/time/timelineFixes.js +++ b/src/time/timelineFixes.js @@ -82,43 +82,66 @@ export function mergeTimelineRuns( centreMs, limit = TIMELINE_FIXES_LIMIT, ) { - const first = newer.length ? timeOf(newer[0]) : Infinity; - const last = newer.length ? timeOf(newer[newer.length - 1]) : -Infinity; + // Each entry's time is read once: a layer merges a run for every contact + // in a snapshot, each holding up to `limit` entries. + const olderTimes = new Array(older.length); + for (let k = 0; k < older.length; k++) olderTimes[k] = timeOf(older[k]); + const newerTimes = new Array(newer.length); + for (let k = 0; k < newer.length; k++) newerTimes[k] = timeOf(newer[k]); + const first = newer.length ? newerTimes[0] : Infinity; + const last = newer.length ? newerTimes[newer.length - 1] : -Infinity; const newest = newer[newer.length - 1]; + // The older entries before the newer run that the loop below would keep + // one by one, each far enough from the one before, are taken at once: a + // contact's kept entries mostly stand before each snapshot's run. + let lead = 0; + while ( + lead < older.length && + !(olderTimes[lead] >= first && olderTimes[lead] <= last) && + (newer.length === 0 || olderTimes[lead] < first) && + (lead === 0 || + olderTimes[lead] - olderTimes[lead - 1] >= TIMELINE_FIX_SPACING_MS) + ) + lead++; // Both runs in order, the older entries within the newer run's time left // out, thinned to the spacing. - const merged = []; - const take = (entry) => { + const merged = older.slice(0, lead); + const times = olderTimes.slice(0, lead); + const take = (entry, t) => { const k = merged.length - 1; - if (k < 0 || timeOf(entry) - timeOf(merged[k]) >= TIMELINE_FIX_SPACING_MS) { + if (k < 0 || t - times[k] >= TIMELINE_FIX_SPACING_MS) { merged.push(entry); + times.push(t); } else if (entry === newest) { merged[k] = entry; + times[k] = t; } }; - let i = 0; + let i = lead; let j = 0; while (i < older.length || j < newer.length) { if (i < older.length) { - const t = timeOf(older[i]); + const t = olderTimes[i]; if (t >= first && t <= last) { i++; continue; } - if (j >= newer.length || t < timeOf(newer[j])) { - take(older[i++]); + if (j >= newer.length || t < newerTimes[j]) { + take(older[i], t); + i++; continue; } } - take(newer[j++]); + take(newer[j], newerTimes[j]); + j++; } if (merged.length <= limit) return merged; // The window of `limit` entries nearest the centre. let start = 0; while ( start + limit < merged.length && - Math.abs(timeOf(merged[start + limit]) - centreMs) < - Math.abs(timeOf(merged[start]) - centreMs) + Math.abs(times[start + limit] - centreMs) < + Math.abs(times[start] - centreMs) ) start++; return merged.slice(start, start + limit); diff --git a/src/time/timelineFixes.test.mjs b/src/time/timelineFixes.test.mjs index 9ab47c184..346388872 100644 --- a/src/time/timelineFixes.test.mjs +++ b/src/time/timelineFixes.test.mjs @@ -96,3 +96,96 @@ test('past the limit only the fixes nearest the centre are kept', () => { [0, 1, 2, 3], ); }); + +/** The merge as first written, a reference the faster one must match. */ +function referenceMerge(older, newer, timeOf, centreMs, limit = 240) { + const SPACING = 20_000; + const first = newer.length ? timeOf(newer[0]) : Infinity; + const last = newer.length ? timeOf(newer[newer.length - 1]) : -Infinity; + const newest = newer[newer.length - 1]; + const merged = []; + const take = (entry) => { + const k = merged.length - 1; + if (k < 0 || timeOf(entry) - timeOf(merged[k]) >= SPACING) + merged.push(entry); + else if (entry === newest) merged[k] = entry; + }; + let i = 0; + let j = 0; + while (i < older.length || j < newer.length) { + if (i < older.length) { + const t = timeOf(older[i]); + if (t >= first && t <= last) { + i++; + continue; + } + if (j >= newer.length || t < timeOf(newer[j])) { + take(older[i++]); + continue; + } + } + take(newer[j++]); + } + if (merged.length <= limit) return merged; + let start = 0; + while ( + start + limit < merged.length && + Math.abs(timeOf(merged[start + limit]) - centreMs) < + Math.abs(timeOf(merged[start]) - centreMs) + ) + start++; + return merged.slice(start, start + limit); +} + +test('the merge keeps exactly what it always kept, for runs of every shape', () => { + let seed = 3; + const rnd = () => (seed = (seed * 16807) % 2147483647) / 2147483647; + const run = (n, from, stepMs, sorted) => { + const out = Array.from({ length: n }, (_, k) => ({ + atMs: + rnd() < 0.05 + ? Number.NaN + : from + + Math.round((sorted ? k : rnd() * n) * stepMs * (0.5 + rnd())), + })); + if (sorted) out.sort((a, b) => a.atMs - b.atMs); + return out; + }; + for (let round = 0; round < 3000; round++) { + const sorted = round % 5 !== 0; + const older = run( + Math.floor(rnd() * 300), + Math.floor(rnd() * 4e6), + 15_000 + rnd() * 50_000, + sorted, + ); + const newer = run( + Math.floor(rnd() * 30), + Math.floor(rnd() * 6e6), + 5_000 + rnd() * 70_000, + sorted, + ); + // The newest of the newer run is sometimes an entry of the older one. + if (newer.length && older.length && rnd() < 0.1) + newer[newer.length - 1] = older[older.length - 1]; + const centreMs = rnd() * 7e6; + const limit = rnd() < 0.5 ? 240 : 1 + Math.floor(rnd() * 40); + const expected = referenceMerge( + older, + newer, + (f) => f.atMs, + centreMs, + limit, + ); + const actual = mergeTimelineRuns( + older, + newer, + (f) => f.atMs, + centreMs, + limit, + ); + assert.equal(actual.length, expected.length, `round ${round}`); + for (let k = 0; k < expected.length; k++) + assert.equal(actual[k], expected[k], `round ${round} entry ${k}`); + } +});