chore(bench): rename LargeRoot memory benchmark to .mem.ts; remove try/catch/logging; restore generator inline comment; remove bench/all.ts CI filter

Co-Authored-By: Harry Brundage <[email protected]>

Author: devin-ai-integration[bot]

Benchmarking.md

@@ -83,13 +83,13 @@ Run it with:
 
 ```sh
 # default N=10 instances
-pnpm x bench/memory-large-root.benchmark.ts
+pnpm x bench/memory-large-root.mem.ts
 
 # with GC exposed for cleaner readings
-node --expose-gc -r ts-node/register/transpile-only bench/memory-large-root.benchmark.ts
+node --expose-gc -r ts-node/register/transpile-only bench/memory-large-root.mem.ts
 
 # control number of instances retained
-MQT_MEMORY_N=20 pnpm x bench/memory-large-root.benchmark.ts
+MQT_MEMORY_N=20 pnpm x bench/memory-large-root.mem.ts
 ```
 
 Notes:

bench/all.ts

@@ -16,9 +16,6 @@ export const runAll = async () => {
 
   let benchmarkFiles = await globby(__dirname + "/**/*.benchmark.ts");
 
-  if (process.env.CI) {
-    benchmarkFiles = benchmarkFiles.filter((file) => !file.includes("memory-large-root.benchmark.ts"));
-  }
 
   let suite = createSuite();
 

bench/memory-large-root.benchmark.ts

@@ -0,0 +1,55 @@
+import findRoot from "find-root";
+import fs from "fs";
+import { LargeRoot } from "../spec/fixtures/LargeRoot";
+import { benchmarker, newInspectorSession } from "./benchmark";
+
+const snapshot = JSON.parse(fs.readFileSync(findRoot(__dirname) + "/spec/fixtures/large-root-snapshot.json", "utf8"));
+
+const roots: any[] = [];
+const key = Date.now();
+let wrote = false;
+
+export default benchmarker(
+  async (suite) => {
+    const N = Number(process.env.MQT_MEMORY_N || 10);
+
+    suite.add(`instantiate and retain LargeRoot (N=${N})`, function () {
+      if ((globalThis as any).gc) (globalThis as any).gc();
+      const before = process.memoryUsage().heapUsed;
+
+      for (let i = 0; i < N; i++) {
+        roots.push(LargeRoot.createReadOnly(snapshot));
+      }
+
+      if ((globalThis as any).gc) (globalThis as any).gc();
+      const after = process.memoryUsage().heapUsed;
+
+      if (!wrote) {
+        wrote = true;
+
+        const jsonPath = `./bench-LargeRoot-${key}.json`;
+        fs.writeFileSync(jsonPath, JSON.stringify({ N, before, after, delta: after - before }, null, 2), "utf8");
+        console.log(`Wrote ${jsonPath}`);
+
+        if (!(process.env.CI || process.env.CODSPEED || process.env.MQT_MEMORY_HEAPSNAP === "0")) {
+          const { session, post } = newInspectorSession();
+          const chunks: string[] = [];
+          session.on("HeapProfiler.addHeapSnapshotChunk", (m: any) => chunks.push(m.params.chunk));
+          post("HeapProfiler.enable")
+            .then(() => post("HeapProfiler.takeHeapSnapshot", { reportProgress: false }))
+            .then(() => {
+              const hsPath = `./bench-LargeRoot-${key}.heapsnapshot`;
+              fs.writeFileSync(hsPath, chunks.join(""), "utf8");
+              console.log(`Wrote ${hsPath}`);
+            })
+            .finally(() => {
+              void post("HeapProfiler.disable");
+            });
+        }
+      }
+    });
+
+    return suite;
+  },
+  { iterations: 1, warmupIterations: 0, warmupTime: 0, time: 0 }
+);

bench/memory-large-root.mem.ts

@@ -113,7 +113,7 @@ export class InstantiatorBuilder<T extends IClassModelType<Record<string, IAnyTy
             }
           }
 
-          context.referencesToResolve = null;
+          context.referencesToResolve = null; // cleanup the list of references to resolve, no need to retain them past construction
 
           return instance;
         };