DragonX/ObsidianDragon
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 4 Wiki Activity
Files
8ef8abeb371a7f78cbef9f945cba7bb3c4dcdfd4
ObsidianDragon/src/util/platform.cpp
DanS 8ef8abeb37 feat: thread benchmark, GPU-aware idle mining, thread scaling fix 
- Add pool mining thread benchmark: cycles through thread counts with
  20s warmup + 10s measurement to find optimal setting for CPU
- Add GPU-aware idle detection: GPU utilization >= 10% (video, games)
  treats system as active; toggle in mining tab header (default: on)
  Supports AMD sysfs, NVIDIA nvidia-smi, Intel freq ratio; -1 on macOS
- Fix idle thread scaling: use getRequestedThreads() for immediate
  thread count instead of xmrig API threads_active which lags on restart
- Apply active thread count on initial mining start when user is active
- Skip idle mining adjustments while benchmark is running
- Disable thread grid drag-to-select during benchmark
- Add idle_gpu_aware setting with JSON persistence (default: true)
- Add 7 i18n English strings for benchmark and GPU-aware tooltips
2026-04-01 17:06:05 -05:00

794 lines
26 KiB
C++
Raw Blame History

// DragonX Wallet - ImGui Edition
// Copyright 2024-2026 The Hush Developers
// Released under the GPLv3
#include "platform.h"
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <sstream>
#include <filesystem>
// Embedded ui.toml (generated at build time)
#if __has_include("ui_toml_embedded.h")
#include "ui_toml_embedded.h"
#define HAS_EMBEDDED_UI_TOML 1
#else
#define HAS_EMBEDDED_UI_TOML 0
#endif
#include <sys/stat.h>
#ifdef _WIN32
#include <windows.h>
#include <shellapi.h>
#include <shlobj.h>
#include <psapi.h>
#include <tlhelp32.h>
#else
#include <unistd.h>
#include <pwd.h>
#include <dirent.h>
#include <dlfcn.h>
#ifdef __APPLE__
#include <mach-o/dyld.h>
#include <sys/sysctl.h>
#include <mach/mach.h>
#endif
#endif
#include "../util/logger.h"
namespace dragonx {
namespace util {
bool Platform::openUrl(const std::string& url)
{
if (url.empty()) return false;
#ifdef _WIN32
// Windows: Use ShellExecute
HINSTANCE result = ShellExecuteA(nullptr, "open", url.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
return (reinterpret_cast<intptr_t>(result) > 32);
#elif defined(__APPLE__)
// macOS: Use 'open' command
std::string cmd = "open \"" + url + "\" &";
return (system(cmd.c_str()) == 0);
#else
// Linux: Use xdg-open
std::string cmd = "xdg-open \"" + url + "\" >/dev/null 2>&1 &";
return (system(cmd.c_str()) == 0);
#endif
}
bool Platform::openFolder(const std::string& path, bool createIfMissing)
{
if (path.empty()) return false;
// Create directory if it doesn't exist
if (createIfMissing) {
#ifdef _WIN32
// Windows: Create directory recursively
std::string cmd = "mkdir \"" + path + "\" 2>nul";
(void)system(cmd.c_str()); // Ignore return value - dir may already exist
#else
// Linux/macOS: Create directory with parents
std::string cmd = "mkdir -p \"" + path + "\" 2>/dev/null";
(void)system(cmd.c_str()); // Ignore return value - dir may already exist
#endif
}
#ifdef _WIN32
// Windows: Use explorer.exe to open folder
HINSTANCE result = ShellExecuteA(nullptr, "explore", path.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
return (reinterpret_cast<intptr_t>(result) > 32);
#elif defined(__APPLE__)
// macOS: Use 'open' command (works for folders too)
std::string cmd = "open \"" + path + "\" &";
return (system(cmd.c_str()) == 0);
#else
// Linux: Use xdg-open (works for folders too)
std::string cmd = "xdg-open \"" + path + "\" >/dev/null 2>&1 &";
return (system(cmd.c_str()) == 0);
#endif
}
uint64_t Platform::getFileSize(const std::string& path)
{
struct stat st;
if (stat(path.c_str(), &st) == 0) {
return static_cast<uint64_t>(st.st_size);
}
return 0;
}
std::string Platform::formatFileSize(uint64_t bytes)
{
char buf[64];
if (bytes >= 1024ULL * 1024ULL * 1024ULL) {
snprintf(buf, sizeof(buf), "%.2f GB", bytes / (1024.0 * 1024.0 * 1024.0));
} else if (bytes >= 1024ULL * 1024ULL) {
snprintf(buf, sizeof(buf), "%.2f MB", bytes / (1024.0 * 1024.0));
} else if (bytes >= 1024ULL) {
snprintf(buf, sizeof(buf), "%.2f KB", bytes / 1024.0);
} else {
snprintf(buf, sizeof(buf), "%llu bytes", static_cast<unsigned long long>(bytes));
}
return std::string(buf);
}
std::string Platform::getHomeDir()
{
#ifdef _WIN32
char path[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(nullptr, CSIDL_PROFILE, nullptr, 0, path))) {
return std::string(path);
}
// Fallback
const char* home = getenv("USERPROFILE");
return home ? home : "C:\\";
#else
const char* home = getenv("HOME");
if (home) return home;
// Fallback to passwd entry
struct passwd* pw = getpwuid(getuid());
if (pw && pw->pw_dir) return pw->pw_dir;
return "/tmp";
#endif
}
std::string Platform::getDragonXDataDir()
{
#ifdef _WIN32
char path[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(nullptr, CSIDL_APPDATA, nullptr, 0, path))) {
return std::string(path) + "\\Hush\\DRAGONX\\";
}
return getHomeDir() + "\\AppData\\Roaming\\Hush\\DRAGONX\\";
#elif defined(__APPLE__)
return getHomeDir() + "/Library/Application Support/Hush/DRAGONX/";
#else
return getHomeDir() + "/.hush/DRAGONX/";
#endif
}
std::string Platform::getDataDir()
{
return getDragonXDataDir();
}
std::string Platform::getConfigDir()
{
#ifdef _WIN32
char path[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(nullptr, CSIDL_APPDATA, nullptr, 0, path))) {
return std::string(path) + "\\ObsidianDragon\\";
}
return getHomeDir() + "\\AppData\\Roaming\\ObsidianDragon\\";
#else
return getHomeDir() + "/.config/ObsidianDragon/";
#endif
}
bool Platform::deleteFile(const std::string& path)
{
#ifdef _WIN32
return DeleteFileA(path.c_str()) != 0 || GetLastError() == ERROR_FILE_NOT_FOUND;
#else
return (remove(path.c_str()) == 0 || errno == ENOENT);
#endif
}
std::string Platform::getExecutableDirectory()
{
#ifdef _WIN32
char path[MAX_PATH];
DWORD len = GetModuleFileNameA(nullptr, path, MAX_PATH);
if (len > 0 && len < MAX_PATH) {
std::string fullPath(path);
size_t pos = fullPath.find_last_of("\\/");
if (pos != std::string::npos) {
return fullPath.substr(0, pos);
}
}
return ".";
#elif defined(__APPLE__)
char path[1024];
uint32_t size = sizeof(path);
if (_NSGetExecutablePath(path, &size) == 0) {
char* resolved = realpath(path, nullptr);
if (resolved) {
std::string fullPath(resolved);
free(resolved);
size_t pos = fullPath.find_last_of('/');
if (pos != std::string::npos) {
return fullPath.substr(0, pos);
}
}
}
return ".";
#else
// Linux: read /proc/self/exe
char path[1024];
ssize_t len = readlink("/proc/self/exe", path, sizeof(path) - 1);
if (len > 0) {
path[len] = '\0';
std::string fullPath(path);
size_t pos = fullPath.find_last_of('/');
if (pos != std::string::npos) {
return fullPath.substr(0, pos);
}
}
return ".";
#endif
}
std::string getExecutableDirectory()
{
return Platform::getExecutableDirectory();
}
std::string Platform::getObsidianDragonDir()
{
#ifdef _WIN32
const char* appdata = std::getenv("APPDATA");
if (appdata) {
return (std::filesystem::path(appdata) / "ObsidianDragon").string();
}
return (std::filesystem::path(getHomeDir()) / "AppData" / "Roaming" / "ObsidianDragon").string();
#elif defined(__APPLE__)
return (std::filesystem::path(getHomeDir()) / "Library" / "Application Support" / "ObsidianDragon").string();
#else
const char* xdg_config = std::getenv("XDG_CONFIG_HOME");
if (xdg_config) {
return (std::filesystem::path(xdg_config) / "ObsidianDragon").string();
}
return (std::filesystem::path(getHomeDir()) / ".config" / "ObsidianDragon").string();
#endif
}
void Platform::ensureObsidianDragonSetup()
{
namespace fs = std::filesystem;
fs::path base = getObsidianDragonDir();
fs::path themes_dir = base / "themes";
fs::path example_dir = base / "example" / "example_theme";
fs::path example_img = example_dir / "img";
// Create directory structure
std::error_code ec;
fs::create_directories(themes_dir, ec);
fs::create_directories(example_img, ec);
if (ec) {
DEBUG_LOGF("Warning: Could not create ObsidianDragon directories: %s\n", ec.message().c_str());
return;
}
DEBUG_LOGF("ObsidianDragon: Config directory: %s\n", base.string().c_str());
// Write example theme.toml — a full copy of ui.toml so users can see
// and modify the complete layout+theme structure. UISchema can load
// themes from TOML format.
// Regenerate whenever the binary is newer than the example file, so
// layout changes in ui.toml are always reflected.
fs::path example_toml = example_dir / "theme.toml";
bool needsWrite = !fs::exists(example_toml);
if (!needsWrite) {
// Regenerate if the running binary is newer than the example file
fs::path exePath = fs::path(getExecutableDirectory()) /
#ifdef _WIN32
"ObsidianDragon.exe";
#else
"ObsidianDragon";
#endif
std::error_code tec;
auto exeTime = fs::last_write_time(exePath, tec);
auto fileTime = fs::last_write_time(example_toml, tec);
if (!tec && exeTime > fileTime)
needsWrite = true;
}
if (needsWrite) {
std::ofstream f(example_toml);
if (f.is_open()) {
// Use the build-time embedded copy first; fall back to the
// bundled file on disk.
std::string content;
#if HAS_EMBEDDED_UI_TOML
content.assign(reinterpret_cast<const char*>(embedded::ui_toml_data),
embedded::ui_toml_size);
#else
{
fs::path bundled = fs::path(getExecutableDirectory()) / "res" / "themes" / "ui.toml";
std::ifstream src(bundled);
if (src.is_open()) {
std::ostringstream ss;
ss << src.rdbuf();
content = ss.str();
}
}
#endif
if (!content.empty()) {
// Patch the theme metadata so the example is clearly
// distinguishable from the bundled default.
// In TOML: name = "DragonX" → name = "Example Theme"
auto replaceFirst = [&](const std::string& key,
const std::string& oldVal,
const std::string& newVal) {
// Find 'key = "oldVal"' pattern and replace oldVal
std::string needle = key + " = ";
auto pos = content.find(needle);
if (pos == std::string::npos) return;
auto vpos = content.find(oldVal, pos);
if (vpos != std::string::npos && vpos - pos < 80)
content.replace(vpos, oldVal.size(), newVal);
};
replaceFirst("name", "\"DragonX\"", "\"Example Theme\"");
replaceFirst("author", "\"The Hush Developers\"", "\"Your Name\"");
// Prepend comment block (TOML uses # for comments natively)
std::string header =
"# === DragonX Wallet Theme File ===\n"
"# Copy this entire folder into the 'themes' folder to use it.\n"
"# The folder name becomes the theme ID.\n"
"#\n"
"# === Images ===\n"
"# Place image files in the 'img' subfolder.\n"
"# Specify custom filenames below, or use the defaults:\n"
"# backgrounds/gradient/dark_gradient.png - background gradient overlay\n"
"# logos/logo_ObsidianDragon_dark.png - sidebar logo (128x128 recommended)\n"
"#\n"
"# === Colors ===\n"
"# Colors use CSS-style formats: #RRGGBB, #RRGGBBAA, or rgba(r,g,b,a)\n"
"# Palette variables can be referenced elsewhere with var(--name)\n\n";
content = header + content;
} else {
DEBUG_LOGF("ObsidianDragon: Warning — ui.toml not available, skipping example theme\n");
}
f << content;
f.close();
DEBUG_LOGF("ObsidianDragon: Created example theme: %s\n", example_toml.string().c_str());
}
}
// Copy bundled images into example/example_theme/img/ for reference
fs::path exe_dir = getExecutableDirectory();
fs::path res_img = exe_dir / "res" / "img";
auto copyIfMissing = [&](const char* srcRelPath, const char* dstFilename) {
fs::path src = res_img / srcRelPath;
fs::path dst = example_img / dstFilename;
if (fs::exists(src) && !fs::exists(dst)) {
std::error_code cpec;
fs::copy_file(src, dst, cpec);
if (!cpec) {
DEBUG_LOGF("ObsidianDragon: Copied %s to example theme\n", dstFilename);
}
}
};
copyIfMissing("backgrounds/gradient/dark_gradient.png", "dark_gradient.png");
copyIfMissing("logos/logo_ObsidianDragon_dark.png", "logo_ObsidianDragon_dark.png");
copyIfMissing("logos/logo_ObsidianDragon_light.png", "logo_ObsidianDragon_light.png");
}
double Platform::getTotalSystemRAM_MB()
{
static double cached = 0.0;
if (cached > 0.0) return cached;
#ifdef _WIN32
MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(memInfo);
if (GlobalMemoryStatusEx(&memInfo)) {
cached = (double)memInfo.ullTotalPhys / (1024.0 * 1024.0);
}
#elif defined(__APPLE__)
int64_t memSize = 0;
size_t len = sizeof(memSize);
if (sysctlbyname("hw.memsize", &memSize, &len, nullptr, 0) == 0) {
cached = (double)memSize / (1024.0 * 1024.0);
}
#else
// Linux: use sysconf
long pages = sysconf(_SC_PHYS_PAGES);
long pageSize = sysconf(_SC_PAGE_SIZE);
if (pages > 0 && pageSize > 0) {
cached = (double)pages * (double)pageSize / (1024.0 * 1024.0);
}
#endif
return cached;
}
double Platform::getUsedSystemRAM_MB()
{
#ifdef _WIN32
MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(memInfo);
if (GlobalMemoryStatusEx(&memInfo)) {
double total = (double)memInfo.ullTotalPhys / (1024.0 * 1024.0);
double avail = (double)memInfo.ullAvailPhys / (1024.0 * 1024.0);
return total - avail;
}
return 0.0;
#elif defined(__APPLE__)
// macOS: vm_statistics64 for free/active/inactive/wired pages
vm_size_t pageSize = 0;
host_page_size(mach_host_self(), &pageSize);
vm_statistics64_data_t vmStats;
mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
if (host_statistics64(mach_host_self(), HOST_VM_INFO64,
(host_info64_t)&vmStats, &count) == KERN_SUCCESS) {
// "used" = total - free - inactive (matches Activity Monitor "Memory Used")
double total = getTotalSystemRAM_MB();
double freeMB = (double)(vmStats.free_count + vmStats.inactive_count) * (double)pageSize / (1024.0 * 1024.0);
return total - freeMB;
}
return 0.0;
#else
// Linux: parse /proc/meminfo for MemAvailable
FILE* f = fopen("/proc/meminfo", "r");
if (!f) return 0.0;
double totalMB = 0.0, availMB = 0.0;
char line[256];
int found = 0;
while (fgets(line, sizeof(line), f) && found < 2) {
long val = 0;
if (strncmp(line, "MemTotal:", 9) == 0) {
if (sscanf(line + 9, "%ld", &val) == 1) { totalMB = (double)val / 1024.0; found++; }
} else if (strncmp(line, "MemAvailable:", 13) == 0) {
if (sscanf(line + 13, "%ld", &val) == 1) { availMB = (double)val / 1024.0; found++; }
}
}
fclose(f);
if (found == 2) return totalMB - availMB;
return 0.0;
#endif
}
double Platform::getSelfMemoryUsageMB()
{
#ifdef _WIN32
PROCESS_MEMORY_COUNTERS pmc;
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) {
return (double)pmc.WorkingSetSize / (1024.0 * 1024.0);
}
return 0.0;
#elif defined(__APPLE__)
struct mach_task_basic_info info;
mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO,
(task_info_t)&info, &count) == KERN_SUCCESS) {
return (double)info.resident_size / (1024.0 * 1024.0);
}
return 0.0;
#else
// Linux: read /proc/self/status for VmRSS
FILE* f = fopen("/proc/self/status", "r");
if (!f) return 0.0;
char line[256];
while (fgets(line, sizeof(line), f)) {
if (strncmp(line, "VmRSS:", 6) == 0) {
long val = 0;
if (sscanf(line + 6, "%ld", &val) == 1) {
fclose(f);
return (double)val / 1024.0; // kB -> MB
}
}
}
fclose(f);
return 0.0;
#endif
}
double Platform::getDaemonMemoryUsageMB()
{
#ifdef _WIN32
// Windows: use CreateToolhelp32Snapshot to find dragonxd.exe processes
// and query their working set size.
HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (snap == INVALID_HANDLE_VALUE) return 0.0;
PROCESSENTRY32 entry;
entry.dwSize = sizeof(entry);
double totalMB = 0.0;
if (Process32First(snap, &entry)) {
do {
if (_stricmp(entry.szExeFile, "dragonxd.exe") == 0) {
// GetProcessMemoryInfo requires PROCESS_QUERY_INFORMATION + PROCESS_VM_READ.
// Try full access first; fall back to limited for elevated processes.
HANDLE hProc = OpenProcess(
PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
FALSE, entry.th32ProcessID);
if (!hProc) {
hProc = OpenProcess(
PROCESS_QUERY_LIMITED_INFORMATION,
FALSE, entry.th32ProcessID);
}
if (hProc) {
PROCESS_MEMORY_COUNTERS pmc;
ZeroMemory(&pmc, sizeof(pmc));
pmc.cb = sizeof(pmc);
if (GetProcessMemoryInfo(hProc, &pmc, sizeof(pmc)))
totalMB += (double)pmc.WorkingSetSize / (1024.0 * 1024.0);
CloseHandle(hProc);
}
}
} while (Process32Next(snap, &entry));
}
CloseHandle(snap);
return totalMB;
#elif defined(__APPLE__)
// macOS: use pgrep to find dragonxd PIDs, then read RSS via proc_pidinfo
FILE* fp = popen("pgrep -x dragonxd", "r");
if (!fp) return 0.0;
double totalMB = 0.0;
char line[64];
while (fgets(line, sizeof(line), fp)) {
pid_t pid = (pid_t)atoi(line);
if (pid <= 0) continue;
struct mach_task_basic_info info;
mach_msg_type_number_t cnt = MACH_TASK_BASIC_INFO_COUNT;
// We can't directly task_for_pid without entitlements, so fall back to ps
char cmd[128];
snprintf(cmd, sizeof(cmd), "ps -o rss= -p %d", pid);
FILE* ps = popen(cmd, "r");
if (ps) {
char rssLine[64];
if (fgets(rssLine, sizeof(rssLine), ps)) {
long rssKB = atol(rssLine);
if (rssKB > 0) totalMB += (double)rssKB / 1024.0;
}
pclose(ps);
}
}
pclose(fp);
return totalMB;
#else
// Linux: iterate /proc/<pid>/comm looking for "dragonxd"
DIR* procDir = opendir("/proc");
if (!procDir) return 0.0;
double totalMB = 0.0;
pid_t selfPid = getpid();
struct dirent* entry;
while ((entry = readdir(procDir)) != nullptr) {
// Only numeric directories (PIDs)
if (entry->d_name[0] < '0' || entry->d_name[0] > '9') continue;
pid_t pid = (pid_t)atoi(entry->d_name);
if (pid <= 0 || pid == selfPid) continue;
// Read comm (process name)
char commPath[64];
snprintf(commPath, sizeof(commPath), "/proc/%d/comm", pid);
FILE* cf = fopen(commPath, "r");
if (!cf) continue;
char comm[256] = {};
if (fgets(comm, sizeof(comm), cf)) {
// Strip trailing newline
size_t len = strlen(comm);
if (len > 0 && comm[len - 1] == '\n') comm[len - 1] = '\0';
}
fclose(cf);
if (strcmp(comm, "dragonxd") != 0) continue;
// Read VmRSS from /proc/<pid>/status
char statusPath[64];
snprintf(statusPath, sizeof(statusPath), "/proc/%d/status", pid);
FILE* sf = fopen(statusPath, "r");
if (!sf) continue;
char sline[256];
while (fgets(sline, sizeof(sline), sf)) {
if (strncmp(sline, "VmRSS:", 6) == 0) {
long val = 0;
if (sscanf(sline + 6, "%ld", &val) == 1)
totalMB += (double)val / 1024.0; // kB -> MB
break;
}
}
fclose(sf);
}
closedir(procDir);
return totalMB;
#endif
}
// ============================================================================
// System-wide idle time detection
// ============================================================================
int Platform::getSystemIdleSeconds()
{
#ifdef _WIN32
LASTINPUTINFO lii;
lii.cbSize = sizeof(lii);
if (GetLastInputInfo(&lii)) {
DWORD elapsed = GetTickCount() - lii.dwTime;
return (int)(elapsed / 1000);
}
return 0;
#elif defined(__APPLE__)
// macOS: use IOKit HIDSystem idle time
// Fallback to 0 (feature not supported) to keep it simple
return 0;
#else
// Linux: dynamically load libXss to query X11 screensaver idle time
// This avoids a hard link dependency on X11/Xss libraries.
typedef struct {
int type;
unsigned long serial;
int/*Bool*/ send_event;
void* /*Display**/ display;
unsigned long/*Drawable*/ window;
int state;
int kind;
unsigned long til_or_since;
unsigned long idle;
unsigned long eventMask;
} XScreenSaverInfo;
// Function pointer types
typedef void* (*XOpenDisplay_t)(const char*);
typedef unsigned long (*XDefaultRootWindow_t)(void*);
typedef XScreenSaverInfo* (*XScreenSaverAllocInfo_t)(void);
typedef int (*XScreenSaverQueryInfo_t)(void*, unsigned long, XScreenSaverInfo*);
typedef int (*XCloseDisplay_t)(void*);
typedef void (*XFree_t)(void*);
static bool s_tried = false;
static void* s_x11 = nullptr;
static void* s_xss = nullptr;
static XOpenDisplay_t s_XOpenDisplay = nullptr;
static XDefaultRootWindow_t s_XDefaultRootWindow = nullptr;
static XScreenSaverAllocInfo_t s_XScreenSaverAllocInfo = nullptr;
static XScreenSaverQueryInfo_t s_XScreenSaverQueryInfo = nullptr;
static XCloseDisplay_t s_XCloseDisplay = nullptr;
(void)s_XCloseDisplay; // retained for potential cleanup
static XFree_t s_XFree = nullptr;
static void* s_display = nullptr;
if (!s_tried) {
s_tried = true;
s_x11 = dlopen("libX11.so.6", RTLD_LAZY);
s_xss = dlopen("libXss.so.1", RTLD_LAZY);
if (s_x11 && s_xss) {
s_XOpenDisplay = (XOpenDisplay_t)dlsym(s_x11, "XOpenDisplay");
s_XDefaultRootWindow = (XDefaultRootWindow_t)dlsym(s_x11, "XDefaultRootWindow");
s_XCloseDisplay = (XCloseDisplay_t)dlsym(s_x11, "XCloseDisplay"); // NOLINT
s_XFree = (XFree_t)dlsym(s_x11, "XFree");
s_XScreenSaverAllocInfo = (XScreenSaverAllocInfo_t)dlsym(s_xss, "XScreenSaverAllocInfo");
s_XScreenSaverQueryInfo = (XScreenSaverQueryInfo_t)dlsym(s_xss, "XScreenSaverQueryInfo");
if (s_XOpenDisplay && s_XDefaultRootWindow && s_XScreenSaverAllocInfo && s_XScreenSaverQueryInfo) {
s_display = s_XOpenDisplay(nullptr);
}
}
}
if (!s_display || !s_XScreenSaverAllocInfo || !s_XScreenSaverQueryInfo || !s_XDefaultRootWindow) {
return 0;
}
XScreenSaverInfo* info = s_XScreenSaverAllocInfo();
if (!info) return 0;
int idleSec = 0;
unsigned long root = s_XDefaultRootWindow(s_display);
if (s_XScreenSaverQueryInfo(s_display, root, info)) {
idleSec = (int)(info->idle / 1000); // idle is in milliseconds
}
if (s_XFree) s_XFree(info);
return idleSec;
#endif
}
// ============================================================================
// GPU utilization detection
// ============================================================================
int Platform::getGpuUtilization()
{
#ifdef _WIN32
// Windows: read GPU utilization via SetupAPI / D3DKMT
// Not all GPUs expose this; return -1 if unavailable.
// Use a popen fallback: nvidia-smi for NVIDIA, or return -1.
static bool s_tried_nvidia = false;
static bool s_has_nvidia = false;
if (!s_tried_nvidia) {
s_tried_nvidia = true;
FILE* f = _popen("where nvidia-smi 2>nul", "r");
if (f) {
char buf[256];
s_has_nvidia = (fgets(buf, sizeof(buf), f) != nullptr);
_pclose(f);
}
}
if (s_has_nvidia) {
FILE* f = _popen("nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits 2>nul", "r");
if (f) {
char buf[64];
int util = -1;
if (fgets(buf, sizeof(buf), f)) {
util = atoi(buf);
if (util < 0 || util > 100) util = -1;
}
_pclose(f);
return util;
}
}
return -1;
#elif defined(__APPLE__)
return -1;
#else
// Linux: try multiple GPU sysfs paths
// AMD: /sys/class/drm/card*/device/gpu_busy_percent
{
// Try card0 through card3
char path[128];
for (int i = 0; i < 4; i++) {
snprintf(path, sizeof(path), "/sys/class/drm/card%d/device/gpu_busy_percent", i);
std::ifstream ifs(path);
if (ifs.is_open()) {
int val = -1;
ifs >> val;
if (val >= 0 && val <= 100)
return val;
}
}
}
// NVIDIA: nvidia-smi (binary may exist even without sysfs)
{
static bool s_tried = false;
static bool s_has_nvidia_smi = false;
if (!s_tried) {
s_tried = true;
FILE* f = popen("which nvidia-smi 2>/dev/null", "r");
if (f) {
char buf[256];
s_has_nvidia_smi = (fgets(buf, sizeof(buf), f) != nullptr);
pclose(f);
}
}
if (s_has_nvidia_smi) {
FILE* f = popen("nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits 2>/dev/null", "r");
if (f) {
char buf[64];
int util = -1;
if (fgets(buf, sizeof(buf), f)) {
util = atoi(buf);
if (util < 0 || util > 100) util = -1;
}
pclose(f);
return util;
}
}
}
// Intel: compare current vs max freq as a rough proxy
{
std::ifstream curF("/sys/class/drm/card0/gt_cur_freq_mhz");
std::ifstream maxF("/sys/class/drm/card0/gt_max_freq_mhz");
if (curF.is_open() && maxF.is_open()) {
int cur = 0, mx = 0;
curF >> cur;
maxF >> mx;
if (mx > 0)
return std::min(100, (cur * 100) / mx);
}
}
return -1;
#endif
}
} // namespace util
} // namespace dragonx
Reference in New Issue View Git Blame Copy Permalink