mltop 0.1.0

Resource monitor for ML engineers written in Rust
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

use crate::constants::BYTES_PER_GB_FLOAT;
use crate::data::components::gpu::Gpu;
use crate::widgets::percentage_bar::percentage_bar;

use ratatui::{
    buffer::Buffer,
    layout::{Alignment, Rect},
    style::{Color, Style},
    text::{Line, Span, Text},
    widgets::{Block, BorderType, Padding, Paragraph, Widget},
};

pub struct GpuWidget {
    data: Option<Gpu>,
}

impl GpuWidget {
    pub fn new(data: Option<Gpu>) -> GpuWidget {
        GpuWidget { data }
    }
}

impl Widget for GpuWidget {
    fn render(self, area: Rect, buf: &mut Buffer) {
        match &self.data {
            None => {
                let block = Block::bordered()
                    .border_type(BorderType::Rounded)
                    .padding(Padding::new(1, 1, 0, 0));
                Paragraph::new(Text::from("No GPU found."))
                    .centered()
                    .block(block)
                    .render(area, buf);
            }
            Some(gpu) => {
                let block = Block::bordered()
                    .title(format!(" {}", gpu.name.clone()))
                    .border_type(BorderType::Rounded)
                    .padding(Padding::new(1, 1, 0, 0));

                let mut spans = vec![Span::styled("TEMP:", Style::default().fg(Color::Cyan))];
                spans.push(Span::raw(format!(" {}°C", gpu.temperature)));

                spans.push(Span::styled("   POW:", Style::default().fg(Color::Cyan)));
                spans.push(Span::raw(format!(
                    " {} W / {} W",
                    gpu.power_usage / 1000,
                    gpu.max_power / 1000
                )));

                spans.push(Span::styled("   FAN:", Style::default().fg(Color::Cyan)));
                spans.push(Span::raw(format!("  {:.0}%", gpu.fan_speed)));

                let mut lines = vec![Line::from(spans).alignment(Alignment::Left)];

                let mut spans = vec![Span::styled("GPU", Style::default().fg(Color::Cyan))];
                let utilization = gpu.utilization.last().unwrap();
                spans.extend(percentage_bar(
                    area.width / 3 - 5,
                    *utilization as f32,
                    &format!("{}%", utilization),
                ));

                spans.push(Span::styled(" MEM", Style::default().fg(Color::Cyan)));
                let used = gpu.used_memory.last().unwrap();
                let mem_perc: f32 = (*used as f32 / gpu.max_memory as f32) * 100.0;
                spans.extend(percentage_bar(
                    area.width / 3 - 5,
                    mem_perc,
                    &format!(
                        "{:.2}Gi/{:.2}Gi",
                        (*used as f32) / BYTES_PER_GB_FLOAT,
                        (gpu.max_memory as f32) / BYTES_PER_GB_FLOAT
                    ),
                ));
                lines.push(Line::from(spans).alignment(Alignment::Left));

                let content = Text::from(lines);
                Paragraph::new(content)
                    .centered()
                    .block(block)
                    .render(area, buf);
            }
        }
    }
}