linux_cpuload.cpp

Go to the documentation of this file.

/**
 * @author: Daniel Fuchs
 * @contact: fuxeysolutions@gmail.com
 *
 * distributed under the MIT License (MIT).
 * Copyright (c) Daniel Fuchs
 *
 */
#include "linux_cpuload.hpp"
 
#include <chrono>
#include <cmath>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <thread>
 
const std::vector<std::string> cpuIdentifiers{"user",
                                              "nice",
                                              "system",
                                              "idle",
                                              "iowait",
                                              "irq",
                                              "softirq",
                                              "steal",
                                              "guest",
                                              "guest_nice"};
 
void
cpuLoad::initCpuUsage()
{
    this->cpuLoadMap = this->parseStatFile(this->procFile);
    this->currentTime = std::chrono::system_clock::now();
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
    this->upDateCPUUsage();
}
 
void
cpuLoad::upDateCPUUsage()
{
    if (!((this->currentTime + std::chrono::milliseconds(10)) > std::chrono::system_clock::now()))
    {
        this->oldCpuLoadMap = this->cpuLoadMap;
        this->currentTime = std::chrono::system_clock::now();
        this->cpuLoadMap = this->parseStatFile(this->procFile);
        this->calculateCpuUsage();
    }
}
 
double
cpuLoad::getCurrentCpuUsage()
{
 
    this->upDateCPUUsage();
    return this->cpuUsage.at("cpu");
}
 
std::vector<double>
cpuLoad::getCurrentMultiCoreUsage()
{
    this->upDateCPUUsage();
    std::vector<double> percents;
    for (const auto& elem : this->cpuUsage)
    {
        if (elem.first == "cpu")
        {
            continue;
        }
        percents.push_back(elem.second);
    }
    return percents;
}
 
void
cpuLoad::calculateCpuUsage()
{
    for (const auto& elem : this->cpuLoadMap)
    {
        if (this->cpuLoadMap.at(elem.first).at("user") <
                this->oldCpuLoadMap.at(elem.first).at("user") ||
            this->cpuLoadMap.at(elem.first).at("nice") <
                this->oldCpuLoadMap.at(elem.first).at("nice") ||
            this->cpuLoadMap.at(elem.first).at("system") <
                this->oldCpuLoadMap.at(elem.first).at("system") ||
            this->cpuLoadMap.at(elem.first).at("idle") <
                this->oldCpuLoadMap.at(elem.first).at("idle"))
        {
        }
        else
        {
            auto total = (this->cpuLoadMap.at(elem.first).at("user") -
                          this->oldCpuLoadMap.at(elem.first).at("user")) +
                         (this->cpuLoadMap.at(elem.first).at("nice") -
                          this->oldCpuLoadMap.at(elem.first).at("nice")) +
                         (this->cpuLoadMap.at(elem.first).at("system") -
                          this->oldCpuLoadMap.at(elem.first).at("system"));
 
            double percent = total;
            total += (this->cpuLoadMap.at(elem.first).at("idle") -
                      this->oldCpuLoadMap.at(elem.first).at("idle"));
            percent /= total;
            percent *= 100.0;
            this->cpuUsage[elem.first] = percent;
        }
    }
}
 
std::map<std::string, std::unordered_map<std::string, uint64_t>>
cpuLoad::parseStatFile(const std::string& fileName)
{
 
    std::map<std::string, std::unordered_map<std::string, uint64_t>> cpuLoad_;
 
    try
    {
        std::ifstream cpuFile(fileName);
 
        uint32_t lineCnt = 0;
        bool infoValid = true;
        for (std::string line; std::getline(cpuFile, line) && infoValid; lineCnt++)
        {
 
            std::stringstream strStream(line);
            std::string strPart;
            std::string cpuNum;
            auto it = cpuIdentifiers.begin();
            std::unordered_map<std::string, uint64_t> cpuValues;
            while (strStream >> strPart)
            {
                if (cpuNum.empty())
                {
                    if (strPart.find("cpu") != std::string::npos)
                    {
                        cpuNum = strPart;
                        continue;
                    }
                    else
                    {
                        infoValid = false;
                        break;
                    }
                }
                if (it != cpuIdentifiers.end())
                {
                    cpuValues[it->data()] = std::stoull(strPart);
                }
                if (it->data() == cpuIdentifiers.at(4))
                {
                    break;
                }
                it++;
            }
            if (!cpuNum.empty())
            {
                cpuLoad_[cpuNum] = cpuValues;
            }
        }
    }
    catch (std::ifstream::failure& e)
    {
        throw std::runtime_error("Exception: " + fileName + std::string(e.what()));
    }
    return cpuLoad_;
}
 
std::string
cpuLoad::getCPUName(const std::string& cpuNameFile)
{
 
    if (!this->cpuName.empty())
    {
        return this->cpuName;
    }
 
    std::ifstream file;
    file.open(cpuNameFile);
 
    if (!file.is_open())
    {
        throw std::runtime_error("unable to open " + cpuNameFile);
    }
    std::string line;
    while (std::getline(file, line))
    {
        if (line.find("model name") != std::string::npos)
        {
            size_t pos = line.find(':');
            if (pos != std::string::npos)
            {
                this->cpuName = line.substr(pos, line.size());
                return this->cpuName;
            }
        }
    }
    return std::string();
}