Add support for total accumulated process CPU usage

src/apple/app_store/process.rs

@@ -68,6 +68,10 @@ impl ProcessExt for Process {
         0.0
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        0.0
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage::default()
     }

src/apple/cpu.rs

@@ -255,7 +255,7 @@ pub(crate) fn update_cpu_usage<F: FnOnce(Arc<CpuData>, *mut i32) -> (f32, usize)
     let mut cpu_info: *mut i32 = std::ptr::null_mut();
     let mut num_cpu_info = 0u32;
 
-    let mut total_cpu_usage = 0f32;
+    let mut total_accumulated_cpu_usage = 0f32;
 
     unsafe {
         if host_processor_info(
@@ -268,9 +268,9 @@ pub(crate) fn update_cpu_usage<F: FnOnce(Arc<CpuData>, *mut i32) -> (f32, usize)
         {
             let (total_percentage, len) =
                 f(Arc::new(CpuData::new(cpu_info, num_cpu_info)), cpu_info);
-            total_cpu_usage = total_percentage / len as f32;
+            total_accumulated_cpu_usage = total_percentage / len as f32;
         }
-        global_cpu.set_cpu_usage(total_cpu_usage);
+        global_cpu.set_cpu_usage(total_accumulated_cpu_usage);
     }
 }
 

src/apple/macos/process.rs

