This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/aitimemachine/gitnexus/test/integration/cpp-pipeline-benchmark.test.ts
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

211 lines
8.2 KiB
TypeScript

/**
* C++ ingestion pipeline benchmark.
*
* Generates synthetic C++ codebases at increasing scales and measures
* wall-clock time and peak heap through the full pipeline — scanning, parsing,
* structure extraction, scope resolution, and graph emission. Fills the one
* missing slot in the per-language benchmark suite (cobol/csharp/go/php/ruby/
* rust already have one); modeled on cobol-pipeline-benchmark.test.ts.
*
* Run: GITNEXUS_BENCH=1 npx vitest run test/integration/cpp-pipeline-benchmark.test.ts
*
* Parses with a single-worker pool (`workerPoolSize: 1`) — the sequential
* parser was removed, so the worker pool is the only parse path. NOTE: this
* needs the built `dist/parse-worker.js`; run `npm run build` first. The
* wall-clock numbers now include 1-worker IPC overhead, so re-baseline before
* trusting the timeRatio margin and confirm the node-ratio guard below still
* trips on an injected O(n²) regression. Scales are kept modest accordingly.
*
* IMPORTANT — this benchmark measures scaling in FILE COUNT, so per-file work
* must stay constant as fileCount grows. Each translation unit therefore
* #includes a FIXED number of shared headers (HEADERS_PER_FILE), independent of
* fileCount. Do NOT make every TU include all headers: headerCount grows as
* floor(fileCount/5), so include-all makes emitted symbol nodes — and thus total
* work — O(fileCount²), which measures header fan-out rather than file-count
* scaling. With constant fan-out the pipeline is O(fileCount); the deterministic
* node-ratio assertion below guards against reintroducing the O(n²) pattern.
*/
import { describe, it, expect } from 'vitest';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { runPipelineFromRepo } from '../../src/core/ingestion/pipeline.js';
const BENCH_ENABLED = process.env.GITNEXUS_BENCH === '1';
interface BenchResult {
fileCount: number;
headerCount: number;
methodCount: number;
elapsedMs: number;
peakHeapMB: number;
nodeCount: number;
edgeCount: number;
}
const METHODS_PER_CLASS = 4;
const HEADERS_PER_FILE = 3;
function generateCppFixture(fileCount: number): {
dir: string;
headerCount: number;
methodCount: number;
} {
const dir = fs.mkdtempSync(path.join(os.tmpdir(), `cpp-bench-${fileCount}-`));
// Shared headers (1 per 5 TUs, at least 2): each a small namespace with a
// struct and a free function the TUs call cross-file (constant fan-in).
const headerCount = Math.max(2, Math.floor(fileCount / 5));
const headerNames: string[] = [];
for (let h = 0; h < headerCount; h++) {
const ns = `hdr${h}`;
headerNames.push(ns);
fs.writeFileSync(
path.join(dir, `${ns}.h`),
[
`#pragma once`,
`namespace ${ns} {`,
`struct Rec${h} { int value; };`,
`void use${h}(Rec${h}& r);`,
`}`,
'',
].join('\n'),
);
}
const methodCount = fileCount * METHODS_PER_CLASS;
for (let f = 0; f < fileCount; f++) {
const className = `C${String(f).padStart(5, '0')}`;
// Constant include fan-out, chosen by index so headers stay shared.
const includes = [
...new Set(
Array.from({ length: HEADERS_PER_FILE }, (_, k) => headerNames[(f + k) % headerCount]),
),
];
const methods: string[] = [];
for (let m = 0; m < METHODS_PER_CLASS; m++) {
// Intra-file call (resolves locally) + one cross-file call into an
// included header's free function (constant cross-file fan-out).
const nextM = (m + 1) % METHODS_PER_CLASS;
const hdr = includes[m % includes.length];
const hdrIdx = hdr.replace('hdr', '');
methods.push(
` void m${m}() {`,
` m${nextM}();`,
` ${hdr}::Rec${hdrIdx} r;`,
` ${hdr}::use${hdrIdx}(r);`,
` }`,
);
}
const content = [
...includes.map((h) => `#include "${h}.h"`),
`class ${className} {`,
`public:`,
...methods,
`};`,
'',
].join('\n');
fs.writeFileSync(path.join(dir, `${className}.cpp`), content);
}
return { dir, headerCount, methodCount };
}
async function runBenchmark(fileCount: number, budgetMs: number): Promise<BenchResult> {
const { dir, headerCount, methodCount } = generateCppFixture(fileCount);
let peakHeapMB = 0;
const heapSampler = setInterval(() => {
const heap = process.memoryUsage().heapUsed / 1024 / 1024;
if (heap > peakHeapMB) peakHeapMB = heap;
}, 50);
try {
const start = Date.now();
const result = await Promise.race([
runPipelineFromRepo(dir, () => {}, { workerPoolSize: 1 }),
new Promise<never>((_, reject) =>
setTimeout(
() => reject(new Error(`Pipeline exceeded ${budgetMs}ms at ${fileCount} files`)),
budgetMs,
),
),
]);
const elapsedMs = Date.now() - start;
return {
fileCount,
headerCount,
methodCount,
elapsedMs,
peakHeapMB: Math.round(peakHeapMB),
nodeCount: result.graph.nodeCount,
edgeCount: result.graph.relationshipCount,
};
} finally {
clearInterval(heapSampler);
fs.rmSync(dir, { recursive: true, force: true });
}
}
function printResults(results: BenchResult[]) {
console.log('\nC++ Pipeline');
console.log('┌──────────┬──────────┬──────────┬───────────┬──────────┬───────┬───────┐');
console.log('│ Files │ Headers │ Methods │ Time (ms) │ Heap MB │ Nodes │ Edges │');
console.log('├──────────┼──────────┼──────────┼───────────┼──────────┼───────┼───────┤');
for (const r of results) {
console.log(
`│ ${String(r.fileCount).padStart(8)} │ ${String(r.headerCount).padStart(8)} │ ${String(r.methodCount).padStart(8)} │ ${String(r.elapsedMs).padStart(9)} │ ${String(r.peakHeapMB).padStart(8)} │ ${String(r.nodeCount).padStart(5)} │ ${String(r.edgeCount).padStart(5)} │`,
);
}
console.log('└──────────┴──────────┴──────────┴───────────┴──────────┴───────┴───────┘');
if (results.length >= 2) {
console.log('\nScaling ratios (time_ratio / file_ratio):');
for (let i = 1; i < results.length; i++) {
const fileRatio = results[i].fileCount / results[i - 1].fileCount;
const timeRatio = results[i].elapsedMs / results[i - 1].elapsedMs;
const scaling = timeRatio / fileRatio;
console.log(
` ${results[i - 1].fileCount} → ${results[i].fileCount}: ${scaling.toFixed(2)}x (${scaling < 1.5 ? 'linear' : scaling < 3 ? 'superlinear' : 'WARNING: quadratic'})`,
);
}
}
}
describe.skipIf(!BENCH_ENABLED)('C++ pipeline benchmark', () => {
it('scales with file count', async () => {
const scales = [50, 100, 200, 400];
const results: BenchResult[] = [];
for (const fileCount of scales) {
const result = await runBenchmark(fileCount, 300_000);
results.push(result);
console.log(
` ${fileCount} files: ${result.elapsedMs}ms, ${result.peakHeapMB}MB heap, ${result.nodeCount} nodes, ${result.edgeCount} edges`,
);
}
printResults(results);
for (let i = 1; i < results.length; i++) {
const fileRatio = results[i].fileCount / results[i - 1].fileCount;
const timeRatio = results[i].elapsedMs / results[i - 1].elapsedMs;
// Wall-clock is noisy (GC/CI load); keep a coarse upper bound here.
expect(timeRatio / fileRatio).toBeLessThan(4);
// Deterministic regression guard: with constant per-file include fan-out
// the emitted node count is linear in fileCount (ratio ≈ 1.0). If someone
// reintroduces O(fileCount²) work — e.g. by making every TU include all
// headers — node growth jumps and this fails. Node count is deterministic,
// so this is a non-flaky guard unlike the wall-clock check above.
const nodeRatio = results[i].nodeCount / results[i - 1].nodeCount;
expect(nodeRatio / fileRatio).toBeLessThan(1.3);
}
}, 600_000);
});