Merge pull request #6 from mcmindcoder/master

Add process struct

Author: GrbavaCigla

include/psutil-cpp/cpu.hpp

@@ -2,13 +2,55 @@
 #include <vector>
 #include <ostream>
 #include <optional>
+#include <chrono>
 
 #include "psutil-cpp/utils.hpp"
 
 #ifdef linux
 #include <unistd.h>
 #endif
 
+using PID = uint32_t;
+using PTime = std::chrono::system_clock::time_point;
+
+/**
+ * Represents single system process and CPU related data for this process
+ */
+struct process {
+  process() = default;
+
+  explicit process(PID pid);
+
+  PID pid{0};                    // field[0]
+  std::string name;              // field[1]
+  std::string path;
+  std::string cmdline_cmd;
+  bool exists{false};
+  PTime time;
+  char status{0};                // field[2]
+  PID ppid{0};                   // field[3]
+  uint32_t ttynr{0};             // field[6]
+  float utime{0};                // field[13]
+  float stime{0};                // field[14]
+  float children_utime{0};       // field[15]
+  float children_stime{0};       // field[16]
+  float create_time{0};          // field[21]
+  uint8_t cpu_num{0};            // field[38]
+  uint32_t blkio_ticks{0};       // field[41]  # aka 'delayacct_blkio_ticks'
+  float iowait{0};               // calculated
+  float cpu_percent{0};          // calculated
+  // stores previous values
+  float last_stime{-1};
+  float last_utime{-1};
+  PTime last_time;
+
+  void reset();
+
+  void update(PID pid);
+
+  float get_cpu_percent(uint32_t interval_mlsec = 0);
+};
+
 struct scputimes
 {
     float user;

include/psutil-cpp/utils.hpp

@@ -50,9 +50,9 @@ std::vector<std::string> cat(std::string path);
 // Returns valid path for cpu_freq
 std::string get_path(int num);
 
-void sleep_mlsec(uint32_t millisec);
+void sleep_mlsec(uint32_t mlsec);
 
-bool is_only_numbers(const std::string &str);
+bool has_only_numbers(const std::string &str);
 
 std::vector<std::string> get_dirs_list(const std::string &path);
 

src/cpu.cpp

@@ -1,4 +1,8 @@
 #include <psutil-cpp/cpu.hpp>
+#include <iostream>
+#include <cassert>
+
+#define MUTE_PSUTIL_LOGS
 
 std::optional<std::vector<scputimes>> cpu_times(bool percpu)
 {
@@ -152,4 +156,184 @@ std::ostream &operator<<(std::ostream &output, const scpufreq &cpufreq)
                   << ", min=" << cpufreq.min
                   << ", max=" << cpufreq.max
                   << ")";
+}
+
+const std::string& get_proc_path() {
+  static const std::string proc_path = std::getenv("PROC_PATH") ? std::getenv("PROC_PATH") : "/proc";
+  return proc_path;
+}
+
+process::process(PID pid) {
+  update(pid);
+}
+
+void process::reset() {
+  pid = 0;
+  name.clear();
+  path.clear();
+  cmdline_cmd.clear();
+  exists = false;
+  status = 0;
+  ppid = 0;
+  ttynr = 0;
+  utime = 0;
+  stime = 0;
+  children_utime = 0;
+  children_stime = 0;
+  create_time = 0;
+  cpu_num = 0;
+  blkio_ticks = 0;
+  iowait = 0;
+}
+
+void process::update(PID pid) {
+  const auto &proc_path = get_proc_path();
+  path = proc_path + "/" + std::to_string(pid) + "/stat";
+  this->pid = pid;
+
+  auto str = file_to_string(path);
+  if (str.empty()) {
+    std::cerr << "psutil: can not find process stat file with path " << path << std::endl;
+    reset();
+    this->pid = pid;
+    return;
+  }
+  // TODO: optimize
+  str = replace_all(str, "((", "(");
+  str = replace_all(str, "))", ")");
+  auto stat = split_by_delim(str, ")");
+  assert(stat.size() == 2);
+  auto stat2 = split_by_delim(stat[1], " ");
+
+  PID proc_pid = std::stoi(stat[0]);
+  if (pid != proc_pid) {
+    std::cerr << "psutil: stat pid[" << proc_pid << "] != requested pid[" << pid << "]" << std::endl;
+    reset();
+    this->pid = pid;
+    return;
+  }
+
+  cmdline_cmd = file_to_string(proc_path + "/" + std::to_string(pid) + "/cmdline");
+  time = std::chrono::system_clock::now();
+  name = split_by_delim(stat[0], "(")[1];
+  status = stat2[1][0];
+  ppid = std::stoi(stat2[2]);
+  ttynr = std::stoi(stat2[5]);
+  utime = std::stof(stat2[12]);
+  stime = std::stof(stat2[13]);
+  children_utime = std::stof(stat2[14]);
+  children_stime = std::stof(stat2[15]);
+  create_time = std::stof(stat2[20]);
+  cpu_num = std::stoi(stat2[37]);
+  blkio_ticks = std::stoi(stat2[40]);
+  exists = true;
+
+  // calc cpu times
+  static const long kClockTicks = sysconf(_SC_CLK_TCK);
+  utime = float(utime) / kClockTicks;
+  stime = float(stime) / kClockTicks;
+  children_utime = float(children_utime) / kClockTicks;
+  children_stime = float(children_stime) / kClockTicks;
+  iowait = float(blkio_ticks) / kClockTicks;
+}
+
+/**
+  Return a float representing the current process CPU utilization as a percentage.
+
+  When *interval* is 0.0 or None (default) compares process times
+  to system CPU times elapsed since last call, returning
+  immediately (non-blocking). That means that the first time
+  this is called it will return a meaningful 0.0 value.
+
+  When *interval* is > 0.0 compares process times to system CPU
+  times elapsed before and after the interval (blocking).
+
+  In this case is recommended for accuracy that this function
+  be called with at least 0.1 seconds between calls.
+
+  A value > 100.0 can be returned in case of processes running
+  multiple threads on different CPU cores.
+
+  The returned value is explicitly NOT split evenly between
+  all available logical CPUs. This means that a busy loop process
+  running on a system with 2 logical CPUs will be reported as
+  having 100% CPU utilization instead of 50%.
+*/
+float process::get_cpu_percent(uint32_t interval_mlsec) {
+  if (pid == 0) {
+    std::cerr << "psutil: get_cpu_percent() can not be run. Process PID is [0]" << std::endl;
+    return 0;
+  }
+
+  float stime1 = 0l, utime1 = 0, stime2 = 0, utime2 = 0;
+  PTime time1, time2;
+  if (interval_mlsec > 0) {
+    update(pid);
+    if (!exists) {
+      return 0;
+    }
+    stime1 = stime;
+    utime1 = utime;
+    time1 = time;
+    sleep_mlsec(interval_mlsec);
+    update(pid);
+    if (!exists) {
+      return 0;
+    }
+    stime2 = stime;
+    utime2 = utime;
+    time2 = time;
+  } else {
+    if (last_utime == -1 || last_stime == -1) {
+      last_stime = stime;
+      last_utime = utime;
+      last_time = time;
+      return 0;
+    }
+    utime1 = last_utime;
+    stime1 = last_stime;
+    time1 = last_time;
+    update(pid);
+    if (!exists) {
+      return 0;
+    }
+    utime2 = utime;
+    stime2 = stime;
+    time2 = time;
+    last_stime = stime;
+    last_utime = utime;
+    last_time = time;
+  }
+
+  auto delta_proc = (utime2 - utime1) + (stime2 - stime1);
+  delta_proc = delta_proc < 0 ? 0 : delta_proc;
+  auto delta_mksec = std::chrono::duration_cast<std::chrono::microseconds>(time2 - time1).count();
+  auto delta_time = static_cast<float>(delta_mksec / 1000000.0 * cpu_count()); // NOLINT(cppcoreguidelines-narrowing-conversions)
+  if (delta_time < 1) {
+#ifndef MUTE_PSUTIL_LOGS
+    std::cerr << std::fixed <<  "pid={" << pid << "}  delta_time={" << delta_time << "} is too small\n";
+#endif
+    cpu_percent = 0;
+    return cpu_percent;
+  }
+  auto overall_cpus_percent = delta_time == 0 ? 0 : ((delta_proc / delta_time) * 100);
+  auto single_cpu_percent = overall_cpus_percent * (float) cpu_count();
+  // TODO: round value
+  cpu_percent = ceilf(single_cpu_percent * 100) / 100;
+
+#ifndef MUTE_PSUTIL_LOGS
+  if(single_cpu_percent > 0) {
+    std::cout << "--------------------------------------------\n";
+    std::cout << std::fixed <<  "pid={" << pid << "}  pt1.system={" << stime1 << "}  pt1.user={" << utime1 << "}\n";
+    std::cout << std::fixed <<  "pid={" << pid << "}  pt2.system={" << stime2 << "}  pt2.user={" << utime2 << "}\n";
+    auto tt1 = std::chrono::duration_cast<std::chrono::microseconds>(time1.time_since_epoch()).count();
+    auto tt2 = std::chrono::duration_cast<std::chrono::microseconds>(time2.time_since_epoch()).count();
+    std::cout << std::fixed <<  "st1={" << tt1 << "}  st2={" << tt2 << "}\n";
+    std::cout << std::fixed <<  "delta_time={" << delta_time << "}\n";
+    std::cout << std::fixed <<  "delta_proc={" << delta_proc << "}\n";
+    std::cout << std::fixed << "single_cpu_percent={" << cpu_percent << "}\n";
+  }
+#endif
+
+  return cpu_percent;
 }

src/utils.cpp

@@ -147,11 +147,11 @@ std::string get_path(int num)
     return "none";
 }
 
-void sleep_mlsec(uint32_t millisec) {
-  std::this_thread::sleep_for(std::chrono::milliseconds(millisec));
+void sleep_mlsec(uint32_t mlsec) {
+  std::this_thread::sleep_for(std::chrono::milliseconds(mlsec));
 }
 
-bool is_only_numbers(const std::string &str) {
+bool has_only_numbers(const std::string &str) {
   if (str.empty()) {
     return false;
   }