gpu_telemetry 0.2.1

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

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

macro_rules! destroy_instance_err {
    ($instance:ident, $msg:tt, $op:expr) => {
        match $op {
            Ok(val) => val,
            Err(_) => {
                let _ = $instance.destroy_instance(None);
                return Err(Error {
                    msg: $msg,
                    kind: ErrorKind::FailedAdapterCreation,
                });
            }
        }
    };
}

/// Vulkan (linux + Windows) querying backend.
pub struct VulkanGpuQuery {
    _entry: 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 {
            destroy_instance_err!(
                instance,
                "failed to enumerate Vulkan physical devices",
                instance.enumerate_physical_devices()
            )
        };

        let physical_device = unsafe {
            *destroy_instance_err!(
                instance,
                "Vulkan adapter index out of range",
                physical_devices.get(adapter).ok_or(())
            )
        };

        let extensions = unsafe {
            destroy_instance_err!(
                instance,
                "failed to enumerate Vulkan device extensions",
                instance.enumerate_device_extension_properties(physical_device)
            )
        };

        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: 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);
        }
    }
}