data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,234 +0,0 @@
-/**
- * C++ Benchmark Runner
- * Compiles and runs C++ benchmark tests using Google Benchmark
- * Output format matches JavaScript benchmark results for unified reporting
- */
-
-import { execSync, spawnSync } from 'child_process';
-import * as path from 'path';
-import * as fs from 'fs';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Color codes
-const YELLOW = '\x1b[33m';
-const END = '\x1b[0m';
-const CYAN = '\x1b[36m';
-const RED = '\x1b[31m';
-const GREEN = '\x1b[32m';
-
-// Find CMakeLists.txt by searching up the directory tree
-function findCMakeRoot() {
-    let currentDir = __dirname;
-
-    // Search up to 5 levels
-    for (let i = 0; i < 5; i++) {
-        const cmakePath = path.join(currentDir, 'CMakeLists.txt');
-        if (fs.existsSync(cmakePath)) {
-            return currentDir;
-        }
-
-        const parentDir = path.dirname(currentDir);
-        if (parentDir === currentDir) {
-            // Reached filesystem root
-            break;
-        }
-        currentDir = parentDir;
-    }
-
-    // Default to 2 levels up (parent directory)
-    return path.resolve(__dirname, '../..');
-}
-
-const parentDirectory = findCMakeRoot();
-const BUILD_DIR = path.join(parentDirectory, 'build');
-
-export async function compileCppBenchmarks() {
-    try {
-        console.log(`${YELLOW}Compiling C++ benchmarks...${END}`);
-
-        if (!fs.existsSync(BUILD_DIR)) {
-            fs.mkdirSync(BUILD_DIR, { recursive: true });
-        }
-
-        execSync(`cmake ${parentDirectory}`, {
-            cwd: BUILD_DIR,
-            stdio: 'inherit'
-        });
-
-        execSync('cmake --build . --config Release', {
-            cwd: BUILD_DIR,
-            stdio: 'inherit'
-        });
-
-        console.log(`${GREEN}✓ C++ compilation successful${END}`);
-        return true;
-    } catch (error) {
-        console.error(`${RED}✗ C++ compilation failed${END}`, error.message);
-        return false;
-    }
-}
-
-export function runCppBenchmark(executablePath) {
-    try {
-        const result = spawnSync(executablePath, [], {
-            encoding: 'utf-8',
-            maxBuffer: 10 * 1024 * 1024
-        });
-
-        if (result.error) {
-            throw result.error;
-        }
-
-        const output = result.stdout || result.stderr;
-        const benchmarks = [];
-        const lines = output.split('\n');
-
-        for (const line of lines) {
-            // Skip empty lines and headers
-            if (!line.trim() || line.includes('Benchmark') || line.includes('---') ||
-                line.includes('Time') || line.includes('CPU') || line.includes('Load') ||
-                line.includes('WARNING') || line.includes('Run on') || line.includes('Caches')) {
-                continue;
-            }
-
-            // Parse Google Benchmark output format
-            // Pattern: "1,000,000 set 171506443 ns 171266200 ns 5"
-            // Also handles decimal numbers like "8.93 ms"
-            const match = line.match(
-                /^(.+?)\s+([\d.]+)\s+(ns|us|ms|s)\s+([\d.]+)\s+(ns|us|ms|s)\s+(\d+)\s*$/
-            );
-
-            if (match) {
-                const [, benchmarkName, timeValue, timeUnit, cpuValue, cpuUnit, iterations] = match;
-
-                // Convert to milliseconds
-                let timeMs = parseFloat(timeValue);
-                switch (timeUnit) {
-                    case 'ns':
-                        timeMs = timeMs / 1000000; // nanoseconds to milliseconds
-                        break;
-                    case 'us':
-                        timeMs = timeMs / 1000; // microseconds to milliseconds
-                        break;
-                    case 's':
-                        timeMs = timeMs * 1000; // seconds to milliseconds
-                        break;
-                    case 'ms':
-                        // already in milliseconds
-                        break;
-                }
-
-                benchmarks.push({
-                    'Test Case': benchmarkName.trim(),
-                    'Latency Avg (ms)': Number(timeMs.toFixed(2)),
-                    'Min (ms)': Number((timeMs * 0.95).toFixed(2)),
-                    'Max (ms)': Number((timeMs * 1.05).toFixed(2)),
-                    'Stability': '±2.50%'
-                });
-            }
-        }
-
-        return {
-            success: true,
-            benchmarks,
-            output
-        };
-    } catch (error) {
-        return {
-            success: false,
-            error: error.message,
-            benchmarks: []
-        };
-    }
-}
-
-/**
- * Discover C++ benchmark executables
- * @param {string[]} testFiles - Array of .test.cpp file paths to generate executable names
- * @returns {Array} Array of {name, path} objects for discovered executables
- */
-export function discoverCppBenchmarks(testFiles = []) {
-    const executables = [];
-    const binDir = path.join(BUILD_DIR, 'bin');
-
-    // If specific test files provided, generate executable names from them
-    if (testFiles && testFiles.length > 0) {
-        for (const testFile of testFiles) {
-            const testName = path.basename(testFile, '.test.cpp');
-            // Try common naming patterns: name-benchmark, name_benchmark, name
-            const patterns = [
-                `${testName}-benchmark`,
-                `${testName}_benchmark`,
-                testName
-            ];
-
-            for (const pattern of patterns) {
-                const exePath = path.join(binDir, pattern);
-                if (fs.existsSync(exePath)) {
-                    executables.push({
-                        name: testName,
-                        path: exePath
-                    });
-                    break;
-                }
-            }
-        }
-    } else {
-        // Fallback: scan directory for any executable with 'benchmark' in name
-        try {
-            if (!fs.existsSync(binDir)) {
-                return [];
-            }
-
-            const files = fs.readdirSync(binDir);
-            for (const file of files) {
-                const exePath = path.join(binDir, file);
-                const stat = fs.statSync(exePath);
-                // Look for executables (not directories)
-                if (stat.isFile() && (file.includes('benchmark') || file.includes('_test'))) {
-                    const name = file.replace(/-benchmark$/, '').replace(/_benchmark$/, '');
-                    executables.push({
-                        name: name,
-                        path: exePath
-                    });
-                }
-            }
-        } catch (e) {
-            console.warn(`Failed to scan bin directory: ${e.message}`);
-        }
-    }
-
-    return executables;
-}
-
-export async function runAllCppBenchmarks() {
-    const compiled = await compileCppBenchmarks();
-    if (!compiled) {
-        return [];
-    }
-
-    const executables = discoverCppBenchmarks();
-    const results = [];
-
-    for (const exe of executables) {
-        console.log(
-            `\n${CYAN}Running C++ benchmark: ${exe.name}${END}`
-        );
-        const result = runCppBenchmark(exe.path);
-        if (result.success && result.benchmarks.length > 0) {
-            results.push({
-                testName: exe.name,
-                benchmarks: result.benchmarks,
-                isNative: true
-            });
-            console.log(`${GREEN}✓ ${result.benchmarks.length} benchmarks collected${END}`);
-        } else {
-            console.warn(`${YELLOW}⚠ No benchmarks parsed from ${exe.name}${END}`);
-        }
-    }
-
-    return results;
-}

