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}`); + } +});