Files
Netcatty/components/terminal/runtime/webglContextBudget.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

158 lines
4.9 KiB
TypeScript

import assert from "node:assert/strict";
import test from "node:test";
import {
createWebglContextBudget,
type WebglContextBudgetMember,
} from "./webglContextBudget";
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;
},
};
}
class FakeMember implements WebglContextBudgetMember {
hiddenSince: number | null = null;
releases = 0;
constructor(readonly name: string) {}
getHiddenSince() { return this.hiddenSince; }
release() { this.releases += 1; }
}
function setup(maxActiveContexts = 3) {
const clock = createClock();
const budget = createWebglContextBudget({
maxActiveContexts,
minHiddenMs: 3_000,
now: clock.now,
setTimer: clock.setTimer,
clearTimer: clock.clearTimer,
});
return { clock, budget };
}
test("below the cap every pane keeps its renderer, hidden or not", () => {
const { clock, budget } = setup(3);
const members = ["a", "b", "c"].map((name) => new FakeMember(name));
for (const member of members) assert.equal(budget.tryAcquire(member), true);
for (const member of members) member.hiddenSince = clock.now();
clock.advance(60_000);
for (const member of members) budget.noteHidden(member);
clock.advance(60_000);
assert.deepEqual(members.map((member) => member.releases), [0, 0, 0]);
assert.equal(budget.getActiveCount(), 3);
assert.equal(clock.pendingTimers, 0);
});
test("a visible pane past the cap releases the least recently seen hidden pane", () => {
const { clock, budget } = setup(3);
const [a, b, c] = ["a", "b", "c"].map((name) => new FakeMember(name));
budget.tryAcquire(a);
budget.tryAcquire(b);
budget.tryAcquire(c);
b.hiddenSince = 1_000;
a.hiddenSince = 2_000;
clock.advance(10_000);
const shown = new FakeMember("shown");
assert.equal(budget.tryAcquire(shown), true);
assert.equal(b.releases, 1, "hidden longest goes first");
assert.equal(a.releases, 0);
assert.equal(c.releases, 0, "visible panes are never released");
assert.equal(budget.getActiveCount(), 3);
});
test("recently hidden panes are released only once they stay hidden long enough", () => {
const { clock, budget } = setup(2);
const [a, b] = ["a", "b"].map((name) => new FakeMember(name));
budget.tryAcquire(a);
budget.tryAcquire(b);
clock.advance(5_000);
a.hiddenSince = clock.now();
budget.noteHidden(a);
budget.tryAcquire(new FakeMember("shown"));
assert.equal(a.releases, 0, "a quick tab flip must not lose the renderer");
assert.equal(budget.getActiveCount(), 3);
clock.advance(2_999);
assert.equal(a.releases, 0);
clock.advance(1);
assert.equal(a.releases, 1);
assert.equal(budget.getActiveCount(), 2);
assert.equal(clock.pendingTimers, 0);
});
test("a pane hidden after the budget went over is released once eligible", () => {
const { clock, budget } = setup(2);
const [a, b, c] = ["a", "b", "c"].map((name) => new FakeMember(name));
budget.tryAcquire(a);
budget.tryAcquire(b);
budget.tryAcquire(c);
assert.equal(budget.getActiveCount(), 3, "three visible panes all keep WebGL");
assert.equal(clock.pendingTimers, 0);
b.hiddenSince = clock.now();
budget.noteHidden(b);
clock.advance(3_000);
assert.equal(b.releases, 1);
assert.equal(budget.getActiveCount(), 2);
});
test("a hidden pane cannot take a context once the budget is full", () => {
const { budget } = setup(2);
budget.tryAcquire(new FakeMember("a"));
budget.tryAcquire(new FakeMember("b"));
const hidden = new FakeMember("hidden");
hidden.hiddenSince = 0;
assert.equal(budget.tryAcquire(hidden), false);
assert.equal(budget.getActiveCount(), 2);
hidden.hiddenSince = null;
assert.equal(budget.tryAcquire(hidden), true, "it gets one as soon as it is shown");
});
test("released and forgotten panes free their slot", () => {
const { budget } = setup(1);
const a = new FakeMember("a");
budget.tryAcquire(a);
budget.forget(a);
budget.forget(a);
assert.equal(budget.getActiveCount(), 0);
const hidden = new FakeMember("hidden");
hidden.hiddenSince = 0;
assert.equal(budget.tryAcquire(hidden), true);
assert.equal(budget.tryAcquire(hidden), true, "acquiring twice keeps one slot");
assert.equal(budget.getActiveCount(), 1);
});