Adding CPU consumption monitoring

Author: textanalyticsman

include/processor.h

@@ -1,12 +1,18 @@
 #ifndef PROCESSOR_H
 #define PROCESSOR_H
 
+#include <vector>
+#include <string>
+
 class Processor {
  public:
   float Utilization();  // TODO: See src/processor.cpp
 
-  // TODO: Declare any necessary private members
  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/linux_parser.cpp

@@ -85,7 +85,6 @@ std::string LinuxParser::RegularExpression(std::string patttern, std::string tex
   return result;
 }
 
-// TODO: Read and return the system memory utilization
 // I need to get the first value from MemTotal:       33263352 kB
 // Then I need the second value from MemFree:        23736848 kB
 // Last I have to execute (MemTotal-MemFree)/100 to get the ratio
@@ -100,7 +99,7 @@ float LinuxParser::MemoryUtilization()
   // Pattern to look for memory information inside /proc/meminfo
   std::string pattern{ R"((Mem\w*:)(\s)*(\d+)(\s*)(kB)?)" };
 
-  std::ifstream filestream("/proc/meminfo");
+  std::ifstream filestream(kProcDirectory + kMeminfoFilename);
   if (filestream.is_open()) 
   {
     while (std::getline(filestream, line)) 
@@ -139,8 +138,35 @@ long LinuxParser::ActiveJiffies() { return 0; }
 // TODO: Read and return the number of idle jiffies for the system
 long LinuxParser::IdleJiffies() { return 0; }
 
-// TODO: Read and return CPU utilization
-vector<string> LinuxParser::CpuUtilization() { return {}; }
+// Read and return CPU utilization
+vector<string> LinuxParser::CpuUtilization() 
+{
+  std::string line;
+  std::string pattern{ R"(cpu\s+((?:\d+\s*)+))" };
+
+  std::ifstream filestream(kProcDirectory + kStatFilename);
+  std::string regular_expression_result;
+
+  if (filestream.is_open()) 
+  {
+    while (std::getline(filestream, line)) 
+    {
+      regular_expression_result = RegularExpression(pattern, line, 1);
+
+      if(regular_expression_result != "")
+        break;
+    }
+  }
+
+  std::istringstream linestream{ regular_expression_result };
+  std::vector<std::string> cpu_tokens;
+  std::string tmp;
+  while (linestream >> tmp)
+    cpu_tokens.push_back(tmp);
+
+  return cpu_tokens;
+
+}
 
 // TODO: Read and return the total number of processes
 int LinuxParser::TotalProcesses() { return 0; }

src/main.cpp

@@ -5,6 +5,7 @@
 #include<string>
 #include<linux_parser.h>
 #include<iostream>
+#include<vector>
 
 int main() {
   System system;

src/processor.cpp

@@ -1,4 +1,104 @@
 #include "processor.h"
+#include "linux_parser.h"
+#include <thread>
+#include <chrono>
+#include <iostream>
 
-// TODO: Return the aggregate CPU utilization
-float Processor::Utilization() { return 0.0; }
+// Return the aggregate CPU utilization
+float Processor::Utilization() 
+{
+  // I have used the algorihm proposed at https://stackoverflow.com/questions/23367857/accurate-calculation-of-cpu-usage-given-in-percentage-in-linux
+  
+  // First reading to get CPU numbers
+  Processor::cpu_data.push_back(LinuxParser::CpuUtilization());
+  // Sleep during some time before executing second reading. Idea taken from https://stackoverflow.com/questions/52268378/c-usleep-returns-immediately-on-linux
+  std::this_thread::sleep_for(std::chrono::milliseconds(Processor::delay_reading));
+  // Second reading
+  Processor::cpu_data.push_back(LinuxParser::CpuUtilization());
+  
+  float first_idle{ 0.0 };
+  float first_non_idle{ 0.0 };
+  float first_total{ 0.0 };
+
+  float second_idle{ 0.0 };
+  float second_non_idle{ 0.0 };
+  float second_total{ 0.0 };  
+  // These are the indexes for idel and wait quantities
+  unsigned const int index_idle{3};
+  unsigned const int index_wait{4};
+
+  for(long unsigned int i=0; i<cpu_data[0].size(); ++i)
+  {
+    if(i==index_idle || i==index_wait)
+    {
+        first_idle += std::stof(cpu_data[0][i]);
+        second_idle += std::stof(cpu_data[1][i]);
+    }
+    else
+    {
+        first_non_idle += std::stof(cpu_data[0][i]);
+        second_non_idle += std::stof(cpu_data[1][i]);
+    }
+  }        
+
+  cpu_data.clear();
+
+  first_total = first_idle + first_non_idle;
+  second_total = second_idle + second_non_idle;
+
+  float total_difference {second_total - first_total};
+  float idle_difference {second_idle - first_idle};
+
+  float consumption {(total_difference - idle_difference) / total_difference};
+
+  return consumption; 
+}
+
+/*float Processor::Utilization2() 
+{
+  // I have used the algorihm proposed at https://stackoverflow.com/questions/23367857/accurate-calculation-of-cpu-usage-given-in-percentage-in-linux
+  
+  // First reading to get CPU numbers
+  Processor::cpu_data.push_back(LinuxParser::CpuUtilization());
+  
+  float first_idle{ 0 };
+  float first_non_idle{ 0 };
+  float first_total{ 0 };
+
+  float second_idle{ 0 };
+  float second_non_idle{ 0 };
+  float second_total{ 0 };  
+  // These are the indexes for idel and wait quantities
+  unsigned const int index_idle{3};
+  unsigned const int index_wait{4};
+
+  if(cpu_data.size()==2)
+  {
+    for(long unsigned int i=0; i<cpu_data.size(); ++i)
+    {
+        if(i==index_idle || i==index_wait)
+        {
+            first_idle += std::stof(cpu_data[0][i]);
+            second_idle += std::stof(cpu_data[1][i]);
+        }
+        else
+        {
+            first_non_idle += std::stof(cpu_data[0][i]);
+            second_non_idle += std::stof(cpu_data[1][i]);
+        }
+    }
+
+    cpu_data.clear();
+
+    first_total = first_idle + first_non_idle;
+    second_total = second_idle + second_non_idle;
+
+    float total_difference {second_total - first_total};
+    float idle_difference {second_idle - first_idle};
+
+    float consumption {(total_difference - idle_difference) / total_difference};      
+  }
+
+
+  return consumption; 
+}*/