diff --git a/wgpu-hal/src/vulkan/adapter.rs b/wgpu-hal/src/vulkan/adapter.rs index 08d9a991d..4d3122f52 100644 --- a/wgpu-hal/src/vulkan/adapter.rs +++ b/wgpu-hal/src/vulkan/adapter.rs @@ -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; diff --git a/wgpu-hal/src/vulkan/command.rs b/wgpu-hal/src/vulkan/command.rs index 8e42d3a22..0aed02bbc 100644 --- a/wgpu-hal/src/vulkan/command.rs +++ b/wgpu-hal/src/vulkan/command.rs @@ -73,7 +73,7 @@ impl crate::CommandBuffer 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 for super::Encoder { } unsafe fn set_push_constants( &mut self, - layout: &Resource, + layout: &super::PipelineLayout, stages: wgt::ShaderStage, offset: u32, data: &[u32], diff --git a/wgpu-hal/src/vulkan/conv.rs b/wgpu-hal/src/vulkan/conv.rs index 9a0d1efe8..8141f81c3 100644 --- a/wgpu-hal/src/vulkan/conv.rs +++ b/wgpu-hal/src/vulkan/conv.rs @@ -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, + } +} diff --git a/wgpu-hal/src/vulkan/device.rs b/wgpu-hal/src/vulkan/device.rs index 373148e44..1b74b5869 100644 --- a/wgpu-hal/src/vulkan/device.rs +++ b/wgpu-hal/src/vulkan/device.rs @@ -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; + + // 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 for super::DeviceShared { unsafe fn allocate_memory( @@ -46,15 +95,13 @@ impl gpu_alloc::MemoryDevice for super::DeviceShared { memory: &mut vk::DeviceMemory, offset: u64, size: u64, - ) -> Result, gpu_alloc::DeviceMapError> { + ) -> Result, 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 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 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 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 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 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 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 for super::Device { unsafe fn create_bind_group_layout( &self, desc: &crate::BindGroupLayoutDescriptor, - ) -> DeviceResult { - Ok(Resource) + ) -> Result { + //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::>(); + + 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, - ) -> DeviceResult { - Ok(Resource) + ) -> Result { + //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::>(); + 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::>(); + + 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, diff --git a/wgpu-hal/src/vulkan/instance.rs b/wgpu-hal/src/vulkan/instance.rs index 9899c0a26..5f464e8bf 100644 --- a/wgpu-hal/src/vulkan/instance.rs +++ b/wgpu-hal/src/vulkan/instance.rs @@ -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::>(); + 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::>(); + 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::>(); + 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 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 for super::Instance { layers }; - let instance = { + let vk_instance = { let str_pointers = layers .iter() .chain(extensions.iter()) @@ -349,19 +451,40 @@ impl crate::Instance 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, diff --git a/wgpu-hal/src/vulkan/mod.rs b/wgpu-hal/src/vulkan/mod.rs index c5476bd9e..36a6ff783 100644 --- a/wgpu-hal/src/vulkan/mod.rs +++ b/wgpu-hal/src/vulkan/mod.rs @@ -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, get_physical_device_properties: Option, //debug_messenger: Option, } @@ -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 for Queue { unsafe fn submit( &mut self,