diff --git a/src/render/cesium/globe.test.mjs b/src/render/cesium/globe.test.mjs index 49fb95413..cf2d21a1c 100644 --- a/src/render/cesium/globe.test.mjs +++ b/src/render/cesium/globe.test.mjs @@ -2,7 +2,7 @@ import assert from 'node:assert/strict'; import test from 'node:test'; import * as Cesium from 'cesium'; import { createCesiumGlobe, markBaseTileset } from './globe.js'; -import { hookProvider, xyzTileUrl } from './imagery.js'; +import { hookProvider, TILE_RETRY_DELAY_MS, xyzTileUrl } from './imagery.js'; const ALL = new Set(['imageHooks', 'imageryOnTiles', 'splitSwipe', 'terrain']); const url = (name) => `https://${name}.invalid/{z}/{x}/{y}.png`; @@ -241,6 +241,7 @@ test('admit decides first; at most maxConcurrentRequests are in flight', async ( retrySoon: () => (counts.retries += 1), laterFrame: () => Promise.resolve(), signals: new Set(), + busy: () => counts.started > counts.settled, }; const admitted = []; const hooked = hookProvider( @@ -261,14 +262,58 @@ test('admit decides first; at most maxConcurrentRequests are in flight', async ( assert.equal(hooked.requestImage(1, 0, 1), undefined, 'the second waits'); assert.equal(counts.retries, 0, 'a full budget asks for no frame itself'); assert.equal(hooked.requestImage(9, 0, 1), undefined, 'admit deferred'); - assert.equal(counts.retries, 1, 'admit deferring asks for a later frame'); + assert.equal( + counts.retries, + 0, + 'with a request in flight, its settling is the later frame', + ); assert.deepEqual(admitted[0], { x: 0, y: 0, level: 1 }); resolvers[0]('image'); assert.equal(await first, 'image'); - assert.deepEqual(counts, { started: 1, settled: 1, retries: 1 }); + assert.deepEqual(counts, { started: 1, settled: 1, retries: 0 }); + assert.equal(hooked.requestImage(9, 0, 1), undefined, 'admit deferred'); + assert.equal(counts.retries, 1, 'with none in flight it asks for a frame'); assert.ok(hooked.requestImage(1, 0, 1), 'the budget is free again'); }); +test('removing a layer cancels the Cesium requests it has in flight', async () => { + const { scene, port } = setup(); + const layer = port.imagery.add({ + kind: 'xyz', + url: url('a'), + admit: (tile, issue) => issue(), + }); + const provider = scene.imageryLayers.get(0).imageryProvider; + const settledRequest = new Cesium.Request({ throttle: false }); + const request = new Cesium.Request({ throttle: false }); + const answers = []; + Object.getPrototypeOf(provider).requestImage = () => + new Promise((resolve) => answers.push(resolve)); + const done = provider.requestImage(0, 0, 1, settledRequest); + assert.ok(provider.requestImage(1, 0, 1, request), 'issued'); + answers[0]('image'); + await done; + layer.remove(); + assert.equal(request.cancelled, true, 'the one in flight is cancelled'); + assert.equal(settledRequest.cancelled, false, 'a settled one is not'); +}); + +test('a layer deferring while another has a request in flight asks for a frame', (t) => { + t.mock.timers.enable({ apis: ['setTimeout'] }); + const { scene, port, renders } = setup(); + port.imagery.add({ kind: 'xyz', url: url('a'), admit: (_t, i) => i() }); + port.imagery.add({ kind: 'xyz', url: url('b'), admit: () => undefined }); + const [busy, waiting] = [0, 1].map( + (i) => scene.imageryLayers.get(i).imageryProvider, + ); + Object.getPrototypeOf(busy).requestImage = () => new Promise(() => {}); + assert.ok(busy.requestImage(0, 0, 1), 'in flight'); + renders.length = 0; + assert.equal(waiting.requestImage(0, 0, 1), undefined); + t.mock.timers.tick(TILE_RETRY_DELAY_MS); + assert.deepEqual(renders, ['imagery']); +}); + test('fetchTile fetches in place of the provider, with the URL it would fetch', async (t) => { const asked = []; const answers = [{ defer: true }, { missing: true }]; diff --git a/src/render/cesium/imagery.js b/src/render/cesium/imagery.js index 5b66a0a7b..eaf618484 100644 --- a/src/render/cesium/imagery.js +++ b/src/render/cesium/imagery.js @@ -52,7 +52,7 @@ function resourceOf(spec) { const statuses = new Set(spec.retryStatuses); return new Cesium.Resource({ url: spec.url, - retryAttempts: 2, + retryAttempts: 3, retryCallback: (_resource, error) => statuses.has(error?.statusCode), }); } @@ -216,10 +216,17 @@ function guarded(run) { * requests: `admit` decides first, an issued request goes through * `fetchTile` (or the provider), then `tileTransform`; at most * `maxConcurrentRequests` are in flight. + * + * A tile `admit` defers is asked again on a later frame: the one a request + * of the same layer in flight asks for as it settles, or, with none in + * flight (`busy`), the one `retrySoon` asks for. So a layer whose own + * budget is full never keeps the scene drawing while it waits. * @param {object} provider * @param {import('../contract/globe').ImagerySpec} spec * @param {{started: () => void, settled: () => void, retrySoon: () => void, - * laterFrame: () => Promise, signals: Set}} ctx + * laterFrame: () => Promise, signals: Set, + * busy?: () => boolean, requests?: Set}} ctx + * `requests`: the Cesium requests in flight, cancelled as the layer goes. */ export function hookProvider(provider, spec, ctx) { const limit = @@ -267,7 +274,7 @@ export function hookProvider(provider, spec, ctx) { } return withTileRequestHook(provider, { - requestImage({ x, y, level }, ask) { + requestImage({ x, y, level, request }, ask) { const tile = { x, y, level }; // Deferred by the budget: the request in flight asks for a frame as // it settles, so none is asked for here. @@ -287,17 +294,20 @@ export function hookProvider(provider, spec, ctx) { } inFlight += 1; ctx.started(); + if (request) ctx.requests?.add(request); let result = Promise.resolve(started); if (spec.tileTransform) result = result.then((image) => transformTile(spec, tile, image)); return result.finally(() => { inFlight -= 1; + if (request) ctx.requests?.delete(request); ctx.settled(); }); }; if (!spec.admit) return issue(); const answer = guarded(() => spec.admit(tile, issue)); - if (answer === undefined && !waitsOnBudget) ctx.retrySoon(); + if (answer === undefined && !waitsOnBudget && !ctx.busy?.()) + ctx.retrySoon(); return answer; }, }); @@ -464,10 +474,18 @@ export function createCesiumImagery( frameReady: listenerList(report), }; const signals = new Set(); + const requests = new Set(); + let layerPending = 0; const ctx = { - started: () => (pending += 1), + busy: () => layerPending > 0, + requests, + started: () => { + pending += 1; + layerPending += 1; + }, settled: () => { pending -= 1; + layerPending -= 1; if (!disposed) requestRender('imagery'); }, retrySoon, @@ -584,6 +602,10 @@ export function createCesiumImagery( if (i >= 0) layers.splice(i, 1); record.offError?.(); for (const controller of signals) controller.abort(); + // Cesium leaves a removed layer's requests running: cancelled, they + // are aborted and free their per-server slots on the next frame. + for (const request of requests) request.cancel?.(); + requests.clear(); listeners.tileError.clear(); listeners.frameReady.clear(); if (usable(record.host) && record.host.contains(record.cesium))