@@ -181,6 +181,10 @@ impl ProcessExt for Process {
         self.cpu_usage
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        self.old_utime.saturating_add(self.old_stime) as f32
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             read_bytes: self.read_bytes.saturating_sub(self.old_read_bytes),

src/freebsd/process.rs

@@ -54,6 +54,7 @@ pub struct Process {
     pub(crate) virtual_memory: u64,
     pub(crate) updated: bool,
     cpu_usage: f32,
+    accum_cpu_usage: f32,
     start_time: u64,
     run_time: u64,
     pub(crate) status: ProcessStatus,
@@ -129,6 +130,10 @@ impl ProcessExt for Process {
         self.cpu_usage
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        self.accum_cpu_usage
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes),
@@ -207,6 +212,11 @@ pub(crate) unsafe fn get_process_data(
     };
     let status = ProcessStatus::from(kproc.ki_stat);
 
+    // from FreeBSD source /bin/ps/print.c
+    let accum_cpu_usage = (kproc.ki_runtime as f64 / 1000000.0) as f32
+        + kproc.ki_childtime.tv_sec as f32
+        + kproc.ki_childtime.tv_usec as f32 / 1000000.0;
+
     // from FreeBSD source /src/usr.bin/top/machine.c
     let virtual_memory = kproc.ki_size as _;
     let memory = (kproc.ki_rssize as u64).saturating_mul(page_size as _);
@@ -275,6 +285,7 @@ pub(crate) unsafe fn get_process_data(
         start_time,
         run_time: now.saturating_sub(start_time),
         cpu_usage,
+        accum_cpu_usage,
         virtual_memory,
         memory,
         // procstat_getfiles

src/lib.rs

@@ -203,6 +203,8 @@ mod doctest {
 
 #[cfg(test)]
 mod test {
+    use std::collections::HashMap;
+
     use crate::*;
 
     #[cfg(feature = "unknown-ci")]
@@ -283,6 +285,42 @@ mod test {
             .any(|(_, proc_)| proc_.cpu_usage() > 0.0));
     }
 
+    #[test]
+    fn check_processes_total_accumulated_cpu_usage() {
+        if System::IS_SUPPORTED {
+            let mut s = System::new();
+
+            s.refresh_processes();
+            let all_procs: HashMap<_, _> = s
+                .processes()
+                .iter()
+                .map(|(pid, proc)| (*pid, proc.total_accumulated_cpu_usage()))
+                .collect();
+            // All accumulated CPU usages will be non-negative.
+            assert!(all_procs.values().all(|&usage| usage >= 0.0));
+
+            // Wait a bit to update CPU usage values
+            std::thread::sleep(System::MINIMUM_CPU_UPDATE_INTERVAL);
+            s.refresh_processes();
+            // They will still all be non-negative.
+            assert!(s
+                .processes()
+                .values()
+                .all(|proc| proc.total_accumulated_cpu_usage() >= 0.0));
+            // They will all have either remained the same or
+            // increased no more than a valid amount.
+            let max_delta =
+                s.cpus().len() as f32 * System::MINIMUM_CPU_UPDATE_INTERVAL.as_secs_f64() as f32;
+            assert!(s
+                .processes()
+                .iter()
+                .all(|(pid, proc)| all_procs.get(pid).map_or(true, |&prev| {
+                    let delta = proc.total_accumulated_cpu_usage() - prev;
+                    delta >= 0.0 && delta <= max_delta
+                })));
+        }
+    }
+
     #[test]
     fn check_cpu_usage() {
         if !System::IS_SUPPORTED {

src/linux/process.rs

@@ -194,6 +194,13 @@ impl ProcessExt for Process {
         self.cpu_usage
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        // The external values for CPU times are in "ticks", which are
+        // scaled by "HZ", which is pegged externally at 100
+        // ticks/second.
+        self.utime.saturating_add(self.stime) as f32 / 100.
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes),

src/traits.rs

@@ -375,6 +375,20 @@ pub trait ProcessExt: Debug {
     /// ```
     fn cpu_usage(&self) -> f32;
 
+    /// Returns the total accumulated CPU usage (in
+    /// CPU-seconds). Notice that it might be bigger than the total
+    /// clock run time of a process if run on a multi-core machine.
+    ///
+    /// ```no_run
+    /// use sysinfo::{Pid, ProcessExt, System, SystemExt};
+    ///
+    /// let s = System::new_all();
+    /// if let Some(process) = s.process(Pid::from(1337)) {
+    ///     println!("{}sec", process.total_accumulated_cpu_usage());
+    /// }
+    /// ```
+    fn total_accumulated_cpu_usage(&self) -> f32;
+
     /// Returns number of bytes read and written to disk.
     ///
     /// ⚠️ On Windows and FreeBSD, this method actually returns **ALL** I/O read and written bytes.

src/unknown/process.rs

@@ -78,6 +78,10 @@ impl ProcessExt for Process {
         0.0
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        0.0
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage::default()
     }

src/windows/process.rs

@@ -212,6 +212,7 @@ struct CPUsageCalculationValues {
     old_process_user_cpu: u64,
     old_system_sys_cpu: u64,
     old_system_user_cpu: u64,
+    nb_cpus: u64,
 }
 
 impl CPUsageCalculationValues {
@@ -221,8 +222,18 @@ impl CPUsageCalculationValues {
             old_process_user_cpu: 0,
             old_system_sys_cpu: 0,
             old_system_user_cpu: 0,
+            nb_cpus: 0,
         }
     }
+
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        self.old_process_user_cpu
+            .saturating_add(self.old_process_sys_cpu) as f32
+            / self
+                .old_system_user_cpu
+                .saturating_add(self.old_system_sys_cpu) as f32
+            * self.nb_cpus as f32
+    }
 }
 static WINDOWS_8_1_OR_NEWER: Lazy<bool> = Lazy::new(|| unsafe {
     let mut version_info: RTL_OSVERSIONINFOEXW = MaybeUninit::zeroed().assume_init();
@@ -599,6 +610,10 @@ impl ProcessExt for Process {
         self.cpu_usage
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        self.cpu_calc_values.total_accumulated_cpu_usage()
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes),
@@ -1108,6 +1123,7 @@ pub(crate) fn compute_cpu_usage(p: &mut Process, nb_cpus: u64) {
         p.cpu_calc_values.old_process_sys_cpu = sys;
         p.cpu_calc_values.old_system_user_cpu = global_user_time;
         p.cpu_calc_values.old_system_sys_cpu = global_kernel_time;
+        p.cpu_calc_values.nb_cpus = nb_cpus;
 
         let denominator = delta_global_user_time.saturating_add(delta_global_kernel_time) as f32;