feat: update

Author: ajanani85

include/resource_monitor/resource_monitor_stats.h

@@ -21,6 +21,7 @@ class ResourceMonitorStats
     AMStat cpu_stats = AMStat("cpu_s", "CPU Stats", 1, 2, 80, 99);
     AMStat gpu_stats = AMStat("gpu_s", "GPU Stats", 1, 2, 80, 99);
     AMStat ram_stats = AMStat("ram_s", "RAM Stats", 1, 2, 80, 99);
+    AMStat drive_stats = AMStat("drive_s", "Drive Stats", 1, 2, 80, 99);
     AMStat lidar_ip = AMStat("lidar_ip_s", "Lidar IP Stats", 1, 2, 80, 99);
     AMStat fl_ip = AMStat("fl_s", "FL IP Stats", 1, 2, 80, 99);
     AMStat fr_ip = AMStat("fr_s", "FR IP Stats", 1, 2, 80, 99);
@@ -35,6 +36,7 @@ class ResourceMonitorStats
         stat_list.add(&gpu_stats);
         stat_list.add(&cpu_stats);
         stat_list.add(&ram_stats);
+        stat_list.add(&drive_stats);
         stat_list.add(&lidar_ip);
         stat_list.add(&fl_ip);
         stat_list.add(&fr_ip);

include/resource_monitor/resource_status_class.h

@@ -12,6 +12,8 @@
 #include <vb_util_lib/transformer.h>
 #include <resource_monitor/resource_monitor_stats.h>
 #include <std_msgs/msg/int32.hpp>
+#include <sys/statvfs.h> // For statvfs
+#include <iomanip>       // For std::setprecision
 
 
 namespace am
@@ -30,9 +32,7 @@ struct GpuInfo
 {
     std::string gpu_name;
     int temp;
-    int mem_used;
-    int mem_free;
-    int util_percent;
+    int load_percent;
 };
 
 struct CpuInfo 
@@ -48,6 +48,13 @@ struct CpuInfo
     unsigned long long total;
 };
 
+struct DiskInfo {
+    unsigned long long totalSpace;  // Total space in bytes
+    unsigned long long availableSpace; // Available space in bytes (matches `df`)
+    unsigned long long usedSpace;   // Used space in bytes
+    double percentUsed;             // Percentage used
+};
+
 class ResourceStatus
 {
 public:
@@ -59,10 +66,12 @@ class ResourceStatus
 
     am::CpuInfo getCPUInfo();
 
-    void getGPUInfo(std::vector<am::GpuInfo> &gpu_infos);
+    am::GpuInfo getGPUInfo();
 
     void getCPUInfo(std::vector<am::CpuInfo> &infos);
 
+    DiskInfo getDiskInfo(const std::string& path = "/");
+
     double calculateCpuLoad(const am::CpuInfo &ci, const am::CpuInfo &ci_old);
 
     double getUpTime();
@@ -102,6 +111,8 @@ class ResourceStatus
 
     int getCPUCoresCount();
 
+    std::string readFile(const std::string& path);
+
     am::CpuInfo parseCpuLine(const std::string &line);
 
     int cpu_cnt_= -1;
@@ -120,7 +131,7 @@ class ResourceStatus
 
     std::vector<am::CpuInfo> cpu_infos_old_;
 
-    std::vector<am::GpuInfo> gpu_infos_;
+    am::GpuInfo gpu_info_;
 
     std::map<std::string, std::string> ip_addresses_; //IPAddress, Name
 

src/resource_monitor/resource_status_class.cpp

@@ -5,6 +5,7 @@
 #include <cstdio>   // For popen and fgets
 #include <memory>   // For std::unique_ptr
 #include <regex>    // For std::regex
+#include <boost/filesystem.hpp>
 
 namespace am
 {
@@ -182,7 +183,26 @@ void ResourceStatus::updateInfos()
 
     cpu_infos_old_ = cpu_infos_;
 
-    getGPUInfo(gpu_infos_);
+    gpu_info_ = getGPUInfo();
+    stats_->gpu_stats = 50;
+    ROS_INFO("GPU Load Percent: %d , Temp: %d", gpu_info_.load_percent, gpu_info_.temp);
+    if(gpu_info_.load_percent > 90)
+    {
+        stats_->gpu_stats = 100;
+        ROS_ERROR("GPU Issues: LOAD Percent: %d, Temp: %d", gpu_info_.load_percent, gpu_info_.temp);
+    }
+
+
+    //check the drive stats
+    stats_->drive_stats = 50;
+    am::DiskInfo disk_info = getDiskInfo();
+    if(disk_info.percentUsed > 98.0)
+    {
+        stats_->drive_stats = 100;
+        int coef = 1024*1024;
+        ROS_ERROR("Disk total: %lld MB, available: %lld MB, used: %lld MB, percentage: %f", (disk_info.totalSpace/coef), (disk_info.availableSpace/coef), (disk_info.usedSpace/coef), disk_info.percentUsed);
+    }
+    
 }
 
 
@@ -224,21 +244,69 @@ am::MemoryInfo& ResourceStatus::getMemoryInfo()
     return mi;
 }
 
