mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-10-09 15:58:34 +00:00
陈大猫
38775245d2
* perf(terminal): bound the connection log with a chunk ring buffer The connection log kept the last 1,000,000 chars via `log += chunk; log = log.slice(-MAX)`. Once a session emits more than that, the slice flattens a ~1M-char string on every subsequent output chunk — on the render thread, for each echoed keystroke included — on long/busy sessions. Replace the string with a small chunk-queue ring buffer that trims only the boundary chunk (amortized O(chunk) append) and materializes the full string once on read. Behavior is unchanged: it still retains exactly the last MAX_CONNECTION_LOG_DATA_CHARS characters. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * perf(terminal): coalesce connection log into bounded blocks (O(1) trim) The first cut used one array entry per append and trimmed with chunks.shift(). For interactive output (many tiny chunks) the array grows toward the cap in entries, so once full, shift() reindexes ~N elements on every append — O(appends) per chunk, no better than the slice it replaced. Coalesce appends into a small, bounded set of fixed-size blocks (~maxChars/blockSize). New data fills an open tail that seals into a block at blockSize; trimming only drops/slices a handful of blocks. Adds segmentCount() and a test asserting the segment count stays bounded across many tiny appends. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
99 lines
3.0 KiB
TypeScript
99 lines
3.0 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import { createConnectionLogBuffer } from "./connectionLogBuffer.ts";
|
|
|
|
test("concatenates appended chunks while under the cap", () => {
|
|
const buf = createConnectionLogBuffer(100);
|
|
buf.append("foo");
|
|
buf.append("bar");
|
|
buf.append("baz");
|
|
assert.equal(buf.toString(), "foobarbaz");
|
|
});
|
|
|
|
test("keeps only the last maxChars, matching slice(-max) semantics", () => {
|
|
const max = 10;
|
|
const buf = createConnectionLogBuffer(max);
|
|
const chunks = ["abcd", "efgh", "ijkl", "mnop"]; // 16 chars total
|
|
let naive = "";
|
|
for (const c of chunks) {
|
|
buf.append(c);
|
|
naive += c;
|
|
}
|
|
assert.equal(buf.toString(), naive.slice(-max));
|
|
assert.equal(buf.toString().length, max);
|
|
});
|
|
|
|
test("trims a single chunk larger than the cap to its last maxChars", () => {
|
|
const buf = createConnectionLogBuffer(5);
|
|
buf.append("0123456789");
|
|
assert.equal(buf.toString(), "56789");
|
|
});
|
|
|
|
test("partial-trims the boundary chunk to keep exactly maxChars", () => {
|
|
const buf = createConnectionLogBuffer(6);
|
|
buf.append("abcde"); // 5
|
|
buf.append("fghij"); // total 10 -> keep last 6 => "efghij"
|
|
assert.equal(buf.toString(), "efghij");
|
|
});
|
|
|
|
test("stays correct across many small appends (ring semantics)", () => {
|
|
const max = 50;
|
|
const buf = createConnectionLogBuffer(max);
|
|
let naive = "";
|
|
for (let i = 0; i < 500; i++) {
|
|
const chunk = `x${i}-`;
|
|
buf.append(chunk);
|
|
naive += chunk;
|
|
}
|
|
assert.equal(buf.toString(), naive.slice(-max));
|
|
});
|
|
|
|
test("reset clears the buffer", () => {
|
|
const buf = createConnectionLogBuffer(100);
|
|
buf.append("hello");
|
|
buf.reset();
|
|
assert.equal(buf.toString(), "");
|
|
buf.append("world");
|
|
assert.equal(buf.toString(), "world");
|
|
});
|
|
|
|
test("ignores empty appends", () => {
|
|
const buf = createConnectionLogBuffer(100);
|
|
buf.append("a");
|
|
buf.append("");
|
|
buf.append("b");
|
|
assert.equal(buf.toString(), "ab");
|
|
});
|
|
|
|
test("keeps the segment count bounded across many tiny appends", () => {
|
|
// The whole point of the rewrite: trimming must not walk one array entry
|
|
// per append. With a blockSize of 10 and a 100-char cap, the buffer should
|
|
// never hold more than ~ceil(cap/blockSize)+1 segments no matter how many
|
|
// single-char appends arrive once it's at capacity.
|
|
const maxChars = 100;
|
|
const blockSize = 10;
|
|
const buf = createConnectionLogBuffer(maxChars, blockSize);
|
|
let naive = "";
|
|
for (let i = 0; i < 10000; i++) {
|
|
buf.append("x");
|
|
naive += "x";
|
|
}
|
|
assert.ok(
|
|
buf.segmentCount() <= Math.ceil(maxChars / blockSize) + 1,
|
|
`segmentCount ${buf.segmentCount()} exceeded the bound`,
|
|
);
|
|
assert.equal(buf.toString(), naive.slice(-maxChars));
|
|
});
|
|
|
|
test("seals and trims whole blocks with a small blockSize", () => {
|
|
const buf = createConnectionLogBuffer(10, 4);
|
|
const chunks = ["abcd", "efgh", "ijkl"]; // 12 chars total
|
|
let naive = "";
|
|
for (const c of chunks) {
|
|
buf.append(c);
|
|
naive += c;
|
|
}
|
|
assert.equal(buf.toString(), naive.slice(-10)); // "cdefghijkl"
|
|
});
|