diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 9c6c525..cb26f55 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -50,8 +50,13 @@ jobs: - name: Test comparison reporting tools run: uv run --project comparisons/tools --locked python -m unittest discover -s comparisons/tools -p 'test_*.py' - name: Validate versioned physical-host pair - if: hashFiles('comparisons/benchmark-results/macos-aarch64.json', 'comparisons/benchmark-results/linux-x86_64.json') != '' + 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') != '' + run: | + uv run --project comparisons/tools --locked python comparisons/tools/generate_report.py comparisons/benchmark-results/linux-x86_64.json + git diff --exit-code -- comparisons/benchmark-results/LATEST.md comparisons/benchmark-results/graphics msrv: runs-on: ubuntu-latest diff --git a/TODO.md b/TODO.md index 3e4c3da..2d636e5 100644 --- a/TODO.md +++ b/TODO.md @@ -34,13 +34,15 @@ The central hypothesis is: hashes, commits, schemas, matrices, or authority status. - [x] Track reporting and visualization tooling as a locked uv project with an exact Python and Matplotlib environment, isolated from benchmark execution. -- [ ] Generate deterministic SVG heatmaps, performance profiles, CPU/memory - tradeoff views, and an embedded `LATEST.md` from validated report pairs. +- [x] Generate deterministic SVG heatmaps, a non-lossy performance profile, + CPU/memory tradeoff views, and an embedded `LATEST.md` from the authoritative + Linux report. Extend the same report rather than opening a separate PR when the + clean macOS half becomes available. - [x] Add CodSpeed CPU simulation for pull requests and `main`. - [ ] Enable public-repository access for the `moderately-ai` Actions runner group, set `CODSPEED_MACRO_ENABLED=true`, and validate ARM64 Linux wall time. -- [ ] Capture and commit the first clean M4 macOS and Ryzen 7950X3D Linux - summaries; retain full raw rounds outside Git. +- [ ] Capture and commit the first clean M4 macOS summary; the Ryzen 7950X3D + Linux summary is complete. Retain full raw rounds outside Git. - [ ] Revisit the practical-equivalence band only after enough stable repeated baselines exist; never tune it in response to a desired result. diff --git a/comparisons/benchmark-results/LATEST.md b/comparisons/benchmark-results/LATEST.md new file mode 100644 index 0000000..3e2e3c9 --- /dev/null +++ b/comparisons/benchmark-results/LATEST.md @@ -0,0 +1,89 @@ +# 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. + +![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 + +- JackVec is not an across-the-board faster `Vec`: it has + 6 confidence-qualified wins and + 7 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 + 1.013× Vec and + 0.322× upstream + ThinVec. This is a large targeted improvement, not a universal CPU claim. +- The clearest JackVec CPU losses versus Vec include 1,024-element sequential + iteration (1.265×), + `u64` retain (1.246×), and + four-element append (1.437×). + They are retained here as investigation targets. +- 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 | 6 | 4 | 5 | 7 | +| ThinVec | 7 | 2 | 3 | 10 | +| SmallVec4 | 1 | 1 | 3 | 17 | +| SmallVec8 | 1 | 3 | 3 | 15 | + +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 | 8 | 5 | 9 | +| ThinVec | 8 | 7 | 7 | +| SmallVec4 | 16 | 2 | 4 | +| SmallVec8 | 15 | 3 | 4 | + +## 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/linux-x86_64-memory-requested-heatmap.svg) + +![Allocator-usable live heap ratio heatmap](graphics/linux-x86_64-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](linux-x86_64.md) for +owner bytes, absolute requested/usable bytes, allocation counts, reallocations, +and spill counts. + +## Run provenance + +- Commit: `1f6e5f8abac7152d6ef3523baaed63096ac88b0a` +- Compiler: `1.97.0` (`2d8144b7880597b6e6d3dfd63a9a9efae3f533d3`) +- CPU rounds: 5; CPU rows: 110; allocation rows: 60 +- Minimum pinned-core idle audit: 100.0% +- Maximum audited one-minute load: 1.12 + +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. diff --git a/comparisons/benchmark-results/README.md b/comparisons/benchmark-results/README.md index 5dd43ab..9c1d419 100644 --- a/comparisons/benchmark-results/README.md +++ b/comparisons/benchmark-results/README.md @@ -9,3 +9,13 @@ CI or experiment artifacts when investigating a result. Exploratory runs are automatically suffixed `-exploratory` and must not replace an authoritative platform summary. + +`LATEST.md` and `graphics/` are deterministic derivatives of the authoritative +JSON. The report keeps requested heap, allocator-usable heap, and collection-owner +size conceptually separate; combining them can either hide allocator rounding or +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 +``` diff --git a/comparisons/benchmark-results/graphics/linux-x86_64-cpu-heatmap.svg b/comparisons/benchmark-results/graphics/linux-x86_64-cpu-heatmap.svg new file mode 100644 index 0000000..39a062c --- /dev/null +++ b/comparisons/benchmark-results/graphics/linux-x86_64-cpu-heatmap.svg @@ -0,0 +1,4245 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/graphics/linux-x86_64-cpu-profile.svg b/comparisons/benchmark-results/graphics/linux-x86_64-cpu-profile.svg new file mode 100644 index 0000000..c798bc8 --- /dev/null +++ b/comparisons/benchmark-results/graphics/linux-x86_64-cpu-profile.svg @@ -0,0 +1,1904 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/graphics/linux-x86_64-memory-requested-heatmap.svg b/comparisons/benchmark-results/graphics/linux-x86_64-memory-requested-heatmap.svg new file mode 100644 index 0000000..b1df5dd --- /dev/null +++ b/comparisons/benchmark-results/graphics/linux-x86_64-memory-requested-heatmap.svg @@ -0,0 +1,3301 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/graphics/linux-x86_64-memory-usable-heatmap.svg b/comparisons/benchmark-results/graphics/linux-x86_64-memory-usable-heatmap.svg new file mode 100644 index 0000000..1009e29 --- /dev/null +++ b/comparisons/benchmark-results/graphics/linux-x86_64-memory-usable-heatmap.svg @@ -0,0 +1,3262 @@ + + + + + + + + image/svg+xml + + + Matplotlib v3.11.0, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/comparisons/benchmark-results/linux-x86_64.json b/comparisons/benchmark-results/linux-x86_64.json new file mode 100644 index 0000000..d1d27e7 --- /dev/null +++ b/comparisons/benchmark-results/linux-x86_64.json @@ -0,0 +1,2768 @@ +{ + "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": "245760", + "moved_reallocations": "0", + "owner_bytes": "240000", + "peak_requested": "240000", + "peak_usable": "245760", + "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": "81920", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "80000", + "peak_usable": "81920", + "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": "81920", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "80000", + "peak_usable": "81920", + "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": "401408", + "moved_reallocations": "0", + "owner_bytes": "400000", + "peak_requested": "400000", + "peak_usable": "401408", + "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": "309760", + "moved_reallocations": "0", + "owner_bytes": "240000", + "peak_requested": "304000", + "peak_usable": "309760", + "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": "177920", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "160000", + "peak_usable": "177920", + "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": "177920", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "176000", + "peak_usable": "177920", + "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": "401408", + "moved_reallocations": "0", + "owner_bytes": "400000", + "peak_requested": "400000", + "peak_usable": "401408", + "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": "565760", + "moved_reallocations": "0", + "owner_bytes": "240000", + "peak_requested": "560000", + "peak_usable": "565760", + "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": "561920", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "480000", + "peak_usable": "561920", + "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": "561920", + "moved_reallocations": "0", + "owner_bytes": "80000", + "peak_requested": "560000", + "peak_usable": "561920", + "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": "401408", + "moved_reallocations": "0", + "owner_bytes": "400000", + "peak_requested": "400000", + "peak_usable": "401408", + "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": "8", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "8", + "peak_usable": "8", + "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": "8", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "1", + "peak_usable": "8", + "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": "8", + "moved_reallocations": "0", + "owner_bytes": "24", + "peak_requested": "4", + "peak_usable": "8", + "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": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "8", + "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": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8200", + "live_usable": "9216", + "moved_reallocations": "8", + "owner_bytes": "8", + "peak_requested": "8200", + "peak_usable": "9216", + "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": "0", + "inline_capacity": "0", + "input": "1024", + "len": "1024", + "live_requested": "8208", + "live_usable": "9216", + "moved_reallocations": "8", + "owner_bytes": "8", + "peak_requested": "8208", + "peak_usable": "9216", + "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": "0", + "inline_capacity": "4", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "7", + "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": "0", + "inline_capacity": "8", + "input": "1024", + "len": "1024", + "live_requested": "8192", + "live_usable": "8192", + "moved_reallocations": "6", + "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": "9216", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "8200", + "peak_usable": "9216", + "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": "9216", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "8208", + "peak_usable": "9216", + "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": "1152", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "1032", + "peak_usable": "1152", + "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": "1152", + "moved_reallocations": "0", + "owner_bytes": "8", + "peak_requested": "1040", + "peak_usable": "1152", + "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": 161.77505719799845, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "equivalent", + "implementation": "JackVec", + "median_ns": 163.95494281430712, + "ratio_ci95": [ + 0.9968067917976962, + 1.021851996291705 + ], + "ratio_to_vec": 1.0146403891728422 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 508.7755249016675, + "ratio_ci95": [ + 3.126091837642611, + 3.1933961619509517 + ], + "ratio_to_vec": 3.1447614354622004 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 192.69557853717026, + "ratio_ci95": [ + 1.1770104344961798, + 1.2282828255995037 + ], + "ratio_to_vec": 1.194446822944933 + }, + { + "benchmark": "append_preallocated/1024", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 208.08677917447972, + "ratio_ci95": [ + 1.2784436451729397, + 1.2992798502694207 + ], + "ratio_to_vec": 1.2872581782861556 + }, + { + "benchmark": "append_preallocated/4", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 2.589009125638002, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 3.7191597038244684, + "ratio_ci95": [ + 1.4326508604689718, + 1.482222680158473 + ], + "ratio_to_vec": 1.436101678793757 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 4.116052245175519, + "ratio_ci95": [ + 1.5669916975036808, + 1.6184725493637409 + ], + "ratio_to_vec": 1.585537126766058 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 5.723299667656713, + "ratio_ci95": [ + 2.204585844891109, + 2.214086132111562 + ], + "ratio_to_vec": 2.2114811493112905 + }, + { + "benchmark": "append_preallocated/4", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 5.71031215270582, + "ratio_ci95": [ + 2.192728130873105, + 2.2090015458612355 + ], + "ratio_to_vec": 2.2004727111785836 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 8.311868970446922, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "win", + "implementation": "JackVec", + "median_ns": 7.682645379876533, + "ratio_ci95": [ + 0.9221977888382257, + 0.9380949120486872 + ], + "ratio_to_vec": 0.9269530663614397 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 7.658920989740534, + "ratio_ci95": [ + 0.9207554830180028, + 0.9266491222139418 + ], + "ratio_to_vec": 0.9224474426795347 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "win", + "implementation": "SmallVec4", + "median_ns": 2.0536155396050595, + "ratio_ci95": [ + 0.2409117289722443, + 0.24870737657868874 + ], + "ratio_to_vec": 0.24710260180745558 + }, + { + "benchmark": "build_growing_and_drop/1", + "classification": "win", + "implementation": "SmallVec8", + "median_ns": 3.2049950101053506, + "ratio_ci95": [ + 0.37632426004844854, + 0.3879007871376156 + ], + "ratio_to_vec": 0.37921128734980103 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 678.7348819835263, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "win", + "implementation": "JackVec", + "median_ns": 562.0511615597011, + "ratio_ci95": [ + 0.817005717550381, + 0.8452634259565537 + ], + "ratio_to_vec": 0.8266457746695103 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 550.8953346066849, + "ratio_ci95": [ + 0.8019214781913301, + 0.8304769355506499 + ], + "ratio_to_vec": 0.8109718569913577 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 1002.8559436664546, + "ratio_ci95": [ + 1.4662726621110902, + 1.5099333239819326 + ], + "ratio_to_vec": 1.4783675584747955 + }, + { + "benchmark": "build_growing_and_drop/1024", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 1006.0232899321475, + "ratio_ci95": [ + 1.4274376907364172, + 1.5069487035696778 + ], + "ratio_to_vec": 1.4746273448169824 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 9.265608441871443, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 8.94698208316751, + "ratio_ci95": [ + 0.9573069961137739, + 0.9797498683903755 + ], + "ratio_to_vec": 0.968763598667124 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 8.468225239740708, + "ratio_ci95": [ + 0.8921372739981763, + 0.9345045459483057 + ], + "ratio_to_vec": 0.9231650546653072 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 10.868385004852975, + "ratio_ci95": [ + 1.168956131243969, + 1.188770074108358 + ], + "ratio_to_vec": 1.1729812535287545 + }, + { + "benchmark": "build_growing_and_drop/4", + "classification": "inconclusive", + "implementation": "SmallVec8", + "median_ns": 8.724095096770357, + "ratio_ci95": [ + 0.9282419824881796, + 1.008598230767938 + ], + "ratio_to_vec": 0.9413956728406905 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 967.3551650448137, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 1039.2353176778752, + "ratio_ci95": [ + 1.0708986290957339, + 1.0756920584855694 + ], + "ratio_to_vec": 1.072976578433573 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 1006.2766152117114, + "ratio_ci95": [ + 1.0391085467326746, + 1.041911577095716 + ], + "ratio_to_vec": 1.0401429315688266 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 1144.6561457496118, + "ratio_ci95": [ + 1.1787299643438678, + 1.197650866320387 + ], + "ratio_to_vec": 1.183284265295244 + }, + { + "benchmark": "dedup_adjacent_pairs/64_byte", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 1147.1235264558886, + "ratio_ci95": [ + 1.1815767720060844, + 1.196587620156839 + ], + "ratio_to_vec": 1.1856014957348264 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 267.9117823332955, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 282.5486322924231, + "ratio_ci95": [ + 1.0017902047950298, + 1.0665727516224783 + ], + "ratio_to_vec": 1.0589503672450276 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 369.63072247497956, + "ratio_ci95": [ + 1.3755367445636895, + 1.5477378785285156 + ], + "ratio_to_vec": 1.3836190278425138 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 447.8860844947735, + "ratio_ci95": [ + 1.5893518476061512, + 2.043953400298191 + ], + "ratio_to_vec": 1.6592116901972738 + }, + { + "benchmark": "dedup_adjacent_pairs/u64", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 367.33583411009477, + "ratio_ci95": [ + 1.306555753795462, + 1.383774362921717 + ], + "ratio_to_vec": 1.3743112956828791 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 152.20840524509512, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 164.9307118263884, + "ratio_ci95": [ + 1.0383200636146916, + 1.112638448000239 + ], + "ratio_to_vec": 1.0724442118020505 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 155.38174191716968, + "ratio_ci95": [ + 0.9771884688976008, + 1.059219256508823 + ], + "ratio_to_vec": 1.020848629659871 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 148.66015759967007, + "ratio_ci95": [ + 0.9288515095237042, + 1.0210922589663562 + ], + "ratio_to_vec": 1.0005831987212552 + }, + { + "benchmark": "extend_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec8", + "median_ns": 160.7589997937258, + "ratio_ci95": [ + 0.9878037048030517, + 1.0775951895652272 + ], + "ratio_to_vec": 1.0437531269978644 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 18932.941566265057, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "win", + "implementation": "JackVec", + "median_ns": 12071.658619505495, + "ratio_ci95": [ + 0.5752664646597035, + 0.6393564531490558 + ], + "ratio_to_vec": 0.6348300012584576 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 10761.008969025728, + "ratio_ci95": [ + 0.502946423562235, + 0.5704376222370897 + ], + "ratio_to_vec": 0.5654569799544956 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 21602.297108066974, + "ratio_ci95": [ + 1.1272137898541237, + 1.1536782794097855 + ], + "ratio_to_vec": 1.143328790394568 + }, + { + "benchmark": "nested_construct_and_drop/empty", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 27141.30669111146, + "ratio_ci95": [ + 1.431947341112366, + 1.4429782446672175 + ], + "ratio_to_vec": 1.4374967124915767 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 113911.53565426171, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "win", + "implementation": "JackVec", + "median_ns": 108169.50775613275, + "ratio_ci95": [ + 0.9349619187296131, + 0.9552830500944242 + ], + "ratio_to_vec": 0.948390575856458 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 103041.8282395528, + "ratio_ci95": [ + 0.8913125867559306, + 0.9169534191703026 + ], + "ratio_to_vec": 0.9045776413049151 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 126057.1113360324, + "ratio_ci95": [ + 1.1007648790469693, + 1.111522249279069 + ], + "ratio_to_vec": 1.1071870606271335 + }, + { + "benchmark": "nested_construct_and_drop/small", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 133435.79833333334, + "ratio_ci95": [ + 1.1602283100913846, + 1.1801373278098373 + ], + "ratio_to_vec": 1.1699161459301493 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 37194.695593635246, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "win", + "implementation": "JackVec", + "median_ns": 32354.042686018507, + "ratio_ci95": [ + 0.8613418922675378, + 0.877225704431685 + ], + "ratio_to_vec": 0.8735633250274036 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 30068.76109540906, + "ratio_ci95": [ + 0.781872980811353, + 0.8132841108086539 + ], + "ratio_to_vec": 0.8107140996742704 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 40198.085527319905, + "ratio_ci95": [ + 1.078137071794029, + 1.083820999924278 + ], + "ratio_to_vec": 1.0798472719510126 + }, + { + "benchmark": "nested_construct_and_drop/sparse", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 45716.869277597405, + "ratio_ci95": [ + 1.2017461701447982, + 1.2414908084365726 + ], + "ratio_to_vec": 1.2270313214646624 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 3971.0052934407363, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 4025.5293749770076, + "ratio_ci95": [ + 1.0128384735330087, + 1.057056106619877 + ], + "ratio_to_vec": 1.0154805648397613 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 4018.0973693825354, + "ratio_ci95": [ + 1.0077931885442024, + 1.0396325312507 + ], + "ratio_to_vec": 1.0128886554333494 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 4085.2766780766297, + "ratio_ci95": [ + 1.0265457316595619, + 1.0633884275454755 + ], + "ratio_to_vec": 1.0276207691191632 + }, + { + "benchmark": "nested_metadata_scan_sparse", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 5346.577738372407, + "ratio_ci95": [ + 1.2604558682632276, + 1.3917850934149392 + ], + "ratio_to_vec": 1.3461190413262374 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 2197.8980411609086, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "equivalent", + "implementation": "JackVec", + "median_ns": 2152.7440403383716, + "ratio_ci95": [ + 0.978853586632099, + 0.9843910979826089 + ], + "ratio_to_vec": 0.9803607485089639 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 3955.254484770887, + "ratio_ci95": [ + 1.7992689975103797, + 1.811240796556842 + ], + "ratio_to_vec": 1.803737670526076 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 5873.414578891257, + "ratio_ci95": [ + 1.8401487842146769, + 2.6844892329437586 + ], + "ratio_to_vec": 2.678065094397275 + }, + { + "benchmark": "nested_traverse/empty", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 6001.314672276957, + "ratio_ci95": [ + 2.187416494867176, + 2.758512370160779 + ], + "ratio_to_vec": 2.7368143791369315 + }, + { + "benchmark": "nested_traverse/small", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 21533.945176700818, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_traverse/small", + "classification": "equivalent", + "implementation": "JackVec", + "median_ns": 21523.873888067013, + "ratio_ci95": [ + 0.9845919748459028, + 1.003136050685809 + ], + "ratio_to_vec": 0.9992770883232633 + }, + { + "benchmark": "nested_traverse/small", + "classification": "equivalent", + "implementation": "ThinVec", + "median_ns": 21521.78652657832, + "ratio_ci95": [ + 0.9846346909790689, + 0.9998533172609713 + ], + "ratio_to_vec": 0.9994500713358617 + }, + { + "benchmark": "nested_traverse/small", + "classification": "equivalent", + "implementation": "SmallVec4", + "median_ns": 21421.318841568842, + "ratio_ci95": [ + 0.9853099756306763, + 0.9970577443061337 + ], + "ratio_to_vec": 0.9941298193685164 + }, + { + "benchmark": "nested_traverse/small", + "classification": "equivalent", + "implementation": "SmallVec8", + "median_ns": 21429.866093366094, + "ratio_ci95": [ + 0.9831328042959161, + 0.9975399533849033 + ], + "ratio_to_vec": 0.9951667433681713 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 3242.745272388791, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 3055.7283117436964, + "ratio_ci95": [ + 0.8272691280252745, + 0.9943450415319834 + ], + "ratio_to_vec": 0.944642006864134 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 5241.9894693486585, + "ratio_ci95": [ + 1.3795306770247378, + 1.705804641948998 + ], + "ratio_to_vec": 1.6225997952230866 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 5045.057546209273, + "ratio_ci95": [ + 1.3267374393757838, + 1.6434602313503568 + ], + "ratio_to_vec": 1.554875535397513 + }, + { + "benchmark": "nested_traverse/sparse", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 5493.643374615509, + "ratio_ci95": [ + 1.4760755424752596, + 1.7541472038579182 + ], + "ratio_to_vec": 1.6669819766303633 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 439.967710756619, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "equivalent", + "implementation": "JackVec", + "median_ns": 432.5131836187069, + "ratio_ci95": [ + 0.9774324863138661, + 0.9980499074819398 + ], + "ratio_to_vec": 0.9861879579791306 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "inconclusive", + "implementation": "ThinVec", + "median_ns": 428.7961426211896, + "ratio_ci95": [ + 0.9643236432752172, + 0.9829026100730435 + ], + "ratio_to_vec": 0.9740712573723846 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 714.3224119683845, + "ratio_ci95": [ + 1.6170948573050588, + 1.6434356204181497 + ], + "ratio_to_vec": 1.6231981788792587 + }, + { + "benchmark": "push_preallocated/1024", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 717.5355860305373, + "ratio_ci95": [ + 1.6260237900536307, + 1.639956757715747 + ], + "ratio_to_vec": 1.6304104789232847 + }, + { + "benchmark": "push_preallocated/4", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 2.2741486535989788, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "push_preallocated/4", + "classification": "win", + "implementation": "JackVec", + "median_ns": 2.1027114709346026, + "ratio_ci95": [ + 0.9108694955653258, + 0.930566930368321 + ], + "ratio_to_vec": 0.9199692667562522 + }, + { + "benchmark": "push_preallocated/4", + "classification": "win", + "implementation": "ThinVec", + "median_ns": 2.1171564048249296, + "ratio_ci95": [ + 0.9168823247966023, + 0.9445036553562008 + ], + "ratio_to_vec": 0.9316944056581401 + }, + { + "benchmark": "push_preallocated/4", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 14.057505738270542, + "ratio_ci95": [ + 6.0973308545428715, + 6.22120125403117 + ], + "ratio_to_vec": 6.134575483687708 + }, + { + "benchmark": "push_preallocated/4", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 14.101692284542334, + "ratio_ci95": [ + 6.105453332680967, + 6.252572651086494 + ], + "ratio_to_vec": 6.206677949413495 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 154.6553120897317, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "inconclusive", + "implementation": "JackVec", + "median_ns": 165.5923017958826, + "ratio_ci95": [ + 1.0135380862144905, + 1.1069930637330465 + ], + "ratio_to_vec": 1.0707184871852653 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 437.1122551148427, + "ratio_ci95": [ + 2.7928512193274284, + 2.917156040633894 + ], + "ratio_to_vec": 2.8295539617457153 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec4", + "median_ns": 153.33454270597127, + "ratio_ci95": [ + 0.9389629898390772, + 1.0534691590301866 + ], + "ratio_to_vec": 0.9816921049259186 + }, + { + "benchmark": "resize_reserved_1024", + "classification": "inconclusive", + "implementation": "SmallVec8", + "median_ns": 154.31301225312995, + "ratio_ci95": [ + 0.9408712076576596, + 1.0389725812654502 + ], + "ratio_to_vec": 1.004258407704554 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 252.4944043655198, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 294.814507165838, + "ratio_ci95": [ + 1.1584533310215124, + 1.1939064764963263 + ], + "ratio_to_vec": 1.1634224655878966 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 445.4600914149444, + "ratio_ci95": [ + 1.7595830803820292, + 1.7845301228314359 + ], + "ratio_to_vec": 1.7677596280754804 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 526.9958189902467, + "ratio_ci95": [ + 2.0755040332733503, + 2.1269014674543287 + ], + "ratio_to_vec": 2.088615438178562 + }, + { + "benchmark": "retain_mixed/64_byte", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 531.9739625590503, + "ratio_ci95": [ + 2.0977049557969805, + 2.1200152611682577 + ], + "ratio_to_vec": 2.1096544906636168 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 558.547422924298, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 696.0192257807906, + "ratio_ci95": [ + 1.2439124583864645, + 1.2503677637595676 + ], + "ratio_to_vec": 1.2468670074838066 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 710.6699367245966, + "ratio_ci95": [ + 1.2662013473914222, + 1.27470338846449 + ], + "ratio_to_vec": 1.2708455194172368 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 919.6149114091737, + "ratio_ci95": [ + 1.642675089835722, + 1.6514855091885443 + ], + "ratio_to_vec": 1.6450629845784999 + }, + { + "benchmark": "retain_mixed/u64", + "classification": "loss", + "implementation": "SmallVec8", + "median_ns": 926.0201425281261, + "ratio_ci95": [ + 1.6540094301846155, + 1.6619662740777847 + ], + "ratio_to_vec": 1.6563748382298298 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 58.679027102332526, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 74.20019758151588, + "ratio_ci95": [ + 1.2625127729049184, + 1.2678067738705334 + ], + "ratio_to_vec": 1.264639816174463 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "equivalent", + "implementation": "ThinVec", + "median_ns": 58.846501097126776, + "ratio_ci95": [ + 1.0024326875504692, + 1.003716773822228 + ], + "ratio_to_vec": 1.0033713254270338 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 101.1388426433173, + "ratio_ci95": [ + 1.7232528291252123, + 1.7320845310072635 + ], + "ratio_to_vec": 1.724226780050877 + }, + { + "benchmark": "sequential_iteration/1024", + "classification": "equivalent", + "implementation": "SmallVec8", + "median_ns": 58.641435076552156, + "ratio_ci95": [ + 0.9989394487291737, + 1.0001603392976162 + ], + "ratio_to_vec": 0.9996372260746553 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "baseline", + "implementation": "Vec", + "median_ns": 1.0748847172922882, + "ratio_ci95": [ + 1.0, + 1.0 + ], + "ratio_to_vec": 1.0 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "loss", + "implementation": "JackVec", + "median_ns": 1.2708135026864915, + "ratio_ci95": [ + 1.1789058856960262, + 1.184571718646692 + ], + "ratio_to_vec": 1.182087536411812 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "loss", + "implementation": "ThinVec", + "median_ns": 1.3980627805212236, + "ratio_ci95": [ + 1.2971749015293816, + 1.303584890666557 + ], + "ratio_to_vec": 1.299999241460088 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "loss", + "implementation": "SmallVec4", + "median_ns": 1.223487804260425, + "ratio_ci95": [ + 1.135031564342506, + 1.1402450757972542 + ], + "ratio_to_vec": 1.1382502556576286 + }, + { + "benchmark": "sequential_iteration/8", + "classification": "equivalent", + "implementation": "SmallVec8", + "median_ns": 1.0884487764363864, + "ratio_ci95": [ + 1.009276755585331, + 1.0166782963110446 + ], + "ratio_to_vec": 1.0121023200459793 + } + ], + "metadata": { + "affinity_cpu": 0, + "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": "x86_64-unknown-linux-gnu", + "release": "1.97.0" + }, + "cpu_summary": "Architecture: x86_64\nCPU op-mode(s): 32-bit, 64-bit\nAddress sizes: 48 bits physical, 48 bits virtual\nByte Order: Little Endian\nCPU(s): 32\nOn-line CPU(s) list: 0-31\nVendor ID: AuthenticAMD\nModel name: AMD Ryzen 9 7950X3D 16-Core Processor\nCPU family: 25\nModel: 97\nThread(s) per core: 2\nCore(s) per socket: 16\nSocket(s): 1\nStepping: 2\nFrequency boost: enabled\nCPU max MHz: 5759.9639\nCPU min MHz: 3000.0000\nBogoMIPS: 8383.97\nFlags: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good nopl nonstop_tsc cpuid extd_apicid aperfmperf rapl pni pclmulqdq monitor ssse3 fma cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx f16c rdrand lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt tce topoext perfctr_core perfctr_nb bpext perfctr_llc mwaitx cpb cat_l3 cdp_l3 hw_pstate ssbd mba ibrs ibpb stibp ibrs_enhanced vmmcall fsgsbase bmi1 avx2 smep bmi2 erms invpcid cqm rdt_a avx512f avx512dq rdseed adx smap avx512ifma clflushopt clwb avx512cd sha_ni avx512bw avx512vl xsaveopt xsavec xgetbv1 xsaves cqm_llc cqm_occup_llc cqm_mbm_total cqm_mbm_local avx512_bf16 clzero irperf xsaveerptr rdpru wbnoinvd cppc arat npt lbrv svm_lock nrip_save tsc_scale vmcb_clean flushbyasid decodeassists pausefilter pfthreshold avic vgif v_spec_ctrl avx512vbmi umip pku ospke avx512_vbmi2 gfni vaes vpclmulqdq avx512_vnni avx512_bitalg avx512_vpopcntdq rdpid overflow_recov succor smca fsrm flush_l1d ibpb_exit_to_user\nVirtualization: AMD-V\nL1d cache: 512 KiB (16 instances)\nL1i cache: 512 KiB (16 instances)\nL2 cache: 16 MiB (16 instances)\nL3 cache: 128 MiB (2 instances)\nNUMA node(s): 1\nNUMA node0 CPU(s): 0-31\nVulnerability Gather data sampling: Not affected\nVulnerability Indirect target selection: Not affected\nVulnerability Itlb multihit: Not affected\nVulnerability L1tf: Not affected\nVulnerability Mds: Not affected\nVulnerability Meltdown: Not affected\nVulnerability Mmio stale data: Not affected\nVulnerability Reg file data sampling: Not affected\nVulnerability Retbleed: Not affected\nVulnerability Spec rstack overflow: Mitigation; safe RET\nVulnerability Spec store bypass: Mitigation; Speculative Store Bypass disabled via prctl and seccomp\nVulnerability Spectre v1: Mitigation; usercopy/swapgs barriers and __user pointer sanitization\nVulnerability Spectre v2: Mitigation; Enhanced / Automatic IBRS; IBPB conditional; STIBP always-on; PBRSB-eIBRS Not affected; BHI Not affected\nVulnerability Srbds: Not affected\nVulnerability Tsa: Vulnerable: Clear CPU buffers attempted, no microcode\nVulnerability Tsx async abort: Not affected\nVulnerability Vmscape: Mitigation; IBPB before exit to userspace", + "git_commit": "1f6e5f8abac7152d6ef3523baaed63096ac88b0a", + "git_dirty": false, + "governor": "performance", + "host_issues": [], + "kernel": "Linux Ubuntu-2204-jammy-amd64-base 5.15.0-177-generic #187-Ubuntu SMP Sat Apr 11 22:54:33 UTC 2026 x86_64 x86_64 x86_64 GNU/Linux", + "load_average": [ + 0.06103515625, + 0.06787109375, + 0.2255859375 + ], + "logical_cpus": 32, + "machine": "x86_64", + "platform": "Linux-5.15.0-177-generic-x86_64-with-glibc2.35", + "processor": "x86_64", + "runtime_audits": [ + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "after-build", + "load_average": [ + 0.0556640625, + 0.06640625, + 0.22412109375 + ], + "timestamp_utc": "2026-07-11T17:33:34.430120+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "after-round-1", + "load_average": [ + 1.12353515625, + 0.7783203125, + 0.50830078125 + ], + "timestamp_utc": "2026-07-11T17:39:43.225875+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "settled-after-round-1", + "load_average": [ + 1.033203125, + 0.76513671875, + 0.50537109375 + ], + "timestamp_utc": "2026-07-11T17:39:48.252931+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "after-round-2", + "load_average": [ + 1.046875, + 0.9638671875, + 0.69091796875 + ], + "timestamp_utc": "2026-07-11T17:45:58.566877+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "settled-after-round-2", + "load_average": [ + 0.962890625, + 0.94775390625, + 0.68701171875 + ], + "timestamp_utc": "2026-07-11T17:46:03.593165+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "after-round-3", + "load_average": [ + 1.0927734375, + 1.0166015625, + 0.81640625 + ], + "timestamp_utc": "2026-07-11T17:52:14.909382+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "settled-after-round-3", + "load_average": [ + 1.0048828125, + 0.99951171875, + 0.81201171875 + ], + "timestamp_utc": "2026-07-11T17:52:19.935949+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "after-round-4", + "load_average": [ + 1.06689453125, + 1.0517578125, + 0.91552734375 + ], + "timestamp_utc": "2026-07-11T17:58:29.260676+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "settled-after-round-4", + "load_average": [ + 0.9814453125, + 1.0341796875, + 0.91015625 + ], + "timestamp_utc": "2026-07-11T17:58:34.287003+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "after-round-5", + "load_average": [ + 1.00537109375, + 1.02392578125, + 0.96240234375 + ], + "timestamp_utc": "2026-07-11T18:04:43.517074+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "settled-after-round-5", + "load_average": [ + 0.9248046875, + 1.0068359375, + 0.95703125 + ], + "timestamp_utc": "2026-07-11T18:04:48.543878+00:00" + }, + { + "busy_processes": [], + "cpu_idle_percent": 100.0, + "label": "after-allocations", + "load_average": [ + 0.93115234375, + 1.00634765625, + 0.95751953125 + ], + "timestamp_utc": "2026-07-11T18:04:53.616669+00:00" + } + ], + "rustc": "rustc 1.97.0 (2d8144b78 2026-07-07)\nbinary: rustc\ncommit-hash: 2d8144b7880597b6e6d3dfd63a9a9efae3f533d3\ncommit-date: 2026-07-07\nhost: x86_64-unknown-linux-gnu\nrelease: 1.97.0\nLLVM version: 22.1.6", + "timestamp_utc": "2026-07-11T17:33:30.306543+00:00" + }, + "platform_id": "linux-x86_64", + "practical_equivalence_band": [ + 0.97, + 1.03 + ], + "round_count": 5, + "schema_version": 1, + "toolchain": "1.97.0" +} diff --git a/comparisons/benchmark-results/linux-x86_64.md b/comparisons/benchmark-results/linux-x86_64.md new file mode 100644 index 0000000..8e45974 --- /dev/null +++ b/comparisons/benchmark-results/linux-x86_64.md @@ -0,0 +1,190 @@ +# JackVec comparison: linux-x86_64 + +Commit: `1f6e5f8abac7152d6ef3523baaed63096ac88b0a` +Rust: `rustc 1.97.0 (2d8144b78 2026-07-07)` +Platform: `Linux-5.15.0-177-generic-x86_64-with-glibc2.35` +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 | 161.775 | 1.000× | 1.000–1.000× | baseline | +| append_preallocated/1024 | JackVec | 163.955 | 1.015× | 0.997–1.022× | equivalent | +| append_preallocated/1024 | ThinVec | 508.776 | 3.145× | 3.126–3.193× | loss | +| append_preallocated/1024 | SmallVec4 | 192.696 | 1.194× | 1.177–1.228× | loss | +| append_preallocated/1024 | SmallVec8 | 208.087 | 1.287× | 1.278–1.299× | loss | +| append_preallocated/4 | Vec | 2.589 | 1.000× | 1.000–1.000× | baseline | +| append_preallocated/4 | JackVec | 3.719 | 1.436× | 1.433–1.482× | loss | +| append_preallocated/4 | ThinVec | 4.116 | 1.586× | 1.567–1.618× | loss | +| append_preallocated/4 | SmallVec4 | 5.723 | 2.211× | 2.205–2.214× | loss | +| append_preallocated/4 | SmallVec8 | 5.710 | 2.200× | 2.193–2.209× | loss | +| build_growing_and_drop/1 | Vec | 8.312 | 1.000× | 1.000–1.000× | baseline | +| build_growing_and_drop/1 | JackVec | 7.683 | 0.927× | 0.922–0.938× | win | +| build_growing_and_drop/1 | ThinVec | 7.659 | 0.922× | 0.921–0.927× | win | +| build_growing_and_drop/1 | SmallVec4 | 2.054 | 0.247× | 0.241–0.249× | win | +| build_growing_and_drop/1 | SmallVec8 | 3.205 | 0.379× | 0.376–0.388× | win | +| build_growing_and_drop/1024 | Vec | 678.735 | 1.000× | 1.000–1.000× | baseline | +| build_growing_and_drop/1024 | JackVec | 562.051 | 0.827× | 0.817–0.845× | win | +| build_growing_and_drop/1024 | ThinVec | 550.895 | 0.811× | 0.802–0.830× | win | +| build_growing_and_drop/1024 | SmallVec4 | 1002.856 | 1.478× | 1.466–1.510× | loss | +| build_growing_and_drop/1024 | SmallVec8 | 1006.023 | 1.475× | 1.427–1.507× | loss | +| build_growing_and_drop/4 | Vec | 9.266 | 1.000× | 1.000–1.000× | baseline | +| build_growing_and_drop/4 | JackVec | 8.947 | 0.969× | 0.957–0.980× | inconclusive | +| build_growing_and_drop/4 | ThinVec | 8.468 | 0.923× | 0.892–0.935× | win | +| build_growing_and_drop/4 | SmallVec4 | 10.868 | 1.173× | 1.169–1.189× | loss | +| build_growing_and_drop/4 | SmallVec8 | 8.724 | 0.941× | 0.928–1.009× | inconclusive | +| dedup_adjacent_pairs/64_byte | Vec | 967.355 | 1.000× | 1.000–1.000× | baseline | +| dedup_adjacent_pairs/64_byte | JackVec | 1039.235 | 1.073× | 1.071–1.076× | loss | +| dedup_adjacent_pairs/64_byte | ThinVec | 1006.277 | 1.040× | 1.039–1.042× | loss | +| dedup_adjacent_pairs/64_byte | SmallVec4 | 1144.656 | 1.183× | 1.179–1.198× | loss | +| dedup_adjacent_pairs/64_byte | SmallVec8 | 1147.124 | 1.186× | 1.182–1.197× | loss | +| dedup_adjacent_pairs/u64 | Vec | 267.912 | 1.000× | 1.000–1.000× | baseline | +| dedup_adjacent_pairs/u64 | JackVec | 282.549 | 1.059× | 1.002–1.067× | inconclusive | +| dedup_adjacent_pairs/u64 | ThinVec | 369.631 | 1.384× | 1.376–1.548× | loss | +| dedup_adjacent_pairs/u64 | SmallVec4 | 447.886 | 1.659× | 1.589–2.044× | loss | +| dedup_adjacent_pairs/u64 | SmallVec8 | 367.336 | 1.374× | 1.307–1.384× | loss | +| extend_reserved_1024 | Vec | 152.208 | 1.000× | 1.000–1.000× | baseline | +| extend_reserved_1024 | JackVec | 164.931 | 1.072× | 1.038–1.113× | loss | +| extend_reserved_1024 | ThinVec | 155.382 | 1.021× | 0.977–1.059× | inconclusive | +| extend_reserved_1024 | SmallVec4 | 148.660 | 1.001× | 0.929–1.021× | inconclusive | +| extend_reserved_1024 | SmallVec8 | 160.759 | 1.044× | 0.988–1.078× | inconclusive | +| nested_construct_and_drop/empty | Vec | 18932.942 | 1.000× | 1.000–1.000× | baseline | +| nested_construct_and_drop/empty | JackVec | 12071.659 | 0.635× | 0.575–0.639× | win | +| nested_construct_and_drop/empty | ThinVec | 10761.009 | 0.565× | 0.503–0.570× | win | +| nested_construct_and_drop/empty | SmallVec4 | 21602.297 | 1.143× | 1.127–1.154× | loss | +| nested_construct_and_drop/empty | SmallVec8 | 27141.307 | 1.437× | 1.432–1.443× | loss | +| nested_construct_and_drop/small | Vec | 113911.536 | 1.000× | 1.000–1.000× | baseline | +| nested_construct_and_drop/small | JackVec | 108169.508 | 0.948× | 0.935–0.955× | win | +| nested_construct_and_drop/small | ThinVec | 103041.828 | 0.905× | 0.891–0.917× | win | +| nested_construct_and_drop/small | SmallVec4 | 126057.111 | 1.107× | 1.101–1.112× | loss | +| nested_construct_and_drop/small | SmallVec8 | 133435.798 | 1.170× | 1.160–1.180× | loss | +| nested_construct_and_drop/sparse | Vec | 37194.696 | 1.000× | 1.000–1.000× | baseline | +| nested_construct_and_drop/sparse | JackVec | 32354.043 | 0.874× | 0.861–0.877× | win | +| nested_construct_and_drop/sparse | ThinVec | 30068.761 | 0.811× | 0.782–0.813× | win | +| nested_construct_and_drop/sparse | SmallVec4 | 40198.086 | 1.080× | 1.078–1.084× | loss | +| nested_construct_and_drop/sparse | SmallVec8 | 45716.869 | 1.227× | 1.202–1.241× | loss | +| nested_metadata_scan_sparse | Vec | 3971.005 | 1.000× | 1.000–1.000× | baseline | +| nested_metadata_scan_sparse | JackVec | 4025.529 | 1.015× | 1.013–1.057× | inconclusive | +| nested_metadata_scan_sparse | ThinVec | 4018.097 | 1.013× | 1.008–1.040× | inconclusive | +| nested_metadata_scan_sparse | SmallVec4 | 4085.277 | 1.028× | 1.027–1.063× | inconclusive | +| nested_metadata_scan_sparse | SmallVec8 | 5346.578 | 1.346× | 1.260–1.392× | loss | +| nested_traverse/empty | Vec | 2197.898 | 1.000× | 1.000–1.000× | baseline | +| nested_traverse/empty | JackVec | 2152.744 | 0.980× | 0.979–0.984× | equivalent | +| nested_traverse/empty | ThinVec | 3955.254 | 1.804× | 1.799–1.811× | loss | +| nested_traverse/empty | SmallVec4 | 5873.415 | 2.678× | 1.840–2.684× | loss | +| nested_traverse/empty | SmallVec8 | 6001.315 | 2.737× | 2.187–2.759× | loss | +| nested_traverse/small | Vec | 21533.945 | 1.000× | 1.000–1.000× | baseline | +| nested_traverse/small | JackVec | 21523.874 | 0.999× | 0.985–1.003× | equivalent | +| nested_traverse/small | ThinVec | 21521.787 | 0.999× | 0.985–1.000× | equivalent | +| nested_traverse/small | SmallVec4 | 21421.319 | 0.994× | 0.985–0.997× | equivalent | +| nested_traverse/small | SmallVec8 | 21429.866 | 0.995× | 0.983–0.998× | equivalent | +| nested_traverse/sparse | Vec | 3242.745 | 1.000× | 1.000–1.000× | baseline | +| nested_traverse/sparse | JackVec | 3055.728 | 0.945× | 0.827–0.994× | inconclusive | +| nested_traverse/sparse | ThinVec | 5241.989 | 1.623× | 1.380–1.706× | loss | +| nested_traverse/sparse | SmallVec4 | 5045.058 | 1.555× | 1.327–1.643× | loss | +| nested_traverse/sparse | SmallVec8 | 5493.643 | 1.667× | 1.476–1.754× | loss | +| push_preallocated/1024 | Vec | 439.968 | 1.000× | 1.000–1.000× | baseline | +| push_preallocated/1024 | JackVec | 432.513 | 0.986× | 0.977–0.998× | equivalent | +| push_preallocated/1024 | ThinVec | 428.796 | 0.974× | 0.964–0.983× | inconclusive | +| push_preallocated/1024 | SmallVec4 | 714.322 | 1.623× | 1.617–1.643× | loss | +| push_preallocated/1024 | SmallVec8 | 717.536 | 1.630× | 1.626–1.640× | loss | +| push_preallocated/4 | Vec | 2.274 | 1.000× | 1.000–1.000× | baseline | +| push_preallocated/4 | JackVec | 2.103 | 0.920× | 0.911–0.931× | win | +| push_preallocated/4 | ThinVec | 2.117 | 0.932× | 0.917–0.945× | win | +| push_preallocated/4 | SmallVec4 | 14.058 | 6.135× | 6.097–6.221× | loss | +| push_preallocated/4 | SmallVec8 | 14.102 | 6.207× | 6.105–6.253× | loss | +| resize_reserved_1024 | Vec | 154.655 | 1.000× | 1.000–1.000× | baseline | +| resize_reserved_1024 | JackVec | 165.592 | 1.071× | 1.014–1.107× | inconclusive | +| resize_reserved_1024 | ThinVec | 437.112 | 2.830× | 2.793–2.917× | loss | +| resize_reserved_1024 | SmallVec4 | 153.335 | 0.982× | 0.939–1.053× | inconclusive | +| resize_reserved_1024 | SmallVec8 | 154.313 | 1.004× | 0.941–1.039× | inconclusive | +| retain_mixed/64_byte | Vec | 252.494 | 1.000× | 1.000–1.000× | baseline | +| retain_mixed/64_byte | JackVec | 294.815 | 1.163× | 1.158–1.194× | loss | +| retain_mixed/64_byte | ThinVec | 445.460 | 1.768× | 1.760–1.785× | loss | +| retain_mixed/64_byte | SmallVec4 | 526.996 | 2.089× | 2.076–2.127× | loss | +| retain_mixed/64_byte | SmallVec8 | 531.974 | 2.110× | 2.098–2.120× | loss | +| retain_mixed/u64 | Vec | 558.547 | 1.000× | 1.000–1.000× | baseline | +| retain_mixed/u64 | JackVec | 696.019 | 1.247× | 1.244–1.250× | loss | +| retain_mixed/u64 | ThinVec | 710.670 | 1.271× | 1.266–1.275× | loss | +| retain_mixed/u64 | SmallVec4 | 919.615 | 1.645× | 1.643–1.651× | loss | +| retain_mixed/u64 | SmallVec8 | 926.020 | 1.656× | 1.654–1.662× | loss | +| sequential_iteration/1024 | Vec | 58.679 | 1.000× | 1.000–1.000× | baseline | +| sequential_iteration/1024 | JackVec | 74.200 | 1.265× | 1.263–1.268× | loss | +| sequential_iteration/1024 | ThinVec | 58.847 | 1.003× | 1.002–1.004× | equivalent | +| sequential_iteration/1024 | SmallVec4 | 101.139 | 1.724× | 1.723–1.732× | loss | +| sequential_iteration/1024 | SmallVec8 | 58.641 | 1.000× | 0.999–1.000× | equivalent | +| sequential_iteration/8 | Vec | 1.075 | 1.000× | 1.000–1.000× | baseline | +| sequential_iteration/8 | JackVec | 1.271 | 1.182× | 1.179–1.185× | loss | +| sequential_iteration/8 | ThinVec | 1.398 | 1.300× | 1.297–1.304× | loss | +| sequential_iteration/8 | SmallVec4 | 1.223 | 1.138× | 1.135–1.140× | loss | +| sequential_iteration/8 | SmallVec8 | 1.088 | 1.012× | 1.009–1.017× | 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 | 245760 | 1 | 0 | na | +| nested | empty | 8 | JackVec | 80000 | 80000 | 81920 | 1 | 0 | na | +| nested | empty | 8 | ThinVec | 80000 | 80000 | 81920 | 1 | 0 | na | +| nested | empty | 8 | SmallVec4 | 400000 | 400000 | 401408 | 1 | 0 | 0 | +| nested | empty | 8 | SmallVec8 | 720000 | 720000 | 720896 | 1 | 0 | 0 | +| nested | sparse | 8 | Vec | 240000 | 304000 | 309760 | 2001 | 0 | na | +| nested | sparse | 8 | JackVec | 80000 | 160000 | 177920 | 2001 | 0 | na | +| nested | sparse | 8 | ThinVec | 80000 | 176000 | 177920 | 2001 | 0 | na | +| nested | sparse | 8 | SmallVec4 | 400000 | 400000 | 401408 | 1 | 0 | 0 | +| nested | sparse | 8 | SmallVec8 | 720000 | 720000 | 720896 | 1 | 0 | 0 | +| nested | small | 8 | Vec | 240000 | 560000 | 565760 | 10001 | 0 | na | +| nested | small | 8 | JackVec | 80000 | 480000 | 561920 | 10001 | 0 | na | +| nested | small | 8 | ThinVec | 80000 | 560000 | 561920 | 10001 | 0 | na | +| nested | small | 8 | SmallVec4 | 400000 | 400000 | 401408 | 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 | 8 | 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 | 8 | 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 | 8 | 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 | 9216 | 1 | 8 | na | +| build_growing | 1024 | 8 | ThinVec | 8 | 8208 | 9216 | 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 | 9216 | 1 | 0 | na | +| push_reserved | 1024 | 8 | ThinVec | 8 | 8208 | 9216 | 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 | 1152 | 1 | 0 | na | +| push_reserved | 1024 | 1 | ThinVec | 8 | 1040 | 1152 | 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 new file mode 100644 index 0000000..ae60629 --- /dev/null +++ b/comparisons/tools/generate_report.py @@ -0,0 +1,260 @@ +#!/usr/bin/env python3 +"""Generate deterministic, reviewable benchmark graphics from authoritative reports.""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import matplotlib as mpl +import matplotlib.pyplot as plt +import numpy as np + + +IMPLEMENTATIONS = ["Vec", "JackVec", "ThinVec", "SmallVec4", "SmallVec8"] +COLORS = { + "Vec": "#64748b", + "JackVec": "#e11d48", + "ThinVec": "#7c3aed", + "SmallVec4": "#0284c7", + "SmallVec8": "#059669", +} + + +def save_svg(fig, output: Path) -> None: + fig.savefig(output, metadata={"Date": None}) + # Matplotlib writes trailing spaces in multiline path data. Normalize its + # otherwise deterministic output so repository whitespace checks stay useful. + output.write_text("\n".join(line.rstrip() for line in output.read_text().splitlines()) + "\n") + plt.close(fig) + + +def load_report(path: Path) -> dict: + report = json.loads(path.read_text()) + if report.get("schema_version") != 1: + raise ValueError(f"{path}: unsupported schema version") + if report.get("metadata", {}).get("authoritative") is not True: + raise ValueError(f"{path}: report is not authoritative") + return report + + +def matrix(rows: list[dict], key, value) -> tuple[list[str], np.ndarray]: + labels = sorted({key(row) for row in rows}) + lookup = {(key(row), row["implementation"]): value(row) for row in rows} + values = np.array([[lookup[(label, impl)] for impl in IMPLEMENTATIONS] for label in labels]) + return labels, values + + +def heatmap(labels, values, title, subtitle, output: Path) -> None: + height = max(5.0, 0.34 * len(labels) + 2.0) + fig, ax = plt.subplots(figsize=(10.5, height), layout="constrained") + # A discrete palette keeps both the cells and colorbar as portable SVG paths; + # Matplotlib rasterizes a continuous colorbar using platform-specific PNG bytes. + palette = mpl.colormaps["RdYlGn_r"].resampled(9) + image = ax.pcolormesh(np.log2(np.clip(values, 0.5, 2.0)), cmap=palette, + vmin=-1, vmax=1, shading="flat") + ax.set_xlim(0, len(IMPLEMENTATIONS)) + ax.set_ylim(len(labels), 0) + ax.set_xticks(np.arange(len(IMPLEMENTATIONS)) + 0.5, IMPLEMENTATIONS, fontweight="bold") + ax.set_yticks(np.arange(len(labels)) + 0.5, labels, fontsize=8) + ax.tick_params(length=0) + for row in range(values.shape[0]): + for col in range(values.shape[1]): + ratio = values[row, col] + ax.text(col + 0.5, row + 0.5, f"{ratio:.2f}×", ha="center", va="center", fontsize=7, + color="white" if ratio < 0.58 or ratio > 1.72 else "#111827") + ax.set_title(title, loc="left", fontsize=16, fontweight="bold", pad=24) + ax.text(0, 1.015, subtitle, transform=ax.transAxes, fontsize=9, color="#475569") + colorbar = fig.colorbar(image, ax=ax, shrink=0.5, pad=0.02) + colorbar.set_ticks([-1, 0, 1], labels=["0.5×", "1×", "2×"]) + colorbar.set_label("ratio to Vec (lower is better)") + save_svg(fig, output) + + +def performance_profile(cpu: list[dict], platform: str, output: Path) -> None: + labels, times = matrix(cpu, lambda row: row["benchmark"], lambda row: row["median_ns"]) + del labels + relative = times / times.min(axis=1, keepdims=True) + factors = np.linspace(1.0, 2.0, 201) + fig, ax = plt.subplots(figsize=(10.5, 5.8), layout="constrained") + for col, impl in enumerate(IMPLEMENTATIONS): + fractions = [(relative[:, col] <= factor).mean() for factor in factors] + ax.plot(factors, fractions, label=impl, color=COLORS[impl], linewidth=2.4) + ax.set(xlim=(1, 2), ylim=(0, 1.01), xlabel="factor of fastest implementation (lower is better)", + ylabel="share of CPU workloads at or below factor") + ax.grid(color="#e2e8f0", linewidth=0.8) + ax.set_title("CPU performance profile", loc="left", fontsize=16, fontweight="bold", pad=24) + ax.text(0, 1.015, f"{platform} · every workload retained · higher and further left is better", + transform=ax.transAxes, fontsize=9, color="#475569") + ax.legend(ncol=5, frameon=False, loc="lower right") + save_svg(fig, output) + + +def allocation_label(row: dict) -> str: + parts = [row["benchmark"], row["input"], f"element={row['element_size']}B"] + return "/".join(parts) + + +def comparison_counts(cpu: list[dict], left: str, right: str) -> tuple[int, int, int]: + by_benchmark: dict[str, dict[str, float]] = {} + for row in cpu: + by_benchmark.setdefault(row["benchmark"], {})[row["implementation"]] = row["median_ns"] + ratios = [rows[left] / rows[right] for rows in by_benchmark.values()] + return (sum(ratio < 0.97 for ratio in ratios), + sum(0.97 <= ratio <= 1.03 for ratio in ratios), + sum(ratio > 1.03 for ratio in ratios)) + + +def write_latest(report: dict, output: Path) -> None: + metadata = report["metadata"] + audits = metadata["runtime_audits"] + classifications = { + impl: {name: 0 for name in ("win", "equivalent", "inconclusive", "loss")} + for impl in IMPLEMENTATIONS[1:] + } + for row in report["cpu"]: + if row["implementation"] in classifications: + classifications[row["implementation"]][row["classification"]] += 1 + classification_rows = "\n".join( + f"| {impl} | {counts['win']} | {counts['equivalent']} | {counts['inconclusive']} | {counts['loss']} |" + for impl, counts in classifications.items() + ) + head_rows = [] + for other in ("Vec", "ThinVec", "SmallVec4", "SmallVec8"): + faster, close, slower = comparison_counts(report["cpu"], "JackVec", other) + head_rows.append(f"| {other} | {faster} | {close} | {slower} |") + head_to_head_rows = "\n".join(head_rows) + cpu = {(row["benchmark"], row["implementation"]): row for row in report["cpu"]} + alloc = { + (row["benchmark"], row["input"], row["element_size"], row["implementation"]): row + for row in report["allocations"] + } + def cpu_ratio(benchmark: str, left: str, right: str) -> float: + return cpu[benchmark, left]["median_ns"] / cpu[benchmark, right]["median_ns"] + + def requested_ratio(benchmark: str, input_: str, element_size: str, left: str, right: str) -> float: + return (float(alloc[benchmark, input_, element_size, left]["live_requested"]) + / float(alloc[benchmark, input_, element_size, right]["live_requested"])) + + output.write_text(f"""# Latest benchmark comparison + +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. + +![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 + +- JackVec is not an across-the-board faster `Vec`: it has + {classifications['JackVec']['win']} confidence-qualified wins and + {classifications['JackVec']['loss']} losses versus `Vec` in this matrix. +- Its intended nested-density advantage is substantial: requested memory for the + empty and sparse nested workloads is + {requested_ratio('nested', 'empty', '8', 'JackVec', 'Vec'):.3f}× and + {requested_ratio('nested', 'sparse', '8', 'JackVec', 'Vec'):.3f}× Vec, + respectively, while each collection owner remains one machine word. +- The optimized large append path reaches + {cpu_ratio('append_preallocated/1024', 'JackVec', 'Vec'):.3f}× Vec and + {cpu_ratio('append_preallocated/1024', 'JackVec', 'ThinVec'):.3f}× upstream + ThinVec. This is a large targeted improvement, not a universal CPU claim. +- The clearest JackVec CPU losses versus Vec include 1,024-element sequential + iteration ({cpu_ratio('sequential_iteration/1024', 'JackVec', 'Vec'):.3f}×), + `u64` retain ({cpu_ratio('retain_mixed/u64', 'JackVec', 'Vec'):.3f}×), and + four-element append ({cpu_ratio('append_preallocated/4', 'JackVec', 'Vec'):.3f}×). + They are retained here as investigation targets. +- 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 | +|---|---:|---:|---:|---:| +{classification_rows} + +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 | +|---|---:|---:|---:| +{head_to_head_rows} + +## 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/{report['platform_id']}-memory-requested-heatmap.svg) + +![Allocator-usable live heap ratio heatmap](graphics/{report['platform_id']}-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]({report['platform_id']}.md) for +owner bytes, absolute requested/usable bytes, allocation counts, reallocations, +and spill counts. + +## Run provenance + +- Commit: `{metadata['git_commit']}` +- Compiler: `{metadata['compiler_identity']['release']}` (`{metadata['compiler_identity']['commit_hash']}`) +- CPU rounds: {report['round_count']}; CPU rows: {len(report['cpu'])}; allocation rows: {len(report['allocations'])} +- Minimum pinned-core idle audit: {min(a['cpu_idle_percent'] for a in audits):.1f}% +- Maximum audited one-minute load: {max(a['load_average'][0] for a in audits):.2f} + +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. +""") + + +def generate(report_path: Path, results_dir: Path) -> None: + report = load_report(report_path) + platform = report["platform_id"] + graphics = results_dir / "graphics" + graphics.mkdir(parents=True, exist_ok=True) + cpu_labels, cpu_values = matrix(report["cpu"], lambda row: row["benchmark"], lambda row: row["ratio_to_vec"]) + heatmap(cpu_labels, cpu_values, "CPU time by workload", f"{platform} · paired medians relative to Vec", + graphics / f"{platform}-cpu-heatmap.svg") + alloc_labels, requested = matrix(report["allocations"], allocation_label, + lambda row: float(row["live_requested"])) + requested /= requested[:, :1] + heatmap(alloc_labels, requested, "Requested live heap by workload", + f"{platform} · requested bytes relative to Vec · zero means inline storage", + graphics / f"{platform}-memory-requested-heatmap.svg") + _, usable = matrix(report["allocations"], allocation_label, + lambda row: float(row["live_usable"])) + usable /= usable[:, :1] + heatmap(alloc_labels, usable, "Allocator-usable live heap by workload", + 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 main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("report", type=Path) + 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) + + +if __name__ == "__main__": + main()