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