hal/vk: pipeline layout, object labels and logging

This commit is contained in:
Dzmitry Malyshau committed 2021-06-11 20:23:15 -04:00
1 parent 61e2e242cd
commit 006c1baaf2
6 files changed
+336 -24

No files matched your search

+2
View File
@@ -194,6 +194,8 @@ impl PhysicalDeviceFeatures {
fn to_wgpu(&self, caps: &PhysicalDeviceCapabilities) -> (wgt::Features, wgt::DownlevelFlags) {
use wgt::{DownlevelFlags as Df, Features as F};
let mut features = F::empty()
| F::MAPPABLE_PRIMARY_BUFFERS
| F::PUSH_CONSTANTS
| F::ADDRESS_MODE_CLAMP_TO_BORDER
| F::SAMPLED_TEXTURE_BINDING_ARRAY
| F::BUFFER_BINDING_ARRAY;
+2 -2
View File
@@ -73,7 +73,7 @@ impl crate::CommandBuffer<super::Api> for super::Encoder {
unsafe fn set_bind_group(
&mut self,
layout: &Resource,
layout: &super::PipelineLayout,
index: u32,
group: &Resource,
dynamic_offsets: &[wgt::DynamicOffset],
@@ -81,7 +81,7 @@ impl crate::CommandBuffer<super::Api> for super::Encoder {
}
unsafe fn set_push_constants(
&mut self,
layout: &Resource,
layout: &super::PipelineLayout,
stages: wgt::ShaderStage,
offset: u32,
data: &[u32],
+36
View File
@@ -378,3 +378,39 @@ pub fn map_comparison(fun: wgt::CompareFunction) -> vk::CompareOp {
Cf::Always => vk::CompareOp::ALWAYS,
}
}
pub fn map_shader_stage(stage: wgt::ShaderStage) -> vk::ShaderStageFlags {
let mut flags = vk::ShaderStageFlags::empty();
if stage.contains(wgt::ShaderStage::VERTEX) {
flags |= vk::ShaderStageFlags::VERTEX;
}
if stage.contains(wgt::ShaderStage::FRAGMENT) {
flags |= vk::ShaderStageFlags::FRAGMENT;
}
if stage.contains(wgt::ShaderStage::COMPUTE) {
flags |= vk::ShaderStageFlags::COMPUTE;
}
flags
}
pub fn map_binding_type(ty: wgt::BindingType) -> vk::DescriptorType {
match ty {
wgt::BindingType::Buffer {
ty,
has_dynamic_offset,
..
} => match ty {
wgt::BufferBindingType::Storage { .. } => match has_dynamic_offset {
true => vk::DescriptorType::STORAGE_BUFFER_DYNAMIC,
false => vk::DescriptorType::STORAGE_BUFFER,
},
wgt::BufferBindingType::Uniform => match has_dynamic_offset {
true => vk::DescriptorType::UNIFORM_BUFFER_DYNAMIC,
false => vk::DescriptorType::UNIFORM_BUFFER,
},
},
wgt::BindingType::Sampler { .. } => vk::DescriptorType::SAMPLER,
wgt::BindingType::Texture { .. } => vk::DescriptorType::SAMPLED_IMAGE,
wgt::BindingType::StorageTexture { .. } => vk::DescriptorType::STORAGE_IMAGE,
}
}
+146 -14
View File
@@ -1,9 +1,58 @@
use super::conv;
use ash::{extensions::khr, version::DeviceV1_0, vk};
use inplace_it::inplace_or_alloc_from_iter;
use parking_lot::Mutex;
use std::{ptr::NonNull, sync::Arc};
use std::{ptr, sync::Arc};
impl super::DeviceShared {
unsafe fn set_object_name(
&self,
object_type: vk::ObjectType,
object: impl vk::Handle,
name: &str,
) {
use std::ffi::CStr;
let extension = match self.instance.debug_utils {
Some(ref debug_utils) => &debug_utils.extension,
None => return,
};
// Keep variables outside the if-else block to ensure they do not
// go out of scope while we hold a pointer to them
let mut buffer: [u8; 64] = [0u8; 64];
let buffer_vec: Vec<u8>;
// Append a null terminator to the string
let name_bytes = if name.len() < buffer.len() {
// Common case, string is very small. Allocate a copy on the stack.
buffer.copy_from_slice(name.as_bytes());
// Add null terminator
buffer[name.len()] = 0;
&buffer[..name.len() + 1]
} else {
// Less common case, the string is large.
// This requires a heap allocation.
buffer_vec = name
.as_bytes()
.iter()
.cloned()
.chain(std::iter::once(0))
.collect();
&buffer_vec
};
let _result = extension.debug_utils_set_object_name(
self.raw.handle(),
&vk::DebugUtilsObjectNameInfoEXT::builder()
.object_type(object_type)
.object_handle(object.as_raw())
.object_name(CStr::from_bytes_with_nul_unchecked(name_bytes)),
);
}
}
impl gpu_alloc::MemoryDevice<vk::DeviceMemory> for super::DeviceShared {
unsafe fn allocate_memory(
@@ -46,15 +95,13 @@ impl gpu_alloc::MemoryDevice<vk::DeviceMemory> for super::DeviceShared {
memory: &mut vk::DeviceMemory,
offset: u64,
size: u64,
) -> Result<NonNull<u8>, gpu_alloc::DeviceMapError> {
) -> Result<ptr::NonNull<u8>, gpu_alloc::DeviceMapError> {
match self
.raw
.map_memory(*memory, offset, size, vk::MemoryMapFlags::empty())
{
Ok(ptr) => {
Ok(NonNull::new(ptr as *mut u8)
.expect("Pointer to memory mapping must not be null"))
}
Ok(ptr) => Ok(ptr::NonNull::new(ptr as *mut u8)
.expect("Pointer to memory mapping must not be null")),
Err(vk::Result::ERROR_OUT_OF_DEVICE_MEMORY) => {
Err(gpu_alloc::DeviceMapError::OutOfDeviceMemory)
}
@@ -212,6 +259,11 @@ impl crate::Device<super::Api> for super::Device {
.raw
.bind_buffer_memory(raw, *block.memory(), block.offset())?;
if let Some(label) = desc.label {
self.shared
.set_object_name(vk::ObjectType::BUFFER, raw, label);
}
Ok(super::Buffer {
raw,
block: Mutex::new(block),
@@ -254,7 +306,7 @@ impl crate::Device<super::Api> for super::Device {
.size(range.end - range.start)
.build()
});
inplace_it::inplace_or_alloc_from_iter(vk_ranges, |array| {
inplace_or_alloc_from_iter(vk_ranges, |array| {
self.shared.raw.flush_mapped_memory_ranges(array).unwrap()
});
}
@@ -270,7 +322,7 @@ impl crate::Device<super::Api> for super::Device {
.size(range.end - range.start)
.build()
});
inplace_it::inplace_or_alloc_from_iter(vk_ranges, |array| {
inplace_or_alloc_from_iter(vk_ranges, |array| {
self.shared
.raw
.invalidate_mapped_memory_ranges(array)
@@ -318,6 +370,11 @@ impl crate::Device<super::Api> for super::Device {
.raw
.bind_image_memory(raw, *block.memory(), block.offset())?;
if let Some(label) = desc.label {
self.shared
.set_object_name(vk::ObjectType::IMAGE, raw, label);
}
Ok(super::Texture {
raw,
block: Some(block),
@@ -354,6 +411,11 @@ impl crate::Device<super::Api> for super::Device {
let raw = self.shared.raw.create_image_view(&vk_info, None)?;
if let Some(label) = desc.label {
self.shared
.set_object_name(vk::ObjectType::IMAGE_VIEW, raw, label);
}
Ok(super::TextureView { raw })
}
unsafe fn destroy_texture_view(&self, view: super::TextureView) {
@@ -398,6 +460,11 @@ impl crate::Device<super::Api> for super::Device {
let raw = self.shared.raw.create_sampler(&vk_info, None)?;
if let Some(label) = desc.label {
self.shared
.set_object_name(vk::ObjectType::SAMPLER, raw, label);
}
Ok(super::Sampler { raw })
}
unsafe fn destroy_sampler(&self, sampler: super::Sampler) {
@@ -415,17 +482,82 @@ impl crate::Device<super::Api> for super::Device {
unsafe fn create_bind_group_layout(
&self,
desc: &crate::BindGroupLayoutDescriptor,
) -> DeviceResult<Resource> {
Ok(Resource)
) -> Result<super::BindGroupLayout, crate::DeviceError> {
//Note: not bothering with inplace_or_alloc_from_iter her as it's low frequency
let vk_bindings = desc
.entries
.iter()
.map(|entry| vk::DescriptorSetLayoutBinding {
binding: entry.binding,
descriptor_type: conv::map_binding_type(entry.ty),
descriptor_count: entry.count.map_or(1, |c| c.get()),
stage_flags: conv::map_shader_stage(entry.visibility),
p_immutable_samplers: ptr::null(),
})
.collect::<Vec<_>>();
let vk_info = vk::DescriptorSetLayoutCreateInfo::builder()
.flags(vk::DescriptorSetLayoutCreateFlags::empty())
.bindings(&vk_bindings);
let raw = self
.shared
.raw
.create_descriptor_set_layout(&vk_info, None)?;
if let Some(label) = desc.label {
self.shared
.set_object_name(vk::ObjectType::DESCRIPTOR_SET_LAYOUT, raw, label);
}
Ok(super::BindGroupLayout { raw })
}
unsafe fn destroy_bind_group_layout(&self, bg_layout: Resource) {}
unsafe fn destroy_bind_group_layout(&self, bg_layout: super::BindGroupLayout) {
self.shared
.raw
.destroy_descriptor_set_layout(bg_layout.raw, None);
}
unsafe fn create_pipeline_layout(
&self,
desc: &crate::PipelineLayoutDescriptor<super::Api>,
) -> DeviceResult<Resource> {
Ok(Resource)
) -> Result<super::PipelineLayout, crate::DeviceError> {
//Note: not bothering with inplace_or_alloc_from_iter her as it's low frequency
let vk_set_layouts = desc
.bind_group_layouts
.iter()
.map(|bgl| bgl.raw)
.collect::<Vec<_>>();
let vk_push_constant_ranges = desc
.push_constant_ranges
.iter()
.map(|pcr| vk::PushConstantRange {
stage_flags: conv::map_shader_stage(pcr.stages),
offset: pcr.range.start,
size: pcr.range.end - pcr.range.start,
})
.collect::<Vec<_>>();
let vk_info = vk::PipelineLayoutCreateInfo::builder()
.flags(vk::PipelineLayoutCreateFlags::empty())
.set_layouts(&vk_set_layouts)
.push_constant_ranges(&vk_push_constant_ranges);
let raw = self.shared.raw.create_pipeline_layout(&vk_info, None)?;
if let Some(label) = desc.label {
self.shared
.set_object_name(vk::ObjectType::PIPELINE_LAYOUT, raw, label);
}
Ok(super::PipelineLayout { raw })
}
unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {}
unsafe fn destroy_pipeline_layout(&self, pipeline_layout: super::PipelineLayout) {
self.shared
.raw
.destroy_pipeline_layout(pipeline_layout.raw, None);
}
unsafe fn create_bind_group(
&self,
desc: &crate::BindGroupDescriptor<super::Api>,
+128 -5
View File
@@ -1,8 +1,9 @@
use std::{
cmp,
ffi::{c_void, CStr, CString},
mem,
mem, slice,
sync::Arc,
thread,
};
use ash::{
@@ -11,6 +12,104 @@ use ash::{
vk,
};
unsafe extern "system" fn debug_utils_messenger_callback(
message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
message_type: vk::DebugUtilsMessageTypeFlagsEXT,
callback_data_ptr: *const vk::DebugUtilsMessengerCallbackDataEXT,
_user_data: *mut c_void,
) -> vk::Bool32 {
use std::borrow::Cow;
if thread::panicking() {
return vk::FALSE;
}
let message_severity = match message_severity {
vk::DebugUtilsMessageSeverityFlagsEXT::ERROR => log::Level::Error,
vk::DebugUtilsMessageSeverityFlagsEXT::WARNING => log::Level::Warn,
vk::DebugUtilsMessageSeverityFlagsEXT::INFO => log::Level::Info,
vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE => log::Level::Trace,
_ => log::Level::Warn,
};
let cd = &*callback_data_ptr;
let message_id_name = if cd.p_message_id_name.is_null() {
Cow::from("")
} else {
CStr::from_ptr(cd.p_message_id_name).to_string_lossy()
};
let message = if cd.p_message.is_null() {
Cow::from("")
} else {
CStr::from_ptr(cd.p_message).to_string_lossy()
};
log::log!(
message_severity,
"{:?} [{} (0x{:x})] : {}\n",
message_type,
message_id_name,
cd.message_id_number,
message
);
if cd.queue_label_count != 0 {
let labels = slice::from_raw_parts(cd.p_queue_labels, cd.queue_label_count as usize);
let names = labels
.iter()
.flat_map(|dul_obj| {
dul_obj
.p_label_name
.as_ref()
.map(|lbl| CStr::from_ptr(lbl).to_string_lossy())
})
.collect::<Vec<_>>();
log::log!(message_severity, "\tqueues: {}\n", names.join(", "));
}
if cd.cmd_buf_label_count != 0 {
let labels = slice::from_raw_parts(cd.p_cmd_buf_labels, cd.cmd_buf_label_count as usize);
let names = labels
.iter()
.flat_map(|dul_obj| {
dul_obj
.p_label_name
.as_ref()
.map(|lbl| CStr::from_ptr(lbl).to_string_lossy())
})
.collect::<Vec<_>>();
log::log!(
message_severity,
"\tcommand buffers: {}\n",
names.join(", ")
);
}
if cd.object_count != 0 {
let labels = slice::from_raw_parts(cd.p_objects, cd.object_count as usize);
//TODO: use color fields of `vk::DebugUtilsLabelExt`?
let names = labels
.iter()
.map(|obj_info| {
let name = obj_info
.p_object_name
.as_ref()
.map(|name| CStr::from_ptr(name).to_string_lossy())
.unwrap_or(Cow::Borrowed("?"));
format!(
"(type: {:?}, hndl: 0x{:x}, name: {})",
obj_info.object_type, obj_info.object_handle, name
)
})
.collect::<Vec<_>>();
log::log!(message_severity, "\tobjects: {}\n", names.join(", "));
}
vk::FALSE
}
impl super::Swapchain {
unsafe fn release_resources(self, device: &ash::Device) -> Self {
let _ = device.device_wait_idle();
@@ -275,7 +374,10 @@ impl crate::Instance<super::Api> for super::Instance {
extensions.push(ash::extensions::mvk::MacOSSurface::name());
}
extensions.push(ext::DebugUtils::name());
if desc.flags.contains(crate::InstanceFlag::DEBUG) {
extensions.push(ext::DebugUtils::name());
}
extensions.push(vk::KhrGetPhysicalDeviceProperties2Fn::name());
// VK_KHR_storage_buffer_storage_class required for `Naga` on Vulkan 1.0 devices
@@ -327,7 +429,7 @@ impl crate::Instance<super::Api> for super::Instance {
layers
};
let instance = {
let vk_instance = {
let str_pointers = layers
.iter()
.chain(extensions.iter())
@@ -349,19 +451,40 @@ impl crate::Instance<super::Api> for super::Instance {
})?
};
let debug_utils = if extensions.contains(&ext::DebugUtils::name()) {
let extension = ext::DebugUtils::new(&entry, &vk_instance);
let vk_info = vk::DebugUtilsMessengerCreateInfoEXT::builder()
.flags(vk::DebugUtilsMessengerCreateFlagsEXT::empty())
.message_severity(vk::DebugUtilsMessageSeverityFlagsEXT::all())
.message_type(vk::DebugUtilsMessageTypeFlagsEXT::all())
.pfn_user_callback(Some(debug_utils_messenger_callback));
let messenger = extension
.create_debug_utils_messenger(&vk_info, None)
.unwrap();
Some(super::DebugUtils {
extension,
messenger,
})
} else {
None
};
let get_physical_device_properties = extensions
.iter()
.find(|&&ext| ext == vk::KhrGetPhysicalDeviceProperties2Fn::name())
.map(|_| {
vk::KhrGetPhysicalDeviceProperties2Fn::load(|name| {
mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
mem::transmute(
entry.get_instance_proc_addr(vk_instance.handle(), name.as_ptr()),
)
})
});
Ok(Self {
shared: Arc::new(super::InstanceShared {
raw: instance,
raw: vk_instance,
flags: desc.flags,
debug_utils,
get_physical_device_properties,
}),
extensions,
+22 -3
View File
@@ -8,7 +8,10 @@ mod instance;
use std::{borrow::Borrow, ffi::CStr, sync::Arc};
use ash::{extensions::khr, vk};
use ash::{
extensions::{ext, khr},
vk,
};
use parking_lot::Mutex;
const MILLIS_TO_NANOS: u64 = 1_000_000;
@@ -38,17 +41,23 @@ impl crate::Api for Api {
type QuerySet = Resource;
type Fence = Resource;
type BindGroupLayout = Resource;
type BindGroupLayout = BindGroupLayout;
type BindGroup = Resource;
type PipelineLayout = Resource;
type PipelineLayout = PipelineLayout;
type ShaderModule = Resource;
type RenderPipeline = Resource;
type ComputePipeline = Resource;
}
struct DebugUtils {
extension: ext::DebugUtils,
messenger: vk::DebugUtilsMessengerEXT,
}
struct InstanceShared {
raw: ash::Instance,
flags: crate::InstanceFlag,
debug_utils: Option<DebugUtils>,
get_physical_device_properties: Option<vk::KhrGetPhysicalDeviceProperties2Fn>,
//debug_messenger: Option<DebugMessenger>,
}
@@ -171,6 +180,16 @@ pub struct Sampler {
raw: vk::Sampler,
}
#[derive(Debug)]
pub struct BindGroupLayout {
raw: vk::DescriptorSetLayout,
}
#[derive(Debug)]
pub struct PipelineLayout {
raw: vk::PipelineLayout,
}
impl crate::Queue<Api> for Queue {
unsafe fn submit<I>(
&mut self,