CPU consumption per process

Author: textanalyticsman

include/linux_parser.h

@@ -21,6 +21,7 @@ const std::string kPasswordPath{"/etc/passwd"};
 // Helpers
 // Function added to use regular expressions in order to look for patterns on Linux files
 std::string RegularExpression(std::string patttern, std::string tex, int group);
+float CpuUtilization(int pid);
 
 // System
 float MemoryUtilization();
@@ -31,6 +32,7 @@ int RunningProcesses();
 std::string OperatingSystem();
 std::string Kernel();
 
+
 // CPU
 enum CPUStates {
   kUser_ = 0,

include/processor.h

@@ -11,8 +11,6 @@ class Processor {
  private:
   //This will save the CPU average numbers for two readings
   std::vector<std::vector<std::string>> cpu_data;
-  // This is the delay between readings in seconds used to calculate CPU consumption
-  unsigned int delay_reading{1000};
 };
 
 #endif

src/format.cpp

@@ -4,8 +4,16 @@
 
 using std::string;
 
-// TODO: Complete this helper function
 // INPUT: Long int measuring seconds
 // OUTPUT: HH:MM:SS
-// REMOVE: [[maybe_unused]] once you define the function
-string Format::ElapsedTime(long seconds[[maybe_unused]]) { return string(); }
+string Format::ElapsedTime(long seconds) 
+{
+    long int tdays{ seconds/60/60/24 };
+    long int thours{ seconds/60/60%24 };
+    long int tminutes{ seconds/60%60 };
+    long int tseconds{ seconds%60 };
+    
+    string result { std::to_string(tdays) + ":" + std::to_string(thours) + ":" + std::to_string(tminutes) + ":" + std::to_string(tseconds)};
+
+    return result;
+}

src/linux_parser.cpp

@@ -123,7 +123,24 @@ float LinuxParser::MemoryUtilization()
 }
 
 // TODO: Read and return the system uptime
-long LinuxParser::UpTime() { return 0; }
+long LinuxParser::UpTime() 
+{ 
+  long int uptime{0};
+  std::string line;
+
+  std::ifstream filestream(kProcDirectory + kUptimeFilename);
+
+  if (filestream.is_open()) 
+    std::getline(filestream, line);
+
+  std::istringstream linestream{ line };
+  
+  std::string tmp;
+  linestream >> tmp;
+  uptime=std::stod(tmp);  
+
+  return uptime;
+}
 
 // TODO: Read and return the number of jiffies for the system
 long LinuxParser::Jiffies() { return 0; }
@@ -168,15 +185,71 @@ vector<string> LinuxParser::CpuUtilization()
 
 }
 
+// To return the CPU utilization per process
+float LinuxParser::CpuUtilization(int pid)
+{
+  float cpu_consumption{ 0.0 };
+  std::string line;
+
+  std::ifstream filestream(kProcDirectory + std::to_string(pid) +  kStatFilename);
+
+  if (filestream.is_open()) 
+    std::getline(filestream, line);
+
+  std::istringstream linestream{ line };
+  vector<float> cpu_tokens;
+  std::string tmp;
+  
+  int i{0};
+
+  while (linestream >> tmp)
+  {
+    ++i;
+    // Positions 14, 15, 16, 17 and 22 are used to calculate CPU consumption per process
+    // https://stackoverflow.com/questions/16726779/how-do-i-get-the-total-cpu-usage-of-an-application-from-proc-pid-stat/16736599#16736599
+    if(i == 14 || i == 15 || i == 16 || i == 17)
+      cpu_tokens.push_back(stof(tmp));
+    else if(i == 22)
+    {
+      cpu_tokens.push_back(stof(tmp));
+      break;
+    }
+  }
+
+  float total_time{0.0};
+  long int hertz{sysconf(_SC_CLK_TCK)};
+  float seconds{0.0};
+  long uptime{UpTime()};
+
+  for(int i=0; i<4; ++i)
+    total_time += cpu_tokens[i];
+  
+  seconds = uptime - (cpu_tokens[4]/hertz);
+
+  cpu_consumption = total_time / hertz / seconds;
+
+  return cpu_consumption;
+}
+
 // TODO: Read and return the total number of processes
 int LinuxParser::TotalProcesses() { return 0; }
 
 // TODO: Read and return the number of running processes
 int LinuxParser::RunningProcesses() { return 0; }
 
-// TODO: Read and return the command associated with a process
-// REMOVE: [[maybe_unused]] once you define the function
-string LinuxParser::Command(int pid[[maybe_unused]]) { return string(); }
+// Read and return the command associated with a process
+string LinuxParser::Command(int pid) 
+{ 
+  std::ifstream filestream(kProcDirectory + std::to_string(pid) + kCmdlineFilename);
+  std::string command_line;
+
+  if (filestream.is_open()) 
+  {
+    std::getline(filestream, command_line);
+  }
+
+  return command_line;
+}
 
 // TODO: Read and return the memory used by a process
 // REMOVE: [[maybe_unused]] once you define the function
@@ -205,8 +278,7 @@ string LinuxParser::Uid(int pid)
   return user_id;
 }
 
-// TODO: Read and return the user associated with a process
-// REMOVE: [[maybe_unused]] once you define the function
+// Read and return the user associated with a process
 string LinuxParser::User(int pid) 
 {
   std::string line;

src/ncurses_display.cpp

@@ -57,10 +57,10 @@ void NCursesDisplay::DisplayProcesses(std::vector<Process>& processes,
   int row{0};
   int const pid_column{2};
   int const user_column{9};
-  int const cpu_column{16};
-  int const ram_column{26};
-  int const time_column{35};
-  int const command_column{46};
+  int const cpu_column{19};
+  int const ram_column{29};
+  int const time_column{39};
+  int const command_column{49};
   wattron(window, COLOR_PAIR(2));
   mvwprintw(window, ++row, pid_column, "PID");
   mvwprintw(window, row, user_column, "USER");

src/system.cpp

@@ -24,7 +24,8 @@ vector<Process>& System::Processes()
 
     for(int pid : list_pids)
     {
-        Process process(pid, LinuxParser::User(pid));
+        Process process(pid, LinuxParser::User(pid), LinuxParser::Command(pid), 
+                       LinuxParser::CpuUtilization(pid));
         processes_.push_back(process);
     }
 
@@ -47,4 +48,4 @@ int System::RunningProcesses() { return 0; }
 int System::TotalProcesses() { return 0; }
 
 // TODO: Return the number of seconds since the system started running
-long int System::UpTime() { return 0; }
+long int System::UpTime() { return LinuxParser::UpTime(); }