package/test/performance/data-structures/binary-tree/avl-rb-range-search.test.cpp

@@ -1,112 +0,0 @@
-#include <benchmark/benchmark.h>
-#include <set>
-#include <random>
-#include <vector>
-
-const int MILLION = 1000000;
-const int HUNDRED_THOUSAND = 100000;
-
-// Global random number generator
-std::mt19937 gen(std::random_device{}());
-std::uniform_int_distribution<> dis(0, MILLION - 1);
-
-// Generate random array
-std::vector<int> generateRandomArray(int size) {
-  std::vector<int> arr;
-  arr.reserve(size);
-  for (int i = 0; i < size; i++) {
-    arr.push_back(dis(gen));
-  }
-  return arr;
-}
-
-static const auto randomArray = generateRandomArray(MILLION);
-
-// Pre-built trees
-static std::set<int> avlTree100K;
-static std::set<int> rbTree1M;
-static bool treesInitialized = false;
-
-void initializeTrees() {
-  if (!treesInitialized) {
-    // Build 100K tree
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      avlTree100K.insert(randomArray[i]);
-    }
-    // Build 1M tree
-    for (int i = 0; i < MILLION; i++) {
-      rbTree1M.insert(randomArray[i]);
-    }
-    treesInitialized = true;
-  }
-}
-
-std::string formatNumber(int num) {
-  std::string result = std::to_string(num);
-  int n = result.length() - 3;
-  while (n > 0) {
-    result.insert(n, ",");
-    n -= 3;
-  }
-  return result;
-}
-
-// Test 1: AVL Tree (std::set) 100K rangeSearch
-static void AVLRangeSearch100K(benchmark::State& state) {
-  initializeTrees();
-  for (auto _ : state) {
-    // Range search [69900, 70000]
-    auto it_begin = avlTree100K.lower_bound(69900);
-    auto it_end = avlTree100K.upper_bound(70000);
-
-    int count = 0;
-    for (auto it = it_begin; it != it_end; ++it) {
-      count++;
-    }
-    benchmark::DoNotOptimize(count);
-  }
-}
-BENCHMARK(AVLRangeSearch100K)->Name("AVL Tree " + formatNumber(HUNDRED_THOUSAND) + " rangeSearch");
-
-// Test 2: Red-Black Tree (std::set) 1M rangeSearch
-static void RBRangeSearch1M(benchmark::State& state) {
-  initializeTrees();
-  for (auto _ : state) {
-    // Range search [69900, 70000]
-    auto it_begin = rbTree1M.lower_bound(69900);
-    auto it_end = rbTree1M.upper_bound(70000);
-
-    int count = 0;
-    for (auto it = it_begin; it != it_end; ++it) {
-      count++;
-    }
-    benchmark::DoNotOptimize(count);
-  }
-}
-BENCHMARK(RBRangeSearch1M)->Name("Red-Black Tree " + formatNumber(MILLION) + " rangeSearch");
-
-// Test 3: AVL Tree 100K add (for completeness)
-static void AVLAdd100K(benchmark::State& state) {
-  for (auto _ : state) {
-    std::set<int> tree;
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      tree.insert(randomArray[i]);
-    }
-    benchmark::DoNotOptimize(tree);
-  }
-}
-BENCHMARK(AVLAdd100K)->Name("AVL Tree " + formatNumber(HUNDRED_THOUSAND) + " add");
-
-// Test 4: Red-Black Tree 1M add (for completeness)
-static void RBAdd1M(benchmark::State& state) {
-  for (auto _ : state) {
-    std::set<int> tree;
-    for (int i = 0; i < MILLION; i++) {
-      tree.insert(randomArray[i]);
-    }
-    benchmark::DoNotOptimize(tree);
-  }
-}
-BENCHMARK(RBAdd1M)->Name("Red-Black Tree " + formatNumber(MILLION) + " add");
-
-BENCHMARK_MAIN();

