MangoHud/src/cpu_gpu.h

#include <thread>
#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
#include "nvidia_info.h"
#include "memory.h"

using namespace std;

int gpuLoad = 0, gpuTemp = 0, cpuTemp = 0, gpuMemClock, gpuCoreClock;
FILE *amdGpuFile = nullptr, *amdTempFile = nullptr, *cpuTempFile = nullptr, *amdGpuVramTotalFile = nullptr, *amdGpuVramUsedFile = nullptr, *amdGpuCoreClockFile = nullptr, *amdGpuMemoryClockFile = nullptr;
float gpuMemUsed = 0, gpuMemTotal = 0;

int numCpuCores = std::thread::hardware_concurrency();
pthread_t cpuThread, gpuThread, cpuInfoThread;

struct amdGpu {
    int load;
    int temp;
    int64_t memoryUsed;
    int64_t memoryTotal;
    int MemClock;
    int CoreClock;
};

extern struct amdGpu amdgpu;

string exec(string command) {
   char buffer[128];
   string result = "";

   // Open pipe to file
   FILE* pipe = popen(command.c_str(), "r");
   if (!pipe) {
      return "popen failed!";
   }

   // read till end of process:
   while (!feof(pipe)) {

      // use buffer to read and add to result
      if (fgets(buffer, 128, pipe) != NULL)
         result += buffer;
   }

   pclose(pipe);
   return result;
}


void *cpuInfo(void *){
    rewind(cpuTempFile);
    fflush(cpuTempFile);
    if (fscanf(cpuTempFile, "%d", &cpuTemp) != 1)
        cpuTemp = 0;
    cpuTemp /= 1000;
    pthread_detach(cpuInfoThread);

    return NULL;
}

void *getNvidiaGpuInfo(void *){
    if (!nvmlSuccess)
        checkNvidia();

    if (nvmlSuccess){
        getNvidiaInfo();
        gpuLoad = nvidiaUtilization.gpu;
        gpuTemp = nvidiaTemp;
        gpuMemUsed = float(nvidiaMemory.used / (1024 * 1024)) / 1000;
        gpuCoreClock = nvidiaCoreClock;
        gpuMemClock = nvidiaMemClock * 2;
    }

    pthread_detach(gpuThread);
    return NULL;
}

void *getAmdGpuUsage(void *){
    if (amdGpuFile) {
        rewind(amdGpuFile);
        fflush(amdGpuFile);
        if (fscanf(amdGpuFile, "%d", &amdgpu.load) != 1)
            amdgpu.load = 0;
        gpuLoad = amdgpu.load;
    }

    if (amdTempFile) {
        rewind(amdTempFile);
        fflush(amdTempFile);
        if (fscanf(amdTempFile, "%d", &amdgpu.temp) != 1)
            amdgpu.temp = 0;
        amdgpu.temp /= 1000;
        gpuTemp = amdgpu.temp;
    }

    if (amdGpuVramTotalFile) {
        rewind(amdGpuVramTotalFile);
        fflush(amdGpuVramTotalFile);
        if (fscanf(amdGpuVramTotalFile, "%" PRId64, &amdgpu.memoryTotal) != 1)
            amdgpu.memoryTotal = 0;
        amdgpu.memoryTotal /= (1024 * 1024);
        gpuMemTotal = amdgpu.memoryTotal;
    }

    if (amdGpuVramUsedFile) {
        rewind(amdGpuVramUsedFile);
        fflush(amdGpuVramUsedFile);
        if (fscanf(amdGpuVramUsedFile, "%" PRId64, &amdgpu.memoryUsed) != 1)
            amdgpu.memoryUsed = 0;
        amdgpu.memoryUsed /= (1024 * 1024);
        gpuMemUsed = float(amdgpu.memoryUsed) / 1000;
    }
    
    if (amdGpuCoreClockFile) {
        rewind(amdGpuCoreClockFile);
        fflush(amdGpuCoreClockFile);
        char line[255];
        while (fgets(line, sizeof(line), amdGpuCoreClockFile)){
            std::string row = line;
            row.erase(row.begin());
            if (row.find("*") != std::string::npos){
                row = std::regex_replace(row, std::regex(R"([^0-9])"), "");
                amdgpu.CoreClock = stoi(row);
                gpuCoreClock = amdgpu.CoreClock;
            }
        }
    }

    if (amdGpuMemoryClockFile) {
        rewind(amdGpuMemoryClockFile);
        fflush(amdGpuMemoryClockFile);
        char line[255];
        while (fgets(line, sizeof(line), amdGpuMemoryClockFile)){
            std::string row = line;
            row.erase(row.begin());
            if (row.find("*") != std::string::npos){
                row = std::regex_replace(row, std::regex(R"([^0-9])"), "");
                amdgpu.MemClock = stoi(row) * 2;
                gpuMemClock = amdgpu.MemClock;
            }
        }
    }

    pthread_detach(gpuThread);
    return NULL;
}