corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
use crate::model::process::{CpuResidency, ProcessSnapshot, ThreadSnapshot};
use anyhow::Result;
use std::{
    collections::HashMap,
    fs,
    path::{Path, PathBuf},
    time::SystemTime,
};

#[allow(dead_code)]
pub trait SchedulerObserver {
    fn process_cpu_residency(&self, pid: u32) -> Result<Option<CpuResidency>>;
}

pub type ParsedProcStat = (String, Option<char>, u64, u64, usize, u64, Option<u32>);

#[derive(Debug, Clone, Copy)]
struct ProcStat {
    utime: u64,
    stime: u64,
    threads: usize,
    rss_pages: u64,
    processor: Option<u32>,
}

pub fn parse_proc_pid_stat(line: &str) -> Result<ParsedProcStat> {
    let close = line
        .rfind(')')
        .ok_or_else(|| anyhow::anyhow!("missing process name delimiter"))?;
    let open = line[..close]
        .find('(')
        .ok_or_else(|| anyhow::anyhow!("missing process name delimiter"))?;
    let name = line[open + 1..close].to_owned();
    let fields: Vec<&str> = line[close + 1..].split_whitespace().collect();
    let value = |index: usize| fields.get(index).copied().unwrap_or_default();
    let state = value(0).chars().next();
    let utime = value(11).parse()?;
    let stime = value(12).parse()?;
    let threads = value(17).parse()?;
    let rss_pages = value(21).parse::<i64>()?.max(0) as u64;
    let processor = value(36).parse().ok();
    Ok((name, state, utime, stime, threads, rss_pages, processor))
}

fn parse_stat(line: &str) -> Result<ProcStat> {
    let (_, _, utime, stime, threads, rss_pages, processor) = parse_proc_pid_stat(line)?;
    Ok(ProcStat {
        utime,
        stime,
        threads,
        rss_pages,
        processor,
    })
}

#[derive(Debug, Clone)]
pub struct ProcessCollector {
    root: PathBuf,
    previous: HashMap<u32, u64>,
    previous_total: Option<u64>,
    pub last: Option<Vec<ProcessSnapshot>>,
}

impl Default for ProcessCollector {
    fn default() -> Self {
        Self::new("/proc")
    }
}
impl ProcessCollector {
    pub fn new(root: impl Into<PathBuf>) -> Self {
        Self {
            root: root.into(),
            previous: HashMap::new(),
            previous_total: None,
            last: None,
        }
    }

    pub fn collect(&mut self, cpu_count: usize) -> Result<Vec<ProcessSnapshot>> {
        let total = read_total_cpu_ticks(&fs::read_to_string(self.root.join("stat"))?);
        let total_delta = self.previous_total.and_then(|old| total.checked_sub(old));
        let mut current_ticks = HashMap::new();
        let mut processes = Vec::new();
        for entry in fs::read_dir(&self.root)?.flatten() {
            let Some(pid) = entry
                .file_name()
                .to_str()
                .and_then(|name| name.parse::<u32>().ok())
            else {
                continue;
            };
            let path = entry.path();
            let Ok(stat_line) = fs::read_to_string(path.join("stat")) else {
                continue;
            };
            let Ok(stat) = parse_stat(&stat_line) else {
                continue;
            };
            let ticks = stat.utime.saturating_add(stat.stime);
            current_ticks.insert(pid, ticks);
            let cpu_percent = self.previous.get(&pid).and_then(|old| {
                total_delta.and_then(|delta| {
                    ticks
                        .checked_sub(*old)
                        .filter(|_| delta > 0)
                        .map(|process_delta| {
                            process_delta as f64 / delta as f64 * cpu_count as f64 * 100.0
                        })
                })
            });
            let command_line = read_cmdline(&path);
            let name = stat_line[..stat_line.rfind(')').unwrap_or(stat_line.len())]
                .rsplit_once('(')
                .map(|(_, value)| value.to_owned())
                .unwrap_or_else(|| "?".into());
            let threads = read_threads(&path.join("task"));
            processes.push(ProcessSnapshot {
                pid,
                name: name.clone(),
                cpu_percent,
                rss_bytes: stat.rss_pages.saturating_mul(page_size()),
                thread_count: stat.threads.max(threads.len()),
                last_cpu: stat.processor,
                command_line: command_line.clone(),
                ollama_related: is_ollama_related(&name, &command_line),
                threads,
            });
        }
        processes.sort_by_key(|process| process.pid);
        self.previous = current_ticks;
        self.previous_total = Some(total);
        self.last = Some(processes.clone());
        Ok(processes)
    }
}

impl SchedulerObserver for ProcessCollector {
    fn process_cpu_residency(&self, pid: u32) -> Result<Option<CpuResidency>> {
        let path = self.root.join(pid.to_string()).join("stat");
        let Ok(line) = fs::read_to_string(path) else {
            return Ok(None);
        };
        Ok(Some(CpuResidency {
            last_cpu: parse_proc_pid_stat(&line)?.6,
            observed_at: SystemTime::now(),
        }))
    }
}

fn read_total_cpu_ticks(stat: &str) -> u64 {
    stat.lines()
        .find(|line| line.starts_with("cpu "))
        .map(|line| {
            line.split_whitespace()
                .skip(1)
                .filter_map(|value| value.parse::<u64>().ok())
                .fold(0, u64::saturating_add)
        })
        .unwrap_or_default()
}
fn read_cmdline(path: &Path) -> String {
    fs::read(path.join("cmdline"))
        .map(|bytes| {
            String::from_utf8_lossy(&bytes)
                .replace('\0', " ")
                .trim()
                .to_owned()
        })
        .unwrap_or_default()
}
fn read_threads(path: &Path) -> Vec<ThreadSnapshot> {
    fs::read_dir(path)
        .ok()
        .into_iter()
        .flatten()
        .filter_map(|entry| entry.ok())
        .filter_map(|entry| {
            let tid = entry.file_name().to_str()?.parse().ok()?;
            let line = fs::read_to_string(entry.path().join("stat")).ok()?;
            let (name, state, _, _, _, _, processor) = parse_proc_pid_stat(&line).ok()?;
            Some(ThreadSnapshot {
                tid,
                name,
                state,
                last_cpu: processor,
            })
        })
        .collect()
}
fn page_size() -> u64 {
    4096
}
fn is_ollama_related(name: &str, command_line: &str) -> bool {
    let value = format!("{} {}", name, command_line).to_lowercase();
    value.contains("ollama") || value.contains("llama")
}

#[cfg(test)]
mod tests {
    use super::parse_proc_pid_stat;
    #[test]
    fn parses_parentheses_in_name() {
        let line = "123 (worker (gpu)) R 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";
        let parsed = parse_proc_pid_stat(line).unwrap();
        assert_eq!(parsed.0, "worker (gpu)");
        assert_eq!(parsed.1, Some('R'));
    }
}