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'));
}
}