Monitor CPU Usage for Specific Processes

#include <mutex>

void MONITOR_BASE::show_cpu_status()
{
    std::vector<ProcessInfo1> process_info = getTopProcesses_CPU(MONITOR_CONSTANT::FIFTY);
    LOG(INFO) << 'CPU Temperature: ' << getCpuTemperature() << '℃';

    for (auto &ele : process_info)
    {
        if (isSubstring(std::string(std::getenv('AUTO_ROOT')), ele.COMMAND) && ele.COMMAND != '')
        {
            LOG(INFO) << 'Process(' << getLastElement(ele.COMMAND)
                      << ') take CPU(' << ele.CPU
                      << '%), MEM(' << ele.MEM
                      << '%), VSZ(' << ele.VSZ / 1024 << ' MB)';
            std::string process_name = getLastElement(ele.COMMAND);
            float cpu = ele.CPU;
            float mem = ele.MEM;
            float vsz = ele.VSZ;

            {
                std::lock_guard<std::mutex> lock(cpu_info_mutex_);
                module_cpu_info(process_name, cpu, mem, vsz);
            }

            clear_cpu_info_(process_name);
            pub_memory_.publish(cpu_info_);
        }
    }
}

void MONITOR_BASE::module_cpu_info(std::string process_name, float cpu, float mem, float vsz)
{

    if (process_name == 'auto_ad_monitor_node')
    {
        cpu_info_.auto_ad_monitor_node.cpu.data = cpu;
        cpu_info_.auto_ad_monitor_node.mem.data = mem;
        cpu_info_.auto_ad_monitor_node.vsz.data = vsz;
    }
    if (process_name == 'auto_ad_memory_monitor')
    {
        cpu_info_.auto_ad_memory_monitor.cpu.data = cpu;
        cpu_info_.auto_ad_memory_monitor.mem.data = mem;
        cpu_info_.auto_ad_memory_monitor.vsz.data = vsz;
    }
    if (process_name == 'auto_ad_localization')
    {
        cpu_info_.auto_ad_localization.cpu.data = cpu;
        cpu_info_.auto_ad_localization.mem.data = mem;
        cpu_info_.auto_ad_localization.vsz.data = vsz;
    }
    if (process_name == 'auto_ad_planning')
    {
        cpu_info_.auto_ad_planning.cpu.data = cpu;
        cpu_info_.auto_ad_planning.mem.data = mem;
        cpu_info_.auto_ad_planning.vsz.data = vsz;
    }
}

void MONITOR_BASE::clear_cpu_info_(std::string process_name)
{
    std::string check_process_cmd = 'pidof ' + process_name;
    FILE *pipe = popen(check_process_cmd.c_str(), 'r');
    char buffer[128];
    std::string result = '';
    while (fgets(buffer, sizeof(buffer), pipe) != nullptr)
    {
        result += buffer;
    }
    pclose(pipe);

    if (result.empty())
    {
        // 进程不存在，将对应的 cpu_info_ 值清零
        if (process_name == 'auto_ad_memory_monitor')
        {
            cpu_info_.auto_ad_memory_monitor.cpu.data = 0;
            cpu_info_.auto_ad_memory_monitor.mem.data = 0;
            cpu_info_.auto_ad_memory_monitor.vsz.data = 0;
        }
        if (process_name == 'auto_ad_monitor_node')
        {
            cpu_info_.auto_ad_monitor_node.cpu.data = 0;
            cpu_info_.auto_ad_monitor_node.mem.data = 0;
            cpu_info_.auto_ad_monitor_node.vsz.data = 0;
        }
        if (process_name == 'auto_ad_localization')
        {
            cpu_info_.auto_ad_localization.cpu.data = 0;
            cpu_info_.auto_ad_localization.mem.data = 0;
            cpu_info_.auto_ad_localization.vsz.data = 0;
        }
        if (process_name == 'auto_ad_planning')
        {
            cpu_info_.auto_ad_planning.cpu.data = 0;
            cpu_info_.auto_ad_planning.mem.data = 0;
            cpu_info_.auto_ad_planning.vsz.data = 0;
        }
    }
}

This code uses a mutex to protect the cpu_info_ structure from race conditions when updating its values. This ensures that concurrent access to cpu_info_ is synchronized, preventing potential data corruption and ensuring accurate CPU usage monitoring. The code utilizes functions like getTopProcesses_CPU, isSubstring, getLastElement, getCpuTemperature, and pub_memory_.publish to retrieve and publish CPU information. The clear_cpu_info_ function checks if a process is still running using pidof and clears the corresponding cpu_info_ values if the process is not found. The code specifically monitors the CPU, memory, and virtual memory size (VSZ) of specific processes. The mutex (cpu_info_mutex_) acts as a synchronization mechanism to avoid data inconsistencies in a multi-threaded environment.