usearch 2.21.2 → 2.21.4

package/simsimd/scripts/bench.rs

@@ -0,0 +1,876 @@
+//! Unified SimSIMD Benchmark Suite
+//!
+//! Compares SimSIMD vs native Rust implementations using Criterion.
+//! Reports both performance and accuracy metrics.
+//!
+//! Run with:
+//! ```bash
+//! cargo bench --bench bench -- --quiet --noplot
+//!
+//! # Or with custom dimensions:
+//! SIMSIMD_BENCH_DENSE_DIMENSIONS=2048 cargo bench --bench bench -- --quiet --noplot
+//! ```
+use std::hint::black_box;
+use std::mem::size_of;
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, Criterion, Throughput};
+use rand::rngs::StdRng;
+use rand::Rng;
+use rand::SeedableRng;
+
+use simsimd::SpatialSimilarity as SimSIMD;
+
+const BOLD: &str = "\x1b[1m";
+const RESET: &str = "\x1b[0m";
+
+fn get_dense_dimensions() -> usize {
+    std::env::var("SIMSIMD_BENCH_DENSE_DIMENSIONS")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(1536)
+}
+
+#[allow(dead_code)]
+fn get_curved_dimensions() -> usize {
+    std::env::var("SIMSIMD_BENCH_CURVED_DIMENSIONS")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(8)
+}
+
+fn calculate_errors(baseline: &[f64], contender: &[f64]) -> (f64, f64) {
+    let mut mean_delta = 0.0f64;
+    let mut mean_relative_error = 0.0f64;
+
+    for (&b, &c) in baseline.iter().zip(contender.iter()) {
+        let abs_delta = (b - c).abs();
+        mean_delta += abs_delta;
+        if abs_delta != 0.0 && b != 0.0 {
+            mean_relative_error += abs_delta / b.abs();
+        }
+    }
+
+    mean_delta /= baseline.len() as f64;
+    mean_relative_error /= baseline.len() as f64;
+    (mean_delta, mean_relative_error)
+}
+
+fn print_error(abs_err: f64, rel_err: f64) {
+    println!(
+        "                        abs error: {}{:.6e}{}",
+        BOLD, abs_err, RESET
+    );
+    println!(
+        "                        rel error: {}{:.6e}{}",
+        BOLD, rel_err, RESET
+    );
+}
+
+// region: Accurate Baseline Implementations (f64)
+
+fn accurate_cos(a: &[f32], b: &[f32]) -> f64 {
+    let mut dot = 0.0f64;
+    let mut norm_a = 0.0f64;
+    let mut norm_b = 0.0f64;
+    for i in 0..a.len() {
+        let (av, bv) = (a[i] as f64, b[i] as f64);
+        dot += av * bv;
+        norm_a += av * av;
+        norm_b += bv * bv;
+    }
+    1.0 - dot / (norm_a * norm_b).sqrt()
+}
+
+fn accurate_l2sq(a: &[f32], b: &[f32]) -> f64 {
+    let mut sum = 0.0f64;
+    for i in 0..a.len() {
+        let diff = (a[i] - b[i]) as f64;
+        sum += diff * diff;
+    }
+    sum
+}
+
+fn accurate_dot(a: &[f32], b: &[f32]) -> f64 {
+    let mut sum = 0.0f64;
+    for i in 0..a.len() {
+        sum += (a[i] as f64) * (b[i] as f64);
+    }
+    -sum
+}
+
+fn accurate_l2(a: &[f32], b: &[f32]) -> f64 {
+    accurate_l2sq(a, b).sqrt()
+}
+
+fn accurate_i8_cos(a: &[i8], b: &[i8]) -> f64 {
+    let mut dot = 0i32;
+    let mut norm_a = 0i32;
+    let mut norm_b = 0i32;
+    for i in 0..a.len() {
+        let (av, bv) = (a[i] as i32, b[i] as i32);
+        dot += av * bv;
+        norm_a += av * av;
+        norm_b += bv * bv;
+    }
+    let dot_f = dot as f32;
+    let norm_a_f = norm_a as f32;
+    let norm_b_f = norm_b as f32;
+    (1.0 - dot_f / (norm_a_f * norm_b_f).sqrt()) as f64
+}
+
+fn accurate_i8_dot(a: &[i8], b: &[i8]) -> f64 {
+    let mut sum = 0i32;
+    for i in 0..a.len() {
+        sum += (a[i] as i32) * (b[i] as i32);
+    }
+    -(sum as f64)
+}
+
+fn accurate_i8_l2sq(a: &[i8], b: &[i8]) -> f64 {
+    let mut sum = 0i32;
+    for i in 0..a.len() {
+        let diff = (a[i] - b[i]) as i32;
+        sum += diff * diff;
+    }
+    sum as f64
+}
+
+fn accurate_i8_l2(a: &[i8], b: &[i8]) -> f64 {
+    accurate_i8_l2sq(a, b).sqrt()
+}
+
+// endregion: Accurate Baseline Implementations (f64)
+
+// region: Baseline Implementations - Cosine Similarity
+
+fn baseline_cos_procedural(a: &[f32], b: &[f32]) -> f64 {
+    let mut dot = 0.0f32;
+    let mut norm_a = 0.0f32;
+    let mut norm_b = 0.0f32;
+    for i in 0..a.len() {
+        let (av, bv) = (a[i], b[i]);
+        dot += av * bv;
+        norm_a += av * av;
+        norm_b += bv * bv;
+    }
+    (1.0 - dot / (norm_a * norm_b).sqrt()) as f64
+}
+
+fn baseline_cos_functional(a: &[f32], b: &[f32]) -> f64 {
+    let (dot, norm_a, norm_b) = a
+        .iter()
+        .zip(b)
+        .map(|(a, b)| (*a * *b, *a * *a, *b * *b))
+        .fold((0.0f32, 0.0f32, 0.0f32), |acc, x| {
+            (acc.0 + x.0, acc.1 + x.1, acc.2 + x.2)
+        });
+    (1.0 - (dot / (norm_a.sqrt() * norm_b.sqrt()))) as f64
+}
+
+fn baseline_cos_unrolled(a: &[f32], b: &[f32]) -> f64 {
+    let mut i = 0;
+    let remainder = a.len() % 8;
+    let mut acc = [0.0f32; 8];
+    let mut norm_a = [0.0f32; 8];
+    let mut norm_b = [0.0f32; 8];
+
+    unsafe {
+        while i < a.len() - remainder {
+            let [a1, a2, a3, a4, a5, a6, a7, a8] = [
+                *a.get_unchecked(i),
+                *a.get_unchecked(i + 1),
+                *a.get_unchecked(i + 2),
+                *a.get_unchecked(i + 3),
+                *a.get_unchecked(i + 4),
+                *a.get_unchecked(i + 5),
+                *a.get_unchecked(i + 6),
+                *a.get_unchecked(i + 7),
+            ];
+            let [b1, b2, b3, b4, b5, b6, b7, b8] = [
+                *b.get_unchecked(i),
+                *b.get_unchecked(i + 1),
+                *b.get_unchecked(i + 2),
+                *b.get_unchecked(i + 3),
+                *b.get_unchecked(i + 4),
+                *b.get_unchecked(i + 5),
+                *b.get_unchecked(i + 6),
+                *b.get_unchecked(i + 7),
+            ];
+
+            acc[0] += a1 * b1;
+            acc[1] += a2 * b2;
+            acc[2] += a3 * b3;
+            acc[3] += a4 * b4;
+            acc[4] += a5 * b5;
+            acc[5] += a6 * b6;
+            acc[6] += a7 * b7;
+            acc[7] += a8 * b8;
+            norm_a[0] += a1 * a1;
+            norm_a[1] += a2 * a2;
+            norm_a[2] += a3 * a3;
+            norm_a[3] += a4 * a4;
+            norm_a[4] += a5 * a5;
+            norm_a[5] += a6 * a6;
+            norm_a[6] += a7 * a7;
+            norm_a[7] += a8 * a8;
+            norm_b[0] += b1 * b1;
+            norm_b[1] += b2 * b2;
+            norm_b[2] += b3 * b3;
+            norm_b[3] += b4 * b4;
+            norm_b[4] += b5 * b5;
+            norm_b[5] += b6 * b6;
+            norm_b[6] += b7 * b7;
+            norm_b[7] += b8 * b8;
+            i += 8;
+        }
+        while i < a.len() {
+            let (av, bv) = (*a.get_unchecked(i), *b.get_unchecked(i));
+            acc[0] += av * bv;
+            norm_a[0] += av * av;
+            norm_b[0] += bv * bv;
+            i += 1;
+        }
+    }
+
+    let dot: f32 = acc.iter().sum();
+    let na: f32 = norm_a.iter().sum();
+    let nb: f32 = norm_b.iter().sum();
+    (1.0 - (dot / (na.sqrt() * nb.sqrt()))) as f64
+}
+
+// endregion: Baseline Implementations - Cosine Similarity
+
+// region: Baseline Implementations - Squared Euclidean Distance
+
+fn baseline_l2sq_procedural(a: &[f32], b: &[f32]) -> f64 {
+    let mut sum = 0.0f32;
+    for i in 0..a.len() {
+        let diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+    sum as f64
+}
+
+fn baseline_l2sq_functional(a: &[f32], b: &[f32]) -> f64 {
+    a.iter()
+        .zip(b)
+        .map(|(x, y)| {
+            let diff = *x - *y;
+            diff * diff
+        })
+        .sum::<f32>() as f64
+}
+
+fn baseline_l2sq_unrolled(a: &[f32], b: &[f32]) -> f64 {
+    let mut i = 0;
+    let remainder = a.len() % 8;
+    let mut acc = [0.0f32; 8];
+
+    unsafe {
+        while i < a.len() - remainder {
+            let [a1, a2, a3, a4, a5, a6, a7, a8] = [
+                *a.get_unchecked(i),
+                *a.get_unchecked(i + 1),
+                *a.get_unchecked(i + 2),
+                *a.get_unchecked(i + 3),
+                *a.get_unchecked(i + 4),
+                *a.get_unchecked(i + 5),
+                *a.get_unchecked(i + 6),
+                *a.get_unchecked(i + 7),
+            ];
+            let [b1, b2, b3, b4, b5, b6, b7, b8] = [
+                *b.get_unchecked(i),
+                *b.get_unchecked(i + 1),
+                *b.get_unchecked(i + 2),
+                *b.get_unchecked(i + 3),
+                *b.get_unchecked(i + 4),
+                *b.get_unchecked(i + 5),
+                *b.get_unchecked(i + 6),
+                *b.get_unchecked(i + 7),
+            ];
+
+            let [d1, d2, d3, d4, d5, d6, d7, d8] = [
+                a1 - b1,
+                a2 - b2,
+                a3 - b3,
+                a4 - b4,
+                a5 - b5,
+                a6 - b6,
+                a7 - b7,
+                a8 - b8,
+            ];
+            acc[0] += d1 * d1;
+            acc[1] += d2 * d2;
+            acc[2] += d3 * d3;
+            acc[3] += d4 * d4;
+            acc[4] += d5 * d5;
+            acc[5] += d6 * d6;
+            acc[6] += d7 * d7;
+            acc[7] += d8 * d8;
+            i += 8;
+        }
+        while i < a.len() {
+            let diff = *a.get_unchecked(i) - *b.get_unchecked(i);
+            acc[0] += diff * diff;
+            i += 1;
+        }
+    }
+
+    acc.iter().sum::<f32>() as f64
+}
+
+// endregion: Baseline Implementations - Squared Euclidean Distance
+
+// region: Baseline Implementations - Dot Product
+
+fn baseline_dot_procedural(a: &[f32], b: &[f32]) -> f64 {
+    let mut sum = 0.0f32;
+    for i in 0..a.len() {
+        sum += a[i] * b[i];
+    }
+    -(sum as f64)
+}
+
+fn baseline_dot_functional(a: &[f32], b: &[f32]) -> f64 {
+    -(a.iter().zip(b).map(|(x, y)| *x * *y).sum::<f32>() as f64)
+}
+
+fn baseline_dot_unrolled(a: &[f32], b: &[f32]) -> f64 {
+    let mut i = 0;
+    let remainder = a.len() % 8;
+    let mut acc = [0.0f32; 8];
+
+    unsafe {
+        while i < a.len() - remainder {
+            let [a1, a2, a3, a4, a5, a6, a7, a8] = [
+                *a.get_unchecked(i),
+                *a.get_unchecked(i + 1),
+                *a.get_unchecked(i + 2),
+                *a.get_unchecked(i + 3),
+                *a.get_unchecked(i + 4),
+                *a.get_unchecked(i + 5),
+                *a.get_unchecked(i + 6),
+                *a.get_unchecked(i + 7),
+            ];
+            let [b1, b2, b3, b4, b5, b6, b7, b8] = [
+                *b.get_unchecked(i),
+                *b.get_unchecked(i + 1),
+                *b.get_unchecked(i + 2),
+                *b.get_unchecked(i + 3),
+                *b.get_unchecked(i + 4),
+                *b.get_unchecked(i + 5),
+                *b.get_unchecked(i + 6),
+                *b.get_unchecked(i + 7),
+            ];
+
+            acc[0] += a1 * b1;
+            acc[1] += a2 * b2;
+            acc[2] += a3 * b3;
+            acc[3] += a4 * b4;
+            acc[4] += a5 * b5;
+            acc[5] += a6 * b6;
+            acc[6] += a7 * b7;
+            acc[7] += a8 * b8;
+            i += 8;
+        }
+        while i < a.len() {
+            acc[0] += *a.get_unchecked(i) * *b.get_unchecked(i);
+            i += 1;
+        }
+    }
+
+    -(acc.iter().sum::<f32>() as f64)
+}
+
+// endregion: Baseline Implementations - Dot Product
+
+// region: Baseline Implementations - Euclidean Distance
+
+fn baseline_l2_procedural(a: &[f32], b: &[f32]) -> f64 {
+    baseline_l2sq_procedural(a, b).sqrt()
+}
+
+fn baseline_l2_functional(a: &[f32], b: &[f32]) -> f64 {
+    baseline_l2sq_functional(a, b).sqrt()
+}
+
+fn baseline_l2_unrolled(a: &[f32], b: &[f32]) -> f64 {
+    baseline_l2sq_unrolled(a, b).sqrt()
+}
+
+// endregion: Baseline Implementations - Euclidean Distance
+
+// region: Baseline Implementations - i8 (i8 -> f64)
+
+fn baseline_i8_cos_procedural(a: &[i8], b: &[i8]) -> f64 {
+    let mut dot = 0i32;
+    let mut norm_a = 0i32;
+    let mut norm_b = 0i32;
+    for i in 0..a.len() {
+        let (av, bv) = (a[i] as i32, b[i] as i32);
+        dot += av * bv;
+        norm_a += av * av;
+        norm_b += bv * bv;
+    }
+    let dot_f = dot as f32;
+    let norm_a_f = norm_a as f32;
+    let norm_b_f = norm_b as f32;
+    (1.0 - dot_f / (norm_a_f * norm_b_f).sqrt()) as f64
+}
+
+fn baseline_i8_dot_procedural(a: &[i8], b: &[i8]) -> f64 {
+    let mut sum = 0i32;
+    for i in 0..a.len() {
+        sum += (a[i] as i32) * (b[i] as i32);
+    }
+    -(sum as f64)
+}
+
+fn baseline_i8_l2sq_procedural(a: &[i8], b: &[i8]) -> f64 {
+    let mut sum = 0i32;
+    for i in 0..a.len() {
+        let diff = (a[i] - b[i]) as i32;
+        sum += diff * diff;
+    }
+    sum as f64
+}
+
+fn baseline_i8_l2_procedural(a: &[i8], b: &[i8]) -> f64 {
+    baseline_i8_l2sq_procedural(a, b).sqrt()
+}
+
+// endregion: Baseline Implementations - i8 (i8 -> f64)
+
+// region: Benchmark Functions
+
+pub fn f32_cosine_benchmark(c: &mut Criterion) {
+    let dimensions = get_dense_dimensions();
+    let bench_pairs_count = (128 * 1024 * 1024) / (dimensions * size_of::<f32>() * 2);
+    let bench_pairs: Vec<_> = (0..bench_pairs_count)
+        .map(|i| {
+            let mut rng = StdRng::seed_from_u64(1000 + i as u64);
+            let a: Vec<f32> = (0..dimensions).map(|_| rng.random()).collect();
+            let b: Vec<f32> = (0..dimensions).map(|_| rng.random()).collect();
+            (a, b)
+        })
+        .collect();
+
+    let accurate: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| accurate_cos(a, b))
+        .collect();
+    let procedural: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_cos_procedural(a, b))
+        .collect();
+    let functional: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_cos_functional(a, b))
+        .collect();
+    let unrolled: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_cos_unrolled(a, b))
+        .collect();
+    let simsimd: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| SimSIMD::cosine(a, b).unwrap())
+        .collect();
+
+    let simsimd_err = calculate_errors(&accurate, &simsimd);
+    let procedural_err = calculate_errors(&accurate, &procedural);
+    let functional_err = calculate_errors(&accurate, &functional);
+    let unrolled_err = calculate_errors(&accurate, &unrolled);
+
+    let mut group = c.benchmark_group(format!("f32/{}d/cosine", dimensions));
+    let bytes_per_op = (2 * dimensions * size_of::<f32>() * bench_pairs_count) as u64;
+    group.throughput(Throughput::Bytes(bytes_per_op));
+    group
+        .sample_size(50)
+        .measurement_time(Duration::from_secs(2))
+        .noise_threshold(0.05);
+
+    group.bench_function("simsimd", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(SimSIMD::cosine(a, b));
+            }
+        })
+    });
+    print_error(simsimd_err.0, simsimd_err.1);
+
+    group.bench_function("procedural", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_cos_procedural(a, b));
+            }
+        })
+    });
+    print_error(procedural_err.0, procedural_err.1);
+
+    group.bench_function("functional", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_cos_functional(a, b));
+            }
+        })
+    });
+    print_error(functional_err.0, functional_err.1);
+
+    group.bench_function("unrolled", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_cos_unrolled(a, b));
+            }
+        })
+    });
+    print_error(unrolled_err.0, unrolled_err.1);
+    group.finish();
+}
+
+pub fn f32_dot_benchmark(c: &mut Criterion) {
+    let dimensions = get_dense_dimensions();
+    let bench_pairs_count = (128 * 1024 * 1024) / (dimensions * size_of::<f32>() * 2);
+    let bench_pairs: Vec<_> = (0..bench_pairs_count)
+        .map(|i| {
+            let mut rng = StdRng::seed_from_u64(1000 + i as u64);
+            let a: Vec<f32> = (0..dimensions).map(|_| rng.random()).collect();
+            let b: Vec<f32> = (0..dimensions).map(|_| rng.random()).collect();
+            (a, b)
+        })
+        .collect();
+
+    let accurate: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| accurate_dot(a, b))
+        .collect();
+    let procedural: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_dot_procedural(a, b))
+        .collect();
+    let functional: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_dot_functional(a, b))
+        .collect();
+    let unrolled: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_dot_unrolled(a, b))
+        .collect();
+    let simsimd: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| SimSIMD::dot(a, b).unwrap())
+        .collect();
+
+    let simsimd_err = calculate_errors(&accurate, &simsimd);
+    let procedural_err = calculate_errors(&accurate, &procedural);
+    let functional_err = calculate_errors(&accurate, &functional);
+    let unrolled_err = calculate_errors(&accurate, &unrolled);
+
+    let mut group = c.benchmark_group(format!("f32/{}d/dot", dimensions));
+    let bytes_per_op = (2 * dimensions * size_of::<f32>() * bench_pairs_count) as u64;
+    group.throughput(Throughput::Bytes(bytes_per_op));
+    group
+        .sample_size(50)
+        .measurement_time(Duration::from_secs(2))
+        .noise_threshold(0.05);
+
+    group.bench_function("simsimd", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(SimSIMD::dot(a, b));
+            }
+        })
+    });
+    print_error(simsimd_err.0, simsimd_err.1);
+
+    group.bench_function("procedural", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_dot_procedural(a, b));
+            }
+        })
+    });
+    print_error(procedural_err.0, procedural_err.1);
+
+    group.bench_function("functional", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_dot_functional(a, b));
+            }
+        })
+    });
+    print_error(functional_err.0, functional_err.1);
+
+    group.bench_function("unrolled", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_dot_unrolled(a, b));
+            }
+        })
+    });
+    print_error(unrolled_err.0, unrolled_err.1);
+    group.finish();
+}
+
+pub fn f32_l2_benchmark(c: &mut Criterion) {
+    let dimensions = get_dense_dimensions();
+    let bench_pairs_count = (128 * 1024 * 1024) / (dimensions * size_of::<f32>() * 2);
+    let bench_pairs: Vec<_> = (0..bench_pairs_count)
+        .map(|i| {
+            let mut rng = StdRng::seed_from_u64(1000 + i as u64);
+            let a: Vec<f32> = (0..dimensions).map(|_| rng.random()).collect();
+            let b: Vec<f32> = (0..dimensions).map(|_| rng.random()).collect();
+            (a, b)
+        })
+        .collect();
+
+    let accurate: Vec<f64> = bench_pairs.iter().map(|(a, b)| accurate_l2(a, b)).collect();
+    let procedural: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_l2_procedural(a, b))
+        .collect();
+    let functional: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_l2_functional(a, b))
+        .collect();
+    let unrolled: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_l2_unrolled(a, b))
+        .collect();
+    let simsimd: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| SimSIMD::euclidean(a, b).unwrap())
+        .collect();
+
+    let simsimd_err = calculate_errors(&accurate, &simsimd);
+    let procedural_err = calculate_errors(&accurate, &procedural);
+    let functional_err = calculate_errors(&accurate, &functional);
+    let unrolled_err = calculate_errors(&accurate, &unrolled);
+
+    let mut group = c.benchmark_group(format!("f32/{}d/l2", dimensions));
+    let bytes_per_op = (2 * dimensions * size_of::<f32>() * bench_pairs_count) as u64;
+    group.throughput(Throughput::Bytes(bytes_per_op));
+    group
+        .sample_size(50)
+        .measurement_time(Duration::from_secs(2))
+        .noise_threshold(0.05);
+
+    group.bench_function("simsimd", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(SimSIMD::euclidean(a, b));
+            }
+        })
+    });
+    print_error(simsimd_err.0, simsimd_err.1);
+
+    group.bench_function("procedural", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_l2_procedural(a, b));
+            }
+        })
+    });
+    print_error(procedural_err.0, procedural_err.1);
+
+    group.bench_function("functional", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_l2_functional(a, b));
+            }
+        })
+    });
+    print_error(functional_err.0, functional_err.1);
+
+    group.bench_function("unrolled", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_l2_unrolled(a, b));
+            }
+        })
+    });
+    print_error(unrolled_err.0, unrolled_err.1);
+    group.finish();
+}
+
+pub fn i8_cosine_benchmark(c: &mut Criterion) {
+    let dimensions = get_dense_dimensions();
+    let bench_pairs_count = (128 * 1024 * 1024) / (dimensions * size_of::<i8>() * 2);
+    let bench_pairs: Vec<_> = (0..bench_pairs_count)
+        .map(|i| {
+            let mut rng = StdRng::seed_from_u64(1000 + i as u64);
+            let a: Vec<i8> = (0..dimensions).map(|_| rng.random()).collect();
+            let b: Vec<i8> = (0..dimensions).map(|_| rng.random()).collect();
+            (a, b)
+        })
+        .collect();
+
+    let accurate: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| accurate_i8_cos(a, b))
+        .collect();
+    let procedural: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_i8_cos_procedural(a, b))
+        .collect();
+    let simsimd: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| SimSIMD::cosine(a, b).unwrap())
+        .collect();
+
+    let simsimd_err = calculate_errors(&accurate, &simsimd);
+    let procedural_err = calculate_errors(&accurate, &procedural);
+
+    let mut group = c.benchmark_group(format!("i8/{}d/cosine", dimensions));
+    let bytes_per_op = (2 * dimensions * size_of::<i8>() * bench_pairs_count) as u64;
+    group.throughput(Throughput::Bytes(bytes_per_op));
+    group
+        .sample_size(50)
+        .measurement_time(Duration::from_secs(2))
+        .noise_threshold(0.05);
+
+    group.bench_function("simsimd", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(SimSIMD::cosine(a, b));
+            }
+        })
+    });
+    print_error(simsimd_err.0, simsimd_err.1);
+
+    group.bench_function("procedural", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_i8_cos_procedural(a, b));
+            }
+        })
+    });
+    print_error(procedural_err.0, procedural_err.1);
+    group.finish();
+}
+
+pub fn i8_dot_benchmark(c: &mut Criterion) {
+    let dimensions = get_dense_dimensions();
+    let bench_pairs_count = (128 * 1024 * 1024) / (dimensions * size_of::<i8>() * 2);
+    let bench_pairs: Vec<_> = (0..bench_pairs_count)
+        .map(|i| {
+            let mut rng = StdRng::seed_from_u64(1000 + i as u64);
+            let a: Vec<i8> = (0..dimensions).map(|_| rng.random()).collect();
+            let b: Vec<i8> = (0..dimensions).map(|_| rng.random()).collect();
+            (a, b)
+        })
+        .collect();
+
+    let accurate: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| accurate_i8_dot(a, b))
+        .collect();
+    let procedural: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_i8_dot_procedural(a, b))
+        .collect();
+    let simsimd: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| SimSIMD::dot(a, b).unwrap())
+        .collect();
+
+    let simsimd_err = calculate_errors(&accurate, &simsimd);
+    let procedural_err = calculate_errors(&accurate, &procedural);
+
+    let mut group = c.benchmark_group(format!("i8/{}d/dot", dimensions));
+    let bytes_per_op = (2 * dimensions * size_of::<i8>() * bench_pairs_count) as u64;
+    group.throughput(Throughput::Bytes(bytes_per_op));
+    group
+        .sample_size(50)
+        .measurement_time(Duration::from_secs(2))
+        .noise_threshold(0.05);
+
+    group.bench_function("simsimd", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(SimSIMD::dot(a, b));
+            }
+        })
+    });
+    print_error(simsimd_err.0, simsimd_err.1);
+
+    group.bench_function("procedural", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_i8_dot_procedural(a, b));
+            }
+        })
+    });
+    print_error(procedural_err.0, procedural_err.1);
+    group.finish();
+}
+
+pub fn i8_l2_benchmark(c: &mut Criterion) {
+    let dimensions = get_dense_dimensions();
+    let bench_pairs_count = (128 * 1024 * 1024) / (dimensions * size_of::<i8>() * 2);
+    let bench_pairs: Vec<_> = (0..bench_pairs_count)
+        .map(|i| {
+            let mut rng = StdRng::seed_from_u64(1000 + i as u64);
+            let a: Vec<i8> = (0..dimensions).map(|_| rng.random()).collect();
+            let b: Vec<i8> = (0..dimensions).map(|_| rng.random()).collect();
+            (a, b)
+        })
+        .collect();
+
+    let accurate: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| accurate_i8_l2(a, b))
+        .collect();
+    let procedural: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| baseline_i8_l2_procedural(a, b))
+        .collect();
+    let simsimd: Vec<f64> = bench_pairs
+        .iter()
+        .map(|(a, b)| SimSIMD::euclidean(a, b).unwrap())
+        .collect();
+
+    let simsimd_err = calculate_errors(&accurate, &simsimd);
+    let procedural_err = calculate_errors(&accurate, &procedural);
+
+    let mut group = c.benchmark_group(format!("i8/{}d/l2", dimensions));
+    let bytes_per_op = (2 * dimensions * size_of::<i8>() * bench_pairs_count) as u64;
+    group.throughput(Throughput::Bytes(bytes_per_op));
+    group
+        .sample_size(50)
+        .measurement_time(Duration::from_secs(2))
+        .noise_threshold(0.05);
+
+    group.bench_function("simsimd", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(SimSIMD::euclidean(a, b));
+            }
+        })
+    });
+    print_error(simsimd_err.0, simsimd_err.1);
+
+    group.bench_function("procedural", |b| {
+        b.iter(|| {
+            for (a, b) in &bench_pairs {
+                black_box(baseline_i8_l2_procedural(a, b));
+            }
+        })
+    });
+    print_error(procedural_err.0, procedural_err.1);
+    group.finish();
+}
+
+// endregion: Benchmark Functions
+
+fn custom_criterion() -> Criterion {
+    Criterion::default().without_plots().noise_threshold(0.05)
+}
+
+criterion_group! {
+    name = benches;
+    config = custom_criterion();
+    targets = f32_cosine_benchmark, f32_dot_benchmark, f32_l2_benchmark,
+              i8_cosine_benchmark, i8_dot_benchmark, i8_l2_benchmark
+}
+criterion_main!(benches);