use crate::{
errors::{Error, ErrorKind},
monitor::telemetry::{GpuHeap, GpuSample},
sys::GpuTelemetry,
};
use std::time::Duration;
use windows::{
core::Interface,
Win32::{
Foundation::{CloseHandle, HANDLE, WAIT_FAILED, WAIT_OBJECT_0, WAIT_TIMEOUT},
Graphics::Dxgi::{
CreateDXGIFactory2, IDXGIAdapter4, IDXGIFactory7, DXGI_CREATE_FACTORY_FLAGS,
DXGI_MEMORY_SEGMENT_GROUP_LOCAL, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL,
DXGI_QUERY_VIDEO_MEMORY_INFO,
},
System::Threading::{CreateEventW, WaitForSingleObject},
},
};
pub struct DxGpuQuery {
budget_change: HANDLE,
cookie: u32,
adapter4: IDXGIAdapter4,
}
impl GpuTelemetry for DxGpuQuery {
fn new(adapter: usize) -> Result<Self, Error> {
let factory: IDXGIFactory7 = unsafe {
CreateDXGIFactory2(DXGI_CREATE_FACTORY_FLAGS::default()).map_err(|_| Error {
msg: "failed to create IDXGIFactory7",
kind: ErrorKind::FailedAdapterCreation,
})?
};
let adapter_index = u32::try_from(adapter).map_err(|_| Error {
msg: "adapter index is too large",
kind: ErrorKind::FailedAdapterCreation,
})?;
let adapter = unsafe {
factory.EnumAdapters1(adapter_index).map_err(|_| Error {
msg: "failed to enumerate IDXGIAdapter1",
kind: ErrorKind::FailedAdapterCreation,
})?
};
let adapter4: IDXGIAdapter4 = adapter.cast().map_err(|_| Error {
msg: "failed to upgrade from IDXGIAdapter1 to IDXGIAdapter4",
kind: ErrorKind::FailedAdapterCreation,
})?;
let budget_change = unsafe {
CreateEventW(None, false, false, None).map_err(|_| Error {
msg: "could not create budget change event",
kind: ErrorKind::FailedEventCreation,
})?
};
let cookie = unsafe {
match adapter4.RegisterVideoMemoryBudgetChangeNotificationEvent(budget_change) {
Ok(cookie) => cookie,
Err(_) => {
let _ = CloseHandle(budget_change);
return Err(Error {
msg: "could not register video memory budget change notification",
kind: ErrorKind::FailedEventCreation,
});
}
}
};
Ok(Self {
budget_change,
cookie,
adapter4,
})
}
fn query(&self) -> Result<GpuSample, Error> {
let mut info_mem = DXGI_QUERY_VIDEO_MEMORY_INFO::default();
unsafe {
self.adapter4
.QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &mut info_mem)
.map_err(|_| Error {
msg: "failed to query video memory info from adapter",
kind: ErrorKind::FailedInfoQuery,
})?
};
let mut info_shared = DXGI_QUERY_VIDEO_MEMORY_INFO::default();
unsafe {
self.adapter4
.QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &mut info_shared)
.map_err(|_| Error {
msg: "failed to query video memory info from adapter",
kind: ErrorKind::FailedInfoQuery,
})?
};
Ok(GpuSample {
heaps: vec![
GpuHeap {
size: None,
usage: Some(info_mem.CurrentUsage),
budget: Some(info_mem.Budget),
reservation: Some(info_mem.CurrentReservation),
available_for_reservation: Some(info_mem.AvailableForReservation),
dev_local: true,
},
GpuHeap {
size: None,
usage: Some(info_shared.CurrentUsage),
budget: Some(info_shared.Budget),
reservation: Some(info_shared.CurrentReservation),
available_for_reservation: Some(info_shared.AvailableForReservation),
dev_local: false,
},
],
})
}
fn wait_at_most(&self, interval: Duration) -> Result<(), Error> {
let result = unsafe {
WaitForSingleObject(
self.budget_change,
interval.as_millis().try_into().map_err(|_| Error {
msg: "interval too slow",
kind: ErrorKind::InvalidInterval,
})?,
)
};
match result {
WAIT_OBJECT_0 | WAIT_TIMEOUT => Ok(()),
WAIT_FAILED => Err(Error {
msg: "could not wait on budget change",
kind: ErrorKind::WaitFailed,
}),
_ => unreachable!(),
}
}
}
impl Drop for DxGpuQuery {
fn drop(&mut self) {
unsafe {
self.adapter4
.UnregisterVideoMemoryBudgetChangeNotification(self.cookie);
let _ = CloseHandle(self.budget_change);
}
}
}