From 193cc064d7ccacdc332f065ec6f5131d01413bdd Mon Sep 17 00:00:00 2001 From: Thomas Santerre Date: Sun, 12 Jul 2026 12:40:36 -0400 Subject: [PATCH] Record authoritative macOS benchmark baseline --- .github/workflows/rust.yml | 4 +- TODO.md | 44 +- comparisons/README.md | 6 +- comparisons/benchmark-results/LATEST.md | 111 +- comparisons/benchmark-results/README.md | 3 +- .../graphics/macos-aarch64-cpu-heatmap.svg | 4246 +++++++++++++++++ .../graphics/macos-aarch64-cpu-profile.svg | 1879 ++++++++ ...macos-aarch64-memory-requested-heatmap.svg | 3287 +++++++++++++ .../macos-aarch64-memory-usable-heatmap.svg | 3248 +++++++++++++ .../benchmark-results/macos-aarch64.json | 2791 +++++++++++ .../benchmark-results/macos-aarch64.md | 191 + comparisons/tools/generate_report.py | 89 +- comparisons/tools/test_generate_report.py | 60 + 13 files changed, 15906 insertions(+), 53 deletions(-) create mode 100644 comparisons/benchmark-results/graphics/macos-aarch64-cpu-heatmap.svg create mode 100644 comparisons/benchmark-results/graphics/macos-aarch64-cpu-profile.svg create mode 100644 comparisons/benchmark-results/graphics/macos-aarch64-memory-requested-heatmap.svg create mode 100644 comparisons/benchmark-results/graphics/macos-aarch64-memory-usable-heatmap.svg create mode 100644 comparisons/benchmark-results/macos-aarch64.json create mode 100644 comparisons/benchmark-results/macos-aarch64.md create mode 100644 comparisons/tools/test_generate_report.py diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index cb26f55..09abc2a 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -53,9 +53,9 @@ jobs: if: hashFiles('comparisons/benchmark-results/macos-aarch64.json') != '' && hashFiles('comparisons/benchmark-results/linux-x86_64.json') != '' run: uv run --project comparisons/tools --locked python comparisons/tools/validate_pair.py comparisons/benchmark-results/macos-aarch64.json comparisons/benchmark-results/linux-x86_64.json - name: Regenerate versioned benchmark graphics - if: hashFiles('comparisons/benchmark-results/linux-x86_64.json') != '' + if: hashFiles('comparisons/benchmark-results/linux-x86_64.json') != '' && hashFiles('comparisons/benchmark-results/macos-aarch64.json') != '' run: | - uv run --project comparisons/tools --locked python comparisons/tools/generate_report.py comparisons/benchmark-results/linux-x86_64.json + uv run --project comparisons/tools --locked python comparisons/tools/generate_report.py comparisons/benchmark-results/linux-x86_64.json comparisons/benchmark-results/macos-aarch64.json git diff --exit-code -- comparisons/benchmark-results/LATEST.md comparisons/benchmark-results/graphics msrv: diff --git a/TODO.md b/TODO.md index c190ebe..3ab586b 100644 --- a/TODO.md +++ b/TODO.md @@ -34,14 +34,13 @@ decision is reached. - [x] Capture and validate a clean Ryzen 7950X3D Linux matrix from canonical `main` merge commit `2dc82e0`, using Rust 1.97.0 and the explicit `system` allocator policy, then regenerate the Linux-only `LATEST.md` and SVGs. -- [ ] Deferred: capture the matching macOS matrix only when dedicated, - controllable Apple Silicon hardware is available. The local M4 host is not an - acceptable canonical source while interactive iTerm2/WindowServer load prevents - the runner from satisfying its idle gate. Never bypass that gate with - `--allow-host-noise`. -- [ ] Deferred with macOS: validate the Linux/macOS pair and extend `LATEST.md` and - the SVGs without pooling either platform's absolute or relative values. The - absence of a macOS result does not block publishing the canonical Linux result. +- [x] Capture the matching macOS matrix on the dedicated, normally idle M3 Pro + host using the exact Linux source/compiler matrix, AC power, Low Power Mode off, + and the strict host-idle gate. Never use `--allow-host-noise` to manufacture a + pair. +- [x] Validate the Linux/macOS pair and extend `LATEST.md` and the SVGs with + separate platform sections. Never pool either platform's absolute or relative + values. - [ ] Enable the already-configured CodSpeed ARM64 macro runner only after public repository runner-group access is available; keep it a trend lane, not a substitute for physical-host baselines. @@ -138,9 +137,9 @@ header alignment without a new real-workload counterexample. - [x] Track public-repository access for the `moderately-ai` Actions runner in the active roadmap; configuration is ready but organization runner-group access and `CODSPEED_MACRO_ENABLED=true` remain external prerequisites. -- [x] Move the matching clean M4 macOS capture and pair validation into the active - roadmap; subsequently defer it until dedicated hardware is available, retaining - full raw rounds outside Git and publishing no rejected/noisy local result. +- [x] Capture and validate the matching clean M3 Pro macOS half on dedicated + hardware, retain full raw rounds outside Git, and publish only the accepted + compact result. - [x] Move practical-equivalence-band review into the active roadmap with its evidence threshold unchanged. @@ -179,9 +178,9 @@ header alignment without a new real-workload counterexample. ## Experiment record -### Canonical Linux comparison baseline (`bench/canonical-linux-baseline`) +### Canonical Linux/macOS comparison baseline (`bench/canonical-linux-baseline`) -- Status: complete on Linux; macOS deliberately deferred +- Status: complete on Linux and macOS - Source: canonical `main` merge commit `2dc82e0656ba2c3997c4dc2dd26b905ce621bb2f`; Rust 1.97.0 (`2d8144b7880597b6e6d3dfd63a9a9efae3f533d3`); explicit system allocator. @@ -197,14 +196,17 @@ header alignment without a new real-workload counterexample. inconclusive results, and six losses versus Vec. Empty and sparse nested requested heap are 0.333x and 0.526x Vec. This remains a situational density design with targeted CPU wins, not an across-the-board faster Vec. -- Rejected macOS capture: the local M4 runner correctly refused to proceed when - iTerm2 and WindowServer each sustained roughly 28% CPU and two consecutive - >=90% idle samples could not be obtained. No local macOS result is authoritative - or published. Retry only on dedicated controllable hardware; never use - `--allow-host-noise` to manufacture a pair. -- Decision: publish the canonical Linux result and Linux-only graphics now. - Cross-platform validation and graphics remain deferred and do not block Linux - performance work; the next credible implementation audit is `retain`. +- macOS quality: five balanced rotations on the normally idle M3 Pro, + using the exact source commit, Rust 1.97.0 compiler identity, and explicit + system allocator. All settle gates passed, no host issue was recorded, and the + final noisy post-round sample recovered to 96.7% idle before allocation + accounting. The report contains 110 CPU rows and 60 allocation rows. +- macOS result: JackVec has four confidence-qualified wins, one equivalent, + eleven inconclusive results, and six losses versus Vec. `retain_mixed/u64` + remains a credible loss at 1.150x and `retain_mixed/64_byte` at 1.070x; + reserved resize is a 0.777x win. Results remain platform-specific. +- Decision: publish the validated pair, platform-specific graphics, and combined + non-pooled report. The next credible implementation audit remains `retain`. ### Preallocated four-element append (`perf/append-small-audit`) diff --git a/comparisons/README.md b/comparisons/README.md index 95e38a2..06dd404 100644 --- a/comparisons/README.md +++ b/comparisons/README.md @@ -65,7 +65,9 @@ sustained system load indicates contamination. `validate_pair.py` independently refuses reports whose commit, compiler identity, schema, workload matrix, or authoritative status differs. -Compact JSON and Markdown summaries in `benchmark-results/` are versioned. Raw +Compact JSON and Markdown summaries in `benchmark-results/` are versioned. Run +`generate_report.py` with every validated platform JSON to regenerate a single +non-pooled `LATEST.md` and the platform-specific graphics. Raw per-round estimates and allocation CSV files live under the ignored `benchmark-results/raw/` directory. @@ -81,7 +83,7 @@ CodSpeed CPU simulation runs on every pull request and `main` update. Managed ARM64 Linux wall time runs on `main` and manual dispatch after the organization enables public-repository macro-runner access and sets the repository variable `CODSPEED_MACRO_ENABLED=true`. These continuous trends complement rather than -replace the controlled M4 macOS and x86_64 Linux reports. +replace the controlled M3 Pro macOS and x86_64 Linux reports. ## Python tooling diff --git a/comparisons/benchmark-results/LATEST.md b/comparisons/benchmark-results/LATEST.md index 5454884..31e0676 100644 --- a/comparisons/benchmark-results/LATEST.md +++ b/comparisons/benchmark-results/LATEST.md @@ -1,15 +1,20 @@ # Latest benchmark comparison -This is the authoritative `linux-x86_64` baseline. Lower ratios are -better. CPU classifications and heatmap ratios use `Vec` as the baseline; red -does not mean an implementation lost to every other candidate. Every measured -implementation and scenario is retained, and platforms are never pooled. +These are the authoritative physical-host baselines. Lower ratios are better. +CPU classifications and heatmap ratios use `Vec` as the baseline; red does not +mean an implementation lost to every other candidate. Every measured +implementation and scenario is retained. Platform results are presented in +separate sections and are never pooled. + +## `linux-x86_64` + +This is the authoritative `linux-x86_64` baseline. ![CPU performance profile](graphics/linux-x86_64-cpu-profile.svg) ![Complete CPU ratio heatmap](graphics/linux-x86_64-cpu-heatmap.svg) -## What this baseline says +### What this baseline says - JackVec is not an across-the-board faster `Vec`: it has 7 confidence-qualified wins and @@ -30,7 +35,7 @@ implementation and scenario is retained, and platforms are never pooled. SmallVec avoids heap allocation when values fit inline. Neither representation dominates every workload. -## CPU outcomes +### CPU outcomes The confidence-aware classifications below compare each implementation with `Vec`. “Inconclusive” means the paired 95% interval crosses a boundary; it is not @@ -53,7 +58,7 @@ using the same ±3% practical band. It does not replace the confidence-aware tab | SmallVec4 | 13 | 4 | 5 | | SmallVec8 | 13 | 4 | 5 | -## Memory outcomes +### Memory outcomes Requested and allocator-usable heap are deliberately separate. Requested bytes show representation savings; usable bytes show what the measured allocator @@ -71,7 +76,7 @@ count memory. See [the complete platform table](linux-x86_64.md) for owner bytes, absolute requested/usable bytes, allocation counts, reallocations, and spill counts. -## Run provenance +### Run provenance - Commit: `2dc82e0656ba2c3997c4dc2dd26b905ce621bb2f` - Compiler: `1.97.0` (`2d8144b7880597b6e6d3dfd63a9a9efae3f533d3`) @@ -86,5 +91,91 @@ The performance profile reports the fraction of workloads within each factor of the fastest implementation for that workload. It is an aggregate view, not a claim that all workloads are equally representative. The heatmaps preserve the individual results. These microbenchmarks describe the listed operations, element -types, sizes, compiler, allocator, and machine—not every application. macOS -remains pending until a clean authoritative run is available. +types, sizes, compiler, allocator, and machine—not every application. + +## `macos-aarch64` + +This is the authoritative `macos-aarch64` baseline. + +![CPU performance profile](graphics/macos-aarch64-cpu-profile.svg) + +![Complete CPU ratio heatmap](graphics/macos-aarch64-cpu-heatmap.svg) + +### What this baseline says + +- JackVec is not an across-the-board faster `Vec`: it has + 4 confidence-qualified wins and + 6 losses versus `Vec` in this matrix. +- Its intended nested-density advantage is substantial: requested memory for the + empty and sparse nested workloads is + 0.333× and + 0.526× Vec, + respectively, while each collection owner remains one machine word. +- The optimized large append path reaches + 0.854× Vec and + 0.362× upstream + ThinVec. This is a large targeted improvement, not a universal CPU claim. +- JackVec's three largest median CPU gaps versus Vec are `nested_metadata_scan_sparse` (2.041×), `append_preallocated/4` (1.324×), `retain_mixed/u64` (1.149×). They are + retained here as investigation targets; confidence-aware classifications remain + authoritative over point-estimate ordering. +- Against the inline candidates, JackVec wins most measured CPU medians, while + SmallVec avoids heap allocation when values fit inline. Neither representation + dominates every workload. + +### CPU outcomes + +The confidence-aware classifications below compare each implementation with +`Vec`. “Inconclusive” means the paired 95% interval crosses a boundary; it is not +silently counted as equality. + +| Implementation | Wins | Equivalent | Inconclusive | Losses | +|---|---:|---:|---:|---:| +| JackVec | 4 | 1 | 11 | 6 | +| ThinVec | 3 | 3 | 6 | 10 | +| SmallVec4 | 4 | 2 | 6 | 10 | +| SmallVec8 | 5 | 2 | 4 | 11 | + +For direct context, this simpler head-to-head table compares median CPU times +using the same ±3% practical band. It does not replace the confidence-aware table. + +| JackVec compared with | JackVec faster | Within ±3% | JackVec slower | +|---|---:|---:|---:| +| Vec | 6 | 7 | 9 | +| ThinVec | 7 | 12 | 3 | +| SmallVec4 | 10 | 6 | 6 | +| SmallVec8 | 12 | 4 | 6 | + +### Memory outcomes + +Requested and allocator-usable heap are deliberately separate. Requested bytes +show representation savings; usable bytes show what the measured allocator +actually retained after size-class rounding. + +![Requested live heap ratio heatmap](graphics/macos-aarch64-memory-requested-heatmap.svg) + +![Allocator-usable live heap ratio heatmap](graphics/macos-aarch64-memory-usable-heatmap.svg) + +Collection-owner size is not included in those heap ratios. A `Vec` owner is 24 +bytes, a JackVec or ThinVec owner is 8 bytes, and SmallVec owners vary with inline +capacity and element alignment. In nested rows the outer allocation already +contains every inner owner, so adding the owner column to live heap would double +count memory. See [the complete platform table](macos-aarch64.md) for +owner bytes, absolute requested/usable bytes, allocation counts, reallocations, +and spill counts. + +### Run provenance + +- Commit: `2dc82e0656ba2c3997c4dc2dd26b905ce621bb2f` +- Compiler: `1.97.0` (`2d8144b7880597b6e6d3dfd63a9a9efae3f533d3`) +- Allocator policy: `system`; inherited injection: + `{'DYLD_INSERT_LIBRARIES': None, 'LD_PRELOAD': None}`; effective injection: + `{'DYLD_INSERT_LIBRARIES': None, 'LD_PRELOAD': None}` +- CPU rounds: 5; CPU rows: 110; allocation rows: 60 +- Minimum pinned-core idle audit: 88.2% +- Maximum audited one-minute load: 2.78 + +The performance profile reports the fraction of workloads within each factor of +the fastest implementation for that workload. It is an aggregate view, not a +claim that all workloads are equally representative. The heatmaps preserve the +individual results. These microbenchmarks describe the listed operations, element +types, sizes, compiler, allocator, and machine—not every application. diff --git a/comparisons/benchmark-results/README.md b/comparisons/benchmark-results/README.md index 9c1d419..2ec9897 100644 --- a/comparisons/benchmark-results/README.md +++ b/comparisons/benchmark-results/README.md @@ -17,5 +17,6 @@ double-count nested owners. Regenerate it with: ```console uv run --project comparisons/tools --locked python comparisons/tools/generate_report.py \ - comparisons/benchmark-results/linux-x86_64.json + comparisons/benchmark-results/linux-x86_64.json \ + comparisons/benchmark-results/macos-aarch64.json ``` diff --git a/comparisons/benchmark-results/graphics/macos-aarch64-cpu-heatmap.svg b/comparisons/benchmark-results/graphics/macos-aarch64-cpu-heatmap.svg new file mode 100644 index 0000000..a20e313 --- /dev/null +++ b/comparisons/benchmark-results/graphics/macos-aarch64-cpu-heatmap.svg @@ -0,0 +1,4246 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/graphics/macos-aarch64-cpu-profile.svg b/comparisons/benchmark-results/graphics/macos-aarch64-cpu-profile.svg new file mode 100644 index 0000000..0e76c1a --- /dev/null +++ b/comparisons/benchmark-results/graphics/macos-aarch64-cpu-profile.svg @@ -0,0 +1,1879 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/graphics/macos-aarch64-memory-requested-heatmap.svg b/comparisons/benchmark-results/graphics/macos-aarch64-memory-requested-heatmap.svg new file mode 100644 index 0000000..4e4b48d --- /dev/null +++ b/comparisons/benchmark-results/graphics/macos-aarch64-memory-requested-heatmap.svg @@ -0,0 +1,3287 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/graphics/macos-aarch64-memory-usable-heatmap.svg b/comparisons/benchmark-results/graphics/macos-aarch64-memory-usable-heatmap.svg new file mode 100644 index 0000000..f3aed51 --- /dev/null +++ b/comparisons/benchmark-results/graphics/macos-aarch64-memory-usable-heatmap.svg @@ -0,0 +1,3248 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/macos-aarch64.json b/comparisons/benchmark-results/macos-aarch64.json new file mode 100644 index 0000000..e108602 --- /dev/null +++ b/comparisons/benchmark-results/macos-aarch64.json @@ -0,0 +1,2791 @@ +{ + "allocations": [ + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "empty", + "len": "10000", + "live_requested": "240000", + "live_usable": "262144", + "moved_reallocations": "0", + "owner_bytes": "240000", + "peak_requested": "240000", + "peak_usable": "262144", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "empty", + "len": "10000", + "live_requested": "80000", + "live_usable": "98304", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "80000", + "peak_usable": "98304", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "empty", + "len": "10000", + "live_requested": "80000", + "live_usable": "98304", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "80000", + "peak_usable": "98304", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "empty", + "len": "10000", + "live_requested": "400000", + "live_usable": "425984", + "moved_reallocations": "0", + "owner_bytes": "400000", + "peak_requested": "400000", + "peak_usable": "425984", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "empty", + "len": "10000", + "live_requested": "720000", + "live_usable": "720896", + "moved_reallocations": "0", + "owner_bytes": "720000", + "peak_requested": "720000", + "peak_usable": "720896", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "2001", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "2001", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "sparse", + "len": "10000", + "live_requested": "304000", + "live_usable": "326144", + "moved_reallocations": "0", + "owner_bytes": "240000", + "peak_requested": "304000", + "peak_usable": "326144", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "2001", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "2001", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "sparse", + "len": "10000", + "live_requested": "160000", + "live_usable": "194304", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "160000", + "peak_usable": "194304", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "2001", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "2001", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "sparse", + "len": "10000", + "live_requested": "176000", + "live_usable": "194304", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "176000", + "peak_usable": "194304", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "sparse", + "len": "10000", + "live_requested": "400000", + "live_usable": "425984", + "moved_reallocations": "0", + "owner_bytes": "400000", + "peak_requested": "400000", + "peak_usable": "425984", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "sparse", + "len": "10000", + "live_requested": "720000", + "live_usable": "720896", + "moved_reallocations": "0", + "owner_bytes": "720000", + "peak_requested": "720000", + "peak_usable": "720896", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "10001", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "10001", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "small", + "len": "10000", + "live_requested": "560000", + "live_usable": "582144", + "moved_reallocations": "0", + "owner_bytes": "240000", + "peak_requested": "560000", + "peak_usable": "582144", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "10001", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "10001", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "small", + "len": "10000", + "live_requested": "480000", + "live_usable": "578304", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "480000", + "peak_usable": "578304", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "10001", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "10001", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "small", + "len": "10000", + "live_requested": "560000", + "live_usable": "578304", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "560000", + "peak_usable": "578304", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "small", + "len": "10000", + "live_requested": "400000", + "live_usable": "425984", + "moved_reallocations": "0", + "owner_bytes": "400000", + "peak_requested": "400000", + "peak_usable": "425984", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "nested", + "capacity": "10000", + "container_count": "10000", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "small", + "len": "10000", + "live_requested": "720000", + "live_usable": "720896", + "moved_reallocations": "0", + "owner_bytes": "720000", + "peak_requested": "720000", + "peak_usable": "720896", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "32", + "live_usable": "32", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "32", + "peak_usable": "32", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "40", + "live_usable": "48", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "40", + "peak_usable": "48", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "48", + "live_usable": "48", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "48", + "peak_usable": "48", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "1", + "len": "1", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "40", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "build_growing", + "capacity": "8", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "1", + "len": "1", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "72", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "8", + "live_usable": "16", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "8", + "peak_usable": "16", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "16", + "live_usable": "16", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "16", + "peak_usable": "16", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "24", + "live_usable": "32", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "24", + "peak_usable": "32", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "1", + "len": "1", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "40", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "8", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "1", + "len": "1", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "72", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "1", + "live_usable": "16", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "1", + "peak_usable": "16", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "9", + "live_usable": "16", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "9", + "peak_usable": "16", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1", + "len": "1", + "live_requested": "17", + "live_usable": "32", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "17", + "peak_usable": "32", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "0", + "element_size": "1", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "1", + "len": "1", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "8", + "container_count": "1", + "deallocations": "0", + "element_size": "1", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "1", + "len": "1", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "32", + "live_usable": "32", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "32", + "peak_usable": "32", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "40", + "live_usable": "48", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "40", + "peak_usable": "48", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "48", + "live_usable": "48", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "48", + "peak_usable": "48", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "build_growing", + "capacity": "4", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "4", + "len": "4", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "40", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "build_growing", + "capacity": "8", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "4", + "len": "4", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "72", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "32", + "live_usable": "32", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "32", + "peak_usable": "32", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "40", + "live_usable": "48", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "40", + "peak_usable": "48", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "48", + "live_usable": "48", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "48", + "peak_usable": "48", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "4", + "len": "4", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "40", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "8", + "container_count": "1", + "deallocations": "0", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "4", + "len": "4", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "72", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "4", + "live_usable": "16", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "4", + "peak_usable": "16", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "12", + "live_usable": "16", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "12", + "peak_usable": "16", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "4", + "len": "4", + "live_requested": "20", + "live_usable": "32", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "20", + "peak_usable": "32", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "4", + "container_count": "1", + "deallocations": "0", + "element_size": "1", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "4", + "len": "4", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "0", + "benchmark": "push_reserved", + "capacity": "8", + "container_count": "1", + "deallocations": "0", + "element_size": "1", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "4", + "len": "4", + "live_requested": "0", + "live_usable": "0", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "0", + "peak_usable": "0", + "reallocations": "0", + "spilled_count": "0" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "3", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "5", + "owner_bytes": "24", + "peak_requested": "8192", + "peak_usable": "8192", + "reallocations": "8", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "3", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8200", + "live_usable": "8704", + "moved_reallocations": "5", + "owner_bytes": "8", + "peak_requested": "8200", + "peak_usable": "8704", + "reallocations": "8", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "2", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8208", + "live_usable": "8704", + "moved_reallocations": "6", + "owner_bytes": "8", + "peak_requested": "8208", + "peak_usable": "8704", + "reallocations": "8", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "3", + "inline_capacity": "4", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "4", + "owner_bytes": "40", + "peak_requested": "8192", + "peak_usable": "8192", + "reallocations": "7", + "spilled_count": "1" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "build_growing", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "3", + "inline_capacity": "8", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "3", + "owner_bytes": "72", + "peak_requested": "8192", + "peak_usable": "8192", + "reallocations": "6", + "spilled_count": "1" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "8192", + "peak_usable": "8192", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8200", + "live_usable": "8704", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "8200", + "peak_usable": "8704", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8208", + "live_usable": "8704", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "8208", + "peak_usable": "8704", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "0", + "owner_bytes": "40", + "peak_requested": "8192", + "peak_usable": "8192", + "reallocations": "0", + "spilled_count": "1" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "8", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "0", + "owner_bytes": "72", + "peak_requested": "8192", + "peak_usable": "8192", + "reallocations": "0", + "spilled_count": "1" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "Vec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "1024", + "live_usable": "1024", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "1024", + "peak_usable": "1024", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "JackVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "1032", + "live_usable": "1536", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "1032", + "peak_usable": "1536", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "ThinVec", + "in_place_reallocations": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "1040", + "live_usable": "1536", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "1040", + "peak_usable": "1536", + "reallocations": "0", + "spilled_count": "na" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "SmallVec4", + "in_place_reallocations": "0", + "inline_capacity": "4", + "input": "1024", + "len": "1024", + "live_requested": "1024", + "live_usable": "1024", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "1024", + "peak_usable": "1024", + "reallocations": "0", + "spilled_count": "1" + }, + { + "after_drop_requested": "0", + "after_drop_usable": "0", + "allocations": "1", + "benchmark": "push_reserved", + "capacity": "1024", + "container_count": "1", + "deallocations": "1", + "element_size": "1", + "implementation": "SmallVec8", + "in_place_reallocations": "0", + "inline_capacity": "8", + "input": "1024", + "len": "1024", + "live_requested": "1024", + "live_usable": "1024", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "1024", + "peak_usable": "1024", + "reallocations": "0", + "spilled_count": "1" + } + ], + "cpu": [ + { + "benchmark": "append_preallocated/1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 376.3396360153257, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 321.3401990087881, + "ratio_ci95": [ + 0.8369786982025732, + 0.9855837974506486 + ], + "ratio_to_vec": 0.8538412286067826 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 887.0600454237987, + "ratio_ci95": [ + 2.2477722973148513, + 2.7800790084859868 + ], + "ratio_to_vec": 2.4121303097004305 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "win", + "implementation": "SmallVec4", + "median_ns": 261.5621794871795, + "ratio_ci95": [ + 0.5802089948382168, + 0.7981207584379048 + ], + "ratio_to_vec": 0.7210117618079005 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "win", + "implementation": "SmallVec8", + "median_ns": 241.17127913752915, + "ratio_ci95": [ + 0.5968527953661465, + 0.715850834158342 + ], + "ratio_to_vec": 0.6864862927115691 + }, + { + "benchmark": "append_preallocated/4", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 3.2023830034298095, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 4.238788455732392, + "ratio_ci95": [ + 1.288080148963291, + 1.3547909445451984 + ], + "ratio_to_vec": 1.3266165683069502 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 3.649421444180409, + "ratio_ci95": [ + 1.1221715782720416, + 1.2483688462716205 + ], + "ratio_to_vec": 1.136942162025953 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 4.477281804193209, + "ratio_ci95": [ + 1.3800784931693437, + 1.4519753102203097 + ], + "ratio_to_vec": 1.394854097373809 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 4.433418267406246, + "ratio_ci95": [ + 1.3182490923212506, + 1.4272257667601511 + ], + "ratio_to_vec": 1.3867830291535594 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 15.409905364689706, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 16.204453592356668, + "ratio_ci95": [ + 1.0180014759719833, + 1.052022887654811 + ], + "ratio_to_vec": 1.0511318752727106 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 15.950407084740394, + "ratio_ci95": [ + 1.0334557052820086, + 1.0493342990474175 + ], + "ratio_to_vec": 1.0350749538857775 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "win", + "implementation": "SmallVec4", + "median_ns": 2.550070673246914, + "ratio_ci95": [ + 0.16168082982481913, + 0.18635831296854652 + ], + "ratio_to_vec": 0.16526350365699752 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "win", + "implementation": "SmallVec8", + "median_ns": 2.737058800798264, + "ratio_ci95": [ + 0.17101479255730834, + 0.2033245262460249 + ], + "ratio_to_vec": 0.17751977460766444 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 648.0834262101534, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 720.5980377637911, + "ratio_ci95": [ + 1.0045191796118835, + 1.1935777796902787 + ], + "ratio_to_vec": 1.108649457501383 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 724.4890462795527, + "ratio_ci95": [ + 1.0508175808501143, + 1.1832916116164522 + ], + "ratio_to_vec": 1.125698746642296 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 2113.0669697456447, + "ratio_ci95": [ + 1.346500850407733, + 3.4703256704560155 + ], + "ratio_to_vec": 3.248702294757611 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 2102.540689699793, + "ratio_ci95": [ + 1.3558729408454862, + 3.4176580269600394 + ], + "ratio_to_vec": 3.266891930683818 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 18.058758343261974, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 17.53183694886381, + "ratio_ci95": [ + 0.9700870783431199, + 1.085891220202052 + ], + "ratio_to_vec": 0.9710926207066823 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 17.283340814917125, + "ratio_ci95": [ + 0.9559600685995624, + 1.039378819858256 + ], + "ratio_to_vec": 1.0182651670763239 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 17.327295131646345, + "ratio_ci95": [ + 0.9539146135122185, + 1.053027126075033 + ], + "ratio_to_vec": 0.9675364777165495 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "inconclusive", + "implementation": "SmallVec8", + "median_ns": 17.102797439320707, + "ratio_ci95": [ + 0.8959020967623404, + 1.0035191531729528 + ], + "ratio_to_vec": 0.9924704652266627 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 389.94842522446686, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 411.9819623280588, + "ratio_ci95": [ + 1.0482451049069863, + 1.0758494116612087 + ], + "ratio_to_vec": 1.053081681307918 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 497.67316335032535, + "ratio_ci95": [ + 1.26597915136672, + 1.2970369345725496 + ], + "ratio_to_vec": 1.2710676111599168 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 519.1801042379223, + "ratio_ci95": [ + 1.311906413063843, + 1.3487008779393013 + ], + "ratio_to_vec": 1.3259967855468273 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 519.9669977027862, + "ratio_ci95": [ + 1.277521518485431, + 1.3390876933514635 + ], + "ratio_to_vec": 1.3343146672292523 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 570.2348720359503, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 567.3685483870968, + "ratio_ci95": [ + 0.9570791885499799, + 1.0531390804500798 + ], + "ratio_to_vec": 0.9955446766477417 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 374.05797984356195, + "ratio_ci95": [ + 0.6330504596487834, + 0.6701964272473278 + ], + "ratio_to_vec": 0.6501076813670008 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "win", + "implementation": "SmallVec4", + "median_ns": 362.4822522065448, + "ratio_ci95": [ + 0.6255661456415896, + 0.6518301946238453 + ], + "ratio_to_vec": 0.6360368011046358 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "win", + "implementation": "SmallVec8", + "median_ns": 368.75155297129186, + "ratio_ci95": [ + 0.6240699375062317, + 0.6567858708182276 + ], + "ratio_to_vec": 0.6378419292087346 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 289.3007391749246, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 322.3141785166007, + "ratio_ci95": [ + 1.0390401631613524, + 1.176391423677758 + ], + "ratio_to_vec": 1.1346241462655637 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 294.25317969130776, + "ratio_ci95": [ + 0.9885875692664995, + 1.12574992733394 + ], + "ratio_to_vec": 1.0192644044969716 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 285.24132579784754, + "ratio_ci95": [ + 0.940292660285466, + 1.0070999019266513 + ], + "ratio_to_vec": 0.9666965304625968 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec8", + "median_ns": 288.0080992957134, + "ratio_ci95": [ + 0.9577783695912956, + 1.0110337151503739 + ], + "ratio_to_vec": 1.0057081943925696 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 11617.426551226552, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "win", + "implementation": "JackVec", + "median_ns": 9314.571754750266, + "ratio_ci95": [ + 0.7961761716199807, + 0.8068950282621061 + ], + "ratio_to_vec": 0.805170640137743 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 9368.621368339001, + "ratio_ci95": [ + 0.8018612760548246, + 0.8180446475188945 + ], + "ratio_to_vec": 0.8146643489704871 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 23067.21134563532, + "ratio_ci95": [ + 1.8969990270925772, + 2.035937047848296 + ], + "ratio_to_vec": 2.00914928755669 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 22798.722063492063, + "ratio_ci95": [ + 1.951708655581117, + 2.0532883490870932 + ], + "ratio_to_vec": 1.9669017322635094 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 196601.3508064516, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 211247.93002136753, + "ratio_ci95": [ + 1.0116168924847668, + 1.097358995892996 + ], + "ratio_to_vec": 1.0609943088677387 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 210396.8275462963, + "ratio_ci95": [ + 1.0495620027915435, + 1.0836318282581154 + ], + "ratio_to_vec": 1.0756756600854418 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 182436.16944444444, + "ratio_ci95": [ + 0.6633850388302579, + 1.0454112618382463 + ], + "ratio_to_vec": 0.892718024868375 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "win", + "implementation": "SmallVec8", + "median_ns": 150758.0904516129, + "ratio_ci95": [ + 0.7439975182876386, + 0.7847186164187007 + ], + "ratio_to_vec": 0.7670819529473795 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 48617.34550865801, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 49504.635627297794, + "ratio_ci95": [ + 0.998022725352167, + 1.0382403298900105 + ], + "ratio_to_vec": 1.0135215458810203 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 49137.618250229774, + "ratio_ci95": [ + 0.9906235862963682, + 1.0456295205723056 + ], + "ratio_to_vec": 1.0017184871599538 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "win", + "implementation": "SmallVec4", + "median_ns": 25679.18700667881, + "ratio_ci95": [ + 0.5225095211424711, + 0.5782133217711761 + ], + "ratio_to_vec": 0.5281898206907603 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "win", + "implementation": "SmallVec8", + "median_ns": 32746.079340277778, + "ratio_ci95": [ + 0.6433747449937846, + 0.7291024239681683 + ], + "ratio_to_vec": 0.6674773396487986 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 1825.3876603689873, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 3726.4853028503567, + "ratio_ci95": [ + 2.022906320374539, + 2.049256021479456 + ], + "ratio_to_vec": 2.04255775137864 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 3660.726872454145, + "ratio_ci95": [ + 1.9631078790400733, + 2.1367654496817083 + ], + "ratio_to_vec": 2.0054517470081716 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 3776.559579326923, + "ratio_ci95": [ + 2.0459152009212715, + 2.103003089663656 + ], + "ratio_to_vec": 2.065269945915572 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 5636.778715512211, + "ratio_ci95": [ + 3.084498174129891, + 3.11112788845916 + ], + "ratio_to_vec": 3.0971429114970093 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 2688.550117287098, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 2544.0039530644794, + "ratio_ci95": [ + 0.9432671600353816, + 0.9932130160173097 + ], + "ratio_to_vec": 0.9875859082175072 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 2562.218402858696, + "ratio_ci95": [ + 0.9530112109065395, + 0.991313847762415 + ], + "ratio_to_vec": 0.9624483615420418 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 3761.467371079213, + "ratio_ci95": [ + 1.384403195670988, + 1.4954150587777275 + ], + "ratio_to_vec": 1.39716668210039 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 5985.809274850624, + "ratio_ci95": [ + 2.164464061642524, + 2.3747057061963255 + ], + "ratio_to_vec": 2.2233805212643083 + }, + { + "benchmark": "nested_traverse/small", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 18038.168464006478, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_traverse/small", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 18137.06104144897, + "ratio_ci95": [ + 0.9992929413162972, + 1.0453091341508707 + ], + "ratio_to_vec": 1.0054824067997716 + }, + { + "benchmark": "nested_traverse/small", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 18221.910867795392, + "ratio_ci95": [ + 0.9805346561746519, + 1.0449354662536203 + ], + "ratio_to_vec": 1.0310841708378462 + }, + { + "benchmark": "nested_traverse/small", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 18330.28057660967, + "ratio_ci95": [ + 0.9997324801683847, + 1.0542704358041728 + ], + "ratio_to_vec": 1.019259545481273 + }, + { + "benchmark": "nested_traverse/small", + "classification": "inconclusive", + "implementation": "SmallVec8", + "median_ns": 18483.35104166667, + "ratio_ci95": [ + 0.9946029475221954, + 1.0310463814904713 + ], + "ratio_to_vec": 1.007774938645821 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 5214.037268932618, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 5225.068512508452, + "ratio_ci95": [ + 0.9595593378514221, + 1.0611025074391933 + ], + "ratio_to_vec": 0.9827384819740215 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "equivalent", + "implementation": "ThinVec", + "median_ns": 5214.488944802727, + "ratio_ci95": [ + 0.9807486614994811, + 1.0189463202113076 + ], + "ratio_to_vec": 1.0023343062973362 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 5349.031820508816, + "ratio_ci95": [ + 1.0060536811590883, + 1.04624054405033 + ], + "ratio_to_vec": 1.0330763964873455 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 5908.741879429888, + "ratio_ci95": [ + 1.117311172875115, + 1.1583566162049637 + ], + "ratio_to_vec": 1.141957080126436 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 793.1865869738714, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "win", + "implementation": "JackVec", + "median_ns": 647.3710250162444, + "ratio_ci95": [ + 0.8026034342315038, + 0.8783108381843442 + ], + "ratio_to_vec": 0.8295940422317805 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 676.9313787954206, + "ratio_ci95": [ + 0.8526170870210406, + 0.895689701935426 + ], + "ratio_to_vec": 0.8652830970952453 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 1843.2173389425798, + "ratio_ci95": [ + 2.080907414999717, + 2.5154511968667936 + ], + "ratio_to_vec": 2.3189431284719575 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 1878.9362120205737, + "ratio_ci95": [ + 2.1230095860263507, + 2.5546579745457154 + ], + "ratio_to_vec": 2.3708863428937956 + }, + { + "benchmark": "push_preallocated/4", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 2.7158926283260927, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "push_preallocated/4", + "classification": "win", + "implementation": "JackVec", + "median_ns": 1.8597067598049914, + "ratio_ci95": [ + 0.6574664601666137, + 0.6859867825113143 + ], + "ratio_to_vec": 0.680216346019057 + }, + { + "benchmark": "push_preallocated/4", + "classification": "equivalent", + "implementation": "ThinVec", + "median_ns": 2.737276950064732, + "ratio_ci95": [ + 0.9963497762954385, + 1.028564252472458 + ], + "ratio_to_vec": 1.0061324811709702 + }, + { + "benchmark": "push_preallocated/4", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 9.980862553493322, + "ratio_ci95": [ + 3.4340734106611928, + 3.7224469165003136 + ], + "ratio_to_vec": 3.6098490302265036 + }, + { + "benchmark": "push_preallocated/4", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 9.855623164668103, + "ratio_ci95": [ + 3.4702815818782264, + 3.744124678157397 + ], + "ratio_to_vec": 3.654072224639185 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 276.87363409245916, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "win", + "implementation": "JackVec", + "median_ns": 218.82857130897185, + "ratio_ci95": [ + 0.7605132599204222, + 0.791845056955279 + ], + "ratio_to_vec": 0.7770680241922918 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 688.9579365079364, + "ratio_ci95": [ + 2.3135914423091046, + 2.658054215871248 + ], + "ratio_to_vec": 2.488347938098959 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 285.866526342539, + "ratio_ci95": [ + 0.9577509266261036, + 1.0696368118962583 + ], + "ratio_to_vec": 0.9961820964819588 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec8", + "median_ns": 288.86052700773797, + "ratio_ci95": [ + 0.973080156452465, + 1.0715159818301356 + ], + "ratio_to_vec": 1.023853938720083 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 350.561586178118, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 372.41691921896194, + "ratio_ci95": [ + 1.0421087781700906, + 1.1021044887866982 + ], + "ratio_to_vec": 1.0698388925443034 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 401.13869463869463, + "ratio_ci95": [ + 1.125143295925373, + 1.2074067508548247 + ], + "ratio_to_vec": 1.146197274508975 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 498.51028730305836, + "ratio_ci95": [ + 1.3874188818140865, + 1.5008646825170064 + ], + "ratio_to_vec": 1.4192533632809616 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 499.66594832580233, + "ratio_ci95": [ + 1.4065849711065368, + 1.4872316280154165 + ], + "ratio_to_vec": 1.4316793692682255 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 507.01032357473036, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 582.3989961446498, + "ratio_ci95": [ + 1.113059457302559, + 1.1724157589591564 + ], + "ratio_to_vec": 1.1504373571402438 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 688.7254212263332, + "ratio_ci95": [ + 1.3409092302535368, + 1.3658612846749125 + ], + "ratio_to_vec": 1.3584051235296377 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 792.4424670901026, + "ratio_ci95": [ + 1.5519252197639637, + 1.579457962641107 + ], + "ratio_to_vec": 1.5672783884206214 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 793.9940040507751, + "ratio_ci95": [ + 1.5616335022280465, + 1.5722326798503348 + ], + "ratio_to_vec": 1.5622350744192994 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 59.406774527142574, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 59.16517112952789, + "ratio_ci95": [ + 0.986370904585429, + 1.2372133602030488 + ], + "ratio_to_vec": 1.012012488766307 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 59.728405519632986, + "ratio_ci95": [ + 0.9843702463690198, + 1.0725467967942677 + ], + "ratio_to_vec": 1.0059489346738753 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "equivalent", + "implementation": "SmallVec4", + "median_ns": 58.998593956586504, + "ratio_ci95": [ + 0.9720580858639529, + 1.013188616374075 + ], + "ratio_to_vec": 0.9940082243179592 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "equivalent", + "implementation": "SmallVec8", + "median_ns": 59.42766924125398, + "ratio_ci95": [ + 0.9842348468001347, + 1.0134839065141121 + ], + "ratio_to_vec": 1.0003805524165696 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 1.593718663268371, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "equivalent", + "implementation": "JackVec", + "median_ns": 1.5935747225501244, + "ratio_ci95": [ + 0.9990943722141988, + 1.0110422342672292 + ], + "ratio_to_vec": 0.9999582499659367 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "equivalent", + "implementation": "ThinVec", + "median_ns": 1.5935943653161488, + "ratio_ci95": [ + 0.9995949989537691, + 1.01961599150134 + ], + "ratio_to_vec": 1.0000517993382827 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "equivalent", + "implementation": "SmallVec4", + "median_ns": 1.5935295655067319, + "ratio_ci95": [ + 0.9948317500330298, + 1.0002530950920752 + ], + "ratio_to_vec": 0.9994949068222467 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "equivalent", + "implementation": "SmallVec8", + "median_ns": 1.5940139666800035, + "ratio_ci95": [ + 0.9996966604295245, + 1.0197936659162616 + ], + "ratio_to_vec": 1.0001059263060155 + } + ], + "metadata": { + "affinity_cpu": null, + "allocator": { + "effective_environment": { + "DYLD_INSERT_LIBRARIES": null, + "LD_PRELOAD": null + }, + "inherited_environment": { + "DYLD_INSERT_LIBRARIES": null, + "LD_PRELOAD": null + }, + "policy": "system" + }, + "authoritative": true, + "cargo": "cargo 1.97.0 (c980f4866 2026-06-30)", + "compiler_identity": { + "LLVM_version": "22.1.6", + "binary": "rustc", + "commit_date": "2026-07-07", + "commit_hash": "2d8144b7880597b6e6d3dfd63a9a9efae3f533d3", + "host": "aarch64-apple-darwin", + "release": "1.97.0" + }, + "cpu_model": "Apple M3 Pro", + "git_commit": "2dc82e0656ba2c3997c4dc2dd26b905ce621bb2f", + "git_dirty": false, + "host_issues": [], + "load_average": [ + 1.64453125, + 2.9140625, + 3.33251953125 + ], + "logical_cpus": 11, + "low_power_mode": "Battery Power:\n Sleep On Power Button 1\n lowpowermode 0\n standby 1\n hibernatemode 3\n powernap 1\n hibernatefile /var/vm/sleepimage\n ttyskeepawake 1\n womp 0\n displaysleep 2\n networkoversleep 0\n sleep 1\n lessbright 1\n tcpkeepalive 1\n disksleep 10\nAC Power:\n Sleep On Power Button 1\n lowpowermode 0\n standby 1\n hibernatemode 3\n powernap 1\n hibernatefile /var/vm/sleepimage\n ttyskeepawake 1\n womp 1\n displaysleep 10\n networkoversleep 0\n sleep 1\n tcpkeepalive 1\n disksleep 10", + "machine": "arm64", + "memory_bytes": "19327352832", + "platform": "macOS-15.7.4-arm64-arm-64bit", + "processor": "arm", + "runtime_audits": [ + { + "busy_processes": [], + "cpu_idle_percent": 95.33, + "label": "after-build", + "load_average": [ + 2.38232421875, + 3.0126953125, + 3.3583984375 + ], + "timestamp_utc": "2026-07-12T16:00:39.257557+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 94.83, + "label": "after-round-1", + "load_average": [ + 2.35302734375, + 2.23486328125, + 2.806640625 + ], + "timestamp_utc": "2026-07-12T16:06:50.919491+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 92.2, + "label": "settled-after-round-1", + "load_average": [ + 2.24462890625, + 2.21435546875, + 2.7958984375 + ], + "timestamp_utc": "2026-07-12T16:06:56.358402+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 95.22, + "label": "after-round-2", + "load_average": [ + 2.77685546875, + 2.38232421875, + 2.6435546875 + ], + "timestamp_utc": "2026-07-12T16:13:00.387744+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 95.75, + "label": "settled-after-round-2", + "load_average": [ + 2.4228515625, + 2.31982421875, + 2.6181640625 + ], + "timestamp_utc": "2026-07-12T16:13:05.816739+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 94.29, + "label": "after-round-3", + "load_average": [ + 1.89697265625, + 1.97998046875, + 2.3251953125 + ], + "timestamp_utc": "2026-07-12T16:19:17.607928+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 96.15, + "label": "settled-after-round-3", + "load_average": [ + 1.83837890625, + 1.9638671875, + 2.3154296875 + ], + "timestamp_utc": "2026-07-12T16:19:23.040899+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 97.31, + "label": "after-round-4", + "load_average": [ + 1.87353515625, + 1.9755859375, + 2.20703125 + ], + "timestamp_utc": "2026-07-12T16:25:31.331367+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 95.89, + "label": "settled-after-round-4", + "load_average": [ + 1.80322265625, + 1.958984375, + 2.19970703125 + ], + "timestamp_utc": "2026-07-12T16:25:36.764518+00:00" + }, + { + "busy_processes": [ + { + "command": "/System/Library/PrivateFrameworks/StreamingExtractor.framework/Versions/A/XPCServices/STExtractionService.privileged.xpc/Contents/MacOS/STExtractionService.privileged", + "cpu_percent": 97.5, + "pid": 4184 + } + ], + "cpu_idle_percent": 88.2, + "label": "after-round-5", + "load_average": [ + 2.09375, + 1.89794921875, + 2.064453125 + ], + "timestamp_utc": "2026-07-12T16:31:48.788613+00:00" + }, + { + "busy_processes": [ + { + "command": "/usr/libexec/mobileassetd", + "cpu_percent": 49.6, + "pid": 179 + } + ], + "cpu_idle_percent": 96.7, + "label": "settled-after-round-5", + "load_average": [ + 1.599609375, + 1.7880859375, + 2.0126953125 + ], + "timestamp_utc": "2026-07-12T16:32:41.130722+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 98.4, + "label": "after-allocations", + "load_average": [ + 1.55126953125, + 1.77490234375, + 2.00634765625 + ], + "timestamp_utc": "2026-07-12T16:32:46.940129+00:00" + } + ], + "rustc": "rustc 1.97.0 (2d8144b78 2026-07-07)\nbinary: rustc\ncommit-hash: 2d8144b7880597b6e6d3dfd63a9a9efae3f533d3\ncommit-date: 2026-07-07\nhost: aarch64-apple-darwin\nrelease: 1.97.0\nLLVM version: 22.1.6", + "timestamp_utc": "2026-07-12T16:00:19.495816+00:00" + }, + "platform_id": "macos-aarch64", + "practical_equivalence_band": [ + 0.97, + 1.03 + ], + "round_count": 5, + "schema_version": 1, + "toolchain": "1.97.0" +} diff --git a/comparisons/benchmark-results/macos-aarch64.md b/comparisons/benchmark-results/macos-aarch64.md new file mode 100644 index 0000000..7e67996 --- /dev/null +++ b/comparisons/benchmark-results/macos-aarch64.md @@ -0,0 +1,191 @@ +# JackVec comparison: macos-aarch64 + +- Commit: `2dc82e0656ba2c3997c4dc2dd26b905ce621bb2f` +- Rust: `rustc 1.97.0 (2d8144b78 2026-07-07)` +- Platform: `macOS-15.7.4-arm64-arm-64bit` +- Allocator policy: `system`; effective override environment: `{'LD_PRELOAD': None, 'DYLD_INSERT_LIBRARIES': None}` +Rounds: 5; practical-equivalence band: 0.97–1.03× Vec. + +A win or loss requires the complete paired bootstrap interval to clear the practical-equivalence band. Results that cross a boundary are reported as inconclusive. + +## CPU + +| Benchmark | Implementation | Median ns | Ratio | 95% interval | Result | +|---|---:|---:|---:|---:|---| +| append_preallocated/1024 | Vec | 376.340 | 1.000× | 1.000–1.000× | baseline | +| append_preallocated/1024 | JackVec | 321.340 | 0.854× | 0.837–0.986× | inconclusive | +| append_preallocated/1024 | ThinVec | 887.060 | 2.412× | 2.248–2.780× | loss | +| append_preallocated/1024 | SmallVec4 | 261.562 | 0.721× | 0.580–0.798× | win | +| append_preallocated/1024 | SmallVec8 | 241.171 | 0.686× | 0.597–0.716× | win | +| append_preallocated/4 | Vec | 3.202 | 1.000× | 1.000–1.000× | baseline | +| append_preallocated/4 | JackVec | 4.239 | 1.327× | 1.288–1.355× | loss | +| append_preallocated/4 | ThinVec | 3.649 | 1.137× | 1.122–1.248× | loss | +| append_preallocated/4 | SmallVec4 | 4.477 | 1.395× | 1.380–1.452× | loss | +| append_preallocated/4 | SmallVec8 | 4.433 | 1.387× | 1.318–1.427× | loss | +| build_growing_and_drop/1 | Vec | 15.410 | 1.000× | 1.000–1.000× | baseline | +| build_growing_and_drop/1 | JackVec | 16.204 | 1.051× | 1.018–1.052× | inconclusive | +| build_growing_and_drop/1 | ThinVec | 15.950 | 1.035× | 1.033–1.049× | loss | +| build_growing_and_drop/1 | SmallVec4 | 2.550 | 0.165× | 0.162–0.186× | win | +| build_growing_and_drop/1 | SmallVec8 | 2.737 | 0.178× | 0.171–0.203× | win | +| build_growing_and_drop/1024 | Vec | 648.083 | 1.000× | 1.000–1.000× | baseline | +| build_growing_and_drop/1024 | JackVec | 720.598 | 1.109× | 1.005–1.194× | inconclusive | +| build_growing_and_drop/1024 | ThinVec | 724.489 | 1.126× | 1.051–1.183× | loss | +| build_growing_and_drop/1024 | SmallVec4 | 2113.067 | 3.249× | 1.347–3.470× | loss | +| build_growing_and_drop/1024 | SmallVec8 | 2102.541 | 3.267× | 1.356–3.418× | loss | +| build_growing_and_drop/4 | Vec | 18.059 | 1.000× | 1.000–1.000× | baseline | +| build_growing_and_drop/4 | JackVec | 17.532 | 0.971× | 0.970–1.086× | inconclusive | +| build_growing_and_drop/4 | ThinVec | 17.283 | 1.018× | 0.956–1.039× | inconclusive | +| build_growing_and_drop/4 | SmallVec4 | 17.327 | 0.968× | 0.954–1.053× | inconclusive | +| build_growing_and_drop/4 | SmallVec8 | 17.103 | 0.992× | 0.896–1.004× | inconclusive | +| dedup_adjacent_pairs/64_byte | Vec | 389.948 | 1.000× | 1.000–1.000× | baseline | +| dedup_adjacent_pairs/64_byte | JackVec | 411.982 | 1.053× | 1.048–1.076× | loss | +| dedup_adjacent_pairs/64_byte | ThinVec | 497.673 | 1.271× | 1.266–1.297× | loss | +| dedup_adjacent_pairs/64_byte | SmallVec4 | 519.180 | 1.326× | 1.312–1.349× | loss | +| dedup_adjacent_pairs/64_byte | SmallVec8 | 519.967 | 1.334× | 1.278–1.339× | loss | +| dedup_adjacent_pairs/u64 | Vec | 570.235 | 1.000× | 1.000–1.000× | baseline | +| dedup_adjacent_pairs/u64 | JackVec | 567.369 | 0.996× | 0.957–1.053× | inconclusive | +| dedup_adjacent_pairs/u64 | ThinVec | 374.058 | 0.650× | 0.633–0.670× | win | +| dedup_adjacent_pairs/u64 | SmallVec4 | 362.482 | 0.636× | 0.626–0.652× | win | +| dedup_adjacent_pairs/u64 | SmallVec8 | 368.752 | 0.638× | 0.624–0.657× | win | +| extend_reserved_1024 | Vec | 289.301 | 1.000× | 1.000–1.000× | baseline | +| extend_reserved_1024 | JackVec | 322.314 | 1.135× | 1.039–1.176× | loss | +| extend_reserved_1024 | ThinVec | 294.253 | 1.019× | 0.989–1.126× | inconclusive | +| extend_reserved_1024 | SmallVec4 | 285.241 | 0.967× | 0.940–1.007× | inconclusive | +| extend_reserved_1024 | SmallVec8 | 288.008 | 1.006× | 0.958–1.011× | inconclusive | +| nested_construct_and_drop/empty | Vec | 11617.427 | 1.000× | 1.000–1.000× | baseline | +| nested_construct_and_drop/empty | JackVec | 9314.572 | 0.805× | 0.796–0.807× | win | +| nested_construct_and_drop/empty | ThinVec | 9368.621 | 0.815× | 0.802–0.818× | win | +| nested_construct_and_drop/empty | SmallVec4 | 23067.211 | 2.009× | 1.897–2.036× | loss | +| nested_construct_and_drop/empty | SmallVec8 | 22798.722 | 1.967× | 1.952–2.053× | loss | +| nested_construct_and_drop/small | Vec | 196601.351 | 1.000× | 1.000–1.000× | baseline | +| nested_construct_and_drop/small | JackVec | 211247.930 | 1.061× | 1.012–1.097× | inconclusive | +| nested_construct_and_drop/small | ThinVec | 210396.828 | 1.076× | 1.050–1.084× | loss | +| nested_construct_and_drop/small | SmallVec4 | 182436.169 | 0.893× | 0.663–1.045× | inconclusive | +| nested_construct_and_drop/small | SmallVec8 | 150758.090 | 0.767× | 0.744–0.785× | win | +| nested_construct_and_drop/sparse | Vec | 48617.346 | 1.000× | 1.000–1.000× | baseline | +| nested_construct_and_drop/sparse | JackVec | 49504.636 | 1.014× | 0.998–1.038× | inconclusive | +| nested_construct_and_drop/sparse | ThinVec | 49137.618 | 1.002× | 0.991–1.046× | inconclusive | +| nested_construct_and_drop/sparse | SmallVec4 | 25679.187 | 0.528× | 0.523–0.578× | win | +| nested_construct_and_drop/sparse | SmallVec8 | 32746.079 | 0.667× | 0.643–0.729× | win | +| nested_metadata_scan_sparse | Vec | 1825.388 | 1.000× | 1.000–1.000× | baseline | +| nested_metadata_scan_sparse | JackVec | 3726.485 | 2.043× | 2.023–2.049× | loss | +| nested_metadata_scan_sparse | ThinVec | 3660.727 | 2.005× | 1.963–2.137× | loss | +| nested_metadata_scan_sparse | SmallVec4 | 3776.560 | 2.065× | 2.046–2.103× | loss | +| nested_metadata_scan_sparse | SmallVec8 | 5636.779 | 3.097× | 3.084–3.111× | loss | +| nested_traverse/empty | Vec | 2688.550 | 1.000× | 1.000–1.000× | baseline | +| nested_traverse/empty | JackVec | 2544.004 | 0.988× | 0.943–0.993× | inconclusive | +| nested_traverse/empty | ThinVec | 2562.218 | 0.962× | 0.953–0.991× | inconclusive | +| nested_traverse/empty | SmallVec4 | 3761.467 | 1.397× | 1.384–1.495× | loss | +| nested_traverse/empty | SmallVec8 | 5985.809 | 2.223× | 2.164–2.375× | loss | +| nested_traverse/small | Vec | 18038.168 | 1.000× | 1.000–1.000× | baseline | +| nested_traverse/small | JackVec | 18137.061 | 1.005× | 0.999–1.045× | inconclusive | +| nested_traverse/small | ThinVec | 18221.911 | 1.031× | 0.981–1.045× | inconclusive | +| nested_traverse/small | SmallVec4 | 18330.281 | 1.019× | 1.000–1.054× | inconclusive | +| nested_traverse/small | SmallVec8 | 18483.351 | 1.008× | 0.995–1.031× | inconclusive | +| nested_traverse/sparse | Vec | 5214.037 | 1.000× | 1.000–1.000× | baseline | +| nested_traverse/sparse | JackVec | 5225.069 | 0.983× | 0.960–1.061× | inconclusive | +| nested_traverse/sparse | ThinVec | 5214.489 | 1.002× | 0.981–1.019× | equivalent | +| nested_traverse/sparse | SmallVec4 | 5349.032 | 1.033× | 1.006–1.046× | inconclusive | +| nested_traverse/sparse | SmallVec8 | 5908.742 | 1.142× | 1.117–1.158× | loss | +| push_preallocated/1024 | Vec | 793.187 | 1.000× | 1.000–1.000× | baseline | +| push_preallocated/1024 | JackVec | 647.371 | 0.830× | 0.803–0.878× | win | +| push_preallocated/1024 | ThinVec | 676.931 | 0.865× | 0.853–0.896× | win | +| push_preallocated/1024 | SmallVec4 | 1843.217 | 2.319× | 2.081–2.515× | loss | +| push_preallocated/1024 | SmallVec8 | 1878.936 | 2.371× | 2.123–2.555× | loss | +| push_preallocated/4 | Vec | 2.716 | 1.000× | 1.000–1.000× | baseline | +| push_preallocated/4 | JackVec | 1.860 | 0.680× | 0.657–0.686× | win | +| push_preallocated/4 | ThinVec | 2.737 | 1.006× | 0.996–1.029× | equivalent | +| push_preallocated/4 | SmallVec4 | 9.981 | 3.610× | 3.434–3.722× | loss | +| push_preallocated/4 | SmallVec8 | 9.856 | 3.654× | 3.470–3.744× | loss | +| resize_reserved_1024 | Vec | 276.874 | 1.000× | 1.000–1.000× | baseline | +| resize_reserved_1024 | JackVec | 218.829 | 0.777× | 0.761–0.792× | win | +| resize_reserved_1024 | ThinVec | 688.958 | 2.488× | 2.314–2.658× | loss | +| resize_reserved_1024 | SmallVec4 | 285.867 | 0.996× | 0.958–1.070× | inconclusive | +| resize_reserved_1024 | SmallVec8 | 288.861 | 1.024× | 0.973–1.072× | inconclusive | +| retain_mixed/64_byte | Vec | 350.562 | 1.000× | 1.000–1.000× | baseline | +| retain_mixed/64_byte | JackVec | 372.417 | 1.070× | 1.042–1.102× | loss | +| retain_mixed/64_byte | ThinVec | 401.139 | 1.146× | 1.125–1.207× | loss | +| retain_mixed/64_byte | SmallVec4 | 498.510 | 1.419× | 1.387–1.501× | loss | +| retain_mixed/64_byte | SmallVec8 | 499.666 | 1.432× | 1.407–1.487× | loss | +| retain_mixed/u64 | Vec | 507.010 | 1.000× | 1.000–1.000× | baseline | +| retain_mixed/u64 | JackVec | 582.399 | 1.150× | 1.113–1.172× | loss | +| retain_mixed/u64 | ThinVec | 688.725 | 1.358× | 1.341–1.366× | loss | +| retain_mixed/u64 | SmallVec4 | 792.442 | 1.567× | 1.552–1.579× | loss | +| retain_mixed/u64 | SmallVec8 | 793.994 | 1.562× | 1.562–1.572× | loss | +| sequential_iteration/1024 | Vec | 59.407 | 1.000× | 1.000–1.000× | baseline | +| sequential_iteration/1024 | JackVec | 59.165 | 1.012× | 0.986–1.237× | inconclusive | +| sequential_iteration/1024 | ThinVec | 59.728 | 1.006× | 0.984–1.073× | inconclusive | +| sequential_iteration/1024 | SmallVec4 | 58.999 | 0.994× | 0.972–1.013× | equivalent | +| sequential_iteration/1024 | SmallVec8 | 59.428 | 1.000× | 0.984–1.013× | equivalent | +| sequential_iteration/8 | Vec | 1.594 | 1.000× | 1.000–1.000× | baseline | +| sequential_iteration/8 | JackVec | 1.594 | 1.000× | 0.999–1.011× | equivalent | +| sequential_iteration/8 | ThinVec | 1.594 | 1.000× | 1.000–1.020× | equivalent | +| sequential_iteration/8 | SmallVec4 | 1.594 | 0.999× | 0.995–1.000× | equivalent | +| sequential_iteration/8 | SmallVec8 | 1.594 | 1.000× | 1.000–1.020× | equivalent | + +## Allocations + +Owner bytes describe the collection values themselves. Requested and usable bytes describe allocator-visible storage; they must not be added together for nested workloads. + +| Benchmark | Input | Element B | Implementation | Owner B | Live requested B | Live usable B | Allocs | Reallocs | Spilled | +|---|---:|---:|---|---:|---:|---:|---:|---:|---:| +| nested | empty | 8 | Vec | 240000 | 240000 | 262144 | 1 | 0 | na | +| nested | empty | 8 | JackVec | 80000 | 80000 | 98304 | 1 | 0 | na | +| nested | empty | 8 | ThinVec | 80000 | 80000 | 98304 | 1 | 0 | na | +| nested | empty | 8 | SmallVec4 | 400000 | 400000 | 425984 | 1 | 0 | 0 | +| nested | empty | 8 | SmallVec8 | 720000 | 720000 | 720896 | 1 | 0 | 0 | +| nested | sparse | 8 | Vec | 240000 | 304000 | 326144 | 2001 | 0 | na | +| nested | sparse | 8 | JackVec | 80000 | 160000 | 194304 | 2001 | 0 | na | +| nested | sparse | 8 | ThinVec | 80000 | 176000 | 194304 | 2001 | 0 | na | +| nested | sparse | 8 | SmallVec4 | 400000 | 400000 | 425984 | 1 | 0 | 0 | +| nested | sparse | 8 | SmallVec8 | 720000 | 720000 | 720896 | 1 | 0 | 0 | +| nested | small | 8 | Vec | 240000 | 560000 | 582144 | 10001 | 0 | na | +| nested | small | 8 | JackVec | 80000 | 480000 | 578304 | 10001 | 0 | na | +| nested | small | 8 | ThinVec | 80000 | 560000 | 578304 | 10001 | 0 | na | +| nested | small | 8 | SmallVec4 | 400000 | 400000 | 425984 | 1 | 0 | 0 | +| nested | small | 8 | SmallVec8 | 720000 | 720000 | 720896 | 1 | 0 | 0 | +| build_growing | 1 | 8 | Vec | 24 | 32 | 32 | 1 | 0 | na | +| build_growing | 1 | 8 | JackVec | 8 | 40 | 48 | 1 | 0 | na | +| build_growing | 1 | 8 | ThinVec | 8 | 48 | 48 | 1 | 0 | na | +| build_growing | 1 | 8 | SmallVec4 | 40 | 0 | 0 | 0 | 0 | 0 | +| build_growing | 1 | 8 | SmallVec8 | 72 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 1 | 8 | Vec | 24 | 8 | 16 | 1 | 0 | na | +| push_reserved | 1 | 8 | JackVec | 8 | 16 | 16 | 1 | 0 | na | +| push_reserved | 1 | 8 | ThinVec | 8 | 24 | 32 | 1 | 0 | na | +| push_reserved | 1 | 8 | SmallVec4 | 40 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 1 | 8 | SmallVec8 | 72 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 1 | 1 | Vec | 24 | 1 | 16 | 1 | 0 | na | +| push_reserved | 1 | 1 | JackVec | 8 | 9 | 16 | 1 | 0 | na | +| push_reserved | 1 | 1 | ThinVec | 8 | 17 | 32 | 1 | 0 | na | +| push_reserved | 1 | 1 | SmallVec4 | 24 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 1 | 1 | SmallVec8 | 24 | 0 | 0 | 0 | 0 | 0 | +| build_growing | 4 | 8 | Vec | 24 | 32 | 32 | 1 | 0 | na | +| build_growing | 4 | 8 | JackVec | 8 | 40 | 48 | 1 | 0 | na | +| build_growing | 4 | 8 | ThinVec | 8 | 48 | 48 | 1 | 0 | na | +| build_growing | 4 | 8 | SmallVec4 | 40 | 0 | 0 | 0 | 0 | 0 | +| build_growing | 4 | 8 | SmallVec8 | 72 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 4 | 8 | Vec | 24 | 32 | 32 | 1 | 0 | na | +| push_reserved | 4 | 8 | JackVec | 8 | 40 | 48 | 1 | 0 | na | +| push_reserved | 4 | 8 | ThinVec | 8 | 48 | 48 | 1 | 0 | na | +| push_reserved | 4 | 8 | SmallVec4 | 40 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 4 | 8 | SmallVec8 | 72 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 4 | 1 | Vec | 24 | 4 | 16 | 1 | 0 | na | +| push_reserved | 4 | 1 | JackVec | 8 | 12 | 16 | 1 | 0 | na | +| push_reserved | 4 | 1 | ThinVec | 8 | 20 | 32 | 1 | 0 | na | +| push_reserved | 4 | 1 | SmallVec4 | 24 | 0 | 0 | 0 | 0 | 0 | +| push_reserved | 4 | 1 | SmallVec8 | 24 | 0 | 0 | 0 | 0 | 0 | +| build_growing | 1024 | 8 | Vec | 24 | 8192 | 8192 | 1 | 8 | na | +| build_growing | 1024 | 8 | JackVec | 8 | 8200 | 8704 | 1 | 8 | na | +| build_growing | 1024 | 8 | ThinVec | 8 | 8208 | 8704 | 1 | 8 | na | +| build_growing | 1024 | 8 | SmallVec4 | 40 | 8192 | 8192 | 1 | 7 | 1 | +| build_growing | 1024 | 8 | SmallVec8 | 72 | 8192 | 8192 | 1 | 6 | 1 | +| push_reserved | 1024 | 8 | Vec | 24 | 8192 | 8192 | 1 | 0 | na | +| push_reserved | 1024 | 8 | JackVec | 8 | 8200 | 8704 | 1 | 0 | na | +| push_reserved | 1024 | 8 | ThinVec | 8 | 8208 | 8704 | 1 | 0 | na | +| push_reserved | 1024 | 8 | SmallVec4 | 40 | 8192 | 8192 | 1 | 0 | 1 | +| push_reserved | 1024 | 8 | SmallVec8 | 72 | 8192 | 8192 | 1 | 0 | 1 | +| push_reserved | 1024 | 1 | Vec | 24 | 1024 | 1024 | 1 | 0 | na | +| push_reserved | 1024 | 1 | JackVec | 8 | 1032 | 1536 | 1 | 0 | na | +| push_reserved | 1024 | 1 | ThinVec | 8 | 1040 | 1536 | 1 | 0 | na | +| push_reserved | 1024 | 1 | SmallVec4 | 24 | 1024 | 1024 | 1 | 0 | 1 | +| push_reserved | 1024 | 1 | SmallVec8 | 24 | 1024 | 1024 | 1 | 0 | 1 | diff --git a/comparisons/tools/generate_report.py b/comparisons/tools/generate_report.py index 8a918a3..8224264 100644 --- a/comparisons/tools/generate_report.py +++ b/comparisons/tools/generate_report.py @@ -36,6 +36,8 @@ def load_report(path: Path) -> dict: raise ValueError(f"{path}: unsupported schema version") if report.get("metadata", {}).get("authoritative") is not True: raise ValueError(f"{path}: report is not authoritative") + if report["metadata"].get("allocator", {}).get("policy") != "system": + raise ValueError(f"{path}: report does not use the system allocator policy") return report @@ -106,7 +108,7 @@ def comparison_counts(cpu: list[dict], left: str, right: str) -> tuple[int, int, sum(ratio > 1.03 for ratio in ratios)) -def write_latest(report: dict, output: Path) -> None: +def platform_section(report: dict) -> str: metadata = report["metadata"] audits = metadata["runtime_audits"] classifications = { @@ -144,18 +146,15 @@ def requested_ratio(benchmark: str, input_: str, element_size: str, left: str, r )[:3] gap_summary = ", ".join(f"`{benchmark}` ({ratio:.3f}×)" for ratio, benchmark in largest_jack_gaps) - output.write_text(f"""# Latest benchmark comparison + return f"""## `{report['platform_id']}` -This is the authoritative `{report['platform_id']}` baseline. Lower ratios are -better. CPU classifications and heatmap ratios use `Vec` as the baseline; red -does not mean an implementation lost to every other candidate. Every measured -implementation and scenario is retained, and platforms are never pooled. +This is the authoritative `{report['platform_id']}` baseline. ![CPU performance profile](graphics/{report['platform_id']}-cpu-profile.svg) ![Complete CPU ratio heatmap](graphics/{report['platform_id']}-cpu-heatmap.svg) -## What this baseline says +### What this baseline says - JackVec is not an across-the-board faster `Vec`: it has {classifications['JackVec']['win']} confidence-qualified wins and @@ -176,7 +175,7 @@ def requested_ratio(benchmark: str, input_: str, element_size: str, left: str, r SmallVec avoids heap allocation when values fit inline. Neither representation dominates every workload. -## CPU outcomes +### CPU outcomes The confidence-aware classifications below compare each implementation with `Vec`. “Inconclusive” means the paired 95% interval crosses a boundary; it is not @@ -193,7 +192,7 @@ def requested_ratio(benchmark: str, input_: str, element_size: str, left: str, r |---|---:|---:|---:| {head_to_head_rows} -## Memory outcomes +### Memory outcomes Requested and allocator-usable heap are deliberately separate. Requested bytes show representation savings; usable bytes show what the measured allocator @@ -211,7 +210,7 @@ def requested_ratio(benchmark: str, input_: str, element_size: str, left: str, r owner bytes, absolute requested/usable bytes, allocation counts, reallocations, and spill counts. -## Run provenance +### Run provenance - Commit: `{metadata['git_commit']}` - Compiler: `{metadata['compiler_identity']['release']}` (`{metadata['compiler_identity']['commit_hash']}`) @@ -226,13 +225,57 @@ def requested_ratio(benchmark: str, input_: str, element_size: str, left: str, r the fastest implementation for that workload. It is an aggregate view, not a claim that all workloads are equally representative. The heatmaps preserve the individual results. These microbenchmarks describe the listed operations, element -types, sizes, compiler, allocator, and machine—not every application. macOS -remains pending until a clean authoritative run is available. +types, sizes, compiler, allocator, and machine—not every application. +""" + + +def pair_issues(left: dict, right: dict) -> list[str]: + issues = [] + for field in ("schema_version", "round_count", "toolchain"): + if left.get(field) != right.get(field): + issues.append(f"{field} differs") + if left["metadata"].get("git_commit") != right["metadata"].get("git_commit"): + issues.append("git commits differ") + for field in ("release", "commit_hash", "LLVM_version"): + if (left["metadata"]["compiler_identity"].get(field) + != right["metadata"]["compiler_identity"].get(field)): + issues.append(f"compiler {field} differs") + cpu_key = lambda row: (row["benchmark"], row["implementation"]) + if {cpu_key(row) for row in left["cpu"]} != {cpu_key(row) for row in right["cpu"]}: + issues.append("CPU matrices differ") + allocation_key = lambda row: ( + row["benchmark"], row["input"], row["element_size"], row["implementation"] + ) + if ({allocation_key(row) for row in left["allocations"]} + != {allocation_key(row) for row in right["allocations"]}): + issues.append("allocation matrices differ") + return issues + + +def write_latest(reports: list[dict], output: Path) -> None: + if not reports: + raise ValueError("at least one report is required") + platforms = [report["platform_id"] for report in reports] + if len(platforms) != len(set(platforms)): + raise ValueError("platform reports must be unique") + for report in reports[1:]: + issues = pair_issues(reports[0], report) + if issues: + raise ValueError("reports are not comparable: " + "; ".join(issues)) + sections = "\n\n".join(platform_section(report).rstrip() for report in reports) + output.write_text(f"""# Latest benchmark comparison + +These are the authoritative physical-host baselines. Lower ratios are better. +CPU classifications and heatmap ratios use `Vec` as the baseline; red does not +mean an implementation lost to every other candidate. Every measured +implementation and scenario is retained. Platform results are presented in +separate sections and are never pooled. + +{sections} """) -def generate(report_path: Path, results_dir: Path) -> None: - report = load_report(report_path) +def generate_graphics(report: dict, results_dir: Path) -> None: platform = report["platform_id"] graphics = results_dir / "graphics" graphics.mkdir(parents=True, exist_ok=True) @@ -252,16 +295,28 @@ def generate(report_path: Path, results_dir: Path) -> None: f"{platform} · usable bytes relative to Vec · includes allocator size-class rounding", graphics / f"{platform}-memory-usable-heatmap.svg") performance_profile(report["cpu"], platform, graphics / f"{platform}-cpu-profile.svg") - write_latest(report, results_dir / "LATEST.md") + + +def generate(report_paths: list[Path], results_dir: Path) -> None: + reports = [load_report(path) for path in report_paths] + reports.sort(key=lambda report: report["platform_id"]) + # Validate the complete set before changing any generated file. + for report in reports[1:]: + issues = pair_issues(reports[0], report) + if issues: + raise ValueError("reports are not comparable: " + "; ".join(issues)) + for report in reports: + generate_graphics(report, results_dir) + write_latest(reports, results_dir / "LATEST.md") def main() -> None: parser = argparse.ArgumentParser() - parser.add_argument("report", type=Path) + parser.add_argument("reports", type=Path, nargs="+") parser.add_argument("--results-dir", type=Path, default=Path("comparisons/benchmark-results")) args = parser.parse_args() mpl.rcParams.update({"font.family": "DejaVu Sans", "svg.hashsalt": "jack-vec"}) - generate(args.report, args.results_dir) + generate(args.reports, args.results_dir) if __name__ == "__main__": diff --git a/comparisons/tools/test_generate_report.py b/comparisons/tools/test_generate_report.py new file mode 100644 index 0000000..a323f0a --- /dev/null +++ b/comparisons/tools/test_generate_report.py @@ -0,0 +1,60 @@ +import importlib.util +import json +import tempfile +import unittest +from pathlib import Path + + +MODULE_PATH = Path(__file__).with_name("generate_report.py") +SPEC = importlib.util.spec_from_file_location("generate_report", MODULE_PATH) +generate_report = importlib.util.module_from_spec(SPEC) +assert SPEC.loader is not None +SPEC.loader.exec_module(generate_report) + +RESULTS = MODULE_PATH.parent.parent / "benchmark-results" + + +class GenerateReportTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.linux = json.loads((RESULTS / "linux-x86_64.json").read_text()) + cls.macos = json.loads((RESULTS / "macos-aarch64.json").read_text()) + + def test_combined_latest_keeps_platforms_separate(self): + with tempfile.TemporaryDirectory() as directory: + output = Path(directory) / "LATEST.md" + generate_report.write_latest([self.linux, self.macos], output) + text = output.read_text() + self.assertIn("## `linux-x86_64`", text) + self.assertIn("## `macos-aarch64`", text) + self.assertIn("platform results are presented in\nseparate sections and are never pooled", text.lower()) + self.assertEqual(text.count("### CPU outcomes"), 2) + self.assertNotIn("macOS remains pending", text) + + def test_pair_mismatch_is_rejected(self): + mismatched = json.loads(json.dumps(self.macos)) + mismatched["metadata"]["git_commit"] = "different" + with tempfile.TemporaryDirectory() as directory: + output = Path(directory) / "LATEST.md" + with self.assertRaisesRegex(ValueError, "git commits differ"): + generate_report.write_latest([self.linux, mismatched], output) + self.assertFalse(output.exists()) + + def test_duplicate_platform_is_rejected(self): + with tempfile.TemporaryDirectory() as directory: + output = Path(directory) / "LATEST.md" + with self.assertRaisesRegex(ValueError, "must be unique"): + generate_report.write_latest([self.linux, self.linux], output) + + def test_non_system_report_is_rejected(self): + report = json.loads(json.dumps(self.macos)) + report["metadata"]["allocator"]["policy"] = "environment" + with tempfile.TemporaryDirectory() as directory: + path = Path(directory) / "report.json" + path.write_text(json.dumps(report)) + with self.assertRaisesRegex(ValueError, "system allocator policy"): + generate_report.load_report(path) + + +if __name__ == "__main__": + unittest.main()