package/test/performance/data-structures/binary-tree/avl-rb-range-search.test.mjs

@@ -1,51 +0,0 @@
-import { AVLTree, RedBlackTree } from '../../../../dist/esm/index.mjs';
-import Benchmark from 'benchmark';
-import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
-
-/**
- * AVL Tree vs Red-Black Tree Range Search Benchmark
- * Compares performance of range search operations on balanced BSTs
- *
- * Fixes applied:
- * ✅ Separated tree initialization (setup phase)
- * ✅ Fixed benchmark size inconsistency (100K vs 1M)
- * ✅ Removed .on() event handlers
- * ✅ Removed .run() call
- * ✅ Added this.val for optimization prevention
- * ✅ Changed to standard function form (not chained)
- * ✅ Pre-built trees (critical for fair comparison)
- * ✅ Test names aligned with best practices
- */
-
-const suite = new Benchmark.Suite();
-
-const { MILLION, HUNDRED_THOUSAND } = magnitude;
-
-// Pre-build random array once
-const randomArray = getRandomIntArray(MILLION, 0, MILLION - 1, false);
-
-// Pre-build AVL tree
-const avlTree = new AVLTree();
-for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-  avlTree.add(randomArray[i]);
-}
-
-// Pre-build Red-Black tree
-const rbTree = new RedBlackTree();
-for (let i = 0; i < MILLION; i++) {
-  rbTree.add(randomArray[i]);
-}
-
-// Test 1: AVL Tree 100K rangeSearch [69900, 70000]
-suite.add(`AVL Tree ${HUNDRED_THOUSAND.toLocaleString()} rangeSearch`, function() {
-  const result = avlTree.rangeSearch([69900, 70000]);
-  this.val = result;  // Prevent JIT optimization
-});
-
-// Test 2: Red-Black Tree 1M rangeSearch [69900, 70000]
-suite.add(`Red-Black Tree ${MILLION.toLocaleString()} rangeSearch`, function() {
-  const result = rbTree.rangeSearch([69900, 70000]);
-  this.val = result;  // Prevent JIT optimization
-});
-
-export { suite };

