data-structure-typed 2.3.0 → 2.4.0

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

@@ -0,0 +1,138 @@
+import { AVLTree } from '../../../../dist/esm/index.mjs';
+
+import Benchmark from 'benchmark';
+
+import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
+
+const suite = new Benchmark.Suite();
+
+const { HUNDRED_THOUSAND } = magnitude;
+
+const randomArray = new Array(HUNDRED_THOUSAND)
+    .fill(0)
+    .map(() => getRandomInt(0, HUNDRED_THOUSAND - 1));
+
+// Global trees for tests that need pre-built data
+let treeForGet = null;
+let treeForGetNode = null;
+let treeForIterator = null;
+
+// Global trees and query ranges for rangeSearch
+let treeForRangeSearch = null;
+let queryRanges = [];
+
+// Keep rangeSearch reasonably fast by default.
+// Env overrides (optional): AVL_RS_N, AVL_RS_QUERY_COUNT, AVL_RS_RANGE_SIZE
+const RANGESEARCH_N = Number(process.env.AVL_RS_N ?? HUNDRED_THOUSAND);
+const QUERY_COUNT = Number(process.env.AVL_RS_QUERY_COUNT ?? HUNDRED_THOUSAND);
+const RANGE_SIZE = Number(process.env.AVL_RS_RANGE_SIZE ?? 100);
+
+// Initialize all trees in suite 'start' event (NOT TIMED)
+suite.on('start', function() {
+  treeForGet = new AVLTree();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    treeForGet.add(randomArray[i]);
+  }
+
+  treeForGetNode = new AVLTree();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    treeForGetNode.add(randomArray[i]);
+  }
+
+  treeForIterator = new AVLTree();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    treeForIterator.add(randomArray[i]);
+  }
+
+  // Initialize for rangeSearch test
+  const randomArrayLarge = getRandomIntArray(RANGESEARCH_N, 0, RANGESEARCH_N - 1, false);
+  treeForRangeSearch = new AVLTree();
+  for (let i = 0; i < RANGESEARCH_N; i++) {
+    treeForRangeSearch.add(randomArrayLarge[i]);
+  }
+
+  // Pre-generate random query ranges
+  queryRanges = [];
+  for (let i = 0; i < QUERY_COUNT; i++) {
+    const min = Math.floor(Math.random() * (RANGESEARCH_N - RANGE_SIZE));
+    queryRanges.push([min, min + RANGE_SIZE]);
+  }
+});
+
+suite.add('100K add randomly', function() {
+  const tree = new AVLTree();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    tree.add(randomArray[i]);
+  }
+  this.val = tree;
+});
+
+suite.add('100K add', function() {
+  const tree = new AVLTree();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    tree.add(i);
+  }
+  this.val = tree;
+});
+
+suite.add('100K get', function() {
+  let count = 0;
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    if (treeForGet.get(randomArray[i]) !== undefined) {
+      count++;
+    }
+  }
+  this.val = count;
+});
+
+suite.add('100K getNode', function() {
+  let count = 0;
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    if (treeForGetNode.getNode(randomArray[i]) !== undefined) {
+      count++;
+    }
+  }
+  this.val = count;
+});
+
+suite.add('100K iterator', function() {
+  let count = 0;
+  for (const node of treeForIterator) {
+    count++;
+  }
+  this.val = count;
+});
+
+suite.add('100K add & delete orderly', function() {
+  const tree = new AVLTree();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    tree.add(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    tree.delete(i);
+  }
+  this.val = tree;
+});
+
+suite.add('100K add & delete randomly', function() {
+  const tree = new AVLTree();
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    tree.add(randomArray[i]);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    tree.delete(randomArray[i]);
+  }
+  this.val = tree;
+});
+
+// rangeSearch queries (default: 100K queries on 100K data)
+suite.add('AVL Tree 100K rangeSearch queries', function() {
+  let totalResults = 0;
+  for (let i = 0; i < QUERY_COUNT; i++) {
+    const result = treeForRangeSearch.rangeSearch(queryRanges[i]);
+    totalResults += result.length;
+  }
+  this.val = totalResults; // Prevent JIT optimization
+});
+
+export { suite };

package/test/performance/data-structures/binary-tree/binary-tree-overall.test.mjs

