amdgpu_top 0.11.3

Tool to displays AMDGPU usage. The tool displays information gathered from performance counters (GRBM, GRBM2), sensors, fdinfo, gpu_metrics and AMDGPU driver. 
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

use libamdgpu_top::{
    DevicePath,
    drmModePropType,
    // ConnectorInfo,
    ModeProp,
};

pub fn dump_all_drm_info(device_path_list: &[DevicePath]) {
    for device_path in device_path_list {
        dump_drm_info(device_path);
        println!();
    }
}

pub fn dump_drm_info(device_path: &DevicePath) {
    let vec_conn_info = libamdgpu_top::connector_info(device_path);
    let len = vec_conn_info.len() - 1;

    println!("\nNode: {:?}", device_path.card);

    for (i, conn) in vec_conn_info.iter().enumerate() {
        let last = i == len;

        println!(
            "{}───{}",
            if last { "└" } else { "├" },
            conn.name(),
        );

        if let Some(crtc) = conn.crtc {
            println!(
                "{}    ├───CRTC: {}x{}@{}",
                if last { " " } else { "│" },
                crtc.mode.hdisplay,
                crtc.mode.vdisplay,
                crtc.mode.refresh_rate(),
            );
        }

        if !conn.mode_info.is_empty() {
            println!("{}    ├───Modes", if last { " " } else { "│" });

            let mode_info_len = conn.mode_info.len() - 1;

            for (ii, mode) in conn.mode_info.iter().enumerate() {
                let last_mode_info = ii == mode_info_len;
                println!(
                    "{}    │    {}───{}x{}@{:.2}{}{}",
                    if last { " " } else { "│" },
                    if last_mode_info { "└" } else { "├" },
                    mode.hdisplay,
                    mode.vdisplay,
                    mode.refresh_rate(),
                    if mode.type_is_preferred() { " preferred" } else { "" },
                    if mode.type_is_driver() { " driver" } else { "" },
                );
            }
        }

        let props_len = conn.mode_props.len() - 1;

        for (j, mode_prop) in conn.mode_props.iter().enumerate() {
            let last_prop = j == props_len;
            dump_mode_prop(mode_prop, last, last_prop);
        }
    }
}

pub fn dump_mode_prop((mode_prop, value): &(ModeProp, u64), last: bool, last_prop: bool) {
    println!(
        "{}    {}───{:?}, id = {}, value: {}{}",
        if last { " " } else { "│" },
        if last_prop { "└" } else { "├" },
        mode_prop.name,
        mode_prop.prop_id,
        value,
        match mode_prop.prop_type {
            drmModePropType::BLOB => ", blob".to_string(),
            drmModePropType::RANGE => format!(", values: {:?}", mode_prop.values),
            drmModePropType::ENUM => {
                let enums = mode_prop.enums_string();

                format!(", enums: [{enums}]")
            },
            _ => "".to_string(),
        },
    );
}