dotzilla 0.2.1

Native Rust implementation of efficient basic linear algebra routines
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// benches/benchmark.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use dotzilla::quantized::{quantize_normalized, quantized_dot_product};
use dotzilla::{dot_product, euclidean_distance};

fn bench_dot_product(c: &mut Criterion) {
    let len = 1024 * 1024;
    // f64 benchmark
    let a_f64: Vec<f64> = (0..len).map(|x| x as f64).collect();
    let b_f64: Vec<f64> = (0..len).map(|x| (x as f64).sin()).collect();
    // f32 benchmark
    let a_f32: Vec<f32> = (0..len).map(|x| x as f32).collect();
    let b_f32: Vec<f32> = (0..len).map(|x| (x as f32).sin()).collect();
    // Quantized
    let a_q = quantize_normalized(&a_f32);
    let b_q = quantize_normalized(&b_f32);

    c.bench_function("dot_product_f64", |bench| {
        bench.iter(|| dot_product(black_box(&a_f64), black_box(&b_f64)))
    });
    c.bench_function("dot_product_f32", |bench| {
        bench.iter(|| dot_product(black_box(&a_f32), black_box(&b_f32)))
    });
    c.bench_function("dot_product_quantized", |bench| {
        bench.iter(|| quantized_dot_product(black_box(&a_q), black_box(&b_q)))
    });
}

fn bench_euclidean_distance(c: &mut Criterion) {
    let len = 1024 * 1024;
    // f64 benchmark
    let a_f64: Vec<f64> = (0..len).map(|x| x as f64).collect();
    let b_f64: Vec<f64> = (0..len).map(|x| (x as f64).sin()).collect();
    // f32 benchmark
    let a_f32: Vec<f32> = (0..len).map(|x| x as f32).collect();
    let b_f32: Vec<f32> = (0..len).map(|x| (x as f32).sin()).collect();

    // Dedicated euclidean distance implementations
    c.bench_function("euclidean_distance_f64_dedicated", |bench| {
        bench.iter(|| euclidean_distance(black_box(&a_f64), black_box(&b_f64)))
    });

    c.bench_function("euclidean_distance_f32_dedicated", |bench| {
        bench.iter(|| euclidean_distance(black_box(&a_f32), black_box(&b_f32)))
    });

    // Euclidean distance via dot products (f64)
    c.bench_function("euclidean_distance_f64_via_dots", |bench| {
        bench.iter(|| {
            let a = black_box(&a_f64);
            let b = black_box(&b_f64);
            let a_dot_a = dot_product(a, a);
            let b_dot_b = dot_product(b, b);
            let a_dot_b = dot_product(a, b);
            (a_dot_a + b_dot_b - 2.0 * a_dot_b).sqrt()
        })
    });

    // Euclidean distance via dot products (f32)
    c.bench_function("euclidean_distance_f32_via_dots", |bench| {
        bench.iter(|| {
            let a = black_box(&a_f32);
            let b = black_box(&b_f32);
            let a_dot_a = dot_product(a, a);
            let b_dot_b = dot_product(b, b);
            let a_dot_b = dot_product(a, b);
            (a_dot_a + b_dot_b - 2.0 * a_dot_b).sqrt()
        })
    });
}

fn bench_euclidean_distance_small(c: &mut Criterion) {
    // Test with smaller vectors to see if the pattern holds
    let len = 512;
    let a_f64: Vec<f64> = (0..len).map(|x| x as f64).collect();
    let b_f64: Vec<f64> = (0..len).map(|x| (x as f64).sin()).collect();
    let a_f32: Vec<f32> = (0..len).map(|x| x as f32).collect();
    let b_f32: Vec<f32> = (0..len).map(|x| (x as f32).sin()).collect();

    c.bench_function("euclidean_distance_f64_dedicated_small", |bench| {
        bench.iter(|| euclidean_distance(black_box(&a_f64), black_box(&b_f64)))
    });

    c.bench_function("euclidean_distance_f32_dedicated_small", |bench| {
        bench.iter(|| euclidean_distance(black_box(&a_f32), black_box(&b_f32)))
    });

    c.bench_function("euclidean_distance_f64_via_dots_small", |bench| {
        bench.iter(|| {
            let a = black_box(&a_f64);
            let b = black_box(&b_f64);
            let a_dot_a = dot_product(a, a);
            let b_dot_b = dot_product(b, b);
            let a_dot_b = dot_product(a, b);
            (a_dot_a + b_dot_b - 2.0 * a_dot_b).sqrt()
        })
    });

    c.bench_function("euclidean_distance_f32_via_dots_small", |bench| {
        bench.iter(|| {
            let a = black_box(&a_f32);
            let b = black_box(&b_f32);
            let a_dot_a = dot_product(a, a);
            let b_dot_b = dot_product(b, b);
            let a_dot_b = dot_product(a, b);
            (a_dot_a + b_dot_b - 2.0 * a_dot_b).sqrt()
        })
    });
}

criterion_group!(
    benches,
    bench_dot_product,
    bench_euclidean_distance,
    bench_euclidean_distance_small
);
criterion_main!(benches);