Add a Navara HD renderer choice, release a parked engine after three minutes, and cut Navara's memory

Navara now draws at CSS pixels without MSAA, like Cesium; Navara HD keeps the device pixel ratio and MSAA 4. Only one Navara variant is ever kept. A parked engine is released after three minutes and its WebGL context is lost. Three leaks that kept a released Navara alive are fixed, the canvas context drops its unused antialias buffer, cloud shadows use two 256 px cascades, and the tile cache is budgeted from the screen buffers.
This commit is contained in:
German Khokhlov committed 2026-11-06 14:41:16 +04:00
1 parent a6c64713ee
commit 9825b02aab
22 files changed
+657 -58

No files matched your search

+13 -5
View File
@@ -15,13 +15,16 @@ import {
} from '../i18n/index.js';
import { mountApplicationViews } from '../ui/views/index.js';
import { createGoogleTokenSource } from '../maps/googleTokens.js';
import { resolveEngineKind } from '../app/engineChoice.js';
import { engineOfChoice, resolveEngineKind } from '../app/engineChoice.js';
import { createSceneHost } from '../app/sceneHost.js';
import { attachScenePart } from '../app/sceneParts.js';
// Only one engine may own the page at a time.
let owner = null;
/** The abort reason of a released globe, made once at module load. */
const SCENE_RELEASED = new DOMException('The globe was released', 'AbortError');
/** The page's engine choice: ?engine=, else the stored gev.engine, else Cesium. */
export function pageEngineKind() {
let storage = null;
@@ -91,7 +94,9 @@ export function createStandaloneApplication({
const controller = new AbortController();
const releases = [];
const release = async () => {
controller.abort();
// A reason made here would keep this call's stack, and with it the
// released scene, alive in every closure that still holds `signal`.
controller.abort(SCENE_RELEASED);
const errors = [];
while (releases.length) {
try {
@@ -123,13 +128,16 @@ export function createStandaloneApplication({
// The catalog of this engine: on Navara only the layers with a Navara
// renderer (src/app/layers/renderers.js), the others' state kept for
// links. The layer models are the session's (layerSession.models).
// Session models keep the catalog's closures past this scene: they
// capture the operations, never the scene (it holds the engine).
const { operations } = scene;
const sceneCatalog = createStandaloneCatalog({
engineKind: kind,
engineKind: engineOfChoice(kind),
layerSession,
sources: { ...sources, ...qaSources },
streetLevelProviders,
nepalBoundaryResolver: (resolverSignal) =>
scene.operations.annotationResolver.resolveRegionRingForQuery(
operations.annotationResolver.resolveRegionRingForQuery(
'Nepal',
resolverSignal,
placeSearch,
@@ -137,7 +145,7 @@ export function createStandaloneApplication({
{ budgetMs: Infinity },
),
signal,
surface: scene.operations.surface,
surface: operations.surface,
});
return Object.freeze({
...scene,
@@ -37,6 +37,7 @@ function standalone({ failOpen = null } = {}) {
getState: () => ({ status: 'ready' }),
}),
resolveEngineKind: () => 'cesium',
engineOfChoice: (choice) => (choice === 'cesium' ? 'cesium' : 'navara'),
createStandalonePlaceSearch: () => ({ kind: 'search' }),
createStandaloneCatalog: ({ engineKind }) => ({ engineKind }),
createGoogleTokenSource: () => null,
@@ -51,6 +52,7 @@ function standalone({ failOpen = null } = {}) {
attachScenePart,
AbortController,
AbortSignal,
DOMException,
});
vm.runInContext(source, context);
const app = context.createStandaloneApplication({});
+2 -2
View File
@@ -12,7 +12,7 @@
// Requests that arrive while a switch or a recovery runs are never dropped:
// once the current attempt settles, the address is read again and reconciled.
const ENGINES = Object.freeze(['cesium', 'navara']);
import { ENGINE_CHOICES } from '../app/engineChoice.js';
/** A started engine whose first frame takes longer than this is shown anyway. */
const FIRST_FRAME_WAIT_MS = 10_000;
@@ -88,7 +88,7 @@ export function createEngineSwitch({
/** The picker's choice. While a switch runs it is queued, not dropped. */
function select(next) {
if (!ENGINES.includes(next) || signal.aborted) return null;
if (!ENGINE_CHOICES.includes(next) || signal.aborted) return null;
requests++;
if (busy) {
queued = next;
+44 -5
View File
@@ -1,13 +1,52 @@
// This cache owns the parked renderer and its map. The layer session owns
// feeds, selection, media and the Director across both renderer attachments.
export function createRendererCache() {
/** How long a parked renderer waits for a switch back before it is
* disposed: a parked Navara holds about 1.3 GiB, a parked Cesium about
* 0.26 GiB. A later switch back builds it cold (1.5-2 s). */
export const PARKED_RELEASE_MS = 3 * 60 * 1000;
/**
* `engineOf(kind)` names the engine a kind runs: kinds of one engine (Navara
* and Navara HD) never stay parked together, so acquiring one releases the
* other first.
*/
export function createRendererCache({
engineOf = (kind) => kind,
parkedMs = PARKED_RELEASE_MS,
onReleaseError = (error) =>
console.error('Parked renderer release failed:', error),
} = {}) {
const idle = new Map();
let retainKind;
function take(kind) {
const entry = idle.get(kind);
idle.delete(kind);
if (entry) clearTimeout(entry.releaseTimer);
return entry;
}
// Dispose a parked renderer for good.
function release(kind) {
const entry = take(kind);
try {
entry.dispose();
} catch (error) {
onReleaseError(error);
} finally {
// A disposed globe's context stays live while anything still
// references its canvas; losing it frees the GPU memory now (the
// canvas is out of the document, so no page listener hears it).
entry.context?.getExtension?.('WEBGL_lose_context')?.loseContext();
}
}
async function acquire(kind, build, defer) {
const host = document.getElementById('cesiumContainer');
let entry = idle.get(kind);
idle.delete(kind);
for (const other of [...idle.keys()])
if (other !== kind && engineOf(other) === engineOf(kind)) release(other);
let entry = take(kind);
// loseContext() takes effect before its queued DOM event is delivered.
// Check the context itself too, before resuming a parked render loop.
if (entry && (entry.lost || entry.context?.isContextLost?.())) {
@@ -76,6 +115,7 @@ export function createRendererCache() {
}
entry.container.remove();
idle.set(kind, entry);
entry.releaseTimer = setTimeout(() => release(kind), parkedMs);
});
return entry.scene;
}
@@ -86,8 +126,7 @@ export function createRendererCache() {
retainKind = kind;
},
clear() {
for (const entry of idle.values()) entry.dispose();
idle.clear();
for (const kind of [...idle.keys()]) take(kind).dispose();
},
};
}
+138 -11
View File
@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
import test from 'node:test';
import { createRendererCache } from './rendererCache.js';
test('a parked renderer is reused, but a lost context is disposed before rebuilding', async (t) => {
function installDocument(t) {
const host = {
prepend: (el) => {
el.isConnected = true;
@@ -20,15 +20,27 @@ test('a parked renderer is reused, but a lost context is disposed before rebuild
t.after(() => {
globalThis.document = saved;
});
const cache = createRendererCache();
let released = 0;
let release;
const build = ({ container, defer }) => {
}
/** A renderer build that counts its releases in `released.count`. */
function fakeBuild(released) {
return ({ container, defer }) => {
defer(() => {
released += 1;
released.count += 1;
});
const canvas = new EventTarget();
const context = { lost: false, isContextLost: () => context.lost };
const context = {
lost: false,
isContextLost: () => context.lost,
getExtension: (name) =>
name === 'WEBGL_lose_context'
? {
loseContext() {
context.lost = true;
},
}
: null,
};
canvas.getContext = (type) => (type === 'webgl2' ? context : null);
return {
context,
@@ -44,6 +56,14 @@ test('a parked renderer is reused, but a lost context is disposed before rebuild
},
};
};
}
test('a parked renderer is reused, but a lost context is disposed before rebuilding', async (t) => {
installDocument(t);
const cache = createRendererCache();
const released = { count: 0 };
let release;
const build = fakeBuild(released);
const open = () =>
cache.acquire('navara', build, (stop) => {
release = stop;
@@ -72,7 +92,7 @@ test('a parked renderer is reused, but a lost context is disposed before rebuild
};
const second = await open();
assert.notEqual(second, first);
assert.equal(released, 1);
assert.equal(released.count, 1);
cache.retain('navara');
release();
second.resume = () => {
@@ -80,14 +100,14 @@ test('a parked renderer is reused, but a lost context is disposed before rebuild
};
await assert.rejects(open(), /resume failed/);
assert.equal(second.engine.host.container.isConnected, false);
assert.equal(released, 2);
assert.equal(released.count, 2);
const eventLost = await open();
cache.retain('navara');
release();
eventLost.engine.host.canvas.dispatchEvent(new Event('webglcontextlost'));
const third = await open();
assert.notEqual(third, eventLost);
assert.equal(released, 3);
assert.equal(released.count, 3);
third.suspend = () => {
throw new Error('suspend failed');
};
@@ -95,5 +115,112 @@ test('a parked renderer is reused, but a lost context is disposed before rebuild
assert.throws(release, /suspend failed/);
assert.equal(third.engine.host.container.isConnected, false);
cache.clear();
assert.equal(released, 4);
assert.equal(released.count, 4);
});
test('a parked renderer is released after a while, unless the page switches back first', async (t) => {
installDocument(t);
t.mock.timers.enable({ apis: ['setTimeout'] });
const errors = [];
const cache = createRendererCache({
parkedMs: 1000,
onReleaseError: (error) => errors.push(error),
});
const released = { count: 0 };
let release;
const open = (build = fakeBuild(released)) =>
cache.acquire('navara', build, (stop) => {
release = stop;
});
const park = () => {
cache.retain('navara');
release();
};
const first = await open();
park();
t.mock.timers.tick(999);
assert.equal(await open(), first, 'a switch back in time is warm');
assert.equal(first.context.lost, false);
park();
// The timer of the earlier parking was cancelled: this one starts afresh.
t.mock.timers.tick(999);
assert.equal(released.count, 0);
t.mock.timers.tick(1);
assert.equal(released.count, 1, 'released once the delay runs out');
assert.equal(first.context.lost, true, 'its GPU memory goes with it');
const cold = await open();
assert.notEqual(cold, first, 'a switch back after the release builds anew');
// A release that fails is reported, and the entry is gone either way.
const failingCache = createRendererCache({
parkedMs: 1000,
onReleaseError: (error) => errors.push(error),
});
let releaseBroken;
const brokenBuild = (options) => {
options.defer(() => {
throw new Error('dispose failed');
});
return fakeBuild({ count: 0 })(options);
};
const openBroken = () =>
failingCache.acquire('navara', brokenBuild, (stop) => {
releaseBroken = stop;
});
const broken = await openBroken();
failingCache.retain('navara');
releaseBroken();
t.mock.timers.tick(1000);
assert.equal(errors.length, 1);
assert.match(errors[0].errors[0].message, /dispose failed/);
assert.notEqual(await openBroken(), broken);
// clear() disposes what is parked and leaves no timer behind.
park();
const before = released.count;
cache.clear();
t.mock.timers.tick(1000);
assert.equal(released.count, before + 1);
});
test('acquiring one kind of an engine releases the other parked kind of it first', async (t) => {
installDocument(t);
const cache = createRendererCache({
engineOf: (kind) => (kind === 'cesium' ? 'cesium' : 'navara'),
});
const released = { count: 0 };
const build = fakeBuild(released);
let release;
const open = (kind) =>
cache.acquire(kind, build, (stop) => {
release = stop;
});
const park = (kind) => {
cache.retain(kind);
release();
};
const navara = await open('navara');
park('navara');
const cesium = await open('cesium');
park('cesium');
let builtWhileParked = null;
const hd = await cache.acquire(
'navara-hd',
(options) => {
builtWhileParked = released.count;
return build(options);
},
(stop) => {
release = stop;
},
);
assert.equal(builtWhileParked, 1, 'Navara went before Navara HD was built');
assert.equal(navara.context.lost, true);
park('navara-hd');
assert.equal(await open('cesium'), cesium, 'Cesium stays parked, warm');
park('cesium');
assert.notEqual(await open('navara'), navara);
assert.equal(hd.context.lost, true);
cache.clear();
});