gpu_telemetry 0.2.1

High-level GPU telemetry background logger
Documentation
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},
    },
};

/// DirectX (Windows-only) querying backend.
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);
        }
    }
}