mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Let a full imagery budget wait without drawing, and cancel a removed layer's tiles
A tile a layer's admit hook defers is asked again on the frame its own request in flight asks for as it settles, so a layer whose budget is full no longer keeps a retry timer drawing frames; with none in flight the delayed retry frame stays. Removing a layer cancels the Cesium requests it still has in flight, which Cesium leaves running, freeing their per-server slots. Statuses a spec names for retry are fetched up to three more times, as the weather layer retried them before moving to the port.
This commit is contained in:
1 parent
bd5a688144
commit
9e1f9a1c3d
2 files changed
+75
-8
No files matched your search
@@ -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 }];
|
||||
|
||||
@@ -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<void>, signals: Set<AbortController>}} ctx
|
||||
* laterFrame: () => Promise<void>, signals: Set<AbortController>,
|
||||
* busy?: () => boolean, requests?: Set<object>}} 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))
|
||||
|
||||
Reference in new issue
Block a user