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.utime + self.stime) as f32
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             read_bytes: self.read_bytes.saturating_sub(self.old_read_bytes),

src/freebsd/process.rs

@@ -129,6 +129,10 @@ impl ProcessExt for Process {
         self.cpu_usage
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        FIXME
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes),

src/linux/process.rs

@@ -17,6 +17,8 @@ use crate::sys::utils::{
 use crate::utils::into_iter;
 use crate::{DiskUsage, Gid, Pid, ProcessExt, ProcessRefreshKind, ProcessStatus, Signal, Uid};
 
+const HZ: f32 = 100.;
+
 #[doc(hidden)]
 impl From<char> for ProcessStatus {
     fn from(status: char) -> ProcessStatus {
@@ -194,6 +196,10 @@ impl ProcessExt for Process {
         self.cpu_usage
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        self.utime.saturating_add(self.stime) as f32 / HZ
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes),
@@ -258,7 +264,7 @@ pub(crate) fn compute_cpu_usage(p: &mut Process, total_time: f32, max_value: f32
         .saturating_sub(p.old_utime)
         .saturating_add(p.stime.saturating_sub(p.old_stime)) as f32
         / total_time
-        * 100.)
+        * HZ)
         .min(max_value);
 
     for task in p.tasks.values_mut() {

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

@@ -599,6 +599,10 @@ impl ProcessExt for Process {
         self.cpu_usage
     }
 
+    fn total_accumulated_cpu_usage(&self) -> f32 {
+        FIXME
+    }
+
     fn disk_usage(&self) -> DiskUsage {
         DiskUsage {
             written_bytes: self.written_bytes.saturating_sub(self.old_written_bytes),