Glassvision/IfcOpenShell
1
0
Fork 0
mirror of https://github.com/IfcOpenShell/IfcOpenShell.git synced 2026-08-29 08:13:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

bonsaiviewer: show pool and device VRAM in the performance stats

Browse Source 
FrameStats gains the geometry pool's used/capacity bytes and, on desktop,
the device-wide used/total reported by the driver (NVML via dlopen, or
amdgpu/i915 sysfs, matched to the wgpu adapter's vendor/device id so a
switchable-graphics laptop reports the card wgpu actually picked). The
device query is polled once a second, not per frame. Web has no VRAM
query, so the device figure is omitted there.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Dion Moult
2026-08-23 13:32:59 +10:00
parent 5fa14c3dea
commit b7d2b2fa3a
7 changed files with 313 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ifcviewer/GpuMemory.cpp
+201
View File
@@ -0,0 +1,201 @@
/********************************************************************************
* *
* This file is part of IfcOpenShell. *
* *
* IfcOpenShell is free software: you can redistribute it and/or modify *
* it under the terms of the Lesser GNU General Public License as published by *
* the Free Software Foundation, either version 3.0 of the License, or *
* (at your option) any later version. *
* *
* IfcOpenShell is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* Lesser GNU General Public License for more details. *
* *
* You should have received a copy of the Lesser GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
********************************************************************************/
#include "GpuMemory.h"
#include <cstdio>
#include <cstring>
#include <string>
#if defined(__linux__)
#include <dirent.h>
#include <dlfcn.h>
#endif
namespace ifcviewer {
namespace {
#if defined(__linux__)
// NVML, loaded at run time rather than linked: the viewer must run on machines
// with no NVIDIA driver at all, so a link-time dependency is not an option.
// Only the four entry points needed here are resolved.
struct Nvml {
void* handle = nullptr;
int (*init)() = nullptr;
int (*shutdown)() = nullptr;
int (*device_count)(unsigned*) = nullptr;
int (*handle_by_index)(unsigned, void**) = nullptr;
int (*pci_info)(void*, void*) = nullptr;
int (*memory_info)(void*, unsigned long long*) = nullptr;
bool load() {
// .so.1 first: the unversioned name is part of the -dev package and is
// frequently absent on user machines.
for (const char* name : {"libnvidia-ml.so.1", "libnvidia-ml.so"}) {
handle = dlopen(name, RTLD_LAZY | RTLD_LOCAL);
if (handle) break;
}
if (!handle) return false;
auto sym = [&](const char* n) { return dlsym(handle, n); };
init = (int (*)())sym("nvmlInit_v2");
shutdown = (int (*)())sym("nvmlShutdown");
device_count = (int (*)(unsigned*))sym("nvmlDeviceGetCount_v2");
handle_by_index = (int (*)(unsigned, void**))sym("nvmlDeviceGetHandleByIndex_v2");
pci_info = (int (*)(void*, void*))sym("nvmlDeviceGetPciInfo_v3");
memory_info = (int (*)(void*, unsigned long long*))sym("nvmlDeviceGetMemoryInfo");
return init && shutdown && device_count && handle_by_index && memory_info;
}
~Nvml() { if (handle) dlclose(handle); }
};
// nvmlPciInfo_t. Only pciDeviceId is read; the leading char arrays are sized
// from the NVML headers so the offset is right.
struct NvmlPciInfo {
char busIdLegacy[16];
unsigned domain;
unsigned bus;
unsigned device;
unsigned pciDeviceId; // (device_id << 16) | vendor_id
unsigned pciSubSystemId;
char busId[32];
};
bool queryNvml(std::uint32_t vendor_id, std::uint32_t device_id, GpuMemoryInfo& out) {
Nvml nvml;
if (!nvml.load()) return false;
if (nvml.init() != 0) return false;
unsigned count = 0;
bool found = false;
if (nvml.device_count(&count) == 0) {
for (unsigned i = 0; i < count && !found; ++i) {
void* dev = nullptr;
if (nvml.handle_by_index(i, &dev) != 0 || !dev) continue;
// Match the card wgpu picked. With a single NVIDIA device and no
// way to read its ids, fall through to it rather than reporting
// nothing -- a slightly uncertain number beats none.
if (nvml.pci_info && (vendor_id || device_id)) {
NvmlPciInfo pci{};
if (nvml.pci_info(dev, &pci) == 0) {
const unsigned dev_id = (pci.pciDeviceId >> 16) & 0xFFFF;
const unsigned ven_id = pci.pciDeviceId & 0xFFFF;
if (device_id && dev_id != device_id) continue;
if (vendor_id && ven_id != vendor_id) continue;
}
} else if (count != 1) {
continue;
}
// nvmlMemory_t: { total, free, used }, all unsigned long long.
//
// This reports more `used` than nvidia-smi does -- measured here,
// 1427 MiB against 1046 MiB, consistently -- because the v1 call
// folds driver-reserved memory into `used` where nvidia-smi
// accounts for it separately. The larger figure is the one worth
// having: what actually allocated on this card topped out around
// 2431 MB, against 2669 MB free by this measure and 3050 MB by
// nvidia-smi's. Budgeting against the optimistic number would
// promise memory that is not there.
unsigned long long mem[3] = {0, 0, 0};
if (nvml.memory_info(dev, mem) == 0 && mem[0] > 0) {
out.total_bytes = mem[0];
out.used_bytes = mem[2];
out.valid = true;
found = true;
}
}
}
nvml.shutdown();
return found;
}
// amdgpu and i915 expose VRAM through sysfs. Reads every card and keeps the
// one whose vendor/device ids match, because the first card is often the
// integrated GPU rather than the one in use.
bool readUint64(const std::string& path, std::uint64_t& out) {
FILE* f = std::fopen(path.c_str(), "r");
if (!f) return false;
unsigned long long v = 0;
const bool ok = std::fscanf(f, "%llu", &v) == 1;
std::fclose(f);
if (ok) out = v;
return ok;
}
bool readHexId(const std::string& path, std::uint32_t& out) {
FILE* f = std::fopen(path.c_str(), "r");
if (!f) return false;
unsigned v = 0;
const bool ok = std::fscanf(f, "0x%x", &v) == 1;
std::fclose(f);
if (ok) out = v;
return ok;
}
bool querySysfs(std::uint32_t vendor_id, std::uint32_t device_id, GpuMemoryInfo& out) {
DIR* dir = opendir("/sys/class/drm");
if (!dir) return false;
bool found = false;
while (dirent* entry = readdir(dir)) {
const std::string name = entry->d_name;
// "card0", not "card0-DP-1".
if (name.rfind("card", 0) != 0 || name.find('-') != std::string::npos) continue;
const std::string base = "/sys/class/drm/" + name + "/device/";
std::uint32_t ven = 0, dev = 0;
if (vendor_id && readHexId(base + "vendor", ven) && ven != vendor_id) continue;
if (device_id && readHexId(base + "device", dev) && dev != device_id) continue;
std::uint64_t total = 0, used = 0;
if (readUint64(base + "mem_info_vram_total", total) && total > 0) {
readUint64(base + "mem_info_vram_used", used);
out.total_bytes = total;
out.used_bytes = used;
out.valid = true;
found = true;
break;
}
}
closedir(dir);
return found;
}
#endif // __linux__
} // namespace
GpuMemoryInfo queryGpuMemory(std::uint32_t vendor_id, std::uint32_t device_id) {
GpuMemoryInfo info;
#if defined(__linux__)
if (queryNvml(vendor_id, device_id, info)) return info;
if (querySysfs(vendor_id, device_id, info)) return info;
#else
// Windows (DXGI QueryVideoMemoryInfo) and macOS
// (recommendedMaxWorkingSetSize) both expose this; not implemented here
// because neither can be verified from this machine. `valid` stays false,
// and callers fall back to behaving as they did before.
(void)vendor_id; (void)device_id;
#endif
return info;
}
} // namespace ifcviewer