gpu_telemetry 0.1.0

High-level GPU telemetry background logger
Documentation
use ash::{vk, Entry};
use std::{mem::ManuallyDrop, time::Duration};

use crate::{
    errors::{Error, ErrorKind}, monitor::telemetry::{GpuHeap, GpuSample}, sys::GpuTelemetry,
};

pub struct VulkanGpuQuery {
    entry: ManuallyDrop<Entry>,
    instance: ash::Instance,
    physical_device: vk::PhysicalDevice,
    memory_budget: bool,
}

impl GpuTelemetry for VulkanGpuQuery {
    fn new(adapter: usize) -> Result<Self, Error> {
        let entry = unsafe {
            Entry::load().map_err(|_| Error {
                msg: "failed to load Vulkan",
                kind: ErrorKind::FailedAdapterCreation,
            })?
        };

        let app_name = c"gpu_telemetry";

        let app_info = vk::ApplicationInfo::default()
            .application_name(app_name)
            .application_version(0)
            .engine_name(app_name)
            .engine_version(0)
            .api_version(vk::API_VERSION_1_3);

        let create_info = vk::InstanceCreateInfo::default()
            .application_info(&app_info);

        let instance = unsafe {
            entry.create_instance(&create_info, None).map_err(|_| Error {
                msg: "failed to create Vulkan instance",
                kind: ErrorKind::FailedAdapterCreation,
            })?
        };

        let physical_devices = unsafe {
            instance.enumerate_physical_devices().map_err(|_| Error {
                msg: "failed to enumerate Vulkan physical devices",
                kind: ErrorKind::FailedAdapterCreation,
            })?
        };

        let physical_device = *physical_devices.get(adapter).ok_or(Error {
            msg: "Vulkan adapter index out of range",
            kind: ErrorKind::FailedAdapterCreation,
        })?;

        let extensions = unsafe {
            instance
                .enumerate_device_extension_properties(physical_device)
                .map_err(|_| Error {
                    msg: "failed to enumerate Vulkan device extensions",
                    kind: ErrorKind::FailedAdapterCreation,
                })?
        };

        let memory_budget = extensions.iter().any(|extension| {
            let name = unsafe {
                std::ffi::CStr::from_ptr(extension.extension_name.as_ptr())
            };

            name == c"VK_EXT_memory_budget"
        });

        Ok(Self {
            entry: ManuallyDrop::new(entry),
            instance,
            physical_device,
            memory_budget,
        })
    }

    fn wait_at_most(&self, interval: Duration) -> Result<(), Error> {
        std::thread::sleep(interval);
        Ok(())
    }

    fn query(&self) -> Result<GpuSample, Error> {
        let mut budget = vk::PhysicalDeviceMemoryBudgetPropertiesEXT::default();

        let mut memory_properties =
            vk::PhysicalDeviceMemoryProperties2::default();

        if self.memory_budget {
            memory_properties = memory_properties.push_next(&mut budget);
        }

        unsafe {
            self.instance
                .get_physical_device_memory_properties2(
                    self.physical_device,
                    &mut memory_properties,
                );
        }

        let memory_properties = memory_properties.memory_properties;

        let mut heaps = Vec::with_capacity(
            memory_properties.memory_heap_count as usize
        );

        for i in 0..memory_properties.memory_heap_count as usize {
            let heap = memory_properties.memory_heaps[i];

            heaps.push(GpuHeap {
                size: Some(heap.size),
                usage: self.memory_budget.then_some(budget.heap_usage[i]),
                budget: self.memory_budget.then_some(budget.heap_budget[i]),
                reservation: None,
                available_for_reservation: None,
                dev_local: heap
                    .flags
                    .contains(vk::MemoryHeapFlags::DEVICE_LOCAL),
            });
        }

        Ok(GpuSample { heaps })
    }
}

impl Drop for VulkanGpuQuery {
    fn drop(&mut self) {
        unsafe {
            self.instance.destroy_instance(None);
            ManuallyDrop::drop(&mut self.entry);
        }
    }
}