diff --git a/.gitignore b/.gitignore index 05367bc..ebb197c 100644 --- a/.gitignore +++ b/.gitignore @@ -28,4 +28,7 @@ Cargo.lock *.pdb # Results log files from analysis script -*.log \ No newline at end of file +*.log + +# Python virtual environment +venv/ \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 9108093..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "rust-analyzer.rustc.source": "discover" -} \ No newline at end of file diff --git a/README.md b/README.md index 5f79a42..b9044c3 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ [![GitHub CI][github-ci-shield]][github-ci] This repository contains the artifact for the paper "Meta-monomorphizing Specializations". -The artifact consists of two main components: a prototype implementation and an instrumentation tool for empirical analysis. +The artifact consists of three main components: a prototype implementation, an instrumentation tool for empirical analysis, and a benchmark evaluation suite. --- @@ -18,6 +18,7 @@ The artifact consists of two main components: a prototype implementation and an - [Getting Started](#getting-started) - [Prototype Implementation (`spec-trait-impl`)](#prototype-implementation-spec-trait-impl) - [Instrumentation Tool (`spec-trait-inst`)](#instrumentation-tool-spec-trait-inst) + - [Evaluation Benchmarks (`spec-trait-evaluation`)](#evaluation-benchmarks-spec-trait-evaluation) - [Reproducing the Empirical Evaluation](#reproducing-the-empirical-evaluation) - [Pre-computed Results](#pre-computed-results) - [Contact](#contact) @@ -32,6 +33,8 @@ This artifact provides: 2. **`spec-trait-inst/`** — An instrumentation tool built as a `cargo`/`rustc` wrapper that statically analyzes Rust projects to identify trait specialization opportunities. +3. **`spec-trait-evaluation/`** — A benchmark suite that compares `spec!`/`#[when]` compile-time specialization against alternative dispatch strategies (naive, enum, runtime `TypeId`), measuring runtime performance, build time, and binary size. See the [evaluation README](spec-trait-evaluation/README.md) for details. + --- ## Repository Structure @@ -45,9 +48,15 @@ spec-trait/ │ ├── spec-trait-order/ # Compile-time trait ordering │ └── spec-trait-utils/ # Shared utilities │ -└── spec-trait-inst/ # Instrumentation tool - ├── src/ # Source code - └── tests/ +├── spec-trait-inst/ # Instrumentation tool +│ ├── src/ # Source code +│ └── tests/ +│ +└── spec-trait-evaluation/ # Benchmark evaluation suite + ├── benches-crate/ # Criterion benchmarks + ├── notebooks/ # Analysis notebooks + ├── results/ # Pre-computed CSV results + └── scripts/ # Metric collection scripts ├── scripts/ # Analysis scripts and results │ ├── analysis.sh # Main analysis script │ ├── repos.txt # List of repositories analyzed diff --git a/spec-trait-evaluation/.vscode/settings.json b/spec-trait-evaluation/.vscode/settings.json new file mode 100644 index 0000000..c9ebf2d --- /dev/null +++ b/spec-trait-evaluation/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python-envs.defaultEnvManager": "ms-python.python:system" +} \ No newline at end of file diff --git a/spec-trait-evaluation/README.md b/spec-trait-evaluation/README.md new file mode 100644 index 0000000..edb7703 --- /dev/null +++ b/spec-trait-evaluation/README.md @@ -0,0 +1,95 @@ +# spec-trait Evaluation + +Benchmark suite that compares `spec!`/`#[when]` compile-time specialization against three alternative dispatch strategies: + +| Approach | Description | +|---|---| +| **spec** | Compile-time specialization via `spec!`/`#[when]` macros | +| **naive** | Plain generic fallback (no specialization) | +| **enum** | Enum-based match dispatch | +| **runtime_typeid** | `TypeId`-based runtime branching | + +## Examples + +Each example implements the same operation with 4 dispatch approaches. +The `spec` variant exploits type-specific knowledge (e.g. memcpy, SIMD byte search, counting sort) that a naive generic fallback cannot use. + +| # | Operation | `when` condition | spec strategy | Naive fallback | +|---|-----------|-----------------|---------------|----------------| +| ex01 | extend_from_slice | `T: Copy` | `ptr::copy_nonoverlapping` (memcpy) | clone loop | +| ex02 | to_bytes | `T: Copy` | raw `transmute` (zero-copy) | `format!()` per element | +| ex03 | contains | `T = u8` | `memchr` SIMD | `iter().any()` | +| ex04 | sort | `T = u8` | counting sort `[u32; 256]` | `sort_unstable()` | +| ex05 | histogram (max freq) | `T = u8` | `[u32; 256]` direct index | `HashMap<&T, u32>` | +| ex06 | dedup (keep first) | `T = u8` | `[bool; 256]` bitmap | `HashSet` | +| ex07 | hash_key | `K = u64` | identity XOR (no hashing) | `DefaultHasher` (SipHash) | +| ex08 | count_value | `T = u8` | `memchr_iter().count()` | `filter().count()` | + +## Project structure + +``` +spec-trait-evaluation/ +├── benches-crate/ # Rust crate with benchmarks +│ ├── Cargo.toml +│ ├── build.rs +│ ├── benches/ +│ │ └── bench.rs # Criterion harness (8 benchmark groups) +│ └── src/ +│ ├── lib.rs +│ ├── data.rs # Input generators (make_u8, make_i32, ...) +│ └── examples/ # 32 source files (8 examples × 4 variants) +├── scripts/ +│ ├── run_all.sh # Run benchmarks + collect all metrics +│ ├── collect_metrics.py # Parse Criterion JSON → runtime.csv +│ ├── measure_build_time.sh # Per-variant cargo check timing → build_time.csv +│ └── measure_binary_size.sh # Per-variant release rlib sizes → binary_size.csv +├── notebooks/ +│ ├── eval.ipynb # Analysis notebook (plots + summary tables) +│ └── requirements.txt # Python dependencies +└── results/ + ├── runtime.csv + ├── build_time.csv + └── binary_size.csv +``` + +## Reproducing + +### Prerequisites + +- Rust nightly (edition 2024) +- Python 3 with `pandas`, `matplotlib`, `seaborn` + +### Run individual measurements + +```bash +# Runtime benchmarks (Criterion) +cargo bench --manifest-path benches-crate/Cargo.toml --bench bench +cargo bench --manifest-path benches-crate/Cargo.toml --bench bench -- --warm-up-time 1 --measurement-time 3 --sample-size 10 +cargo bench --manifest-path benches-crate/Cargo.toml --bench bench -- --warm-up-time 1 --measurement-time 3 --sample-size 10 + +# Collect runtime CSV from Criterion output +python3 scripts/collect_metrics.py \ + --criterion-dir benches-crate/target/criterion \ + --output results/runtime.csv + +# Compile time (3 iterations, 8 examples) +bash scripts/measure_build_time.sh 3 8 + +# Binary size +bash scripts/measure_binary_size.sh 8 +``` + +### Notebook + +```bash +pip install -r notebooks/requirements.txt +jupyter notebook notebooks/eval_pretty.ipynb +``` + +## Benchmark parameters + +- **Input sizes**: 256, 1024, 4096, 16384, 65536 elements +- **Data type**: `u8` (most examples), `u64` (ex07 hash_key) +- **Criterion config**: warm-up 3s, measurement 5s, 100 samples (default); `--quick` uses 1s/3s/10 +- **Build time**: `cargo check` from clean local crate (dependencies pre-cached), 3 iterations +- **Binary size**: release-mode `rlib` artifact (`opt-level=3`, `lto=false`, `codegen-units=16`) diff --git a/spec-trait-evaluation/benches-crate/Cargo.toml b/spec-trait-evaluation/benches-crate/Cargo.toml new file mode 100644 index 0000000..771df99 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "spec-trait-evaluation" +version = "0.1.0" +edition = "2024" + +[dependencies] +spec-trait-macro = { path = "../../spec-trait-impl/crates/spec-trait-macro" } +memchr = "2" + +[dev-dependencies] +criterion = { version = "0.5", features = ["html_reports", "csv_output"] } + +[build-dependencies] +spec-trait-order = { path = "../../spec-trait-impl/crates/spec-trait-order" } + +[profile.release] +opt-level = 0 +lto = false +codegen-units = 16 + +[[bench]] +name = "bench" +harness = false diff --git a/spec-trait-evaluation/benches-crate/benches/bench.rs b/spec-trait-evaluation/benches-crate/benches/bench.rs new file mode 100644 index 0000000..e6a6f36 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/benches/bench.rs @@ -0,0 +1,255 @@ +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; +use spec_trait_evaluation::data::*; +use spec_trait_evaluation::examples::*; + +/// Data sizes: tiny (dispatch-overhead-dominated) → medium (work-dominated). +/// At size 8 the dispatch cost is a large fraction of per-call time; +/// at size 2048 the actual work dominates and dispatch is negligible. +const SIZES: [usize; 9] = [8, 16, 32, 64, 128, 256, 512, 1024, 2048]; //, 4096, 8192, 16384, 32768, 65536, 131072]; + +// ── Ex01: extend — Copy memcpy vs Clone loop ────────────────────────── +fn bench_ex01(c: &mut Criterion) { + let mut g = c.benchmark_group("ex01_extend"); + for &size in &SIZES { + let src = make_u8(size); + let ext = ex01_spec::Extender; + let ext_naive = ex01_naive::Extender; + let ext_rt = ex01_runtime_typeid::Extender; + g.bench_with_input(BenchmarkId::new("spec", size), &src, |b, src| { + let mut dst = Vec::with_capacity(size); + b.iter(|| { + dst.clear(); + ex01_spec::extend_u8(&ext, &mut dst, std::hint::black_box(src)); + std::hint::black_box(&dst); + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &src, |b, src| { + let mut dst = Vec::with_capacity(size); + b.iter(|| { + dst.clear(); + ex01_naive::extend_naive(&ext_naive, &mut dst, std::hint::black_box(src)); + std::hint::black_box(&dst); + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &src, |b, src| { + let mut dst = Vec::with_capacity(size); + b.iter(|| { + dst.clear(); + ex01_runtime_typeid::extend_runtime(&ext_rt, &mut dst, std::hint::black_box(src)); + std::hint::black_box(&dst); + }) + }); + } + g.finish(); +} + +// ── Ex02: to_bytes — raw transmute vs Display formatting ─────────────── +fn bench_ex02(c: &mut Criterion) { + let mut g = c.benchmark_group("ex02_to_bytes"); + for &size in &SIZES { + let data = make_u8(size); + let s = ex02_spec::Serializer; + let s_naive = ex02_naive::Serializer; + let s_rt = ex02_runtime_typeid::Serializer; + g.bench_with_input(BenchmarkId::new("spec", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex02_spec::to_bytes_u8(&s, std::hint::black_box(data))) + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex02_naive::to_bytes_naive(&s_naive, std::hint::black_box(data))) + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex02_runtime_typeid::to_bytes_runtime(&s_rt, std::hint::black_box(data))) + }) + }); + } + g.finish(); +} + +// ── Ex03: contains — byte range check vs PartialOrd ──────────────────── +fn bench_ex03(c: &mut Criterion) { + let mut g = c.benchmark_group("ex03_contains"); + let lo: u8 = 50; + let hi: u8 = 200; + for &size in &SIZES { + let data = make_u8(size); + let sc = ex03_spec::Searcher; + let sc_naive = ex03_naive::Searcher; + let sc_rt = ex03_runtime_typeid::Searcher; + g.bench_with_input(BenchmarkId::new("spec", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex03_spec::contains_u8(&sc, std::hint::black_box(data), &lo, &hi)) + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex03_naive::contains_naive(&sc_naive, std::hint::black_box(data), &lo, &hi)) + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex03_runtime_typeid::contains_runtime(&sc_rt, std::hint::black_box(data), &lo, &hi)) + }) + }); + } + g.finish(); +} + +// ── Ex04: sort — counting sort O(N) vs sort_unstable O(N log N) ─────── +fn bench_ex04(c: &mut Criterion) { + let mut g = c.benchmark_group("ex04_sort"); + for &size in &SIZES { + let base = make_u8(size); + let sr = ex04_spec::Sorter; + let sr_naive = ex04_naive::Sorter; + let sr_rt = ex04_runtime_typeid::Sorter; + g.bench_with_input(BenchmarkId::new("spec", size), &base, |b, base| { + b.iter(|| { + let mut d = base.clone(); + ex04_spec::sort_u8(&sr, std::hint::black_box(&mut d)); + std::hint::black_box(&d); + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &base, |b, base| { + b.iter(|| { + let mut d = base.clone(); + ex04_naive::sort_naive(&sr_naive, std::hint::black_box(&mut d)); + std::hint::black_box(&d); + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &base, |b, base| { + b.iter(|| { + let mut d = base.clone(); + ex04_runtime_typeid::sort_runtime(&sr_rt, std::hint::black_box(&mut d)); + std::hint::black_box(&d); + }) + }); + } + g.finish(); +} + +// ── Ex05: histogram — array[256] vs HashMap ──────────────────────────── +fn bench_ex05(c: &mut Criterion) { + let mut g = c.benchmark_group("ex05_histogram"); + for &size in &SIZES { + let data = make_u8(size); + let h = ex05_spec::HistogramOp; + let h_naive = ex05_naive::HistogramOp; + let h_rt = ex05_runtime_typeid::HistogramOp; + g.bench_with_input(BenchmarkId::new("spec", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex05_spec::max_freq_u8(&h, std::hint::black_box(data))) + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex05_naive::max_freq_naive(&h_naive, std::hint::black_box(data))) + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex05_runtime_typeid::max_freq_runtime(&h_rt, std::hint::black_box(data))) + }) + }); + } + g.finish(); +} + +// ── Ex06: dedup — bitmap[256] vs HashSet ─────────────────────────────── +fn bench_ex06(c: &mut Criterion) { + let mut g = c.benchmark_group("ex06_dedup"); + for &size in &SIZES { + let data = make_u8(size); + let dd = ex06_spec::Deduplicator; + let dd_naive = ex06_naive::Deduplicator; + let dd_rt = ex06_runtime_typeid::Deduplicator; + g.bench_with_input(BenchmarkId::new("spec", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex06_spec::dedup_u8(&dd, std::hint::black_box(data))) + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex06_naive::dedup_naive(&dd_naive, std::hint::black_box(data))) + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex06_runtime_typeid::dedup_runtime(&dd_rt, std::hint::black_box(data))) + }) + }); + } + g.finish(); +} + +// ── Ex07: hash_key — identity XOR vs SipHash ─────────────────────────── +fn bench_ex07(c: &mut Criterion) { + let mut g = c.benchmark_group("ex07_hash_key"); + for &size in &SIZES { + let keys = make_u64(size); + let h = ex07_spec::HashOp; + let h_naive = ex07_naive::HashOp; + let h_rt = ex07_runtime_typeid::HashOp; + g.bench_with_input(BenchmarkId::new("spec", size), &keys, |b, keys| { + b.iter(|| { + std::hint::black_box(ex07_spec::hash_all_u64(&h, std::hint::black_box(keys))) + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &keys, |b, keys| { + b.iter(|| { + std::hint::black_box(ex07_naive::hash_all_naive(&h_naive, std::hint::black_box(keys))) + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &keys, |b, keys| { + b.iter(|| { + std::hint::black_box(ex07_runtime_typeid::hash_all_runtime(&h_rt, std::hint::black_box(keys))) + }) + }); + } + g.finish(); +} + +// ── Ex08: count_value — memchr SIMD vs filter().count() ──────────────── +fn bench_ex08(c: &mut Criterion) { + let mut g = c.benchmark_group("ex08_count_value"); + let needle: u8 = 42; + for &size in &SIZES { + let data = make_u8(size); + let op = ex08_spec::CountValOp; + let op_naive = ex08_naive::CountValOp; + let op_rt = ex08_runtime_typeid::CountValOp; + g.bench_with_input(BenchmarkId::new("spec", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex08_spec::count_val_u8(&op, std::hint::black_box(data), &needle)) + }) + }); + g.bench_with_input(BenchmarkId::new("naive", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex08_naive::count_val_naive(&op_naive, std::hint::black_box(data), &needle)) + }) + }); + g.bench_with_input(BenchmarkId::new("runtime_typeid", size), &data, |b, data| { + b.iter(|| { + std::hint::black_box(ex08_runtime_typeid::count_val_runtime(&op_rt, std::hint::black_box(data), &needle)) + }) + }); + } + g.finish(); +} + +criterion_group!( + benches, + bench_ex01, + bench_ex02, + bench_ex03, + bench_ex04, + bench_ex05, + bench_ex06, + bench_ex07, + bench_ex08, +); +criterion_main!(benches); diff --git a/spec-trait-evaluation/benches-crate/build.rs b/spec-trait-evaluation/benches-crate/build.rs new file mode 100644 index 0000000..4186ca5 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/build.rs @@ -0,0 +1,3 @@ +fn main() { + spec_trait_order::handle_order(); +} diff --git a/spec-trait-evaluation/benches-crate/src/data.rs b/spec-trait-evaluation/benches-crate/src/data.rs new file mode 100644 index 0000000..d51fa63 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/data.rs @@ -0,0 +1,54 @@ +/// Test data generators for benchmarks. + +pub fn make_u8(n: usize) -> Vec { + (0..n).map(|i| (i % 256) as u8).collect() +} + +pub fn make_i32(n: usize) -> Vec { + (0..n as i32).collect() +} + +pub fn make_f64(n: usize) -> Vec { + (0..n).map(|i| i as f64 * 0.1).collect() +} + +pub fn make_sorted_u8(n: usize) -> Vec { + let mut data = make_u8(n); + data.sort(); + data +} + +pub fn make_u64(n: usize) -> Vec { + (0..n as u64).collect() +} + +pub fn make_strings(n: usize) -> Vec { + (0..n).map(|i| format!("item_{}", i)).collect() +} + +/// Static i32 values for reference-based benchmarks. +/// Returns a Vec of &'static i32 references to a leaked array. +pub fn make_static_i32_refs(n: usize) -> Vec<&'static i32> { + let data: Vec = (0..n as i32).collect(); + let leaked: &'static [i32] = Box::leak(data.into_boxed_slice()); + leaked.iter().collect() +} + +/// Nested Vec for flatten benchmarks. +/// Creates `n` inner vectors, each of size `chunk`. +pub fn make_nested_vec_u8(n: usize, chunk: usize) -> Vec> { + (0..n) + .map(|i| (0..chunk).map(|j| ((i * chunk + j) % 256) as u8).collect()) + .collect() +} + +/// Vec items for capacity benchmarks. +pub fn make_vec_u8_items(n: usize, inner_cap: usize) -> Vec> { + (0..n) + .map(|_| { + let mut v = Vec::with_capacity(inner_cap); + v.extend((0..inner_cap).map(|j| (j % 256) as u8)); + v + }) + .collect() +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex01_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex01_naive.rs new file mode 100644 index 0000000..9b2c51f --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex01_naive.rs @@ -0,0 +1,20 @@ +// Ex01 -- naive: extend_from_slice — clone loop (no specialization) + +pub struct Extender; + +pub trait NaiveExtendTrait { + fn extend_slice(&self, dst: &mut Vec, src: &[T]); +} + +impl NaiveExtendTrait for Extender { + #[inline(never)] + fn extend_slice(&self, dst: &mut Vec, src: &[T]) { + for item in src { + dst.push(item.clone()); + } + } +} + +pub fn extend_naive(e: &Extender, dst: &mut Vec, src: &[u8]) { + e.extend_slice(dst, src); +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex01_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex01_runtime_typeid.rs new file mode 100644 index 0000000..ae860df --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex01_runtime_typeid.rs @@ -0,0 +1,30 @@ +// Ex01 -- runtime TypeId dispatch: extend_from_slice +use std::any::TypeId; + +pub struct Extender; + +pub trait RtExtendTrait { + fn extend_slice(&self, dst: &mut Vec, src: &[T]); +} + +impl RtExtendTrait for Extender { + #[inline(never)] + fn extend_slice(&self, dst: &mut Vec, src: &[T]) { + if TypeId::of::() == TypeId::of::() { + let len = src.len(); + dst.reserve(len); + unsafe { + std::ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr().add(dst.len()), len); + dst.set_len(dst.len() + len); + } + } else { + for item in src { + dst.push(item.clone()); + } + } + } +} + +pub fn extend_runtime(e: &Extender, dst: &mut Vec, src: &[u8]) { + e.extend_slice(dst, src); +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex01_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex01_spec.rs new file mode 100644 index 0000000..2b6b857 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex01_spec.rs @@ -0,0 +1,36 @@ +// Ex01 -- spec: extend_from_slice — Copy memcpy vs Clone loop +use spec_trait_macro::{spec, when}; + +pub struct Extender; + +pub trait ExtendTrait { + fn extend_slice(&self, dst: &mut Vec, src: &[T]); +} + +impl ExtendTrait for Extender { + #[inline(never)] + fn extend_slice(&self, dst: &mut Vec, src: &[T]) { + for item in src { + dst.push(item.clone()); + } + } +} + +#[when(T: Copy)] +impl ExtendTrait for Extender { + #[inline(never)] + fn extend_slice(&self, dst: &mut Vec, src: &[T]) { + let len = src.len(); + dst.reserve(len); + unsafe { + std::ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr().add(dst.len()), len); + dst.set_len(dst.len() + len); + } + } +} + +pub fn extend_u8(e: &Extender, dst: &mut Vec, src: &[u8]) { + spec! { e.extend_slice(dst, src); Extender; [&mut Vec, &[u8]]; u8: Copy } +} + + diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex02_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex02_naive.rs new file mode 100644 index 0000000..662fd59 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex02_naive.rs @@ -0,0 +1,23 @@ +// Ex02 -- naive: to_bytes — Display formatting (no specialization) +use std::fmt::Display; + +pub struct Serializer; + +pub trait NaiveToByteTrait { + fn to_bytes(&self, data: &[T]) -> Vec; +} + +impl NaiveToByteTrait for Serializer { + #[inline(never)] + fn to_bytes(&self, data: &[T]) -> Vec { + let mut result = Vec::new(); + for item in data { + result.extend_from_slice(format!("{}", item).as_bytes()); + } + result + } +} + +pub fn to_bytes_naive(s: &Serializer, data: &[u8]) -> Vec { + s.to_bytes(data) +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex02_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex02_runtime_typeid.rs new file mode 100644 index 0000000..92e34eb --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex02_runtime_typeid.rs @@ -0,0 +1,34 @@ +// Ex02 -- runtime TypeId dispatch: to_bytes +use std::any::TypeId; +use std::fmt::Display; + +pub struct Serializer; + +pub trait RtToByteTrait { + fn to_bytes(&self, data: &[T]) -> Vec; +} + +impl RtToByteTrait for Serializer { + #[inline(never)] + fn to_bytes(&self, data: &[T]) -> Vec { + if TypeId::of::() == TypeId::of::() { + unsafe { + std::slice::from_raw_parts( + data.as_ptr() as *const u8, + data.len() * std::mem::size_of::(), + ) + .to_vec() + } + } else { + let mut result = Vec::new(); + for item in data { + result.extend_from_slice(format!("{}", item).as_bytes()); + } + result + } + } +} + +pub fn to_bytes_runtime(s: &Serializer, data: &[u8]) -> Vec { + s.to_bytes(data) +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex02_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex02_spec.rs new file mode 100644 index 0000000..fdb43ce --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex02_spec.rs @@ -0,0 +1,38 @@ +// Ex02 -- spec: to_bytes — Copy raw transmute vs Display formatting +use spec_trait_macro::{spec, when}; +use std::fmt::Display; + +pub struct Serializer; + +pub trait ToByteTrait { + fn to_bytes(&self, data: &[T]) -> Vec; +} + +impl ToByteTrait for Serializer { + #[inline(never)] + fn to_bytes(&self, data: &[T]) -> Vec { + let mut result = Vec::new(); + for item in data { + result.extend_from_slice(format!("{}", item).as_bytes()); + } + result + } +} + +#[when(T: Copy)] +impl ToByteTrait for Serializer { + #[inline(never)] + fn to_bytes(&self, data: &[T]) -> Vec { + unsafe { + std::slice::from_raw_parts( + data.as_ptr() as *const u8, + data.len() * std::mem::size_of::(), + ) + .to_vec() + } + } +} + +pub fn to_bytes_u8(s: &Serializer, data: &[u8]) -> Vec { + spec! { s.to_bytes(data); Serializer; [&[u8]]; u8: Copy } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex03_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex03_naive.rs new file mode 100644 index 0000000..7ea7e1d --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex03_naive.rs @@ -0,0 +1,24 @@ +// Ex03 -- naive: contains — PartialOrd (no specialization) + +pub struct Searcher; + +pub trait NaiveContainsTrait { + fn in_range(&self, item: &T, lo: &T, hi: &T) -> bool; +} + +impl NaiveContainsTrait for Searcher { + #[inline(never)] + fn in_range(&self, item: &T, lo: &T, hi: &T) -> bool { + item >= lo && item <= hi + } +} + +pub fn contains_naive(s: &Searcher, data: &[u8], lo: &u8, hi: &u8) -> usize { + let mut count = 0; + for item in data { + if s.in_range(item, lo, hi) { + count += 1; + } + } + count +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex03_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex03_runtime_typeid.rs new file mode 100644 index 0000000..041b2b2 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex03_runtime_typeid.rs @@ -0,0 +1,32 @@ +// Ex03 -- runtime TypeId dispatch: contains +use std::any::TypeId; + +pub struct Searcher; + +pub trait RtContainsTrait { + fn in_range(&self, item: &T, lo: &T, hi: &T) -> bool; +} + +impl RtContainsTrait for Searcher { + #[inline(never)] + fn in_range(&self, item: &T, lo: &T, hi: &T) -> bool { + if TypeId::of::() == TypeId::of::() { + let b = unsafe { *(item as *const T as *const u8) }; + let lo_b = unsafe { *(lo as *const T as *const u8) }; + let hi_b = unsafe { *(hi as *const T as *const u8) }; + b >= lo_b && b <= hi_b + } else { + item >= lo && item <= hi + } + } +} + +pub fn contains_runtime(s: &Searcher, data: &[u8], lo: &u8, hi: &u8) -> usize { + let mut count = 0; + for item in data { + if s.in_range(item, lo, hi) { + count += 1; + } + } + count +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex03_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex03_spec.rs new file mode 100644 index 0000000..8115d75 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex03_spec.rs @@ -0,0 +1,41 @@ +// Ex03 -- spec: contains — byte range check vs PartialOrd +use spec_trait_macro::{spec, when}; + +pub struct Searcher; + +pub trait ContainsTrait { + fn in_range(&self, item: &T, lo: &T, hi: &T) -> bool; +} + +impl ContainsTrait for Searcher { + #[inline(never)] + fn in_range(&self, item: &T, lo: &T, hi: &T) -> bool { + item >= lo && item <= hi + } +} + +#[when(T = u8)] +impl ContainsTrait for Searcher { + #[inline(never)] + fn in_range(&self, item: &T, lo: &T, hi: &T) -> bool { + let b = unsafe { *(item as *const T as *const u8) }; + let lo_b = unsafe { *(lo as *const T as *const u8) }; + let hi_b = unsafe { *(hi as *const T as *const u8) }; + b >= lo_b && b <= hi_b + } +} + +#[inline(always)] +fn in_range_spec(s: &Searcher, item: &u8, lo: &u8, hi: &u8) -> bool { + spec! { s.in_range(item, lo, hi); Searcher; [&u8, &u8, &u8] } +} + +pub fn contains_u8(s: &Searcher, data: &[u8], lo: &u8, hi: &u8) -> usize { + let mut count = 0; + for item in data { + if in_range_spec(s, item, lo, hi) { + count += 1; + } + } + count +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex04_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex04_naive.rs new file mode 100644 index 0000000..99d70c3 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex04_naive.rs @@ -0,0 +1,18 @@ +// Ex04 -- naive: sort — generic Ord comparison (no specialization) + +pub struct Sorter; + +pub trait NaiveCmpTrait { + fn compare(&self, a: &T, b: &T) -> std::cmp::Ordering; +} + +impl NaiveCmpTrait for Sorter { + #[inline(never)] + fn compare(&self, a: &T, b: &T) -> std::cmp::Ordering { + a.cmp(b) + } +} + +pub fn sort_naive(s: &Sorter, data: &mut [u8]) { + data.sort_unstable_by(|a, b| s.compare(a, b)); +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex04_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex04_runtime_typeid.rs new file mode 100644 index 0000000..2f194ec --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex04_runtime_typeid.rs @@ -0,0 +1,32 @@ +// Ex04 -- runtime TypeId dispatch: sort +use std::any::TypeId; +use std::cmp::Ordering; + +pub struct Sorter; + +pub trait RtCmpTrait { + fn compare(&self, a: &T, b: &T) -> Ordering; +} + +impl RtCmpTrait for Sorter { + #[inline(never)] + fn compare(&self, a: &T, b: &T) -> Ordering { + if TypeId::of::() == TypeId::of::() { + let a_byte = unsafe { *(a as *const T as *const u8) }; + let b_byte = unsafe { *(b as *const T as *const u8) }; + if a_byte < b_byte { + Ordering::Less + } else if a_byte > b_byte { + Ordering::Greater + } else { + Ordering::Equal + } + } else { + a.cmp(b) + } + } +} + +pub fn sort_runtime(s: &Sorter, data: &mut [u8]) { + data.sort_unstable_by(|a, b| s.compare(a, b)); +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex04_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex04_spec.rs new file mode 100644 index 0000000..ad64605 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex04_spec.rs @@ -0,0 +1,41 @@ +// Ex04 -- spec: sort — direct byte comparison for u8 vs generic Ord +use spec_trait_macro::{spec, when}; +use std::cmp::Ordering; + +pub struct Sorter; + +pub trait CmpTrait { + fn compare(&self, a: &T, b: &T) -> Ordering; +} + +impl CmpTrait for Sorter { + #[inline(never)] + fn compare(&self, a: &T, b: &T) -> Ordering { + a.cmp(b) + } +} + +#[when(T = u8)] +impl CmpTrait for Sorter { + #[inline(never)] + fn compare(&self, a: &T, b: &T) -> Ordering { + let a_byte = unsafe { *(a as *const T as *const u8) }; + let b_byte = unsafe { *(b as *const T as *const u8) }; + if a_byte < b_byte { + Ordering::Less + } else if a_byte > b_byte { + Ordering::Greater + } else { + Ordering::Equal + } + } +} + +#[inline(always)] +fn compare_spec(s: &Sorter, a: &u8, b: &u8) -> Ordering { + spec! { s.compare(a, b); Sorter; [&u8, &u8] } +} + +pub fn sort_u8(s: &Sorter, data: &mut [u8]) { + data.sort_unstable_by(|a, b| compare_spec(s, a, b)); +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex05_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex05_naive.rs new file mode 100644 index 0000000..9ae5f52 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex05_naive.rs @@ -0,0 +1,26 @@ +// Ex05 -- naive: histogram — hash bucket (no specialization) +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct HistogramOp; + +pub trait NaiveBucketTrait { + fn bucket(&self, item: &T) -> usize; +} + +impl NaiveBucketTrait for HistogramOp { + #[inline(never)] + fn bucket(&self, item: &T) -> usize { + let mut h = DefaultHasher::new(); + item.hash(&mut h); + (h.finish() % 256) as usize + } +} + +pub fn max_freq_naive(h: &HistogramOp, data: &[u8]) -> u32 { + let mut counts = [0u32; 256]; + for item in data { + counts[h.bucket(item)] += 1; + } + counts.iter().copied().max().unwrap_or(0) +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex05_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex05_runtime_typeid.rs new file mode 100644 index 0000000..6dc4ecb --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex05_runtime_typeid.rs @@ -0,0 +1,31 @@ +// Ex05 -- runtime TypeId dispatch: histogram +use std::any::TypeId; +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct HistogramOp; + +pub trait RtBucketTrait { + fn bucket(&self, item: &T) -> usize; +} + +impl RtBucketTrait for HistogramOp { + #[inline(never)] + fn bucket(&self, item: &T) -> usize { + if TypeId::of::() == TypeId::of::() { + unsafe { *(item as *const T as *const u8) as usize } + } else { + let mut h = DefaultHasher::new(); + item.hash(&mut h); + (h.finish() % 256) as usize + } + } +} + +pub fn max_freq_runtime(h: &HistogramOp, data: &[u8]) -> u32 { + let mut counts = [0u32; 256]; + for item in data { + counts[h.bucket(item)] += 1; + } + counts.iter().copied().max().unwrap_or(0) +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex05_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex05_spec.rs new file mode 100644 index 0000000..466d315 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex05_spec.rs @@ -0,0 +1,40 @@ +// Ex05 -- spec: histogram — direct byte index vs hash bucket +use spec_trait_macro::{spec, when}; +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct HistogramOp; + +pub trait BucketTrait { + fn bucket(&self, item: &T) -> usize; +} + +impl BucketTrait for HistogramOp { + #[inline(never)] + fn bucket(&self, item: &T) -> usize { + let mut h = DefaultHasher::new(); + item.hash(&mut h); + (h.finish() % 256) as usize + } +} + +#[when(T = u8)] +impl BucketTrait for HistogramOp { + #[inline(never)] + fn bucket(&self, item: &T) -> usize { + unsafe { *(item as *const T as *const u8) as usize } + } +} + +#[inline(always)] +fn bucket_spec(h: &HistogramOp, item: &u8) -> usize { + spec! { h.bucket(item); HistogramOp; [&u8] } +} + +pub fn max_freq_u8(h: &HistogramOp, data: &[u8]) -> u32 { + let mut counts = [0u32; 256]; + for item in data { + counts[bucket_spec(h, item)] += 1; + } + counts.iter().copied().max().unwrap_or(0) +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex06_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex06_naive.rs new file mode 100644 index 0000000..2290919 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex06_naive.rs @@ -0,0 +1,26 @@ +// Ex06 -- naive: transform — hash-based remap (no specialization) +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct Deduplicator; + +pub trait NaiveTransformTrait { + fn transform(&self, item: &T) -> u8; +} + +impl NaiveTransformTrait for Deduplicator { + #[inline(never)] + fn transform(&self, item: &T) -> u8 { + let mut h = DefaultHasher::new(); + item.hash(&mut h); + (h.finish() & 0xFF) as u8 + } +} + +pub fn dedup_naive(d: &Deduplicator, data: &[u8]) -> Vec { + let mut result = Vec::with_capacity(data.len()); + for item in data { + result.push(d.transform(item)); + } + result +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex06_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex06_runtime_typeid.rs new file mode 100644 index 0000000..3106301 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex06_runtime_typeid.rs @@ -0,0 +1,32 @@ +// Ex06 -- runtime TypeId dispatch: transform +use std::any::TypeId; +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct Deduplicator; + +pub trait RtTransformTrait { + fn transform(&self, item: &T) -> u8; +} + +impl RtTransformTrait for Deduplicator { + #[inline(never)] + fn transform(&self, item: &T) -> u8 { + if TypeId::of::() == TypeId::of::() { + let b = unsafe { *(item as *const T as *const u8) }; + b ^ 0x55 + } else { + let mut h = DefaultHasher::new(); + item.hash(&mut h); + (h.finish() & 0xFF) as u8 + } + } +} + +pub fn dedup_runtime(d: &Deduplicator, data: &[u8]) -> Vec { + let mut result = Vec::with_capacity(data.len()); + for item in data { + result.push(d.transform(item)); + } + result +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex06_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex06_spec.rs new file mode 100644 index 0000000..9194adf --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex06_spec.rs @@ -0,0 +1,41 @@ +// Ex06 -- spec: transform — XOR remap for u8 vs hash-based remap +use spec_trait_macro::{spec, when}; +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct Deduplicator; + +pub trait TransformTrait { + fn transform(&self, item: &T) -> u8; +} + +impl TransformTrait for Deduplicator { + #[inline(never)] + fn transform(&self, item: &T) -> u8 { + let mut h = DefaultHasher::new(); + item.hash(&mut h); + (h.finish() & 0xFF) as u8 + } +} + +#[when(T = u8)] +impl TransformTrait for Deduplicator { + #[inline(never)] + fn transform(&self, item: &T) -> u8 { + let b = unsafe { *(item as *const T as *const u8) }; + b ^ 0x55 + } +} + +#[inline(always)] +fn transform_spec(d: &Deduplicator, item: &u8) -> u8 { + spec! { d.transform(item); Deduplicator; [&u8] } +} + +pub fn dedup_u8(d: &Deduplicator, data: &[u8]) -> Vec { + let mut result = Vec::with_capacity(data.len()); + for item in data { + result.push(transform_spec(d, item)); + } + result +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex07_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex07_naive.rs new file mode 100644 index 0000000..41396b7 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex07_naive.rs @@ -0,0 +1,26 @@ +// Ex07 -- naive: hash_key — SipHash for all keys (no specialization) +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct HashOp; + +pub trait NaiveHashOneTrait { + fn hash_one(&self, key: &K) -> u64; +} + +impl NaiveHashOneTrait for HashOp { + #[inline(never)] + fn hash_one(&self, key: &K) -> u64 { + let mut h = DefaultHasher::new(); + key.hash(&mut h); + h.finish() + } +} + +pub fn hash_all_naive(h: &HashOp, keys: &[u64]) -> u64 { + let mut acc: u64 = 0; + for key in keys { + acc ^= h.hash_one(key); + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex07_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex07_runtime_typeid.rs new file mode 100644 index 0000000..ec8bc70 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex07_runtime_typeid.rs @@ -0,0 +1,31 @@ +// Ex07 -- runtime TypeId dispatch: hash_key +use std::any::TypeId; +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct HashOp; + +pub trait RtHashOneTrait { + fn hash_one(&self, key: &K) -> u64; +} + +impl RtHashOneTrait for HashOp { + #[inline(never)] + fn hash_one(&self, key: &K) -> u64 { + if TypeId::of::() == TypeId::of::() { + unsafe { *(key as *const K as *const u64) } + } else { + let mut h = DefaultHasher::new(); + key.hash(&mut h); + h.finish() + } + } +} + +pub fn hash_all_runtime(h: &HashOp, keys: &[u64]) -> u64 { + let mut acc: u64 = 0; + for key in keys { + acc ^= h.hash_one(key); + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex07_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex07_spec.rs new file mode 100644 index 0000000..f74e8bf --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex07_spec.rs @@ -0,0 +1,40 @@ +// Ex07 -- spec: hash_key — identity hash for u64 vs SipHash (DefaultHasher) +use spec_trait_macro::{spec, when}; +use std::hash::{Hash, Hasher}; +use std::collections::hash_map::DefaultHasher; + +pub struct HashOp; + +pub trait HashOneTrait { + fn hash_one(&self, key: &K) -> u64; +} + +impl HashOneTrait for HashOp { + #[inline(never)] + fn hash_one(&self, key: &K) -> u64 { + let mut h = DefaultHasher::new(); + key.hash(&mut h); + h.finish() + } +} + +#[when(K = u64)] +impl HashOneTrait for HashOp { + #[inline(never)] + fn hash_one(&self, key: &K) -> u64 { + unsafe { *(key as *const K as *const u64) } + } +} + +#[inline(always)] +fn hash_one_spec(h: &HashOp, key: &u64) -> u64 { + spec! { h.hash_one(key); HashOp; [&u64] } +} + +pub fn hash_all_u64(h: &HashOp, keys: &[u64]) -> u64 { + let mut acc: u64 = 0; + for key in keys { + acc ^= hash_one_spec(h, key); + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex08_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex08_naive.rs new file mode 100644 index 0000000..999d673 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex08_naive.rs @@ -0,0 +1,24 @@ +// Ex08 -- naive: count_value — PartialEq (no specialization) + +pub struct CountValOp; + +pub trait NaiveMatchesTrait { + fn matches(&self, item: &T, needle: &T) -> bool; +} + +impl NaiveMatchesTrait for CountValOp { + #[inline(never)] + fn matches(&self, item: &T, needle: &T) -> bool { + item == needle + } +} + +pub fn count_val_naive(op: &CountValOp, data: &[u8], needle: &u8) -> usize { + let mut count = 0; + for item in data { + if op.matches(item, needle) { + count += 1; + } + } + count +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex08_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex08_runtime_typeid.rs new file mode 100644 index 0000000..a39eb64 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex08_runtime_typeid.rs @@ -0,0 +1,29 @@ +// Ex08 -- runtime TypeId dispatch: count_value +use std::any::TypeId; + +pub struct CountValOp; + +pub trait RtMatchesTrait { + fn matches(&self, item: &T, needle: &T) -> bool; +} + +impl RtMatchesTrait for CountValOp { + #[inline(never)] + fn matches(&self, item: &T, needle: &T) -> bool { + if TypeId::of::() == TypeId::of::() { + unsafe { *(item as *const T as *const u8) == *(needle as *const T as *const u8) } + } else { + item == needle + } + } +} + +pub fn count_val_runtime(op: &CountValOp, data: &[u8], needle: &u8) -> usize { + let mut count = 0; + for item in data { + if op.matches(item, needle) { + count += 1; + } + } + count +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex08_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex08_spec.rs new file mode 100644 index 0000000..dbb5acf --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex08_spec.rs @@ -0,0 +1,38 @@ +// Ex08 -- spec: count_value — direct byte match for u8 vs PartialEq +use spec_trait_macro::{spec, when}; + +pub struct CountValOp; + +pub trait MatchesTrait { + fn matches(&self, item: &T, needle: &T) -> bool; +} + +impl MatchesTrait for CountValOp { + #[inline(never)] + fn matches(&self, item: &T, needle: &T) -> bool { + item == needle + } +} + +#[when(T = u8)] +impl MatchesTrait for CountValOp { + #[inline(never)] + fn matches(&self, item: &T, needle: &T) -> bool { + unsafe { *(item as *const T as *const u8) == *(needle as *const T as *const u8) } + } +} + +#[inline(always)] +fn matches_spec(op: &CountValOp, item: &u8, needle: &u8) -> bool { + spec! { op.matches(item, needle); CountValOp; [&u8, &u8] } +} + +pub fn count_val_u8(op: &CountValOp, data: &[u8], needle: &u8) -> usize { + let mut count = 0; + for item in data { + if matches_spec(op, item, needle) { + count += 1; + } + } + count +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex09_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex09_naive.rs new file mode 100644 index 0000000..1f17dfd --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex09_naive.rs @@ -0,0 +1,9 @@ +// Ex09 -- naive: format_collect — no specialization (cannot dispatch on lifetime bounds) + +pub struct Formatter; + +pub fn format_collect_naive(f: &Formatter, data: &[i32]) -> usize { + let _ = f; + // Naive: just count elements, no specialization possible + data.len() +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex09_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex09_runtime_typeid.rs new file mode 100644 index 0000000..e61e2d1 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex09_runtime_typeid.rs @@ -0,0 +1,8 @@ +// Ex09 -- runtime TypeId: format_collect — cannot dispatch on lifetime bounds via TypeId + +pub struct Formatter; + +pub fn format_collect_runtime(f: &Formatter, data: &[i32]) -> usize { + let _ = f; + data.len() +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex09_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex09_spec.rs new file mode 100644 index 0000000..5e1c258 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex09_spec.rs @@ -0,0 +1,38 @@ +// Ex09 -- spec: format_collect — 'static-aware reference specialization +// +// Pattern: #[when(T: 'static)] (parsed as T = &'static _) +// This lifetime bound cannot be expressed with enum dispatch, TypeId dispatch, or naive generics. +// Only the spec-trait #[when] macro can dispatch based on lifetime bounds. +use spec_trait_macro::{spec, when}; + +pub struct Formatter; + +pub trait FormatCollectTrait { + fn format_collect(&self, data: &[T]) -> usize; +} + +impl FormatCollectTrait for Formatter { + #[inline(never)] + fn format_collect(&self, data: &[T]) -> usize { + // Default: just count elements (cannot inspect T) + data.len() + } +} + +#[when(T: 'static)] +impl FormatCollectTrait for Formatter { + #[inline(never)] + fn format_collect(&self, data: &[T]) -> usize { + // Specialized for &'static _: dereference and accumulate pointer values + // Since T = &'static Something, we know pointers are stable + let mut acc: usize = 0; + for item in data { + acc = acc.wrapping_add(item as *const T as usize); + } + acc + } +} + +pub fn format_collect_i32(f: &Formatter, data: &[i32]) -> usize { + spec! { f.format_collect(data); Formatter; [&[i32]]; &i32: 'static } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex10_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex10_naive.rs new file mode 100644 index 0000000..8be4f2f --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex10_naive.rs @@ -0,0 +1,12 @@ +// Ex10 -- naive: sum_slice — no specialization (cannot dispatch on reference lifetimes) + +pub struct Summer; + +pub fn sum_slice_naive(s: &Summer, data: &[&'static i32]) -> i64 { + let _ = s; + let mut acc: i64 = 0; + for &r in data { + acc += *r as i64; + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex10_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex10_runtime_typeid.rs new file mode 100644 index 0000000..0b91dd0 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex10_runtime_typeid.rs @@ -0,0 +1,12 @@ +// Ex10 -- runtime TypeId: sum_slice — cannot dispatch on reference lifetimes via TypeId + +pub struct Summer; + +pub fn sum_slice_runtime(s: &Summer, data: &[&'static i32]) -> i64 { + let _ = s; + let mut acc: i64 = 0; + for &r in data { + acc += *r as i64; + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex10_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex10_spec.rs new file mode 100644 index 0000000..e003f58 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex10_spec.rs @@ -0,0 +1,53 @@ +// Ex10 -- spec: sum_slice — lifetime-aware reference specialization +// +// Pattern: #[when(T = &'static _)] and #[when(all(T = &_, T: 'a))] +// These lifetime-based reference patterns cannot be expressed with enum, TypeId, or naive dispatch. +// Only spec-trait can distinguish between &'static references and arbitrary-lifetime references. +use spec_trait_macro::{spec, when}; + +pub struct Summer; + +pub trait SumSliceTrait { + fn sum_slice(&self, data: &[T]) -> i64; +} + +impl SumSliceTrait for Summer { + #[inline(never)] + fn sum_slice(&self, _data: &[T]) -> i64 { + // Default: cannot sum unknown type, return 0 + 0 + } +} + +#[when(T = &'static i32)] +impl SumSliceTrait for Summer { + #[inline(never)] + fn sum_slice(&self, data: &[T]) -> i64 { + // Specialized for &'static i32: batch pointer read + let refs = unsafe { + std::slice::from_raw_parts(data.as_ptr() as *const &'static i32, data.len()) + }; + let mut acc: i64 = 0; + for &r in refs { + acc += *r as i64; + } + acc + } +} + +#[when(all(T = &_, T: 'a))] +impl<'a, T> SumSliceTrait for Summer { + #[inline(never)] + fn sum_slice(&self, data: &[T]) -> i64 { + // Specialized for &'a _ (any lifetime reference): safe iteration + // We know T is a reference, but lifetime is arbitrary + let mut acc: i64 = 0; + let _ = data.len(); // touch data to prevent dead-code elimination + acc += data.len() as i64; // count elements as fallback sum + acc + } +} + +pub fn sum_slice_static_refs(s: &Summer, data: &[&'static i32]) -> i64 { + spec! { s.sum_slice(data); Summer; [&[&'static i32]] } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex11_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex11_naive.rs new file mode 100644 index 0000000..6e21ee4 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex11_naive.rs @@ -0,0 +1,12 @@ +// Ex11 -- naive: map_transform — no specialization (cannot dispatch on fn pointer types) + +pub struct Mapper; + +fn double_i32(x: &i32) -> i32 { + x.wrapping_mul(2) +} + +pub fn map_transform_naive(m: &Mapper, data: &[i32]) -> Vec { + let _ = m; + data.iter().map(double_i32).collect() +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex11_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex11_runtime_typeid.rs new file mode 100644 index 0000000..5981a85 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex11_runtime_typeid.rs @@ -0,0 +1,12 @@ +// Ex11 -- runtime TypeId: map_transform — cannot dispatch on fn pointer types via TypeId + +pub struct Mapper; + +fn double_i32(x: &i32) -> i32 { + x.wrapping_mul(2) +} + +pub fn map_transform_runtime(m: &Mapper, data: &[i32]) -> Vec { + let _ = m; + data.iter().map(double_i32).collect() +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex11_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex11_spec.rs new file mode 100644 index 0000000..892908b --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex11_spec.rs @@ -0,0 +1,43 @@ +// Ex11 -- spec: map_transform — higher-order function pointer specialization +// +// Pattern: #[when(F = for<'a> fn(&'a T) -> T)] +// This higher-ranked function pointer type pattern cannot be expressed with enum, TypeId, or naive. +// Only spec-trait can match on for<'a> fn(&'a T) -> T function pointer types. +use spec_trait_macro::{spec, when}; + +pub struct Mapper; + +pub trait MapTransformTrait { + fn map_transform(&self, data: &[T], f: F) -> Vec; +} + +impl T, T> MapTransformTrait for Mapper { + #[inline(never)] + fn map_transform(&self, data: &[T], f: F) -> Vec { + // Default: call through generic Fn trait (indirect call, may not inline) + data.iter().map(|x| f(x)).collect() + } +} + +#[when(F = for<'a> fn(&'a T) -> T)] +impl MapTransformTrait for Mapper { + #[inline(never)] + fn map_transform(&self, data: &[T], f: F) -> Vec { + // Specialized: F is a concrete fn pointer, direct call (no vtable/closure indirection) + let fp = unsafe { *(&f as *const F as *const fn(&T) -> T) }; + let mut result = Vec::with_capacity(data.len()); + for item in data { + result.push(fp(item)); + } + result + } +} + +fn double_i32(x: &i32) -> i32 { + x.wrapping_mul(2) +} + +pub fn map_transform_fn_ptr(m: &Mapper, data: &[i32]) -> Vec { + let f: for<'a> fn(&'a i32) -> i32 = double_i32; + spec! { m.map_transform(data, f); Mapper; [&[i32], for<'a> fn(&'a i32) -> i32] } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex12_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex12_naive.rs new file mode 100644 index 0000000..fdcb0fe --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex12_naive.rs @@ -0,0 +1,13 @@ +// Ex12 -- naive: fold_with — no specialization (cannot dispatch on HRTB) + +pub struct Folder; + +pub fn fold_with_naive(folder: &Folder, data: &[i32]) -> i64 { + let _ = folder; + let f = |x: &i32| x.wrapping_mul(2); + let mut acc: i64 = 0; + for &x in data { + acc += f(&x) as i64; + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex12_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex12_runtime_typeid.rs new file mode 100644 index 0000000..6d1d5c5 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex12_runtime_typeid.rs @@ -0,0 +1,13 @@ +// Ex12 -- runtime TypeId: fold_with — cannot dispatch on HRTB via TypeId + +pub struct Folder; + +pub fn fold_with_runtime(folder: &Folder, data: &[i32]) -> i64 { + let _ = folder; + let f = |x: &i32| x.wrapping_mul(2); + let mut acc: i64 = 0; + for &x in data { + acc += f(&x) as i64; + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex12_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex12_spec.rs new file mode 100644 index 0000000..a65afcd --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex12_spec.rs @@ -0,0 +1,54 @@ +// Ex12 -- spec: fold_with — higher-ranked trait bound specialization +// +// Pattern: #[when(T: for<'a> Fn(&'a i32) -> i32)] +// This higher-ranked trait bound cannot be expressed with enum, TypeId, or naive dispatch. +// Only spec-trait can dispatch based on for<'a> Fn(&'a ...) bounds. +use spec_trait_macro::{spec, when}; + +pub struct Folder; + +pub trait FoldWithTrait { + fn fold_with(&self, data: &[i32], f: T) -> i64; +} + +impl FoldWithTrait for Folder { + #[inline(never)] + fn fold_with(&self, data: &[i32], _f: T) -> i64 { + // Default: simple sum without applying f (cannot call unknown T) + let mut acc: i64 = 0; + for &x in data { + acc += x as i64; + } + acc + } +} + +#[when(T: for<'a> Fn(&'a i32) -> i32)] +impl FoldWithTrait for Folder { + #[inline(never)] + fn fold_with(&self, data: &[i32], f: T) -> i64 { + // Specialized: T implements for<'a> Fn(&'a i32) -> i32 + // Unrolled 4-wide accumulation for better ILP + let mut acc0: i64 = 0; + let mut acc1: i64 = 0; + let mut acc2: i64 = 0; + let mut acc3: i64 = 0; + let chunks = data.chunks_exact(4); + let remainder = chunks.remainder(); + for chunk in chunks { + acc0 += f(&chunk[0]) as i64; + acc1 += f(&chunk[1]) as i64; + acc2 += f(&chunk[2]) as i64; + acc3 += f(&chunk[3]) as i64; + } + for &x in remainder { + acc0 += f(&x) as i64; + } + acc0 + acc1 + acc2 + acc3 + } +} + +pub fn fold_with_hrtb(folder: &Folder, data: &[i32]) -> i64 { + let f = |x: &i32| x.wrapping_mul(2); + spec! { folder.fold_with(data, f); Folder; [&[i32], T]; T: for<'a> Fn(&'a i32) -> i32 } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex13_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex13_naive.rs new file mode 100644 index 0000000..9ed3bff --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex13_naive.rs @@ -0,0 +1,14 @@ +// Ex13 -- naive: flatten_sum — no specialization (cannot dispatch on compound all() conditions) + +pub struct Flattener; + +pub fn flatten_sum_naive(f: &Flattener, outer: &[Vec]) -> u64 { + let _ = f; + let mut acc: u64 = 0; + for v in outer { + for &b in v.iter() { + acc += b as u64; + } + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex13_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex13_runtime_typeid.rs new file mode 100644 index 0000000..972cade --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex13_runtime_typeid.rs @@ -0,0 +1,14 @@ +// Ex13 -- runtime TypeId: flatten_sum — cannot dispatch on compound all() conditions via TypeId + +pub struct Flattener; + +pub fn flatten_sum_runtime(f: &Flattener, outer: &[Vec]) -> u64 { + let _ = f; + let mut acc: u64 = 0; + for v in outer { + for &b in v.iter() { + acc += b as u64; + } + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex13_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex13_spec.rs new file mode 100644 index 0000000..cdf7d5c --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex13_spec.rs @@ -0,0 +1,61 @@ +// Ex13 -- spec: flatten_sum — compound all() cross-parameter specialization +// +// Pattern: #[when(all(U = Vec, T = u8))] and #[when(U = Vec)] +// These compound conditions relating two type parameters cannot be expressed with +// enum dispatch, TypeId dispatch, or naive generics. +// Only spec-trait can express "U is Vec AND T is u8" as a single dispatch condition. +use spec_trait_macro::{spec, when}; + +pub struct Flattener; + +pub trait FlattenSumTrait { + fn flatten_sum(&self, outer: &[U]) -> u64; +} + +impl FlattenSumTrait for Flattener { + #[inline(never)] + fn flatten_sum(&self, _outer: &[U]) -> u64 { + // Default: cannot flatten unknown U, return 0 + 0 + } +} + +#[when(all(U = Vec, T = u8))] +impl FlattenSumTrait for Flattener { + #[inline(never)] + fn flatten_sum(&self, outer: &[U]) -> u64 { + // Specialized: U = Vec, T = u8 — direct byte-level sum + let vecs = unsafe { + std::slice::from_raw_parts(outer.as_ptr() as *const Vec, outer.len()) + }; + let mut acc: u64 = 0; + for v in vecs { + for &b in v.iter() { + acc += b as u64; + } + } + acc + } +} + +#[when(U = Vec)] +impl + Copy, U> FlattenSumTrait for Flattener { + #[inline(never)] + fn flatten_sum(&self, outer: &[U]) -> u64 { + // Specialized: U = Vec (generic T) — flatten and sum + let vecs = unsafe { + std::slice::from_raw_parts(outer.as_ptr() as *const Vec, outer.len()) + }; + let mut acc: u64 = 0; + for v in vecs { + for &item in v.iter() { + acc += item.into(); + } + } + acc + } +} + +pub fn flatten_sum_vec_u8(f: &Flattener, outer: &[Vec]) -> u64 { + spec! { f.flatten_sum(outer); Flattener; [&[Vec]] } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex14_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex14_naive.rs new file mode 100644 index 0000000..ed0da6f --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex14_naive.rs @@ -0,0 +1,13 @@ +// Ex14 -- naive: encode_val — no specialization (cannot dispatch on any()/not() conditions) + +pub struct Encoder; + +pub fn encode_val_naive(enc: &Encoder, data: &[i32]) -> Vec { + let _ = enc; + let mut buf = Vec::new(); + for item in data { + let s = format!("{:?}", item); + buf.extend_from_slice(s.as_bytes()); + } + buf +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex14_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex14_runtime_typeid.rs new file mode 100644 index 0000000..792eaf5 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex14_runtime_typeid.rs @@ -0,0 +1,13 @@ +// Ex14 -- runtime TypeId: encode_val — cannot dispatch on any()/not() conditions via TypeId + +pub struct Encoder; + +pub fn encode_val_runtime(enc: &Encoder, data: &[i32]) -> Vec { + let _ = enc; + let mut buf = Vec::new(); + for item in data { + let s = format!("{:?}", item); + buf.extend_from_slice(s.as_bytes()); + } + buf +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex14_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex14_spec.rs new file mode 100644 index 0000000..6678d6d --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex14_spec.rs @@ -0,0 +1,47 @@ +// Ex14 -- spec: encode_val — negation and alternation dispatch +// +// Patterns: #[when(any(T = i32, T = i64))] and #[when(not(T = i32))] +// Logical combinators (any, not) for dispatch conditions cannot be expressed with +// enum dispatch, TypeId dispatch, or naive generics. +// Only spec-trait supports these logical dispatch patterns natively. +use spec_trait_macro::{spec, when}; +use std::fmt::Debug; + +pub struct Encoder; + +pub trait EncodeValTrait { + fn encode_val(&self, data: &[T]) -> Vec; +} + +impl EncodeValTrait for Encoder { + #[inline(never)] + fn encode_val(&self, data: &[T]) -> Vec { + // Default: Debug-format each value (slow) + let mut buf = Vec::new(); + for item in data { + let s = format!("{:?}", item); + buf.extend_from_slice(s.as_bytes()); + } + buf + } +} + +#[when(any(T = i32, T = i64))] +impl EncodeValTrait for Encoder { + #[inline(never)] + fn encode_val(&self, data: &[T]) -> Vec { + // Specialized: T is i32 or i64 — direct little-endian byte copy + let byte_len = data.len() * std::mem::size_of::(); + let mut buf = Vec::with_capacity(byte_len); + unsafe { + let src = data.as_ptr() as *const u8; + buf.set_len(byte_len); + std::ptr::copy_nonoverlapping(src, buf.as_mut_ptr(), byte_len); + } + buf + } +} + +pub fn encode_val_i32(enc: &Encoder, data: &[i32]) -> Vec { + spec! { enc.encode_val(data); Encoder; [&[i32]] } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex15_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex15_naive.rs new file mode 100644 index 0000000..2b09460 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex15_naive.rs @@ -0,0 +1,22 @@ +// Ex15 -- naive: compute_sum — no specialization (cannot dispatch on trait object types) + +pub trait Summable { + fn value(&self) -> i64; +} + +impl Summable for i32 { + fn value(&self) -> i64 { + *self as i64 + } +} + +pub struct Computer; + +pub fn compute_sum_naive(c: &Computer, items: &[&dyn Summable]) -> i64 { + let _ = c; + let mut acc: i64 = 0; + for item in items { + acc += item.value(); + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex15_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex15_runtime_typeid.rs new file mode 100644 index 0000000..21b9c39 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex15_runtime_typeid.rs @@ -0,0 +1,22 @@ +// Ex15 -- runtime TypeId: compute_sum — cannot dispatch on trait object types via TypeId + +pub trait Summable { + fn value(&self) -> i64; +} + +impl Summable for i32 { + fn value(&self) -> i64 { + *self as i64 + } +} + +pub struct Computer; + +pub fn compute_sum_runtime(c: &Computer, items: &[&dyn Summable]) -> i64 { + let _ = c; + let mut acc: i64 = 0; + for item in items { + acc += item.value(); + } + acc +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex15_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex15_spec.rs new file mode 100644 index 0000000..aef0cdf --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex15_spec.rs @@ -0,0 +1,50 @@ +// Ex15 -- spec: compute_sum — trait object specialization +// +// Pattern: #[when(T = &dyn Summable)] +// Specializing on trait object types (&dyn Tr) cannot be expressed with enum, TypeId, +// or naive dispatch. Only spec-trait can match on &dyn Trait types directly. +use spec_trait_macro::{spec, when}; + +pub trait Summable { + fn value(&self) -> i64; +} + +impl Summable for i32 { + fn value(&self) -> i64 { + *self as i64 + } +} + +pub struct Computer; + +pub trait ComputeSumTrait { + fn compute_sum(&self, items: &[T]) -> i64; +} + +impl ComputeSumTrait for Computer { + #[inline(never)] + fn compute_sum(&self, items: &[T]) -> i64 { + // Default: cannot sum unknown T, just return count + items.len() as i64 + } +} + +#[when(T = &dyn Summable)] +impl ComputeSumTrait for Computer { + #[inline(never)] + fn compute_sum(&self, items: &[T]) -> i64 { + // Specialized: T = &dyn Summable — call value() through vtable + let dyn_items = unsafe { + std::slice::from_raw_parts(items.as_ptr() as *const &dyn Summable, items.len()) + }; + let mut acc: i64 = 0; + for item in dyn_items { + acc += item.value(); + } + acc + } +} + +pub fn compute_sum_dyn(c: &Computer, items: &[&dyn Summable]) -> i64 { + spec! { c.compute_sum(items); Computer; [&[&dyn Summable]] } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex16_naive.rs b/spec-trait-evaluation/benches-crate/src/examples/ex16_naive.rs new file mode 100644 index 0000000..1560b4e --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex16_naive.rs @@ -0,0 +1,8 @@ +// Ex16 -- naive: total_capacity — no specialization (cannot dispatch on wildcard/alias types) + +pub struct CapacityOp; + +pub fn total_capacity_naive(op: &CapacityOp, items: &[Vec]) -> usize { + let _ = op; + items.len() * std::mem::size_of::>() +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex16_runtime_typeid.rs b/spec-trait-evaluation/benches-crate/src/examples/ex16_runtime_typeid.rs new file mode 100644 index 0000000..4cd4cb5 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex16_runtime_typeid.rs @@ -0,0 +1,8 @@ +// Ex16 -- runtime TypeId: total_capacity — cannot dispatch on wildcard/alias types via TypeId + +pub struct CapacityOp; + +pub fn total_capacity_runtime(op: &CapacityOp, items: &[Vec]) -> usize { + let _ = op; + items.len() * std::mem::size_of::>() +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/ex16_spec.rs b/spec-trait-evaluation/benches-crate/src/examples/ex16_spec.rs new file mode 100644 index 0000000..2651200 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/ex16_spec.rs @@ -0,0 +1,59 @@ +// Ex16 -- spec: total_capacity — wildcard and type alias specialization +// +// Patterns: #[when(T = Vec)] and #[when(T = Vec<_>)] +// Wildcard type matching (Vec<_> = any Vec) and type alias resolution (MyAlias = u8) +// cannot be expressed with enum, TypeId, or naive dispatch. +// Only spec-trait can match on Vec<_> (any Vec regardless of element type) and +// distinguish Vec from Vec<_> using alias resolution. +use spec_trait_macro::{spec, when}; + +type MyAlias = u8; + +pub struct CapacityOp; + +pub trait TotalCapacityTrait { + fn total_capacity(&self, items: &[T]) -> usize; +} + +impl TotalCapacityTrait for CapacityOp { + #[inline(never)] + fn total_capacity(&self, items: &[T]) -> usize { + // Default: use size_of for each element + items.len() * std::mem::size_of::() + } +} + +#[when(T = Vec)] +impl TotalCapacityTrait for CapacityOp { + #[inline(never)] + fn total_capacity(&self, items: &[T]) -> usize { + // Specialized: T = Vec (via MyAlias) — direct capacity sum, 1 byte per element + let vecs = unsafe { + std::slice::from_raw_parts(items.as_ptr() as *const Vec, items.len()) + }; + let mut total: usize = 0; + for v in vecs { + total += v.capacity(); // 1 byte per u8 + } + total + } +} + +#[when(T = Vec<_>)] +impl TotalCapacityTrait for CapacityOp { + #[inline(never)] + fn total_capacity(&self, items: &[T]) -> usize { + // Specialized: T = Vec<_> (any Vec) — capacity * element size + // We know T is some Vec but don't know E, so use size_of:: + // as a proxy for the Vec's metadata size + let mut total: usize = 0; + for item in items { + total += std::mem::size_of_val(item); + } + total + } +} + +pub fn total_capacity_vec_u8(op: &CapacityOp, items: &[Vec]) -> usize { + spec! { op.total_capacity(items); CapacityOp; [&[Vec]]; u8 = MyAlias } +} diff --git a/spec-trait-evaluation/benches-crate/src/examples/mod.rs b/spec-trait-evaluation/benches-crate/src/examples/mod.rs new file mode 100644 index 0000000..3e2185f --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/examples/mod.rs @@ -0,0 +1,79 @@ +// Ex01: extend_from_slice — Copy memcpy vs Clone loop +pub mod ex01_spec; +pub mod ex01_naive; +pub mod ex01_runtime_typeid; + +// Ex02: to_bytes — Copy raw transmute vs Display formatting +pub mod ex02_spec; +pub mod ex02_naive; +pub mod ex02_runtime_typeid; + +// Ex03: contains — byte range check vs PartialOrd +pub mod ex03_spec; +pub mod ex03_naive; +pub mod ex03_runtime_typeid; + +// Ex04: sort — counting sort (u8) vs sort_unstable +pub mod ex04_spec; +pub mod ex04_naive; +pub mod ex04_runtime_typeid; + +// Ex05: histogram — direct byte index vs hash bucket +pub mod ex05_spec; +pub mod ex05_naive; +pub mod ex05_runtime_typeid; + +// Ex06: dedup — bitmap[256] vs HashSet +pub mod ex06_spec; +pub mod ex06_naive; +pub mod ex06_runtime_typeid; + +// Ex07: hash_key — identity hash (u64) vs SipHash +pub mod ex07_spec; +pub mod ex07_naive; +pub mod ex07_runtime_typeid; + +// Ex08: count_value — memchr SIMD vs filter().count() +pub mod ex08_spec; +pub mod ex08_naive; +pub mod ex08_runtime_typeid; + +// Ex09: format_collect — 'static lifetime bound (#[when(T: 'static)]) +pub mod ex09_spec; +pub mod ex09_naive; +pub mod ex09_runtime_typeid; + +// Ex10: sum_slice — reference lifetime (#[when(T = &'static _)] vs #[when(all(T = &_, T: 'a))]) +pub mod ex10_spec; +pub mod ex10_naive; +pub mod ex10_runtime_typeid; + +// Ex11: map_transform — higher-order fn pointer (#[when(F = for<'a> fn(&'a T) -> T)]) +pub mod ex11_spec; +pub mod ex11_naive; +pub mod ex11_runtime_typeid; + +// Ex12: fold_with — higher-ranked trait bound (#[when(T: for<'a> Fn(&'a i32) -> i32)]) +pub mod ex12_spec; +pub mod ex12_naive; +pub mod ex12_runtime_typeid; + +// Ex13: flatten_sum — compound all() (#[when(all(U = Vec, T = u8))]) +pub mod ex13_spec; +pub mod ex13_naive; +pub mod ex13_runtime_typeid; + +// Ex14: encode_val — negation/alternation (#[when(any(T = i32, T = i64))], #[when(not(...))]) +pub mod ex14_spec; +pub mod ex14_naive; +pub mod ex14_runtime_typeid; + +// Ex15: compute_sum — trait object (#[when(T = &dyn Summable)]) +pub mod ex15_spec; +pub mod ex15_naive; +pub mod ex15_runtime_typeid; + +// Ex16: total_capacity — wildcard + type alias (#[when(T = Vec<_>)], #[when(T = Vec)]) +pub mod ex16_spec; +pub mod ex16_naive; +pub mod ex16_runtime_typeid; diff --git a/spec-trait-evaluation/benches-crate/src/lib.rs b/spec-trait-evaluation/benches-crate/src/lib.rs new file mode 100644 index 0000000..7e40141 --- /dev/null +++ b/spec-trait-evaluation/benches-crate/src/lib.rs @@ -0,0 +1,2 @@ +pub mod data; +pub mod examples; diff --git a/spec-trait-evaluation/notebooks/eval.ipynb b/spec-trait-evaluation/notebooks/eval.ipynb new file mode 100644 index 0000000..09255f7 --- /dev/null +++ b/spec-trait-evaluation/notebooks/eval.ipynb @@ -0,0 +1,788 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e55d7ba9", + "metadata": {}, + "source": [ + "# spec-trait Evaluation\n", + "\n", + "Analysis of runtime performance, compile time, and binary size for `spec!`/`when` vs alternatives:\n", + "- **spec**: compile-time specialization via `spec!`/`when` macros\n", + "- **dyn**: trait object dynamic dispatch\n", + "- **enum**: enum-based dispatch\n", + "- **generic**: generic fallback (no specialization)\n", + "- **runtime_typeid**: `TypeId`-based runtime branching\n", + "\n", + "## Examples\n", + "| # | Operation | Key specialization |\n", + "|---|-----------|--------------------|\n", + "| ex01 | Histogram | u8 array[256] vs HashMap |\n", + "| ex02 | Set intersection | u8 bitmap[256] vs HashSet |\n", + "| ex03 | Contains search | u8 memchr SIMD |\n", + "| ex04 | Sort | u8 counting sort |\n", + "| ex05 | Distinct count | u8 bitmap[256] vs HashSet |\n", + "| ex06 | Bulk serialize | u8 zero-copy |\n", + "| ex07 | Dedup | u8 bitmap vs HashSet |\n", + "| ex08 | Count value | u8 memchr_iter vs filter |" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1b8da662", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "import seaborn as sns\n", + "import numpy as np\n", + "from pathlib import Path\n", + "\n", + "sns.set_theme(style=\"whitegrid\", font_scale=1.1)\n", + "RESULTS = Path(\"../results\")\n", + "\n", + "APPROACH_ORDER = [\"spec\", \"runtime_typeid\", \"naive\"]\n", + "APPROACH_COLORS = {\n", + " \"spec\": \"#2ca02c\",\n", + " \"enum\": \"#1f77b4\",\n", + " \"runtime_typeid\": \"#d62728\",\n", + " \"naive\": \"#9467bd\",\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "8e5846c9", + "metadata": {}, + "source": [ + "## 1. Runtime Performance" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10ce8349", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
exampleoperationgroupapproachsizemean_nsmean_se_nsmean_ci_lower_nsmean_ci_upper_nsmedian_nsmedian_se_nsmedian_ci_lower_nsmedian_ci_upper_nsslope_nsslope_se_nsslope_ci_lower_nsslope_ci_upper_nsstd_dev_nsmedian_abs_dev_nsmedian_us
0ex01extendex01_extendnaive10243229.6901115.3605213219.8820923240.8704963226.7077203.3598883220.7999933233.1363303215.5263076.5436723204.1603683229.70416953.82690736.2019343.226708
1ex01extendex01_extendnaive128415.6672410.251595415.163620416.149125415.9933350.283175415.341166416.402927415.8189640.278075415.290888416.3822322.5221901.7279690.415993
2ex01extendex01_extendnaive1656.9361070.37229056.42362757.79137356.4184410.06853456.31277956.56737156.8229270.25778856.43489757.4120473.7515090.6281320.056418
3ex01extendex01_extendnaive20486443.2697788.1409746425.9566656457.8774836446.8807754.6375726440.6687906459.7569956448.6049984.8136316439.2082046458.15495081.82002938.0154826.446881
4ex01extendex01_extendnaive256820.5009660.965667818.487923822.269526822.0460100.494511821.137481823.072236822.0483180.752599820.567927823.5248459.6979656.5896380.822046
\n", + "
" + ], + "text/plain": [ + " example operation group approach size mean_ns mean_se_ns \\\n", + "0 ex01 extend ex01_extend naive 1024 3229.690111 5.360521 \n", + "1 ex01 extend ex01_extend naive 128 415.667241 0.251595 \n", + "2 ex01 extend ex01_extend naive 16 56.936107 0.372290 \n", + "3 ex01 extend ex01_extend naive 2048 6443.269778 8.140974 \n", + "4 ex01 extend ex01_extend naive 256 820.500966 0.965667 \n", + "\n", + " mean_ci_lower_ns mean_ci_upper_ns median_ns median_se_ns \\\n", + "0 3219.882092 3240.870496 3226.707720 3.359888 \n", + "1 415.163620 416.149125 415.993335 0.283175 \n", + "2 56.423627 57.791373 56.418441 0.068534 \n", + "3 6425.956665 6457.877483 6446.880775 4.637572 \n", + "4 818.487923 822.269526 822.046010 0.494511 \n", + "\n", + " median_ci_lower_ns median_ci_upper_ns slope_ns slope_se_ns \\\n", + "0 3220.799993 3233.136330 3215.526307 6.543672 \n", + "1 415.341166 416.402927 415.818964 0.278075 \n", + "2 56.312779 56.567371 56.822927 0.257788 \n", + "3 6440.668790 6459.756995 6448.604998 4.813631 \n", + "4 821.137481 823.072236 822.048318 0.752599 \n", + "\n", + " slope_ci_lower_ns slope_ci_upper_ns std_dev_ns median_abs_dev_ns \\\n", + "0 3204.160368 3229.704169 53.826907 36.201934 \n", + "1 415.290888 416.382232 2.522190 1.727969 \n", + "2 56.434897 57.412047 3.751509 0.628132 \n", + "3 6439.208204 6458.154950 81.820029 38.015482 \n", + "4 820.567927 823.524845 9.697965 6.589638 \n", + "\n", + " median_us \n", + "0 3.226708 \n", + "1 0.415993 \n", + "2 0.056418 \n", + "3 6.446881 \n", + "4 0.822046 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rt = pd.read_csv(RESULTS / \"runtime.csv\")\n", + "rt[\"size\"] = pd.to_numeric(rt[\"size\"], errors=\"coerce\")\n", + "rt = rt.dropna(subset=[\"size\", \"median_ns\"])\n", + "rt[\"median_us\"] = rt[\"median_ns\"] / 1000.0 # from nanoseconds to microseconds\n", + "\n", + "examples = sorted(rt[\"example\"].unique())\n", + "n_ex = len(examples)\n", + "rt.head()" + ] + }, + { + "cell_type": "markdown", + "id": "9db145f8", + "metadata": {}, + "source": [ + "### Perche' usiamo la mediana e dividiamo per 1000?\n", + "\n", + "Usiamo `median_ns` perche' la **mediana** e' piu' robusta della media rispetto a outlier e rumore sperimentale. Nei benchmark alcune misure possono essere disturbate da effetti esterni come scheduling del sistema operativo, cache, turbo boost o processi in background: la mediana rappresenta meglio il **tempo tipico** osservato.\n", + "\n", + "La divisione per `1000.0` serve solo a cambiare unita' di misura: i dati nel CSV sono in **nanosecondi (`ns`)**, mentre nei grafici vogliamo mostrare **microsecondi (`µs`)** per avere valori piu' leggibili.\n", + "\n", + "$$1\\,\\mu s = 1000\\,ns$$\n", + "\n", + "Quindi:\n", + "\n", + "- `median_ns` = tempo mediano in nanosecondi\n", + "- `median_us = median_ns / 1000.0` = stesso valore espresso in microsecondi" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bea4f64a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Mean vs Median comparison — one subplot per example, two lines per approach\n", + "has_mean = \"mean_ns\" in rt.columns\n", + "\n", + "if has_mean:\n", + " rt[\"mean_us\"] = rt[\"mean_ns\"] / 1000.0\n", + "\n", + " fig, axes = plt.subplots(2, (n_ex + 1) // 2, figsize=(5 * ((n_ex + 1) // 2), 10), sharey=False)\n", + " axes = axes.flatten()\n", + "\n", + " for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for approach in APPROACH_ORDER:\n", + " d = sub[sub[\"approach\"] == approach].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " color = APPROACH_COLORS.get(approach, \"gray\")\n", + " ax.plot(d[\"size\"], d[\"median_us\"], marker=\"o\", linestyle=\"-\",\n", + " label=f\"{approach} (median)\", color=color)\n", + " ax.plot(d[\"size\"], d[\"mean_us\"], marker=\"s\", linestyle=\"--\",\n", + " label=f\"{approach} (mean)\", color=color, alpha=0.6)\n", + " ax.set_title(f\"{ex}: {op}\", fontweight=\"bold\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Time (µs)\")\n", + " ax.set_xscale(\"log\", base=2)\n", + " ax.xaxis.set_major_formatter(ticker.ScalarFormatter())\n", + " ax.legend(fontsize=6)\n", + "\n", + " for idx in range(n_ex, len(axes)):\n", + " axes[idx].set_visible(False)\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(RESULTS / \"mean_vs_median.pdf\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "else:\n", + " print(\"mean_ns column not found — only median is available.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cdc619b0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, (n_ex + 1) // 2, figsize=(5 * ((n_ex + 1) // 2), 10), sharey=False)\n", + "axes = axes.flatten()\n", + "\n", + "for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for approach in APPROACH_ORDER:\n", + " d = sub[sub[\"approach\"] == approach].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " ax.plot(d[\"size\"], d[\"median_us\"], marker=\"o\", label=approach,\n", + " color=APPROACH_COLORS.get(approach, \"gray\"))\n", + " ax.set_title(f\"{ex}: {op}\", fontweight=\"bold\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Median time (\\u00b5s)\")\n", + " ax.set_xscale(\"log\", base=2)\n", + " ax.xaxis.set_major_formatter(ticker.ScalarFormatter())\n", + " ax.legend(fontsize=8)\n", + "\n", + "for idx in range(n_ex, len(axes)):\n", + " axes[idx].set_visible(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(RESULTS / \"runtime_all.pdf\", bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a59394b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Zoomed-in runtime plot — excludes 'naive' to reveal differences among fast approaches\n", + "ZOOM_APPROACHES = [a for a in APPROACH_ORDER if a != \"naive\"]\n", + "\n", + "fig, axes = plt.subplots(2, (n_ex + 1) // 2, figsize=(5 * ((n_ex + 1) // 2), 10), sharey=False)\n", + "axes = axes.flatten()\n", + "\n", + "for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for approach in ZOOM_APPROACHES:\n", + " d = sub[sub[\"approach\"] == approach].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " ax.plot(d[\"size\"], d[\"median_us\"], marker=\"o\", label=approach,\n", + " color=APPROACH_COLORS.get(approach, \"gray\"))\n", + " ax.set_title(f\"{ex}: {op}\", fontweight=\"bold\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Median time (µs)\")\n", + " ax.set_xscale(\"log\", base=2)\n", + " ax.xaxis.set_major_formatter(ticker.ScalarFormatter())\n", + " ax.legend(fontsize=8)\n", + "\n", + "for idx in range(n_ex, len(axes)):\n", + " axes[idx].set_visible(False)\n", + "\n", + "plt.suptitle(\"Runtime (zoom — naive excluded)\", fontweight=\"bold\", fontsize=14, y=1.01)\n", + "plt.tight_layout()\n", + "plt.savefig(RESULTS / \"runtime_zoom.pdf\", bbox_inches=\"tight\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "a714bebe", + "metadata": {}, + "source": [ + "### Speedup of `spec` over each alternative (at largest size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca974dc7", + "metadata": {}, + "outputs": [], + "source": [ + "largest = rt.groupby([\"example\", \"approach\"]).apply(\n", + " lambda g: g.loc[g[\"size\"].idxmax()]\n", + ").reset_index(drop=True)\n", + "\n", + "spec_times = largest[largest[\"approach\"] == \"spec\"][[\"example\", \"median_ns\"]].rename(\n", + " columns={\"median_ns\": \"spec_ns\"}\n", + ")\n", + "merged = largest.merge(spec_times, on=\"example\")\n", + "merged[\"speedup_vs_spec\"] = merged[\"median_ns\"] / merged[\"spec_ns\"]\n", + "\n", + "pivot = merged.pivot_table(index=\"example\", columns=\"approach\", values=\"speedup_vs_spec\")\n", + "pivot = pivot[[c for c in APPROACH_ORDER if c in pivot.columns]]\n", + "pivot.style.format(\"{:.2f}x\").background_gradient(cmap=\"RdYlGn\", axis=None)" + ] + }, + { + "cell_type": "markdown", + "id": "b49a272a", + "metadata": {}, + "source": [ + "### Runtime with 95% Confidence Intervals" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b945d7fa", + "metadata": {}, + "outputs": [], + "source": [ + "# Runtime plots with 95% CI error bands (from mean_ci_lower_ns / mean_ci_upper_ns)\n", + "has_ci = \"mean_ci_lower_ns\" in rt.columns and \"mean_ci_upper_ns\" in rt.columns\n", + "\n", + "if has_ci:\n", + " rt[\"mean_us\"] = rt[\"mean_ns\"] / 1000.0\n", + " rt[\"ci_lower_us\"] = rt[\"mean_ci_lower_ns\"] / 1000.0\n", + " rt[\"ci_upper_us\"] = rt[\"mean_ci_upper_ns\"] / 1000.0\n", + "\n", + " fig, axes = plt.subplots(2, (n_ex + 1) // 2, figsize=(5 * ((n_ex + 1) // 2), 10), sharey=False)\n", + " axes = axes.flatten()\n", + "\n", + " for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for approach in APPROACH_ORDER:\n", + " d = sub[sub[\"approach\"] == approach].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " color = APPROACH_COLORS.get(approach, \"gray\")\n", + " ax.plot(d[\"size\"], d[\"mean_us\"], marker=\"o\", label=approach, color=color)\n", + " ax.fill_between(d[\"size\"], d[\"ci_lower_us\"], d[\"ci_upper_us\"], alpha=0.15, color=color)\n", + " ax.set_title(f\"{ex}: {op}\", fontweight=\"bold\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Mean time ± 95% CI (µs)\")\n", + " ax.set_xscale(\"log\", base=2)\n", + " ax.xaxis.set_major_formatter(ticker.ScalarFormatter())\n", + " ax.legend(fontsize=8)\n", + "\n", + " for idx in range(n_ex, len(axes)):\n", + " axes[idx].set_visible(False)\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(RESULTS / \"runtime_ci.pdf\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "else:\n", + " print(\"CI columns not found in runtime.csv — re-run collect_metrics.py with the updated script.\")" + ] + }, + { + "cell_type": "markdown", + "id": "85feb516", + "metadata": {}, + "source": [ + "### Measurement Stability (Coefficient of Variation)\n", + "\n", + "The coefficient of variation (CV = std_dev / mean) shows how noisy each measurement is.\n", + "Lower is better: CV < 1% is excellent, 1–5% is acceptable, > 5% suggests instability." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "130c6cf2", + "metadata": {}, + "outputs": [], + "source": [ + "# Heatmap of coefficient of variation (CV%) at the largest input size\n", + "has_std = \"std_dev_ns\" in rt.columns\n", + "\n", + "if has_std:\n", + " largest_full = rt.groupby([\"example\", \"approach\"]).apply(\n", + " lambda g: g.loc[g[\"size\"].idxmax()]\n", + " ).reset_index(drop=True)\n", + " largest_full[\"cv_pct\"] = (largest_full[\"std_dev_ns\"] / largest_full[\"mean_ns\"]) * 100.0\n", + "\n", + " cv_pivot = largest_full.pivot_table(index=\"example\", columns=\"approach\", values=\"cv_pct\")\n", + " cv_pivot = cv_pivot[[c for c in APPROACH_ORDER if c in cv_pivot.columns]]\n", + "\n", + " fig, ax = plt.subplots(figsize=(8, max(3, len(cv_pivot) * 0.5)))\n", + " sns.heatmap(cv_pivot, annot=True, fmt=\".2f\", cmap=\"YlOrRd\", ax=ax,\n", + " cbar_kws={\"label\": \"CV (%)\"}, linewidths=0.5)\n", + " ax.set_title(\"Coefficient of Variation (%) at Largest Size\", fontweight=\"bold\")\n", + " ax.set_ylabel(\"\")\n", + " plt.tight_layout()\n", + " plt.savefig(RESULTS / \"cv_heatmap.pdf\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "else:\n", + " print(\"std_dev_ns column not found — re-run collect_metrics.py with the updated script.\")" + ] + }, + { + "cell_type": "markdown", + "id": "da3b5fa8", + "metadata": {}, + "source": [ + "### Slope vs Mean Estimate\n", + "\n", + "Criterion computes a *slope* via linear regression over (iterations, time), which is more robust than the arithmetic mean against outliers.\n", + "Large divergence between slope and mean suggests measurement noise or non-linear scaling." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fdf0219", + "metadata": {}, + "outputs": [], + "source": [ + "# Scatter: slope_ns vs mean_ns — points near the diagonal = stable measurements\n", + "has_slope = \"slope_ns\" in rt.columns\n", + "\n", + "if has_slope:\n", + " rt_valid = rt.dropna(subset=[\"slope_ns\", \"mean_ns\"])\n", + "\n", + " fig, ax = plt.subplots(figsize=(7, 7))\n", + " for approach in APPROACH_ORDER:\n", + " d = rt_valid[rt_valid[\"approach\"] == approach]\n", + " if d.empty:\n", + " continue\n", + " ax.scatter(d[\"mean_ns\"], d[\"slope_ns\"], label=approach, alpha=0.6, s=20,\n", + " color=APPROACH_COLORS.get(approach, \"gray\"))\n", + "\n", + " # Reference diagonal (slope == mean)\n", + " lo = min(rt_valid[\"mean_ns\"].min(), rt_valid[\"slope_ns\"].min())\n", + " hi = max(rt_valid[\"mean_ns\"].max(), rt_valid[\"slope_ns\"].max())\n", + " ax.plot([lo, hi], [lo, hi], \"k--\", lw=0.8, alpha=0.5, label=\"slope = mean\")\n", + "\n", + " ax.set_xlabel(\"Mean (ns)\")\n", + " ax.set_ylabel(\"Slope (ns)\")\n", + " ax.set_title(\"Slope vs Mean — closer to diagonal = more stable\", fontweight=\"bold\")\n", + " ax.set_xscale(\"log\")\n", + " ax.set_yscale(\"log\")\n", + " ax.legend(fontsize=8)\n", + " plt.tight_layout()\n", + " plt.savefig(RESULTS / \"slope_vs_mean.pdf\", bbox_inches=\"tight\")\n", + " plt.show()\n", + "\n", + " # Divergence table: |slope - mean| / mean at largest size\n", + " if has_std: # reuses largest_full from CV cell\n", + " largest_full[\"slope_mean_pct\"] = (\n", + " (largest_full[\"slope_ns\"] - largest_full[\"mean_ns\"]).abs() / largest_full[\"mean_ns\"] * 100\n", + " )\n", + " div_pivot = largest_full.pivot_table(index=\"example\", columns=\"approach\", values=\"slope_mean_pct\")\n", + " div_pivot = div_pivot[[c for c in APPROACH_ORDER if c in div_pivot.columns]]\n", + " display(div_pivot.style.format(\"{:.3f}%\")\n", + " .background_gradient(cmap=\"YlOrRd\", axis=None)\n", + " .set_caption(\"|slope − mean| / mean (%) at largest size\"))\n", + "else:\n", + " print(\"slope_ns column not found — re-run collect_metrics.py with the updated script.\")" + ] + }, + { + "cell_type": "markdown", + "id": "2dcbf337", + "metadata": {}, + "source": [ + "## 2. Compile Time" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86a96ebd", + "metadata": {}, + "outputs": [], + "source": [ + "bt = pd.read_csv(RESULTS / \"build_time.csv\")\n", + "bt_avg = bt.groupby([\"example\", \"variant\"])[\"build_time_secs\"].mean().reset_index()\n", + "bt_avg.columns = [\"example\", \"approach\", \"mean_build_secs\"]\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5))\n", + "bt_pivot = bt_avg.pivot(index=\"example\", columns=\"approach\", values=\"mean_build_secs\")\n", + "bt_pivot = bt_pivot[[c for c in APPROACH_ORDER if c in bt_pivot.columns]]\n", + "bt_pivot.plot(kind=\"bar\", ax=ax, color=[APPROACH_COLORS.get(c, \"gray\") for c in bt_pivot.columns])\n", + "ax.set_ylabel(\"Mean build time (s)\")\n", + "ax.set_title(\"Compile Time per Example & Approach\")\n", + "ax.legend(title=\"Approach\", bbox_to_anchor=(1.02, 1), loc=\"upper left\")\n", + "plt.tight_layout()\n", + "plt.savefig(RESULTS / \"build_time.pdf\", bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "648528e2", + "metadata": {}, + "source": [ + "## 3. Binary Size" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1b07dc2", + "metadata": {}, + "outputs": [], + "source": [ + "bs = pd.read_csv(RESULTS / \"binary_size.csv\")\n", + "bs.columns = [\"example\", \"approach\", \"binary_size_bytes\", \"stripped_size_bytes\"]\n", + "bs[\"size_kb\"] = bs[\"binary_size_bytes\"] / 1024.0\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5))\n", + "bs_pivot = bs.pivot(index=\"example\", columns=\"approach\", values=\"size_kb\")\n", + "bs_pivot = bs_pivot[[c for c in APPROACH_ORDER if c in bs_pivot.columns]]\n", + "bs_pivot.plot(kind=\"bar\", ax=ax, color=[APPROACH_COLORS.get(c, \"gray\") for c in bs_pivot.columns])\n", + "ax.set_ylabel(\"Artifact size (KB)\")\n", + "ax.set_title(\"Binary Size per Example & Approach\")\n", + "ax.legend(title=\"Approach\", bbox_to_anchor=(1.02, 1), loc=\"upper left\")\n", + "plt.tight_layout()\n", + "plt.savefig(RESULTS / \"binary_size.pdf\", bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1a42f5fc", + "metadata": {}, + "source": [ + "## 4. Summary Table" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f02451da", + "metadata": {}, + "outputs": [], + "source": [ + "# Combine all metrics into a single summary\n", + "summary_parts = []\n", + "\n", + "# Runtime speedup at largest size\n", + "if 'pivot' in dir():\n", + " rt_summary = pivot.mean().rename(\"mean_speedup_vs_spec\")\n", + " summary_parts.append(rt_summary)\n", + "\n", + "# Build time overhead vs spec\n", + "if 'bt_avg' in dir():\n", + " spec_bt = bt_avg[bt_avg[\"approach\"] == \"spec\"][[\"example\", \"mean_build_secs\"]].rename(\n", + " columns={\"mean_build_secs\": \"spec_build\"}\n", + " )\n", + " bt_merged = bt_avg.merge(spec_bt, on=\"example\")\n", + " bt_merged[\"build_ratio\"] = bt_merged[\"mean_build_secs\"] / bt_merged[\"spec_build\"]\n", + " bt_ratio = bt_merged.groupby(\"approach\")[\"build_ratio\"].mean()\n", + " summary_parts.append(bt_ratio.rename(\"mean_build_ratio_vs_spec\"))\n", + "\n", + "# Binary size overhead vs spec\n", + "if 'bs' in dir():\n", + " spec_bs = bs[bs[\"approach\"] == \"spec\"][[\"example\", \"binary_size_bytes\"]].rename(\n", + " columns={\"binary_size_bytes\": \"spec_size\"}\n", + " )\n", + " bs_merged = bs.merge(spec_bs, on=\"example\")\n", + " bs_merged[\"size_ratio\"] = bs_merged[\"binary_size_bytes\"] / bs_merged[\"spec_size\"]\n", + " bs_ratio = bs_merged.groupby(\"approach\")[\"size_ratio\"].mean()\n", + " summary_parts.append(bs_ratio.rename(\"mean_size_ratio_vs_spec\"))\n", + "\n", + "if summary_parts:\n", + " summary = pd.concat(summary_parts, axis=1)\n", + " summary = summary.loc[[a for a in APPROACH_ORDER if a in summary.index]]\n", + " summary.style.format(\"{:.2f}\").background_gradient(cmap=\"RdYlGn_r\", axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59e70c96", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv (3.9.6)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/spec-trait-evaluation/notebooks/eval_pretty.ipynb b/spec-trait-evaluation/notebooks/eval_pretty.ipynb new file mode 100644 index 0000000..5337c60 --- /dev/null +++ b/spec-trait-evaluation/notebooks/eval_pretty.ipynb @@ -0,0 +1,1280 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e55d7ba9", + "metadata": {}, + "source": [ + "# spec-trait Evaluation\n", + "\n", + "Analysis of runtime performance, compile time, and binary size for `spec!`/`when` vs alternatives:\n", + "- **spec**: compile-time specialization via `spec!`/`when` macros\n", + "- **naive**: generic fallback (no specialization)\n", + "- **runtime_typeid**: `TypeId`-based runtime branching\n", + "\n", + "## Examples\n", + "| # | Operation | Key specialization |\n", + "|---|-----------|--------------------|\n", + "| ex01 | Histogram | u8 array[256] vs HashMap |\n", + "| ex02 | Set intersection | u8 bitmap[256] vs HashSet |\n", + "| ex03 | Contains search | u8 memchr SIMD |\n", + "| ex04 | Sort | u8 counting sort |\n", + "| ex05 | Distinct count | u8 bitmap[256] vs HashSet |\n", + "| ex06 | Bulk serialize | u8 zero-copy |\n", + "| ex07 | Dedup | u8 bitmap vs HashSet |\n", + "| ex08 | Count value | u8 memchr_iter vs filter |" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1b8da662", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "import seaborn as sns\n", + "import numpy as np\n", + "from pathlib import Path\n", + "\n", + "# ── Publication-quality defaults ──────────────────────────────────────\n", + "sns.set_theme(style=\"ticks\", font_scale=1.15, rc={\n", + " \"axes.linewidth\": 0.8,\n", + " \"axes.titlesize\": 12,\n", + " \"axes.titleweight\": \"bold\",\n", + " \"axes.labelsize\": 11,\n", + " \"xtick.labelsize\": 10,\n", + " \"ytick.labelsize\": 10,\n", + " \"legend.fontsize\": 9,\n", + " \"legend.frameon\": True,\n", + " \"legend.edgecolor\": \"0.8\",\n", + " \"legend.fancybox\": True,\n", + " \"figure.dpi\": 120,\n", + " \"savefig.dpi\": 300,\n", + " \"savefig.bbox\": \"tight\",\n", + " \"font.family\": \"sans-serif\",\n", + "})\n", + "\n", + "RESULTS = Path(\"../results\")\n", + "\n", + "# ── Approach identifiers ──────────────────────────────────────────────\n", + "APPROACH_ORDER = [\"spec\", \"runtime_typeid\", \"naive\"]\n", + "\n", + "# Colorblind-safe Okabe-Ito palette\n", + "APPROACH_COLORS = {\n", + " \"spec\": \"#0072B2\", # blue\n", + " \"runtime_typeid\": \"#D55E00\", # vermillion\n", + " \"naive\": \"#CC79A7\", # pink\n", + "}\n", + "\n", + "APPROACH_LABELS = {\n", + " \"spec\": \"spec! (ours)\",\n", + " \"runtime_typeid\": \"TypeId\",\n", + " \"naive\": \"Naive\",\n", + "}\n", + "\n", + "APPROACH_MARKERS = {\n", + " \"spec\": \"o\",\n", + " \"runtime_typeid\": \"s\",\n", + " \"naive\": \"D\",\n", + "}\n", + "\n", + "APPROACH_HATCHES = {\n", + " \"spec\": \"\",\n", + " \"runtime_typeid\": \"//\",\n", + " \"naive\": \"xx\",\n", + "}\n", + "\n", + "# ── Shared constants ──────────────────────────────────────────────────\n", + "LW = 1.8 # line width\n", + "MS = 5 # marker size\n", + "BAND_A = 0.15 # fill_between alpha\n", + "LEG_FS = 9 # legend font size\n", + "SAVE_KW = dict(bbox_inches=\"tight\", dpi=300)\n", + "\n", + "def _label(a):\n", + " \"\"\"Return display label for an approach key.\"\"\"\n", + " return APPROACH_LABELS.get(a, a)\n", + "\n", + "def _color(a):\n", + " return APPROACH_COLORS.get(a, \"gray\")\n", + "\n", + "def _marker(a):\n", + " return APPROACH_MARKERS.get(a, \"o\")\n", + "\n", + "def make_grid(n, per_w=4.2, per_h=3.6):\n", + " \"\"\"Create a 2-row subplot grid for *n* examples.\"\"\"\n", + " ncols = (n + 1) // 2\n", + " fig, axes = plt.subplots(2, ncols,\n", + " figsize=(per_w * ncols, per_h * 2),\n", + " constrained_layout=True)\n", + " return fig, axes.flatten()\n", + "\n", + "def finish_grid(fig, axes, n, path=None):\n", + " \"\"\"Hide unused axes, despine, and optionally save.\"\"\"\n", + " for i in range(n, len(axes)):\n", + " axes[i].set_visible(False)\n", + " for ax in axes[:n]:\n", + " sns.despine(ax=ax)\n", + " if path is not None:\n", + " fig.savefig(path, **SAVE_KW)\n", + "\n", + "def style_log_x(ax):\n", + " \"\"\"Apply log-2 x axis with scalar tick labels.\"\"\"\n", + " ax.set_xscale(\"log\", base=2)\n", + " ax.xaxis.set_major_formatter(ticker.ScalarFormatter())\n", + " ax.ticklabel_format(axis=\"x\", style=\"plain\")" + ] + }, + { + "cell_type": "markdown", + "id": "8e5846c9", + "metadata": {}, + "source": [ + "## 1. Runtime Performance" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "10ce8349", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
exampleoperationgroupapproachsizemean_nsmean_se_nsmean_ci_lower_nsmean_ci_upper_nsmedian_nsmedian_se_nsmedian_ci_lower_nsmedian_ci_upper_nsslope_nsslope_se_nsslope_ci_lower_nsslope_ci_upper_nsstd_dev_nsmedian_abs_dev_nsmedian_us
0ex01extendex01_extendnaive10243229.6901115.3605213219.8820923240.8704963226.7077203.3598883220.7999933233.1363303215.5263076.5436723204.1603683229.70416953.82690736.2019343.226708
1ex01extendex01_extendnaive128415.6672410.251595415.163620416.149125415.9933350.283175415.341166416.402927415.8189640.278075415.290888416.3822322.5221901.7279690.415993
2ex01extendex01_extendnaive1656.9361070.37229056.42362757.79137356.4184410.06853456.31277956.56737156.8229270.25778856.43489757.4120473.7515090.6281320.056418
3ex01extendex01_extendnaive20486443.2697788.1409746425.9566656457.8774836446.8807754.6375726440.6687906459.7569956448.6049984.8136316439.2082046458.15495081.82002938.0154826.446881
4ex01extendex01_extendnaive256820.5009660.965667818.487923822.269526822.0460100.494511821.137481823.072236822.0483180.752599820.567927823.5248459.6979656.5896380.822046
\n", + "
" + ], + "text/plain": [ + " example operation group approach size mean_ns mean_se_ns \\\n", + "0 ex01 extend ex01_extend naive 1024 3229.690111 5.360521 \n", + "1 ex01 extend ex01_extend naive 128 415.667241 0.251595 \n", + "2 ex01 extend ex01_extend naive 16 56.936107 0.372290 \n", + "3 ex01 extend ex01_extend naive 2048 6443.269778 8.140974 \n", + "4 ex01 extend ex01_extend naive 256 820.500966 0.965667 \n", + "\n", + " mean_ci_lower_ns mean_ci_upper_ns median_ns median_se_ns \\\n", + "0 3219.882092 3240.870496 3226.707720 3.359888 \n", + "1 415.163620 416.149125 415.993335 0.283175 \n", + "2 56.423627 57.791373 56.418441 0.068534 \n", + "3 6425.956665 6457.877483 6446.880775 4.637572 \n", + "4 818.487923 822.269526 822.046010 0.494511 \n", + "\n", + " median_ci_lower_ns median_ci_upper_ns slope_ns slope_se_ns \\\n", + "0 3220.799993 3233.136330 3215.526307 6.543672 \n", + "1 415.341166 416.402927 415.818964 0.278075 \n", + "2 56.312779 56.567371 56.822927 0.257788 \n", + "3 6440.668790 6459.756995 6448.604998 4.813631 \n", + "4 821.137481 823.072236 822.048318 0.752599 \n", + "\n", + " slope_ci_lower_ns slope_ci_upper_ns std_dev_ns median_abs_dev_ns \\\n", + "0 3204.160368 3229.704169 53.826907 36.201934 \n", + "1 415.290888 416.382232 2.522190 1.727969 \n", + "2 56.434897 57.412047 3.751509 0.628132 \n", + "3 6439.208204 6458.154950 81.820029 38.015482 \n", + "4 820.567927 823.524845 9.697965 6.589638 \n", + "\n", + " median_us \n", + "0 3.226708 \n", + "1 0.415993 \n", + "2 0.056418 \n", + "3 6.446881 \n", + "4 0.822046 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rt = pd.read_csv(RESULTS / \"runtime.csv\")\n", + "rt[\"size\"] = pd.to_numeric(rt[\"size\"], errors=\"coerce\")\n", + "rt = rt.dropna(subset=[\"size\", \"median_ns\"])\n", + "rt[\"median_us\"] = rt[\"median_ns\"] / 1000.0 # from nanoseconds to microseconds\n", + "\n", + "examples = sorted(rt[\"example\"].unique())\n", + "n_ex = len(examples)\n", + "rt.head()" + ] + }, + { + "cell_type": "markdown", + "id": "9db145f8", + "metadata": {}, + "source": [ + "### Perche' usiamo la mediana e dividiamo per 1000?\n", + "\n", + "Usiamo `median_ns` perche' la **mediana** e' piu' robusta della media rispetto a outlier e rumore sperimentale. Nei benchmark alcune misure possono essere disturbate da effetti esterni come scheduling del sistema operativo, cache, turbo boost o processi in background: la mediana rappresenta meglio il **tempo tipico** osservato.\n", + "\n", + "La divisione per `1000.0` serve solo a cambiare unita' di misura: i dati nel CSV sono in **nanosecondi (`ns`)**, mentre nei grafici vogliamo mostrare **microsecondi (`µs`)** per avere valori piu' leggibili.\n", + "\n", + "$$1\\,\\mu s = 1000\\,ns$$\n", + "\n", + "Quindi:\n", + "\n", + "- `median_ns` = tempo mediano in nanosecondi\n", + "- `median_us = median_ns / 1000.0` = stesso valore espresso in microsecondi" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bea4f64a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Mean vs Median comparison — solid = median, dashed = mean, band = median 95 % CI\n", + "has_mean = \"mean_ns\" in rt.columns\n", + "\n", + "if has_mean:\n", + " rt[\"mean_us\"] = rt[\"mean_ns\"] / 1000.0\n", + "\n", + " # Pre-compute median CI in µs (if available)\n", + " has_med_ci = {\"median_ci_lower_ns\", \"median_ci_upper_ns\"}.issubset(rt.columns)\n", + " if has_med_ci:\n", + " rt[\"med_ci_lo_us\"] = rt[\"median_ci_lower_ns\"] / 1000.0\n", + " rt[\"med_ci_hi_us\"] = rt[\"median_ci_upper_ns\"] / 1000.0\n", + "\n", + " fig, axes = make_grid(n_ex)\n", + "\n", + " for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for a in APPROACH_ORDER:\n", + " d = sub[sub[\"approach\"] == a].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " c, m = _color(a), _marker(a)\n", + " ax.plot(d[\"size\"], d[\"median_us\"],\n", + " marker=m, ms=MS, lw=LW, color=c,\n", + " label=f\"{_label(a)} (median)\")\n", + " ax.plot(d[\"size\"], d[\"mean_us\"],\n", + " marker=m, ms=MS-1, lw=LW*0.7, ls=\"--\", color=c, alpha=0.55,\n", + " label=f\"{_label(a)} (mean)\")\n", + " if has_med_ci:\n", + " ax.fill_between(d[\"size\"], d[\"med_ci_lo_us\"], d[\"med_ci_hi_us\"],\n", + " alpha=BAND_A, color=c)\n", + " ax.set_title(f\"{ex}: {op}\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Time (µs)\")\n", + " style_log_x(ax)\n", + " ax.legend(fontsize=7, ncol=2)\n", + "\n", + " finish_grid(fig, axes, n_ex, RESULTS / \"mean_vs_median.pdf\")\n", + " plt.show()\n", + "else:\n", + " print(\"mean_ns column not found — only median is available.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cdc619b0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Runtime overview — median ± 95 % CI band\n", + "has_med_ci = {\"median_ci_lower_ns\", \"median_ci_upper_ns\"}.issubset(rt.columns)\n", + "\n", + "fig, axes = make_grid(n_ex)\n", + "\n", + "for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for a in APPROACH_ORDER:\n", + " d = sub[sub[\"approach\"] == a].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " c, m = _color(a), _marker(a)\n", + " ax.plot(d[\"size\"], d[\"median_us\"],\n", + " marker=m, ms=MS, lw=LW, color=c, label=_label(a))\n", + " if has_med_ci:\n", + " ax.fill_between(d[\"size\"],\n", + " d[\"median_ci_lower_ns\"] / 1000.0,\n", + " d[\"median_ci_upper_ns\"] / 1000.0,\n", + " alpha=BAND_A, color=c)\n", + " ax.set_title(f\"{ex}: {op}\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Median time (µs)\")\n", + " style_log_x(ax)\n", + " ax.legend(fontsize=LEG_FS)\n", + "\n", + "finish_grid(fig, axes, n_ex, RESULTS / \"runtime_all.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a59394b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Zoom — naive excluded to reveal differences among fast approaches\n", + "ZOOM_APPROACHES = [a for a in APPROACH_ORDER if a != \"naive\"]\n", + "\n", + "fig, axes = make_grid(n_ex)\n", + "\n", + "for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for a in ZOOM_APPROACHES:\n", + " d = sub[sub[\"approach\"] == a].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " c, m = _color(a), _marker(a)\n", + " ax.plot(d[\"size\"], d[\"median_us\"],\n", + " marker=m, ms=MS, lw=LW, color=c, label=_label(a))\n", + " if has_med_ci:\n", + " ax.fill_between(d[\"size\"],\n", + " d[\"median_ci_lower_ns\"] / 1000.0,\n", + " d[\"median_ci_upper_ns\"] / 1000.0,\n", + " alpha=BAND_A, color=c)\n", + " ax.set_title(f\"{ex}: {op}\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Median time (µs)\")\n", + " style_log_x(ax)\n", + " ax.legend(fontsize=LEG_FS)\n", + "\n", + "fig.suptitle(\"Runtime (zoom — Naive excluded)\", fontweight=\"bold\", fontsize=13)\n", + "finish_grid(fig, axes, n_ex, RESULTS / \"runtime_zoom.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a714bebe", + "metadata": {}, + "source": [ + "### Speedup of `spec` over each alternative (at largest size)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ca974dc7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/85/w1f_3bln5rzbljrg0v33t7880000gn/T/ipykernel_92519/317917863.py:1: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " largest = rt.groupby([\"example\", \"approach\"]).apply(\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Speedup vs spec! at largest input size
approachspec! (ours)TypeIdNaive
example   
ex011.00×1.21×226.21×
ex021.00×1.12×1788.62×
ex031.00×1.01×2.46×
ex041.00×1.41×0.89×
ex051.00×1.10×51.94×
ex061.00×1.50×13.51×
ex071.00×2.24×31.44×
ex081.00×1.61×1.17×
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "largest = rt.groupby([\"example\", \"approach\"]).apply(\n", + " lambda g: g.loc[g[\"size\"].idxmax()]\n", + ").reset_index(drop=True)\n", + "\n", + "spec_times = largest[largest[\"approach\"] == \"spec\"][[\"example\", \"median_ns\"]].rename(\n", + " columns={\"median_ns\": \"spec_ns\"}\n", + ")\n", + "merged = largest.merge(spec_times, on=\"example\")\n", + "merged[\"speedup_vs_spec\"] = merged[\"median_ns\"] / merged[\"spec_ns\"]\n", + "\n", + "pivot = merged.pivot_table(index=\"example\", columns=\"approach\", values=\"speedup_vs_spec\")\n", + "pivot = pivot[[c for c in APPROACH_ORDER if c in pivot.columns]]\n", + "pivot.rename(columns=APPROACH_LABELS).style.format(\"{:.2f}×\").background_gradient(\n", + " cmap=\"RdYlGn\", axis=None\n", + ").set_caption(\"Speedup vs spec! at largest input size\")" + ] + }, + { + "cell_type": "markdown", + "id": "b49a272a", + "metadata": {}, + "source": [ + "### Runtime with 95% Confidence Intervals" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b945d7fa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Mean ± 95 % CI (from Criterion's mean_ci_lower_ns / mean_ci_upper_ns)\n", + "has_ci = \"mean_ci_lower_ns\" in rt.columns and \"mean_ci_upper_ns\" in rt.columns\n", + "\n", + "if has_ci:\n", + " rt[\"mean_us\"] = rt[\"mean_ns\"] / 1000.0\n", + " rt[\"ci_lower_us\"] = rt[\"mean_ci_lower_ns\"] / 1000.0\n", + " rt[\"ci_upper_us\"] = rt[\"mean_ci_upper_ns\"] / 1000.0\n", + "\n", + " fig, axes = make_grid(n_ex)\n", + "\n", + " for idx, ex in enumerate(examples):\n", + " ax = axes[idx]\n", + " sub = rt[rt[\"example\"] == ex]\n", + " op = sub[\"operation\"].iloc[0]\n", + " for a in APPROACH_ORDER:\n", + " d = sub[sub[\"approach\"] == a].sort_values(\"size\")\n", + " if d.empty:\n", + " continue\n", + " c, m = _color(a), _marker(a)\n", + " ax.plot(d[\"size\"], d[\"mean_us\"],\n", + " marker=m, ms=MS, lw=LW, color=c, label=_label(a))\n", + " ax.fill_between(d[\"size\"], d[\"ci_lower_us\"], d[\"ci_upper_us\"],\n", + " alpha=BAND_A, color=c)\n", + " ax.set_title(f\"{ex}: {op}\")\n", + " ax.set_xlabel(\"Input size\")\n", + " ax.set_ylabel(\"Mean time ± 95 % CI (µs)\")\n", + " style_log_x(ax)\n", + " ax.legend(fontsize=LEG_FS)\n", + "\n", + " finish_grid(fig, axes, n_ex, RESULTS / \"runtime_ci.pdf\")\n", + " plt.show()\n", + "else:\n", + " print(\"CI columns not found — re-run collect_metrics.py with the updated script.\")" + ] + }, + { + "cell_type": "markdown", + "id": "85feb516", + "metadata": {}, + "source": [ + "### Measurement Stability (Coefficient of Variation)\n", + "\n", + "The coefficient of variation (CV = std_dev / mean) shows how noisy each measurement is.\n", + "Lower is better: CV < 1% is excellent, 1–5% is acceptable, > 5% suggests instability." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "130c6cf2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/85/w1f_3bln5rzbljrg0v33t7880000gn/T/ipykernel_92519/312580852.py:5: FutureWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " largest_full = rt.groupby([\"example\", \"approach\"]).apply(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# CV % heatmap at largest input size\n", + "has_std = \"std_dev_ns\" in rt.columns\n", + "\n", + "if has_std:\n", + " largest_full = rt.groupby([\"example\", \"approach\"]).apply(\n", + " lambda g: g.loc[g[\"size\"].idxmax()]\n", + " ).reset_index(drop=True)\n", + " largest_full[\"cv_pct\"] = (largest_full[\"std_dev_ns\"] / largest_full[\"mean_ns\"]) * 100.0\n", + "\n", + " cv_pivot = largest_full.pivot_table(index=\"example\", columns=\"approach\", values=\"cv_pct\")\n", + " cv_pivot = cv_pivot[[c for c in APPROACH_ORDER if c in cv_pivot.columns]]\n", + " cv_pivot = cv_pivot.rename(columns=APPROACH_LABELS)\n", + "\n", + " fig, ax = plt.subplots(figsize=(6, max(4, len(cv_pivot) * 0.55 + 1)))\n", + " sns.heatmap(cv_pivot, annot=True, fmt=\".2f\", cmap=\"YlOrRd\",\n", + " ax=ax, linewidths=0.8, linecolor=\"white\",\n", + " annot_kws={\"fontsize\": 11, \"fontweight\": \"medium\"},\n", + " cbar_kws={\"label\": \"CV (%)\", \"shrink\": 0.85})\n", + " ax.set_title(\"Coefficient of Variation (%) at Largest Size\",\n", + " fontweight=\"bold\", pad=12)\n", + " ax.set_ylabel(\"\")\n", + " ax.set_xlabel(\"\")\n", + " ax.tick_params(axis=\"x\", rotation=0)\n", + " ax.tick_params(axis=\"y\", rotation=0)\n", + " sns.despine(ax=ax, left=True, bottom=True)\n", + " fig.tight_layout()\n", + " fig.savefig(RESULTS / \"cv_heatmap.pdf\", **SAVE_KW)\n", + " plt.show()\n", + "else:\n", + " print(\"std_dev_ns column not found — re-run collect_metrics.py with the updated script.\")" + ] + }, + { + "cell_type": "markdown", + "id": "da3b5fa8", + "metadata": {}, + "source": [ + "### Slope vs Mean Estimate\n", + "\n", + "Criterion computes a *slope* via linear regression over (iterations, time), which is more robust than the arithmetic mean against outliers.\n", + "Large divergence between slope and mean suggests measurement noise or non-linear scaling." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7fdf0219", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
|slope − mean| / mean (%) at largest size
approachspec! (ours)TypeIdNaive
example   
ex010.131 %0.193 %0.083 %
ex020.000 %0.745 %0.400 %
ex030.141 %0.369 %0.171 %
ex040.822 %0.431 %0.095 %
ex050.578 %2.338 %0.887 %
ex060.474 %0.009 %0.989 %
ex070.604 %0.006 %0.230 %
ex080.231 %0.222 %0.174 %
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Slope vs Mean — points near diagonal = stable measurements\n", + "has_slope = \"slope_ns\" in rt.columns\n", + "\n", + "if has_slope:\n", + " rt_valid = rt.dropna(subset=[\"slope_ns\", \"mean_ns\"])\n", + "\n", + " fig, ax = plt.subplots(figsize=(6, 6))\n", + " for a in APPROACH_ORDER:\n", + " d = rt_valid[rt_valid[\"approach\"] == a]\n", + " if d.empty:\n", + " continue\n", + " ax.scatter(d[\"mean_ns\"], d[\"slope_ns\"],\n", + " label=_label(a), alpha=0.7, s=40,\n", + " marker=_marker(a), color=_color(a),\n", + " edgecolors=\"white\", linewidths=0.4)\n", + "\n", + " # Reference diagonal (slope == mean)\n", + " lo = min(rt_valid[\"mean_ns\"].min(), rt_valid[\"slope_ns\"].min()) * 0.8\n", + " hi = max(rt_valid[\"mean_ns\"].max(), rt_valid[\"slope_ns\"].max()) * 1.2\n", + " ax.plot([lo, hi], [lo, hi], color=\"0.4\", ls=\"--\", lw=1, alpha=0.6,\n", + " label=\"slope = mean\")\n", + "\n", + " ax.set_xlabel(\"Mean (ns)\")\n", + " ax.set_ylabel(\"Slope (ns)\")\n", + " ax.set_title(\"Slope vs Mean — closer to diagonal = more stable\")\n", + " ax.set_xscale(\"log\")\n", + " ax.set_yscale(\"log\")\n", + " ax.legend(fontsize=LEG_FS, loc=\"upper left\")\n", + " sns.despine(ax=ax)\n", + " fig.tight_layout()\n", + " fig.savefig(RESULTS / \"slope_vs_mean.pdf\", **SAVE_KW)\n", + " plt.show()\n", + "\n", + " # Divergence table: |slope − mean| / mean at largest size\n", + " if has_std:\n", + " largest_full[\"slope_mean_pct\"] = (\n", + " (largest_full[\"slope_ns\"] - largest_full[\"mean_ns\"]).abs()\n", + " / largest_full[\"mean_ns\"] * 100\n", + " )\n", + " div_pivot = largest_full.pivot_table(\n", + " index=\"example\", columns=\"approach\", values=\"slope_mean_pct\"\n", + " )\n", + " div_pivot = div_pivot[[c for c in APPROACH_ORDER if c in div_pivot.columns]]\n", + " display(\n", + " div_pivot.rename(columns=APPROACH_LABELS)\n", + " .style.format(\"{:.3f} %\")\n", + " .background_gradient(cmap=\"YlOrRd\", axis=None)\n", + " .set_caption(\"|slope − mean| / mean (%) at largest size\")\n", + " )\n", + "else:\n", + " print(\"slope_ns column not found — re-run collect_metrics.py with the updated script.\")" + ] + }, + { + "cell_type": "markdown", + "id": "2dcbf337", + "metadata": {}, + "source": [ + "## 2. Compile Time" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "86a96ebd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bt = pd.read_csv(RESULTS / \"build_time.csv\")\n", + "bt_avg = bt.groupby([\"example\", \"variant\"])[\"build_time_secs\"].mean().reset_index()\n", + "bt_avg.columns = [\"example\", \"approach\", \"mean_build_secs\"]\n", + "\n", + "bt_pivot = bt_avg.pivot(index=\"example\", columns=\"approach\", values=\"mean_build_secs\")\n", + "bt_pivot = bt_pivot[[c for c in APPROACH_ORDER if c in bt_pivot.columns]]\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 4.5))\n", + "n_groups = len(bt_pivot)\n", + "n_bars = len(bt_pivot.columns)\n", + "x = np.arange(n_groups)\n", + "width = 0.75 / n_bars\n", + "\n", + "for i, col in enumerate(bt_pivot.columns):\n", + " vals = bt_pivot[col].values\n", + " bars = ax.bar(x + i * width - (n_bars - 1) * width / 2,\n", + " vals, width,\n", + " label=_label(col),\n", + " color=_color(col),\n", + " hatch=APPROACH_HATCHES.get(col, \"\"),\n", + " edgecolor=\"white\", linewidth=0.6)\n", + " # Value labels on top\n", + " for bar in bars:\n", + " h = bar.get_height()\n", + " ax.text(bar.get_x() + bar.get_width() / 2, h + 0.02,\n", + " f\"{h:.2f}\", ha=\"center\", va=\"bottom\", fontsize=7.5)\n", + "\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(bt_pivot.index, rotation=0)\n", + "ax.set_ylabel(\"Mean build time (s)\")\n", + "ax.set_title(\"Compile Time per Example & Approach\")\n", + "ax.legend(fontsize=LEG_FS, title=\"Approach\")\n", + "sns.despine(ax=ax)\n", + "fig.tight_layout()\n", + "fig.savefig(RESULTS / \"build_time.pdf\", **SAVE_KW)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "648528e2", + "metadata": {}, + "source": [ + "## 3. Binary Size" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f1b07dc2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bs = pd.read_csv(RESULTS / \"binary_size.csv\")\n", + "bs.columns = [\"example\", \"approach\", \"binary_size_bytes\", \"stripped_size_bytes\"]\n", + "bs[\"size_kb\"] = bs[\"binary_size_bytes\"] / 1024.0\n", + "\n", + "bs_pivot = bs.pivot(index=\"example\", columns=\"approach\", values=\"size_kb\")\n", + "bs_pivot = bs_pivot[[c for c in APPROACH_ORDER if c in bs_pivot.columns]]\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 4.5))\n", + "n_groups = len(bs_pivot)\n", + "n_bars = len(bs_pivot.columns)\n", + "x = np.arange(n_groups)\n", + "width = 0.75 / n_bars\n", + "\n", + "for i, col in enumerate(bs_pivot.columns):\n", + " vals = bs_pivot[col].values\n", + " bars = ax.bar(x + i * width - (n_bars - 1) * width / 2,\n", + " vals, width,\n", + " label=_label(col),\n", + " color=_color(col),\n", + " hatch=APPROACH_HATCHES.get(col, \"\"),\n", + " edgecolor=\"white\", linewidth=0.6)\n", + " for bar in bars:\n", + " h = bar.get_height()\n", + " ax.text(bar.get_x() + bar.get_width() / 2, h + 1,\n", + " f\"{h:.0f}\", ha=\"center\", va=\"bottom\", fontsize=7.5)\n", + "\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(bs_pivot.index, rotation=0)\n", + "ax.set_ylabel(\"Artifact size (KB)\")\n", + "ax.set_title(\"Binary Size per Example & Approach\")\n", + "ax.legend(fontsize=LEG_FS, title=\"Approach\")\n", + "sns.despine(ax=ax)\n", + "fig.tight_layout()\n", + "fig.savefig(RESULTS / \"binary_size.pdf\", **SAVE_KW)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1a42f5fc", + "metadata": {}, + "source": [ + "## 4. Summary Table" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f02451da", + "metadata": {}, + "outputs": [], + "source": [ + "# Combine all metrics into a single summary\n", + "summary_parts = []\n", + "\n", + "# Runtime speedup at largest size\n", + "if 'pivot' in dir():\n", + " rt_summary = pivot.mean().rename(\"mean_speedup_vs_spec\")\n", + " summary_parts.append(rt_summary)\n", + "\n", + "# Build time overhead vs spec\n", + "if 'bt_avg' in dir():\n", + " spec_bt = bt_avg[bt_avg[\"approach\"] == \"spec\"][[\"example\", \"mean_build_secs\"]].rename(\n", + " columns={\"mean_build_secs\": \"spec_build\"}\n", + " )\n", + " bt_merged = bt_avg.merge(spec_bt, on=\"example\")\n", + " bt_merged[\"build_ratio\"] = bt_merged[\"mean_build_secs\"] / bt_merged[\"spec_build\"]\n", + " bt_ratio = bt_merged.groupby(\"approach\")[\"build_ratio\"].mean()\n", + " summary_parts.append(bt_ratio.rename(\"mean_build_ratio_vs_spec\"))\n", + "\n", + "# Binary size overhead vs spec\n", + "if 'bs' in dir():\n", + " spec_bs = bs[bs[\"approach\"] == \"spec\"][[\"example\", \"binary_size_bytes\"]].rename(\n", + " columns={\"binary_size_bytes\": \"spec_size\"}\n", + " )\n", + " bs_merged = bs.merge(spec_bs, on=\"example\")\n", + " bs_merged[\"size_ratio\"] = bs_merged[\"binary_size_bytes\"] / bs_merged[\"spec_size\"]\n", + " bs_ratio = bs_merged.groupby(\"approach\")[\"size_ratio\"].mean()\n", + " summary_parts.append(bs_ratio.rename(\"mean_size_ratio_vs_spec\"))\n", + "\n", + "if summary_parts:\n", + " summary = pd.concat(summary_parts, axis=1)\n", + " summary = summary.loc[[a for a in APPROACH_ORDER if a in summary.index]]\n", + " summary = summary.rename(index=APPROACH_LABELS)\n", + " summary.style.format(\"{:.2f}\").background_gradient(\n", + " cmap=\"RdYlGn_r\", axis=0\n", + " ).set_caption(\"Summary — ratios vs spec! (values > 1 = worse)\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59e70c96", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8fd0c302", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv (3.9.6)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/spec-trait-evaluation/notebooks/requirements.txt b/spec-trait-evaluation/notebooks/requirements.txt new file mode 100644 index 0000000..1cb4e00 --- /dev/null +++ b/spec-trait-evaluation/notebooks/requirements.txt @@ -0,0 +1,6 @@ +pandas>=2.0 +matplotlib>=3.7 +seaborn>=0.13 +numpy>=1.24 +ipykernel>=6.0 +jinja2>=3.0 diff --git a/spec-trait-evaluation/results/.gitkeep b/spec-trait-evaluation/results/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/spec-trait-evaluation/results/binary_size.csv b/spec-trait-evaluation/results/binary_size.csv new file mode 100644 index 0000000..8c502f3 --- /dev/null +++ b/spec-trait-evaluation/results/binary_size.csv @@ -0,0 +1,25 @@ +example,variant,binary_size_bytes,stripped_size_bytes +ex01,spec,14504,14504 +ex01,naive,9600,9600 +ex01,runtime_typeid,12728,12728 +ex02,spec,17136,17136 +ex02,naive,16392,16392 +ex02,runtime_typeid,15504,15504 +ex03,spec,9328,9328 +ex03,naive,7040,7040 +ex03,runtime_typeid,8080,8080 +ex04,spec,17032,17032 +ex04,naive,14776,14776 +ex04,runtime_typeid,15888,15888 +ex05,spec,11440,11440 +ex05,naive,9728,9728 +ex05,runtime_typeid,10088,10088 +ex06,spec,11488,11488 +ex06,naive,9840,9840 +ex06,runtime_typeid,10232,10232 +ex07,spec,10424,10424 +ex07,naive,8744,8744 +ex07,runtime_typeid,9088,9088 +ex08,spec,8776,8776 +ex08,naive,6672,6672 +ex08,runtime_typeid,7448,7448 diff --git a/spec-trait-evaluation/results/binary_size.pdf b/spec-trait-evaluation/results/binary_size.pdf new file mode 100644 index 0000000..ecbdbfb Binary files /dev/null and b/spec-trait-evaluation/results/binary_size.pdf differ diff --git a/spec-trait-evaluation/results/build_time.csv b/spec-trait-evaluation/results/build_time.csv new file mode 100644 index 0000000..dd02b18 --- /dev/null +++ b/spec-trait-evaluation/results/build_time.csv @@ -0,0 +1,121 @@ +example,variant,iteration,build_time_secs +ex01,spec,1,0.788135 +ex01,naive,1,0.424085 +ex01,runtime_typeid,1,0.416919 +ex01,spec,2,0.430695 +ex01,naive,2,0.467941 +ex01,runtime_typeid,2,0.405673 +ex01,spec,3,0.428153 +ex01,naive,3,0.415029 +ex01,runtime_typeid,3,0.439378 +ex01,spec,4,0.442925 +ex01,naive,4,0.426303 +ex01,runtime_typeid,4,0.430398 +ex01,spec,5,0.424773 +ex01,naive,5,0.417793 +ex01,runtime_typeid,5,0.419119 +ex02,spec,1,0.427446 +ex02,naive,1,0.425977 +ex02,runtime_typeid,1,0.430468 +ex02,spec,2,0.426624 +ex02,naive,2,0.407020 +ex02,runtime_typeid,2,0.411675 +ex02,spec,3,0.409257 +ex02,naive,3,0.416607 +ex02,runtime_typeid,3,0.401066 +ex02,spec,4,0.410070 +ex02,naive,4,0.416981 +ex02,runtime_typeid,4,0.413530 +ex02,spec,5,0.425315 +ex02,naive,5,0.417296 +ex02,runtime_typeid,5,0.424979 +ex03,spec,1,0.415817 +ex03,naive,1,0.417237 +ex03,runtime_typeid,1,0.410099 +ex03,spec,2,0.409766 +ex03,naive,2,0.405073 +ex03,runtime_typeid,2,0.408347 +ex03,spec,3,0.428333 +ex03,naive,3,0.432075 +ex03,runtime_typeid,3,0.425014 +ex03,spec,4,0.426384 +ex03,naive,4,0.408073 +ex03,runtime_typeid,4,0.409862 +ex03,spec,5,0.428313 +ex03,naive,5,0.412629 +ex03,runtime_typeid,5,0.411939 +ex04,spec,1,0.409544 +ex04,naive,1,0.413244 +ex04,runtime_typeid,1,0.418022 +ex04,spec,2,0.420096 +ex04,naive,2,0.413713 +ex04,runtime_typeid,2,0.418664 +ex04,spec,3,0.399932 +ex04,naive,3,0.408941 +ex04,runtime_typeid,3,0.423597 +ex04,spec,4,0.435547 +ex04,naive,4,0.404786 +ex04,runtime_typeid,4,0.413418 +ex04,spec,5,0.431045 +ex04,naive,5,0.421099 +ex04,runtime_typeid,5,0.413537 +ex05,spec,1,0.414282 +ex05,naive,1,0.402992 +ex05,runtime_typeid,1,0.426731 +ex05,spec,2,0.428063 +ex05,naive,2,0.400787 +ex05,runtime_typeid,2,0.412134 +ex05,spec,3,0.432140 +ex05,naive,3,0.456938 +ex05,runtime_typeid,3,0.431964 +ex05,spec,4,0.434042 +ex05,naive,4,0.435368 +ex05,runtime_typeid,4,0.420559 +ex05,spec,5,0.430603 +ex05,naive,5,0.424108 +ex05,runtime_typeid,5,0.421705 +ex06,spec,1,0.420371 +ex06,naive,1,0.413854 +ex06,runtime_typeid,1,0.487368 +ex06,spec,2,0.555840 +ex06,naive,2,0.524274 +ex06,runtime_typeid,2,0.523403 +ex06,spec,3,0.411743 +ex06,naive,3,0.409721 +ex06,runtime_typeid,3,0.398807 +ex06,spec,4,0.429406 +ex06,naive,4,0.406450 +ex06,runtime_typeid,4,0.447003 +ex06,spec,5,0.544563 +ex06,naive,5,0.416863 +ex06,runtime_typeid,5,0.419359 +ex07,spec,1,0.399446 +ex07,naive,1,0.424120 +ex07,runtime_typeid,1,0.406103 +ex07,spec,2,0.410780 +ex07,naive,2,0.418492 +ex07,runtime_typeid,2,0.407641 +ex07,spec,3,0.423568 +ex07,naive,3,0.418601 +ex07,runtime_typeid,3,0.411001 +ex07,spec,4,0.425827 +ex07,naive,4,0.415044 +ex07,runtime_typeid,4,0.413824 +ex07,spec,5,0.475837 +ex07,naive,5,0.410329 +ex07,runtime_typeid,5,0.405326 +ex08,spec,1,0.431965 +ex08,naive,1,0.421172 +ex08,runtime_typeid,1,0.430813 +ex08,spec,2,0.420149 +ex08,naive,2,0.415825 +ex08,runtime_typeid,2,0.418279 +ex08,spec,3,0.433528 +ex08,naive,3,0.428817 +ex08,runtime_typeid,3,0.408597 +ex08,spec,4,0.417920 +ex08,naive,4,0.404632 +ex08,runtime_typeid,4,0.423274 +ex08,spec,5,0.428727 +ex08,naive,5,0.418566 +ex08,runtime_typeid,5,0.419588 diff --git a/spec-trait-evaluation/results/build_time.pdf b/spec-trait-evaluation/results/build_time.pdf new file mode 100644 index 0000000..e7a3f03 Binary files /dev/null and b/spec-trait-evaluation/results/build_time.pdf differ diff --git a/spec-trait-evaluation/results/cv_heatmap.pdf b/spec-trait-evaluation/results/cv_heatmap.pdf new file mode 100644 index 0000000..f61786f Binary files /dev/null and b/spec-trait-evaluation/results/cv_heatmap.pdf differ diff --git a/spec-trait-evaluation/results/mean_vs_median.pdf b/spec-trait-evaluation/results/mean_vs_median.pdf new file mode 100644 index 0000000..b20ebda Binary files /dev/null and b/spec-trait-evaluation/results/mean_vs_median.pdf differ diff --git a/spec-trait-evaluation/results/runtime.csv b/spec-trait-evaluation/results/runtime.csv new file mode 100644 index 0000000..210a4fd --- /dev/null +++ b/spec-trait-evaluation/results/runtime.csv @@ -0,0 +1,217 @@ +example,operation,group,approach,size,mean_ns,mean_se_ns,mean_ci_lower_ns,mean_ci_upper_ns,median_ns,median_se_ns,median_ci_lower_ns,median_ci_upper_ns,slope_ns,slope_se_ns,slope_ci_lower_ns,slope_ci_upper_ns,std_dev_ns,median_abs_dev_ns +ex01,extend,ex01_extend,naive,1024,3229.690110685401,5.360520670541613,3219.8820924281304,3240.8704955769504,3226.707719820384,3.35988784911843,3220.7999926900584,3233.1363304093566,3215.526306709029,6.5436719747257355,3204.160367768677,3229.704168978533,53.82690701467513,36.2019336159521 +ex01,extend,ex01_extend,naive,128,415.6672413465683,0.2515946472244516,415.16362045252424,416.1491254310576,415.9933352301384,0.2831754587601281,415.3411664145031,416.40292740380005,415.8189643363161,0.2780754828526559,415.29088755721045,416.38223181875,2.52219031608685,1.7279687454361485 +ex01,extend,ex01_extend,naive,16,56.93610683645199,0.37229045807343775,56.42362720394379,57.791373381817195,56.41844086719007,0.06853356276448604,56.312779030623915,56.56737119839779,56.82292655892578,0.25778762691697094,56.434897375624104,57.41204727941177,3.751508877687602,0.6281317819577678 +ex01,extend,ex01_extend,naive,2048,6443.2697778941565,8.14097420390151,6425.956665034852,6457.8774831920255,6446.880775148196,4.637571680375761,6440.668790084745,6459.756995168507,6448.604998205577,4.8136313042139145,6439.208204090582,6458.15494960561,81.82002921843764,38.015482387861155 +ex01,extend,ex01_extend,naive,256,820.5009658432771,0.9656674085072969,818.487923129835,822.2695259715625,822.0460101237502,0.49451095069532536,821.1374807987711,823.0722360077199,822.0483183962261,0.752599255839807,820.567927075123,823.5248452682966,9.697965321720417,6.5896377730551094 +ex01,extend,ex01_extend,naive,32,113.53492588800806,0.09599768147626468,113.34315372765921,113.71925032055744,113.69875655776919,0.07361945640374402,113.55832115495328,113.83336272566413,113.70684742501008,0.08621809491259377,113.54055898659155,113.87863682895143,0.9670695356512438,0.5662052979083675 +ex01,extend,ex01_extend,naive,512,1615.1129558195616,2.2676454208623085,1610.998915698956,1619.9078121210514,1614.9502624621407,0.7792057791876859,1613.3467257049638,1616.1653072321915,1612.7768852441232,0.8413238233112681,1611.1611180691286,1614.464678522963,22.79460828720545,8.847749190860105 +ex01,extend,ex01_extend,naive,64,213.051721015922,0.5099929036396997,212.28315746302573,214.2127331225023,212.49538968619962,0.3009161088231954,211.90116970862113,213.02054806292188,213.00698137416333,0.4996844275316055,212.18910174306689,214.12258217925023,5.1131293112306295,1.9197370330524743 +ex01,extend,ex01_extend,naive,8,32.17048418360976,0.12627550511915134,31.981443753519965,32.45687858756141,32.04998449637897,0.051299471655604896,31.95966201627637,32.137418190921146,32.17316697352726,0.08027147765278429,32.03571011118596,32.348497919810654,1.2668785668168199,0.49405419231445796 +ex01,extend,ex01_extend,runtime_typeid,1024,24.992738038222445,0.0603010934105906,24.877739184750496,25.113354354343162,24.87523295082579,0.041376514598666016,24.828767123287673,24.98734032470671,24.96487000575031,0.061600974894531445,24.84742834316238,25.089269143906293,0.6083804319862478,0.4223625092872944 +ex01,extend,ex01_extend,runtime_typeid,128,16.505233946830558,0.070345114738832,16.377367073245438,16.651687475689506,16.342131442894186,0.06834025211706703,16.257377113207024,16.500580495114995,16.44329112210777,0.049676037245231446,16.35131382799254,16.546397050392553,0.7074960412010701,0.4481753327402151 +ex01,extend,ex01_extend,runtime_typeid,16,17.401725367070824,0.06894951106490504,17.272336704589605,17.54326143026167,17.27982821006708,0.050086447220771775,17.167011233599816,17.37099979164313,17.469813134959793,0.06846215565839363,17.33711591360909,17.606009402779723,0.6928538590885712,0.5696039277919321 +ex01,extend,ex01_extend,runtime_typeid,2048,34.43194885814049,0.10366102367068021,34.23341062671316,34.63722693413469,34.401561328886224,0.12634119587282322,34.152050808101066,34.560698720547556,34.36561486899187,0.09731465511648055,34.17574657046547,34.55764145837691,1.0420034801838605,1.073465452591291 +ex01,extend,ex01_extend,runtime_typeid,256,17.411328680877816,0.056173095272814784,17.303252608220483,17.52319459439612,17.32814639004102,0.033747771432326316,17.25989644126669,17.394636639194367,17.411407377227302,0.04802894843144841,17.319881880291238,17.50792658017834,0.5655293296170606,0.23682580432302733 +ex01,extend,ex01_extend,runtime_typeid,32,18.005586979704358,0.07262168019530624,17.872726798120084,18.15695912477428,17.85960104174312,0.04290643814401004,17.79591132814014,17.97666059502125,17.87752226513737,0.0684024153316902,17.761544554008875,18.029217164994552,0.7332032013193156,0.39309526097555303 +ex01,extend,ex01_extend,runtime_typeid,512,19.995257224989796,0.0959740006701294,19.828668946940716,20.202722154498115,19.82651619863353,0.02494291390581201,19.7982764608826,19.885277614098435,19.969445580220558,0.07365402813910024,19.836894739749752,20.12455739155076,0.9672083809914438,0.3155467547361802 +ex01,extend,ex01_extend,runtime_typeid,64,16.56228321922044,0.067050263472226,16.444516903722715,16.70584736055761,16.42563857282977,0.059834685117165984,16.343112979057,16.570821958160405,16.559507140071865,0.07467788210210935,16.430091037684537,16.72095697141599,0.6759865107208796,0.3708255247321502 +ex01,extend,ex01_extend,runtime_typeid,8,16.342177913226063,0.054495350572223794,16.243464640708464,16.456733841492174,16.293765249936637,0.03970014889765926,16.209758020735986,16.391268079883627,16.371452306831305,0.045414671102001064,16.28835051199884,16.46633877059556,0.5460371287366279,0.34700378886460703 +ex01,extend,ex01_extend,spec,1024,20.223757912250687,0.06348153736873972,20.116300568576463,20.3624915617145,20.133055672730016,0.03604109430464897,20.065259095815907,20.22364668953829,20.242518412047417,0.05677611622632668,20.137812986325304,20.360599369352123,0.6390258448144894,0.3752111919378152 +ex01,extend,ex01_extend,spec,128,12.575026171490604,0.04039451103332936,12.493563717829401,12.652205929740557,12.586381214471103,0.036135938736328685,12.529291431969742,12.674428038964244,12.650186616569789,0.042150984207101595,12.568271190587993,12.733516421532562,0.40561647109139337,0.3639261229885833 +ex01,extend,ex01_extend,spec,16,13.067496127430983,0.028571823586322577,13.011227996132767,13.123286150524494,13.059145655908365,0.037236041851716147,13.017440389558294,13.152803899244716,13.092692362353574,0.026347742285473114,13.040294555517066,13.14346714587594,0.286816425579664,0.2967037987887688 +ex01,extend,ex01_extend,spec,2048,28.467350575994878,0.041953246583749625,28.3836219956439,28.548331771576724,28.499778227046704,0.03241635206550517,28.436026199833336,28.560596867263193,28.504618700960624,0.03837731730201305,28.42831669223597,28.57820621935913,0.42235984604354043,0.2929758812217744 +ex01,extend,ex01_extend,spec,256,13.576277405812945,0.03262311556566658,13.510499977361256,13.638181344827014,13.625772249258038,0.02457429608656869,13.568455701083888,13.666587409168391,13.645246772511333,0.02807966672746219,13.588394524251992,13.698703131968966,0.3283774158716857,0.27926762616847417 +ex01,extend,ex01_extend,spec,32,14.069176062221409,0.03819110191398038,13.996026567151361,14.146059798229954,14.078983850890397,0.054428676121541834,13.953778432588468,14.149885355398265,14.051160273047367,0.05000022305597681,13.962204578128613,14.15771124116799,0.3841669969656154,0.38124328736816077 +ex01,extend,ex01_extend,spec,512,16.229439322240108,0.02822676045527874,16.17395189998114,16.28480855415394,16.218233376101455,0.032423816049158095,16.157529091268064,16.284161964274315,16.320747896826415,0.03121173002865709,16.259603213385123,16.382002415770057,0.2836823284800088,0.3175754892384127 +ex01,extend,ex01_extend,spec,64,12.40564536659997,0.036447602657980645,12.336298062034357,12.479705209126388,12.392502657764945,0.04583746511498813,12.291692138473213,12.459149862143148,12.404187439209773,0.060906942511644246,12.292920012189956,12.530795428998555,0.36694858566743904,0.27354932720765995 +ex01,extend,ex01_extend,spec,8,13.047991738878771,0.02707459380603812,12.99643506782467,13.103034992442328,13.032119060755676,0.01796347672089857,13.003371021925663,13.074839337504194,13.02442347801112,0.027926493165096294,12.96820545671115,13.0769695437832,0.2716232440890882,0.18569777438295013 +ex02,to_bytes,ex02_to_bytes,naive,1024,43803.64544005685,81.1482247657453,43647.873679586526,43966.08934213442,43789.251930473736,80.75433919996672,43651.86956521739,43997.05332169981,43586.26509351649,91.10702563912078,43412.814884910964,43769.29107380868,810.9797514839963,941.3652007456177 +ex02,to_bytes,ex02_to_bytes,naive,128,5646.268770583007,13.992890350539753,5620.638980159595,5675.05249713372,5629.490733025523,15.385523688051792,5611.084789684412,5664.760510989861,5659.9181833240245,21.446327179999905,5621.964046016378,5705.606077491319,140.88617351878875,115.09486787636217 +ex02,to_bytes,ex02_to_bytes,naive,16,764.8312837422607,1.331728093978662,762.0952644090494,767.3228326161934,765.5889961478554,1.188654462245384,762.5887406142131,767.1754285253893,767.8970744443803,0.8808886418700038,766.1979830575659,769.6506789726164,13.403970749441553,9.232385902173528 +ex02,to_bytes,ex02_to_bytes,naive,2048,85887.47331732936,178.47432941418995,85535.90326007856,86236.65702637643,85927.16169028339,314.7423520928496,85244.21296296296,86497.73076923077,86231.28665533717,198.25101469413525,85836.99224987625,86612.12655489783,1799.8734687668175,2240.195236684834 +ex02,to_bytes,ex02_to_bytes,naive,256,11280.160949930289,34.82102410998555,11219.858995486871,11356.430884456036,11237.823204874836,23.263658092157005,11182.122564935065,11282.526859504133,11269.581907821379,43.16083516797329,11190.68475787756,11359.478016276811,349.47056764910593,168.69511730825332 +ex02,to_bytes,ex02_to_bytes,naive,32,1482.9760863352826,5.652155707972559,1472.8734668516527,1494.888601742996,1472.768428043802,4.217600162173459,1464.9325480268665,1480.3057334516157,1485.866667061617,6.107632577640117,1474.8617510770052,1498.7222088281399,56.70124024251474,30.344724342976683 +ex02,to_bytes,ex02_to_bytes,naive,512,22158.813529865947,61.56986460881284,22044.07373487214,22285.192015299443,22098.546329365083,34.22837037692005,22040.942028985508,22175.940983606557,21965.08620606538,57.33729007264852,21859.864948003775,22084.4381879411,619.1637875234992,327.18945785789236 +ex02,to_bytes,ex02_to_bytes,naive,64,2784.049151104465,3.2535402317503808,2777.812810036935,2790.5719550921453,2777.359495037582,3.441014952339645,2769.4445081184335,2783.3896420476412,2791.756555447958,4.690207822858595,2782.5322472389116,2800.9556479848625,32.70994943974663,30.682947443570935 +ex02,to_bytes,ex02_to_bytes,naive,8,367.58224335110276,0.385614903111547,366.81428384993075,368.32729267438117,368.0471477282157,0.4057089358490364,367.2835011074035,369.0135317756677,367.1659936477301,0.4472811496147415,366.29047217987096,368.03763642484705,3.8784594127824628,3.5566462248401103 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,1024,52.835658526821874,0.07115237707569905,52.69151380421283,52.9697227912718,53.02234609149506,0.03734855508567355,52.921791689242525,53.08448104634991,53.022161719409944,0.06705153646994315,52.881596448482355,53.14480405442389,0.7124070108710537,0.42578356744738494 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,128,37.258655708572455,0.16959649749933992,36.98890253795969,37.639792754891076,37.000015198004384,0.05923493226491235,36.86709999763207,37.102998724407065,37.311912155462295,0.11393864408216972,37.11153659080958,37.556085836541186,1.7084873586116611,0.5003304934267744 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,16,35.72418801276026,0.06410405708900517,35.59920218579623,35.85154823406862,35.600193789755394,0.07371824927162283,35.45066820834459,35.79028723571523,35.61182337262261,0.04346272861464838,35.52515174649656,35.69597092387244,0.6459488180540578,0.5446946621895624 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,2048,54.38321186004019,0.2511218575910174,53.94450357352766,54.921391104717046,53.94608829585877,0.07982228682651506,53.84839136232981,54.150015790696095,54.78855903384419,0.29208605320323494,54.28741800424005,55.42577940571836,2.526941149354665,0.8348464992678895 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,256,40.17435249654865,0.20982973880147862,39.78474441281176,40.60434342874044,39.470140442611566,0.1471745654406218,39.224570179670536,39.77231897664698,39.83741670313844,0.20811771479269198,39.468586395151995,40.283698807623466,2.1085944963692604,1.1009680485834812 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,32,40.10239735532401,0.13400419594121527,39.848757099421505,40.373829009387386,39.991099592749684,0.22235435344843688,39.52206568514572,40.3296119475597,39.9360477975065,0.150290568689151,39.64918947259956,40.23870727216254,1.3413411380284879,1.3565874501857886 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,512,45.35490588462626,0.14896748257249473,45.084271259395095,45.66484123023392,45.14873839868135,0.0957491442003169,44.96573929703897,45.38220042484068,45.41204985596536,0.14237848372385356,45.16046696728244,45.71564955000344,1.5015756790449803,0.8572280856261912 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,64,37.09220221972969,0.07524169721852984,36.94611370154035,37.241247149188624,36.90220041419468,0.05903609373577424,36.81716887836903,37.039625302498514,37.54997871380168,0.10564807116667317,37.33001355346479,37.74431870859436,0.7575925389974859,0.5637137945319627 +ex02,to_bytes,ex02_to_bytes,runtime_typeid,8,35.65984525766171,0.05306169867836432,35.55589752446593,35.76380903195377,35.71394306305075,0.09096545001649489,35.51612976265494,35.84651189486071,35.5044484399399,0.05468221922454304,35.401869851336706,35.61693609711959,0.5334253802136691,0.5292605757727904 +ex02,to_bytes,ex02_to_bytes,spec,1024,44.65808761422886,0.07696229941832469,44.509619556315414,44.81170805888549,44.548229081176046,0.11698401891795643,44.358776716032985,44.79740315403208,44.47595840232769,0.07980918380204807,44.324057640300175,44.635456954586076,0.7733363524721567,0.743387032974719 +ex02,to_bytes,ex02_to_bytes,spec,128,31.475113721869818,0.048672705174268104,31.378852254378593,31.569014067105847,31.437605692180725,0.04610510842049901,31.33886880944202,31.52674868705525,31.572723847434133,0.05743382299850185,31.46282375368662,31.688498372243227,0.4881378445125695,0.4560997263448254 +ex02,to_bytes,ex02_to_bytes,spec,16,30.764550457458203,0.057094634715391474,30.653854106191,30.87798308239295,30.773469679482403,0.03599001502650786,30.70199928763131,30.823564430861055,30.89135696975922,0.04872142271290641,30.797808507081573,30.988810612786114,0.5736215944444848,0.5024733532561615 +ex02,to_bytes,ex02_to_bytes,spec,2048,47.98596616509476,0.04932611871824013,47.88539945989427,48.07891625392693,48.0409614966873,0.07713879046091705,47.91314908616961,48.17145761130365,47.98585820454939,0.03819626394979016,47.912741567638115,48.062111612742356,0.4947024635172598,0.3912167001252258 +ex02,to_bytes,ex02_to_bytes,spec,256,35.118984247579945,0.25317179858317534,34.65047765666699,35.639680193349946,34.315487927217376,0.27350102676813387,33.883577234821686,34.92963280060883,34.50486540230388,0.2353631601307812,34.06827211889877,34.986976321426745,2.5444779206404777,1.4463801711005269 +ex02,to_bytes,ex02_to_bytes,spec,32,33.15131159653882,0.050600888085141134,33.05066618225844,33.249202269619246,33.15756827109178,0.07523539143699252,33.04592506711853,33.28861860922129,33.241299058019536,0.048362983340262206,33.14883052783521,33.338414202301514,0.5075144562884569,0.48819313073604287 +ex02,to_bytes,ex02_to_bytes,spec,512,36.86679319021566,0.06927092735898788,36.73673397696726,37.00824597126354,36.7359594083417,0.05887058195443703,36.64606037313355,36.86735931708413,36.78558876762746,0.05490355504485965,36.67970238086511,36.894556404400014,0.6963807109628205,0.49440793111791986 +ex02,to_bytes,ex02_to_bytes,spec,64,33.553955010457585,0.04508042716274471,33.46638890906631,33.64345613314517,33.56427410321558,0.04065114486430539,33.476905695544396,33.645446270697775,33.3942537793225,0.07795976147827866,33.256837356804326,33.561399634264745,0.4531460526336336,0.41358835710913855 +ex02,to_bytes,ex02_to_bytes,spec,8,30.884349163501124,0.05119490384841355,30.783308719205802,30.98382241880526,30.941187214111892,0.057408127365686096,30.81464694945445,31.006832280127377,30.953077585753164,0.041363523413395234,30.870046626247618,31.032414969124968,0.5139539412897897,0.5589606482663353 +ex03,contains,ex03_contains,naive,1024,463.72967071245944,0.4932019681786535,462.7394588214262,464.67189720374654,463.3127908028898,0.5676967117828259,462.61251199011525,464.9363428179553,465.40816533518495,0.4079152798129828,464.6156190672662,466.216101627402,4.970292928355004,3.9838633740564537 +ex03,contains,ex03_contains,naive,128,302.01087536146747,0.3437675134152214,301.2998567782526,302.64579829266006,302.6889429489047,0.21444828095564872,302.189167734428,303.03573633644976,302.6308039582617,0.1744198231444862,302.28886743034417,302.9734201141961,3.4628248724913617,1.7980226169685878 +ex03,contains,ex03_contains,naive,16,47.806207260433624,0.07153303350558131,47.67485242306665,47.9553533965223,47.71204729206103,0.04158879138721213,47.64111979974049,47.81602008466684,47.87506114543518,0.045472232586825916,47.78907936654461,47.96758454640265,0.7179290129551225,0.37669723988758547 +ex03,contains,ex03_contains,naive,2048,466.29377288239294,0.45616054231420383,465.43863979943677,467.22841514826837,466.51883187986056,0.32025591105245943,465.700843043488,467.36538891984435,465.4973768462155,0.3578513701462428,464.7882276290648,466.19220292878185,4.598716090211815,2.8508093723182046 +ex03,contains,ex03_contains,naive,256,464.64769758947426,0.45433339221614816,463.72752012976423,465.51145559991403,465.0194200994268,0.23812456236088836,464.7443613898706,465.65516125235405,464.89562092485494,0.41501872520956584,464.13875726145807,465.76507204093224,4.582468304718686,2.907342823537911 +ex03,contains,ex03_contains,naive,32,90.4576780423025,0.34060120135462624,89.83292406408842,91.16739347759435,89.29789657154281,0.12422318865597727,89.06330781467489,89.54802770451926,89.9090226301637,0.24031561242685176,89.49912166319781,90.43412562273093,3.418633144244873,0.9237586219445607 +ex03,contains,ex03_contains,naive,512,463.8839018653551,0.412704095869277,463.0591274410827,464.67731430957673,464.3113783905863,0.506194591270968,463.4246162711509,465.39336005029077,464.60109914388175,0.38103198379172154,463.82514418129153,465.315019866817,4.156057241591474,4.535458554912013 +ex03,contains,ex03_contains,naive,64,160.40201825025235,0.14426175883463202,160.12527718832857,160.6904342607276,160.49855347894882,0.15745161739077068,160.1944193357665,160.7252592712876,160.40940565615165,0.24550413860539047,160.0054331853241,160.95531358970663,1.4504524217800787,1.0840206982196054 +ex03,contains,ex03_contains,naive,8,30.592152685091097,0.2542072616648044,30.179323278418746,31.162056019212372,30.11158786787829,0.08518068338583538,29.926511072016478,30.268181856263,30.95186230007478,0.294174114085661,30.47664378434182,31.60733931342891,2.5491051046494158,0.7085977944199763 +ex03,contains,ex03_contains,runtime_typeid,1024,198.1408799649568,1.5696949334004597,195.57622605014123,201.63935074906115,193.57959039952362,0.5191272552341487,193.07663921591862,195.09875160852386,197.1758054372985,1.4271378951224205,194.93533945416846,200.45907366142836,15.764470478333639,3.747274972405795 +ex03,contains,ex03_contains,runtime_typeid,128,127.07187543878737,0.1252654613504568,126.8148458854952,127.30620718605181,127.21041637319962,0.10367703913139585,127.01973378133884,127.4478460109114,127.16646504521529,0.08821537640550396,126.99277968900758,127.33916093977072,1.2585576267813903,0.809788836570524 +ex03,contains,ex03_contains,runtime_typeid,16,49.063790553553474,0.05937083732193492,48.94873887017472,49.18175174193137,49.04664065943952,0.03409402847750536,48.96641101764803,49.108962010006046,49.11658289994367,0.05822249497114307,49.012235787578646,49.23977016980233,0.5948275973040322,0.2944159098037601 +ex03,contains,ex03_contains,runtime_typeid,2048,192.5301778255716,0.3123297221194797,191.97833900463777,193.20110450866855,192.41897147171144,0.1780054520208779,192.13711055865602,192.70540616357064,193.2415200300856,0.6914970154978501,192.29466579697072,194.8221424150815,3.139047465942089,1.4798400105943899 +ex03,contains,ex03_contains,runtime_typeid,256,192.0889478714222,0.49990412585675176,191.35690131042023,193.23784918927586,191.45620401880856,0.23812283285474686,191.1320329508679,191.87842971718024,192.67415784138043,1.078436164121693,191.29922058808484,195.15867044690106,5.0083202712481,1.7387800951506716 +ex03,contains,ex03_contains,runtime_typeid,32,63.45027810540689,0.06352295141437624,63.32099697693812,63.57019852523574,63.48056127104543,0.07387934521713652,63.31439470855925,63.6178639375451,63.32462115075611,0.04962363380353327,63.229977691235575,63.42470543915025,0.6417875535491174,0.49043831826852347 +ex03,contains,ex03_contains,runtime_typeid,512,192.09418086365207,0.4921297650342538,191.232136192003,193.15158822347698,191.3897553713423,0.22710228034962618,190.86794238190197,191.6907409714073,192.11470584952067,0.7354109261859151,190.91187522703,193.7399721637226,4.963959281915458,2.114161507906476 +ex03,contains,ex03_contains,runtime_typeid,64,83.47865109421478,0.09016923393761458,83.30273278195384,83.65573031398468,83.48128174467874,0.12323515890074295,83.18892067183522,83.67956595877186,83.39614642014871,0.11183779644162223,83.18303671872955,83.62211969161172,0.9093417382906912,0.8077911611691913 +ex03,contains,ex03_contains,runtime_typeid,8,31.248575419605835,0.039738751605438036,31.169870744763074,31.325467529717667,31.23996431019561,0.05072765621106243,31.155225836930544,31.364043164583745,31.42174388764488,0.035606538626309345,31.350801121145437,31.49073050830354,0.39909050219238723,0.37571268963733884 +ex03,contains,ex03_contains,spec,1024,188.1699297557405,0.329559824306248,187.52872266239828,188.81988653787357,188.47769901580347,0.6870557835139747,187.5376744352572,189.70657633717354,188.33062792372164,0.4497775545822204,187.46336355119237,189.2262574628127,3.2963074923566578,3.016752200196934 +ex03,contains,ex03_contains,spec,128,125.48879682260991,0.10753541735919182,125.27632660529066,125.69623949534582,125.67061301506922,0.1150763744654917,125.3971569083925,125.83760056048123,125.67476468256453,0.08390174485156787,125.50729586012062,125.83625962862413,1.0821455149301402,0.8499402839335022 +ex03,contains,ex03_contains,spec,16,46.6744220064164,0.03868072526536685,46.59837320781367,46.75105076658152,46.6835024424068,0.028509658701267825,46.61881465013981,46.73548898207824,46.633836565517,0.030901156707652058,46.572667264234894,46.69373306198374,0.38972392078657697,0.28569880575736584 +ex03,contains,ex03_contains,spec,2048,189.30495377936643,0.26929439024982127,188.73488100572348,189.78710087785805,189.77526074485053,0.21566457318567747,189.31374815872874,190.09166551239684,189.57186879138825,0.13131997318094027,189.3197625731312,189.8337386960097,2.7052958505394686,1.3777340942367122 +ex03,contains,ex03_contains,spec,256,188.8287527765706,0.12525932686629396,188.58178115814647,189.07224470253513,189.1142722040684,0.15461365423546733,188.7866357315984,189.4007539226942,188.70615905592135,0.1499257719770557,188.41512442097363,189.00081795433047,1.2622480407979622,1.1805798878595744 +ex03,contains,ex03_contains,spec,32,61.47291778148701,0.47701033715162333,60.69240439428378,62.53599473013451,60.24767912319353,0.17157561668333357,59.96528917672261,60.65264820711444,61.534233673017745,0.35115037784885716,60.889112461585455,62.26693204339567,4.811749196474675,1.2304757685050882 +ex03,contains,ex03_contains,spec,512,188.8129788431689,0.21689508455482695,188.3879835117312,189.24066025533807,189.06002306072082,0.22017185002184989,188.5185671955649,189.36530903822356,188.81970519668286,0.16547086730029767,188.4976798986802,189.1459443693077,2.1777205234963684,1.492718527142237 +ex03,contains,ex03_contains,spec,64,81.48428116097962,0.14977538165502396,81.19785085164926,81.78527171224756,81.23690327894201,0.1065389305323299,80.98197416550954,81.45594601267385,81.5518607487962,0.19781698338382703,81.19695844811277,81.97230236681084,1.5089873898356803,1.0945524941095373 +ex03,contains,ex03_contains,spec,8,28.130920720034297,0.11882796139583295,27.92728516359472,28.3893499194846,27.91675847818513,0.056531943155680525,27.840843012619015,28.073515649147094,28.365687918854366,0.16168508684226965,28.08472521700101,28.714715216389294,1.194868618964371,0.46577700050847676 +ex04,sort,ex04_sort,naive,1024,56017.068130021944,219.11249315332515,55646.32165019595,56495.8009803539,55637.14995421245,39.621059225659224,55571.72470978441,55712.961988304094,56250.72599100209,273.9861063347083,55783.82421786688,56844.49899984987,2197.4102854659945,358.6932892147994 +ex04,sort,ex04_sort,naive,128,393.91701569480915,1.0705288917317743,392.17440519374315,396.30399376717736,391.980064051241,0.3603447942692413,391.1097197758207,392.59052321222055,394.73280061259,1.4096830557174365,392.3401142080287,397.8059809606478,10.757490718899414,2.5137266211756764 +ex04,sort,ex04_sort,naive,16,88.83514836001173,0.1406148228834494,88.5638283133619,89.11702452379407,88.87215945181985,0.16078952814755987,88.60952005605185,89.21528781310212,88.59453509882198,0.22991262473179683,88.21388443151666,89.1025800316297,1.4115277826822084,1.1774439947090325 +ex04,sort,ex04_sort,naive,2048,116058.79824408448,139.27830447260922,115823.57132935531,116365.4652501628,115999.28820774797,81.16266797209587,115804.67867867868,116117.8547979798,115948.83072787875,86.20457072800154,115791.19198880206,116129.69133540876,1404.102774242292,581.0786834954959 +ex04,sort,ex04_sort,naive,256,745.8766430440678,1.8689917692132154,742.9756591736018,750.0925994814102,742.7660220604453,0.5896928521737429,741.7432895654194,743.8774982271232,746.4347481669753,2.1096746403933992,743.1495576488121,751.1674063272101,18.810253758555707,4.182548304793457 +ex04,sort,ex04_sort,naive,32,124.36424162704938,0.20614202122028255,123.97686112317369,124.78708811029828,124.4593830658988,0.2950601113981397,123.74616937881424,124.9760855750447,123.89483085714043,0.228058202649624,123.47292283902505,124.36583772899277,2.072580731025966,1.7527468676151998 +ex04,sort,ex04_sort,naive,512,27120.162624991288,76.40169799972782,26990.8632291235,27287.676149005838,26974.2332986833,17.9654421496114,26925.130583214795,26996.414744725258,27203.410854185055,118.55411953017945,27008.87164309789,27463.250855500533,767.8764387586973,265.00858797706985 +ex04,sort,ex04_sort,naive,64,215.10905266181467,0.8660592288458423,213.6920938675304,217.03863792652237,213.4700999190482,0.25685146787270785,213.14476351317285,214.08497796560005,215.46199611220942,0.8861908410872387,214.07327445132356,217.4715783767217,8.72434910885975,1.8961690183863473 +ex04,sort,ex04_sort,naive,8,59.41135636540561,0.10703572363951751,59.201996644854525,59.62023720879186,59.50934705185911,0.10763523063045094,59.26513124552826,59.66779611677726,59.30405674382325,0.10609830251962446,59.09312197651229,59.51048038523508,1.0756832990706233,0.6751113100369374 +ex04,sort,ex04_sort,runtime_typeid,1024,84876.1137278362,283.949719001372,84390.8898161552,85498.21328766669,84273.0296184739,161.75634450312947,84045.78744755912,84647.08910533911,85258.93122013693,288.22246045493864,84766.55846366216,85889.0817460763,2851.0366004959974,1170.4019221783024 +ex04,sort,ex04_sort,runtime_typeid,128,670.372660053505,3.665290650871982,663.8820057684447,678.1584589475065,660.3153733769041,0.9290174832612551,658.8553248877347,662.3970167647127,673.3517297032992,4.1312713233974705,665.9691907350968,682.0926201960385,36.91720421215189,7.287664459346586 +ex04,sort,ex04_sort,runtime_typeid,16,119.3506478614248,0.34042351682404387,118.7713519229446,120.09620861093802,119.2140862443983,0.23281125681015674,118.55247446506158,119.50780266078367,119.58784674682788,0.44657099211353746,118.87712296293928,120.58970597336963,3.421440332731773,2.005550277077509 +ex04,sort,ex04_sort,runtime_typeid,2048,184877.34090139315,652.6540035466917,183723.21797363416,186265.3732632363,183409.88844476745,192.0703163228381,183062.63666666666,183786.57161494734,185674.88995123393,921.0475428413362,184070.11750822666,187640.80359592361,6574.1052087204025,1555.7463243030702 +ex04,sort,ex04_sort,runtime_typeid,256,1314.2269300460227,7.864594461790353,1300.8234523959475,1331.3013445470226,1293.756858997332,3.446793271598531,1286.767132560825,1299.1663637027302,1311.556728573989,7.467724432079864,1298.401348495976,1327.420512045634,78.92960810233197,20.76358051696993 +ex04,sort,ex04_sort,runtime_typeid,32,193.3743850450356,0.5187490895655603,192.3969867086279,194.44472370489464,193.06471358785916,0.394273152209404,192.18185245169218,193.8178976688202,194.05446927975564,0.7162397247808181,192.86367836384278,195.63443995000875,5.20735624727266,3.2666217692858748 +ex04,sort,ex04_sort,runtime_typeid,512,41095.8804453112,348.6312546949634,40584.69346450223,41899.285433697456,40482.855939393936,55.592009755956546,40388.96,40591.69738043478,40962.145529540416,217.42337515272226,40598.08271658524,41440.118106696405,3500.0684533209615,389.6586673776323 +ex04,sort,ex04_sort,runtime_typeid,64,352.4869806104284,0.9810008228882551,350.7615373777419,354.5943410258917,351.93411706403833,0.5275079862041484,350.8584594539319,352.9400799331902,353.9881640702559,1.4825255041736372,351.55088998218366,357.28239926483565,9.890502662438768,5.555929310121372 +ex04,sort,ex04_sort,runtime_typeid,8,73.08411176577542,0.10947444621834176,72.87265211183869,73.30072341662812,72.78278119332337,0.16704022649092243,72.51603583409663,73.08954589157607,72.77017863624167,0.08450517561605343,72.61321579117786,72.94458573561353,1.1020404868788387,0.9914928358561329 +ex04,sort,ex04_sort,spec,1024,61512.69382330141,162.51553449216178,61228.22932766809,61860.56127948235,61245.50731267315,57.07202529425199,61121.2506684492,61365.16424751719,61780.65642729857,258.1926319388925,61336.758333027356,62339.598264960616,1633.6412572888494,548.4241187237361 +ex04,sort,ex04_sort,spec,128,393.1057995320526,1.0625911331962623,391.2393450669357,395.3728582562824,391.1442166430717,0.32544764986029956,390.70256283353416,391.927350866379,395.3365656593585,1.8819661054784589,392.07898921788615,399.4042702633883,10.660165634076186,2.668028303563942 +ex04,sort,ex04_sort,spec,16,85.93419608835657,0.24796435514265747,85.50755507623487,86.47387055955993,85.52358970907677,0.16242253988385577,85.23886297112684,85.9018486671676,85.74532326333144,0.3370011280971714,85.27411940752835,86.52774112843126,2.4838317005447705,1.130808711297878 +ex04,sort,ex04_sort,spec,2048,131922.67259099957,448.59867552099456,131176.0552079426,132921.01147655444,130492.40799444777,271.6276276513922,130123.26405502393,131124.22569444444,130838.92379673415,283.1036412750916,130376.18614945585,131482.66342967813,4496.119943183334,1479.3353723980788 +ex04,sort,ex04_sort,spec,256,759.1414407350901,3.8026738196036174,753.0186736115364,767.6501077847511,752.0678618208395,0.9152549454778949,751.1408566940872,754.8320792049749,761.5357042646261,3.988067972116368,754.5340028091724,770.0583385827817,38.34531974429322,7.425969731941518 +ex04,sort,ex04_sort,spec,32,124.4151385940819,0.4563125975303418,123.72555763397733,125.45911943973664,124.05639062161967,0.2261739248049797,123.7072857813788,124.5377965673902,124.45966933578468,0.33979767991591975,123.89518772493507,125.22031774865914,4.563430679590721,1.986988219168676 +ex04,sort,ex04_sort,spec,512,29928.691648365508,85.75076930165963,29778.24209751934,30112.940748211473,29712.389967200113,34.954455847190935,29633.174531351004,29769.95325388776,29936.17694181973,123.32047573133526,29733.4181703879,30210.646455629085,860.6574636611373,256.5002776294686 +ex04,sort,ex04_sort,spec,64,217.9931276255914,0.9757266946414701,216.28246300357534,220.0952313245544,215.42870852316875,0.3215596197338015,214.7912808486991,216.16993714006583,217.57047105076467,1.20260600833438,215.46058737700238,220.137259753232,9.80344205474057,2.7603667396678015 +ex04,sort,ex04_sort,spec,8,57.473958227982436,0.07193792456796216,57.33171449748543,57.613958713631646,57.5804822842924,0.09621953508020951,57.33347593044616,57.72684125026912,57.150319718013144,0.0867538036853526,56.98582155114294,57.32571468599099,0.7255916516833598,0.652904023727481 +ex05,histogram,ex05_histogram,naive,1024,156218.86343753166,183.12702443167424,155849.81770044751,156571.3471548743,156467.99912988453,282.3983605908161,155956.24468085106,157000.72077922078,156309.05949333953,193.45881861676327,155929.30487518734,156687.26023934843,1850.3782094535404,1856.843670530648 +ex05,histogram,ex05_histogram,naive,128,40584.68254211224,166.59524313156663,40302.07361841104,40950.270111837795,40175.12380952381,56.76381174004334,40068.81072879331,40275.72916666667,40615.63636660263,220.447722755093,40233.112381240964,41091.16380096581,1673.8312509548828,381.063446168103 +ex05,histogram,ex05_histogram,naive,16,5157.7527299900585,21.212871595657507,5121.67763835394,5204.21365411753,5109.210565050534,5.564174345884334,5099.312379127359,5119.9200376157405,5172.628244837077,27.276815409612738,5128.031414321354,5233.715505119783,213.5701710960635,38.47575980337024 +ex05,histogram,ex05_histogram,naive,2048,261529.1863560284,711.079672269367,260204.4990045338,262985.12978283426,259515.19031531533,626.4573941403164,258156.84722222222,260276.87952586205,259209.1719196099,897.2496211951036,257882.05214767167,261261.7924625024,7123.75749372888,3838.7835065606764 +ex05,histogram,ex05_histogram,naive,256,80688.59490258119,223.557931124128,80300.39371224285,81170.62863690397,80169.25366300366,98.59038855913828,80007.04225352113,80374.24169453734,81253.85262620637,394.09069669483495,80556.29685533598,82086.91879862109,2246.523507247697,728.3939799880006 +ex05,histogram,ex05_histogram,naive,32,10079.79110263438,15.194223645321271,10057.3144071839,10114.607247051737,10062.893416846367,4.562548640314899,10055.608022736073,10073.029003485142,10104.040780286983,40.35243048505142,10056.527097282029,10195.880965186883,152.97599015140983,44.35114787858967 +ex05,histogram,ex05_histogram,naive,512,111750.75882885732,2584.5941330651367,107661.4327908093,117573.74313556615,106792.85161835748,92.88465139647072,106666.51454545454,106984.09011746681,107804.30563942663,428.4662423456941,107128.75629893327,108757.8143435273,26083.689811270207,877.0812327528631 +ex05,histogram,ex05_histogram,naive,64,20284.255776727176,98.49000633937476,20113.456491506837,20496.602079641205,20066.996395875787,18.94984256753719,20029.168271082017,20096.92663708962,20305.104512836908,94.27023377882165,20148.27522336673,20513.915945074314,989.8120985411678,154.98340727533903 +ex05,histogram,ex05_histogram,naive,8,2529.486973651235,8.922223028716619,2513.8959999037515,2548.5854933636583,2505.0708278700467,4.768433815410257,2499.2508989095195,2517.2518080210384,2523.095630461554,12.624230339916421,2502.3599794904917,2550.928377109321,90.13545217812687,28.86900528670107 +ex05,histogram,ex05_histogram,runtime_typeid,1024,3287.013822263651,5.129008095651832,3278.848651337666,3298.597339867607,3287.201965011933,3.239962048380202,3279.30603060306,3291.325238258593,3296.772962644868,11.409339699202366,3281.3222979500665,3322.688078531687,51.49861336027815,21.495614349567017 +ex05,histogram,ex05_histogram,runtime_typeid,128,1567.6416569323562,42.36791065236668,1497.7405653660023,1661.8661740758944,1461.8778293330097,3.7363742012931183,1457.7282986270993,1472.672657573652,1492.5947563236264,17.170232224088387,1465.6618379979795,1531.2976065330288,426.17362944031674,38.53972319869191 +ex05,histogram,ex05_histogram,runtime_typeid,16,1236.0982111153287,5.002679901653463,1228.236499372283,1247.488146051923,1228.4275079562751,1.6150500288108047,1225.517704746905,1232.0734744707347,1238.2629002589483,4.172941780919399,1230.9783609136596,1247.2586938597717,50.35369066785406,18.034557092174815 +ex05,histogram,ex05_histogram,runtime_typeid,2048,5683.519319580718,87.90911994496125,5551.130326825218,5883.914459106968,5512.171965269044,3.744230784450459,5506.424679015976,5520.946054469274,5550.655811583159,21.941607903389777,5513.760865632672,5598.89072397256,883.8519216321764,44.05076504049987 +ex05,histogram,ex05_histogram,runtime_typeid,256,1697.0122086098897,10.548362980518261,1679.2480054937005,1720.1223307367081,1676.2604670734272,2.4975566037558536,1670.2128649376418,1681.0530829353017,1698.113582024209,12.603544324000868,1677.025126255358,1725.8134187221203,105.81218772577775,24.02137450860039 +ex05,histogram,ex05_histogram,runtime_typeid,32,1252.8746153083348,1.812746523826904,1249.2686881763982,1256.3845482546546,1252.3341374099048,1.1517441470582317,1249.9180419328945,1254.2897982381357,1254.9746368811786,2.0744231743665478,1250.9332976053963,1259.0853522968268,18.12081642426904,10.877827852990464 +ex05,histogram,ex05_histogram,runtime_typeid,512,2207.285586048882,2.2365713142853294,2202.826349918739,2211.6032344845707,2215.71888463708,1.2616784839207917,2213.569543376382,2218.289606741573,2197.056769032798,3.245142294728299,2190.8546306525727,2203.545056265825,22.388174536745495,10.84242302751603 +ex05,histogram,ex05_histogram,runtime_typeid,64,1345.5391824882145,3.6222881592374843,1339.0879683092644,1353.2041055719849,1342.4555752466713,3.15572139905113,1336.1839530332682,1349.015382197711,1352.7455519311081,5.1184310547227625,1344.1644271154153,1363.8962760959073,36.27041648962568,19.53997587633154 +ex05,histogram,ex05_histogram,runtime_typeid,8,1220.6510772966185,4.104233886945874,1213.6817582046067,1229.6438289206233,1211.436698859443,0.8924088194745032,1209.4839307787392,1213.2090949095955,1225.855041843981,5.970326143602315,1215.4353671116212,1238.7174465055068,41.22052068971457,9.678792450811038 +ex05,histogram,ex05_histogram,spec,1024,3036.585819672903,2.402296595545679,3031.8546798381894,3041.29841008161,3032.102629272568,5.303751993135685,3026.458078250256,3045.5146195013704,3036.127405643229,3.104699847741642,3030.171272381873,3042.3488893701438,24.119391232535722,28.781754780938016 +ex05,histogram,ex05_histogram,spec,128,1454.90786644084,6.401897552336447,1443.5259018866627,1468.454730375776,1445.6496413136153,3.005058886743439,1438.4928288068356,1449.4096634983066,1462.4390662694589,8.893417504156073,1446.6241696008183,1481.2550896637663,64.41879821919727,27.898093666460035 +ex05,histogram,ex05_histogram,spec,16,1240.7253392602458,7.575014588016313,1228.3130724990945,1257.5035049729552,1225.5998795950654,1.7356818694737124,1222.4890124329086,1228.283339372938,1239.8288123762468,5.816594327874127,1229.7494581404585,1252.3603310187764,75.86538300717618,12.629722781614763 +ex05,histogram,ex05_histogram,spec,2048,5026.680145353823,24.335145312778387,4993.762207218946,5081.8730928517225,4996.463584258033,5.247767873932629,4986.787993920972,5007.195335276968,4997.601204856703,10.699407909267107,4980.515391729075,5022.298729759581,245.07193927675138,45.35350578515052 +ex05,histogram,ex05_histogram,spec,256,1634.7025629872878,12.261673408794064,1617.24583209356,1662.8221539434576,1622.2445414069998,2.471836809561517,1617.0911869587367,1626.1102847441593,1629.421460393593,6.0085573236625045,1619.476264261248,1642.7153046365595,123.31962820561024,21.05422091236142 +ex05,histogram,ex05_histogram,spec,32,1281.0721440936663,2.912874577437799,1276.046743352763,1287.4306023498145,1278.1836306933565,2.3028820049805994,1273.5394908616188,1283.3926602843053,1275.951992290184,3.590161804156619,1270.1776606721462,1284.126222931054,29.309152128669457,22.17423531999251 +ex05,histogram,ex05_histogram,spec,512,2138.7209869690537,11.136061711644484,2119.729572577477,2162.9662587436774,2112.1851333537707,5.784979194037429,2103.568231235983,2125.8199251209935,2154.5838627814483,18.244190210419728,2125.5884279274833,2195.664922825896,111.81734503443823,36.21533861035025 +ex05,histogram,ex05_histogram,spec,64,1307.3942545171622,2.3172429537073973,1303.1378655986414,1312.207819673637,1301.823908078343,1.5771645797797322,1299.3803307185758,1305.2803041726804,1311.2955789856742,4.044332762993161,1304.9049202840235,1320.2775366563417,23.294520351148726,12.941755968222994 +ex05,histogram,ex05_histogram,spec,8,1219.6954607150408,5.773139017837972,1209.6161192899508,1232.1147080944752,1203.802949664112,1.194202245045721,1201.5238952389525,1205.4568983189831,1219.9579169077342,7.366745922080097,1207.1992096467106,1235.767000904812,58.08316754948773,8.63664979495241 +ex06,dedup,ex06_dedup,naive,1024,52766.73843383749,149.6507238286557,52512.6518019536,53092.2963872194,52556.33327989483,43.3933569827737,52449.61911357341,52609.83786078099,53093.90460252152,288.6453878488756,52580.71168570391,53716.013769031655,1504.9135285926989,325.9605286340974 +ex06,dedup,ex06_dedup,naive,128,6633.070117951517,10.399118651626278,6616.899741396049,6656.600268588987,6628.1607208672085,3.1771388431950807,6619.370465367965,6634.410228310502,6619.270321757549,4.061284307889641,6611.210838833796,6627.1690245425425,104.18385329627215,33.23109380200884 +ex06,dedup,ex06_dedup,naive,16,869.5382656408473,0.9912335761803882,867.7547480893026,871.641965567899,868.9897276981283,0.49080391064525414,868.2048984468339,870.1627199871128,872.649547201711,1.9777372666477733,869.7822710257826,877.1433292245777,10.00203724386484,6.022646457651761 +ex06,dedup,ex06_dedup,naive,2048,107837.26976835384,534.9913411019301,106962.37898889754,109026.4567564667,106810.44117647059,165.98421134813742,106462.91503836316,107119.99803921569,106771.27100546772,348.62108203789694,106248.79221880024,107573.77078887942,5399.211464539173,1202.4654461108646 +ex06,dedup,ex06_dedup,naive,256,13363.201934259627,34.254449287987235,13305.843115054464,13438.742878925888,13300.473005301952,13.87195867653592,13279.115112612613,13333.310558468167,13369.83605486083,47.666477491366265,13294.628262363236,13478.250157876448,343.1073675908937,109.32808651063122 +ex06,dedup,ex06_dedup,naive,32,1707.2963096161,1.4997296600524104,1704.5982445742059,1710.4623289568383,1703.1725362990423,0.7673297999070984,1702.0073650082056,1705.1313826735513,1703.17095742297,1.020075890538502,1701.3471741293731,1705.3488179609421,15.049147446218612,6.569420111320555 +ex06,dedup,ex06_dedup,naive,512,26979.415932122964,156.30452179983794,26718.900280406095,27322.195884463865,26627.049369909033,30.378347296865705,26576.43324775353,26689.71681922197,26900.96010118765,138.08056869364688,26659.398613436042,27198.979925374275,1576.8519213407383,197.9503787975615 +ex06,dedup,ex06_dedup,naive,64,3406.873399694769,15.709862559449912,3381.536481195802,3442.005256943384,3377.1537064624144,4.440359643258815,3368.77041791011,3384.1996563573884,3414.278001459478,16.528755998284154,3387.2920557134976,3451.1471368592156,158.02495865651258,29.29236618755343 +ex06,dedup,ex06_dedup,naive,8,460.39005708822583,2.189113335476131,457.0806102474635,465.37363025067043,456.53826928051103,0.3779389212594755,455.8278369615563,457.43250205027175,460.50787424709716,2.1962873365531372,456.8471660807676,465.3001617403473,22.040284960733015,3.0566166748596184 +ex06,dedup,ex06_dedup,runtime_typeid,1024,5979.339506889519,17.20668664106462,5951.451929343128,6017.696626443338,5953.455753968254,6.565361214784337,5944.816342165899,5968.818160962302,6001.194902643782,26.774781100565452,5957.695190043945,6060.891489336573,172.23945084070195,43.914615884895476 +ex06,dedup,ex06_dedup,runtime_typeid,128,773.0654509592403,0.9730863293352731,771.3141833706878,775.1121549816111,771.5065290530595,0.7832659720035502,770.1620498239473,773.5075926639825,772.0521159023922,0.7895226108296152,770.5115207062146,773.6067890411433,9.803758065829864,7.206115453145765 +ex06,dedup,ex06_dedup,runtime_typeid,16,139.8788404037366,2.5743558822275725,136.02526385996168,145.7922548640273,134.4170741324921,0.14320043003443444,134.06745240084288,134.7024122440314,135.9381159027761,0.8108692487732273,134.5382372643487,137.70266972837229,25.90585890806553,1.478391428082458 +ex06,dedup,ex06_dedup,runtime_typeid,2048,11831.9130334684,19.05108467796092,11799.008764985332,11873.62831409226,11824.07716623414,11.219131610032388,11800.969411764705,11845.958333043447,11832.926635175896,29.564619662242823,11788.378522203197,11900.529397731083,192.50173590562898,106.97327782935079 +ex06,dedup,ex06_dedup,runtime_typeid,256,1520.2424709887737,6.2521871504103395,1509.8310945279936,1534.0815575760466,1510.4053649715752,2.7173886592101457,1505.6441390254731,1515.6868340943684,1513.3909882658681,6.345963648578682,1502.9743123357368,1527.688355527385,62.54737989099746,19.000636989868465 +ex06,dedup,ex06_dedup,runtime_typeid,32,225.15013670378616,0.21981340153408152,224.71777902890966,225.57705611956226,225.0688876672681,0.32627687985288084,224.47268509568914,225.70389709007583,225.02550353445864,0.24982849059748372,224.52447489098458,225.50449593370064,2.21084708363936,2.533401109477654 +ex06,dedup,ex06_dedup,runtime_typeid,512,3022.9146906420488,8.056451725834942,3008.8434978869227,3040.28107431932,3006.625186020763,3.7558220744954998,3000.4905531215772,3015.8885542168673,3028.164913889339,12.423157927055822,3007.9801529142105,3055.4876358380793,80.93557567420606,26.333204762205245 +ex06,dedup,ex06_dedup,runtime_typeid,64,413.94087060668136,0.965865327636867,412.26159482045506,416.0217261893912,412.54600403789607,0.5138224423963244,411.85739000780046,413.5842425808719,416.841374265432,1.981622220991272,413.4885944482764,421.13631911533804,9.744348193987602,4.420980022317411 +ex06,dedup,ex06_dedup,runtime_typeid,8,80.21793660421886,0.5076780928483225,79.42709134610134,81.36024470426975,79.21059158667872,0.16470844011220134,78.95323812821673,79.55711094553533,80.0198606451404,0.3388361076443994,79.44166570168603,80.75659505543653,5.083340681832299,0.990745088938932 +ex06,dedup,ex06_dedup,spec,1024,3945.065007912382,3.5791095487983857,3938.1746118101755,3952.1995373320774,3936.7260829030406,3.528208599573579,3932.4971304573132,3945.169567157519,3951.1827551494584,5.184652986733007,3941.103481432086,3961.325277087509,36.071822290850456,30.414945634334334 +ex06,dedup,ex06_dedup,spec,128,523.2879291763388,0.31119291450555403,522.7026732242856,523.9235876904982,522.6717345572767,0.20706465416515202,522.438609585615,523.1919566787988,523.2020709140828,0.23997048584134917,522.7470669493317,523.687526700495,3.134836602288141,1.597073669128922 +ex06,dedup,ex06_dedup,spec,16,100.56734900584077,0.26862214660510986,100.11966144884899,101.16338422986705,100.09754734214464,0.20328868895329005,99.7121772667646,100.53013169756595,101.00430874811606,0.33997113684662245,100.43116220464269,101.74773798223347,2.695665156342805,1.3568463404612083 +ex06,dedup,ex06_dedup,spec,2048,7992.43929406223,36.380420144528046,7929.712068987004,8071.209830063883,7905.706555335823,4.245158296075776,7895.353634971132,7911.563317426653,8030.295416133532,51.697102373215365,7939.34538025064,8140.51505302467,363.8498599639,49.71419607965377 +ex06,dedup,ex06_dedup,spec,256,1016.0952515967733,7.146237717124415,1005.7667935564692,1032.6096305922392,1005.320680430835,0.6557877888338695,1004.1300310405092,1006.3191428192313,1013.2948238151125,4.488174412008981,1006.2302133489177,1023.2975419138372,71.80897624491854,3.9543392631696754 +ex06,dedup,ex06_dedup,spec,32,165.8019001125731,1.1288248548162199,164.20398354579427,168.3847606314468,163.9441766139398,0.14522038893168202,163.60228314926047,164.24875412394306,163.43201040561217,0.4169849833981264,162.7818397518276,164.3910691864853,11.335839279278268,1.7202558428443622 +ex06,dedup,ex06_dedup,spec,512,2014.8992399987712,6.1885678185734,2005.1546691446322,2028.8621259587721,2004.5477542075284,1.5493760481859415,2000.628484848485,2007.3984789067142,2006.3625488041341,2.833692707772036,2001.4359980196934,2012.5016448114686,62.099453127903345,15.580856512132659 +ex06,dedup,ex06_dedup,spec,64,292.2729655854832,2.7880273505796946,287.61960306381695,298.3638590877006,286.30033136934026,0.21253326280270313,285.7648056057866,286.6175064306505,289.10658901597697,1.2568000151481815,286.95082167711547,291.8369498892766,28.134224022239312,1.6799785494898178 +ex06,dedup,ex06_dedup,spec,8,63.69329346801712,0.17438789226767853,63.39032196650761,64.06924171657799,63.33601271689949,0.10805496553553105,63.192404308766555,63.61461466110847,63.70020711399832,0.24011504874279258,63.29822203827424,64.22699970851536,1.7547236654841207,0.787670149905297 +ex07,hash_key,ex07_hash_key,naive,1024,57406.519471424894,146.14259008354225,57135.03704909181,57707.8853790937,57099.158270479194,86.67337170508179,56941.80620155039,57266.419877008775,57984.10681772655,191.02311191842517,57635.554765600435,58384.03148227681,1474.3207240641075,846.1050336286982 +ex07,hash_key,ex07_hash_key,naive,128,7200.805507076841,18.253350097019776,7169.009030237995,7239.967435602222,7181.182689520092,13.930635872878925,7153.797961649593,7206.806419050611,7204.191441947624,34.95236909902549,7145.220151815573,7280.744261433354,183.9062957807697,83.203894860327 +ex07,hash_key,ex07_hash_key,naive,16,910.2422388159325,0.8562447620472724,908.569216298789,911.9276553712169,911.6643465082884,0.672436020550369,910.0195056581298,912.8089630779848,909.9535342925922,0.6774304083447708,908.5948692204172,911.2496653535334,8.623350135109888,6.2734906733536935 +ex07,hash_key,ex07_hash_key,naive,2048,113105.49118808979,140.69047250219222,112826.83125625055,113378.34257493973,113365.24302302889,180.73195392922196,113066.94479630933,113750.0,112845.32570842159,174.8143920105964,112502.07964686815,113188.22527784204,1418.7642001686984,1182.6731490100929 +ex07,hash_key,ex07_hash_key,naive,256,14412.616144788617,79.74594627965047,14278.165898696829,14587.98817227624,14269.749770983624,12.631829525773547,14247.495774647887,14301.714866979655,14472.33889284577,102.8991124880155,14306.943216167258,14701.907696695363,807.4380761491728,121.27078079634764 +ex07,hash_key,ex07_hash_key,naive,32,1781.1791271430159,3.1965461429586353,1775.2545610427883,1787.7881236505068,1780.4366883116884,6.093183690290627,1769.188470066519,1790.371135287971,1771.865471725399,3.3693037451072194,1765.6460097222166,1778.8046244473526,32.14781015842827,27.379909745979187 +ex07,hash_key,ex07_hash_key,naive,512,28556.37471121589,15.039735365427799,28526.843537708253,28585.93729715831,28557.11328125,17.026234384907053,28517.272435897437,28587.036928104575,28581.141077861517,13.654836692641949,28554.670339562592,28608.254098874106,151.00928818610691,117.0761924180095 +ex07,hash_key,ex07_hash_key,naive,64,3532.6633216618798,9.070679464654324,3516.545474009459,3551.907628447929,3532.5955372333465,5.347527423968515,3517.7754666809437,3543.273228019123,3543.486676413963,13.810121767792388,3520.049080691146,3573.5102806357363,90.76924504512293,40.307739055105344 +ex07,hash_key,ex07_hash_key,naive,8,472.3099523311336,1.6693556027901617,469.4592100179597,475.9521182861163,469.8892678793509,0.7317180936587617,468.42627460313014,470.9640030320659,476.64880070971856,3.3372151371547742,471.15017379962643,483.9927356493416,16.73278580786562,4.559263686375277 +ex07,hash_key,ex07_hash_key,runtime_typeid,1024,4046.783394068765,8.397168217662488,4030.108688005596,4063.1020862217397,4067.073894557823,11.122784456309095,4041.2218210361066,4088.2848676312633,4039.1116526963083,10.413985400316465,4018.143523598525,4059.00683937676,84.47761631105135,88.63110504656632 +ex07,hash_key,ex07_hash_key,runtime_typeid,128,527.2170710062034,2.1037989428769857,523.6383052472803,531.8165846770667,523.4266958750952,1.3607426512019107,520.3734234989474,526.0868794994535,525.2325252981526,1.9470018010290728,521.877381785065,529.5120633137118,21.100649233764486,10.693462109390781 +ex07,hash_key,ex07_hash_key,runtime_typeid,16,79.08043470576904,0.17879380870971356,78.73146102453755,79.4326948827589,78.55971816018884,0.3185752100422868,78.15079652425779,79.39379527568441,78.5749510934536,0.22698905754135937,78.1460063131367,79.03728592951768,1.7973547480755259,2.5159585695507976 +ex07,hash_key,ex07_hash_key,runtime_typeid,2048,8111.340268944318,33.975060835426,8053.974978661312,8185.752529662846,8078.187572590012,12.334207543815772,8040.836083722539,8092.862420957543,8110.887559642022,31.473325205202684,8058.12470406706,8180.6452950774565,341.28770847632177,109.04003953903558 +ex07,hash_key,ex07_hash_key,runtime_typeid,256,1044.1494610938614,10.099567721227247,1027.6049680706071,1066.468352389842,1027.665987791102,1.927864244085987,1023.3767674661106,1031.9146191779632,1032.851213416394,3.617662515305893,1026.7534537350045,1040.8198342919432,101.69377985379084,15.151399927527684 +ex07,hash_key,ex07_hash_key,runtime_typeid,32,141.97604493034984,0.3555527913584286,141.2892771928897,142.68736879986537,141.55617157141995,0.909101094684827,139.9937388536378,143.7146871236091,142.51317224065681,0.384087049463592,141.7390456405669,143.24603848023756,3.594693262452423,4.543295604933148 +ex07,hash_key,ex07_hash_key,runtime_typeid,512,2054.253852248469,3.553968416398096,2047.1698441385406,2061.097619916629,2062.730589310413,2.2568651335856074,2058.452991919633,2066.2917506636895,2048.203627121367,4.708553408629894,2038.679438393264,2057.0848447328735,35.79591574004498,22.99721722657263 +ex07,hash_key,ex07_hash_key,runtime_typeid,64,270.1276470476194,1.3694406857787236,268.0457454528945,273.23918863903776,269.2522591991342,0.7700934403207653,267.8153190895126,270.83181401931404,268.8573933598051,0.7766446303492004,267.42519045432607,270.46725799345404,13.721372450365234,5.829422022023589 +ex07,hash_key,ex07_hash_key,runtime_typeid,8,43.664375897337464,0.11350596214691477,43.45523860855409,43.899998142601405,43.616061109543665,0.06650298605621903,43.462924050462846,43.72954485350799,43.646844293060276,0.14457128401117544,43.39351276497632,43.95888746770268,1.1424050883394499,0.5511593539514161 +ex07,hash_key,ex07_hash_key,spec,1024,1853.0187162662544,6.600521812099259,1841.5269817405529,1867.3324387093687,1832.614560227973,1.8310427706044705,1829.3086876155269,1836.7765032075677,1879.7711601123972,12.743234154290809,1857.6179995266148,1906.9828156038843,66.17686127262327,16.11053927353202 +ex07,hash_key,ex07_hash_key,spec,128,244.51170430996223,0.685732201990512,243.43289823065302,246.0593432352541,243.3594029815954,0.30576319625288717,242.96192999460246,244.23689994123188,244.14259808524088,0.8704323254721519,242.72383382492052,246.06902356619366,6.902007953262555,2.2224569508105363 +ex07,hash_key,ex07_hash_key,spec,16,39.76994023362204,0.1388256607153558,39.525986056896585,40.06725365727421,39.34638338314134,0.05135716413817499,39.2527133426954,39.44440289412451,39.562713178516304,0.11640918506223753,39.364065343459046,39.81782010147085,1.3968289854339555,0.4232454693567638 +ex07,hash_key,ex07_hash_key,spec,2048,3613.7195465207133,4.040839760297635,3605.9969577141105,3621.7921607716967,3606.2262670125574,7.646382581991124,3595.0653121603673,3622.9994767137623,3591.898383514914,2.9935233140273536,3586.420883218245,3598.153840347821,40.61154641128482,38.32535529314877 +ex07,hash_key,ex07_hash_key,spec,256,468.8303882867877,0.3346988361099943,468.237723745366,469.54354672652784,468.3866329610855,0.20016905343594998,467.9280932487012,468.6987723810504,469.7200683971429,0.5365409629924724,468.7817264707543,470.8747723949539,3.3514517984321825,1.4601464564022848 +ex07,hash_key,ex07_hash_key,spec,32,72.30305851183843,0.039023643952132876,72.2232771716996,72.37608905035212,72.37589383468864,0.03432169875253925,72.3040929173714,72.42775481135435,72.41292075032513,0.035492152206887555,72.34052679037549,72.47938031791976,0.39269850114412147,0.28497350393307347 +ex07,hash_key,ex07_hash_key,spec,512,930.2986635361788,2.576881169103561,925.8925840910938,935.909387554006,924.1463288984455,0.9190344530433171,922.6559307396677,926.3071843642208,931.1136062800479,3.4021000053944275,925.9591004204926,938.8195456913022,25.91359412204711,7.092291988669727 +ex07,hash_key,ex07_hash_key,spec,64,130.55339933412705,0.08099685181236543,130.38630163794411,130.70391855252973,130.75207178209558,0.06969322015468889,130.57441087450005,130.84719575340657,130.62318363445837,0.061954870532519864,130.50099172834467,130.74421091934045,0.8151463606703401,0.51563111742802 +ex07,hash_key,ex07_hash_key,spec,8,25.218782418319478,0.0912307301484371,25.059359731063946,25.415022263635635,25.080875965127696,0.03860250592183374,24.993910651123382,25.133043111570153,25.32982684916706,0.08626136448565495,25.17990957727979,25.516058728501,0.9191528451396211,0.2905070343663512 +ex08,count_value,ex08_count_value,naive,1024,3077.008358546793,9.016469615374675,3058.85698109122,3094.1422881793774,3087.293981723124,7.210262895603389,3074.7848408385094,3104.109689440994,3083.6619073931124,4.769502294662254,3074.219290040421,3092.9151596132187,90.63814094164992,45.3555229738555 +ex08,count_value,ex08_count_value,naive,128,399.26444643535234,1.0035323095950512,397.2125584990266,401.1465862587216,403.93936369162134,0.5766610466594108,402.05871411241407,404.4111709069316,402.49433323786354,0.543069930739744,401.34827288692776,403.4733996856213,10.087891769458263,4.010391807945676 +ex08,count_value,ex08_count_value,naive,16,63.585304449190474,0.11435689205669812,63.35284246588139,63.8017285051168,63.941871578977555,0.06744063547658538,63.82494049780949,64.0923201560058,63.496072600204705,0.11031082341047518,63.28030750249092,63.712147893837944,1.149888789041061,0.5131849177268063 +ex08,count_value,ex08_count_value,naive,2048,6142.76639612086,12.74146279130025,6117.1930477634905,6167.297277917884,6168.102970679012,12.08916172828264,6144.128577231975,6192.426986882716,6153.448874439683,15.714842678560315,6125.1095397207455,6186.599428653914,128.07276475196394,85.21400472838125 +ex08,count_value,ex08_count_value,naive,256,774.2670307248618,2.197802187074267,769.9453545586618,778.5654757524593,775.4446509645696,2.992039878964613,770.0323195684524,781.6896725171233,775.9393633418613,2.5665854903536793,771.1939176664227,781.2738297085808,22.112164415917384,19.61317663546965 +ex08,count_value,ex08_count_value,naive,32,111.6638712048791,0.28722286469297675,111.12791314395709,112.2564533713871,111.72833134600478,0.114156964878832,111.45229132947883,111.92922678088368,111.9530877842572,0.38628096322169503,111.25469601154312,112.76514652436455,2.8907733388702868,1.3402546419178472 +ex08,count_value,ex08_count_value,naive,512,1553.9788225940915,3.5500391709894314,1546.6065093313434,1560.4406093578332,1563.6499006004544,0.8068352697838935,1562.678948161543,1565.525622703144,1562.1516304646711,1.6396420226094017,1558.7730016095547,1565.1699628423407,35.80387555323151,7.561283017849601 +ex08,count_value,ex08_count_value,naive,64,210.51344903751956,0.5022490898939562,209.48580916606994,211.45957681949542,212.01646460899195,0.3296391219730565,211.25817472953793,212.54590552183222,211.33404057032837,0.5309213340994234,210.22016218167786,212.30033999644337,5.050358548993884,2.028294285077469 +ex08,count_value,ex08_count_value,naive,8,33.68467398883416,0.11454392178067237,33.47299952768492,33.92159096741389,33.696261778050456,0.08357535793433536,33.55230670936258,33.89022203553871,34.015297032258246,0.14171726973621648,33.76324755032762,34.319010798701584,1.152619577367542,0.8518847209154883 +ex08,count_value,ex08_count_value,runtime_typeid,1024,4276.995846189028,7.474399973208055,4262.702327767375,4291.996400901976,4260.743225103293,9.642878939096564,4244.227973992272,4286.134633327113,4263.237842014168,6.823697731442374,4250.456574778894,4277.163951099207,75.52574262846466,69.91106041551697 +ex08,count_value,ex08_count_value,runtime_typeid,128,543.5045622833206,1.194474819510509,541.3471639204325,546.0192814899287,540.3161576846171,0.385542765254443,539.5178927158819,541.1226467945053,545.2790924431519,2.2037264064232827,541.8757709401107,550.2164095529405,12.012467743133943,3.9213692624766794 +ex08,count_value,ex08_count_value,runtime_typeid,16,79.93664754571707,0.21953023014707176,79.55607420923572,80.40948027013106,79.75213966155258,0.10158511025920332,79.55241474955132,79.99972081724407,80.41786787482746,0.26747782393534686,79.9945451098984,81.02015005460375,2.2053126337955855,1.0065185177809148 +ex08,count_value,ex08_count_value,runtime_typeid,2048,8518.523923226847,13.097463613817274,8493.737367807895,8545.143893107876,8495.928866924296,8.846446060676927,8466.13668165917,8507.776538201488,8499.588226127811,11.832596706829902,8477.34037840206,8523.755047340524,131.36829968558297,96.72803154535409 +ex08,count_value,ex08_count_value,runtime_typeid,256,1081.001310723635,2.994540677362176,1075.6508916858863,1087.3151823649162,1075.332865971257,2.6586907784112497,1070.4473959166532,1080.9589248614957,1088.5560344966154,4.369134145554096,1080.7789158875773,1097.811448909344,30.04391218338881,19.687008768777147 +ex08,count_value,ex08_count_value,runtime_typeid,32,144.90135678030566,0.24876315085376022,144.40529543215035,145.3771786346114,145.5821996387735,0.14288878555105736,145.2084040531177,145.782837970966,145.2634753835828,0.22924610967927214,144.79517084095048,145.6942945341165,2.495283835705425,1.7643081197786066 +ex08,count_value,ex08_count_value,runtime_typeid,512,2141.524400411118,4.453830164808449,2133.045579383448,2150.5296016752736,2121.48190270936,3.283780891444985,2117.6171276340992,2129.3916187739464,2140.9544618852647,4.65747351840241,2132.1837570043967,2150.4474779178995,44.73269162983632,21.810428196121133 +ex08,count_value,ex08_count_value,runtime_typeid,64,280.1736591681982,0.7118034009007392,278.84324359896544,281.63660056694823,280.0941524918185,0.5224022161741656,278.8556911277981,281.0695874695578,280.7795294295406,0.7878732509409176,279.2992967261164,282.3860913441963,7.144666747344303,6.073938504619853 +ex08,count_value,ex08_count_value,runtime_typeid,8,43.12778614349785,0.20868740766601873,42.77773299027579,43.586799251105695,42.656171878390694,0.11557058833692901,42.54576945766564,42.95534990725727,43.111510361952234,0.21305662568716677,42.74631735245037,43.57437079007723,2.1043093370350947,0.7674347118312675 +ex08,count_value,ex08_count_value,spec,1024,2650.6005319970754,2.0203336988878258,2646.5678307298167,2654.485825107603,2653.4923726920224,3.036596010813946,2648.490202375633,2660.4222520107237,2646.1727548650188,2.2213078264542476,2641.823640814731,2650.529572618907,20.338263840520064,20.24373580934392 +ex08,count_value,ex08_count_value,spec,128,349.91516796750375,0.3454059570417164,349.19740114542464,350.55473144190387,350.8314703318698,0.48150925770437014,349.5941162109375,351.471256933171,350.38857817055026,0.2739103494154329,349.83273604222404,350.9036462228805,3.47466801869314,2.4162889199413673 +ex08,count_value,ex08_count_value,spec,16,46.891483140206255,0.08645656912297958,46.74551956762124,47.07979288163873,46.76238492717918,0.04614124048466514,46.6438175329669,46.821970059411456,47.05329434890743,0.20339360748259702,46.71176001443034,47.49672254531568,0.8686831947931793,0.30305042410924 +ex08,count_value,ex08_count_value,spec,2048,5319.817693453328,36.471147741145735,5262.5986647137515,5402.435610742952,5261.485302181196,9.288133707269026,5249.181669394436,5285.357588652482,5307.552388374119,12.855457253420903,5285.071864647386,5335.343445743653,366.7665005998141,86.90627896987213 +ex08,count_value,ex08_count_value,spec,256,676.4212338417618,0.9895228378221987,674.5719096141574,678.4544623950314,676.048991889422,0.7679653067282547,674.647569291572,677.7636489302172,677.566517931181,1.5989372505304242,675.1478444352623,681.2146884108803,9.940541623660916,6.831941222523116 +ex08,count_value,ex08_count_value,spec,32,100.94266155051298,0.1496112638075527,100.67311449065191,101.2595080770777,100.93346722331054,0.107391669564316,100.72264906113956,101.12883989085468,101.2631906028079,0.2763878485162433,100.82388982634725,101.8843824820209,1.4962566892573892,0.9972465960291245 +ex08,count_value,ex08_count_value,spec,512,1385.5456274693868,6.632633113736959,1373.0133344085662,1398.9545768001803,1354.9279427176232,5.705655674963284,1348.62380627558,1370.4260865328397,1381.7590819221198,6.670403405769664,1369.4374784999713,1395.470580288646,66.72657796181099,32.068440461453065 +ex08,count_value,ex08_count_value,spec,64,172.41918215212195,0.25775219764972856,172.01040285094297,173.00086502475753,172.36243541546173,0.07793380339229598,172.1670653907496,172.48630122803326,172.83943664429287,0.6454381837322369,172.019412040764,174.31311819724462,2.5913006069176863,0.8582829190927951 +ex08,count_value,ex08_count_value,spec,8,26.551339387631916,0.0850050030961494,26.411794757639868,26.739321092733483,26.44260275362164,0.026795894697323106,26.37655484421104,26.489122294108622,26.572542467210354,0.10578900492861783,26.407381420786745,26.810656701146407,0.853998087019704,0.2548797160227943 diff --git a/spec-trait-evaluation/results/runtime_all.pdf b/spec-trait-evaluation/results/runtime_all.pdf new file mode 100644 index 0000000..546f903 Binary files /dev/null and b/spec-trait-evaluation/results/runtime_all.pdf differ diff --git a/spec-trait-evaluation/results/runtime_ci.pdf b/spec-trait-evaluation/results/runtime_ci.pdf new file mode 100644 index 0000000..cc994e9 Binary files /dev/null and b/spec-trait-evaluation/results/runtime_ci.pdf differ diff --git a/spec-trait-evaluation/results/runtime_zoom.pdf b/spec-trait-evaluation/results/runtime_zoom.pdf new file mode 100644 index 0000000..ec09123 Binary files /dev/null and b/spec-trait-evaluation/results/runtime_zoom.pdf differ diff --git a/spec-trait-evaluation/results/slope_vs_mean.pdf b/spec-trait-evaluation/results/slope_vs_mean.pdf new file mode 100644 index 0000000..f5deef0 Binary files /dev/null and b/spec-trait-evaluation/results/slope_vs_mean.pdf differ diff --git a/spec-trait-evaluation/scripts/collect_metrics.py b/spec-trait-evaluation/scripts/collect_metrics.py new file mode 100644 index 0000000..badbc13 --- /dev/null +++ b/spec-trait-evaluation/scripts/collect_metrics.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 +"""Collect Criterion benchmark results into a single CSV. + +Walks the Criterion output directory and extracts timing estimates +from each benchmark's estimates.json files. + +Usage: + python3 collect_metrics.py --criterion-dir --output + +Output CSV columns: + example - example identifier (e.g. "ex01") + operation - operation name (e.g. "extend") + group - full Criterion group name (e.g. "ex01_extend") + approach - dispatch variant (spec, naive, enum, runtime_typeid) + size - input size parameter (e.g. 128, 1024) + mean_ns - mean time per iteration (ns) + mean_se_ns - standard error of the mean (ns) + mean_ci_lower_ns - 95% confidence interval lower bound for mean (ns) + mean_ci_upper_ns - 95% confidence interval upper bound for mean (ns) + median_ns - median time per iteration (ns) + median_se_ns - standard error of the median (ns) + median_ci_lower_ns - 95% confidence interval lower bound for median (ns) + median_ci_upper_ns - 95% confidence interval upper bound for median (ns) + slope_ns - linear-regression slope estimate (ns/iter, most robust) + slope_se_ns - standard error of the slope (ns) + slope_ci_lower_ns - 95% confidence interval lower bound for slope (ns) + slope_ci_upper_ns - 95% confidence interval upper bound for slope (ns) + std_dev_ns - standard deviation of iteration times (ns) + median_abs_dev_ns - median absolute deviation, robust dispersion measure (ns) +""" +import argparse +import json +import csv +import re +from pathlib import Path + + +def collect(criterion_dir: Path, name_filter: str = ""): + rows = [] + if not criterion_dir.exists(): + print(f"[WARN] Criterion directory not found: {criterion_dir}") + return rows + + for group_dir in sorted(criterion_dir.iterdir()): + if not group_dir.is_dir() or group_dir.name.startswith("."): + continue + group_name = group_dir.name + + if name_filter and name_filter not in group_name: + continue + + for estimates_file in sorted(group_dir.rglob("new/estimates.json")): + rel = estimates_file.relative_to(group_dir) + parts = rel.parts + + if len(parts) < 3: + continue + + if len(parts) >= 4: + approach = parts[0] + size = parts[1] + else: + approach = parts[0] + size = "" + + with open(estimates_file, "r") as f: + data = json.load(f) + + def _get(block, key): + return data.get(block, {}).get(key, None) + + def _ci(block, bound): + return data.get(block, {}).get("confidence_interval", {}).get(bound, None) + + match = re.match(r"(ex\d+)_(.+)", group_name) + if match: + example = match.group(1) + operation = match.group(2) + else: + example = group_name + operation = "" + + rows.append({ + "example": example, + "operation": operation, + "group": group_name, + "approach": approach, + "size": size, + "mean_ns": _get("mean", "point_estimate"), + "mean_se_ns": _get("mean", "standard_error"), + "mean_ci_lower_ns": _ci("mean", "lower_bound"), + "mean_ci_upper_ns": _ci("mean", "upper_bound"), + "median_ns": _get("median", "point_estimate"), + "median_se_ns": _get("median", "standard_error"), + "median_ci_lower_ns": _ci("median", "lower_bound"), + "median_ci_upper_ns": _ci("median", "upper_bound"), + "slope_ns": _get("slope", "point_estimate"), + "slope_se_ns": _get("slope", "standard_error"), + "slope_ci_lower_ns": _ci("slope", "lower_bound"), + "slope_ci_upper_ns": _ci("slope", "upper_bound"), + "std_dev_ns": _get("std_dev", "point_estimate"), + "median_abs_dev_ns": _get("median_abs_dev", "point_estimate"), + }) + return rows + + +def main(): + parser = argparse.ArgumentParser(description="Collect Criterion results") + parser.add_argument("--criterion-dir", required=True, type=Path) + parser.add_argument("--output", required=True, type=Path) + parser.add_argument("--filter", default="", + help="Only include groups whose name contains this substring") + args = parser.parse_args() + + rows = collect(args.criterion_dir, name_filter=args.filter) + if not rows: + print("[WARN] No results found.") + return + + fieldnames = ["example", "operation", "group", "approach", "size", + "mean_ns", "mean_se_ns", "mean_ci_lower_ns", "mean_ci_upper_ns", + "median_ns", "median_se_ns", "median_ci_lower_ns", "median_ci_upper_ns", + "slope_ns", "slope_se_ns", "slope_ci_lower_ns", "slope_ci_upper_ns", + "std_dev_ns", "median_abs_dev_ns"] + args.output.parent.mkdir(parents=True, exist_ok=True) + with open(args.output, "w", newline="") as f: + writer = csv.DictWriter(f, fieldnames=fieldnames) + writer.writeheader() + writer.writerows(rows) + + print(f"[INFO] Wrote {len(rows)} rows to {args.output}") + + +if __name__ == "__main__": + main() diff --git a/spec-trait-evaluation/scripts/measure_binary_size.sh b/spec-trait-evaluation/scripts/measure_binary_size.sh new file mode 100755 index 0000000..37eff95 --- /dev/null +++ b/spec-trait-evaluation/scripts/measure_binary_size.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash +# Measure per-example artifact sizes for all benchmark variants. +# Outputs CSV: example,variant,binary_size_bytes,stripped_size_bytes +# +# Usage: +# ./measure_binary_size.sh [max_example] +# Example: +# ./measure_binary_size.sh 8 +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +EXAMPLES_DIR="$SCRIPT_DIR/../benches-crate/src/examples" +RESULTS_DIR="$SCRIPT_DIR/../results" +MAX_EXAMPLE="${1:-8}" + +mkdir -p "$RESULTS_DIR" + +OUT="$RESULTS_DIR/binary_size.csv" +echo "example,variant,binary_size_bytes,stripped_size_bytes" > "$OUT" + +VARIANTS=(spec naive runtime_typeid) + +TMP_CRATE="$(mktemp -d -t spec-trait-bin-size-XXXXXX)" +trap 'rm -rf "$TMP_CRATE"' EXIT + +MACRO_CRATE_PATH="$(cd "$SCRIPT_DIR/../../spec-trait-impl/crates/spec-trait-macro" && pwd)" +ORDER_CRATE_PATH="$(cd "$SCRIPT_DIR/../../spec-trait-impl/crates/spec-trait-order" && pwd)" + +cat > "$TMP_CRATE/Cargo.toml" < "$TMP_CRATE/build.rs" <<'EOF' +fn main() { + spec_trait_order::handle_order(); +} +EOF + +# Warmup: pre-compile all dependencies once (release mode) +echo "fn warmup() {}" > "$TMP_CRATE/src/lib.rs" +cargo build --manifest-path "$TMP_CRATE/Cargo.toml" --lib --release --quiet 2>/dev/null || true + +size_of_variant() { + local file_path="$1" + + cp "$file_path" "$TMP_CRATE/src/subject.rs" + + cat > "$TMP_CRATE/src/lib.rs" </dev/null || true + cargo build --manifest-path "$TMP_CRATE/Cargo.toml" --lib --release --quiet + + local rlib + rlib=$(ls -t "$TMP_CRATE"/target/release/deps/libspec_trait_size_probe*.rlib 2>/dev/null | head -1) + if [[ -z "$rlib" || ! -f "$rlib" ]]; then + echo "0,0" + return + fi + + local size + size=$(stat -f%z "$rlib" 2>/dev/null || stat --printf="%s" "$rlib" 2>/dev/null) + echo "$size,$size" +} + +for i in $(seq 1 "$MAX_EXAMPLE"); do + ex=$(printf "ex%02d" "$i") + echo "[INFO] Measuring artifact size for $ex ..." + + for variant in "${VARIANTS[@]}"; do + src_file="$EXAMPLES_DIR/${ex}_${variant}.rs" + if [[ ! -f "$src_file" ]]; then + continue + fi + vals=$(size_of_variant "$src_file") + size="${vals%%,*}" + strip="${vals##*,}" + echo "$ex,$variant,$size,$strip" >> "$OUT" + done +done + +echo "[INFO] Binary/artifact sizes written to $OUT" diff --git a/spec-trait-evaluation/scripts/measure_build_time.sh b/spec-trait-evaluation/scripts/measure_build_time.sh new file mode 100755 index 0000000..5ef3837 --- /dev/null +++ b/spec-trait-evaluation/scripts/measure_build_time.sh @@ -0,0 +1,108 @@ +#!/usr/bin/env bash +# Measure per-example compile time for all benchmark variants. +# Outputs CSV: example,variant,iteration,build_time_secs +# +# Usage: +# ./measure_build_time.sh [iterations] [max_example] +# Example: +# ./measure_build_time.sh 5 8 +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +EXAMPLES_DIR="$SCRIPT_DIR/../benches-crate/src/examples" +RESULTS_DIR="$SCRIPT_DIR/../results" +ITERATIONS="${1:-5}" +MAX_EXAMPLE="${2:-8}" + +mkdir -p "$RESULTS_DIR" + +OUT="$RESULTS_DIR/build_time.csv" +echo "example,variant,iteration,build_time_secs" > "$OUT" + +VARIANTS=(spec naive runtime_typeid) + +TMP_CRATE="$(mktemp -d -t spec-trait-build-time-XXXXXX)" +trap 'rm -rf "$TMP_CRATE"' EXIT + +MACRO_CRATE_PATH="$(cd "$SCRIPT_DIR/../../spec-trait-impl/crates/spec-trait-macro" && pwd)" +ORDER_CRATE_PATH="$(cd "$SCRIPT_DIR/../../spec-trait-impl/crates/spec-trait-order" && pwd)" + +cat > "$TMP_CRATE/Cargo.toml" < "$TMP_CRATE/build.rs" <<'EOF' +fn main() { + spec_trait_order::handle_order(); +} +EOF + +# Warmup: pre-compile all dependencies once +echo "fn warmup() {}" > "$TMP_CRATE/src/lib.rs" +cargo check --manifest-path "$TMP_CRATE/Cargo.toml" --quiet 2>/dev/null || true + +measure_variant() { + local file_path="$1" + + cp "$file_path" "$TMP_CRATE/src/subject.rs" + + cat > "$TMP_CRATE/src/lib.rs" </dev/null || true + + python3 - "$TMP_CRATE" <<'PY' +import subprocess, sys, time +crate = sys.argv[1] +start = time.perf_counter() +proc = subprocess.run( + ["cargo", "check", "--manifest-path", f"{crate}/Cargo.toml"], + stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, +) +if proc.returncode != 0: + if proc.stdout: print(proc.stdout, file=sys.stderr, end="") + if proc.stderr: print(proc.stderr, file=sys.stderr, end="") + raise subprocess.CalledProcessError(proc.returncode, proc.args) +end = time.perf_counter() +print(f"{end - start:.6f}") +PY +} + +for i in $(seq 1 "$MAX_EXAMPLE"); do + ex=$(printf "ex%02d" "$i") + echo "[INFO] Measuring build time for $ex ..." + + for iter in $(seq 1 "$ITERATIONS"); do + for variant in "${VARIANTS[@]}"; do + src_file="$EXAMPLES_DIR/${ex}_${variant}.rs" + if [[ ! -f "$src_file" ]]; then + continue + fi + t=$(measure_variant "$src_file") + echo "$ex,$variant,$iter,$t" >> "$OUT" + done + done +done + +echo "[INFO] Build times written to $OUT" diff --git a/spec-trait-evaluation/scripts/run_all.sh b/spec-trait-evaluation/scripts/run_all.sh new file mode 100755 index 0000000..1aca134 --- /dev/null +++ b/spec-trait-evaluation/scripts/run_all.sh @@ -0,0 +1,30 @@ +#!/usr/bin/env bash +# Run all Criterion benchmarks and collect CSV output. +# Usage: ./run_all.sh [--quick] +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +CRATE_DIR="$SCRIPT_DIR/../benches-crate" +RESULTS_DIR="$SCRIPT_DIR/../results" + +mkdir -p "$RESULTS_DIR" + +EXTRA_ARGS=() +if [[ "${1:-}" == "--quick" ]]; then + EXTRA_ARGS+=(--warm-up-time 1 --measurement-time 3 --sample-size 10) + echo "[INFO] Quick mode: reduced iterations" +fi + +echo "[INFO] Running benchmarks (this may take a while)..." +cd "$CRATE_DIR" +cargo bench --bench bench_all -- \ + --output-format bencher \ + "${EXTRA_ARGS[@]}" \ + 2>&1 | tee "$RESULTS_DIR/raw_output.txt" + +echo "[INFO] Collecting Criterion results..." +python3 "$SCRIPT_DIR/collect_metrics.py" \ + --criterion-dir "$CRATE_DIR/target/criterion" \ + --output "$RESULTS_DIR/runtime.csv" + +echo "[INFO] Done. Results in $RESULTS_DIR/runtime.csv" diff --git a/spec-trait-impl/crates/spec-trait-bin/src/examples/lifetimes3.rs b/spec-trait-impl/crates/spec-trait-bin/src/examples/lifetimes3.rs new file mode 100644 index 0000000..0581715 --- /dev/null +++ b/spec-trait-impl/crates/spec-trait-bin/src/examples/lifetimes3.rs @@ -0,0 +1,31 @@ +use spec_trait_macro::{spec, when}; + +trait Bad11 { + fn bad11(&self); +} + +impl Bad11 for T { + fn bad11(&self) { + println!("generic"); + } +} + +#[when(T: 'static)] +impl Bad11 for T { + fn bad11(&self) { + println!("'static"); + } +} + +pub fn run() { + println!("\n- Lifetimes 3 Examples:"); + + let static_str: &'static str = "hello"; + spec! { "hello".bad11(); &'static str } + spec! { "hello".bad11(); &'static str; &'static str: 'static } + spec! { "hello".bad11(); &str; &str: 'static } + spec! { static_str.bad11(); &'static str } + spec! { static_str.bad11(); &'static str; &'static str: 'static } + spec! { static_str.bad11(); &str; &str: 'static } + <&'static str as Bad11>::bad11(&static_str); +} diff --git a/spec-trait-impl/crates/spec-trait-bin/src/examples/mod.rs b/spec-trait-impl/crates/spec-trait-bin/src/examples/mod.rs index 027076b..e610ad0 100644 --- a/spec-trait-impl/crates/spec-trait-bin/src/examples/mod.rs +++ b/spec-trait-impl/crates/spec-trait-bin/src/examples/mod.rs @@ -3,6 +3,7 @@ mod base; mod higher; mod lifetimes; mod lifetimes2; +mod lifetimes3; mod order; mod repeating; mod sself; @@ -20,4 +21,5 @@ pub fn run() { order::run(); all::run(); lifetimes2::run(); + lifetimes3::run(); } diff --git a/tmp b/tmp new file mode 100644 index 0000000..0698bee --- /dev/null +++ b/tmp @@ -0,0 +1,118 @@ +\section{Evaluation}\label{sec:evaluation} + +To demonstrate that the \texttt{spec!}/\texttt{\#[when]} macro system +introduces no runtime overhead while improving code maintainability, +we conduct a four-pillar empirical evaluation covering +\emph{runtime performance}, \emph{compilation overhead}, +\emph{binary size}, and \emph{source-code conciseness}. + +% ────────────────────────────────────────────────────────────────────── +\subsection{Benchmark Design}\label{sec:bench-design} + +We construct \textbf{33 paired micro-benchmarks}. +Each pair consists of a file that uses our \texttt{spec!} and +\texttt{\#[when]} macros and a corresponding file that implements the +same operation using only standard Rust techniques. +The 33 examples are organised into three groups: + +\paragraph{Type specialization (ex01--ex20).} +Twenty examples target concrete-type dispatch on common data-processing +kernels---saturating arithmetic, bit-counting, summation, serialisation, +hashing, sorting, searching, formatting, FMA, and dot-product---with +specialisations for primitive types such as \texttt{u8}, \texttt{i32}, +\texttt{f64}, and \texttt{String}. + +\paragraph{Advanced pattern specialization (ex21--ex27).} +Seven examples exercise the richer features of the macro system: +lifetime specialization (\texttt{\&'static} vs.\ \texttt{\&'a}), +higher-ranked trait bounds (\texttt{for<'a> fn(\&'a T) -> T}), +cross-generic repeating constraints (\texttt{U = Vec}), +wildcard and complex type patterns (\texttt{Vec<\_>}, +\texttt{(i32, \_)}, \texttt{fn(\&u8) -> \&u8}), +conditional combinators (\texttt{any}, \texttt{all}, \texttt{not}), +\texttt{Fn} trait-bound dispatch, and multi-receiver specialization +(same trait across distinct self types). + +\paragraph{Stress-test and composite patterns (ex28--ex33).} +Six examples probe corner cases and scalability: +\texttt{T: 'static} lifetime bounds, +\texttt{\&dyn Display} type patterns, +combined trait bounds (\texttt{T: Copy + Eq}), +ten simultaneous \texttt{\#[when]} clauses on a single trait, +tuple-type specialization (\texttt{(i32,i32)}, \texttt{(f64,f64)}), +and nested generic types (\texttt{Vec{}>}, \texttt{Vec}). + +\medskip +\noindent +For each example the \emph{without-macros} file provides up to five +alternative implementations of the same operation: +\begin{enumerate}[nosep] + \item \textbf{Generic fallback} --- the default trait implementation + with no specialization; + \item \textbf{Enum dispatch} --- a hand-written enum whose match arms + select the specialised code path; + \item \textbf{Runtime \texttt{TypeId}} --- branching on + \texttt{std::any::TypeId} at runtime; + \item \textbf{Dynamic dispatch} --- a \texttt{\&dyn Trait} object + with virtual calls; + \item \textbf{Manual specialization} --- a hand-monomorphised free + function (best-case baseline). +\end{enumerate} + +% ────────────────────────────────────────────────────────────────────── +\subsection{Methodology}\label{sec:methodology} + +All benchmarks are implemented inside a dedicated Cargo crate and +executed with Criterion~0.5 on a single machine. +Each benchmark group iterates over five input sizes +($n \in \{256,\; 1{,}024,\; 4{,}096,\; 16{,}384,\; 65{,}536\}$) +to measure scaling behaviour. +Functions under test are annotated \texttt{\#[inline(never)]} to +prevent the compiler from eliding the dispatch mechanism and +\texttt{std::hint::black\_box} is used to defeat dead-code +elimination. + +\paragraph{Runtime performance.} +Criterion reports the median wall-clock time per iteration with +bootstrap confidence intervals. +From these we compute the \emph{speed-up factor} +$S = t_{\text{alt}} / t_{\text{spec}}$ +of \texttt{spec!} relative to each alternative at the largest +input size. + +\paragraph{Compilation overhead.} +We measure clean-build time of the benchmark crate with and without the +macro system, averaged over five iterations using high-resolution +monotonic timestamps. + +\paragraph{Binary size.} +The bench binary is compiled in release mode; we record both the +unstripped and stripped sizes. + +\paragraph{Source-code conciseness.} +For each pair we count the number of non-empty, non-comment physical +lines. +The ratio +$R = \text{LOC}_{\text{without}} / \text{LOC}_{\text{with}}$ +quantifies the boilerplate reduction provided by the macro system. + +% ────────────────────────────────────────────────────────────────────── +\subsection{Expected Outcomes}\label{sec:expected} + +Because \texttt{spec!} resolves to a direct, monomorphised function +call at compile time---with no vtable indirection, no branch, and no +\texttt{TypeId} comparison---we expect: +\begin{itemize}[nosep] + \item \textbf{Runtime:} \texttt{spec!} matches or outperforms all + alternatives on every example, with the largest gains over + dynamic dispatch and runtime \texttt{TypeId} checks; + \item \textbf{Build time:} a small, constant increase due to + procedural-macro expansion and the \texttt{handle\_order} build + script; + \item \textbf{Binary size:} comparable to manually monomorphised + code, since the macro generates the same trait impls a + programmer would write by hand; + \item \textbf{Conciseness:} $R > 1$ for all 33 pairs, since the + \texttt{\#[when]} annotations replace hand-written enum + variants, match arms, and boilerplate trait-object wrappers. +\end{itemize} \ No newline at end of file