Merge pull request #518 from Bluemangoo/feature/top-tui-23

top: implement tui `2` `3` `c` `z`

Author: cakebaker

src/uu/top/src/header.rs

@@ -7,7 +7,7 @@ use crate::picker::sysinfo;
 use crate::platform::*;
 use crate::tui::stat::{CpuValueMode, TuiStat};
 use bytesize::ByteSize;
-use uu_vmstat::CpuLoad;
+use uu_vmstat::{CpuLoad, CpuLoadRaw};
 use uu_w::get_formatted_uptime_procps;
 use uucore::uptime::{get_formatted_loadavg, get_formatted_nusers, get_formatted_time};
 
@@ -119,8 +119,8 @@ fn user() -> String {
     get_formatted_nusers()
 }
 
-fn sum_cpu_loads(cpu_loads: &[uu_vmstat::CpuLoadRaw]) -> uu_vmstat::CpuLoadRaw {
-    let mut total = uu_vmstat::CpuLoadRaw {
+fn sum_cpu_loads(cpu_loads: Vec<&CpuLoadRaw>) -> CpuLoadRaw {
+    let mut total = CpuLoadRaw {
         user: 0,
         nice: 0,
         system: 0,
@@ -162,9 +162,38 @@ fn cpu(stat: &TuiStat) -> Vec<(String, CpuLoad)> {
             })
             .collect::<Vec<(String, CpuLoad)>>(),
         CpuValueMode::Sum => {
-            let total = sum_cpu_loads(&cpu_loads);
+            let total = sum_cpu_loads(cpu_loads.iter().collect());
             let cpu_load = CpuLoad::from_raw(&total);
             vec![(String::from("Cpu(s)"), cpu_load)]
         }
+        CpuValueMode::Numa => {
+            let numa_nodes = get_numa_nodes();
+            let total = sum_cpu_loads(cpu_loads.iter().collect());
+            let cpu_load = CpuLoad::from_raw(&total);
+            let mut data = vec![(String::from("Cpu(s)"), cpu_load)];
+            for (id, cores) in numa_nodes {
+                let loads = cores.iter().map(|id| &cpu_loads[*id]).collect();
+                let total = sum_cpu_loads(loads);
+                let cpu_load = CpuLoad::from_raw(&total);
+                data.push((format!("Node{id}"), cpu_load));
+            }
+            data
+        }
+        CpuValueMode::NumaNode(id) => {
+            let numa_nodes = get_numa_nodes();
+            if let Some(cores) = numa_nodes.get(&id) {
+                let loads = cores.iter().map(|id| &cpu_loads[*id]).collect();
+                let total = sum_cpu_loads(loads);
+                let cpu_load = CpuLoad::from_raw(&total);
+                let mut data = vec![(format!("Node{id}"), cpu_load)];
+                data.extend(cores.iter().map(|core_id| {
+                    let cpu_load = CpuLoad::from_raw(&cpu_loads[*core_id]);
+                    (format!("Cpu{core_id}"), cpu_load)
+                }));
+                data
+            } else {
+                vec![]
+            }
+        }
     }
 }

src/uu/top/src/picker.rs

@@ -3,6 +3,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::tui::stat::TuiStat;
+use crate::Settings;
 use std::{
     ffi::OsString,
     fs::File,
@@ -19,7 +21,10 @@ pub fn sysinfo() -> &'static RwLock<System> {
     SYSINFO.get_or_init(|| RwLock::new(System::new_all()))
 }
 
-pub(crate) fn pickers(fields: &[String]) -> Vec<Box<dyn Fn(u32) -> String>> {
+type Stat<'a> = (&'a Settings, &'a TuiStat);
+type Picker = Box<dyn Fn(u32, Stat) -> String>;
+
+pub(crate) fn pickers(fields: &[String]) -> Vec<Picker> {
     fields
         .iter()
         .map(|field| match field.as_str() {
@@ -41,7 +46,7 @@ pub(crate) fn pickers(fields: &[String]) -> Vec<Box<dyn Fn(u32) -> String>> {
 }
 
 #[inline]
-fn helper(f: impl Fn(u32) -> String + 'static) -> Box<dyn Fn(u32) -> String> {
+fn helper(f: impl Fn(u32, Stat) -> String + 'static) -> Picker {
     Box::new(f)
 }
 
@@ -55,11 +60,11 @@ fn format_memory(memory_b: u64) -> String {
     }
 }
 
-fn todo(_pid: u32) -> String {
+fn todo(_pid: u32, _stat: Stat) -> String {
     "TODO".into()
 }
 
-fn cpu(pid: u32) -> String {
+fn cpu(pid: u32, _stat: Stat) -> String {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
         return "0.0".into();
@@ -70,11 +75,11 @@ fn cpu(pid: u32) -> String {
     format!("{usage:.2}")
 }
 
-fn pid(pid: u32) -> String {
+fn pid(pid: u32, _stat: Stat) -> String {
     pid.to_string()
 }
 
-fn user(pid: u32) -> String {
+fn user(pid: u32, _stat: Stat) -> String {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
         return "0.0".into();
@@ -89,7 +94,7 @@ fn user(pid: u32) -> String {
 }
 
 #[cfg(target_os = "linux")]
-fn pr(pid: u32) -> String {
+fn pr(pid: u32, _stat: Stat) -> String {
     use uucore::libc::*;
     let policy = unsafe { sched_getscheduler(pid as i32) };
     if policy == -1 {
@@ -111,8 +116,8 @@ fn pr(pid: u32) -> String {
 }
 
 #[cfg(not(target_os = "linux"))]
-fn pr(pid: u32) -> String {
-    todo(pid)
+fn pr(pid: u32, stat: Stat) -> String {
+    todo(pid, stat)
 }
 
 #[cfg(not(target_os = "windows"))]
@@ -134,18 +139,18 @@ fn get_nice(pid: u32) -> i32 {
 }
 
 #[cfg(not(target_os = "windows"))]
-fn ni(pid: u32) -> String {
+fn ni(pid: u32, _stat: Stat) -> String {
     format!("{}", get_nice(pid))
 }
 
 // TODO: Implement this function for Windows
 #[cfg(target_os = "windows")]
-fn ni(_pid: u32) -> String {
+fn ni(_pid: u32, _stat: Stat) -> String {
     "0".into()
 }
 
 #[cfg(target_os = "linux")]
-fn virt(pid: u32) -> String {
+fn virt(pid: u32, _stat: Stat) -> String {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
         return "0.0".into();
@@ -154,12 +159,12 @@ fn virt(pid: u32) -> String {
 }
 
 #[cfg(not(target_os = "linux"))]
-fn virt(_pid: u32) -> String {
-    "TODO".into()
+fn virt(pid: u32, stat: Stat) -> String {
+    todo(pid, stat)
 }
 
 #[cfg(target_os = "linux")]
-fn res(pid: u32) -> String {
+fn res(pid: u32, _stat: Stat) -> String {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
         return "0.0".into();
@@ -168,12 +173,12 @@ fn res(pid: u32) -> String {
 }
 
 #[cfg(not(target_os = "linux"))]
-fn res(_pid: u32) -> String {
-    "TODO".into()
+fn res(pid: u32, stat: Stat) -> String {
+    todo(pid, stat)
 }
 
 #[cfg(target_os = "linux")]
-fn shr(pid: u32) -> String {
+fn shr(pid: u32, _stat: Stat) -> String {
     let file_path = format!("/proc/{pid}/statm");
     let Ok(file) = File::open(file_path) else {
         return "0.0".into();
@@ -189,11 +194,11 @@ fn shr(pid: u32) -> String {
 }
 
 #[cfg(not(target_os = "linux"))]
-fn shr(_pid: u32) -> String {
-    "TODO".into()
+fn shr(pid: u32, stat: Stat) -> String {
+    todo(pid, stat)
 }
 
-fn s(pid: u32) -> String {
+fn s(pid: u32, _stat: Stat) -> String {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
         return "?".into();
@@ -208,7 +213,7 @@ fn s(pid: u32) -> String {
         .to_string()
 }
 
-fn time_plus(pid: u32) -> String {
+fn time_plus(pid: u32, _stat: Stat) -> String {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
         return "0:00.00".into();
@@ -226,7 +231,7 @@ fn time_plus(pid: u32) -> String {
     format!("{hour}:{min:0>2}.{sec:0>2}")
 }
 
-fn mem(pid: u32) -> String {
+fn mem(pid: u32, _stat: Stat) -> String {
     let binding = sysinfo().read().unwrap();
     let Some(proc) = binding.process(Pid::from_u32(pid)) else {
         return "0.0".into();
@@ -238,7 +243,8 @@ fn mem(pid: u32) -> String {
     )
 }
 
-fn command(pid: u32) -> String {
+fn command(pid: u32, stat: Stat) -> String {
+    let full_command_line = stat.1.full_command_line;
     let f = |cmd: &[OsString]| -> String {
         let binding = cmd
             .iter()
@@ -250,6 +256,7 @@ fn command(pid: u32) -> String {
         let result: String = trimmed.into();
 
         if cfg!(target_os = "linux") && result.is_empty() {
+            // actually executable name
             let path = PathBuf::from_str(&format!("/proc/{pid}/status")).unwrap();
             if let Ok(file) = File::open(path) {
                 let content = read_to_string(file).unwrap();
@@ -276,8 +283,17 @@ fn command(pid: u32) -> String {
     };
 
     proc.exe()
-        .and_then(|it| it.iter().next_back())
-        .map(|it| it.to_str().unwrap())
-        .unwrap_or(&f(proc.cmd()))
-        .into()
+        .and_then(|it| {
+            if full_command_line {
+                it.iter().next_back()
+            } else {
+                it.file_name()
+            }
+        })
+        .map(|it| it.to_str().unwrap().to_string())
+        .unwrap_or(if full_command_line {
+            f(proc.cmd())
+        } else {
+            proc.name().to_str().unwrap().to_string()
+        })
 }

src/uu/top/src/platform/fallback.rs

@@ -7,6 +7,7 @@
 
 use crate::header::Memory;
 use crate::picker::sysinfo;
+use std::collections::HashMap;
 
 pub fn get_cpu_loads() -> Vec<uu_vmstat::CpuLoadRaw> {
     vec![]
@@ -26,3 +27,6 @@ pub fn get_memory() -> Memory {
         used_swap: binding.used_swap(),
     }
 }
+pub fn get_numa_nodes() -> HashMap<usize, Vec<usize>> {
+    HashMap::new()
+}

src/uu/top/src/platform/linux.rs

@@ -4,6 +4,7 @@
 // file that was distributed with this source code.
 
 use crate::header::Memory;
+use std::collections::HashMap;
 use std::str::FromStr;
 
 extern "C" {
@@ -92,3 +93,38 @@ pub fn get_memory() -> Memory {
         used_swap: mem_info.swap_total.0 - mem_info.swap_free.0,
     }
 }
+
+pub fn get_numa_nodes() -> HashMap<usize, Vec<usize>> {
+    let mut map = HashMap::new();
+    if let Ok(entries) = std::fs::read_dir("/sys/devices/system/node/") {
+        for entry in entries.flatten() {
+            let file_name = entry.file_name();
+            let file_name = file_name.to_string_lossy();
+            if file_name.starts_with("node") {
+                let node_id = file_name.trim_start_matches("node").parse::<usize>();
+                let node_id = match node_id {
+                    Ok(id) => id,
+                    Err(_) => continue,
+                };
+
+                let mut nodes = Vec::new();
+
+                if let Ok(node_entries) = std::fs::read_dir(entry.path()) {
+                    for node_entry in node_entries.flatten() {
+                        let cpu_file_name = node_entry.file_name();
+                        let cpu_file_name = cpu_file_name.to_string_lossy();
+                        if cpu_file_name.starts_with("cpu") {
+                            let cpu_id = cpu_file_name.trim_start_matches("cpu").parse::<usize>();
+                            if let Ok(cpu_id) = cpu_id {
+                                nodes.push(cpu_id);
+                            }
+                        }
+                    }
+                    nodes.sort();
+                    map.insert(node_id, nodes);
+                }
+            }
+        }
+    }
+    map
+}

src/uu/top/src/platform/mod.rs

@@ -11,7 +11,7 @@ pub mod windows;
 pub mod fallback;
 
 #[cfg(target_os = "linux")]
-pub use linux::{get_cpu_loads, get_memory, get_nusers_systemd};
+pub use linux::{get_cpu_loads, get_memory, get_numa_nodes, get_nusers_systemd};
 #[cfg(target_os = "windows")]
 pub use windows::get_cpu_loads;