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

//! BrickStats cycles and falsification tests.

use super::super::*;

#[test]
fn test_brick_stats_cycles() {
    let mut stats = BrickStats::new("test");
    stats.add_sample_with_cycles(1000, 100, 3000);

    assert_eq!(stats.total_cycles, 3000);
    assert!((stats.cycles_per_element() - 30.0).abs() < 0.001);
}

// FALSIFICATION TESTS

/// FALSIFICATION TEST: BrickId round-trip via name
#[test]
fn test_falsify_brick_id_round_trip() {
    for brick_id in [
        BrickId::RmsNorm,
        BrickId::LayerNorm,
        BrickId::QkvProjection,
        BrickId::RopeEmbedding,
        BrickId::AttentionScore,
        BrickId::AttentionSoftmax,
        BrickId::AttentionOutput,
        BrickId::OutputProjection,
        BrickId::GateProjection,
        BrickId::UpProjection,
        BrickId::Activation,
        BrickId::DownProjection,
        BrickId::Embedding,
        BrickId::LmHead,
        BrickId::Sampling,
    ] {
        let name = brick_id.name();
        let parsed = BrickId::from_str(name);
        assert_eq!(
            parsed,
            Some(brick_id),
            "FALSIFICATION FAILED: BrickId::{:?}.name() = {:?} does not round-trip",
            brick_id,
            name
        );
    }
}

/// FALSIFICATION TEST: ExecutionGraph maintains node/edge count consistency
#[test]
fn test_falsify_graph_consistency() {
    let mut graph = ExecutionGraph::new();

    // Add nodes and edges
    let n1 = graph.add_node(ExecutionNode::Layer { index: 0 });
    let n2 = graph.add_node(ExecutionNode::Layer { index: 1 });
    graph.add_edge(n1, n2, EdgeType::Sequence);

    assert_eq!(graph.num_nodes(), 2, "FALSIFICATION FAILED: node count mismatch");
    assert_eq!(graph.num_edges(), 1, "FALSIFICATION FAILED: edge count mismatch");

    // Clear and verify
    graph.clear();
    assert_eq!(graph.num_nodes(), 0, "FALSIFICATION FAILED: clear did not reset nodes");
    assert_eq!(graph.num_edges(), 0, "FALSIFICATION FAILED: clear did not reset edges");
}

/// FALSIFICATION TEST: BrickStats min/max tracking
#[test]
fn test_falsify_brick_stats_minmax() {
    let mut stats = BrickStats::new("test");

    for ns in [1000u64, 500, 2000, 750, 1500] {
        stats.add_sample(ns, 100);
    }

    assert_eq!(
        stats.min_ns, 500,
        "FALSIFICATION FAILED: min_ns should be 500, got {}",
        stats.min_ns
    );
    assert_eq!(
        stats.max_ns, 2000,
        "FALSIFICATION FAILED: max_ns should be 2000, got {}",
        stats.max_ns
    );
}