repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/lsp/__bench__/evidence.ts
Rawimport assert from "node:assert/strict";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { isAbsolute, join, relative, resolve, sep } from "node:path";
import { pathToFileURL } from "node:url";
import type { Client } from "../src/client.ts";
import { normalize } from "../src/result.ts";
import { fromPosition, snapshot } from "../src/source.ts";
const evidence = resolve(process.argv[2] ?? "");
const relativeEvidence = relative(tmpdir(), evidence);
assert(
isAbsolute(process.argv[2] ?? "") &&
relativeEvidence !== "" &&
relativeEvidence !== ".." &&
!relativeEvidence.startsWith(`..${sep}`) &&
!isAbsolute(relativeEvidence),
"Provide dedicated OS-temp evidence directory.",
);
await mkdir(evidence, { recursive: true });
const root = await mkdtemp(join(tmpdir(), "lsp-evidence-bench-"));
const file = join(root, "sample.go");
const text = `var Value = 1\n${"// realistic source line\n".repeat(4000)}`;
await writeFile(file, text);
const location = {
uri: pathToFileURL(file).href,
range: { start: { line: 0, character: 4 }, end: { line: 0, character: 9 } },
};
const client = {
root,
encoding: "utf-16",
remember: async () => undefined,
} as unknown as Client;
const signal = new AbortController().signal;
const late = {
uri: location.uri,
range: {
start: { line: 4000, character: 3 },
end: { line: 4000, character: 12 },
},
};
async function references(
hit: typeof location,
snippet: string,
): Promise<void> {
for (let i = 0; i < 3; i++) {
const output = await normalize(
client,
"references",
file,
Array.from({ length: 50 }, () => hit),
50,
32768,
signal,
);
assert.deepEqual(
output.items,
Array.from({ length: 50 }, () => ({
file,
range: {
start: {
line: hit.range.start.line + 1,
column: hit.range.start.character + 1,
},
end: {
line: hit.range.end.line + 1,
column: hit.range.end.character + 1,
},
},
snippet,
})),
);
assert.equal(output.toolTruncated, false);
}
}
const workloads = {
snapshot: async () => {
for (let i = 0; i < 20; i++) assert.equal(await snapshot(file), text);
},
references: () => references(location, "var Value = 1"),
lateReferences: () => references(late, "// realistic source line"),
latePosition: async () => {
for (let i = 0; i < 100; i++) {
assert.deepEqual(fromPosition(text, late.range.start, "utf-16"), {
line: 4001,
column: 4,
});
}
},
};
const rounds = 12;
const warmup = 3;
const samples: Record<string, number[]> = {};
try {
for (const [name, work] of Object.entries(workloads)) {
for (let i = 0; i < warmup; i++) await work();
samples[name] = [];
for (let i = 0; i < rounds; i++) {
global.gc?.();
const start = performance.now();
await work();
samples[name]?.push(performance.now() - start);
}
}
const report = {
node: process.version,
platform: process.platform,
warmup,
rounds,
fixtureBytes: Buffer.byteLength(text),
method:
"Per batch: 20 snapshots, 3 reference normalizations of 50 hits (first/4001st line), or 100 late-line position conversions, in one 100014-byte file. remember stubbed; three discarded warmups, GC between rounds; raw samples retained, no outliers removed.",
samples,
};
await writeFile(
join(evidence, "timing.json"),
JSON.stringify(report, null, 2),
);
console.log(JSON.stringify(report));
} finally {
await rm(root, { recursive: true, force: true });
}