Archives
/
MangoHud
mirror of https://github.com/flightlessmango/MangoHud
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Consolidated amdgpu file handles to a struct and add `gpu_power` param to show power usage for amdgpu/nvml

Browse Source
pull/197/head
jackun 4 years ago
parent 5c3c8a5ac9
commit ff48525313
No known key found for this signature in database
GPG Key ID: 119DB3F1D05A9ED3
7 changed files with 102 additions and 77 deletions
Show Stats Download Patch File Download Diff File

84
src/gpu.cpp
Unescape Escape View File

@ -3,7 +3,7 @@
#include "gpu.h"
struct gpuInfo gpu_info;
FILE *amdGpuFile = nullptr, *amdTempFile = nullptr, *amdGpuVramTotalFile = nullptr, *amdGpuVramUsedFile = nullptr, *amdGpuCoreClockFile = nullptr, *amdGpuMemoryClockFile = nullptr;
amdgpu_files amdgpu {};
void getNvidiaGpuInfo(){
if (nvmlSuccess){
@ -13,6 +13,7 @@ void getNvidiaGpuInfo(){
gpu_info.memoryUsed = nvidiaMemory.used / (1024.f * 1024.f * 1024.f);
gpu_info.CoreClock = nvidiaCoreClock;
gpu_info.MemClock = nvidiaMemClock;
gpu_info.powerUsage = nvidiaPowerUsage / 1000;
}
#ifdef HAVE_XNVCTRL
else if (nvctrlSuccess) {
@ -22,65 +23,70 @@ void getNvidiaGpuInfo(){
gpu_info.memoryUsed = nvctrl_info.memoryUsed / (1024.f);
gpu_info.CoreClock = nvctrl_info.CoreClock;
gpu_info.MemClock = nvctrl_info.MemClock;
gpu_info.powerUsage = 0;
}
#endif
}
void getAmdGpuUsage(){
void getAmdGpuInfo(){
int64_t value = 0;
if (amdGpuFile) {
rewind(amdGpuFile);
fflush(amdGpuFile);
if (fscanf(amdGpuFile, "%d", &amdgpu.load) != 1)
amdgpu.load = 0;
gpu_info.load = amdgpu.load;
if (amdgpu.busy) {
rewind(amdgpu.busy);
fflush(amdgpu.busy);
if (fscanf(amdgpu.busy, "%d", &gpu_info.load) != 1)
gpu_info.load = 0;
gpu_info.load = gpu_info.load;
}
if (amdTempFile) {
rewind(amdTempFile);
fflush(amdTempFile);
if (fscanf(amdTempFile, "%d", &amdgpu.temp) != 1)
amdgpu.temp = 0;
amdgpu.temp /= 1000;
gpu_info.temp = amdgpu.temp;
if (amdgpu.temp) {
rewind(amdgpu.temp);
fflush(amdgpu.temp);
if (fscanf(amdgpu.temp, "%d", &gpu_info.temp) != 1)
gpu_info.temp = 0;
gpu_info.temp /= 1000;
}
if (amdGpuVramTotalFile) {
rewind(amdGpuVramTotalFile);
fflush(amdGpuVramTotalFile);
if (fscanf(amdGpuVramTotalFile, "%" PRId64, &value) != 1)
if (amdgpu.vram_total) {
rewind(amdgpu.vram_total);
fflush(amdgpu.vram_total);
if (fscanf(amdgpu.vram_total, "%" PRId64, &value) != 1)
value = 0;
amdgpu.memoryTotal = float(value) / (1024 * 1024 * 1024);
gpu_info.memoryTotal = amdgpu.memoryTotal;
gpu_info.memoryTotal = float(value) / (1024 * 1024 * 1024);
}
if (amdGpuVramUsedFile) {
rewind(amdGpuVramUsedFile);
fflush(amdGpuVramUsedFile);
if (fscanf(amdGpuVramUsedFile, "%" PRId64, &value) != 1)
if (amdgpu.vram_used) {
rewind(amdgpu.vram_used);
fflush(amdgpu.vram_used);
if (fscanf(amdgpu.vram_used, "%" PRId64, &value) != 1)
value = 0;
amdgpu.memoryUsed = float(value) / (1024 * 1024 * 1024);
gpu_info.memoryUsed = amdgpu.memoryUsed;
gpu_info.memoryUsed = float(value) / (1024 * 1024 * 1024);
}
if (amdGpuCoreClockFile) {
rewind(amdGpuCoreClockFile);
fflush(amdGpuCoreClockFile);
if (fscanf(amdGpuCoreClockFile, "%" PRId64, &value) != 1)
if (amdgpu.core_clock) {
rewind(amdgpu.core_clock);
fflush(amdgpu.core_clock);
if (fscanf(amdgpu.core_clock, "%" PRId64, &value) != 1)
value = 0;
amdgpu.CoreClock = value / 1000000;
gpu_info.CoreClock = amdgpu.CoreClock;
gpu_info.CoreClock = value / 1000000;
}
if (amdGpuMemoryClockFile) {
rewind(amdGpuMemoryClockFile);
fflush(amdGpuMemoryClockFile);
if (fscanf(amdGpuMemoryClockFile, "%" PRId64, &value) != 1)
if (amdgpu.memory_clock) {
rewind(amdgpu.memory_clock);
fflush(amdgpu.memory_clock);
if (fscanf(amdgpu.memory_clock, "%" PRId64, &value) != 1)
value = 0;
amdgpu.MemClock = value / 1000000;
gpu_info.MemClock = amdgpu.MemClock;
gpu_info.MemClock = value / 1000000;
}
if (amdgpu.power_usage) {
rewind(amdgpu.power_usage);
fflush(amdgpu.power_usage);
if (fscanf(amdgpu.power_usage, "%" PRId64, &value) != 1)
value = 0;
gpu_info.powerUsage = value / 1000000;
}
}

25
src/gpu.h
Unescape Escape View File

@ -5,18 +5,19 @@
#include "nvidia_info.h"
#include "nvctrl.h"
using namespace std;
extern FILE *amdGpuFile, *amdTempFile, *amdGpuVramTotalFile, *amdGpuVramUsedFile, *amdGpuCoreClockFile, *amdGpuMemoryClockFile;
struct amdGpu {
int load;
int temp;
float memoryUsed;
float memoryTotal;
int MemClock;
int CoreClock;
struct amdgpu_files
{
FILE *busy;
FILE *temp;
FILE *vram_total;
FILE *vram_used;
FILE *core_clock;
FILE *memory_clock;
FILE *power_usage;
};
extern amdgpu_files amdgpu;
struct gpuInfo{
int load;
int temp;
@ -24,10 +25,10 @@ struct gpuInfo{
float memoryTotal;
int MemClock;
int CoreClock;
int powerUsage;
};
extern struct amdGpu amdgpu;
extern struct gpuInfo gpu_info;
void getNvidiaGpuInfo(void);
void getAmdGpuUsage(void);
void getAmdGpuInfo(void);

2
src/nvidia_info.h
Unescape Escape View File

@ -1,7 +1,7 @@
#include <nvml.h>
extern nvmlReturn_t result;
extern unsigned int nvidiaTemp, processSamplesCount, *vgpuInstanceSamplesCount, nvidiaCoreClock, nvidiaMemClock;
extern unsigned int nvidiaTemp, processSamplesCount, *vgpuInstanceSamplesCount, nvidiaCoreClock, nvidiaMemClock, nvidiaPowerUsage;
extern nvmlDevice_t nvidiaDevice;
extern struct nvmlUtilization_st nvidiaUtilization;
extern struct nvmlMemory_st nvidiaMemory;

3
src/nvml.cpp
Unescape Escape View File

@ -9,7 +9,7 @@ nvmlReturn_t result;
nvmlDevice_t nvidiaDevice;
nvmlPciInfo_t nvidiaPciInfo;
bool nvmlSuccess = false;
unsigned int nvidiaTemp, nvidiaCoreClock, nvidiaMemClock;
unsigned int nvidiaTemp = 0, nvidiaCoreClock = 0, nvidiaMemClock = 0, nvidiaPowerUsage = 0;
struct nvmlUtilization_st nvidiaUtilization;
struct nvmlMemory_st nvidiaMemory {};
@ -48,6 +48,7 @@ bool getNVMLInfo(){
nvml.nvmlDeviceGetClockInfo(nvidiaDevice, NVML_CLOCK_GRAPHICS, &nvidiaCoreClock);
nvml.nvmlDeviceGetClockInfo(nvidiaDevice, NVML_CLOCK_MEM, &nvidiaMemClock);
nvml.nvmlDeviceGetPciInfo_v3(nvidiaDevice, &nvidiaPciInfo);
nvml.nvmlDeviceGetPowerUsage(nvidiaDevice, &nvidiaPowerUsage);
deviceID = nvidiaPciInfo.pciDeviceId >> 16;
if (response == NVML_ERROR_NOT_SUPPORTED)

42
src/overlay.cpp
Unescape Escape View File

@ -70,7 +70,6 @@ bool open = false;
string gpuString;
float offset_x, offset_y, hudSpacing;
int hudFirstRow, hudSecondRow;
struct amdGpu amdgpu;
struct fps_limit fps_limit_stats;
VkPhysicalDeviceDriverProperties driverProps = {};
int32_t deviceID;
@ -811,22 +810,24 @@ void init_gpu_stats(uint32_t& vendorID, overlay_params& params)
std::cerr << "using amdgpu path: " << path << std::endl;
#endif
if (!amdGpuFile)
amdGpuFile = fopen((path + "/gpu_busy_percent").c_str(), "r");
if (!amdGpuVramTotalFile)
amdGpuVramTotalFile = fopen((path + "/mem_info_vram_total").c_str(), "r");
if (!amdGpuVramUsedFile)
amdGpuVramUsedFile = fopen((path + "/mem_info_vram_used").c_str(), "r");
if (!amdgpu.busy)
amdgpu.busy = fopen((path + "/gpu_busy_percent").c_str(), "r");
if (!amdgpu.vram_total)
amdgpu.vram_total = fopen((path + "/mem_info_vram_total").c_str(), "r");
if (!amdgpu.vram_used)
amdgpu.vram_used = fopen((path + "/mem_info_vram_used").c_str(), "r");
path += "/hwmon/";
string tempFolder;
if (find_folder(path, "hwmon", tempFolder)) {
if (!amdGpuCoreClockFile)
amdGpuCoreClockFile = fopen((path + tempFolder + "/freq1_input").c_str(), "r");
if (!amdGpuMemoryClockFile)
amdGpuMemoryClockFile = fopen((path + tempFolder + "/freq2_input").c_str(), "r");
if (!amdTempFile)
amdTempFile = fopen((path + tempFolder + "/temp1_input").c_str(), "r");
if (!amdgpu.core_clock)
amdgpu.core_clock = fopen((path + tempFolder + "/freq1_input").c_str(), "r");
if (!amdgpu.memory_clock)
amdgpu.memory_clock = fopen((path + tempFolder + "/freq2_input").c_str(), "r");
if (!amdgpu.temp)
amdgpu.temp = fopen((path + tempFolder + "/temp1_input").c_str(), "r");
if (!amdgpu.power_usage)
amdgpu.power_usage = fopen((path + tempFolder + "/power1_average").c_str(), "r");
params.enabled[OVERLAY_PARAM_ENABLED_gpu_stats] = true;
vendorID = 0x1002;
@ -835,7 +836,7 @@ void init_gpu_stats(uint32_t& vendorID, overlay_params& params)
}
// don't bother then
if (!amdGpuFile && !amdTempFile && !amdGpuVramTotalFile && !amdGpuVramUsedFile) {
if (!amdgpu.busy && !amdgpu.temp && !amdgpu.vram_total && !amdgpu.vram_used) {
params.enabled[OVERLAY_PARAM_ENABLED_gpu_stats] = false;
}
}
@ -983,7 +984,7 @@ void update_hud_info(struct swapchain_stats& sw_stats, struct overlay_params& pa
if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_stats]) {
if (vendorID == 0x1002)
std::thread(getAmdGpuUsage).detach();
std::thread(getAmdGpuInfo).detach();
if (vendorID == 0x10de)
std::thread(getNvidiaGpuInfo).detach();
@ -1267,12 +1268,23 @@ void render_imgui(swapchain_stats& data, struct overlay_params& params, ImVec2&
ImGui::Text("°C");
}
if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_core_clock]){
if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_power])
ImGui::TableNextRow();
ImGui::TableNextCell();
right_aligned_text(char_width * 4, "%i", gpu_info.CoreClock);
ImGui::SameLine(0, 1.0f);
ImGui::PushFont(data.font1);
ImGui::Text("MHz");
ImGui::PopFont();
if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_power]) {
ImGui::TableNextCell();
right_aligned_text(char_width * 4, "%i", gpu_info.powerUsage);
ImGui::SameLine(0, 1.0f);
ImGui::PushFont(data.font1);
ImGui::Text("W");
ImGui::PopFont();
}
}
}
if(params.enabled[OVERLAY_PARAM_ENABLED_cpu_stats]){

22
src/overlay_params.cpp
Unescape Escape View File

@ -338,7 +338,7 @@ parse_overlay_config(struct overlay_params *params,
params->enabled[OVERLAY_PARAM_ENABLED_io_read] = false;
params->enabled[OVERLAY_PARAM_ENABLED_io_write] = false;
params->fps_sampling_period = 500000; /* 500ms */
params->width = 280;
params->width = 0;
params->height = 140;
params->control = -1;
params->fps_limit = 0;
@ -436,17 +436,21 @@ parse_overlay_config(struct overlay_params *params,
if (!params->font_size) {
params->font_size = 24;
} else {
params->width = params->font_size * 11.7;
}
//increase hud width if io read and write
if (params->enabled[OVERLAY_PARAM_ENABLED_io_read] && params->enabled[OVERLAY_PARAM_ENABLED_io_write] && params->width == 280)
params->width = 15 * params->font_size;
if (params->enabled[OVERLAY_PARAM_ENABLED_gpu_core_clock] && params->enabled[OVERLAY_PARAM_ENABLED_gpu_temp] && params->enabled[OVERLAY_PARAM_ENABLED_gpu_stats]){
params->tableCols = 4;
params->width = 20 * params->font_size;
if (!params->width) {
if (!params->enabled[OVERLAY_PARAM_ENABLED_gpu_power]
&& params->enabled[OVERLAY_PARAM_ENABLED_gpu_core_clock]
&& params->enabled[OVERLAY_PARAM_ENABLED_gpu_temp]
&& params->enabled[OVERLAY_PARAM_ENABLED_gpu_stats]) {
params->tableCols = 4;
params->width = 20 * params->font_size;
} else if ((params->enabled[OVERLAY_PARAM_ENABLED_io_read] || params->enabled[OVERLAY_PARAM_ENABLED_io_write])) {
params->width = 15 * params->font_size;
} else {
params->width = params->font_size * 11.7;
}
}
// set frametime limit

1
src/overlay_params.h
Unescape Escape View File

@ -40,6 +40,7 @@ typedef unsigned long KeySym;
OVERLAY_PARAM_BOOL(io_write) \
OVERLAY_PARAM_BOOL(gpu_mem_clock) \
OVERLAY_PARAM_BOOL(gpu_core_clock) \
OVERLAY_PARAM_BOOL(gpu_power) \
OVERLAY_PARAM_BOOL(arch) \
OVERLAY_PARAM_BOOL(media_player) \
OVERLAY_PARAM_BOOL(version) \

Write Preview
Loading…
Cancel
Save