Files
Netcatty/components/terminal/runtime/webglRendererBudget.test.ts
T
陈大猫andClaude Opus 5.5 d56150953d perf(terminal): cap live WebGL contexts, release them eagerly, bound note undo history (#4122)
* perf(terminal): cap live WebGL contexts and stop the context-loss cascade

Chromium keeps at most 16 WebGL contexts per renderer and force-loses the
one that drew least recently past that. Hidden terminal panes keep their
WebGL renderer unless hibernation is on, so with more than 16 terminal
tabs every forced loss was rebuilt 50 ms later, evicting another context.
With 20 local tabs, half of all tab switches landed on a lost context
(xterm waits 3 s before falling back), and terminals that lost three
contexts within a minute were parked on the DOM renderer for good.

- Add a shared context budget (12). Past it, renderers of panes hidden for
  at least 3 s are released, least recently seen first. Visible panes are
  never released or refused; a released pane rebuilds when shown.
- A context lost while hidden waits for the reveal instead of rebuilding
  at once, and no longer counts toward the breaker.
- The short-hide CSS reveal path now also asks for the renderer (a no-op
  while it is live).
- Disposing the addon left its context alive until GC. Lose it explicitly
  so GPU memory and the Chromium slot come back right away.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* perf(notes): bound the source editor's undo history

Every undo step in the markdown source editor holds a full copy of the
note, and the stack never shrank. A long session on a large note kept
every intermediate version alive (a 100 KB note with 1,000 steps holds
~200 MB of UTF-16 text).

Keep the 200 most recent steps and at most 8M characters across them,
dropping the oldest first. The newest step always survives.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 00:22:42 -08:00

276 lines
7.8 KiB
TypeScript

import assert from "node:assert/strict";
import test from "node:test";
import { createWebglContextBudget } from "./webglContextBudget";
import { createWebglRendererController } from "./webglRendererController";
class FakeAddon {
contextLoss: (() => void) | null = null;
disposeCalls = 0;
onContextLoss(callback: () => void) {
this.contextLoss = callback;
}
dispose() {
this.disposeCalls += 1;
}
loseContext() {
assert.ok(this.contextLoss, "addon must install a context-loss handler");
this.contextLoss();
}
}
function createClock() {
let time = 0;
let nextTimerId = 1;
const timers = new Map<number, { at: number; run: () => void }>();
return {
now: () => time,
setTimer: (run: () => void, delayMs: number) => {
const id = nextTimerId++;
timers.set(id, { at: time + delayMs, run });
return id as unknown as ReturnType<typeof setTimeout>;
},
clearTimer: (id: ReturnType<typeof setTimeout>) => {
timers.delete(id as unknown as number);
},
get pendingTimers() { return timers.size; },
advance(ms: number) {
const end = time + ms;
for (;;) {
const next = [...timers.entries()]
.filter(([, timer]) => timer.at <= end)
.sort((a, b) => a[1].at - b[1].at)[0];
if (!next) break;
timers.delete(next[0]);
time = next[1].at;
next[1].run();
}
time = end;
},
};
}
function setup(maxActiveContexts = 12) {
const clock = createClock();
const budget = createWebglContextBudget({
maxActiveContexts,
now: clock.now,
setTimer: clock.setTimer,
clearTimer: clock.clearTimer,
});
const createPane = (initiallyVisible = true) => {
let visible = initiallyVisible;
const addons: FakeAddon[] = [];
const warnings: string[] = [];
let loaded = false;
const controller = createWebglRendererController({
enabled: true,
createAddon: () => {
const addon = new FakeAddon();
addons.push(addon);
return addon;
},
loadAddon: () => {},
repaint: () => {},
setLoaded: (value) => { loaded = value; },
warn: (message) => warnings.push(message),
now: clock.now,
setTimer: clock.setTimer,
clearTimer: clock.clearTimer,
budget,
isVisible: () => visible,
});
return {
controller,
addons,
warnings,
get loaded() { return loaded; },
/** Change visibility the way useTerminalEffects does: ref, then sync. */
setVisible(value: boolean) {
visible = value;
controller.syncVisibility();
},
/** Change only the live ref, as if a sync never reached this runtime. */
setVisibleWithoutSync(value: boolean) {
visible = value;
},
reveal() {
this.setVisible(true);
controller.ensure();
},
};
};
return { clock, budget, createPane };
}
test("a context lost while hidden waits for the pane to be shown", () => {
const { clock, createPane } = setup();
const pane = createPane();
pane.controller.ensure();
pane.setVisible(false);
pane.addons[0].loseContext();
assert.equal(pane.loaded, false);
assert.equal(clock.pendingTimers, 0, "no rebuild while nothing is drawn");
assert.ok(pane.warnings.some((warning) => warning.includes("rebuilding when shown")));
clock.advance(60_000);
assert.equal(pane.addons.length, 1);
pane.reveal();
assert.equal(pane.addons.length, 2);
assert.equal(pane.loaded, true);
});
test("a recovery scheduled while visible is dropped if the pane is hidden first", () => {
const { clock, createPane } = setup();
const pane = createPane();
pane.controller.ensure();
pane.addons[0].loseContext();
assert.equal(clock.pendingTimers, 1);
pane.setVisible(false);
clock.advance(50);
assert.equal(pane.addons.length, 1);
assert.equal(pane.loaded, false);
pane.reveal();
assert.equal(pane.addons.length, 2);
});
test("evictions while hidden do not trip the context-loss breaker", () => {
const { clock, createPane } = setup();
const pane = createPane();
pane.controller.ensure();
for (let round = 0; round < 5; round += 1) {
pane.setVisible(false);
pane.addons.at(-1)!.loseContext();
clock.advance(1_000);
pane.reveal();
assert.equal(pane.loaded, true, `round ${round} rebuilt on reveal`);
}
assert.ok(!pane.warnings.some((warning) => warning.includes("staying on DOM renderer")));
});
test("panes past the budget give up WebGL after staying hidden, and get it back when shown", () => {
const { clock, budget, createPane } = setup(2);
const background = createPane();
const other = createPane();
background.controller.ensure();
other.controller.ensure();
background.setVisible(false);
clock.advance(3_000);
const front = createPane();
front.controller.ensure();
assert.equal(background.loaded, false);
assert.equal(background.addons[0].disposeCalls, 1);
assert.equal(other.loaded, true);
assert.equal(front.loaded, true);
assert.equal(budget.getActiveCount(), 2);
front.setVisible(false);
background.reveal();
assert.equal(background.loaded, true);
assert.equal(budget.getActiveCount(), 3, "the pane just hidden keeps WebGL for a while");
clock.advance(3_000);
assert.equal(front.loaded, false);
assert.equal(budget.getActiveCount(), 2);
});
test("a hidden pane mounted past the budget keeps the DOM renderer until shown", () => {
const { budget, createPane } = setup(1);
createPane().controller.ensure();
const hidden = createPane(false);
hidden.controller.ensure();
assert.equal(hidden.addons.length, 0);
assert.equal(budget.getActiveCount(), 1);
hidden.reveal();
assert.equal(hidden.loaded, true);
});
test("a pane on screen is never refused or released, even if a sync was missed", () => {
const { clock, budget, createPane } = setup(1);
const visible = createPane();
visible.controller.ensure();
visible.setVisible(false);
clock.advance(10_000);
visible.setVisibleWithoutSync(true);
createPane().controller.ensure();
clock.advance(10_000);
assert.equal(visible.loaded, true);
assert.equal(budget.getActiveCount(), 2);
const late = createPane(false);
late.setVisibleWithoutSync(true);
late.controller.ensure();
assert.equal(late.loaded, true);
});
test("suspend, dispose and failed loads return the budget slot", () => {
const { budget, createPane } = setup();
const suspended = createPane();
suspended.controller.ensure();
suspended.controller.suspend();
const disposed = createPane();
disposed.controller.ensure();
disposed.controller.dispose();
assert.equal(budget.getActiveCount(), 0);
const failing = createWebglRendererController({
enabled: true,
createAddon: () => new FakeAddon(),
loadAddon: () => { throw new Error("no WebGL"); },
repaint: () => {},
setLoaded: () => {},
warn: () => {},
budget,
});
failing.ensure();
assert.equal(budget.getActiveCount(), 0);
});
test("every teardown goes through disposeAddon so the context can be released", () => {
const clock = createClock();
const released: FakeAddon[] = [];
const make = (failLoad = false) => createWebglRendererController<FakeAddon>({
enabled: true,
createAddon: () => new FakeAddon(),
loadAddon: () => {
if (failLoad) throw new Error("no WebGL");
},
repaint: () => {},
setLoaded: () => {},
warn: () => {},
now: clock.now,
setTimer: clock.setTimer,
clearTimer: clock.clearTimer,
disposeAddon: (addon) => { released.push(addon); },
});
const suspended = make();
suspended.ensure();
suspended.suspend();
const disposed = make();
disposed.ensure();
disposed.dispose();
make(true).ensure();
const lost = make();
lost.ensure();
lost.getAddon()!.loseContext();
assert.equal(released.length, 4);
assert.ok(released.every((addon) => addon.disposeCalls === 0), "the hook replaces addon.dispose()");
});