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