`6de6ba9`

Add per-process disk I/O and network socket stats

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 6de6ba955f475200aa76dc7089dd3267c0e23660
Parents: 32386d7
Tree: 9450344

4 changed files

Status	File	+	-
M	`gartop-ipc/src/lib.rs`	14	0
M	`gartop/src/collector/process.rs`	96	17
M	`gartop/src/gui/app.rs`	6	3
M	`gartop/src/gui/process_list.rs`	81	15

gartop-ipc/src/lib.rsmodified

      #[default]
      Cpu,
      Memory,
++    DiskRead,
++    DiskWrite,
++    DiskTotal,
++    NetConnections,
      Pid,
      Name,
+ }
      pub rss: u64,
      /// Virtual memory size in bytes.
      pub vsize: u64,
++    /// Disk read bytes (cumulative).
++    pub io_read_bytes: u64,
++    /// Disk write bytes (cumulative).
++    pub io_write_bytes: u64,
++    /// Disk read rate in bytes/sec.
++    pub io_read_rate: f64,
++    /// Disk write rate in bytes/sec.
++    pub io_write_rate: f64,
++    /// Number of open network connections (TCP + UDP).
++    pub net_connections: u32,
      /// Process state.
      pub state: String,
      /// User owning the process.

gartop/src/collector/process.rsmodified

  use crate::error::{Error, Result};
  use gartop_ipc::{ProcessInfo, SortField};
--use procfs::process::{all_processes, Process};
++use procfs::process::{all_processes, FDTarget, Process};
  use procfs::{Current, CurrentSI};
  use std::collections::HashMap;
++use std::time::Instant;
++
++/// Previous process stats for delta calculations.
++struct PrevProcessStats {
++    /// Previous CPU time (utime + stime).
++    cpu_time: u64,
++    /// Previous system total CPU time.
++    system_time: u64,
++    /// Previous I/O read bytes.
++    io_read_bytes: u64,
++    /// Previous I/O write bytes.
++    io_write_bytes: u64,
++    /// Timestamp of previous sample.
++    timestamp: Instant,
++}
--/// Process collector with previous CPU times for percentage calculation.
++/// Process collector with previous stats for rate calculations.
  pub struct ProcessCollector {
--    /// Previous CPU times per PID for delta calculation.
++    /// Previous stats per PID for delta calculation.
--    prev_times: HashMap<i32, (u64, u64)>, // (utime + stime, total_system_time)
++    prev_stats: HashMap<i32, PrevProcessStats>,
      /// Total memory for percentage calculation.
      total_memory: u64,
+ }
          let meminfo = procfs::Meminfo::current()?;
          Ok(Self {
--            prev_times: HashMap::new(),
++            prev_stats: HashMap::new(),
              total_memory: meminfo.mem_total,
          })
+     }
          sort_by: SortField,
          limit: Option<usize>,
      ) -> Result<Vec<ProcessInfo>> {
++        let now = Instant::now();
          let kernel_stats = procfs::KernelStats::current()?;
          let total = &kernel_stats.total;
          let system_total = total.user
              let pid = proc.pid();
              current_pids.push(pid);
--            match self.process_info(&proc, system_total) {
++            match self.process_info(&proc, system_total, now) {
                  Ok(info) => processes.push(info),
                  Err(_) => continue, // Skip processes we can't read
+             }
+         }
          // Clean up old entries
--        self.prev_times.retain(|pid, _| current_pids.contains(pid));
++        self.prev_stats.retain(|pid, _| current_pids.contains(pid));
          // Sort
          match sort_by {
                      .partial_cmp(&a.memory_percent)
                      .unwrap_or(std::cmp::Ordering::Equal)
              }),
++            SortField::DiskRead => processes.sort_by(|a, b| {
++                b.io_read_rate
++                    .partial_cmp(&a.io_read_rate)
++                    .unwrap_or(std::cmp::Ordering::Equal)
++            }),
++            SortField::DiskWrite => processes.sort_by(|a, b| {
++                b.io_write_rate
++                    .partial_cmp(&a.io_write_rate)
++                    .unwrap_or(std::cmp::Ordering::Equal)
++            }),
++            SortField::DiskTotal => processes.sort_by(|a, b| {
++                let a_total = a.io_read_rate + a.io_write_rate;
++                let b_total = b.io_read_rate + b.io_write_rate;
++                b_total
++                    .partial_cmp(&a_total)
++                    .unwrap_or(std::cmp::Ordering::Equal)
++            }),
++            SortField::NetConnections => processes.sort_by(|a, b| {
++                b.net_connections.cmp(&a.net_connections)
++            }),
              SortField::Pid => processes.sort_by_key(|p| p.pid),
              SortField::Name => processes.sort_by(|a, b| a.name.cmp(&b.name)),
