trueno 0.18.0

High-performance SIMD compute library with GPU support, LLM inference engine, and GGUF model loading
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

use crate::vector::Vector;
use crate::{Backend, TruenoError};

mod backend;
mod individual;
mod relu_dispatch;
mod softmax;

type ActFn = fn(&Vector<f32>) -> Result<Vector<f32>, TruenoError>;

/// Assert that an activation produces expected element-wise results on a given backend.
fn assert_activation_elementwise(
    data: &[f32],
    backend: Backend,
    activation_fn: ActFn,
    expected_fn: fn(f32) -> f32,
    tolerance: f32,
    label: &str,
) {
    let v = Vector::from_slice_with_backend(data, backend);
    let result = activation_fn(&v).unwrap();
    for (i, &val) in result.as_slice().iter().enumerate() {
        let exp = expected_fn(data[i]);
        assert!(
            (val - exp).abs() < tolerance,
            "{label} {backend:?} mismatch at index {i}: got {val} expected {exp}",
        );
    }
}

/// Assert that an activation on a given backend produces values within a range.
fn assert_activation_in_range(
    data: &[f32],
    backend: Backend,
    activation_fn: ActFn,
    lo: f32,
    hi: f32,
    label: &str,
) {
    let v = Vector::from_slice_with_backend(data, backend);
    let result = activation_fn(&v).unwrap();
    for &val in result.as_slice() {
        assert!(val >= lo && val <= hi, "{label} {backend:?} out of range [{lo}, {hi}]: {val}");
    }
}

/// Assert that an activation at a specific index equals an expected value.
fn assert_activation_at(
    data: &[f32],
    backend: Backend,
    activation_fn: ActFn,
    index: usize,
    expected: f32,
    tolerance: f32,
    label: &str,
) {
    let v = Vector::from_slice_with_backend(data, backend);
    let result = activation_fn(&v).unwrap();
    let got = result.as_slice()[index];
    assert!(
        (got - expected).abs() < tolerance,
        "{label} {backend:?} at index {index}: got {got} expected {expected}",
    );
}

/// Assert backend equivalence: compare Scalar result with SSE2 and AVX2.
#[cfg(target_arch = "x86_64")]
fn assert_backend_equivalence(data: &[f32], activation_fn: ActFn, tolerance: f32, label: &str) {
    let scalar = activation_fn(&Vector::from_slice_with_backend(data, Backend::Scalar)).unwrap();
    for &backend in &[Backend::SSE2] {
        let other = activation_fn(&Vector::from_slice_with_backend(data, backend)).unwrap();
        for (i, (&s, &x)) in scalar.as_slice().iter().zip(other.as_slice().iter()).enumerate() {
            assert!(
                (s - x).abs() < tolerance,
                "Scalar vs {backend:?} {label} mismatch at {i}: {s} vs {x}"
            );
        }
    }
    if is_x86_feature_detected!("avx2") {
        let avx2 = activation_fn(&Vector::from_slice_with_backend(data, Backend::AVX2)).unwrap();
        for (i, (&s, &x)) in scalar.as_slice().iter().zip(avx2.as_slice().iter()).enumerate() {
            assert!(
                (s - x).abs() < tolerance,
                "Scalar vs AVX2 {label} mismatch at {i}: {s} vs {x}"
            );
        }
    }
}

// Activation adapters: wrap method calls as fn pointers for helpers.
fn act_relu(v: &Vector<f32>) -> Result<Vector<f32>, TruenoError> {
    v.relu()
}
fn act_sigmoid(v: &Vector<f32>) -> Result<Vector<f32>, TruenoError> {
    v.sigmoid()
}
fn act_gelu(v: &Vector<f32>) -> Result<Vector<f32>, TruenoError> {
    v.gelu()
}
fn act_swish(v: &Vector<f32>) -> Result<Vector<f32>, TruenoError> {
    v.swish()
}

/// Activation spec for parametric tests: (adapter, label, zero_output).
fn activation_specs() -> [(ActFn, &'static str, f32); 4] {
    [
        (act_relu, "relu", 0.0),
        (act_sigmoid, "sigmoid", 0.5),
        (act_gelu, "gelu", 0.0),
        (act_swish, "swish", 0.0),
    ]
}