-void ResourceStatus::getGPUInfo(std::vector<am::GpuInfo> &gpu_infos)
+// Function to read the content of a file
+std::string ResourceStatus::readFile(const std::string& path) 
 {
-    gpu_infos.clear();
+    std::ifstream file(path);
+    if (!file.is_open()) {
+        throw std::runtime_error("Error: Unable to open file " + path);
+    }
+
+    std::string content;
+    std::getline(file, content);
+    file.close();
+    return content;
+}
+
+am::GpuInfo ResourceStatus::getGPUInfo()
+{
+    am::GpuInfo gpu_info;
+
+    // "/sys/devices/gpu.0/load" exists only in Jetpack
+    //in contrast, nvidia-smi only exists in amd64 architure
+    const std::string loadPath = "/sys/devices/gpu.0/load";
+    if (boost::filesystem::exists(loadPath))
+    {
+        std::string loadStr = readFile(loadPath);
+        gpu_info.load_percent = std::stoi(loadStr) / 1000; // Convert to percentage
+
+        const std::string baseThermalPath = "/sys/class/thermal/";
+        const std::string typeSuffix = "/type";
+        const std::string tempSuffix = "/temp";
+
+        for (int i = 0; i < 10; ++i) { // Check up to 10 thermal zones
+            try {
+                std::string typePath = baseThermalPath + "thermal_zone" + std::to_string(i) + typeSuffix;
+                std::string type = readFile(typePath);
+                if (type.find("GPU") != std::string::npos) 
+                { // Look for the GPU thermal zone
+                    std::string tempPath = baseThermalPath + "thermal_zone" + std::to_string(i) + tempSuffix;
+                    std::string tempStr = readFile(tempPath);
+                    gpu_info.temp = std::stoi(tempStr) / 1000; // Convert millidegrees to degrees Celsius
+                }
+            } catch (...) {
+                // Ignore errors and continue checking other zones
+            }
+        }
+        throw std::runtime_error("Error: GPU thermal zone not found.");
+
+        return gpu_info;
+    }
+
+
     // Execute the nvidia-smi command and read the output directly
     const std::string command = "nvidia-smi --query-gpu=name,utilization.gpu,temperature.gpu,memory.used,memory.free --format=csv,nounits,noheader";
     FILE* pipe = popen(command.c_str(), "r");
     if (!pipe) 
     {
         ROS_ERROR("Error: Unable to execute nvidia-smi. Ensure it's installed and available in PATH.");
-        return;
+        return gpu_info;
     }
 
     char buffer[128];
     std::ostringstream result;
-    while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
+    while (fgets(buffer, sizeof(buffer), pipe) != nullptr) 
+    {
         result << buffer;
     }
     pclose(pipe);
@@ -248,10 +316,8 @@ void ResourceStatus::getGPUInfo(std::vector<am::GpuInfo> &gpu_infos)
     std::string line;
     while (std::getline(iss, line)) 
     {
-
         //ROS_INFO(GREEN "%s" COLOR_RESET, line.c_str());
         std::istringstream lineStream(line);
-        am::GpuInfo gpu_info;
         // Parse memory used and free values
         std::string gpuName;
         int gpuUtilization, gpuTemperature, memoryUsed, memoryFree;
@@ -269,14 +335,15 @@ void ResourceStatus::getGPUInfo(std::vector<am::GpuInfo> &gpu_infos)
         lineStream >> memoryFree;
 
         gpu_info.gpu_name = gpuName;
-        gpu_info.util_percent = gpuUtilization;
+        gpu_info.load_percent = gpuUtilization;
         gpu_info.temp = gpuTemperature;
-        gpu_info.mem_free = memoryFree;
-        gpu_info.mem_used = memoryUsed;
-        stats_->gpu_stats = (gpu_info.util_percent>90?100:50);
-
-        gpu_infos.push_back(gpu_info);
+        
+        return gpu_info;
     }
+
+
+    
+    return gpu_info;
 }
 
 
@@ -385,10 +452,7 @@ void ResourceStatus::print()
     ROS_INFO("UpTime: %f", uptime_seconds_);
 
     msg = "";
-    for(int i = 0; i < gpu_infos_.size(); i++)
-    {
-        msg += gpu_infos_[i].gpu_name + ": Temp[C] = " + std::to_string(gpu_infos_[i].temp) + ", Used[%]: " + std::to_string(gpu_infos_[i].util_percent);
-    }
+    msg += "GPU: Temp[C] = " + std::to_string(gpu_info_.temp) + ", Used[%]: " + std::to_string(gpu_info_.load_percent);
 
     ROS_INFO("%s", msg.c_str());
 }
@@ -567,6 +631,25 @@ std::vector<std::string> ResourceStatus::getInetAddresses()
     return inetAddresses;
 }
 
+
+// Function to get disk usage information
+DiskInfo ResourceStatus::getDiskInfo(const std::string& path) 
+{
+    struct statvfs stat;
+
+    if (statvfs(path.c_str(), &stat) != 0) {
+        throw std::runtime_error("Error: Unable to get disk information for " + path);
+    }
+
+    DiskInfo info;
+    info.totalSpace = stat.f_blocks * stat.f_frsize;      // Total blocks * block size
+    info.availableSpace = stat.f_bavail * stat.f_frsize;  // Available blocks * block size
+    info.usedSpace = info.totalSpace - info.availableSpace;
+    info.percentUsed = (info.usedSpace * 100.0) / info.totalSpace;
+
+    return info;
+}
+
 /*
     Timer Callback: this is where everything is updated
  */