trueno 0.16.4

High-performance SIMD compute library with GPU support for matrix operations
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

use super::super::*;

// ========================================================================
// Profiler Tests
// ========================================================================

#[test]
fn test_profiler_records_timing() {
    let mut profiler = BlisProfiler::enabled();

    let n = 128;
    let a: Vec<f32> = vec![1.0; n * n];
    let b: Vec<f32> = vec![1.0; n * n];
    let mut c = vec![0.0; n * n];

    gemm_blis(n, n, n, &a, &b, &mut c, Some(&mut profiler)).unwrap();

    assert!(profiler.macro_stats.count > 0);
    assert!(profiler.macro_stats.flops > 0);
    assert!(profiler.micro_stats.count > 0);
}

#[test]
fn test_kaizen_metrics() {
    let mut metrics = KaizenMetrics::default();

    metrics.record(100, 100, 100, std::time::Duration::from_micros(100));

    assert_eq!(metrics.flops, 2_000_000); // 2 * 100^3
    assert!(metrics.gflops() > 0.0);
}

// ========================================================================
// Heijunka Tests
// ========================================================================

#[test]
fn test_heijunka_balanced_partition() {
    let scheduler = HeijunkaScheduler { num_threads: 4, variance_threshold: 0.05 };

    // Use m=288 which divides evenly into 4 blocks of MC=72
    let partitions = scheduler.partition_m(288, MC);

    // Should have 4 partitions
    assert_eq!(partitions.len(), 4);

    // Each partition should be exactly equal (72 rows each)
    let sizes: Vec<usize> = partitions.iter().map(|r| r.len()).collect();
    let avg = sizes.iter().sum::<usize>() as f32 / sizes.len() as f32;

    for size in &sizes {
        let variance = ((*size as f32 - avg) / avg).abs();
        assert!(variance < 0.01, "Partition variance too high: {}", variance);
    }

    // Also test uneven case - should still work
    let partitions_uneven = scheduler.partition_m(256, MC);
    assert_eq!(partitions_uneven.len(), 4);
    let total: usize = partitions_uneven.iter().map(|r| r.len()).sum();
    assert_eq!(total, 256); // All rows covered
}

#[test]
fn test_heijunka_single_thread() {
    let scheduler = HeijunkaScheduler { num_threads: 1, variance_threshold: 0.05 };
    let partitions = scheduler.partition_m(100, MC);
    assert_eq!(partitions.len(), 1);
    assert_eq!(partitions[0], 0..100);
}

#[test]
fn test_heijunka_more_threads_than_blocks() {
    let scheduler = HeijunkaScheduler { num_threads: 8, variance_threshold: 0.05 };
    // m=MC means 1 block but 8 threads — some threads get nothing
    let partitions = scheduler.partition_m(MC, MC);
    assert!(!partitions.is_empty());
    let total: usize = partitions.iter().map(|r| r.len()).sum();
    assert_eq!(total, MC);
}

#[test]
fn test_heijunka_default() {
    let scheduler = HeijunkaScheduler::default();
    assert!(scheduler.num_threads >= 1);
    assert!((scheduler.variance_threshold - 0.05).abs() < 1e-6);
}

#[test]
fn test_gemm_blis_parallel_small_matrix() {
    // Small matrix falls through to sequential gemm_blis
    let m = 10;
    let n = 10;
    let k = 10;
    let a: Vec<f32> = (0..m * k).map(|i| i as f32).collect();
    let b: Vec<f32> = vec![0.0; k * n];
    // Identity-like: b[i*n+i] = 1.0
    let mut b_mut = b;
    for i in 0..k.min(n) {
        b_mut[i * n + i] = 1.0;
    }
    let mut c = vec![0.0; m * n];

    gemm_blis_parallel(m, n, k, &a, &b_mut, &mut c).unwrap();
    // First row of C should match first row of A (for k<=n)
    for j in 0..k.min(n) {
        assert!((c[j] - a[j]).abs() < 1e-3, "c[{}] = {}, a[{}] = {}", j, c[j], j, a[j]);
    }
}

#[test]
fn test_gemm_blis_parallel_dimension_mismatch() {
    let mut c = vec![0.0; 4];
    // a.len() = 3 != m*k = 2*2 = 4
    let result = gemm_blis_parallel(2, 2, 2, &[1.0, 2.0, 3.0], &[1.0; 4], &mut c);
    assert!(result.is_err());
}