+         }
+     }
      /// Get info for a single process.
--    fn process_info(&mut self, proc: &Process, system_total: u64) -> Result<ProcessInfo> {
++    fn process_info(&mut self, proc: &Process, system_total: u64, now: Instant) -> Result<ProcessInfo> {
          let stat = proc.stat()?;
          let status = proc.status()?;
              .map(|v| v.join(" "))
              .unwrap_or_else(|_| name.clone());
--        // Calculate CPU percentage
++        // Get I/O stats (may fail for some processes due to permissions)
++        let (io_read_bytes, io_write_bytes) = proc
++            .io()
++            .map(|io| (io.read_bytes, io.write_bytes))
++            .unwrap_or((0, 0));
++
++        // Calculate CPU percentage and I/O rates from previous stats
          let proc_time = stat.utime + stat.stime;
--        let cpu_percent =
++        let (cpu_percent, io_read_rate, io_write_rate) =
--            if let Some((prev_proc_time, prev_sys_time)) = self.prev_times.get(&pid) {
++            if let Some(prev) = self.prev_stats.get(&pid) {
--                let proc_delta = proc_time.saturating_sub(*prev_proc_time);
++                let elapsed = now.duration_since(prev.timestamp).as_secs_f64();
--                let sys_delta = system_total.saturating_sub(*prev_sys_time);
++
--                if sys_delta > 0 {
++                // CPU percentage
++                let proc_delta = proc_time.saturating_sub(prev.cpu_time);
++                let sys_delta = system_total.saturating_sub(prev.system_time);
++                let cpu_pct = if sys_delta > 0 {
                      (proc_delta as f64 / sys_delta as f64) * 100.0
                  } else {
 .0
--                }
++                };
++
++                // I/O rates
++                let (read_rate, write_rate) = if elapsed > 0.0 {
++                    let read_delta = io_read_bytes.saturating_sub(prev.io_read_bytes) as f64;
++                    let write_delta = io_write_bytes.saturating_sub(prev.io_write_bytes) as f64;
++                    (read_delta / elapsed, write_delta / elapsed)
                  } else {
--                0.0
++                    (0.0, 0.0)
                  };
--        self.prev_times.insert(pid, (proc_time, system_total));
++
++                (cpu_pct, read_rate, write_rate)
++            } else {
++                (0.0, 0.0, 0.0)
++            };
++
++        // Store current stats for next calculation
++        self.prev_stats.insert(pid, PrevProcessStats {
++            cpu_time: proc_time,
++            system_time: system_total,
++            io_read_bytes,
++            io_write_bytes,
++            timestamp: now,
++        });
          // Memory
          let rss = stat.rss as u64 * 4096; // Pages to bytes
              .map(|u| u.name().to_string_lossy().to_string())
              .unwrap_or_else(|| status.ruid.to_string());
++        // Count network connections (sockets)
++        let net_connections = proc
++            .fd()
++            .map(|fds| {
++                fds.filter_map(|fd| fd.ok())
++                    .filter(|fd| matches!(fd.target, FDTarget::Socket(_)))
++                    .count() as u32
++            })
++            .unwrap_or(0);
++
          Ok(ProcessInfo {
              pid,
              name,
              memory_percent,
              rss,
              vsize,
++            io_read_bytes,
++            io_write_bytes,
++            io_read_rate,
++            io_write_rate,
++            net_connections,
              state,
              user,
          })

gartop/src/gui/app.rsmodified

          let sort_field = match self.tab_bar.active() {
              Tab::Cpu => SortField::Cpu,
              Tab::Memory => SortField::Memory,
--            Tab::Network | Tab::Disk => SortField::Cpu, // Default for I/O tabs
++            Tab::Network => SortField::NetConnections,
++            Tab::Disk => SortField::DiskTotal,
          };
          if let Some(resp) = self.send_command(&Command::GetProcesses {
              sort_by: Some(sort_field),
                  let sort_field = match tab {
                      Tab::Cpu => SortField::Cpu,
                      Tab::Memory => SortField::Memory,
--                    Tab::Network | Tab::Disk => SortField::Cpu,
++                    Tab::Network => SortField::NetConnections,
++                    Tab::Disk => SortField::DiskTotal,
                  };
                  self.process_list.set_sort(sort_field);
                  // Force refresh to get re-sorted processes
                              let sort_field = match new_tab {
                                  Tab::Cpu => SortField::Cpu,
                                  Tab::Memory => SortField::Memory,
--                                Tab::Network | Tab::Disk => SortField::Cpu,
++                                Tab::Network => SortField::NetConnections,
++                                Tab::Disk => SortField::DiskTotal,
                              };
                              self.process_list.set_sort(sort_field);
                              self.last_refresh = Instant::now() - std::time::Duration::from_secs(10);

gartop/src/gui/process_list.rsmodified

  use gartop_ipc::{ProcessInfo, SortField};
  use super::theme::Theme;
++/// Format rate (bytes/second) to human-readable compact string.
++fn format_rate(bytes_per_sec: f64) -> String {
++    const KIB: f64 = 1024.0;
++    const MIB: f64 = KIB * 1024.0;
++    const GIB: f64 = MIB * 1024.0;
++
++    if bytes_per_sec >= GIB {
++        format!("{:.1}G", bytes_per_sec / GIB)
++    } else if bytes_per_sec >= MIB {
++        format!("{:.1}M", bytes_per_sec / MIB)
++    } else if bytes_per_sec >= KIB {
++        format!("{:.0}K", bytes_per_sec / KIB)
++    } else if bytes_per_sec > 0.0 {
++        format!("{:.0}B", bytes_per_sec)
++    } else {
++        "0".to_string()
++    }
++}
++
  /// Row height for process list.
  const ROW_HEIGHT: u32 = 22;
              color: match self.sort_field {
                  SortField::Cpu => theme.cpu_color,
                  SortField::Memory => theme.memory_color,
++                SortField::DiskRead | SortField::DiskWrite | SortField::DiskTotal => theme.disk_color,
++                SortField::NetConnections => theme.network_color,
                  _ => theme.text_secondary,
              },
              ..header_style.clone()
          };
--        if self.sort_field == SortField::Cpu {
++        // Show different columns based on sort field
++        let is_disk_sort = matches!(self.sort_field, SortField::DiskRead | SortField::DiskWrite | SortField::DiskTotal);
++        let is_net_sort = matches!(self.sort_field, SortField::NetConnections);
++
++        if is_disk_sort {
++            renderer.text("Read/s", col_cpu, header_y, &sort_style)?;
++            renderer.text("Write/s", col_mem, header_y, &sort_style)?;
++        } else if is_net_sort {
++            renderer.text("Sockets", col_cpu, header_y, &sort_style)?;
++            renderer.text("Mem%", col_mem, header_y, &header_style)?;
++        } else if self.sort_field == SortField::Cpu {
              renderer.text("CPU%", col_cpu, header_y, &sort_style)?;
              renderer.text("Mem%", col_mem, header_y, &header_style)?;
          } else {
              };
              renderer.text(&name, col_name, text_y, &text_style)?;
++            // Show CPU/Memory or I/O or Network depending on sort field
++            if is_disk_sort {
++                // Read rate
++                let read_style = if process.io_read_rate > 1_000_000.0 {
++                    TextStyle { color: theme.disk_color, ..text_style.clone() }
++                } else {
++                    dim_style.clone()
++                };
++                renderer.text(&format_rate(process.io_read_rate), col_cpu, text_y, &read_style)?;
++
++                // Write rate
++                let write_style = if process.io_write_rate > 1_000_000.0 {
++                    TextStyle { color: theme.disk_color, ..text_style.clone() }
++                } else {
++                    dim_style.clone()
++                };
++                renderer.text(&format_rate(process.io_write_rate), col_mem, text_y, &write_style)?;
++            } else if is_net_sort {
++                // Socket count
++                let net_style = if process.net_connections > 10 {
++                    TextStyle { color: theme.network_color, ..text_style.clone() }
++                } else {
++                    dim_style.clone()
++                };
++                renderer.text(&process.net_connections.to_string(), col_cpu, text_y, &net_style)?;
++
++                // Memory %
++                let mem_style = if process.memory_percent > 10.0 {
++                    TextStyle { color: theme.memory_color, ..text_style.clone() }
++                } else {
++                    dim_style.clone()
++                };
++                renderer.text(&format!("{:.1}", process.memory_percent), col_mem, text_y, &mem_style)?;
++            } else {
                  // CPU %
                  let cpu_style = if process.cpu_percent > 50.0 {
                      TextStyle { color: theme.cpu_color, ..text_style.clone() }
                      dim_style.clone()
                  };
                  renderer.text(&format!("{:.1}", process.memory_percent), col_mem, text_y, &mem_style)?;
++            }
              // User
              let user = if process.user.len() > 10 {