crabtop 0.1.0

Terminal-based Linux system monitor with CPU, memory, GPU and thermal metrics
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

pub mod cpu;
pub mod gpu;
pub mod mem;
pub mod temp;

use sysinfo::System;

use crate::history::History;
use cpu::CpuMetrics;
use gpu::{GpuCollector, GpuMetrics};
use mem::MemMetrics;
use temp::TempMetrics;

pub struct Collectors {
    system: System,
    gpu: GpuCollector,
}

impl Collectors {
    pub fn new() -> Self {
        let mut system = System::new();
        system.refresh_cpu_all();
        system.refresh_memory();
        Self {
            system,
            gpu: GpuCollector::new(),
        }
    }

    pub fn refresh(&mut self) {
        self.system.refresh_cpu_all();
        self.system.refresh_memory();
    }

    pub fn cpu(&self) -> CpuMetrics {
        cpu::collect(&self.system)
    }

    pub fn mem(&self) -> MemMetrics {
        mem::collect(&self.system)
    }

    pub fn temp(&self) -> TempMetrics {
        temp::collect()
    }

    pub fn gpu(&mut self) -> Vec<GpuMetrics> {
        self.gpu.collect()
    }
}

#[derive(Debug, Default)]
pub struct Snapshot {
    pub cpu: CpuMetrics,
    pub mem: MemMetrics,
    pub temp: TempMetrics,
    pub gpus: Vec<GpuMetrics>,
}

#[derive(Debug)]
pub struct Histories {
    pub cpu_total: History,
    pub cpu_per_core: Vec<History>,
    pub mem_used_pct: History,
    pub swap_used_pct: History,
    pub gpu_util: Vec<History>,
    pub gpu_vram_pct: Vec<History>,
    pub cpu_temp_max: History,
    capacity: usize,
}

impl Histories {
    pub fn new(capacity: usize) -> Self {
        Self {
            cpu_total: History::new(capacity),
            cpu_per_core: Vec::new(),
            mem_used_pct: History::new(capacity),
            swap_used_pct: History::new(capacity),
            gpu_util: Vec::new(),
            gpu_vram_pct: Vec::new(),
            cpu_temp_max: History::new(capacity),
            capacity,
        }
    }

    pub fn push(&mut self, snap: &Snapshot) {
        self.cpu_total.push(snap.cpu.total_usage as f64);

        if self.cpu_per_core.len() != snap.cpu.per_core.len() {
            self.cpu_per_core = (0..snap.cpu.per_core.len())
                .map(|_| History::new(self.capacity))
                .collect();
        }
        for (h, c) in self.cpu_per_core.iter_mut().zip(snap.cpu.per_core.iter()) {
            h.push(c.usage as f64);
        }

        self.mem_used_pct.push(snap.mem.ram_used_pct());
        self.swap_used_pct.push(snap.mem.swap_used_pct());

        if self.gpu_util.len() != snap.gpus.len() {
            self.gpu_util = (0..snap.gpus.len())
                .map(|_| History::new(self.capacity))
                .collect();
            self.gpu_vram_pct = (0..snap.gpus.len())
                .map(|_| History::new(self.capacity))
                .collect();
        }
        for (h, g) in self.gpu_util.iter_mut().zip(snap.gpus.iter()) {
            h.push(g.utilization_pct.unwrap_or(0.0) as f64);
        }
        for (h, g) in self.gpu_vram_pct.iter_mut().zip(snap.gpus.iter()) {
            h.push(g.vram_used_pct().unwrap_or(0.0));
        }

        let temp_max = snap
            .temp
            .cpu_sensors
            .iter()
            .map(|s| s.temp_c)
            .fold(f32::MIN, f32::max);
        if temp_max.is_finite() {
            self.cpu_temp_max.push(temp_max as f64);
        }
    }
}