mltop 0.6.2

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

use crate::config::Theme;
use crate::config::GRAPH_X_AXIS_WINDOW_IN_SECONDS;
use crate::data::store::{DataStore, StoredSnapshot};
use ratatui::layout::Constraint;

use ratatui::style::{Color, Style};
use ratatui::{
    buffer::Buffer,
    layout::Rect,
    symbols,
    widgets::{Axis, Block, BorderType, Chart, Dataset, GraphType, Widget},
};

pub struct LineGraphWidget<'a> {
    pub data: &'a DataStore,
    pub max_gpu_mem: Option<u64>,
    pub theme: &'a Theme,
}

impl<'a> Widget for LineGraphWidget<'a> {
    fn render(self, area: Rect, buf: &mut Buffer) {
        let mut datasets = vec![];

        let data: Vec<&StoredSnapshot> = self
            .data
            .snapshots
            .iter()
            .rev()
            .take(GRAPH_X_AXIS_WINDOW_IN_SECONDS)
            .rev()
            .collect();

        // GPU USE %
        let gpu_use_data: Vec<(f64, f64)> = data
            .iter()
            .filter_map(|s| s.gpu_use)
            .enumerate()
            .map(|(t, g)| (t as f64, g as f64))
            .collect();
        if !gpu_use_data.is_empty() {
            datasets.push(
                Dataset::default()
                    .name("GPU %")
                    .marker(symbols::Marker::Braille)
                    .style(Style::default().fg(self.theme.line_graph_gpu_use))
                    .graph_type(GraphType::Line)
                    .data(&gpu_use_data),
            );
        }

        // GPU MEM %
        let gpu_mem_data: Vec<(f64, f64)> = data
            .iter()
            .filter_map(|s| s.gpu_mem_use)
            .enumerate()
            .map(|(t, g)| {
                (
                    t as f64,
                    (g as f64 / self.max_gpu_mem.unwrap() as f64 * 100.0),
                )
            })
            .collect();
        if !gpu_mem_data.is_empty() {
            datasets.push(
                Dataset::default()
                    .name("GPU MEM%")
                    .marker(symbols::Marker::Braille)
                    .style(Style::default().fg(self.theme.line_graph_gpu_mem))
                    .graph_type(GraphType::Line)
                    .data(&gpu_mem_data),
            );
        }

        // CPU %
        let cpu_data: Vec<(f64, f64)> = data
            .iter()
            .enumerate()
            .map(|(t, s)| (t as f64, s.cpu_use as f64))
            .collect();
        datasets.push(
            Dataset::default()
                .name("CPU %")
                .marker(symbols::Marker::Braille)
                .style(Style::default().fg(self.theme.line_graph_cpu))
                .graph_type(GraphType::Line)
                .data(&cpu_data),
        );

        // MEM %
        let mem_data: Vec<(f64, f64)> = data
            .iter()
            .enumerate()
            .map(|(t, s)| (t as f64, s.mem_use * 100.0))
            .collect();
        datasets.push(
            Dataset::default()
                .name("MEM %")
                .marker(symbols::Marker::Braille)
                .style(Style::default().fg(self.theme.line_graph_mem))
                .graph_type(GraphType::Line)
                .data(&mem_data),
        );

        Chart::new(datasets)
            .block(Block::bordered().border_type(BorderType::Rounded))
            .x_axis(
                Axis::default()
                    .style(Style::default().fg(Color::Gray))
                    .bounds([0.0, 120.0])
                    .labels(["0", "120"]),
            )
            .y_axis(
                Axis::default()
                    .style(Style::default().fg(Color::Gray))
                    .bounds([0.0, 100.0])
                    .labels(["0", "100"]),
            )
            .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)))
            .render(area, buf);
    }
}