#![cfg(windows)]
use serde::Deserialize;
use std::collections::HashMap;
use wmi::{COMLibrary, Variant, WMIConnection};
#[derive(Debug, Clone)]
pub struct DxgiAdapterInfo {
pub description: String,
pub dedicated_video_memory: u64,
pub shared_system_memory: u64,
pub vendor_id: u32,
pub device_id: u32,
pub luid_low: u32,
pub luid_high: i32,
}
pub fn enumerate_dxgi_adapters() -> Vec<DxgiAdapterInfo> {
use windows::Win32::Graphics::Dxgi::{CreateDXGIFactory1, IDXGIFactory1};
let mut adapters = Vec::new();
let factory: IDXGIFactory1 = match unsafe { CreateDXGIFactory1() } {
Ok(f) => f,
Err(_) => return adapters,
};
let mut index = 0u32;
loop {
let adapter = match unsafe { factory.EnumAdapters(index) } {
Ok(a) => a,
Err(_) => break,
};
let desc = match unsafe { adapter.GetDesc() } {
Ok(d) => d,
Err(_) => {
index += 1;
continue;
}
};
let description = String::from_utf16_lossy(
&desc
.Description
.iter()
.copied()
.take_while(|&c| c != 0)
.collect::<Vec<u16>>(),
);
adapters.push(DxgiAdapterInfo {
description,
dedicated_video_memory: desc.DedicatedVideoMemory as u64,
shared_system_memory: desc.SharedSystemMemory as u64,
vendor_id: desc.VendorId,
device_id: desc.DeviceId,
luid_low: desc.AdapterLuid.LowPart,
luid_high: desc.AdapterLuid.HighPart,
});
index += 1;
}
adapters
}
pub fn find_dxgi_adapter(adapters: &[DxgiAdapterInfo], gpu_name: &str) -> Option<DxgiAdapterInfo> {
let name_lower = gpu_name.to_lowercase();
adapters
.iter()
.find(|a| a.description.to_lowercase().contains(&name_lower))
.cloned()
}
pub fn find_dxgi_adapter_by_vendor(
adapters: &[DxgiAdapterInfo],
vendor_id: u32,
) -> Option<DxgiAdapterInfo> {
adapters.iter().find(|a| a.vendor_id == vendor_id).cloned()
}
#[derive(Debug, Default, Clone)]
pub struct EngineUtilization {
pub graphics: Option<u8>,
pub compute: Option<u8>,
pub video_decode: Option<u8>,
pub video_encode: Option<u8>,
pub copy: Option<u8>,
pub overall: Option<u8>,
}
#[derive(Debug, Default, Clone)]
pub struct WinGpuPerfData {
pub engines: EngineUtilization,
pub dedicated_used: Option<u64>,
pub shared_used: Option<u64>,
pub temperature: Option<i32>,
}
pub fn format_luid(luid_high: i32, luid_low: u32) -> String {
format!("0x{:08x}_0x{:08x}", luid_high, luid_low)
}
fn counter_bytes(v: Option<&Variant>) -> Option<u64> {
match v {
Some(Variant::UI8(x)) => Some(*x),
Some(Variant::UI4(x)) => Some(*x as u64),
_ => None,
}
}
struct PerfCounterRows {
taken: std::time::Instant,
engines: Vec<(String, f64)>,
memory: Vec<(String, Option<u64>, Option<u64>)>,
}
static PERF_ROWS: std::sync::Mutex<Option<std::sync::Arc<PerfCounterRows>>> =
std::sync::Mutex::new(None);
const PERF_ROWS_TTL: std::time::Duration = std::time::Duration::from_millis(400);
fn perf_counter_rows() -> Option<std::sync::Arc<PerfCounterRows>> {
let mut cached = PERF_ROWS.lock().ok()?;
if let Some(rows) = cached.as_ref() {
if rows.taken.elapsed() < PERF_ROWS_TTL {
return Some(std::sync::Arc::clone(rows));
}
}
let com = COMLibrary::new().ok()?;
let wmi = WMIConnection::with_namespace_path("root\\CIMV2", com).ok()?;
let engines = wmi
.raw_query::<HashMap<String, Variant>>(
"SELECT Name, UtilizationPercentage FROM \
Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine",
)
.unwrap_or_default()
.iter()
.filter_map(|item| {
let name = match item.get("Name") {
Some(Variant::String(s)) => s.to_lowercase(),
_ => return None,
};
let util = match item.get("UtilizationPercentage") {
Some(Variant::UI8(v)) => *v as f64,
Some(Variant::UI4(v)) => *v as f64,
_ => return None,
};
Some((name, util))
})
.collect();
let memory = wmi
.raw_query::<HashMap<String, Variant>>(
"SELECT Name, DedicatedUsage, SharedUsage FROM \
Win32_PerfFormattedData_GPUPerformanceCounters_GPUAdapterMemory",
)
.unwrap_or_default()
.iter()
.filter_map(|item| {
let name = match item.get("Name") {
Some(Variant::String(s)) => s.to_lowercase(),
_ => return None,
};
Some((
name,
counter_bytes(item.get("DedicatedUsage")),
counter_bytes(item.get("SharedUsage")),
))
})
.collect();
let rows = std::sync::Arc::new(PerfCounterRows {
taken: std::time::Instant::now(),
engines,
memory,
});
*cached = Some(std::sync::Arc::clone(&rows));
Some(rows)
}
pub fn query_gpu_perf_counters(luid_filter: Option<&str>) -> WinGpuPerfData {
let mut data = WinGpuPerfData::default();
let Some(rows) = perf_counter_rows() else {
return data;
};
{
let results = &rows.engines;
let mut gfx_total: f64 = 0.0;
let mut gfx_count: u32 = 0;
let mut compute_total: f64 = 0.0;
let mut compute_count: u32 = 0;
let mut vdec_total: f64 = 0.0;
let mut vdec_count: u32 = 0;
let mut venc_total: f64 = 0.0;
let mut venc_count: u32 = 0;
let mut copy_total: f64 = 0.0;
let mut copy_count: u32 = 0;
for (name, util) in results {
let (name, util) = (name.as_str(), *util);
if let Some(luid) = luid_filter {
if !name.contains(&luid.to_lowercase()) {
continue;
}
}
if name.contains("engtype_3d") {
gfx_total += util;
gfx_count += 1;
} else if name.contains("engtype_compute") {
compute_total += util;
compute_count += 1;
} else if name.contains("engtype_videodecode") {
vdec_total += util;
vdec_count += 1;
} else if name.contains("engtype_videoencode") {
venc_total += util;
venc_count += 1;
} else if name.contains("engtype_copy") {
copy_total += util;
copy_count += 1;
}
}
let avg = |total: f64, count: u32| -> Option<u8> {
if count > 0 {
Some((total / count as f64).min(100.0) as u8)
} else {
None
}
};
data.engines.graphics = avg(gfx_total, gfx_count);
data.engines.compute = avg(compute_total, compute_count);
data.engines.video_decode = avg(vdec_total, vdec_count);
data.engines.video_encode = avg(venc_total, venc_count);
data.engines.copy = avg(copy_total, copy_count);
data.engines.overall = data.engines.graphics;
}
for (name, dedicated, shared) in &rows.memory {
if let Some(luid) = luid_filter {
if !name.contains(&luid.to_lowercase()) {
continue;
}
}
if dedicated.is_some() {
data.dedicated_used = *dedicated;
}
if shared.is_some() {
data.shared_used = *shared;
}
if dedicated.is_some_and(|v| v > 0) || shared.is_some_and(|v| v > 0) {
break;
}
}
data
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
struct HwMonSensor {
name: String,
#[allow(dead_code)]
sensor_type: String,
value: f32,
parent: String,
}
const HWMON_NAMESPACES: [&str; 2] = ["root\\OpenHardwareMonitor", "root\\LibreHardwareMonitor"];
static HWMON_NAMESPACE: std::sync::Mutex<Option<(std::time::Instant, Option<&'static str>)>> =
std::sync::Mutex::new(None);
const HWMON_PROBE_TTL: std::time::Duration = std::time::Duration::from_secs(60);
fn hwmon_namespace(com: COMLibrary) -> Option<&'static str> {
let mut cached = HWMON_NAMESPACE.lock().ok()?;
if let Some((probed_at, answer)) = *cached {
if probed_at.elapsed() < HWMON_PROBE_TTL {
return answer;
}
}
let answer = HWMON_NAMESPACES
.into_iter()
.find(|ns| WMIConnection::with_namespace_path(ns, com).is_ok());
*cached = Some((std::time::Instant::now(), answer));
answer
}
pub fn query_gpu_temperature_ohm(gpu_name_hint: &str) -> Option<i32> {
let com = COMLibrary::new().ok()?;
let namespace = hwmon_namespace(com)?;
let hint_lower = gpu_name_hint.to_lowercase();
{
let wmi = WMIConnection::with_namespace_path(namespace, com).ok()?;
let sensors: Vec<HwMonSensor> = wmi
.raw_query(
"SELECT Name, SensorType, Value, Parent FROM Sensor WHERE SensorType = 'Temperature'",
)
.unwrap_or_default();
for sensor in &sensors {
let parent_lower = sensor.parent.to_lowercase();
let name_lower = sensor.name.to_lowercase();
if (parent_lower.contains(&hint_lower) || name_lower.contains(&hint_lower))
&& sensor.value > 0.0
&& sensor.value < 150.0
{
return Some(sensor.value as i32);
}
}
for sensor in &sensors {
let parent_lower = sensor.parent.to_lowercase();
let name_lower = sensor.name.to_lowercase();
let is_gpu = parent_lower.contains("gpu")
|| parent_lower.contains("radeon")
|| parent_lower.contains("amd")
|| parent_lower.contains("intel")
|| parent_lower.contains("arc")
|| name_lower.contains("gpu");
if is_gpu && sensor.value > 0.0 && sensor.value < 150.0 {
return Some(sensor.value as i32);
}
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_format_luid() {
assert_eq!(format_luid(0, 0x0000ABCD), "0x00000000_0x0000abcd");
assert_eq!(format_luid(1, 0xDEADBEEF), "0x00000001_0xdeadbeef");
}
#[test]
fn test_engine_utilization_default() {
let eng = EngineUtilization::default();
assert!(eng.graphics.is_none());
assert!(eng.compute.is_none());
assert!(eng.video_decode.is_none());
assert!(eng.video_encode.is_none());
assert!(eng.copy.is_none());
assert_eq!(
eng.overall, None,
"no engine counter answered, so there is no overall figure"
);
}
#[test]
fn test_win_gpu_perf_data_default() {
let data = WinGpuPerfData::default();
assert_eq!(data.engines.overall, None);
assert_eq!(data.dedicated_used, None);
assert_eq!(data.shared_used, None);
assert!(data.temperature.is_none());
}
#[test]
fn test_counter_bytes_absent_is_not_zero() {
assert_eq!(counter_bytes(None), None);
assert_eq!(counter_bytes(Some(&Variant::String("x".into()))), None);
assert_eq!(counter_bytes(Some(&Variant::UI8(5))), Some(5));
assert_eq!(counter_bytes(Some(&Variant::UI4(7))), Some(7));
}
#[test]
fn test_dxgi_adapter_info_fields() {
let info = DxgiAdapterInfo {
description: "Test GPU".to_string(),
dedicated_video_memory: 8 * 1024 * 1024 * 1024, shared_system_memory: 16 * 1024 * 1024 * 1024,
vendor_id: 0x1002,
device_id: 0x73BF,
luid_low: 0x0000ABCD,
luid_high: 0,
};
assert_eq!(info.dedicated_video_memory, 8589934592);
assert_eq!(info.vendor_id, 0x1002);
}
}