Skip to content
TypeScript

perf(resource-monitor): Linux terminal process checks use a third of the CPU (#30381)

Jai Khuranaf63e23e9479e
diff --git a/native/resource-monitor/src/main.rs b/native/resource-monitor/src/main.rs
index a5876579500..ba60bbc7527 100644
--- a/native/resource-monitor/src/main.rs
+++ b/native/resource-monitor/src/main.rs
@@ -375,6 +375,35 @@ impl Collector {
self.cpu_baseline_refreshed_at = Some(Instant::now());
}
+ // Terminal polling asks for this every second while a shell is open. On
+ // Linux one read of /proc/<pid>/stat has everything; sysinfo also opens
+ // /proc/<pid>/status and builds a full record per process, ~3x the CPU.
+ #[cfg(target_os = "linux")]
+ fn process_table(&self) -> Vec<ProcessTableEntry> {
+ use std::io::Read;
+
+ let Ok(entries) = std::fs::read_dir("/proc") else {
+ return Vec::new();
+ };
+ let mut buffer = Vec::with_capacity(512);
+ let mut processes = entries
+ .filter_map(|entry| {
+ let entry = entry.ok()?;
+ let pid = entry.file_name().to_str()?.parse::<u32>().ok()?;
+ buffer.clear();
+ std::fs::File::open(entry.path().join("stat"))
+ .ok()?
+ .read_to_end(&mut buffer)
+ .ok()?;
+ let (name, ppid) = parse_proc_stat(&buffer)?;
+ Some(ProcessTableEntry { pid, ppid, name })
+ })
+ .collect::<Vec<_>>();
+ processes.sort_by_key(|process| process.pid);
+ processes
+ }
+
+ #[cfg(not(target_os = "linux"))]
fn process_table(&self) -> Vec<ProcessTableEntry> {
// A separate System preserves snapshot CPU baselines.
let mut process_table_system = System::new();
@@ -575,6 +604,24 @@ fn process_refresh_kind() -> ProcessRefreshKind {
.without_tasks()
}
+/// Name and parent pid from `/proc/<pid>/stat`: `pid (comm) state ppid ...`.
+/// The name may itself contain spaces and parentheses, so it ends at the last `)`.
+#[cfg(any(target_os = "linux", test))]
+fn parse_proc_stat(stat: &[u8]) -> Option<(String, u32)> {
+ let open = stat.iter().position(|&byte| byte == b'(')?;
+ let close = stat.iter().rposition(|&byte| byte == b')')?;
+ let name = stat.get(open + 1..close)?;
+ let mut fields = stat.get(close + 1..)?.split(|&byte| byte == b' ');
+ fields.next()?;
+ fields.next()?;
+ let ppid = std::str::from_utf8(fields.next()?).ok()?.parse().ok()?;
+ let name = truncate_utf8(
+ String::from_utf8_lossy(name).into_owned(),
+ MAX_PROCESS_NAME_BYTES,
+ );
+ Some((name, ppid))
+}
+
fn inaccessible_process_count(selected: usize, materialized: usize) -> usize {
selected.saturating_sub(materialized)
}
@@ -1338,6 +1385,43 @@ mod tests {
assert!(truncated.is_char_boundary(truncated.len()));
}
+ #[test]
+ fn parses_proc_stat_names_with_spaces_and_parentheses() {
+ assert_eq!(
+ parse_proc_stat(b"4242 (tmux: server) S 1 4242 4242 0 -1 4194560 3101"),
+ Some(("tmux: server".to_owned(), 1))
+ );
+ assert_eq!(
+ parse_proc_stat(b"77 (a) b (c)) R 4242 77 77 34816 77 4194304"),
+ Some(("a) b (c)".to_owned(), 4242))
+ );
+ assert_eq!(parse_proc_stat(b"77 (truncated"), None);
+ }
+
+ #[cfg(target_os = "linux")]
+ #[test]
+ fn linux_process_table_reports_own_process_like_sysinfo() {
+ let collector = Collector::new();
+ let mut system = System::new();
+ system.refresh_processes_specifics(
+ ProcessesToUpdate::All,
+ true,
+ ProcessRefreshKind::nothing().without_tasks(),
+ );
+ let own_pid = std::process::id();
+ let table = collector.process_table();
+ let own = table
+ .iter()
+ .find(|process| process.pid == own_pid)
+ .expect("own process");
+ let expected = system
+ .process(Pid::from_u32(own_pid))
+ .expect("sysinfo own process");
+ assert_eq!(own.ppid, expected.parent().map(Pid::as_u32).unwrap_or(0));
+ assert_eq!(own.name, expected.name().to_string_lossy());
+ assert!(table.windows(2).all(|pair| pair[0].pid < pair[1].pid));
+ }
+
#[test]
fn refreshes_commands_without_enumerating_linux_tasks() {
let refresh_kind = process_refresh_kind();