@@ -0,0 +1,85 @@
+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 Comparison Benchmark
+ * Overall performance metrics for balanced BSTs
+ *
+ * Fixes applied:
+ * ✅ Removed chain calls - standard function form
+ * ✅ Added this.val for optimization prevention
+ * ✅ Removed unnecessary .clear() calls
+ * ✅ Pre-built trees for fair comparison
+ * ✅ Added export statement
+ */
+
+const suite = new Benchmark.Suite();
+const { TEN_THOUSAND } = magnitude;
+
+// Pre-build array once
+const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND - 1, true);
+
+// Test 1: RB Tree add randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} RedBlackTree add randomly`, function() {
+  const tree = new RedBlackTree();
+  for (let i = 0; i < arr.length; i++) {
+    tree.add(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 2: RB Tree get randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} RedBlackTree get randomly`, function() {
+  const tree = new RedBlackTree();
+  tree.addMany(arr);
+  for (let i = 0; i < arr.length; i++) {
+    tree.get(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 3: RB Tree add & delete randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} RedBlackTree add & delete randomly`, function() {
+  const tree = new RedBlackTree();
+  for (let i = 0; i < arr.length; i++) {
+    tree.add(arr[i]);
+  }
+  for (let i = 0; i < arr.length; i++) {
+    tree.delete(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 4: AVL Tree add randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} AVLTree add randomly`, function() {
+  const tree = new AVLTree();
+  for (let i = 0; i < arr.length; i++) {
+    tree.add(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 5: AVL Tree get randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} AVLTree get randomly`, function() {
+  const tree = new AVLTree();
+  tree.addMany(arr);
+  for (let i = 0; i < arr.length; i++) {
+    tree.get(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 6: AVL Tree add & delete randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} AVLTree add & delete randomly`, function() {
+  const tree = new AVLTree();
+  for (let i = 0; i < arr.length; i++) {
+    tree.add(arr[i]);
+  }
+  for (let i = 0; i < arr.length; i++) {
+    tree.delete(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+export { suite };

package/test/performance/data-structures/binary-tree/binary-tree.test.mjs

@@ -0,0 +1,100 @@
+import { BinaryTree } from '../../../../dist/esm/index.mjs';
+import Benchmark from 'benchmark';
+import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
+
+/**
+ * Binary Tree Benchmark Suite
+ * Tests general binary tree operations
+ *
+ * Fixes applied:
+ * ✅ Removed chain calls - standard function form
+ * ✅ Added this.val for optimization prevention
+ * ✅ Added export statement
+ * ✅ Fixed setup/teardown logic
+ */
+
+const suite = new Benchmark.Suite();
+const { THOUSAND } = magnitude;
+
+// Pre-build array once
+const arr = getRandomIntArray(THOUSAND, 0, THOUSAND, true);
+
+// Test 1: 1K add randomly
+suite.add(`${THOUSAND.toLocaleString()} add randomly`, function() {
+  const tree = new BinaryTree();
+  for (let i = 0; i < arr.length; i++) {
+    tree.add(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 2: 1K add & delete randomly
+suite.add(`${THOUSAND.toLocaleString()} add & delete randomly`, function() {
+  const tree = new BinaryTree();
+  for (let i = 0; i < arr.length; i++) {
+    tree.add(arr[i]);
+  }
+  for (let i = 0; i < arr.length; i++) {
+    tree.delete(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 3: 1K addMany
+suite.add(`${THOUSAND.toLocaleString()} addMany`, function() {
+  const tree = new BinaryTree();
+  tree.addMany(arr);
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 4: 1K get
+suite.add(`${THOUSAND.toLocaleString()} get`, function() {
+  const tree = new BinaryTree();
+  tree.addMany(arr);
+  for (let i = 0; i < arr.length; i++) {
+    tree.get(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 5: 1K has
+suite.add(`${THOUSAND.toLocaleString()} has`, function() {
+  const tree = new BinaryTree();
+  tree.addMany(arr);
+  for (let i = 0; i < arr.length; i++) {
+    tree.has(arr[i]);
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 6: 1K dfs
+suite.add(`${THOUSAND.toLocaleString()} dfs`, function() {
+  const tree = new BinaryTree();
+  tree.addMany(arr);
+  for (let i = 0; i < THOUSAND; i++) {
+    tree.dfs();
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 7: 1K bfs
+suite.add(`${THOUSAND.toLocaleString()} bfs`, function() {
+  const tree = new BinaryTree();
+  tree.addMany(arr);
+  for (let i = 0; i < THOUSAND; i++) {
+    tree.bfs();
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+// Test 8: 1K morris
+suite.add(`${THOUSAND.toLocaleString()} morris`, function() {
+  const tree = new BinaryTree();
+  tree.addMany(arr);
+  for (let i = 0; i < THOUSAND; i++) {
+    tree.morris(n => n, 'PRE');
+  }
+  this.val = tree;  // Prevent JIT optimization
+});
+
+export { suite };

package/test/performance/data-structures/binary-tree/bst.test.mjs

@@ -0,0 +1,61 @@
+import { BST } from '../../../../dist/esm/index.mjs';
+import Benchmark from 'benchmark';
+import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
+
+/**
+ * BST (Binary Search Tree) Benchmark Suite
+ * Tests BST-specific operations
+ *
+ * Fixes applied:
+ * ✅ Removed setup object syntax - use standard function form
+ * ✅ Removed 0ms bug source
+ * ✅ Added this.val for optimization prevention
+ * ✅ Single suite export
+ * ✅ Pre-built array for efficiency
+ */
+
+const suite = new Benchmark.Suite();
+const { TEN_THOUSAND } = magnitude;
+
+// Pre-build array once
+const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND, true);
+
+// Test 1: 10K add randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} add randomly`, function() {
+    const bst = new BST();
+    for (let i = 0; i < arr.length; i++) {
+        bst.add(arr[i]);
+    }
+    this.val = bst; // Prevent JIT optimization
+});
+
+// Test 2: 10K add & delete randomly
+suite.add(`${TEN_THOUSAND.toLocaleString()} add & delete randomly`, function() {
+    const bst = new BST();
+    for (let i = 0; i < arr.length; i++) {
+        bst.add(arr[i]);
+    }
+    for (let i = 0; i < arr.length; i++) {
+        bst.delete(arr[i]);
+    }
+    this.val = bst; // Prevent JIT optimization
+});
+
+// Test 3: 10K addMany
+suite.add(`${TEN_THOUSAND.toLocaleString()} addMany`, function() {
+    const bst = new BST();
+    bst.addMany(arr);
+    this.val = bst; // Prevent JIT optimization
+});
+
+// Test 4: 10K get (with pre-populated tree)
+suite.add(`${TEN_THOUSAND.toLocaleString()} get`, function() {
+    const bst = new BST();
+    bst.addMany(arr);
+    for (let i = 0; i < arr.length; i++) {
+        bst.get(arr[i]);
+    }
+    this.val = bst; // Prevent JIT optimization
+});
+
+export { suite };

package/test/performance/data-structures/binary-tree/red-black-tree-cjs.test.mjs

@@ -0,0 +1,259 @@
+import { createRequire } from 'module';
+import * as path from 'path';
+
+import { getRandomIntArray, magnitude } from '../../../utils/perf.mjs';
+
+// IMPORTANT: For perf stability, load the CJS build directly (matches the standalone scripts).
+// Using package ESM entry (`import { ... } from '../../../../dist/esm/index.mjs'`) showed large slowdowns
+// for Node Mode get in this environment.
+const require = createRequire(import.meta.url);
+const { RedBlackTree } = require(path.resolve(process.cwd(), '../data-structure-typed/dist/cjs/index.cjs'));
+const { OrderedMap } = require('js-sdsl');
+
+/**
+ * Red-Black Tree (macro) perf harness
+ *
+ * Goal: keep the report.json schema the same (Latency Avg/Min/Max/Stability)
+ * but avoid Benchmark.js loop-shaping/JIT artifacts by measuring real total
+ * wall-time for the intended workload (e.g. 1,000,000 operations) using hrtime.
+ *
+ * Notes:
+ * - This module exports `getResults()` consumed by benchmark-runner-enhanced.mjs.
+ * - We still support smoke testing via env knobs.
+ */
+
+const { MILLION } = magnitude;
+
+const N = Number(process.env.RBT_N ?? MILLION);
+const KEY_POOL = Number(process.env.RBT_KEY_POOL ?? 100_000);
+const GET_N = Number(process.env.RBT_GET_N ?? MILLION);
+
+// Repeats per test case. Tune for stability vs runtime.
+const REPEATS = Number(process.env.RBT_REPEAT ?? 5);
+
+function nowMs() {
+    return Number(process.hrtime.bigint()) / 1e6;
+}
+
+function mean(arr) {
+    let s = 0;
+    for (let i = 0; i < arr.length; i++) s += arr[i];
+    return s / arr.length;
+}
+
+function stddev(arr, m) {
+    if (arr.length <= 1) return 0;
+    let s = 0;
+    for (let i = 0; i < arr.length; i++) {
+        const d = arr[i] - m;
+        s += d * d;
+    }
+    return Math.sqrt(s / (arr.length - 1));
+}
+
+// 95% t critical values for df=1..30 (two-tailed). For df>30 use ~1.96.
+const T95 = [
+    NaN,
+    12.706, 4.303, 3.182, 2.776, 2.571,
+    2.447, 2.365, 2.306, 2.262, 2.228,
+    2.201, 2.179, 2.160, 2.145, 2.131,
+    2.120, 2.110, 2.101, 2.093, 2.086,
+    2.080, 2.074, 2.069, 2.064, 2.060,
+    2.056, 2.052, 2.048, 2.045, 2.042
+];
+
+function rme95Percent(samples, m) {
+    const n = samples.length;
+    if (n <= 1) return 0;
+    const sd = stddev(samples, m);
+    const se = sd / Math.sqrt(n);
+    const df = n - 1;
+    const t = df <= 30 ? T95[df] : 1.96;
+    const moe = t * se; // margin of error (ms)
+    return m === 0 ? 0 : (moe / m) * 100;
+}
+
+function formatCase(name, samplesMs) {
+    const m = mean(samplesMs);
+    const minV = Math.min(...samplesMs);
+    const maxV = Math.max(...samplesMs);
+    const rme = rme95Percent(samplesMs, m);
+
+    const msDigits = m < 10 ? 4 : 2;
+
+    return {
+        'Test Case': name,
+        'Latency Avg (ms)': Number(m.toFixed(msDigits)),
+        'Min (ms)': Number(minV.toFixed(msDigits)),
+        'Max (ms)': Number(maxV.toFixed(msDigits)),
+        'Stability': `±${rme.toFixed(2)}%`
+    };
+}
+
+const COOLDOWN_MS = Number(process.env.RBT_COOLDOWN_MS ?? 50);
+
+function sleepMs(ms) {
+    if (!ms || ms <= 0) return;
+    // Synchronous sleep without extra deps.
+    // (Atomics.wait is supported in Node; this keeps the macro harness simple.)
+    const sab = new SharedArrayBuffer(4);
+    const i32 = new Int32Array(sab);
+    Atomics.wait(i32, 0, 0, ms);
+}
+
+function maybeGC() {
+    try {
+        if (typeof global.gc === 'function') global.gc();
+    } catch {
+        // ignore
+    }
+}
+
+function withRepeats(label, fn) {
+    const samples = [];
+    for (let r = 0; r < REPEATS; r++) {
+        // Try to reduce cross-repeat noise.
+        maybeGC();
+        sleepMs(COOLDOWN_MS);
+
+        const t0 = nowMs();
+        fn();
+        const t1 = nowMs();
+
+        maybeGC();
+        sleepMs(COOLDOWN_MS);
+
+        const dt = t1 - t0;
+        samples.push(dt);
+        console.log(`  ✓ ${label} [${r + 1}/${REPEATS}] ${dt.toFixed(2)}ms`);
+    }
+    return formatCase(label, samples);
+}
+
+export async function getResults() {
+    console.log(`RBT macro perf: N=${N.toLocaleString()} KEY_POOL=${KEY_POOL.toLocaleString()} GET_N=${GET_N.toLocaleString()} REPEATS=${REPEATS}`);
+
+    // Pre-generate random data outside timing.
+    console.log('pre-generating random data...');
+    const randUniqueKeys = getRandomIntArray(N, 0, N - 1, true);
+    const randUpdateKeys = getRandomIntArray(N, 0, KEY_POOL - 1, false);
+    console.log('random data ready');
+
+    const results = [];
+
+    // GET (prefill not timed) - run first to avoid heap/GC pollution from insert/update benchmarks.
+    console.log('pre-building get trees (not timed)...');
+    const rbMapMode = new RedBlackTree([], { isMapMode: true });
+    const rbNodeMode = new RedBlackTree([], { isMapMode: false });
+    const sdslOrderedMap = new OrderedMap();
+    for (let i = 0; i < GET_N; i++) {
+        rbMapMode.set(i, i);
+        rbNodeMode.add(i);
+        sdslOrderedMap.setElement(i, i);
+    }
+    console.log('pre-build done');
+
+    results.push(withRepeats(`${GET_N.toLocaleString()} get`, () => {
+        let count = 0;
+        for (let i = 0; i < GET_N; i++) if (rbMapMode.get(i) !== undefined) count++;
+        if (count === 42) console.log('');
+    }));
+
+    results.push(withRepeats(`${GET_N.toLocaleString()} get (Node Mode)`, () => {
+        let count = 0;
+        for (let i = 0; i < GET_N; i++) if (rbNodeMode.get(i) !== undefined) count++;
+        if (count === 42) console.log('');
+    }));
+
+    results.push(withRepeats(`${GET_N.toLocaleString()} get (js-sdsl)`, () => {
+        let count = 0;
+        for (let i = 0; i < GET_N; i++) if (sdslOrderedMap.getElementByKey(i) !== undefined) count++;
+        if (count === 42) console.log('');
+    }));
+
+    // UPDATE (SEQ)
+    results.push(withRepeats(`${MILLION.toLocaleString()} upd SEQ`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: true });
+        for (let i = 0; i < KEY_POOL; i++) rbTree.set(i, 0);
+        for (let i = 0; i < N; i++) rbTree.set(i % KEY_POOL, i);
+    }));
+
+    results.push(withRepeats(`${MILLION.toLocaleString()} upd SEQ (Node Mode)`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: false });
+        for (let i = 0; i < KEY_POOL; i++) rbTree.set(i, 0);
+        for (let i = 0; i < N; i++) rbTree.set(i % KEY_POOL, i);
+    }));
+
+    results.push(withRepeats(`${MILLION.toLocaleString()} upd SEQ (js-sdsl)`, () => {
+        const mp = new OrderedMap();
+        for (let i = 0; i < KEY_POOL; i++) mp.setElement(i, 0);
+        for (let i = 0; i < N; i++) mp.setElement(i % KEY_POOL, i);
+    }));
+
+    // UPDATE (RAND)
+    results.push(withRepeats(`${MILLION.toLocaleString()} upd RAND`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: true });
+        for (let i = 0; i < KEY_POOL; i++) rbTree.set(i, 0);
+        for (let i = 0; i < N; i++) rbTree.set(randUpdateKeys[i], i);
+    }));
+
+    results.push(withRepeats(`${MILLION.toLocaleString()} upd RAND (Node Mode)`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: false });
+        for (let i = 0; i < KEY_POOL; i++) rbTree.set(i, 0);
+        for (let i = 0; i < N; i++) rbTree.set(randUpdateKeys[i], i);
+    }));
+
+    results.push(withRepeats(`${MILLION.toLocaleString()} upd RAND (js-sdsl)`, () => {
+        const mp = new OrderedMap();
+        for (let i = 0; i < KEY_POOL; i++) mp.setElement(i, 0);
+        for (let i = 0; i < N; i++) mp.setElement(randUpdateKeys[i], i);
+    }));
+
+    // INSERT (SEQ)
+    results.push(withRepeats(`${N.toLocaleString()} ins SEQ`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: true });
+        for (let i = 0; i < N; i++) rbTree.set(i, i);
+    }));
+
+    results.push(withRepeats(`${MILLION.toLocaleString()} ins SEQ (Node Mode)`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: false });
+        for (let i = 0; i < N; i++) rbTree.add(i);
+    }));
+
+    results.push(withRepeats(`${N.toLocaleString()} ins SEQ (js-sdsl)`, () => {
+        const mp = new OrderedMap();
+        for (let i = 0; i < N; i++) mp.setElement(i, i);
+    }));
+
+    // INSERT (RAND unique)
+    results.push(withRepeats(`${MILLION.toLocaleString()} ins RAND`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: true });
+        for (let i = 0; i < N; i++) {
+            const k = randUniqueKeys[i];
+            rbTree.set(k, k);
+        }
+    }));
+
+    results.push(withRepeats(`${MILLION.toLocaleString()} ins RAND (Node Mode)`, () => {
+        const rbTree = new RedBlackTree([], { isMapMode: false });
+        for (let i = 0; i < N; i++) rbTree.add(randUniqueKeys[i]);
+    }));
+
+    results.push(withRepeats(`${MILLION.toLocaleString()} ins RAND (js-sdsl)`, () => {
+        const mp = new OrderedMap();
+        for (let i = 0; i < N; i++) {
+            const k = randUniqueKeys[i];
+            mp.setElement(k, k);
+        }
+    }));
+
+    // Baseline: keys-only
+    results.push(withRepeats(`${MILLION.toLocaleString()} keys-only`, () => {
+        let s = 0;
+        for (let i = 0; i < N; i++) s += randUniqueKeys[i];
+        // consume
+        if (s === 42) console.log('');
+    }));
+
+    return results;
+}