gpu-histop 0.1.0

High-resolution GPU history monitor for NVIDIA, AMDGPU, and Apple Silicon
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

use std::time::Instant;

#[derive(Debug, Clone)]
pub struct GpuInfo {
    pub id: usize,
    pub backend_index: u32,
    pub name: String,
    pub uuid: Option<String>,
}

#[derive(Debug, Clone)]
pub struct GpuSample {
    pub gpu_id: usize,
    pub at: Instant,
    pub gpu_util_percent: Option<f64>,
    pub mem_util_percent: Option<f64>,
    pub vram_used_bytes: Option<u64>,
    pub vram_total_bytes: Option<u64>,
    pub power_watts: Option<f64>,
    pub power_limit_watts: Option<f64>,
    pub temperature_celsius: Option<f64>,
    pub fan_percent: Option<f64>,
    pub graphics_clock_mhz: Option<f64>,
    pub memory_clock_mhz: Option<f64>,
    pub compute_processes: Option<u32>,
    pub processes: Vec<GpuProcess>,
}

impl GpuSample {
    pub fn vram_used_percent(&self) -> Option<f64> {
        let used = self.vram_used_bytes? as f64;
        let total = self.vram_total_bytes? as f64;
        (total > 0.0).then_some((used / total) * 100.0)
    }
}

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum GpuProcessKind {
    Compute,
    Graphics,
    Mps,
}

impl GpuProcessKind {
    pub fn label(self) -> &'static str {
        match self {
            Self::Compute => "C",
            Self::Graphics => "G",
            Self::Mps => "MPS",
        }
    }
}

#[derive(Debug, Clone)]
pub struct GpuProcess {
    pub pid: u32,
    pub user: Option<String>,
    pub command: Option<String>,
    pub kinds: Vec<GpuProcessKind>,
    pub used_gpu_memory_bytes: Option<u64>,
    pub gpu_instance_id: Option<u32>,
    pub compute_instance_id: Option<u32>,
}

impl GpuProcess {
    pub fn kind_label(&self) -> String {
        self.kinds
            .iter()
            .map(|kind| kind.label())
            .collect::<Vec<_>>()
            .join("+")
    }
}

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum MetricKind {
    GpuUtil,
    MemUtil,
    VramUsed,
    Power,
    Temperature,
    Fan,
}

impl MetricKind {
    pub const ALL: [Self; 6] = [
        Self::GpuUtil,
        Self::MemUtil,
        Self::VramUsed,
        Self::Power,
        Self::Temperature,
        Self::Fan,
    ];

    pub fn title(self) -> &'static str {
        match self {
            Self::GpuUtil => "GPU",
            Self::MemUtil => "MEM",
            Self::VramUsed => "VRAM",
            Self::Power => "POWER",
            Self::Temperature => "TEMP",
            Self::Fan => "FAN",
        }
    }

    pub fn unit(self) -> &'static str {
        match self {
            Self::GpuUtil | Self::MemUtil | Self::VramUsed | Self::Fan => "%",
            Self::Power => "W",
            Self::Temperature => "C",
        }
    }

    pub fn value(self, sample: &GpuSample) -> Option<f64> {
        match self {
            Self::GpuUtil => sample.gpu_util_percent,
            Self::MemUtil => sample.mem_util_percent,
            Self::VramUsed => sample.vram_used_percent(),
            Self::Power => sample.power_watts,
            Self::Temperature => sample.temperature_celsius,
            Self::Fan => sample.fan_percent,
        }
    }

    pub fn fixed_range(self, latest: Option<&GpuSample>) -> Option<(f64, f64)> {
        match self {
            Self::GpuUtil | Self::MemUtil | Self::VramUsed | Self::Fan => Some((0.0, 100.0)),
            Self::Temperature => Some((0.0, 100.0)),
            Self::Power => latest
                .and_then(|sample| sample.power_limit_watts)
                .map(|limit| (0.0, limit.max(1.0))),
        }
    }
}