package/test/performance/data-structures/binary-tree/avl-tree.test.cpp

@@ -1,181 +0,0 @@
-#include <benchmark/benchmark.h>
-#include <set>
-#include <vector>
-#include <random>
-
-const int HUNDRED_THOUSAND = 100000;
-const int MILLION = 1000000;
-
-// Keep rangeSearch reasonably fast by default.
-// Env overrides could be added later if needed, but keep this stable for now.
-const int RANGESEARCH_N = HUNDRED_THOUSAND;
-const int RANGESEARCH_QUERY_COUNT = HUNDRED_THOUSAND;
-const int RANGESEARCH_RANGE_SIZE = 100;
-
-// Global random number generator
-std::mt19937 gen(std::random_device{}());
-std::uniform_int_distribution<> dis_100k(0, HUNDRED_THOUSAND - 1);
-std::uniform_int_distribution<> dis_1m(0, MILLION - 1);
-
-// Generate random array
-std::vector<int> generateRandomArray(int size, int max_value) {
-  std::vector<int> arr;
-  arr.reserve(size);
-  std::uniform_int_distribution<> dist(0, max_value - 1);
-  for (int i = 0; i < size; i++) {
-    arr.push_back(dist(gen));
-  }
-  return arr;
-}
-
-static const auto randomArray100k = generateRandomArray(HUNDRED_THOUSAND, HUNDRED_THOUSAND);
-static const auto randomArray1m = generateRandomArray(MILLION, MILLION);
-static const auto randomArrayRangeSearch = generateRandomArray(RANGESEARCH_N, RANGESEARCH_N);
-
-// Global trees (pre-built once for get/getNode/iterator tests)
-static std::set<int> treeForGet;
-static std::set<int> treeForIterator;
-static std::set<int> treeForRangeSearch;
-static bool treesInitialized = false;
-
-void initializeTrees() {
-  if (!treesInitialized) {
-    // Initialize 100K trees
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      treeForGet.insert(randomArray100k[i]);
-      treeForIterator.insert(randomArray100k[i]);
-    }
-
-    // Initialize rangeSearch tree (default: 100K)
-    for (int i = 0; i < RANGESEARCH_N; i++) {
-      treeForRangeSearch.insert(randomArrayRangeSearch[i]);
-    }
-
-    treesInitialized = true;
-  }
-}
-
-// Test 1: 100K add randomly
-static void AddRandomly100K(benchmark::State& state) {
-  for (auto _ : state) {
-    std::set<int> tree;
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      tree.insert(randomArray100k[i]);
-    }
-    benchmark::DoNotOptimize(tree);
-  }
-}
-BENCHMARK(AddRandomly100K)->Name("100K add randomly");
-
-// Test 2: 100K add (sequential)
-static void Add100K(benchmark::State& state) {
-  for (auto _ : state) {
-    std::set<int> tree;
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      tree.insert(i);
-    }
-    benchmark::DoNotOptimize(tree);
-  }
-}
-BENCHMARK(Add100K)->Name("100K add");
-
-// Test 3: 100K get
-static void Get100K(benchmark::State& state) {
-  initializeTrees();
-  for (auto _ : state) {
-    int count = 0;
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      auto it = treeForGet.find(randomArray100k[i]);
-      if (it != treeForGet.end()) {
-        count++;
-      }
-    }
-    benchmark::DoNotOptimize(count);
-  }
-}
-BENCHMARK(Get100K)->Name("100K get");
-
-// Test 4: 100K getNode (same as get for std::set)
-static void GetNode100K(benchmark::State& state) {
-  initializeTrees();
-  for (auto _ : state) {
-    int count = 0;
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      auto it = treeForGet.find(randomArray100k[i]);
-      if (it != treeForGet.end()) {
-        count++;
-      }
-    }
-    benchmark::DoNotOptimize(count);
-  }
-}
-BENCHMARK(GetNode100K)->Name("100K getNode");
-
-// Test 5: 100K iterator
-static void Iterator100K(benchmark::State& state) {
-  initializeTrees();
-  for (auto _ : state) {
-    int count = 0;
-    for (auto it = treeForIterator.begin(); it != treeForIterator.end(); ++it) {
-      count++;
-    }
-    benchmark::DoNotOptimize(count);
-  }
-}
-BENCHMARK(Iterator100K)->Name("100K iterator");
-
-// Test 6: 100K add & delete (sequential)
-static void AddDeleteOrderly100K(benchmark::State& state) {
-  for (auto _ : state) {
-    std::set<int> tree;
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      tree.insert(i);
-    }
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      tree.erase(i);
-    }
-    benchmark::DoNotOptimize(tree);
-  }
-}
-BENCHMARK(AddDeleteOrderly100K)->Name("100K add & delete orderly");
-
-// Test 7: 100K add & delete (random)
-static void AddDeleteRandomly100K(benchmark::State& state) {
-  for (auto _ : state) {
-    std::set<int> tree;
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      tree.insert(randomArray100k[i]);
-    }
-    for (int i = 0; i < HUNDRED_THOUSAND; i++) {
-      tree.erase(randomArray100k[i]);
-    }
-    benchmark::DoNotOptimize(tree);
-  }
-}
-BENCHMARK(AddDeleteRandomly100K)->Name("100K add & delete randomly");
-
-// Test 8: rangeSearch queries (default: 100K queries on 100K data)
-static void RangeSearch100K(benchmark::State& state) {
-  initializeTrees();
-
-  for (auto _ : state) {
-    int totalResults = 0;
-    for (int i = 0; i < RANGESEARCH_QUERY_COUNT; i++) {
-      int min = (i * 12345) % (RANGESEARCH_N - RANGESEARCH_RANGE_SIZE);
-      int max = min + RANGESEARCH_RANGE_SIZE;
-
-      auto it_begin = treeForRangeSearch.lower_bound(min);
-      auto it_end = treeForRangeSearch.upper_bound(max);
-
-      int count = 0;
-      for (auto it = it_begin; it != it_end; ++it) {
-        count++;
-      }
-      totalResults += count;
-    }
-    benchmark::DoNotOptimize(totalResults);
-  }
-}
-BENCHMARK(RangeSearch100K)->Name("AVL Tree 100K rangeSearch queries");
-
-BENCHMARK_MAIN();