use std::sync::{Mutex, OnceLock};
use windows::core::w;
use windows::Win32::System::Performance::{
PdhAddEnglishCounterW, PdhCollectQueryData, PdhGetFormattedCounterArrayW,
PdhGetFormattedCounterValue, PdhOpenQueryW, PDH_FMT_COUNTERVALUE, PDH_FMT_COUNTERVALUE_ITEM_W,
PDH_FMT_DOUBLE, PDH_FMT_LARGE,
};
struct PerformanceQuery {
query: isize,
counter: isize,
}
unsafe impl Send for PerformanceQuery {}
static QUERY: OnceLock<Option<Mutex<PerformanceQuery>>> = OnceLock::new();
fn query() -> Option<&'static Mutex<PerformanceQuery>> {
QUERY
.get_or_init(|| {
let mut query: isize = 0;
if unsafe { PdhOpenQueryW(None, 0, &mut query) } != 0 {
return None;
}
let mut counter: isize = 0;
let added = unsafe {
PdhAddEnglishCounterW(
query,
w!("\\Processor Information(*)\\% Processor Performance"),
0,
&mut counter,
)
};
if added != 0 {
return None;
}
unsafe { PdhCollectQueryData(query) };
std::thread::sleep(std::time::Duration::from_millis(120));
Some(Mutex::new(PerformanceQuery { query, counter }))
})
.as_ref()
}
pub(crate) fn processor_performance_percent() -> Option<Vec<Option<f64>>> {
let lock = query()?;
let state = lock.lock().ok()?;
if unsafe { PdhCollectQueryData(state.query) } != 0 {
return None;
}
let mut size: u32 = 0;
let mut count: u32 = 0;
unsafe {
PdhGetFormattedCounterArrayW(state.counter, PDH_FMT_DOUBLE, &mut size, &mut count, None)
};
if size == 0 {
return None;
}
let mut buffer = vec![0u8; size as usize];
let fetched = unsafe {
PdhGetFormattedCounterArrayW(
state.counter,
PDH_FMT_DOUBLE,
&mut size,
&mut count,
Some(buffer.as_mut_ptr() as *mut PDH_FMT_COUNTERVALUE_ITEM_W),
)
};
if fetched != 0 {
return None;
}
let items = unsafe {
std::slice::from_raw_parts(
buffer.as_ptr() as *const PDH_FMT_COUNTERVALUE_ITEM_W,
count as usize,
)
};
let mut out: Vec<Option<f64>> = Vec::new();
for item in items {
let name = unsafe { item.szName.to_string() }.unwrap_or_default();
let Some((_group, cpu)) = name.split_once(',') else {
continue;
};
let Ok(index) = cpu.parse::<usize>() else {
continue;
};
if out.len() <= index {
out.resize(index + 1, None);
}
out[index] = Some(unsafe { item.FmtValue.Anonymous.doubleValue });
}
(!out.is_empty()).then_some(out)
}
static FREE_PAGE_QUERY: OnceLock<Option<Mutex<PerformanceQuery>>> = OnceLock::new();
pub(crate) fn free_and_zero_page_list_bytes() -> Option<u64> {
let lock = FREE_PAGE_QUERY
.get_or_init(|| {
let mut query: isize = 0;
if unsafe { PdhOpenQueryW(None, 0, &mut query) } != 0 {
return None;
}
let mut counter: isize = 0;
let added = unsafe {
PdhAddEnglishCounterW(
query,
w!("\\Memory\\Free & Zero Page List Bytes"),
0,
&mut counter,
)
};
(added == 0).then(|| Mutex::new(PerformanceQuery { query, counter }))
})
.as_ref()?;
let state = lock.lock().ok()?;
if unsafe { PdhCollectQueryData(state.query) } != 0 {
return None;
}
let mut value = PDH_FMT_COUNTERVALUE::default();
let status =
unsafe { PdhGetFormattedCounterValue(state.counter, PDH_FMT_LARGE, None, &mut value) };
if status != 0 || value.CStatus != 0 {
return None;
}
u64::try_from(unsafe { value.Anonymous.largeValue }).ok()
}