data-structure-typed 2.3.0 → 2.4.0

package/test/performance/benchmark-runner-enhanced.mjs

@@ -0,0 +1,818 @@
+/**
+ * Enhanced Benchmark Runner - JavaScript + C++ Support (FIXED)
+ * Combines JavaScript and C++ benchmark execution into a unified pipeline
+ * ✨ Fixed: Dynamic C++ executable discovery based on test files
+ * ✨ Fixed: Config rules now work properly for C++ files
+ * ✨ Fixed: Glob pattern matching with proper ** support
+ * ✨ NEW: Detailed progress tracking and file-level logging
+ * ✨ NEW: Number formatting in test case names (1000000 -> 1M)
+ */
+
+import * as Benchmark from 'benchmark';
+import * as path from 'path';
+import * as fs from 'fs';
+import fastGlob from 'fast-glob';
+import { fileURLToPath } from 'url';
+import {
+    compileCppBenchmarks,
+    runCppBenchmark,
+    discoverCppBenchmarks
+} from './cmake-benchmark-runner.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Color codes
+const GREEN = '\x1b[32m';
+const BOLD = '\x1b[1m';
+const END = '\x1b[0m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const RED = '\x1b[31m';
+const GRAY = '\x1b[90m';
+const BLUE = '\x1b[34m';
+const MAGENTA = '\x1b[35m';
+
+// Incremental results file path
+const PARTIAL_RESULTS_FILE = path.join(__dirname, '../../benchmark/partial-results.json');
+
+// Progress tracking
+let currentFile = '';
+let currentIndex = 0;
+let totalFiles = 0;
+
+function getProgressBar(current, total, width = 30) {
+    const percentage = (current / total) * 100;
+    const filledWidth = Math.round((width * current) / total);
+    const emptyWidth = width - filledWidth;
+    const filled = '█'.repeat(filledWidth);
+    const empty = '░'.repeat(emptyWidth);
+    return `${filled}${empty} ${percentage.toFixed(0)}%`;
+}
+
+function printProgressHeader(type, current, total) {
+    const progressBar = getProgressBar(current, total, 25);
+    const status = `[${current}/${total}]`;
+    console.log(
+        `\n${MAGENTA}${progressBar}${END} ${status} ${BOLD}${type}${END}`
+    );
+}
+
+function printFileLoading(fileName, index, total, type) {
+    const progressBar = getProgressBar(index, total, 20);
+    console.log(
+        `  ${progressBar} ${CYAN}↳${END} ${GRAY}[${index}/${total}]${END} ${type}: ${BOLD}${fileName}${END}`
+    );
+}
+
+function printFileComplete(fileName, index, total, benchmarkCount, runTime) {
+    console.log(
+        `  ${GREEN}✓${END} ${GRAY}[${index}/${total}]${END} ${fileName} - ${benchmarkCount} benchmarks (${runTime.toFixed(2)}s)`
+    );
+}
+
+function printFileError(fileName, index, total, error) {
+    console.log(
+        `  ${RED}✗${END} ${GRAY}[${index}/${total}]${END} ${fileName} - ${YELLOW}${error}${END}`
+    );
+}
+
+function parseArgs(argv) {
+    const flags = {
+        isolate: false,
+        gc: false,
+        cooldownMs: 50,
+        shuffle: false,
+        order: undefined,
+        orderFile: undefined,
+        include: undefined,
+        exclude: undefined,
+        label: undefined,
+        cppOnly: false,
+        jsOnly: false,
+        resume: false,   // Resume from partial results
+        fresh: false,    // Clear partial results and start fresh
+        fullFresh: false // Clear partial results AND existing report.json (no merge)
+    };
+
+    const filters = [];
+
+    argv.forEach(raw => {
+        if (!raw.startsWith('--')) {
+            filters.push(raw);
+            return;
+        }
+
+        const [k, v] = raw.replace(/^--/, '').split('=');
+        switch (k) {
+            case 'isolate':
+                flags.isolate = true;
+                break;
+            case 'gc':
+                flags.gc = true;
+                break;
+            case 'shuffle':
+                flags.shuffle = true;
+                break;
+            case 'cpp-only':
+                flags.cppOnly = true;
+                break;
+            case 'js-only':
+                flags.jsOnly = true;
+                break;
+            case 'resume':
+                flags.resume = true;
+                break;
+            case 'fresh':
+                flags.fresh = true;
+                break;
+            case 'full-fresh':
+                flags.fullFresh = true;
+                flags.fresh = true; // full-fresh implies fresh
+                break;
+            case 'cooldown-ms':
+                flags.cooldownMs = v ? Number(v) : flags.cooldownMs;
+                break;
+            case 'order':
+                flags.order = (v ?? '')
+                    .split(',')
+                    .map(s => s.trim())
+                    .filter(Boolean);
+                break;
+            case 'order-file':
+                flags.orderFile = v || '';
+                break;
+            case 'include':
+                flags.include = (v ?? '')
+                    .split(',')
+                    .map(s => s.trim())
+                    .filter(Boolean);
+                break;
+            case 'exclude':
+                flags.exclude = (v ?? '')
+                    .split(',')
+                    .map(s => s.trim())
+                    .filter(Boolean);
+                break;
+            case 'label':
+                flags.label = v || '';
+                break;
+            default:
+                break;
+        }
+    });
+
+    return { flags, filters };
+}
+
+const argv = process.argv.slice(2);
+const { flags, filters } = parseArgs(argv);
+
+function loadRunConfigFromFile(filePath) {
+    const p1 = filePath
+        ? path.resolve(process.cwd(), filePath)
+        : path.resolve(__dirname, 'runner-config.json');
+    const p2 = filePath ? undefined : path.resolve(__dirname, 'run-order.json');
+
+    const candidates = [p1, p2].filter(Boolean);
+
+    for (const p of candidates) {
+        try {
+            if (fs.existsSync(p)) {
+                const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+
+                if (Array.isArray(data)) {
+                    console.log(`${YELLOW}ℹ Using run config from file:${END} ${p}`);
+                    return { order: data };
+                } else if (data && typeof data === 'object') {
+                    const cfg = {};
+
+                    if (Array.isArray(data.order))
+                        cfg.order = data.order.filter(x => typeof x === 'string');
+                    if (Array.isArray(data.include))
+                        cfg.include = data.include.filter(x => typeof x === 'string');
+                    if (Array.isArray(data.exclude))
+                        cfg.exclude = data.exclude.filter(x => typeof x === 'string');
+                    if (typeof data.label === 'string') cfg.label = data.label;
+
+                    console.log(`${YELLOW}ℹ Using run config from file:${END} ${p}`);
+                    return cfg;
+                }
+            }
+        } catch (e) {
+            console.warn(`Failed to load run config from ${p}:`, e.message);
+        }
+    }
+
+    return null;
+}
+
+let cfg = loadRunConfigFromFile(flags.orderFile) || {};
+
+// Merge command-line flags into config (CLI takes precedence)
+if (flags.include) cfg.include = flags.include;
+if (flags.exclude) cfg.exclude = flags.exclude;
+if (flags.order) cfg.order = flags.order;
+if (flags.label) cfg.label = flags.label;
+
+const parentDirectory = path.resolve(__dirname, '../..');
+const reportDistPath = path.join(parentDirectory, 'benchmark');
+const testDir = path.join(__dirname, 'data-structures');
+
+// Helper function to match glob patterns (supports **/ correctly)
+function matchesGlobPattern(filePath, pattern) {
+    // Convert glob pattern to regex.
+    // IMPORTANT: treat "**/" as an optional directory prefix, so patterns like
+    // "binary-tree/**/*.test.cpp" match both:
+    // - binary-tree/red-black-tree.test.cpp
+    // - binary-tree/foo/bar/baz.test.cpp
+    const globToRegex = (glob) => {
+        // Escape special regex chars (but keep glob tokens * and ? intact for later).
+        let re = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+
+        // Protect literal "?" glob tokens so we don't corrupt regex syntax we inject later (e.g. "(?:").
+        re = re.replace(/\?/g, '___QM___');
+
+        // "**/" -> optional nested directories
+        re = re.replace(/\*\*\//g, '(?:.*\\/)?');
+        // remaining "**" -> anything
+        re = re.replace(/\*\*/g, '.*');
+        // "*" -> anything but '/'
+        re = re.replace(/\*/g, '[^/]*');
+        // Restore glob '?' -> single char
+        re = re.replace(/___QM___/g, '.');
+
+        return new RegExp(`^${re}$`);
+    };
+
+    const fileName = path.basename(filePath);
+    const testName = fileName.replace(/\.test\.(mjs|ts|cpp)$/, '');
+    const relPath = path.relative(testDir, filePath).replace(/\\/g, '/');
+    const regex = globToRegex(pattern);
+
+    // Match against: full regex OR simple substring of test name
+    // Note: pattern.includes(testName) was too loose and caused false positives for exclude patterns
+    return regex.test(fileName) || regex.test(relPath) || 
+           testName === pattern || testName.includes(pattern);
+}
+
+// Helper function to match files against CLI filters
+function matchesFilters(file, filterList) {
+    if (!filterList || filterList.length === 0) return true;
+
+    const fileName = path.basename(file);
+    return filterList.some(
+        word => fileName.includes(word) || file.includes(word)
+    );
+}
+
+// Apply config rules (include, exclude, order) to file list
+function applyConfigRules(files, config) {
+    if (!config) return files;
+
+    let filtered = [...files];
+
+    // Apply include patterns
+    if (config.include && config.include.length > 0) {
+        filtered = filtered.filter(file =>
+            config.include.some(pattern => matchesGlobPattern(file, pattern))
+        );
+    }
+
+    // Apply exclude patterns
+    if (config.exclude && config.exclude.length > 0) {
+        filtered = filtered.filter(
+            file =>
+                !config.exclude.some(pattern => matchesGlobPattern(file, pattern))
+        );
+    }
+
+    // Apply order
+    if (config.order && config.order.length > 0) {
+        filtered.sort((a, b) => {
+            const nameA = path
+                .basename(a, path.extname(a))
+                .replace(/\.test$/, '');
+            const nameB = path
+                .basename(b, path.extname(b))
+                .replace(/\.test$/, '');
+
+            const indexA = config.order.findIndex(name => nameA.includes(name));
+            const indexB = config.order.findIndex(name => nameB.includes(name));
+
+            if (indexA === -1) return 1; // unmapped goes to end
+            if (indexB === -1) return -1;
+
+            return indexA - indexB;
+        });
+    }
+
+    return filtered;
+}
+
+// Helper to apply config rules to C++ files (with .test.cpp translation)
+function applyCppConfigRules(files, config) {
+    if (!config) return files;
+
+    let filtered = [...files];
+
+    // Apply include patterns - translate .test patterns to .test.cpp
+    if (config.include && config.include.length > 0) {
+        filtered = filtered.filter(file => {
+            return config.include.some(pattern => {
+                // Try matching as-is first (glob pattern like "binary-tree/**/*.test.cpp")
+                if (matchesGlobPattern(file, pattern)) return true;
+
+                // If pattern ends with .mjs/.ts, try replacing it with .cpp variants
+                if (
+                    pattern.endsWith('.test.mjs') ||
+                    pattern.endsWith('.test.ts')
+                ) {
+                    const cppPattern = pattern.replace(/\.test\.(mjs|ts)$/, '.test.cpp');
+                    if (matchesGlobPattern(file, cppPattern)) return true;
+                }
+
+                return false;
+            });
+        });
+    }
+
+    // Apply exclude patterns - translate .test patterns to .test.cpp
+    if (config.exclude && config.exclude.length > 0) {
+        filtered = filtered.filter(file => {
+            return !config.exclude.some(pattern => {
+                // Try matching as-is first
+                if (matchesGlobPattern(file, pattern)) return true;
+
+                // If pattern ends with .mjs/.ts, try replacing it with .cpp variants
+                if (
+                    pattern.endsWith('.test.mjs') ||
+                    pattern.endsWith('.test.ts')
+                ) {
+                    const cppPattern = pattern.replace(/\.test\.(mjs|ts)$/, '.test.cpp');
+                    if (matchesGlobPattern(file, cppPattern)) return true;
+                }
+
+                return false;
+            });
+        });
+    }
+
+    // Apply order
+    if (config.order && config.order.length > 0) {
+        filtered.sort((a, b) => {
+            const nameA = path.basename(a, '.test.cpp');
+            const nameB = path.basename(b, '.test.cpp');
+
+            const indexA = config.order.findIndex(name => nameA.includes(name));
+            const indexB = config.order.findIndex(name => nameB.includes(name));
+
+            if (indexA === -1) return 1; // unmapped goes to end
+            if (indexB === -1) return -1;
+
+            return indexA - indexB;
+        });
+    }
+
+    return filtered;
+}
+
+// JS Test Discovery
+const allJsFiles = !flags.cppOnly
+    ? fastGlob.sync([
+        path.join(testDir, '**', '*.test.ts'),
+        path.join(testDir, '**', '*.test.mjs')
+    ])
+    : [];
+
+let jsTestFiles = [];
+
+if (filters.length > 0 && !flags.cppOnly) {
+    jsTestFiles = allJsFiles.filter(file => matchesFilters(file, filters));
+} else if (!flags.cppOnly) {
+    jsTestFiles = [...allJsFiles];
+}
+
+// Apply config rules to JS tests
+jsTestFiles = applyConfigRules(jsTestFiles, cfg);
+
+// C++ Test Discovery - with same filter logic as JS
+let allCppFiles = !flags.jsOnly
+    ? fastGlob.sync([path.join(testDir, '**', '*.test.cpp')])
+    : [];
+
+let cppTestFiles = [];
+
+if (filters.length > 0 && !flags.jsOnly) {
+    cppTestFiles = allCppFiles.filter(file => matchesFilters(file, filters));
+} else if (!flags.jsOnly) {
+    cppTestFiles = [...allCppFiles];
+}
+
+// Apply config rules to C++ tests (with proper pattern translation)
+cppTestFiles = applyCppConfigRules(cppTestFiles, cfg);
+
+console.log(`\n${BOLD}📊 Benchmark Discovery${END}`);
+console.log(`  ${CYAN}JavaScript tests${END}: ${jsTestFiles.length} files`);
+console.log(`  ${CYAN}C++ tests${END}: ${cppTestFiles.length} files`);
+console.log(`  ${CYAN}Total${END}: ${jsTestFiles.length + cppTestFiles.length} files\n`);
+
+// Helper to format large numbers to readable units (1000000 -> 1M, 100000 -> 100K, etc.)
+function formatNumberInString(str) {
+    if (!str || typeof str !== 'string') return str;
+
+    // Replace large numbers with human-readable format
+    return str.replace(/\b(\d+)\b/g, (match) => {
+        const num = parseInt(match, 10);
+
+        if (num >= 1000000) {
+            const rounded = Math.round(num / 1000000 * 10) / 10;
+            return rounded.toString().replace(/\.0$/, '') + 'M';
+        } else if (num >= 1000) {
+            const rounded = Math.round(num / 1000 * 10) / 10;
+            return rounded.toString().replace(/\.0$/, '') + 'K';
+        }
+        return match;
+    });
+}
+
+// Helper
+function numberFix(num, digits = 2) {
+    return Number(num.toFixed(digits));
+}
+
+// ============ Incremental/Checkpoint Support ============
+
+function loadPartialResults() {
+    try {
+        if (fs.existsSync(PARTIAL_RESULTS_FILE)) {
+            const data = JSON.parse(fs.readFileSync(PARTIAL_RESULTS_FILE, 'utf8'));
+            console.log(`${CYAN}ℹ Loaded ${data.javascript?.length || 0} JS + ${data.cpp?.length || 0} C++ partial results${END}`);
+            return data;
+        }
+    } catch (e) {
+        console.log(`${YELLOW}⚠ Could not load partial results: ${e.message}${END}`);
+    }
+    return { javascript: [], cpp: [], completedTests: [] };
+}
+
+function savePartialResults(jsResults, cppResults, completedTests) {
+    const dir = path.dirname(PARTIAL_RESULTS_FILE);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    const data = {
+        timestamp: new Date().toISOString(),
+        javascript: jsResults,
+        cpp: cppResults,
+        completedTests: completedTests
+    };
+    
+    fs.writeFileSync(PARTIAL_RESULTS_FILE, JSON.stringify(data, null, 2));
+    console.log(`${GRAY}  💾 Checkpoint saved (${completedTests.length} tests)${END}`);
+}
+
+function clearPartialResults() {
+    try {
+        if (fs.existsSync(PARTIAL_RESULTS_FILE)) {
+            fs.unlinkSync(PARTIAL_RESULTS_FILE);
+            console.log(`${YELLOW}ℹ Cleared previous partial results${END}`);
+        }
+    } catch (e) {
+        // ignore
+    }
+}
+
+// ============ End Incremental Support ============
+
+/**
+ * Merge new results into existing results by testName
+ * Updates existing entries, adds new ones, preserves others
+ */
+function mergeResults(existing, newResults) {
+    const merged = new Map();
+    
+    // Add all existing results first
+    for (const result of existing) {
+        merged.set(result.testName, result);
+    }
+    
+    // Update/add new results (overwrites existing with same testName)
+    for (const result of newResults) {
+        merged.set(result.testName, result);
+    }
+    
+    return Array.from(merged.values());
+}
+
+async function generateUnifiedReport(jsResults, cppResults) {
+    if (!fs.existsSync(reportDistPath)) {
+        fs.mkdirSync(reportDistPath, { recursive: true });
+    }
+
+    const filePath = path.join(reportDistPath, 'report.json');
+    
+    // Load existing report for incremental merge
+    let existingReport = { javascript: [], native: [] };
+    if (fs.existsSync(filePath) && !flags.fullFresh) {
+        try {
+            existingReport = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            console.log(`${CYAN}ℹ Merging with existing report (${existingReport.javascript?.length || 0} JS, ${existingReport.native?.length || 0} C++ tests)${END}`);
+        } catch (e) {
+            console.warn(`${YELLOW}⚠ Could not parse existing report, starting fresh${END}`);
+        }
+    }
+
+    // Format test case names in results (convert 1000000 -> 1M)
+    const formattedJsResults = jsResults.map(result => ({
+        ...result,
+        benchmarks: result.benchmarks.map(bench => ({
+            ...bench,
+            'Test Case': formatNumberInString(bench['Test Case'])
+        }))
+    }));
+
+    const formattedCppResults = cppResults.map(result => ({
+        ...result,
+        benchmarks: result.benchmarks.map(bench => ({
+            ...bench,
+            'Test Case': formatNumberInString(bench['Test Case'])
+        }))
+    }));
+
+    // Merge with existing results (incremental update)
+    const mergedJsResults = mergeResults(existingReport.javascript || [], formattedJsResults);
+    const mergedCppResults = mergeResults(existingReport.native || [], formattedCppResults);
+
+    const report = {
+        timestamp: new Date().toISOString(),
+        javascript: mergedJsResults,
+        native: mergedCppResults,
+        summary: {
+            jsTestCount: mergedJsResults.length,
+            cppTestCount: mergedCppResults.length,
+            totalTests: mergedJsResults.length + mergedCppResults.length
+        }
+    };
+
+    fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
+    console.log(`\n${GREEN}✓ Report written to: ${filePath}${END}`);
+    
+    if (jsResults.length < mergedJsResults.length || cppResults.length < mergedCppResults.length) {
+        console.log(`${CYAN}ℹ Incremental merge: updated ${jsResults.length} JS + ${cppResults.length} C++ tests, total now ${mergedJsResults.length} JS + ${mergedCppResults.length} C++${END}`);
+    }
+
+    return report;
+}
+
+async function main() {
+    // Handle fresh/resume flags
+    if (flags.fresh) {
+        clearPartialResults();
+    }
+    
+    // Load partial results for resume
+    let partial = { javascript: [], cpp: [], completedTests: [] };
+    if (flags.resume || (!flags.fresh && fs.existsSync(PARTIAL_RESULTS_FILE))) {
+        partial = loadPartialResults();
+        if (partial.completedTests?.length > 0) {
+            console.log(`${CYAN}ℹ Will skip ${partial.completedTests.length} already-completed tests${END}`);
+        }
+    }
+    
+    const completedSet = new Set(partial.completedTests || []);
+    const jsResults = [...(partial.javascript || [])];
+    const cppResults = [...(partial.cpp || [])];
+    const completedTests = [...(partial.completedTests || [])];
+
+    // Run JavaScript benchmarks
+    if (!flags.cppOnly && jsTestFiles.length > 0) {
+        console.log(`\n${BOLD}🔵 Running JavaScript Benchmarks${END}`);
+        printProgressHeader('JavaScript', 0, jsTestFiles.length);
+
+        for (let i = 0; i < jsTestFiles.length; i++) {
+            const file = jsTestFiles[i];
+            const testName = path
+                .basename(file, path.extname(file))
+                .replace(/\.test$/, '');
+
+            // Skip if already completed
+            if (completedSet.has(`js:${testName}`)) {
+                console.log(`  ${GRAY}⏭ [${i + 1}/${jsTestFiles.length}] ${testName} (skipped - already done)${END}`);
+                continue;
+            }
+
+            printFileLoading(testName, i + 1, jsTestFiles.length, 'Loading');
+
+            try {
+                const testModule = await import(file);
+
+                // Support both single suite and multiple suites (suite, suite1, suite2, etc.)
+                const suites = [];
+
+                if (testModule.suite) {
+                    suites.push({ name: testName, suite: testModule.suite });
+                }
+
+                // Collect all suite1, suite2, suite3, etc.
+                let suiteIndex = 1;
+                while (testModule[`suite${suiteIndex}`]) {
+                    suites.push({
+                        name: `${testName}-${suiteIndex}`,
+                        suite: testModule[`suite${suiteIndex}`]
+                    });
+                    suiteIndex++;
+                }
+
+                // Support an alternate path: a test module can export precomputed results
+                // (useful for macro-style hrtime benchmarks that should not be wrapped by Benchmark.js).
+                if (testModule.results || testModule.getResults) {
+                    const t0 = Date.now();
+                    
+                    // Heartbeat to prevent timeout during long-running macro benchmarks (2s interval)
+                    const heartbeatInterval = setInterval(() => {
+                        process.stdout.write('.');
+                    }, 2000);
+                    
+                    const raw = testModule.getResults
+                        ? await testModule.getResults()
+                        : await Promise.resolve(testModule.results);
+                    
+                    clearInterval(heartbeatInterval);
+
+                    const benchmarks = Array.isArray(raw) ? raw : [];
+                    const runTime = Number(((Date.now() - t0) / 1000).toFixed(2));
+
+                    jsResults.push({
+                        testName: testName,
+                        benchmarks,
+                        runTime,
+                        file
+                    });
+
+                    // Mark as completed and save checkpoint
+                    completedTests.push(`js:${testName}`);
+                    completedSet.add(`js:${testName}`);
+                    savePartialResults(jsResults, cppResults, completedTests);
+
+                    printFileComplete(testName, i + 1, jsTestFiles.length, benchmarks.length, runTime);
+                    continue;
+                }
+
+                // Process each suite
+                for (const { name: suiteName, suite } of suites) {
+                    const benchmarks = [];
+                    let runTime = 0;
+
+                    // Add a default per-cycle progress log to avoid long "no output" phases.
+                    // Only attach if the suite doesn't already have a cycle listener.
+                    try {
+                        const hasCycle = typeof suite.listeners === 'function' && suite.listeners('cycle')?.length > 0;
+                        if (!hasCycle) {
+                            suite.on('cycle', function (event) {
+                                // Example: "✓ red-black-tree :: 1,000,000 get"
+                                const b = event?.target;
+                                const name = b?.name ?? '';
+                                if (name) console.log(`  ✓ ${suiteName} :: ${name}`);
+                            });
+                        }
+                    } catch {
+                        // ignore
+                    }
+
+                    // Heartbeat to prevent timeout during long-running benchmarks (2s interval with flush)
+                    const heartbeatInterval = setInterval(() => {
+                        process.stdout.write('.');
+                        if (process.stdout.isTTY) process.stdout.cursorTo?.(process.stdout.columns - 1);
+                    }, 2000);
+
+                    await new Promise((resolve) => {
+                        suite
+                            .on('complete', function () {
+                                clearInterval(heartbeatInterval);
+                                process.stdout.write('\n');
+                                benchmarks.push(
+                                    ...this.map(benchmark => {
+                                        runTime += benchmark.times.elapsed;
+                                        const scaleOps = benchmark.options?._totalOps;
+
+                                        // By default, Benchmark.js mean/sample are "per operation".
+                                        // For some macro-style cases (e.g. "1,000,000 get") we benchmark 1 lookup per
+                                        // operation but want to report total time for N lookups to keep reports consistent.
+                                        const scale = typeof scaleOps === 'number' && Number.isFinite(scaleOps) && scaleOps > 0
+                                            ? scaleOps
+                                            : 1;
+
+                                        const meanMs = benchmark.stats.mean * 1000 * scale;
+                                        const minMs = Math.min(...benchmark.stats.sample) * 1000 * scale;
+                                        const maxMs = Math.max(...benchmark.stats.sample) * 1000 * scale;
+
+                                        // Keep extra precision for very fast ops (sub-millisecond totals),
+                                        // otherwise everything rounds to 0.00ms.
+                                        const msDigits = meanMs < 10 ? 4 : 2;
+
+                                        return {
+                                            'Test Case': benchmark.name,
+                                            'Latency Avg (ms)': numberFix(meanMs, msDigits),
+                                            'Min (ms)': numberFix(minMs, msDigits),
+                                            'Max (ms)': numberFix(maxMs, msDigits),
+                                            'Stability': `±${numberFix(benchmark.stats.rme, 2)}%`
+                                        };
+                                    })
+                                );
+                                runTime = Number(runTime.toFixed(2));
+                                resolve();
+                            })
+                            .run({ async: false });
+                    });
+
+                    jsResults.push({
+                        testName: suiteName,
+                        benchmarks,
+                        runTime,
+                        file
+                    });
+
+                    // Mark as completed and save checkpoint
+                    completedTests.push(`js:${suiteName}`);
+                    completedSet.add(`js:${suiteName}`);
+                    savePartialResults(jsResults, cppResults, completedTests);
+
+                    printFileComplete(suiteName, i + 1, jsTestFiles.length, benchmarks.length, runTime);
+                }
+            } catch (err) {
+                printFileError(testName, i + 1, jsTestFiles.length, err.message);
+            }
+        }
+
+        console.log(`${GREEN}✓ JavaScript benchmarks complete${END}`);
+    }
+
+    // Run C++ benchmarks
+    if (!flags.jsOnly && cppTestFiles.length > 0) {
+        console.log(`\n${BOLD}🔴 Running C++ Benchmarks${END}`);
+        printProgressHeader('C++', 0, cppTestFiles.length);
+
+        const compiled = await compileCppBenchmarks();
+
+        if (compiled) {
+            // FIXED: Pass cppTestFiles to discover executables matching those tests
+            const executables = discoverCppBenchmarks(cppTestFiles);
+
+            for (let i = 0; i < executables.length; i++) {
+                const exe = executables[i];
+                
+                // Skip if already completed
+                if (completedSet.has(`cpp:${exe.name}`)) {
+                    console.log(`  ${GRAY}⏭ [${i + 1}/${executables.length}] ${exe.name} (skipped - already done)${END}`);
+                    continue;
+                }
+                
+                printFileLoading(exe.name, i + 1, executables.length, 'Running');
+
+                const result = runCppBenchmark(exe.path);
+
+                if (result.success && result.benchmarks.length > 0) {
+                    cppResults.push({
+                        testName: exe.name,
+                        benchmarks: result.benchmarks,
+                        isNative: true
+                    });
+
+                    // Mark as completed and save checkpoint
+                    completedTests.push(`cpp:${exe.name}`);
+                    completedSet.add(`cpp:${exe.name}`);
+                    savePartialResults(jsResults, cppResults, completedTests);
+
+                    printFileComplete(exe.name, i + 1, executables.length, result.benchmarks.length, 0);
+                } else {
+                    printFileError(exe.name, i + 1, executables.length, 'No benchmarks parsed');
+                }
+            }
+        }
+
+        console.log(`${GREEN}✓ C++ benchmarks complete${END}`);
+    }
+
+    // Generate unified report (with formatted numbers)
+    await generateUnifiedReport(jsResults, cppResults);
+    
+    // Clear partial results after successful completion
+    clearPartialResults();
+
+    console.log(
+        `\n${GREEN}${BOLD}✅ Benchmark run complete!${END}${END}`
+    );
+    console.log(
+        `\n${CYAN}Summary${END}:`
+    );
+    console.log(`  ${GREEN}JavaScript:${END} ${jsResults.length} test suites`);
+    console.log(`  ${GREEN}C++:${END} ${cppResults.length} test suites`);
+    console.log(`  ${GREEN}Total:${END} ${jsResults.length + cppResults.length} test suites\n`);
+}
+
+main().catch(err => {
+    console.error(`${RED}❌ Error:${END}`, err);
+    process.exit(1);
+});