gpu_telemetry 0.1.0

High-level GPU telemetry background logger
Documentation
use crate::{errors::{Error, ErrorKind}, monitor::telemetry::{GpuHeap, GpuSample}, sys::GpuTelemetry};

use std::time::Duration;

use windows::{
    Win32::{
        Foundation::{CloseHandle, HANDLE, WAIT_FAILED, WAIT_OBJECT_0, WAIT_TIMEOUT}, Graphics::Dxgi::{
            CreateDXGIFactory2, DXGI_CREATE_FACTORY_FLAGS, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, DXGI_QUERY_VIDEO_MEMORY_INFO, IDXGIAdapter4, IDXGIFactory7,
        }, System::Threading::{CreateEventW, WaitForSingleObject}
    }, core::Interface,
};

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 = unsafe {
            factory.EnumAdapters1(
                adapter as u32,
            ).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 {
            adapter4.RegisterVideoMemoryBudgetChangeNotificationEvent(
                budget_change,
            ).map_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);
        }
    }
}