aprender-gpu 0.32.0

Pure Rust PTX generation for NVIDIA CUDA - no LLVM, no nvcc
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! TileError Display, Error trait, and GpuError conversion tests

use super::*;

// ========== Display and Error trait tests ==========

#[test]
fn test_tile_error_display_too_many_elements() {
    let err = TileError::TooManyElements {
        actual: 20_000_000,
        max: 16_777_216,
    };
    let msg = err.to_string();
    assert!(
        msg.contains("20000000"),
        "Should contain actual count: {}",
        msg
    );
    assert!(
        msg.contains("16777216"),
        "Should contain max count: {}",
        msg
    );
    assert!(
        msg.contains("too many elements"),
        "Should describe the error: {}",
        msg
    );
}

#[test]
fn test_tile_error_display_dimension_too_large() {
    let err = TileError::DimensionTooLarge {
        actual: 8192,
        max: 4096,
    };
    let msg = err.to_string();
    assert!(
        msg.contains("8192"),
        "Should contain actual dimension: {}",
        msg
    );
    assert!(
        msg.contains("4096"),
        "Should contain max dimension: {}",
        msg
    );
    assert!(
        msg.contains("exceeds"),
        "Should describe the error: {}",
        msg
    );
}

#[test]
fn test_tile_error_display_invalid_wmma_shape() {
    let err = TileError::InvalidWmmaShape {
        shape: "m64n64k64".to_string(),
    };
    let msg = err.to_string();
    assert!(msg.contains("m64n64k64"), "Should contain shape: {}", msg);
    assert!(
        msg.contains("Invalid WMMA"),
        "Should describe the error: {}",
        msg
    );
}

#[test]
fn test_tile_error_display_non_power_of_two() {
    let err = TileError::NonPowerOfTwo { dim: 123 };
    let msg = err.to_string();
    assert!(msg.contains("123"), "Should contain dimension: {}", msg);
    assert!(
        msg.contains("power of two"),
        "Should describe the error: {}",
        msg
    );
}

#[test]
fn test_tile_error_implements_std_error() {
    let err = TileError::NonPowerOfTwo { dim: 42 };
    // Verify Error trait is implemented (source() returns None by default)
    let std_err: &dyn std::error::Error = &err;
    assert!(std_err.source().is_none());
}

#[test]
fn test_tile_error_to_gpu_error_conversion() {
    let tile_err = TileError::TooManyElements {
        actual: 100,
        max: 50,
    };
    let gpu_err: GpuError = tile_err.clone().into();

    // Verify conversion produces InvalidParameter variant with the error message
    match gpu_err {
        GpuError::InvalidParameter(msg) => {
            assert!(msg.contains("100"), "Should contain actual: {}", msg);
            assert!(msg.contains("50"), "Should contain max: {}", msg);
        }
        _ => panic!("Expected InvalidParameter variant"),
    }
}

#[test]
fn test_tile_error_conversion_non_power_of_two() {
    let tile_err = TileError::NonPowerOfTwo { dim: 37 };
    let gpu_err: GpuError = tile_err.into();

    match gpu_err {
        GpuError::InvalidParameter(msg) => {
            assert!(msg.contains("37"));
            assert!(msg.contains("power of two"));
        }
        _ => panic!("Expected InvalidParameter"),
    }
}

#[test]
fn test_tile_error_conversion_dimension_too_large() {
    let tile_err = TileError::DimensionTooLarge {
        actual: 10000,
        max: 4096,
    };
    let gpu_err: GpuError = tile_err.into();

    match gpu_err {
        GpuError::InvalidParameter(msg) => {
            assert!(msg.contains("10000"));
            assert!(msg.contains("4096"));
        }
        _ => panic!("Expected InvalidParameter"),
    }
}

#[test]
fn test_tile_error_conversion_invalid_wmma() {
    let tile_err = TileError::InvalidWmmaShape {
        shape: "m99n99k99".to_string(),
    };
    let gpu_err: GpuError = tile_err.into();

    match gpu_err {
        GpuError::InvalidParameter(msg) => {
            assert!(msg.contains("m99n99k99"));
        }
        _ => panic!("Expected InvalidParameter"),
    }
}