luwen 0.8.5

A high-level interface for Tenstorrent AI accelerators
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

#![cfg(test)]

use serial_test::serial;

use luwen::api::ChipImpl;
use luwen::def::Arch;

/// Test utilities for verifying telemetry functionality
///
/// These tests verify:
/// - Chip telemetry collection
/// - Chip status reporting
/// - Chip architecture detection
/// - Chip-specific functionality (Wormhole, Blackhole)
///
/// Note: These tests require physical hardware to run. By default, they are
/// annotated with #[ignore] to avoid false failures on systems without hardware.
/// To run all hardware tests:
///
///   cargo test --test telem_test -- --ignored
///
/// The tests will automatically detect if compatible hardware is present;
/// if hardware is not found, the test will be skipped.
mod test_utils;

#[serial]
mod tests {
    use super::*;

    #[test]
    #[cfg_attr(
        not(all(feature = "test_hardware", feature = "test_wormhole")),
        ignore = "Requires real wormhole hardware"
    )]
    fn wormhole_test_chip_telemetry() {
        let partial_chips = luwen::pci::detect_chips_fallible().unwrap();
        assert!(!partial_chips.is_empty(), "Should find at least one chip");

        for chip in partial_chips {
            let upgraded_chip = chip.try_upgrade();
            if let Some(upgraded_chip) = upgraded_chip {
                // Only test Wormhole chips
                if let Some(wh) = upgraded_chip.as_wh() {
                    let status = chip.status();
                    println!("Wormhole chip status: {status:?}");

                    let eth_status = chip.eth_safe();
                    println!("Wormhole ethernet status: {eth_status:?}");

                    println!("Testing Wormhole chip");

                    if chip.arc_alive() {
                        let telemetry = wh.get_telemetry().unwrap();
                        println!("Wormhole board ID: {:X}", telemetry.board_id_low);
                        assert_ne!(telemetry.board_id_low, 0, "Board ID should be non-zero");
                    }

                    // Check remote status
                    println!("Wormhole remote status: {}", wh.is_remote);

                    // Print chip information
                    println!(
                        "Wormhole chip: {:?}, Status: {:?}, Ethernet: {:?}",
                        upgraded_chip.get_arch(),
                        status,
                        eth_status
                    );

                    // Verify that architecture is reported correctly
                    assert_eq!(
                        upgraded_chip.get_arch(),
                        Arch::Wormhole,
                        "Architecture should be Wormhole"
                    );
                }
            }
        }
    }

    #[test]
    #[cfg_attr(
        not(all(feature = "test_hardware", feature = "test_blackhole")),
        ignore = "Requires real blackhole hardware"
    )]
    fn blackhole_test_chip_telemetry() {
        let partial_chips = luwen::pci::detect_chips_fallible().unwrap();
        assert!(!partial_chips.is_empty(), "Should find at least one chip");

        for chip in partial_chips {
            let upgraded_chip = chip.try_upgrade();
            if let Some(upgraded_chip) = upgraded_chip {
                // Only test Blackhole chips
                if let Some(bh) = upgraded_chip.as_bh() {
                    let status = chip.status();
                    println!("Blackhole chip status: {status:?}");

                    let eth_status = chip.eth_safe();
                    println!("Blackhole ethernet status: {eth_status:?}");

                    println!("Testing Blackhole chip");

                    // Get telemetry twice to verify consistency
                    let telemetry1 = bh.get_telemetry().unwrap();
                    let telemetry2 = bh.get_telemetry().unwrap();

                    println!("Blackhole telemetry: {telemetry1:?}");
                    println!("Blackhole telemetry: {telemetry2:?}");

                    // Get subsystem ID
                    if let Some(subsystem) = bh
                        .get_if::<luwen::api::chip::NocInterface>()
                        .map(|v| &v.backing)
                        .and_then(|v| {
                            v.as_any().downcast_ref::<luwen::api::CallbackStorage<
                                    luwen::pci::ExtendedPciDeviceWrapper,
                                >>()
                        })
                        .map(|v| v.user_data.borrow().device.physical.subsystem_id)
                    {
                        println!("Blackhole subsystem ID: {subsystem:x}");
                        assert_ne!(subsystem, 0, "Subsystem ID should be non-zero");
                    }

                    // Print chip information
                    println!(
                        "Blackhole chip: {:?}, Status: {:?}, Ethernet: {:?}",
                        upgraded_chip.get_arch(),
                        status,
                        eth_status
                    );

                    // Verify that architecture is reported correctly
                    assert_eq!(
                        upgraded_chip.get_arch(),
                        Arch::Blackhole,
                        "Architecture should be Blackhole"
                    );
                }
            }
        }
    }
}