From eb4f633e39fc67ac7d8aa42b8e9b002eb9e25d8f Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Thu, 19 Nov 2020 20:35:20 -0500 Subject: [PATCH 1/8] [error] texture creation --- player/src/lib.rs | 3 +- wgpu-core/src/device/mod.rs | 81 ++++++++++++++++++------------------- wgpu-core/src/lib.rs | 2 + wgpu-core/src/resource.rs | 6 +-- 4 files changed, 47 insertions(+), 45 deletions(-) diff --git a/player/src/lib.rs b/player/src/lib.rs index 5ded59d70..d0ecda446 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -147,7 +147,8 @@ impl GlobalPlay for wgc::hub::Global { } A::CreateTexture(id, desc) => { self.device_maintain_ids::(device).unwrap(); - self.device_create_texture::(device, &desc, id).unwrap(); + let (_, error) = self.device_create_texture::(device, &desc, id); + assert_eq!(error, None); } A::FreeTexture(id) => { self.texture_destroy::(id).unwrap(); diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs index 7c7ebe26c..c3f467494 100644 --- a/wgpu-core/src/device/mod.rs +++ b/wgpu-core/src/device/mod.rs @@ -500,6 +500,14 @@ impl Device { ) -> Result, resource::CreateTextureError> { debug_assert_eq!(self_id.backend(), B::VARIANT); + let features = conv::texture_features(desc.format); + if !self.features.contains(features) { + return Err(resource::CreateTextureError::MissingFeature( + features, + desc.format, + )); + } + // Ensure `D24Plus` textures cannot be copied match desc.format { TextureFormat::Depth24Plus | TextureFormat::Depth24PlusStencil8 => { @@ -915,10 +923,10 @@ impl crate::hub::Resource for Device { } #[error("device is invalid")] -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub struct InvalidDevice; -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum DeviceError { #[error("parent device is invalid")] Invalid, @@ -1280,62 +1288,53 @@ impl Global { device_id: id::DeviceId, desc: &resource::TextureDescriptor, id_in: Input, - ) -> Result { + ) -> (id::TextureId, Option) { span!(_guard, INFO, "Device::create_texture"); let hub = B::hub(self); let mut token = Token::root(); let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; + let texture = match device.create_texture(device_id, desc) { + Ok(texture) => texture, + Err(error) => break error, + }; + let num_levels = texture.full_range.levels.end; + let num_layers = texture.full_range.layers.end; + let ref_count = texture.life_guard.add_ref(); - let texture_features = conv::texture_features(desc.format); - if texture_features != wgt::Features::empty() && !device.features.contains(texture_features) - { - return Err(resource::CreateTextureError::MissingFeature( - texture_features, - desc.format, - )); - } + let id = hub.textures.register_identity(id_in, texture, &mut token); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace + .lock() + .add(trace::Action::CreateTexture(id.0, desc.clone())); + } - let texture = device.create_texture(device_id, desc)?; - let num_levels = texture.full_range.levels.end; - let num_layers = texture.full_range.layers.end; - let ref_count = texture.life_guard.add_ref(); - - let id = hub.textures.register_identity(id_in, texture, &mut token); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace + device + .trackers .lock() - .add(trace::Action::CreateTexture(id.0, desc.clone())); - } + .textures + .init(id, ref_count, TextureState::new(num_levels, num_layers)) + .unwrap(); + return (id.0, None); + }; - device - .trackers - .lock() + let id = hub .textures - .init(id, ref_count, TextureState::new(num_levels, num_layers)) - .unwrap(); - Ok(id.0) + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } pub fn texture_label(&self, id: id::TextureId) -> String { B::hub(self).textures.label_for_resource(id) } - pub fn texture_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::TextureId { - B::hub(self) - .textures - .register_error(id_in, label.unwrap_or(""), &mut Token::root()) - } - pub fn texture_destroy( &self, texture_id: id::TextureId, diff --git a/wgpu-core/src/lib.rs b/wgpu-core/src/lib.rs index e9a36400c..4ce70c31f 100644 --- a/wgpu-core/src/lib.rs +++ b/wgpu-core/src/lib.rs @@ -8,6 +8,8 @@ unused_extern_crates, unused_qualifications )] +// We use loops for getting early-out of scope without closures. +#![allow(clippy::never_loop)] #[macro_use] mod macros; diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs index 16319dd27..75b5fbb16 100644 --- a/wgpu-core/src/resource.rs +++ b/wgpu-core/src/resource.rs @@ -207,14 +207,14 @@ pub struct Texture { pub(crate) life_guard: LifeGuard, } -#[derive(Clone, Debug)] +#[derive(Clone, Debug, PartialEq)] pub enum TextureErrorDimension { X, Y, Z, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum TextureDimensionError { #[error("Dimension {0:?} is zero")] Zero(TextureErrorDimension), @@ -224,7 +224,7 @@ pub enum TextureDimensionError { InvalidSampleCount(u32), } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateTextureError { #[error(transparent)] Device(#[from] DeviceError), From bedd037517b3a0ce514f20befb8737a0d435249a Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Thu, 19 Nov 2020 21:09:47 -0500 Subject: [PATCH 2/8] [error] buffer creation --- player/src/lib.rs | 3 +- wgpu-core/src/device/mod.rs | 177 ++++++++++++++++++++++-------------- wgpu-core/src/resource.rs | 4 +- wgpu-core/src/validation.rs | 2 +- 4 files changed, 112 insertions(+), 74 deletions(-) diff --git a/player/src/lib.rs b/player/src/lib.rs index d0ecda446..bfbb94ea9 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -137,7 +137,8 @@ impl GlobalPlay for wgc::hub::Global { } A::CreateBuffer(id, desc) => { self.device_maintain_ids::(device).unwrap(); - self.device_create_buffer::(device, &desc, id).unwrap(); + let (_, error) = self.device_create_buffer::(device, &desc, id); + assert_eq!(error, None); } A::FreeBuffer(id) => { self.buffer_destroy::(id).unwrap(); diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs index c3f467494..9fb420fa2 100644 --- a/wgpu-core/src/device/mod.rs +++ b/wgpu-core/src/device/mod.rs @@ -417,9 +417,14 @@ impl Device { ) -> Result, resource::CreateBufferError> { debug_assert_eq!(self_id.backend(), B::VARIANT); let (mut usage, _memory_properties) = conv::map_buffer_usage(desc.usage); - if desc.mapped_at_creation && !desc.usage.contains(wgt::BufferUsage::MAP_WRITE) { - // we are going to be copying into it, internally - usage |= hal::buffer::Usage::TRANSFER_DST; + if desc.mapped_at_creation { + if desc.size % wgt::COPY_BUFFER_ALIGNMENT != 0 { + return Err(resource::CreateBufferError::UnalignedSize); + } + if !desc.usage.contains(wgt::BufferUsage::MAP_WRITE) { + // we are going to be copying into it, internally + usage |= hal::buffer::Usage::TRANSFER_DST; + } } let mem_usage = { @@ -1004,7 +1009,7 @@ impl Global { device_id: id::DeviceId, desc: &resource::BufferDescriptor, id_in: Input, - ) -> Result { + ) -> (id::BufferId, Option) { span!(_guard, INFO, "Device::create_buffer"); let hub = B::hub(self); @@ -1012,73 +1017,114 @@ impl Global { tracing::info!("Create buffer {:?} with ID {:?}", desc, id_in); - if desc.mapped_at_creation && desc.size % wgt::COPY_BUFFER_ALIGNMENT != 0 { - return Err(resource::CreateBufferError::UnalignedSize); - } - let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; - let mut buffer = device.create_buffer(device_id, desc, false)?; - let ref_count = buffer.life_guard.add_ref(); - - let buffer_use = if !desc.mapped_at_creation { - resource::BufferUse::EMPTY - } else if desc.usage.contains(wgt::BufferUsage::MAP_WRITE) { - // buffer is mappable, so we are just doing that at start - let size = buffer.size; - let ptr = map_buffer(&device.raw, &mut buffer, 0, size, HostMap::Write)?; - - buffer.map_state = resource::BufferMapState::Active { - ptr, - sub_range: hal::buffer::SubRange::WHOLE, - host: HostMap::Write, + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), }; + let mut buffer = match device.create_buffer(device_id, desc, false) { + Ok(buffer) => buffer, + Err(e) => break e, + }; + let ref_count = buffer.life_guard.add_ref(); - resource::BufferUse::MAP_WRITE - } else { - // buffer needs staging area for initialization only - let stage = device.create_buffer( - device_id, - &wgt::BufferDescriptor { + let buffer_use = if !desc.mapped_at_creation { + resource::BufferUse::EMPTY + } else if desc.usage.contains(wgt::BufferUsage::MAP_WRITE) { + // buffer is mappable, so we are just doing that at start + let map_size = buffer.size; + let ptr = match map_buffer(&device.raw, &mut buffer, 0, map_size, HostMap::Write) { + Ok(ptr) => ptr, + Err(e) => { + let (raw, memory) = buffer.raw.unwrap(); + device.lock_life(&mut token).schedule_resource_destruction( + queue::TempResource::Buffer(raw), + memory, + !0, + ); + break e.into(); + } + }; + buffer.map_state = resource::BufferMapState::Active { + ptr, + sub_range: hal::buffer::SubRange::WHOLE, + host: HostMap::Write, + }; + resource::BufferUse::MAP_WRITE + } else { + // buffer needs staging area for initialization only + let stage_desc = wgt::BufferDescriptor { label: Some(Cow::Borrowed("")), size: desc.size, usage: wgt::BufferUsage::MAP_WRITE | wgt::BufferUsage::COPY_SRC, mapped_at_creation: false, - }, - true, - )?; - let (stage_buffer, mut stage_memory) = stage.raw.unwrap(); - let ptr = stage_memory.map(&device.raw, 0, stage.size)?; - buffer.map_state = resource::BufferMapState::Init { - ptr, - needs_flush: !stage_memory.is_coherent(), - stage_buffer, - stage_memory, + }; + let stage = match device.create_buffer(device_id, &stage_desc, true) { + Ok(stage) => stage, + Err(e) => { + let (raw, memory) = buffer.raw.unwrap(); + device.lock_life(&mut token).schedule_resource_destruction( + queue::TempResource::Buffer(raw), + memory, + !0, + ); + break e; + } + }; + let (stage_buffer, mut stage_memory) = stage.raw.unwrap(); + let ptr = match stage_memory.map(&device.raw, 0, stage.size) { + Ok(ptr) => ptr, + Err(e) => { + let (raw, memory) = buffer.raw.unwrap(); + let mut life_lock = device.lock_life(&mut token); + life_lock.schedule_resource_destruction( + queue::TempResource::Buffer(raw), + memory, + !0, + ); + life_lock.schedule_resource_destruction( + queue::TempResource::Buffer(stage_buffer), + stage_memory, + !0, + ); + break e.into(); + } + }; + buffer.map_state = resource::BufferMapState::Init { + ptr, + needs_flush: !stage_memory.is_coherent(), + stage_buffer, + stage_memory, + }; + resource::BufferUse::COPY_DST }; - resource::BufferUse::COPY_DST + + let id = hub.buffers.register_identity(id_in, buffer, &mut token); + tracing::info!("Created buffer {:?} with {:?}", id, desc); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + let mut desc = desc.clone(); + let mapped_at_creation = mem::replace(&mut desc.mapped_at_creation, false); + if mapped_at_creation && !desc.usage.contains(wgt::BufferUsage::MAP_WRITE) { + desc.usage |= wgt::BufferUsage::COPY_DST; + } + trace.lock().add(trace::Action::CreateBuffer(id.0, desc)); + } + + device + .trackers + .lock() + .buffers + .init(id, ref_count, BufferState::with_usage(buffer_use)) + .unwrap(); + return (id.0, None); }; - let id = hub.buffers.register_identity(id_in, buffer, &mut token); - tracing::info!("Created buffer {:?} with {:?}", id, desc); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - let mut desc = desc.clone(); - let mapped_at_creation = mem::replace(&mut desc.mapped_at_creation, false); - if mapped_at_creation && !desc.usage.contains(wgt::BufferUsage::MAP_WRITE) { - desc.usage |= wgt::BufferUsage::COPY_DST; - } - trace.lock().add(trace::Action::CreateBuffer(id.0, desc)); - } - - device - .trackers - .lock() + let id = hub .buffers - .init(id, ref_count, BufferState::with_usage(buffer_use)) - .unwrap(); - Ok(id.0) + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } #[cfg(feature = "replay")] @@ -1178,16 +1224,6 @@ impl Global { B::hub(self).buffers.label_for_resource(id) } - pub fn buffer_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::BufferId { - B::hub(self) - .buffers - .register_error(id_in, label.unwrap_or(""), &mut Token::root()) - } - pub fn buffer_destroy( &self, buffer_id: id::BufferId, @@ -1309,6 +1345,7 @@ impl Global { let ref_count = texture.life_guard.add_ref(); let id = hub.textures.register_identity(id_in, texture, &mut token); + tracing::info!("Created texture {:?} with {:?}", id, desc); #[cfg(feature = "trace")] if let Some(ref trace) = device.trace { trace diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs index 75b5fbb16..3ac1e5b30 100644 --- a/wgpu-core/src/resource.rs +++ b/wgpu-core/src/resource.rs @@ -126,7 +126,7 @@ impl BufferMapOperation { } } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum BufferAccessError { #[error(transparent)] Device(#[from] DeviceError), @@ -166,7 +166,7 @@ pub struct Buffer { pub(crate) map_state: BufferMapState, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateBufferError { #[error(transparent)] Device(#[from] DeviceError), diff --git a/wgpu-core/src/validation.rs b/wgpu-core/src/validation.rs index d7d7034f5..202c84d77 100644 --- a/wgpu-core/src/validation.rs +++ b/wgpu-core/src/validation.rs @@ -8,7 +8,7 @@ use std::collections::hash_map::Entry; use thiserror::Error; use wgt::{BindGroupLayoutEntry, BindingType}; -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] #[error("buffer usage is {actual:?} which does not contain required usage {expected:?}")] pub struct MissingBufferUsageError { pub(crate) actual: wgt::BufferUsage, From 828746485566891f3c01152364191b05e5cbce65 Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Thu, 19 Nov 2020 21:32:22 -0500 Subject: [PATCH 3/8] [error] texture view creation --- player/src/lib.rs | 3 +- wgpu-core/src/device/mod.rs | 359 +++++++++++++++++++----------------- wgpu-core/src/resource.rs | 2 +- 3 files changed, 188 insertions(+), 176 deletions(-) diff --git a/player/src/lib.rs b/player/src/lib.rs index bfbb94ea9..f102e6546 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -163,7 +163,8 @@ impl GlobalPlay for wgc::hub::Global { desc, } => { self.device_maintain_ids::(device).unwrap(); - self.texture_create_view::(parent_id, &desc, id).unwrap(); + let (_, error) = self.texture_create_view::(parent_id, &desc, id); + assert_eq!(error, None); } A::DestroyTextureView(id) => { self.texture_view_drop::(id).unwrap(); diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs index 9fb420fa2..6a40242f7 100644 --- a/wgpu-core/src/device/mod.rs +++ b/wgpu-core/src/device/mod.rs @@ -598,6 +598,161 @@ impl Device { }) } + fn create_texture_view( + &self, + texture: &resource::Texture, + texture_id: id::TextureId, + desc: &resource::TextureViewDescriptor, + ) -> Result, resource::CreateTextureViewError> { + let &(ref texture_raw, _) = texture + .raw + .as_ref() + .ok_or(resource::CreateTextureViewError::InvalidTexture)?; + + let view_dim = + match desc.dimension { + Some(dim) => { + use hal::image::Kind; + + let required_tex_dim = dim.compatible_texture_dimension(); + + if required_tex_dim != texture.dimension { + return Err( + resource::CreateTextureViewError::InvalidTextureViewDimension { + view: dim, + image: texture.dimension, + }, + ); + } + + if let Kind::D2(_, _, depth, _) = texture.kind { + match dim { + TextureViewDimension::Cube if depth != 6 => { + return Err( + resource::CreateTextureViewError::InvalidCubemapTextureDepth { + depth, + }, + ) + } + TextureViewDimension::CubeArray if depth % 6 != 0 => return Err( + resource::CreateTextureViewError::InvalidCubemapArrayTextureDepth { + depth, + }, + ), + _ => {} + } + } + + dim + } + None => match texture.kind { + hal::image::Kind::D1(..) => wgt::TextureViewDimension::D1, + hal::image::Kind::D2(_, _, depth, _) + if depth > 1 && desc.array_layer_count.is_none() => + { + wgt::TextureViewDimension::D2Array + } + hal::image::Kind::D2(..) => wgt::TextureViewDimension::D2, + hal::image::Kind::D3(..) => wgt::TextureViewDimension::D3, + }, + }; + + let required_level_count = + desc.base_mip_level + desc.level_count.map_or(1, |count| count.get()); + let required_layer_count = + desc.base_array_layer + desc.array_layer_count.map_or(1, |count| count.get()); + let level_end = texture.full_range.levels.end; + let layer_end = texture.full_range.layers.end; + if required_level_count > level_end as u32 { + return Err(resource::CreateTextureViewError::TooManyMipLevels { + requested: required_level_count, + total: level_end, + }); + } + if required_layer_count > layer_end as u32 { + return Err(resource::CreateTextureViewError::TooManyArrayLayers { + requested: required_layer_count, + total: layer_end, + }); + }; + + let aspects = match desc.aspect { + wgt::TextureAspect::All => texture.aspects, + wgt::TextureAspect::DepthOnly => hal::format::Aspects::DEPTH, + wgt::TextureAspect::StencilOnly => hal::format::Aspects::STENCIL, + }; + if !texture.aspects.contains(aspects) { + return Err(resource::CreateTextureViewError::InvalidAspect { + requested: aspects, + total: texture.aspects, + }); + } + + let end_level = desc + .level_count + .map_or(level_end, |_| required_level_count as u8); + let end_layer = desc + .array_layer_count + .map_or(layer_end, |_| required_layer_count as u16); + let selector = TextureSelector { + levels: desc.base_mip_level as u8..end_level, + layers: desc.base_array_layer as u16..end_layer, + }; + + let view_layer_count = (selector.layers.end - selector.layers.start) as u32; + let layer_check_ok = match view_dim { + wgt::TextureViewDimension::D1 + | wgt::TextureViewDimension::D2 + | wgt::TextureViewDimension::D3 => view_layer_count == 1, + wgt::TextureViewDimension::D2Array => true, + wgt::TextureViewDimension::Cube => view_layer_count == 6, + wgt::TextureViewDimension::CubeArray => view_layer_count % 6 == 0, + }; + if !layer_check_ok { + return Err(resource::CreateTextureViewError::InvalidArrayLayerCount { + requested: view_layer_count, + dim: view_dim, + }); + } + + let format = desc.format.unwrap_or(texture.format); + let range = hal::image::SubresourceRange { + aspects, + level_start: desc.base_mip_level as _, + level_count: desc.level_count.map(|v| v.get() as _), + layer_start: desc.base_array_layer as _, + layer_count: desc.array_layer_count.map(|v| v.get() as _), + }; + + let raw = unsafe { + self.raw + .create_image_view( + texture_raw, + conv::map_texture_view_dimension(view_dim), + conv::map_texture_format(format, self.private_features), + hal::format::Swizzle::NO, + range.clone(), + ) + .or(Err(resource::CreateTextureViewError::OutOfMemory))? + }; + + Ok(resource::TextureView { + inner: resource::TextureViewInner::Native { + raw, + source_id: Stored { + value: id::Valid(texture_id), + ref_count: texture.life_guard.add_ref(), + }, + }, + aspects, + format: texture.format, + extent: texture.kind.extent().at_level(desc.base_mip_level as _), + samples: texture.kind.num_samples(), + selector, + life_guard: LifeGuard::new(desc.label.borrow_or_default()), + }) + } + /// Create a compatible render pass with a given key. /// /// This functions doesn't consider the following aspects for compatibility: @@ -1472,7 +1627,7 @@ impl Global { texture_id: id::TextureId, desc: &resource::TextureViewDescriptor, id_in: Input, - ) -> Result { + ) -> (id::TextureViewId, Option) { span!(_guard, INFO, "Texture::create_view"); let hub = B::hub(self); @@ -1480,192 +1635,48 @@ impl Global { let (device_guard, mut token) = hub.devices.read(&mut token); let (texture_guard, mut token) = hub.textures.read(&mut token); - let texture = texture_guard - .get(texture_id) - .map_err(|_| resource::CreateTextureViewError::InvalidTexture)?; - let &(ref texture_raw, _) = texture - .raw - .as_ref() - .ok_or(resource::CreateTextureViewError::InvalidTexture)?; - let device = &device_guard[texture.device_id.value]; - - let view_dim = - match desc.dimension { - Some(dim) => { - use hal::image::Kind; - - let required_tex_dim = dim.compatible_texture_dimension(); - - if required_tex_dim != texture.dimension { - return Err( - resource::CreateTextureViewError::InvalidTextureViewDimension { - view: dim, - image: texture.dimension, - }, - ); - } - - if let Kind::D2(_, _, depth, _) = texture.kind { - match dim { - TextureViewDimension::Cube if depth != 6 => { - return Err( - resource::CreateTextureViewError::InvalidCubemapTextureDepth { - depth, - }, - ) - } - TextureViewDimension::CubeArray if depth % 6 != 0 => return Err( - resource::CreateTextureViewError::InvalidCubemapArrayTextureDepth { - depth, - }, - ), - _ => {} - } - } - - dim - } - None => match texture.kind { - hal::image::Kind::D1(..) => wgt::TextureViewDimension::D1, - hal::image::Kind::D2(_, _, depth, _) - if depth > 1 && desc.array_layer_count.is_none() => - { - wgt::TextureViewDimension::D2Array - } - hal::image::Kind::D2(..) => wgt::TextureViewDimension::D2, - hal::image::Kind::D3(..) => wgt::TextureViewDimension::D3, - }, + let error = loop { + let texture = match texture_guard.get(texture_id) { + Ok(texture) => texture, + Err(_) => break resource::CreateTextureViewError::InvalidTexture, }; - let required_level_count = - desc.base_mip_level + desc.level_count.map_or(1, |count| count.get()); - let required_layer_count = - desc.base_array_layer + desc.array_layer_count.map_or(1, |count| count.get()); - let level_end = texture.full_range.levels.end; - let layer_end = texture.full_range.layers.end; - if required_level_count > level_end as u32 { - return Err(resource::CreateTextureViewError::TooManyMipLevels { - requested: required_level_count, - total: level_end, - }); - } - if required_layer_count > layer_end as u32 { - return Err(resource::CreateTextureViewError::TooManyArrayLayers { - requested: required_layer_count, - total: layer_end, - }); - }; + let device = &device_guard[texture.device_id.value]; - let aspects = match desc.aspect { - wgt::TextureAspect::All => texture.aspects, - wgt::TextureAspect::DepthOnly => hal::format::Aspects::DEPTH, - wgt::TextureAspect::StencilOnly => hal::format::Aspects::STENCIL, - }; - if !texture.aspects.contains(aspects) { - return Err(resource::CreateTextureViewError::InvalidAspect { - requested: aspects, - total: texture.aspects, - }); - } + let view = match device.create_texture_view(texture, texture_id, desc) { + Ok(view) => view, + Err(e) => break e, + }; + let ref_count = view.life_guard.add_ref(); - let end_level = desc - .level_count - .map_or(level_end, |_| required_level_count as u8); - let end_layer = desc - .array_layer_count - .map_or(layer_end, |_| required_layer_count as u16); - let selector = TextureSelector { - levels: desc.base_mip_level as u8..end_level, - layers: desc.base_array_layer as u16..end_layer, - }; + let id = hub.texture_views.register_identity(id_in, view, &mut token); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace.lock().add(trace::Action::CreateTextureView { + id: id.0, + parent_id: texture_id, + desc: desc.clone(), + }); + } - let view_layer_count = (selector.layers.end - selector.layers.start) as u32; - let layer_check_ok = match view_dim { - wgt::TextureViewDimension::D1 - | wgt::TextureViewDimension::D2 - | wgt::TextureViewDimension::D3 => view_layer_count == 1, - wgt::TextureViewDimension::D2Array => true, - wgt::TextureViewDimension::Cube => view_layer_count == 6, - wgt::TextureViewDimension::CubeArray => view_layer_count % 6 == 0, - }; - if !layer_check_ok { - return Err(resource::CreateTextureViewError::InvalidArrayLayerCount { - requested: view_layer_count, - dim: view_dim, - }); - } - - let format = desc.format.unwrap_or(texture.format); - let range = hal::image::SubresourceRange { - aspects, - level_start: desc.base_mip_level as _, - level_count: desc.level_count.map(|v| v.get() as _), - layer_start: desc.base_array_layer as _, - layer_count: desc.array_layer_count.map(|v| v.get() as _), - }; - - let raw = unsafe { device - .raw - .create_image_view( - texture_raw, - conv::map_texture_view_dimension(view_dim), - conv::map_texture_format(format, device.private_features), - hal::format::Swizzle::NO, - range.clone(), - ) - .or(Err(resource::CreateTextureViewError::OutOfMemory))? + .trackers + .lock() + .views + .init(id, ref_count, PhantomData) + .unwrap(); + return (id.0, None); }; - let view = resource::TextureView { - inner: resource::TextureViewInner::Native { - raw, - source_id: Stored { - value: id::Valid(texture_id), - ref_count: texture.life_guard.add_ref(), - }, - }, - aspects, - format: texture.format, - extent: texture.kind.extent().at_level(desc.base_mip_level as _), - samples: texture.kind.num_samples(), - selector, - life_guard: LifeGuard::new(desc.label.borrow_or_default()), - }; - let ref_count = view.life_guard.add_ref(); - - let id = hub.texture_views.register_identity(id_in, view, &mut token); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace.lock().add(trace::Action::CreateTextureView { - id: id.0, - parent_id: texture_id, - desc: desc.clone(), - }); - } - - device - .trackers - .lock() - .views - .init(id, ref_count, PhantomData) - .unwrap(); - Ok(id.0) + let id = + hub.texture_views + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } pub fn texture_view_label(&self, id: id::TextureViewId) -> String { B::hub(self).texture_views.label_for_resource(id) } - pub fn texture_view_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::TextureViewId { - B::hub(self) - .texture_views - .register_error(id_in, label.unwrap_or(""), &mut Token::root()) - } - pub fn texture_view_drop( &self, texture_view_id: id::TextureViewId, diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs index 3ac1e5b30..08cd32325 100644 --- a/wgpu-core/src/resource.rs +++ b/wgpu-core/src/resource.rs @@ -305,7 +305,7 @@ pub struct TextureView { pub(crate) life_guard: LifeGuard, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateTextureViewError { #[error("parent texture is invalid or destroyed")] InvalidTexture, From e96e5f917cde9da9c2b10bda5f8fe01e9eefb4e5 Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Thu, 19 Nov 2020 21:39:45 -0500 Subject: [PATCH 4/8] [error] sampler creation --- player/src/lib.rs | 3 +- wgpu-core/src/device/mod.rs | 206 +++++++++++++++++++----------------- wgpu-core/src/resource.rs | 2 +- 3 files changed, 111 insertions(+), 100 deletions(-) diff --git a/player/src/lib.rs b/player/src/lib.rs index f102e6546..3c38a0bb2 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -171,7 +171,8 @@ impl GlobalPlay for wgc::hub::Global { } A::CreateSampler(id, desc) => { self.device_maintain_ids::(device).unwrap(); - self.device_create_sampler::(device, &desc, id).unwrap(); + let (_, error) = self.device_create_sampler::(device, &desc, id); + assert_eq!(error, None); } A::DestroySampler(id) => { self.sampler_drop::(id); diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs index 6a40242f7..98b970891 100644 --- a/wgpu-core/src/device/mod.rs +++ b/wgpu-core/src/device/mod.rs @@ -753,6 +753,86 @@ impl Device { }) } + fn create_sampler( + &self, + self_id: id::DeviceId, + desc: &resource::SamplerDescriptor, + ) -> Result, resource::CreateSamplerError> { + let clamp_to_border_enabled = self + .features + .contains(wgt::Features::ADDRESS_MODE_CLAMP_TO_BORDER); + let clamp_to_border_found = desc + .address_modes + .iter() + .any(|am| am == &wgt::AddressMode::ClampToBorder); + if clamp_to_border_found && !clamp_to_border_enabled { + return Err(resource::CreateSamplerError::MissingFeature( + wgt::Features::ADDRESS_MODE_CLAMP_TO_BORDER, + )); + } + + let actual_clamp = if let Some(clamp) = desc.anisotropy_clamp { + let clamp = clamp.get(); + let valid_clamp = clamp <= MAX_ANISOTROPY && conv::is_power_of_two(clamp as u32); + if !valid_clamp { + return Err(resource::CreateSamplerError::InvalidClamp(clamp)); + } + if self.private_features.anisotropic_filtering { + Some(clamp) + } else { + None + } + } else { + None + }; + + let actual_border: hal::image::PackedColor = desc + .border_color + .map(|c| match c { + wgt::SamplerBorderColor::TransparentBlack => [0., 0., 0., 0.].into(), + wgt::SamplerBorderColor::OpaqueBlack => [0., 0., 0., 1.].into(), + wgt::SamplerBorderColor::OpaqueWhite => [1., 1., 1., 1.].into(), + }) + .unwrap_or([0., 0., 0., 0.].into()); + + let info = hal::image::SamplerDesc { + min_filter: conv::map_filter(desc.min_filter), + mag_filter: conv::map_filter(desc.mag_filter), + mip_filter: conv::map_filter(desc.mipmap_filter), + wrap_mode: ( + conv::map_wrap(desc.address_modes[0]), + conv::map_wrap(desc.address_modes[1]), + conv::map_wrap(desc.address_modes[2]), + ), + lod_bias: hal::image::Lod(0.0), + lod_range: hal::image::Lod(desc.lod_min_clamp)..hal::image::Lod(desc.lod_max_clamp), + comparison: desc.compare.map(conv::map_compare_function), + border: actual_border, + normalized: true, + anisotropy_clamp: actual_clamp, + }; + + let raw = unsafe { + self.raw.create_sampler(&info).map_err(|err| match err { + hal::device::AllocationError::OutOfMemory(_) => { + resource::CreateSamplerError::Device(DeviceError::OutOfMemory) + } + hal::device::AllocationError::TooManyObjects => { + resource::CreateSamplerError::TooManyObjects + } + })? + }; + Ok(resource::Sampler { + raw, + device_id: Stored { + value: id::Valid(self_id), + ref_count: self.life_guard.add_ref(), + }, + life_guard: LifeGuard::new(desc.label.borrow_or_default()), + comparison: info.comparison.is_some(), + }) + } + /// Create a compatible render pass with a given key. /// /// This functions doesn't consider the following aspects for compatibility: @@ -1724,122 +1804,52 @@ impl Global { device_id: id::DeviceId, desc: &resource::SamplerDescriptor, id_in: Input, - ) -> Result { + ) -> (id::SamplerId, Option) { span!(_guard, INFO, "Device::create_sampler"); let hub = B::hub(self); let mut token = Token::root(); let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; - let clamp_to_border_enabled = device - .features - .contains(wgt::Features::ADDRESS_MODE_CLAMP_TO_BORDER); - let clamp_to_border_found = desc - .address_modes - .iter() - .any(|am| am == &wgt::AddressMode::ClampToBorder); - if clamp_to_border_found && !clamp_to_border_enabled { - return Err(resource::CreateSamplerError::MissingFeature( - wgt::Features::ADDRESS_MODE_CLAMP_TO_BORDER, - )); - } + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; - let actual_clamp = if let Some(clamp) = desc.anisotropy_clamp { - let clamp = clamp.get(); - let valid_clamp = clamp <= MAX_ANISOTROPY && conv::is_power_of_two(clamp as u32); - if !valid_clamp { - return Err(resource::CreateSamplerError::InvalidClamp(clamp)); + let sampler = match device.create_sampler(device_id, desc) { + Ok(sampler) => sampler, + Err(e) => break e, + }; + let ref_count = sampler.life_guard.add_ref(); + + let id = hub.samplers.register_identity(id_in, sampler, &mut token); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace + .lock() + .add(trace::Action::CreateSampler(id.0, desc.clone())); } - if device.private_features.anisotropic_filtering { - Some(clamp) - } else { - None - } - } else { - None - }; - let actual_border: hal::image::PackedColor = desc - .border_color - .map(|c| match c { - wgt::SamplerBorderColor::TransparentBlack => [0., 0., 0., 0.].into(), - wgt::SamplerBorderColor::OpaqueBlack => [0., 0., 0., 1.].into(), - wgt::SamplerBorderColor::OpaqueWhite => [1., 1., 1., 1.].into(), - }) - .unwrap_or([0., 0., 0., 0.].into()); - - let info = hal::image::SamplerDesc { - min_filter: conv::map_filter(desc.min_filter), - mag_filter: conv::map_filter(desc.mag_filter), - mip_filter: conv::map_filter(desc.mipmap_filter), - wrap_mode: ( - conv::map_wrap(desc.address_modes[0]), - conv::map_wrap(desc.address_modes[1]), - conv::map_wrap(desc.address_modes[2]), - ), - lod_bias: hal::image::Lod(0.0), - lod_range: hal::image::Lod(desc.lod_min_clamp)..hal::image::Lod(desc.lod_max_clamp), - comparison: desc.compare.map(conv::map_compare_function), - border: actual_border, - normalized: true, - anisotropy_clamp: actual_clamp, - }; - - let raw = unsafe { - device.raw.create_sampler(&info).map_err(|err| match err { - hal::device::AllocationError::OutOfMemory(_) => { - resource::CreateSamplerError::Device(DeviceError::OutOfMemory) - } - hal::device::AllocationError::TooManyObjects => { - resource::CreateSamplerError::TooManyObjects - } - })? - }; - let sampler = resource::Sampler { - raw, - device_id: Stored { - value: id::Valid(device_id), - ref_count: device.life_guard.add_ref(), - }, - life_guard: LifeGuard::new(desc.label.borrow_or_default()), - comparison: info.comparison.is_some(), - }; - let ref_count = sampler.life_guard.add_ref(); - - let id = hub.samplers.register_identity(id_in, sampler, &mut token); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace + device + .trackers .lock() - .add(trace::Action::CreateSampler(id.0, desc.clone())); - } + .samplers + .init(id, ref_count, PhantomData) + .unwrap(); + return (id.0, None); + }; - device - .trackers - .lock() + let id = hub .samplers - .init(id, ref_count, PhantomData) - .unwrap(); - Ok(id.0) + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } pub fn sampler_label(&self, id: id::SamplerId) -> String { B::hub(self).samplers.label_for_resource(id) } - pub fn sampler_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::SamplerId { - B::hub(self) - .samplers - .register_error(id_in, label.unwrap_or(""), &mut Token::root()) - } - pub fn sampler_drop(&self, sampler_id: id::SamplerId) { span!(_guard, INFO, "Sampler::drop"); diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs index 08cd32325..d564cffa5 100644 --- a/wgpu-core/src/resource.rs +++ b/wgpu-core/src/resource.rs @@ -411,7 +411,7 @@ pub struct Sampler { pub(crate) comparison: bool, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateSamplerError { #[error(transparent)] Device(#[from] DeviceError), From fccbca28bd1f6bfb911a98ebc3be6e3b934482ff Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Thu, 19 Nov 2020 23:23:19 -0500 Subject: [PATCH 5/8] [error] shader module creation, separate descriptor --- Cargo.lock | 2 +- player/src/lib.rs | 29 +++-- player/tests/data/bind-group.ron | 1 + wgpu-core/Cargo.toml | 2 +- wgpu-core/src/device/mod.rs | 217 +++++++++++++++++-------------- wgpu-core/src/device/trace.rs | 1 + wgpu-core/src/pipeline.rs | 25 +++- 7 files changed, 160 insertions(+), 117 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ef3637b7d..26fe580db 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1121,7 +1121,7 @@ dependencies = [ [[package]] name = "naga" version = "0.2.0" -source = "git+https://github.com/gfx-rs/naga?rev=27ec95a2381ae8e0afd07fa13c83a436a9e0bd41#27ec95a2381ae8e0afd07fa13c83a436a9e0bd41" +source = "git+https://github.com/gfx-rs/naga?rev=7c7702c9d8d59325328aa7081347e151a7bb63d7#7c7702c9d8d59325328aa7081347e151a7bb63d7" dependencies = [ "bitflags", "fxhash", diff --git a/player/src/lib.rs b/player/src/lib.rs index 3c38a0bb2..96f4a8464 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -208,20 +208,23 @@ impl GlobalPlay for wgc::hub::Global { A::DestroyBindGroup(id) => { self.bind_group_drop::(id); } - A::CreateShaderModule { id, data } => { - let source = if data.ends_with(".wgsl") { - let code = fs::read_to_string(dir.join(data)).unwrap(); - wgc::pipeline::ShaderModuleSource::Wgsl(Cow::Owned(code)) - } else { - let byte_vec = fs::read(dir.join(data)).unwrap(); - let spv = byte_vec - .chunks(4) - .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]])) - .collect::>(); - wgc::pipeline::ShaderModuleSource::SpirV(Cow::Owned(spv)) + A::CreateShaderModule { id, data, label } => { + let desc = wgc::pipeline::ShaderModuleDescriptor { + source: if data.ends_with(".wgsl") { + let code = fs::read_to_string(dir.join(data)).unwrap(); + wgc::pipeline::ShaderModuleSource::Wgsl(Cow::Owned(code)) + } else { + let byte_vec = fs::read(dir.join(data)).unwrap(); + let spv = byte_vec + .chunks(4) + .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]])) + .collect::>(); + wgc::pipeline::ShaderModuleSource::SpirV(Cow::Owned(spv)) + }, + label, }; - self.device_create_shader_module::(device, source, id) - .unwrap(); + let (_, error) = self.device_create_shader_module::(device, &desc, id); + assert_eq!(error, None); } A::DestroyShaderModule(id) => { self.shader_module_drop::(id); diff --git a/player/tests/data/bind-group.ron b/player/tests/data/bind-group.ron index 18b341ca1..0c1674196 100644 --- a/player/tests/data/bind-group.ron +++ b/player/tests/data/bind-group.ron @@ -9,6 +9,7 @@ )), CreateShaderModule( id: Id(0, 1, Empty), + label: None, data: "empty.comp.spv", ), CreateComputePipeline(Id(0, 1, Empty), ( diff --git a/wgpu-core/Cargo.toml b/wgpu-core/Cargo.toml index c5c0e510f..580e026ef 100644 --- a/wgpu-core/Cargo.toml +++ b/wgpu-core/Cargo.toml @@ -40,7 +40,7 @@ gpu-alloc = { git = "https://github.com/zakarumych/gpu-alloc", rev = "7bd745e488 [dependencies.naga] version = "0.2" git = "https://github.com/gfx-rs/naga" -rev = "27ec95a2381ae8e0afd07fa13c83a436a9e0bd41" +rev = "7c7702c9d8d59325328aa7081347e151a7bb63d7" features = ["spv-in", "spv-out", "wgsl-in"] [dependencies.wgt] diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs index 98b970891..e4eb1a94f 100644 --- a/wgpu-core/src/device/mod.rs +++ b/wgpu-core/src/device/mod.rs @@ -833,6 +833,89 @@ impl Device { }) } + fn create_shader_module<'a>( + &self, + self_id: id::DeviceId, + desc: &'a pipeline::ShaderModuleDescriptor<'a>, + ) -> Result<(pipeline::ShaderModule, Cow<'a, [u32]>), pipeline::CreateShaderModuleError> + { + let spv_flags = if cfg!(debug_assertions) { + naga::back::spv::WriterFlags::DEBUG + } else { + naga::back::spv::WriterFlags::empty() + }; + + let (spv, naga) = match desc.source { + pipeline::ShaderModuleSource::SpirV(ref spv) => { + let module = if self.private_features.shader_validation { + // Parse the given shader code and store its representation. + let spv_iter = spv.iter().cloned(); + naga::front::spv::Parser::new(spv_iter, &Default::default()) + .parse() + .map_err(|err| { + // TODO: eventually, when Naga gets support for all features, + // we want to convert these to a hard error, + tracing::warn!("Failed to parse shader SPIR-V code: {:?}", err); + tracing::warn!("Shader module will not be validated"); + }) + .ok() + } else { + None + }; + (Cow::Borrowed(&**spv), module) + } + pipeline::ShaderModuleSource::Wgsl(ref code) => { + // TODO: refactor the corresponding Naga error to be owned, and then + // display it instead of unwrapping + let module = naga::front::wgsl::parse_str(code).unwrap(); + let spv = naga::back::spv::Writer::new(&module.header, spv_flags).write(&module); + ( + Cow::Owned(spv), + if self.private_features.shader_validation { + Some(module) + } else { + None + }, + ) + } /* + pipeline::ShaderModuleSource::Naga(module) => { + let spv = naga::back::spv::Writer::new(&module.header, spv_flags).write(&module); + ( + Cow::Owned(spv), + if device.private_features.shader_validation { + Some(module) + } else { + None + }, + ) + }*/ + }; + + if let Some(ref module) = naga { + naga::proc::Validator::new().validate(module)?; + } + + let raw = unsafe { + self.raw + .create_shader_module(&spv) + .map_err(|err| match err { + hal::device::ShaderError::OutOfMemory(_) => DeviceError::OutOfMemory, + _ => panic!("failed to create shader module: {}", err), + })? + }; + let shader = pipeline::ShaderModule { + raw, + device_id: Stored { + value: id::Valid(self_id), + ref_count: self.life_guard.add_ref(), + }, + module: naga, + #[cfg(debug_assertions)] + label: desc.label.to_string_or_default(), + }; + Ok((shader, spv)) + } + /// Create a compatible render pass with a given key. /// /// This functions doesn't consider the following aspects for compatibility: @@ -2569,119 +2652,59 @@ impl Global { pub fn device_create_shader_module( &self, device_id: id::DeviceId, - source: pipeline::ShaderModuleSource, + desc: &pipeline::ShaderModuleDescriptor, id_in: Input, - ) -> Result { + ) -> ( + id::ShaderModuleId, + Option, + ) { span!(_guard, INFO, "Device::create_shader_module"); let hub = B::hub(self); let mut token = Token::root(); + let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; - let spv_flags = if cfg!(debug_assertions) { - naga::back::spv::WriterFlags::DEBUG - } else { - naga::back::spv::WriterFlags::empty() - }; + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; + let (shader, spv) = match device.create_shader_module(device_id, desc) { + Ok(pair) => pair, + Err(e) => break e, + }; - let (spv, naga) = match source { - pipeline::ShaderModuleSource::SpirV(spv) => { - let module = if device.private_features.shader_validation { - // Parse the given shader code and store its representation. - let spv_iter = spv.into_iter().cloned(); - naga::front::spv::Parser::new(spv_iter, &Default::default()) - .parse() - .map_err(|err| { - // TODO: eventually, when Naga gets support for all features, - // we want to convert these to a hard error, - tracing::warn!("Failed to parse shader SPIR-V code: {:?}", err); - tracing::warn!("Shader module will not be validated"); - }) - .ok() - } else { - None - }; - (spv, module) - } - pipeline::ShaderModuleSource::Wgsl(code) => { - // TODO: refactor the corresponding Naga error to be owned, and then - // display it instead of unwrapping - let module = naga::front::wgsl::parse_str(&code).unwrap(); - let spv = naga::back::spv::Writer::new(&module.header, spv_flags).write(&module); - ( - Cow::Owned(spv), - if device.private_features.shader_validation { - Some(module) - } else { - None - }, - ) - } - pipeline::ShaderModuleSource::Naga(module) => { - let spv = naga::back::spv::Writer::new(&module.header, spv_flags).write(&module); - ( - Cow::Owned(spv), - if device.private_features.shader_validation { - Some(module) - } else { - None - }, - ) + let id = hub + .shader_modules + .register_identity(id_in, shader, &mut token); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + let mut trace = trace.lock(); + let data = trace.make_binary("spv", unsafe { + std::slice::from_raw_parts(spv.as_ptr() as *const u8, spv.len() * 4) + }); + let label = desc.label.clone(); + trace.add(trace::Action::CreateShaderModule { + id: id.0, + data, + label, + }); } + + let _ = spv; + return (id.0, None); }; - if let Some(ref module) = naga { - naga::proc::Validator::new().validate(module)?; - } - - let raw = unsafe { - device - .raw - .create_shader_module(&spv) - .map_err(|err| match err { - hal::device::ShaderError::OutOfMemory(_) => DeviceError::OutOfMemory, - _ => panic!("failed to create shader module: {}", err), - })? - }; - let shader = pipeline::ShaderModule { - raw, - device_id: Stored { - value: id::Valid(device_id), - ref_count: device.life_guard.add_ref(), - }, - module: naga, - }; - - let id = hub - .shader_modules - .register_identity(id_in, shader, &mut token); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - let mut trace = trace.lock(); - let data = trace.make_binary("spv", unsafe { - std::slice::from_raw_parts(spv.as_ptr() as *const u8, spv.len() * 4) - }); - trace.add(trace::Action::CreateShaderModule { id: id.0, data }); - } - Ok(id.0) + let id = + hub.shader_modules + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } pub fn shader_module_label(&self, id: id::ShaderModuleId) -> String { B::hub(self).shader_modules.label_for_resource(id) } - pub fn shader_module_error( - &self, - id_in: Input, - ) -> id::ShaderModuleId { - let hub = B::hub(self); - let mut token = Token::root(); - let (_, mut token) = hub.devices.read(&mut token); - hub.shader_modules.register_error(id_in, "", &mut token) - } - pub fn shader_module_drop(&self, shader_module_id: id::ShaderModuleId) { span!(_guard, INFO, "ShaderModule::drop"); diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs index dc78864d9..354649819 100644 --- a/wgpu-core/src/device/trace.rs +++ b/wgpu-core/src/device/trace.rs @@ -71,6 +71,7 @@ pub enum Action<'a> { DestroyBindGroup(id::BindGroupId), CreateShaderModule { id: id::ShaderModuleId, + label: crate::Label<'a>, data: FileName, }, DestroyShaderModule(id::ShaderModuleId), diff --git a/wgpu-core/src/pipeline.rs b/wgpu-core/src/pipeline.rs index e47b9a941..55f271bdb 100644 --- a/wgpu-core/src/pipeline.rs +++ b/wgpu-core/src/pipeline.rs @@ -14,13 +14,23 @@ use std::borrow::Cow; use thiserror::Error; use wgt::{BufferAddress, IndexFormat, InputStepMode}; -// Unable to serialize with `naga::Module` in here: -// requires naga serialization feature. #[derive(Debug)] +#[cfg_attr(feature = "trace", derive(serde::Serialize))] +#[cfg_attr(feature = "replay", derive(serde::Deserialize))] pub enum ShaderModuleSource<'a> { SpirV(Cow<'a, [u32]>), Wgsl(Cow<'a, str>), - Naga(naga::Module), + // Unable to serialize with `naga::Module` in here: + // requires naga serialization feature. + //Naga(naga::Module), +} + +#[derive(Debug)] +#[cfg_attr(feature = "trace", derive(serde::Serialize))] +#[cfg_attr(feature = "replay", derive(serde::Deserialize))] +pub struct ShaderModuleDescriptor<'a> { + pub label: Label<'a>, + pub source: ShaderModuleSource<'a>, } #[derive(Debug)] @@ -28,6 +38,8 @@ pub struct ShaderModule { pub(crate) raw: B::ShaderModule, pub(crate) device_id: Stored, pub(crate) module: Option, + #[cfg(debug_assertions)] + pub(crate) label: String, } impl Resource for ShaderModule { @@ -38,11 +50,14 @@ impl Resource for ShaderModule { } fn label(&self) -> &str { - "" + #[cfg(debug_assertions)] + return &self.label; + #[cfg(not(debug_assertions))] + return ""; } } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateShaderModuleError { #[error(transparent)] Device(#[from] DeviceError), From ad824de268e33d0efbab0dd344207e7b01e9fd5a Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Fri, 20 Nov 2020 20:28:11 -0500 Subject: [PATCH 6/8] [error] bind groups and layouts creation --- player/src/bin/play.rs | 11 +- player/src/lib.rs | 12 +- player/tests/test.rs | 10 +- wgpu-core/src/binding_model.rs | 12 +- wgpu-core/src/device/mod.rs | 942 +++++++++++++++++---------------- wgpu-core/src/device/trace.rs | 2 +- wgpu-core/src/instance.rs | 307 ++++++----- wgpu-core/src/validation.rs | 2 +- wgpu-types/src/lib.rs | 15 +- 9 files changed, 683 insertions(+), 630 deletions(-) diff --git a/player/src/bin/play.rs b/player/src/bin/play.rs index 2f67b4798..b2ae956bb 100644 --- a/player/src/bin/play.rs +++ b/player/src/bin/play.rs @@ -84,16 +84,19 @@ fn main() { let info = gfx_select!(adapter => global.adapter_get_info(adapter)).unwrap(); log::info!("Picked '{}'", info.name); - gfx_select!(adapter => global.adapter_request_device( + let id = wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty); + let (_, error) = gfx_select!(adapter => global.adapter_request_device( adapter, &desc, None, - wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty) - )) - .expect("Failed to request device") + id + )); + assert_eq!(error, None); + id } _ => panic!("Expected Action::Init"), }; + log::info!("Executing actions"); #[cfg(not(feature = "winit"))] { diff --git a/player/src/lib.rs b/player/src/lib.rs index 96f4a8464..987254bfe 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -186,24 +186,24 @@ impl GlobalPlay for wgc::hub::Global { } } A::CreateBindGroupLayout(id, desc) => { - self.device_create_bind_group_layout::(device, &desc, id) - .unwrap(); + let (_, error) = self.device_create_bind_group_layout::(device, &desc, id); + assert_eq!(error, None); } A::DestroyBindGroupLayout(id) => { self.bind_group_layout_drop::(id); } A::CreatePipelineLayout(id, desc) => { self.device_maintain_ids::(device).unwrap(); - self.device_create_pipeline_layout::(device, &desc, id) - .unwrap(); + let (_, error) = self.device_create_pipeline_layout::(device, &desc, id); + assert_eq!(error, None); } A::DestroyPipelineLayout(id) => { self.pipeline_layout_drop::(id); } A::CreateBindGroup(id, desc) => { self.device_maintain_ids::(device).unwrap(); - self.device_create_bind_group::(device, &desc, id) - .unwrap(); + let (_, error) = self.device_create_bind_group::(device, &desc, id); + assert_eq!(error, None); } A::DestroyBindGroup(id) => { self.bind_group_drop::(id); diff --git a/player/tests/test.rs b/player/tests/test.rs index 3f52ff193..43397c388 100644 --- a/player/tests/test.rs +++ b/player/tests/test.rs @@ -86,17 +86,19 @@ impl Test<'_> { test_num: u32, ) { let backend = adapter.backend(); - let device = gfx_select!(adapter => global.adapter_request_device( + let device = wgc::id::TypedId::zip(test_num, 0, backend); + let (_, error) = gfx_select!(adapter => global.adapter_request_device( adapter, &wgt::DeviceDescriptor { + label: None, features: self.features | wgt::Features::MAPPABLE_PRIMARY_BUFFERS, limits: wgt::Limits::default(), shader_validation: true, }, None, - wgc::id::TypedId::zip(test_num, 0, backend) - )) - .unwrap(); + device + )); + assert_eq!(error, None); let mut command_buffer_id_manager = wgc::hub::IdentityManager::default(); println!("\t\t\tRunning..."); diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs index cc5d270a5..c90a65db4 100644 --- a/wgpu-core/src/binding_model.rs +++ b/wgpu-core/src/binding_model.rs @@ -26,7 +26,7 @@ use std::{ use thiserror::Error; -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateBindGroupLayoutError { #[error(transparent)] Device(#[from] DeviceError), @@ -40,7 +40,7 @@ pub enum CreateBindGroupLayoutError { TooManyBindings(BindingTypeMaxCountError), } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateBindGroupError { #[error(transparent)] Device(#[from] DeviceError), @@ -96,7 +96,7 @@ pub enum CreateBindGroupError { DepthStencilAspect, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum BindingZone { #[error("stage {0:?}")] Stage(wgt::ShaderStage), @@ -104,7 +104,7 @@ pub enum BindingZone { Pipeline, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] #[error("too many bindings of type {kind:?} in {zone}, limit is {count}")] pub struct BindingTypeMaxCountError { pub kind: BindingTypeMaxCountErrorKind, @@ -112,7 +112,7 @@ pub struct BindingTypeMaxCountError { pub count: u32, } -#[derive(Clone, Debug)] +#[derive(Clone, Debug, PartialEq)] pub enum BindingTypeMaxCountErrorKind { DynamicUniformBuffers, DynamicStorageBuffers, @@ -336,7 +336,7 @@ impl Resource for BindGroupLayout { } } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreatePipelineLayoutError { #[error(transparent)] Device(#[from] DeviceError), diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs index e4eb1a94f..bc13b652f 100644 --- a/wgpu-core/src/device/mod.rs +++ b/wgpu-core/src/device/mod.rs @@ -3,8 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use crate::{ - binding_model::{self, CreateBindGroupError, CreatePipelineLayoutError}, - command, conv, + binding_model, command, conv, device::life::WaitIdleError, hub::{ GfxBackend, Global, GlobalIdentityHandlerFactory, Hub, Input, InvalidId, Storage, Token, @@ -57,6 +56,8 @@ pub const MAX_VERTEX_BUFFERS: usize = 16; pub const MAX_ANISOTROPY: u8 = 16; pub const SHADER_STAGE_COUNT: usize = 3; +pub type DeviceDescriptor<'a> = wgt::DeviceDescriptor>; + pub fn all_buffer_stages() -> hal::pso::PipelineStage { use hal::pso::PipelineStage as Ps; Ps::DRAW_INDIRECT @@ -252,7 +253,7 @@ impl Device { mem_props: hal::adapter::MemoryProperties, hal_limits: hal::Limits, private_features: PrivateFeatures, - desc: &wgt::DeviceDescriptor, + desc: &DeviceDescriptor, trace_path: Option<&std::path::Path>, ) -> Result { let cmd_allocator = command::CommandAllocator::new(queue_group.family, &raw) @@ -1057,16 +1058,351 @@ impl Device { }) } + fn create_bind_group( + &self, + self_id: id::DeviceId, + layout: &binding_model::BindGroupLayout, + desc: &binding_model::BindGroupDescriptor, + hub: &Hub, + token: &mut Token>, + ) -> Result, binding_model::CreateBindGroupError> { + use crate::binding_model::{BindingResource as Br, CreateBindGroupError as Error}; + { + // Check that the number of entries in the descriptor matches + // the number of entries in the layout. + let actual = desc.entries.len(); + let expected = layout.entries.len(); + if actual != expected { + return Err(Error::BindingsNumMismatch { expected, actual }); + } + } + + // TODO: arrayvec/smallvec + // Record binding info for dynamic offset validation + let mut dynamic_binding_info = Vec::new(); + // fill out the descriptors + let mut used = TrackerSet::new(B::VARIANT); + + let (buffer_guard, mut token) = hub.buffers.read(token); + let (texture_guard, mut token) = hub.textures.read(&mut token); //skip token + let (texture_view_guard, mut token) = hub.texture_views.read(&mut token); + let (sampler_guard, _) = hub.samplers.read(&mut token); + + // `BTreeMap` has ordered bindings as keys, which allows us to coalesce + // the descriptor writes into a single transaction. + let mut write_map = BTreeMap::new(); + for entry in desc.entries.iter() { + let binding = entry.binding; + // Find the corresponding declaration in the layout + let decl = layout + .entries + .get(&binding) + .ok_or(Error::MissingBindingDeclaration(binding))?; + let descriptors: SmallVec<[_; 1]> = match entry.resource { + Br::Buffer(ref bb) => { + let (pub_usage, internal_use, min_size, dynamic) = match decl.ty { + wgt::BindingType::UniformBuffer { + dynamic, + min_binding_size, + } => ( + wgt::BufferUsage::UNIFORM, + resource::BufferUse::UNIFORM, + min_binding_size, + dynamic, + ), + wgt::BindingType::StorageBuffer { + dynamic, + min_binding_size, + readonly, + } => ( + wgt::BufferUsage::STORAGE, + if readonly { + resource::BufferUse::STORAGE_LOAD + } else { + resource::BufferUse::STORAGE_STORE + }, + min_binding_size, + dynamic, + ), + _ => { + return Err(Error::WrongBindingType { + binding, + actual: decl.ty.clone(), + expected: "UniformBuffer, StorageBuffer or ReadonlyStorageBuffer", + }) + } + }; + + if bb.offset % wgt::BIND_BUFFER_ALIGNMENT != 0 { + return Err(Error::UnalignedBufferOffset(bb.offset)); + } + + let buffer = used + .buffers + .use_extend(&*buffer_guard, bb.buffer_id, (), internal_use) + .map_err(|_| Error::InvalidBuffer(bb.buffer_id))?; + check_buffer_usage(buffer.usage, pub_usage)?; + let &(ref buffer_raw, _) = buffer + .raw + .as_ref() + .ok_or(Error::InvalidBuffer(bb.buffer_id))?; + + let (bind_size, bind_end) = match bb.size { + Some(size) => { + let end = bb.offset + size.get(); + if end > buffer.size { + return Err(Error::BindingRangeTooLarge { + range: bb.offset..end, + size: buffer.size, + }); + } + (size.get(), end) + } + None => (buffer.size - bb.offset, buffer.size), + }; + + if pub_usage == wgt::BufferUsage::UNIFORM + && (self.limits.max_uniform_buffer_binding_size as u64) < bind_size + { + return Err(Error::UniformBufferRangeTooLarge); + } + + // Record binding info for validating dynamic offsets + if dynamic { + dynamic_binding_info.push(binding_model::BindGroupDynamicBindingData { + maximum_dynamic_offset: buffer.size - bind_end, + }); + } + + if let Some(non_zero) = min_size { + let min_size = non_zero.get(); + if min_size > bind_size { + return Err(Error::BindingSizeTooSmall { + actual: bind_size, + min: min_size, + }); + } + } + + let sub_range = hal::buffer::SubRange { + offset: bb.offset, + size: Some(bind_size), + }; + SmallVec::from([hal::pso::Descriptor::Buffer(buffer_raw, sub_range)]) + } + Br::Sampler(id) => { + match decl.ty { + wgt::BindingType::Sampler { comparison } => { + let sampler = used + .samplers + .use_extend(&*sampler_guard, id, (), ()) + .map_err(|_| Error::InvalidSampler(id))?; + + // Check the actual sampler to also (not) be a comparison sampler + if sampler.comparison != comparison { + return Err(Error::WrongSamplerComparison); + } + + SmallVec::from([hal::pso::Descriptor::Sampler(&sampler.raw)]) + } + _ => { + return Err(Error::WrongBindingType { + binding, + actual: decl.ty.clone(), + expected: "Sampler", + }) + } + } + } + Br::TextureView(id) => { + let view = used + .views + .use_extend(&*texture_view_guard, id, (), ()) + .map_err(|_| Error::InvalidTextureView(id))?; + let (pub_usage, internal_use) = match decl.ty { + wgt::BindingType::SampledTexture { .. } => { + (wgt::TextureUsage::SAMPLED, resource::TextureUse::SAMPLED) + } + wgt::BindingType::StorageTexture { readonly, .. } => ( + wgt::TextureUsage::STORAGE, + if readonly { + resource::TextureUse::STORAGE_LOAD + } else { + resource::TextureUse::STORAGE_STORE + }, + ), + _ => return Err(Error::WrongBindingType { + binding, + actual: decl.ty.clone(), + expected: + "SampledTexture, ReadonlyStorageTexture or WriteonlyStorageTexture", + }), + }; + if view + .aspects + .contains(hal::format::Aspects::DEPTH | hal::format::Aspects::STENCIL) + { + return Err(Error::DepthStencilAspect); + } + match view.inner { + resource::TextureViewInner::Native { + ref raw, + ref source_id, + } => { + // Careful here: the texture may no longer have its own ref count, + // if it was deleted by the user. + let texture = &texture_guard[source_id.value]; + used.textures + .change_extend( + source_id.value, + &source_id.ref_count, + view.selector.clone(), + internal_use, + ) + .unwrap(); + check_texture_usage(texture.usage, pub_usage)?; + let image_layout = + conv::map_texture_state(internal_use, view.aspects).1; + SmallVec::from([hal::pso::Descriptor::Image(raw, image_layout)]) + } + resource::TextureViewInner::SwapChain { .. } => { + return Err(Error::SwapChainImage); + } + } + } + Br::TextureViewArray(ref bindings_array) => { + let required_feats = wgt::Features::SAMPLED_TEXTURE_BINDING_ARRAY; + if !self.features.contains(required_feats) { + return Err(Error::MissingFeatures(required_feats)); + } + + if let Some(count) = decl.count { + let count = count.get() as usize; + let num_bindings = bindings_array.len(); + if count != num_bindings { + return Err(Error::BindingArrayLengthMismatch { + actual: num_bindings, + expected: count, + }); + } + } else { + return Err(Error::SingleBindingExpected); + } + + let (pub_usage, internal_use) = match decl.ty { + wgt::BindingType::SampledTexture { .. } => { + (wgt::TextureUsage::SAMPLED, resource::TextureUse::SAMPLED) + } + _ => { + return Err(Error::WrongBindingType { + binding, + actual: decl.ty.clone(), + expected: "SampledTextureArray", + }) + } + }; + bindings_array + .iter() + .map(|&id| { + let view = used + .views + .use_extend(&*texture_view_guard, id, (), ()) + .map_err(|_| Error::InvalidTextureView(id))?; + match view.inner { + resource::TextureViewInner::Native { + ref raw, + ref source_id, + } => { + // Careful here: the texture may no longer have its own ref count, + // if it was deleted by the user. + let texture = &texture_guard[source_id.value]; + used.textures + .change_extend( + source_id.value, + &source_id.ref_count, + view.selector.clone(), + internal_use, + ) + .unwrap(); + check_texture_usage(texture.usage, pub_usage)?; + let image_layout = + conv::map_texture_state(internal_use, view.aspects).1; + Ok(hal::pso::Descriptor::Image(raw, image_layout)) + } + resource::TextureViewInner::SwapChain { .. } => { + Err(Error::SwapChainImage) + } + } + }) + .collect::>()? + } + }; + if write_map.insert(binding, descriptors).is_some() { + return Err(Error::DuplicateBinding(binding)); + } + } + + let mut desc_sets = ArrayVec::<[_; 1]>::new(); + self.desc_allocator + .lock() + .allocate( + &self.raw, + &layout.raw, + &layout.desc_counts, + 1, + &mut desc_sets, + ) + .expect("failed to allocate descriptor set"); + let mut desc_set = desc_sets.pop().unwrap(); + + // Set the descriptor set's label for easier debugging. + if let Some(label) = desc.label.as_ref() { + unsafe { + self.raw.set_descriptor_set_name(desc_set.raw_mut(), &label); + } + } + + if let Some(start_binding) = write_map.keys().next().cloned() { + let descriptors = write_map + .into_iter() + .flat_map(|(_, list)| list) + .collect::>(); + let write = hal::pso::DescriptorSetWrite { + set: desc_set.raw(), + binding: start_binding, + array_offset: 0, + descriptors, + }; + unsafe { + self.raw.write_descriptor_sets(iter::once(write)); + } + } + + Ok(binding_model::BindGroup { + raw: desc_set, + device_id: Stored { + value: id::Valid(self_id), + ref_count: self.life_guard.add_ref(), + }, + layout_id: id::Valid(desc.layout), + life_guard: LifeGuard::new(desc.label.borrow_or_default()), + used, + dynamic_binding_info, + }) + } + fn create_pipeline_layout( &self, self_id: id::DeviceId, desc: &binding_model::PipelineLayoutDescriptor, bgl_guard: &Storage, id::BindGroupLayoutId>, - ) -> Result, CreatePipelineLayoutError> { + ) -> Result, binding_model::CreatePipelineLayoutError> { + use crate::binding_model::CreatePipelineLayoutError as Error; + let bind_group_layouts_count = desc.bind_group_layouts.len(); let device_max_bind_groups = self.limits.max_bind_groups as usize; if bind_group_layouts_count > device_max_bind_groups { - return Err(CreatePipelineLayoutError::TooManyGroups { + return Err(Error::TooManyGroups { actual: bind_group_layouts_count, max: device_max_bind_groups, }); @@ -1075,26 +1411,22 @@ impl Device { if !desc.push_constant_ranges.is_empty() && !self.features.contains(wgt::Features::PUSH_CONSTANTS) { - return Err(CreatePipelineLayoutError::MissingFeature( - wgt::Features::PUSH_CONSTANTS, - )); + return Err(Error::MissingFeature(wgt::Features::PUSH_CONSTANTS)); } let mut used_stages = wgt::ShaderStage::empty(); for (index, pc) in desc.push_constant_ranges.iter().enumerate() { if pc.stages.intersects(used_stages) { - return Err( - CreatePipelineLayoutError::MoreThanOnePushConstantRangePerStage { - index, - provided: pc.stages, - intersected: pc.stages & used_stages, - }, - ); + return Err(Error::MoreThanOnePushConstantRangePerStage { + index, + provided: pc.stages, + intersected: pc.stages & used_stages, + }); } used_stages |= pc.stages; let device_max_pc_size = self.limits.max_push_constant_size; if device_max_pc_size < pc.range.end { - return Err(CreatePipelineLayoutError::PushConstantRangeTooLarge { + return Err(Error::PushConstantRangeTooLarge { index, range: pc.range.clone(), max: device_max_pc_size, @@ -1102,13 +1434,13 @@ impl Device { } if pc.range.start % wgt::PUSH_CONSTANT_ALIGNMENT != 0 { - return Err(CreatePipelineLayoutError::MisalignedPushConstantRange { + return Err(Error::MisalignedPushConstantRange { index, bound: pc.range.start, }); } if pc.range.end % wgt::PUSH_CONSTANT_ALIGNMENT != 0 { - return Err(CreatePipelineLayoutError::MisalignedPushConstantRange { + return Err(Error::MisalignedPushConstantRange { index, bound: pc.range.end, }); @@ -1121,12 +1453,12 @@ impl Device { for &id in desc.bind_group_layouts.iter() { let bind_group_layout = bgl_guard .get(id) - .map_err(|_| CreatePipelineLayoutError::InvalidBindGroupLayout(id))?; + .map_err(|_| Error::InvalidBindGroupLayout(id))?; count_validator.merge(&bind_group_layout.count_validator); } count_validator .validate(&self.limits) - .map_err(CreatePipelineLayoutError::TooManyBindings)?; + .map_err(Error::TooManyBindings)?; let descriptor_set_layouts = desc .bind_group_layouts @@ -1967,71 +2299,76 @@ impl Global { device_id: id::DeviceId, desc: &binding_model::BindGroupLayoutDescriptor, id_in: Input, - ) -> Result { + ) -> ( + id::BindGroupLayoutId, + Option, + ) { span!(_guard, INFO, "Device::create_bind_group_layout"); let mut token = Token::root(); let hub = B::hub(self); - let mut entry_map = FastHashMap::default(); - for entry in desc.entries.iter() { - if entry_map.insert(entry.binding, entry.clone()).is_some() { - return Err(binding_model::CreateBindGroupLayoutError::ConflictBinding( - entry.binding, - )); + + let error = 'outer: loop { + let mut entry_map = FastHashMap::default(); + for entry in desc.entries.iter() { + if entry_map.insert(entry.binding, entry.clone()).is_some() { + break 'outer binding_model::CreateBindGroupLayoutError::ConflictBinding( + entry.binding, + ); + } } - } - let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; + let (device_guard, mut token) = hub.devices.read(&mut token); + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; - // If there is an equivalent BGL, just bump the refcount and return it. - // This is only applicable for identity filters that are generating new IDs, - // so their inputs are `PhantomData` of size 0. - if mem::size_of::>() == 0 { - let (bgl_guard, _) = hub.bind_group_layouts.read(&mut token); - if let Some(id) = - Device::deduplicate_bind_group_layout(device_id, &entry_map, &*bgl_guard) - { - return Ok(id); + // If there is an equivalent BGL, just bump the refcount and return it. + // This is only applicable for identity filters that are generating new IDs, + // so their inputs are `PhantomData` of size 0. + if mem::size_of::>() == 0 { + let (bgl_guard, _) = hub.bind_group_layouts.read(&mut token); + if let Some(id) = + Device::deduplicate_bind_group_layout(device_id, &entry_map, &*bgl_guard) + { + return (id, None); + } } - } - let layout = device.create_bind_group_layout( - device_id, - desc.label.as_ref().map(|cow| cow.as_ref()), - entry_map, - )?; + let layout = match device.create_bind_group_layout( + device_id, + desc.label.as_ref().map(|cow| cow.as_ref()), + entry_map, + ) { + Ok(layout) => layout, + Err(e) => break e, + }; - let id = hub - .bind_group_layouts - .register_identity(id_in, layout, &mut token); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace - .lock() - .add(trace::Action::CreateBindGroupLayout(id.0, desc.clone())); - } - Ok(id.0) + let id = hub + .bind_group_layouts + .register_identity(id_in, layout, &mut token); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace + .lock() + .add(trace::Action::CreateBindGroupLayout(id.0, desc.clone())); + } + return (id.0, None); + }; + + let id = hub.bind_group_layouts.register_error( + id_in, + desc.label.borrow_or_default(), + &mut token, + ); + (id, Some(error)) } pub fn bind_group_layout_label(&self, id: id::BindGroupLayoutId) -> String { B::hub(self).bind_group_layouts.label_for_resource(id) } - pub fn bind_group_layout_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::BindGroupLayoutId { - B::hub(self).bind_group_layouts.register_error( - id_in, - label.unwrap_or(""), - &mut Token::root(), - ) - } - pub fn bind_group_layout_drop( &self, bind_group_layout_id: id::BindGroupLayoutId, @@ -2065,48 +2402,52 @@ impl Global { device_id: id::DeviceId, desc: &binding_model::PipelineLayoutDescriptor, id_in: Input, - ) -> Result { + ) -> ( + id::PipelineLayoutId, + Option, + ) { span!(_guard, INFO, "Device::create_pipeline_layout"); let hub = B::hub(self); let mut token = Token::root(); let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; - let layout = { - let (bgl_guard, _) = hub.bind_group_layouts.read(&mut token); - device.create_pipeline_layout(device_id, desc, &*bgl_guard)? + let layout = { + let (bgl_guard, _) = hub.bind_group_layouts.read(&mut token); + match device.create_pipeline_layout(device_id, desc, &*bgl_guard) { + Ok(layout) => layout, + Err(e) => break e, + } + }; + + let id = hub + .pipeline_layouts + .register_identity(id_in, layout, &mut token); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace + .lock() + .add(trace::Action::CreatePipelineLayout(id.0, desc.clone())); + } + return (id.0, None); }; - let id = hub - .pipeline_layouts - .register_identity(id_in, layout, &mut token); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace - .lock() - .add(trace::Action::CreatePipelineLayout(id.0, desc.clone())); - } - Ok(id.0) + let id = + hub.pipeline_layouts + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } pub fn pipeline_layout_label(&self, id: id::PipelineLayoutId) -> String { B::hub(self).pipeline_layouts.label_for_resource(id) } - pub fn pipeline_layout_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::PipelineLayoutId { - B::hub(self) - .pipeline_layouts - .register_error(id_in, label.unwrap_or(""), &mut Token::root()) - } - pub fn pipeline_layout_drop(&self, pipeline_layout_id: id::PipelineLayoutId) { span!(_guard, INFO, "PipelineLayout::drop"); @@ -2234,392 +2575,71 @@ impl Global { device_id: id::DeviceId, desc: &binding_model::BindGroupDescriptor, id_in: Input, - ) -> Result { - use crate::binding_model::BindingResource as Br; - + ) -> (id::BindGroupId, Option) { span!(_guard, INFO, "Device::create_bind_group"); let hub = B::hub(self); let mut token = Token::root(); let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; let (bind_group_layout_guard, mut token) = hub.bind_group_layouts.read(&mut token); - let bind_group_layout = bind_group_layout_guard - .get(desc.layout) - .map_err(|_| CreateBindGroupError::InvalidLayout)?; - { - // Check that the number of entries in the descriptor matches - // the number of entries in the layout. - let actual = desc.entries.len(); - let expected = bind_group_layout.entries.len(); - if actual != expected { - return Err(CreateBindGroupError::BindingsNumMismatch { expected, actual }); - } - } + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; + let bind_group_layout = match bind_group_layout_guard.get(desc.layout) { + Ok(layout) => layout, + Err(_) => break binding_model::CreateBindGroupError::InvalidLayout, + }; - // TODO: arrayvec/smallvec - // Record binding info for dynamic offset validation - let mut dynamic_binding_info = Vec::new(); + let bind_group = match device.create_bind_group( + device_id, + bind_group_layout, + desc, + &hub, + &mut token, + ) { + Ok(bind_group) => bind_group, + Err(e) => break e, + }; + let ref_count = bind_group.life_guard.add_ref(); - // fill out the descriptors - let mut used = TrackerSet::new(B::VARIANT); - let desc_set = { - let (buffer_guard, mut token) = hub.buffers.read(&mut token); - let (texture_guard, mut token) = hub.textures.read(&mut token); //skip token - let (texture_view_guard, mut token) = hub.texture_views.read(&mut token); - let (sampler_guard, _) = hub.samplers.read(&mut token); - - // `BTreeMap` has ordered bindings as keys, which allows us to coalesce - // the descriptor writes into a single transaction. - let mut write_map = BTreeMap::new(); - for entry in desc.entries.iter() { - let binding = entry.binding; - // Find the corresponding declaration in the layout - let decl = bind_group_layout - .entries - .get(&binding) - .ok_or(CreateBindGroupError::MissingBindingDeclaration(binding))?; - let descriptors: SmallVec<[_; 1]> = match entry.resource { - Br::Buffer(ref bb) => { - let (pub_usage, internal_use, min_size, dynamic) = match decl.ty { - wgt::BindingType::UniformBuffer { - dynamic, - min_binding_size, - } => ( - wgt::BufferUsage::UNIFORM, - resource::BufferUse::UNIFORM, - min_binding_size, - dynamic, - ), - wgt::BindingType::StorageBuffer { - dynamic, - min_binding_size, - readonly, - } => ( - wgt::BufferUsage::STORAGE, - if readonly { - resource::BufferUse::STORAGE_LOAD - } else { - resource::BufferUse::STORAGE_STORE - }, - min_binding_size, - dynamic, - ), - _ => { - return Err(CreateBindGroupError::WrongBindingType { - binding, - actual: decl.ty.clone(), - expected: - "UniformBuffer, StorageBuffer or ReadonlyStorageBuffer", - }) - } - }; - - if bb.offset % wgt::BIND_BUFFER_ALIGNMENT != 0 { - return Err(CreateBindGroupError::UnalignedBufferOffset(bb.offset)); - } - - let buffer = used - .buffers - .use_extend(&*buffer_guard, bb.buffer_id, (), internal_use) - .map_err(|_| CreateBindGroupError::InvalidBuffer(bb.buffer_id))?; - check_buffer_usage(buffer.usage, pub_usage)?; - let &(ref buffer_raw, _) = buffer - .raw - .as_ref() - .ok_or(CreateBindGroupError::InvalidBuffer(bb.buffer_id))?; - - let (bind_size, bind_end) = match bb.size { - Some(size) => { - let end = bb.offset + size.get(); - if end > buffer.size { - return Err(CreateBindGroupError::BindingRangeTooLarge { - range: bb.offset..end, - size: buffer.size, - }); - } - (size.get(), end) - } - None => (buffer.size - bb.offset, buffer.size), - }; - - if pub_usage == wgt::BufferUsage::UNIFORM - && (device.limits.max_uniform_buffer_binding_size as u64) < bind_size - { - return Err(CreateBindGroupError::UniformBufferRangeTooLarge); - } - - // Record binding info for validating dynamic offsets - if dynamic { - dynamic_binding_info.push(binding_model::BindGroupDynamicBindingData { - maximum_dynamic_offset: buffer.size - bind_end, - }); - } - - if let Some(non_zero) = min_size { - let min_size = non_zero.get(); - if min_size > bind_size { - return Err(CreateBindGroupError::BindingSizeTooSmall { - actual: bind_size, - min: min_size, - }); - } - } - - let sub_range = hal::buffer::SubRange { - offset: bb.offset, - size: Some(bind_size), - }; - SmallVec::from([hal::pso::Descriptor::Buffer(buffer_raw, sub_range)]) - } - Br::Sampler(id) => { - match decl.ty { - wgt::BindingType::Sampler { comparison } => { - let sampler = used - .samplers - .use_extend(&*sampler_guard, id, (), ()) - .map_err(|_| CreateBindGroupError::InvalidSampler(id))?; - - // Check the actual sampler to also (not) be a comparison sampler - if sampler.comparison != comparison { - return Err(CreateBindGroupError::WrongSamplerComparison); - } - - SmallVec::from([hal::pso::Descriptor::Sampler(&sampler.raw)]) - } - _ => { - return Err(CreateBindGroupError::WrongBindingType { - binding, - actual: decl.ty.clone(), - expected: "Sampler", - }) - } - } - } - Br::TextureView(id) => { - let view = used - .views - .use_extend(&*texture_view_guard, id, (), ()) - .map_err(|_| CreateBindGroupError::InvalidTextureView(id))?; - let (pub_usage, internal_use) = match decl.ty { - wgt::BindingType::SampledTexture { .. } => ( - wgt::TextureUsage::SAMPLED, - resource::TextureUse::SAMPLED, - ), - wgt::BindingType::StorageTexture { readonly, .. } => ( - wgt::TextureUsage::STORAGE, - if readonly { - resource::TextureUse::STORAGE_LOAD - } else { - resource::TextureUse::STORAGE_STORE - }, - ), - _ => return Err(CreateBindGroupError::WrongBindingType { - binding, - actual: decl.ty.clone(), - expected: "SampledTexture, ReadonlyStorageTexture or WriteonlyStorageTexture" - }) - }; - if view - .aspects - .contains(hal::format::Aspects::DEPTH | hal::format::Aspects::STENCIL) - { - return Err(CreateBindGroupError::DepthStencilAspect); - } - match view.inner { - resource::TextureViewInner::Native { - ref raw, - ref source_id, - } => { - // Careful here: the texture may no longer have its own ref count, - // if it was deleted by the user. - let texture = &texture_guard[source_id.value]; - used.textures - .change_extend( - source_id.value, - &source_id.ref_count, - view.selector.clone(), - internal_use, - ) - .unwrap(); - check_texture_usage(texture.usage, pub_usage)?; - let image_layout = - conv::map_texture_state(internal_use, view.aspects).1; - SmallVec::from([hal::pso::Descriptor::Image(raw, image_layout)]) - } - resource::TextureViewInner::SwapChain { .. } => { - return Err(CreateBindGroupError::SwapChainImage); - } - } - } - Br::TextureViewArray(ref bindings_array) => { - let required_feats = wgt::Features::SAMPLED_TEXTURE_BINDING_ARRAY; - if !device.features.contains(required_feats) { - return Err(CreateBindGroupError::MissingFeatures(required_feats)); - } - - if let Some(count) = decl.count { - let count = count.get() as usize; - let num_bindings = bindings_array.len(); - if count != num_bindings { - return Err(CreateBindGroupError::BindingArrayLengthMismatch { - actual: num_bindings, - expected: count, - }); - } - } else { - return Err(CreateBindGroupError::SingleBindingExpected); - } - - let (pub_usage, internal_use) = match decl.ty { - wgt::BindingType::SampledTexture { .. } => { - (wgt::TextureUsage::SAMPLED, resource::TextureUse::SAMPLED) - } - _ => { - return Err(CreateBindGroupError::WrongBindingType { - binding, - actual: decl.ty.clone(), - expected: "SampledTextureArray", - }) - } - }; - bindings_array - .iter() - .map(|&id| { - let view = used - .views - .use_extend(&*texture_view_guard, id, (), ()) - .map_err(|_| CreateBindGroupError::InvalidTextureView(id))?; - match view.inner { - resource::TextureViewInner::Native { - ref raw, - ref source_id, - } => { - // Careful here: the texture may no longer have its own ref count, - // if it was deleted by the user. - let texture = &texture_guard[source_id.value]; - used.textures - .change_extend( - source_id.value, - &source_id.ref_count, - view.selector.clone(), - internal_use, - ) - .unwrap(); - check_texture_usage(texture.usage, pub_usage)?; - let image_layout = - conv::map_texture_state(internal_use, view.aspects).1; - Ok(hal::pso::Descriptor::Image(raw, image_layout)) - } - resource::TextureViewInner::SwapChain { .. } => { - Err(CreateBindGroupError::SwapChainImage) - } - } - }) - .collect::>()? - } - }; - if write_map.insert(binding, descriptors).is_some() { - return Err(CreateBindGroupError::DuplicateBinding(binding)); - } + let id = hub + .bind_groups + .register_identity(id_in, bind_group, &mut token); + tracing::debug!( + "Bind group {:?} {:#?}", + id, + hub.bind_groups.read(&mut token).0[id].used + ); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace + .lock() + .add(trace::Action::CreateBindGroup(id.0, desc.clone())); } - let mut desc_sets = ArrayVec::<[_; 1]>::new(); device - .desc_allocator + .trackers .lock() - .allocate( - &device.raw, - &bind_group_layout.raw, - &bind_group_layout.desc_counts, - 1, - &mut desc_sets, - ) - .expect("failed to allocate descriptor set"); - let mut desc_set = desc_sets.pop().unwrap(); - - // Set the descriptor set's label for easier debugging. - if let Some(label) = desc.label.as_ref() { - unsafe { - device - .raw - .set_descriptor_set_name(desc_set.raw_mut(), &label); - } - } - - if let Some(start_binding) = write_map.keys().next().cloned() { - let descriptors = write_map - .into_iter() - .flat_map(|(_, list)| list) - .collect::>(); - let write = hal::pso::DescriptorSetWrite { - set: desc_set.raw(), - binding: start_binding, - array_offset: 0, - descriptors, - }; - unsafe { - device.raw.write_descriptor_sets(iter::once(write)); - } - } - desc_set + .bind_groups + .init(id, ref_count, PhantomData) + .unwrap(); + return (id.0, None); }; - let bind_group = binding_model::BindGroup { - raw: desc_set, - device_id: Stored { - value: id::Valid(device_id), - ref_count: device.life_guard.add_ref(), - }, - layout_id: id::Valid(desc.layout), - life_guard: LifeGuard::new(desc.label.borrow_or_default()), - used, - dynamic_binding_info, - }; - let ref_count = bind_group.life_guard.add_ref(); - let id = hub .bind_groups - .register_identity(id_in, bind_group, &mut token); - tracing::debug!( - "Bind group {:?} {:#?}", - id, - hub.bind_groups.read(&mut token).0[id].used - ); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace - .lock() - .add(trace::Action::CreateBindGroup(id.0, desc.clone())); - } - - device - .trackers - .lock() - .bind_groups - .init(id, ref_count, PhantomData) - .unwrap(); - Ok(id.0) + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } pub fn bind_group_label(&self, id: id::BindGroupId) -> String { B::hub(self).bind_groups.label_for_resource(id) } - pub fn bind_group_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::BindGroupId { - B::hub(self) - .bind_groups - .register_error(id_in, label.unwrap_or(""), &mut Token::root()) - } - pub fn bind_group_drop(&self, bind_group_id: id::BindGroupId) { span!(_guard, INFO, "BindGroup::drop"); @@ -3847,12 +3867,6 @@ impl Global { B::hub(self).devices.label_for_resource(id) } - pub fn device_error(&self, id_in: Input) -> id::DeviceId { - B::hub(self) - .devices - .register_error(id_in, "", &mut Token::root()) - } - pub fn device_drop(&self, device_id: id::DeviceId) { span!(_guard, INFO, "Device::drop"); diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs index 354649819..8fbd08526 100644 --- a/wgpu-core/src/device/trace.rs +++ b/wgpu-core/src/device/trace.rs @@ -31,7 +31,7 @@ pub(crate) fn new_render_bundle_encoder_descriptor<'a>( #[cfg_attr(feature = "replay", derive(serde::Deserialize))] pub enum Action<'a> { Init { - desc: wgt::DeviceDescriptor, + desc: crate::device::DeviceDescriptor<'a>, backend: wgt::Backend, }, CreateBuffer(id::BufferId, crate::resource::BufferDescriptor<'a>), diff --git a/wgpu-core/src/instance.rs b/wgpu-core/src/instance.rs index 2a3d6fe18..c3fdbd44f 100644 --- a/wgpu-core/src/instance.rs +++ b/wgpu-core/src/instance.rs @@ -4,13 +4,13 @@ use crate::{ backend, - device::Device, + device::{Device, DeviceDescriptor}, hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Input, Token}, id::{AdapterId, DeviceId, SurfaceId, Valid}, - span, LifeGuard, PrivateFeatures, Stored, MAX_BIND_GROUPS, + span, LabelHelpers, LifeGuard, PrivateFeatures, Stored, MAX_BIND_GROUPS, }; -use wgt::{Backend, BackendBit, DeviceDescriptor, PowerPreference, BIND_BUFFER_ALIGNMENT}; +use wgt::{Backend, BackendBit, PowerPreference, BIND_BUFFER_ALIGNMENT}; use hal::{ adapter::{AdapterInfo as HalAdapterInfo, DeviceType as HalDeviceType, PhysicalDevice as _}, @@ -127,7 +127,7 @@ pub struct Adapter { life_guard: LifeGuard, } -impl Adapter { +impl Adapter { fn new(raw: hal::adapter::Adapter) -> Self { span!(_guard, INFO, "Adapter::new"); @@ -227,6 +227,150 @@ impl Adapter { life_guard: LifeGuard::new(""), } } + + fn create_device( + &self, + self_id: AdapterId, + desc: &DeviceDescriptor, + trace_path: Option<&std::path::Path>, + ) -> Result, RequestDeviceError> { + // Verify all features were exposed by the adapter + if !self.features.contains(desc.features) { + return Err(RequestDeviceError::UnsupportedFeature( + desc.features - self.features, + )); + } + + // Verify feature preconditions + if desc + .features + .contains(wgt::Features::MAPPABLE_PRIMARY_BUFFERS) + && self.raw.info.device_type == hal::adapter::DeviceType::DiscreteGpu + { + tracing::warn!("Feature MAPPABLE_PRIMARY_BUFFERS enabled on a discrete gpu. This is a massive performance footgun and likely not what you wanted"); + } + + let phd = &self.raw.physical_device; + let available_features = phd.features(); + + // Check features that are always needed + let wishful_features = hal::Features::ROBUST_BUFFER_ACCESS + | hal::Features::VERTEX_STORES_AND_ATOMICS + | hal::Features::FRAGMENT_STORES_AND_ATOMICS + | hal::Features::NDC_Y_UP + | hal::Features::INDEPENDENT_BLENDING + | hal::Features::SAMPLER_ANISOTROPY + | hal::Features::IMAGE_CUBE_ARRAY; + let mut enabled_features = available_features & wishful_features; + if enabled_features != wishful_features { + tracing::warn!( + "Missing internal features: {:?}", + wishful_features - enabled_features + ); + } + + // Features + enabled_features.set( + hal::Features::TEXTURE_DESCRIPTOR_ARRAY, + desc.features + .contains(wgt::Features::SAMPLED_TEXTURE_BINDING_ARRAY), + ); + enabled_features.set( + hal::Features::SHADER_SAMPLED_IMAGE_ARRAY_DYNAMIC_INDEXING, + desc.features + .contains(wgt::Features::SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING), + ); + enabled_features.set( + hal::Features::SAMPLED_TEXTURE_DESCRIPTOR_INDEXING, + desc.features + .contains(wgt::Features::SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING), + ); + enabled_features.set( + hal::Features::UNSIZED_DESCRIPTOR_ARRAY, + desc.features.contains(wgt::Features::UNSIZED_BINDING_ARRAY), + ); + enabled_features.set( + hal::Features::MULTI_DRAW_INDIRECT, + desc.features.contains(wgt::Features::MULTI_DRAW_INDIRECT), + ); + enabled_features.set( + hal::Features::DRAW_INDIRECT_COUNT, + desc.features + .contains(wgt::Features::MULTI_DRAW_INDIRECT_COUNT), + ); + enabled_features.set( + hal::Features::NON_FILL_POLYGON_MODE, + desc.features.contains(wgt::Features::NON_FILL_POLYGON_MODE), + ); + + let family = self + .raw + .queue_families + .iter() + .find(|family| family.queue_type().supports_graphics()) + .ok_or(RequestDeviceError::NoGraphicsQueue)?; + let mut gpu = + unsafe { phd.open(&[(family, &[1.0])], enabled_features) }.map_err(|err| { + use hal::device::CreationError::*; + match err { + DeviceLost => RequestDeviceError::DeviceLost, + InitializationFailed => RequestDeviceError::Internal, + OutOfMemory(_) => RequestDeviceError::OutOfMemory, + _ => panic!("failed to create `gfx-hal` device: {}", err), + } + })?; + + if let Some(_) = desc.label { + //TODO + } + + let limits = phd.limits(); + assert_eq!( + 0, + BIND_BUFFER_ALIGNMENT % limits.min_storage_buffer_offset_alignment, + "Adapter storage buffer offset alignment not compatible with WGPU" + ); + assert_eq!( + 0, + BIND_BUFFER_ALIGNMENT % limits.min_uniform_buffer_offset_alignment, + "Adapter uniform buffer offset alignment not compatible with WGPU" + ); + if self.limits < desc.limits { + return Err(RequestDeviceError::LimitsExceeded); + } + + let mem_props = phd.memory_properties(); + if !desc.shader_validation { + tracing::warn!("Shader validation is disabled"); + } + let private_features = PrivateFeatures { + shader_validation: desc.shader_validation, + anisotropic_filtering: enabled_features.contains(hal::Features::SAMPLER_ANISOTROPY), + texture_d24: phd + .format_properties(Some(hal::format::Format::X8D24Unorm)) + .optimal_tiling + .contains(hal::format::ImageFeature::DEPTH_STENCIL_ATTACHMENT), + texture_d24_s8: phd + .format_properties(Some(hal::format::Format::D24UnormS8Uint)) + .optimal_tiling + .contains(hal::format::ImageFeature::DEPTH_STENCIL_ATTACHMENT), + }; + + Device::new( + gpu.device, + Stored { + value: Valid(self_id), + ref_count: self.life_guard.add_ref(), + }, + gpu.queue_groups.swap_remove(0), + mem_props, + limits, + private_features, + desc, + trace_path, + ) + .or(Err(RequestDeviceError::OutOfMemory)) + } } impl crate::hub::Resource for Adapter { @@ -668,152 +812,29 @@ impl Global { desc: &DeviceDescriptor, trace_path: Option<&std::path::Path>, id_in: Input, - ) -> Result { + ) -> (DeviceId, Option) { span!(_guard, INFO, "Adapter::request_device"); let hub = B::hub(self); let mut token = Token::root(); - let device = { - let (adapter_guard, _) = hub.adapters.read(&mut token); - let adapter = adapter_guard - .get(adapter_id) - .map_err(|_| RequestDeviceError::InvalidAdapter)?; - let phd = &adapter.raw.physical_device; - // Verify all features were exposed by the adapter - if !adapter.features.contains(desc.features) { - return Err(RequestDeviceError::UnsupportedFeature( - desc.features - adapter.features, - )); - } - - // Verify feature preconditions - if desc - .features - .contains(wgt::Features::MAPPABLE_PRIMARY_BUFFERS) - && adapter.raw.info.device_type == hal::adapter::DeviceType::DiscreteGpu - { - tracing::warn!("Feature MAPPABLE_PRIMARY_BUFFERS enabled on a discrete gpu. This is a massive performance footgun and likely not what you wanted"); - } - - let available_features = adapter.raw.physical_device.features(); - - // Check features that are always needed - let wishful_features = hal::Features::ROBUST_BUFFER_ACCESS - | hal::Features::VERTEX_STORES_AND_ATOMICS - | hal::Features::FRAGMENT_STORES_AND_ATOMICS - | hal::Features::NDC_Y_UP - | hal::Features::INDEPENDENT_BLENDING - | hal::Features::SAMPLER_ANISOTROPY - | hal::Features::IMAGE_CUBE_ARRAY; - let mut enabled_features = available_features & wishful_features; - if enabled_features != wishful_features { - tracing::warn!( - "Missing internal features: {:?}", - wishful_features - enabled_features - ); - } - - // Features - enabled_features.set( - hal::Features::TEXTURE_DESCRIPTOR_ARRAY, - desc.features - .contains(wgt::Features::SAMPLED_TEXTURE_BINDING_ARRAY), - ); - enabled_features.set( - hal::Features::SHADER_SAMPLED_IMAGE_ARRAY_DYNAMIC_INDEXING, - desc.features - .contains(wgt::Features::SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING), - ); - enabled_features.set( - hal::Features::SAMPLED_TEXTURE_DESCRIPTOR_INDEXING, - desc.features - .contains(wgt::Features::SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING), - ); - enabled_features.set( - hal::Features::UNSIZED_DESCRIPTOR_ARRAY, - desc.features.contains(wgt::Features::UNSIZED_BINDING_ARRAY), - ); - enabled_features.set( - hal::Features::MULTI_DRAW_INDIRECT, - desc.features.contains(wgt::Features::MULTI_DRAW_INDIRECT), - ); - enabled_features.set( - hal::Features::DRAW_INDIRECT_COUNT, - desc.features - .contains(wgt::Features::MULTI_DRAW_INDIRECT_COUNT), - ); - enabled_features.set( - hal::Features::NON_FILL_POLYGON_MODE, - desc.features.contains(wgt::Features::NON_FILL_POLYGON_MODE), - ); - - let family = adapter - .raw - .queue_families - .iter() - .find(|family| family.queue_type().supports_graphics()) - .ok_or(RequestDeviceError::NoGraphicsQueue)?; - let mut gpu = - unsafe { phd.open(&[(family, &[1.0])], enabled_features) }.map_err(|err| { - use hal::device::CreationError::*; - match err { - DeviceLost => RequestDeviceError::DeviceLost, - InitializationFailed => RequestDeviceError::Internal, - OutOfMemory(_) => RequestDeviceError::OutOfMemory, - _ => panic!("failed to create `gfx-hal` device: {}", err), - } - })?; - - let limits = phd.limits(); - assert_eq!( - 0, - BIND_BUFFER_ALIGNMENT % limits.min_storage_buffer_offset_alignment, - "Adapter storage buffer offset alignment not compatible with WGPU" - ); - assert_eq!( - 0, - BIND_BUFFER_ALIGNMENT % limits.min_uniform_buffer_offset_alignment, - "Adapter uniform buffer offset alignment not compatible with WGPU" - ); - if adapter.limits < desc.limits { - return Err(RequestDeviceError::LimitsExceeded); - } - - let mem_props = phd.memory_properties(); - if !desc.shader_validation { - tracing::warn!("Shader validation is disabled"); - } - let private_features = PrivateFeatures { - shader_validation: desc.shader_validation, - anisotropic_filtering: enabled_features.contains(hal::Features::SAMPLER_ANISOTROPY), - texture_d24: phd - .format_properties(Some(hal::format::Format::X8D24Unorm)) - .optimal_tiling - .contains(hal::format::ImageFeature::DEPTH_STENCIL_ATTACHMENT), - texture_d24_s8: phd - .format_properties(Some(hal::format::Format::D24UnormS8Uint)) - .optimal_tiling - .contains(hal::format::ImageFeature::DEPTH_STENCIL_ATTACHMENT), + let error = loop { + let (adapter_guard, mut token) = hub.adapters.read(&mut token); + let adapter = match adapter_guard.get(adapter_id) { + Ok(adapter) => adapter, + Err(_) => break RequestDeviceError::InvalidAdapter, }; - - Device::new( - gpu.device, - Stored { - value: Valid(adapter_id), - ref_count: adapter.life_guard.add_ref(), - }, - gpu.queue_groups.swap_remove(0), - mem_props, - limits, - private_features, - desc, - trace_path, - ) - .or(Err(RequestDeviceError::OutOfMemory))? + let device = match adapter.create_device(adapter_id, desc, trace_path) { + Ok(device) => device, + Err(e) => break e, + }; + let id = hub.devices.register_identity(id_in, device, &mut token); + return (id.0, None); }; - let id = hub.devices.register_identity(id_in, device, &mut token); - Ok(id.0) + let id = hub + .devices + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, Some(error)) } } diff --git a/wgpu-core/src/validation.rs b/wgpu-core/src/validation.rs index 202c84d77..58e8de0be 100644 --- a/wgpu-core/src/validation.rs +++ b/wgpu-core/src/validation.rs @@ -28,7 +28,7 @@ pub fn check_buffer_usage( } } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] #[error("texture usage is {actual:?} which does not contain required usage {expected:?}")] pub struct MissingTextureUsageError { pub(crate) actual: wgt::TextureUsage, diff --git a/wgpu-types/src/lib.rs b/wgpu-types/src/lib.rs index 025bc61c2..7ccc1198b 100644 --- a/wgpu-types/src/lib.rs +++ b/wgpu-types/src/lib.rs @@ -382,7 +382,9 @@ impl Default for Limits { #[derive(Clone, Debug, Default)] #[cfg_attr(feature = "trace", derive(Serialize))] #[cfg_attr(feature = "replay", derive(Deserialize))] -pub struct DeviceDescriptor { +pub struct DeviceDescriptor { + /// Debug label for the device. + pub label: L, /// Features that the device should support. If any feature is not supported by /// the adapter, creating a device will panic. pub features: Features, @@ -394,6 +396,17 @@ pub struct DeviceDescriptor { pub shader_validation: bool, } +impl DeviceDescriptor { + pub fn map_label(&self, fun: impl FnOnce(&L) -> K) -> DeviceDescriptor { + DeviceDescriptor { + label: fun(&self.label), + features: self.features, + limits: self.limits.clone(), + shader_validation: self.shader_validation, + } + } +} + bitflags::bitflags! { /// Describes the shader stages that a binding will be visible from. /// From 6307294e2b1a867c8b445cc3b36b863e92e00e77 Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Fri, 20 Nov 2020 23:18:44 -0500 Subject: [PATCH 7/8] [error] pipeline creation --- player/src/lib.rs | 10 +- wgpu-core/src/device/mod.rs | 1449 ++++++++++++++++++----------------- wgpu-core/src/pipeline.rs | 6 +- wgpu-core/src/validation.rs | 6 +- 4 files changed, 766 insertions(+), 705 deletions(-) diff --git a/player/src/lib.rs b/player/src/lib.rs index 987254bfe..255314242 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -231,16 +231,18 @@ impl GlobalPlay for wgc::hub::Global { } A::CreateComputePipeline(id, desc) => { self.device_maintain_ids::(device).unwrap(); - self.device_create_compute_pipeline::(device, &desc, id, None) - .unwrap(); + let (_, _, error) = + self.device_create_compute_pipeline::(device, &desc, id, None); + assert_eq!(error, None); } A::DestroyComputePipeline(id) => { self.compute_pipeline_drop::(id); } A::CreateRenderPipeline(id, desc) => { self.device_maintain_ids::(device).unwrap(); - self.device_create_render_pipeline::(device, &desc, id, None) - .unwrap(); + let (_, _, error) = + self.device_create_render_pipeline::(device, &desc, id, None); + assert_eq!(error, None); } A::DestroyRenderPipeline(id) => { self.render_pipeline_drop::(id); diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs index bc13b652f..08b38695d 100644 --- a/wgpu-core/src/device/mod.rs +++ b/wgpu-core/src/device/mod.rs @@ -1500,6 +1500,634 @@ impl Device { }) } + //TODO: refactor this. It's the only method of `Device` that registers new objects + // (the pipeline layout). + fn derive_pipeline_layout( + &self, + self_id: id::DeviceId, + implicit_pipeline_ids: Option>, + mut derived_group_layouts: ArrayVec<[binding_model::BindEntryMap; MAX_BIND_GROUPS]>, + bgl_guard: &mut Storage, id::BindGroupLayoutId>, + pipeline_layout_guard: &mut Storage, id::PipelineLayoutId>, + hub: &Hub, + ) -> Result< + (id::PipelineLayoutId, pipeline::ImplicitBindGroupCount), + pipeline::ImplicitLayoutError, + > { + let derived_bind_group_count = + derived_group_layouts.len() as pipeline::ImplicitBindGroupCount; + + while derived_group_layouts + .last() + .map_or(false, |map| map.is_empty()) + { + derived_group_layouts.pop(); + } + let ids = implicit_pipeline_ids + .as_ref() + .ok_or(pipeline::ImplicitLayoutError::MissingIds(0))?; + if ids.group_ids.len() < derived_group_layouts.len() { + tracing::error!( + "Not enough bind group IDs ({}) specified for the implicit layout ({})", + ids.group_ids.len(), + derived_group_layouts.len() + ); + return Err(pipeline::ImplicitLayoutError::MissingIds( + derived_bind_group_count, + )); + } + + let mut derived_group_layout_ids = + ArrayVec::<[id::BindGroupLayoutId; MAX_BIND_GROUPS]>::new(); + for (bgl_id, map) in ids.group_ids.iter().zip(derived_group_layouts) { + let processed_id = match Device::deduplicate_bind_group_layout(self_id, &map, bgl_guard) + { + Some(dedup_id) => dedup_id, + None => { + #[cfg(feature = "trace")] + let bgl_desc = binding_model::BindGroupLayoutDescriptor { + label: None, + entries: if self.trace.is_some() { + Cow::Owned(map.values().cloned().collect()) + } else { + Cow::Borrowed(&[]) + }, + }; + let bgl = self.create_bind_group_layout(self_id, None, map)?; + let out_id = hub.bind_group_layouts.register_identity_locked( + bgl_id.clone(), + bgl, + bgl_guard, + ); + #[cfg(feature = "trace")] + if let Some(ref trace) = self.trace { + trace + .lock() + .add(trace::Action::CreateBindGroupLayout(out_id.0, bgl_desc)); + } + out_id.0 + } + }; + derived_group_layout_ids.push(processed_id); + } + + let layout_desc = binding_model::PipelineLayoutDescriptor { + label: None, + bind_group_layouts: Cow::Borrowed(&derived_group_layout_ids), + push_constant_ranges: Cow::Borrowed(&[]), //TODO? + }; + let layout = self.create_pipeline_layout(self_id, &layout_desc, bgl_guard)?; + let layout_id = hub.pipeline_layouts.register_identity_locked( + ids.root_id.clone(), + layout, + pipeline_layout_guard, + ); + #[cfg(feature = "trace")] + if let Some(ref trace) = self.trace { + trace.lock().add(trace::Action::CreatePipelineLayout( + layout_id.0, + layout_desc, + )); + } + Ok((layout_id.0, derived_bind_group_count)) + } + + fn create_compute_pipeline( + &self, + self_id: id::DeviceId, + desc: &pipeline::ComputePipelineDescriptor, + implicit_pipeline_ids: Option>, + hub: &Hub, + token: &mut Token, + ) -> Result< + ( + pipeline::ComputePipeline, + pipeline::ImplicitBindGroupCount, + id::PipelineLayoutId, + ), + pipeline::CreateComputePipelineError, + > { + //TODO: only lock mutable if the layout is derived + let (mut pipeline_layout_guard, mut token) = hub.pipeline_layouts.write(token); + let (mut bgl_guard, mut token) = hub.bind_group_layouts.write(&mut token); + + let mut derived_group_layouts = + ArrayVec::<[binding_model::BindEntryMap; MAX_BIND_GROUPS]>::new(); + + let interface = validation::StageInterface::default(); + let pipeline_stage = &desc.compute_stage; + let (shader_module_guard, _) = hub.shader_modules.read(&mut token); + + let entry_point_name = &pipeline_stage.entry_point; + let shader_module = shader_module_guard + .get(pipeline_stage.module) + .map_err(|_| { + pipeline::CreateComputePipelineError::Stage(validation::StageError::InvalidModule) + })?; + + let flag = wgt::ShaderStage::COMPUTE; + if let Some(ref module) = shader_module.module { + let group_layouts = match desc.layout { + Some(pipeline_layout_id) => Device::get_introspection_bind_group_layouts( + pipeline_layout_guard + .get(pipeline_layout_id) + .map_err(|_| pipeline::CreateComputePipelineError::InvalidLayout)?, + &*bgl_guard, + ), + None => { + for _ in 0..self.limits.max_bind_groups { + derived_group_layouts.push(binding_model::BindEntryMap::default()); + } + validation::IntrospectionBindGroupLayouts::Derived(&mut derived_group_layouts) + } + }; + let _ = + validation::check_stage(module, group_layouts, &entry_point_name, flag, interface) + .map_err(pipeline::CreateComputePipelineError::Stage)?; + } else if desc.layout.is_none() { + return Err(pipeline::ImplicitLayoutError::ReflectionError(flag).into()); + } + + let shader = hal::pso::EntryPoint:: { + entry: &entry_point_name, // TODO + module: &shader_module.raw, + specialization: hal::pso::Specialization::EMPTY, + }; + + // TODO + let flags = hal::pso::PipelineCreationFlags::empty(); + // TODO + let parent = hal::pso::BasePipeline::None; + + let (pipeline_layout_id, derived_bind_group_count) = match desc.layout { + Some(id) => (id, 0), + None => self.derive_pipeline_layout( + self_id, + implicit_pipeline_ids, + derived_group_layouts, + &mut *bgl_guard, + &mut *pipeline_layout_guard, + &hub, + )?, + }; + let layout = pipeline_layout_guard + .get(pipeline_layout_id) + .map_err(|_| pipeline::CreateComputePipelineError::InvalidLayout)?; + + let pipeline_desc = hal::pso::ComputePipelineDesc { + shader, + layout: &layout.raw, + flags, + parent, + }; + + let raw = match unsafe { self.raw.create_compute_pipeline(&pipeline_desc, None) } { + Ok(pipeline) => pipeline, + Err(hal::pso::CreationError::OutOfMemory(_)) => { + return Err(pipeline::CreateComputePipelineError::Device( + DeviceError::OutOfMemory, + )) + } + other => panic!("Compute pipeline creation error: {:?}", other), + }; + if let Some(_) = desc.label { + //TODO-0.6: self.raw.set_compute_pipeline_name(&mut raw, label); + } + + let pipeline = pipeline::ComputePipeline { + raw, + layout_id: Stored { + value: id::Valid(pipeline_layout_id), + ref_count: layout.life_guard.add_ref(), + }, + device_id: Stored { + value: id::Valid(self_id), + ref_count: self.life_guard.add_ref(), + }, + life_guard: LifeGuard::new(desc.label.borrow_or_default()), + }; + Ok((pipeline, derived_bind_group_count, pipeline_layout_id)) + } + + fn create_render_pipeline( + &self, + self_id: id::DeviceId, + desc: &pipeline::RenderPipelineDescriptor, + implicit_pipeline_ids: Option>, + hub: &Hub, + token: &mut Token, + ) -> Result< + ( + pipeline::RenderPipeline, + pipeline::ImplicitBindGroupCount, + id::PipelineLayoutId, + ), + pipeline::CreateRenderPipelineError, + > { + //TODO: only lock mutable if the layout is derived + let (mut pipeline_layout_guard, mut token) = hub.pipeline_layouts.write(token); + let (mut bgl_guard, mut token) = hub.bind_group_layouts.write(&mut token); + + let mut derived_group_layouts = + ArrayVec::<[binding_model::BindEntryMap; MAX_BIND_GROUPS]>::new(); + + let samples = { + let sc = desc.sample_count; + if sc == 0 || sc > 32 || !conv::is_power_of_two(sc) { + return Err(pipeline::CreateRenderPipelineError::InvalidSampleCount(sc)); + } + sc as u8 + }; + + let color_states = &desc.color_states; + let depth_stencil_state = desc.depth_stencil_state.as_ref(); + + let rasterization_state = desc + .rasterization_state + .as_ref() + .cloned() + .unwrap_or_default(); + let rasterizer = conv::map_rasterization_state_descriptor(&rasterization_state); + + let mut interface = validation::StageInterface::default(); + let mut validated_stages = wgt::ShaderStage::empty(); + + let desc_vbs = &desc.vertex_state.vertex_buffers; + let mut vertex_strides = Vec::with_capacity(desc_vbs.len()); + let mut vertex_buffers = Vec::with_capacity(desc_vbs.len()); + let mut attributes = Vec::new(); + for (i, vb_state) in desc_vbs.iter().enumerate() { + vertex_strides + .alloc() + .init((vb_state.stride, vb_state.step_mode)); + if vb_state.attributes.is_empty() { + continue; + } + if vb_state.stride % wgt::VERTEX_STRIDE_ALIGNMENT != 0 { + return Err(pipeline::CreateRenderPipelineError::UnalignedVertexStride { + index: i as u32, + stride: vb_state.stride, + }); + } + vertex_buffers.alloc().init(hal::pso::VertexBufferDesc { + binding: i as u32, + stride: vb_state.stride as u32, + rate: match vb_state.step_mode { + InputStepMode::Vertex => hal::pso::VertexInputRate::Vertex, + InputStepMode::Instance => hal::pso::VertexInputRate::Instance(1), + }, + }); + let desc_atts = &vb_state.attributes; + for attribute in desc_atts.iter() { + if attribute.offset >= 0x10000000 { + return Err( + pipeline::CreateRenderPipelineError::InvalidVertexAttributeOffset { + location: attribute.shader_location, + offset: attribute.offset, + }, + ); + } + attributes.alloc().init(hal::pso::AttributeDesc { + location: attribute.shader_location, + binding: i as u32, + element: hal::pso::Element { + format: conv::map_vertex_format(attribute.format), + offset: attribute.offset as u32, + }, + }); + interface.insert( + attribute.shader_location, + validation::MaybeOwned::Owned(validation::map_vertex_format(attribute.format)), + ); + } + } + + let input_assembler = hal::pso::InputAssemblerDesc { + primitive: conv::map_primitive_topology(desc.primitive_topology), + with_adjacency: false, + restart_index: None, //TODO + }; + + let blender = hal::pso::BlendDesc { + logic_op: None, // TODO + targets: color_states + .iter() + .map(conv::map_color_state_descriptor) + .collect(), + }; + let depth_stencil = depth_stencil_state + .map(conv::map_depth_stencil_state_descriptor) + .unwrap_or_default(); + + let multisampling: Option = if samples == 1 { + None + } else { + Some(hal::pso::Multisampling { + rasterization_samples: samples, + sample_shading: None, + sample_mask: desc.sample_mask as u64, + alpha_coverage: desc.alpha_to_coverage_enabled, + alpha_to_one: false, + }) + }; + + // TODO + let baked_states = hal::pso::BakedStates { + viewport: None, + scissor: None, + blend_color: None, + depth_bounds: None, + }; + + if rasterization_state.clamp_depth && !self.features.contains(wgt::Features::DEPTH_CLAMPING) + { + return Err(pipeline::CreateRenderPipelineError::MissingFeature( + wgt::Features::DEPTH_CLAMPING, + )); + } + if rasterization_state.polygon_mode != wgt::PolygonMode::Fill + && !self.features.contains(wgt::Features::NON_FILL_POLYGON_MODE) + { + return Err(pipeline::CreateRenderPipelineError::MissingFeature( + wgt::Features::NON_FILL_POLYGON_MODE, + )); + } + + if desc.layout.is_none() { + for _ in 0..self.limits.max_bind_groups { + derived_group_layouts.push(binding_model::BindEntryMap::default()); + } + } + + let (shader_module_guard, _) = hub.shader_modules.read(&mut token); + + let rp_key = RenderPassKey { + colors: color_states + .iter() + .map(|state| { + let at = hal::pass::Attachment { + format: Some(conv::map_texture_format( + state.format, + self.private_features, + )), + samples, + ops: hal::pass::AttachmentOps::PRESERVE, + stencil_ops: hal::pass::AttachmentOps::DONT_CARE, + layouts: hal::image::Layout::General..hal::image::Layout::General, + }; + (at, hal::image::Layout::ColorAttachmentOptimal) + }) + .collect(), + // We can ignore the resolves as the vulkan specs says: + // As an additional special case, if two render passes have a single subpass, + // they are compatible even if they have different resolve attachment references + // or depth/stencil resolve modes but satisfy the other compatibility conditions. + resolves: ArrayVec::new(), + depth_stencil: depth_stencil_state.map(|state| { + let at = hal::pass::Attachment { + format: Some(conv::map_texture_format( + state.format, + self.private_features, + )), + samples, + ops: hal::pass::AttachmentOps::PRESERVE, + stencil_ops: hal::pass::AttachmentOps::PRESERVE, + layouts: hal::image::Layout::General..hal::image::Layout::General, + }; + (at, hal::image::Layout::DepthStencilAttachmentOptimal) + }), + }; + + let vertex = { + let entry_point_name = &desc.vertex_stage.entry_point; + let flag = wgt::ShaderStage::VERTEX; + + let shader_module = + shader_module_guard + .get(desc.vertex_stage.module) + .map_err(|_| pipeline::CreateRenderPipelineError::Stage { + flag, + error: validation::StageError::InvalidModule, + })?; + + if let Some(ref module) = shader_module.module { + let group_layouts = match desc.layout { + Some(pipeline_layout_id) => Device::get_introspection_bind_group_layouts( + pipeline_layout_guard + .get(pipeline_layout_id) + .map_err(|_| pipeline::CreateRenderPipelineError::InvalidLayout)?, + &*bgl_guard, + ), + None => validation::IntrospectionBindGroupLayouts::Derived( + &mut derived_group_layouts, + ), + }; + + interface = validation::check_stage( + module, + group_layouts, + &entry_point_name, + flag, + interface, + ) + .map_err(|error| pipeline::CreateRenderPipelineError::Stage { flag, error })?; + validated_stages |= flag; + } + + hal::pso::EntryPoint:: { + entry: &entry_point_name, // TODO + module: &shader_module.raw, + specialization: hal::pso::Specialization::EMPTY, + } + }; + + let fragment = match &desc.fragment_stage { + Some(stage) => { + let entry_point_name = &stage.entry_point; + let flag = wgt::ShaderStage::FRAGMENT; + + let shader_module = shader_module_guard.get(stage.module).map_err(|_| { + pipeline::CreateRenderPipelineError::Stage { + flag, + error: validation::StageError::InvalidModule, + } + })?; + + let group_layouts = match desc.layout { + Some(pipeline_layout_id) => Device::get_introspection_bind_group_layouts( + pipeline_layout_guard + .get(pipeline_layout_id) + .map_err(|_| pipeline::CreateRenderPipelineError::InvalidLayout)?, + &*bgl_guard, + ), + None => validation::IntrospectionBindGroupLayouts::Derived( + &mut derived_group_layouts, + ), + }; + + if validated_stages == wgt::ShaderStage::VERTEX { + if let Some(ref module) = shader_module.module { + interface = validation::check_stage( + module, + group_layouts, + &entry_point_name, + flag, + interface, + ) + .map_err(|error| { + pipeline::CreateRenderPipelineError::Stage { flag, error } + })?; + validated_stages |= flag; + } + } + + Some(hal::pso::EntryPoint:: { + entry: &entry_point_name, + module: &shader_module.raw, + specialization: hal::pso::Specialization::EMPTY, + }) + } + None => None, + }; + + if validated_stages.contains(wgt::ShaderStage::FRAGMENT) { + for (i, state) in color_states.iter().enumerate() { + let output = &interface[&(i as wgt::ShaderLocation)]; + if !validation::check_texture_format(state.format, output) { + tracing::warn!( + "Incompatible fragment output[{}]. Shader: {:?}. Expected: {:?}", + i, + state.format, + &**output + ); + return Err( + pipeline::CreateRenderPipelineError::IncompatibleOutputFormat { + index: i as u8, + }, + ); + } + } + } + let last_stage = match desc.fragment_stage { + Some(_) => wgt::ShaderStage::FRAGMENT, + None => wgt::ShaderStage::VERTEX, + }; + if desc.layout.is_none() && !validated_stages.contains(last_stage) { + return Err(pipeline::ImplicitLayoutError::ReflectionError(last_stage).into()); + } + + let primitive_assembler = hal::pso::PrimitiveAssemblerDesc::Vertex { + buffers: &vertex_buffers, + attributes: &attributes, + input_assembler, + vertex, + tessellation: None, + geometry: None, + }; + + // TODO + let flags = hal::pso::PipelineCreationFlags::empty(); + // TODO + let parent = hal::pso::BasePipeline::None; + + let (pipeline_layout_id, derived_bind_group_count) = match desc.layout { + Some(id) => (id, 0), + None => self.derive_pipeline_layout( + self_id, + implicit_pipeline_ids, + derived_group_layouts, + &mut *bgl_guard, + &mut *pipeline_layout_guard, + &hub, + )?, + }; + let layout = pipeline_layout_guard + .get(pipeline_layout_id) + .map_err(|_| pipeline::CreateRenderPipelineError::InvalidLayout)?; + + let mut render_pass_cache = self.render_passes.lock(); + let pipeline_desc = hal::pso::GraphicsPipelineDesc { + primitive_assembler, + rasterizer, + fragment, + blender, + depth_stencil, + multisampling, + baked_states, + layout: &layout.raw, + subpass: hal::pass::Subpass { + index: 0, + main_pass: match render_pass_cache.entry(rp_key) { + Entry::Occupied(e) => e.into_mut(), + Entry::Vacant(e) => { + let pass = self + .create_compatible_render_pass(e.key()) + .or(Err(DeviceError::OutOfMemory))?; + e.insert(pass) + } + }, + }, + flags, + parent, + }; + // TODO: cache + let raw = unsafe { + self.raw + .create_graphics_pipeline(&pipeline_desc, None) + .map_err(|err| match err { + hal::pso::CreationError::OutOfMemory(_) => DeviceError::OutOfMemory, + _ => panic!("failed to create graphics pipeline: {}", err), + })? + }; + if let Some(_) = desc.label { + //TODO-0.6: self.set_graphics_pipeline_name(&mut raw, label) + } + + let pass_context = RenderPassContext { + attachments: AttachmentData { + colors: color_states.iter().map(|state| state.format).collect(), + resolves: ArrayVec::new(), + depth_stencil: depth_stencil_state + .as_ref() + .map(|state| state.format.clone()), + }, + sample_count: samples, + }; + + let mut flags = pipeline::PipelineFlags::empty(); + for state in color_states.iter() { + if state.color_blend.uses_color() | state.alpha_blend.uses_color() { + flags |= pipeline::PipelineFlags::BLEND_COLOR; + } + } + if let Some(ds) = depth_stencil_state.as_ref() { + if ds.stencil.is_enabled() && ds.stencil.needs_ref_value() { + flags |= pipeline::PipelineFlags::STENCIL_REFERENCE; + } + if !ds.is_read_only() { + flags |= pipeline::PipelineFlags::WRITES_DEPTH_STENCIL; + } + } + + let pipeline = pipeline::RenderPipeline { + raw, + layout_id: Stored { + value: id::Valid(pipeline_layout_id), + ref_count: layout.life_guard.add_ref(), + }, + device_id: Stored { + value: id::Valid(self_id), + ref_count: self.life_guard.add_ref(), + }, + pass_context, + flags, + index_format: desc.vertex_state.index_format, + vertex_strides, + life_guard: LifeGuard::new(desc.label.borrow_or_default()), + }; + Ok((pipeline, derived_bind_group_count, pipeline_layout_id)) + } + fn wait_for_submit( &self, submission_index: SubmissionIndex, @@ -2479,97 +3107,6 @@ impl Global { }); } - fn derive_pipeline_layout( - &self, - device: &Device, - device_id: id::DeviceId, - implicit_pipeline_ids: Option>, - mut derived_group_layouts: ArrayVec<[binding_model::BindEntryMap; MAX_BIND_GROUPS]>, - bgl_guard: &mut Storage, id::BindGroupLayoutId>, - pipeline_layout_guard: &mut Storage, id::PipelineLayoutId>, - ) -> Result< - (id::PipelineLayoutId, pipeline::ImplicitBindGroupCount), - pipeline::ImplicitLayoutError, - > { - let hub = B::hub(self); - let derived_bind_group_count = - derived_group_layouts.len() as pipeline::ImplicitBindGroupCount; - - while derived_group_layouts - .last() - .map_or(false, |map| map.is_empty()) - { - derived_group_layouts.pop(); - } - let ids = implicit_pipeline_ids - .as_ref() - .ok_or(pipeline::ImplicitLayoutError::MissingIds(0))?; - if ids.group_ids.len() < derived_group_layouts.len() { - tracing::error!( - "Not enough bind group IDs ({}) specified for the implicit layout ({})", - ids.group_ids.len(), - derived_group_layouts.len() - ); - return Err(pipeline::ImplicitLayoutError::MissingIds( - derived_bind_group_count, - )); - } - - let mut derived_group_layout_ids = - ArrayVec::<[id::BindGroupLayoutId; MAX_BIND_GROUPS]>::new(); - for (bgl_id, map) in ids.group_ids.iter().zip(derived_group_layouts) { - let processed_id = - match Device::deduplicate_bind_group_layout(device_id, &map, bgl_guard) { - Some(dedup_id) => dedup_id, - None => { - #[cfg(feature = "trace")] - let bgl_desc = binding_model::BindGroupLayoutDescriptor { - label: None, - entries: if device.trace.is_some() { - Cow::Owned(map.values().cloned().collect()) - } else { - Cow::Borrowed(&[]) - }, - }; - let bgl = device.create_bind_group_layout(device_id, None, map)?; - let out_id = hub.bind_group_layouts.register_identity_locked( - bgl_id.clone(), - bgl, - bgl_guard, - ); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace - .lock() - .add(trace::Action::CreateBindGroupLayout(out_id.0, bgl_desc)); - } - out_id.0 - } - }; - derived_group_layout_ids.push(processed_id); - } - - let layout_desc = binding_model::PipelineLayoutDescriptor { - label: None, - bind_group_layouts: Cow::Borrowed(&derived_group_layout_ids), - push_constant_ranges: Cow::Borrowed(&[]), //TODO? - }; - let layout = device.create_pipeline_layout(device_id, &layout_desc, bgl_guard)?; - let layout_id = hub.pipeline_layouts.register_identity_locked( - ids.root_id.clone(), - layout, - pipeline_layout_guard, - ); - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace.lock().add(trace::Action::CreatePipelineLayout( - layout_id.0, - layout_desc, - )); - } - Ok((layout_id.0, derived_bind_group_count)) - } - pub fn device_create_bind_group( &self, device_id: id::DeviceId, @@ -2899,448 +3436,51 @@ impl Global { desc: &pipeline::RenderPipelineDescriptor, id_in: Input, implicit_pipeline_ids: Option>, - ) -> Result< - (id::RenderPipelineId, pipeline::ImplicitBindGroupCount), - pipeline::CreateRenderPipelineError, - > { + ) -> ( + id::RenderPipelineId, + pipeline::ImplicitBindGroupCount, + Option, + ) { span!(_guard, INFO, "Device::create_render_pipeline"); let hub = B::hub(self); let mut token = Token::root(); - let samples = { - let sc = desc.sample_count; - if sc == 0 || sc > 32 || !conv::is_power_of_two(sc) { - return Err(pipeline::CreateRenderPipelineError::InvalidSampleCount(sc)); - } - sc as u8 - }; - - let color_states = &desc.color_states; - let depth_stencil_state = desc.depth_stencil_state.as_ref(); - - let rasterization_state = desc - .rasterization_state - .as_ref() - .cloned() - .unwrap_or_default(); - let rasterizer = conv::map_rasterization_state_descriptor(&rasterization_state); - - let mut interface = validation::StageInterface::default(); - let mut validated_stages = wgt::ShaderStage::empty(); - - let desc_vbs = &desc.vertex_state.vertex_buffers; - let mut vertex_strides = Vec::with_capacity(desc_vbs.len()); - let mut vertex_buffers = Vec::with_capacity(desc_vbs.len()); - let mut attributes = Vec::new(); - for (i, vb_state) in desc_vbs.iter().enumerate() { - vertex_strides - .alloc() - .init((vb_state.stride, vb_state.step_mode)); - if vb_state.attributes.is_empty() { - continue; - } - if vb_state.stride % wgt::VERTEX_STRIDE_ALIGNMENT != 0 { - return Err(pipeline::CreateRenderPipelineError::UnalignedVertexStride { - index: i as u32, - stride: vb_state.stride, - }); - } - vertex_buffers.alloc().init(hal::pso::VertexBufferDesc { - binding: i as u32, - stride: vb_state.stride as u32, - rate: match vb_state.step_mode { - InputStepMode::Vertex => hal::pso::VertexInputRate::Vertex, - InputStepMode::Instance => hal::pso::VertexInputRate::Instance(1), - }, - }); - let desc_atts = &vb_state.attributes; - for attribute in desc_atts.iter() { - if attribute.offset >= 0x10000000 { - return Err( - pipeline::CreateRenderPipelineError::InvalidVertexAttributeOffset { - location: attribute.shader_location, - offset: attribute.offset, - }, - ); - } - attributes.alloc().init(hal::pso::AttributeDesc { - location: attribute.shader_location, - binding: i as u32, - element: hal::pso::Element { - format: conv::map_vertex_format(attribute.format), - offset: attribute.offset as u32, - }, - }); - interface.insert( - attribute.shader_location, - validation::MaybeOwned::Owned(validation::map_vertex_format(attribute.format)), - ); - } - } - - let input_assembler = hal::pso::InputAssemblerDesc { - primitive: conv::map_primitive_topology(desc.primitive_topology), - with_adjacency: false, - restart_index: None, //TODO - }; - - let blender = hal::pso::BlendDesc { - logic_op: None, // TODO - targets: color_states - .iter() - .map(conv::map_color_state_descriptor) - .collect(), - }; - let depth_stencil = depth_stencil_state - .map(conv::map_depth_stencil_state_descriptor) - .unwrap_or_default(); - - let multisampling: Option = if samples == 1 { - None - } else { - Some(hal::pso::Multisampling { - rasterization_samples: samples, - sample_shading: None, - sample_mask: desc.sample_mask as u64, - alpha_coverage: desc.alpha_to_coverage_enabled, - alpha_to_one: false, - }) - }; - - // TODO - let baked_states = hal::pso::BakedStates { - viewport: None, - scissor: None, - blend_color: None, - depth_bounds: None, - }; - let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; - if rasterization_state.clamp_depth - && !device.features.contains(wgt::Features::DEPTH_CLAMPING) - { - return Err(pipeline::CreateRenderPipelineError::MissingFeature( - wgt::Features::DEPTH_CLAMPING, - )); - } - if rasterization_state.polygon_mode != wgt::PolygonMode::Fill - && !device - .features - .contains(wgt::Features::NON_FILL_POLYGON_MODE) - { - return Err(pipeline::CreateRenderPipelineError::MissingFeature( - wgt::Features::NON_FILL_POLYGON_MODE, - )); - } - - let (raw_pipeline, layout_id, layout_ref_count, derived_bind_group_count) = { - //TODO: only lock mutable if the layout is derived - let (mut pipeline_layout_guard, mut token) = hub.pipeline_layouts.write(&mut token); - let (mut bgl_guard, mut token) = hub.bind_group_layouts.write(&mut token); - - let mut derived_group_layouts = - ArrayVec::<[binding_model::BindEntryMap; MAX_BIND_GROUPS]>::new(); - if desc.layout.is_none() { - for _ in 0..device.limits.max_bind_groups { - derived_group_layouts.push(binding_model::BindEntryMap::default()); - } - } - - let (shader_module_guard, _) = hub.shader_modules.read(&mut token); - - let rp_key = RenderPassKey { - colors: color_states - .iter() - .map(|state| { - let at = hal::pass::Attachment { - format: Some(conv::map_texture_format( - state.format, - device.private_features, - )), - samples, - ops: hal::pass::AttachmentOps::PRESERVE, - stencil_ops: hal::pass::AttachmentOps::DONT_CARE, - layouts: hal::image::Layout::General..hal::image::Layout::General, - }; - (at, hal::image::Layout::ColorAttachmentOptimal) - }) - .collect(), - // We can ignore the resolves as the vulkan specs says: - // As an additional special case, if two render passes have a single subpass, - // they are compatible even if they have different resolve attachment references - // or depth/stencil resolve modes but satisfy the other compatibility conditions. - resolves: ArrayVec::new(), - depth_stencil: depth_stencil_state.map(|state| { - let at = hal::pass::Attachment { - format: Some(conv::map_texture_format( - state.format, - device.private_features, - )), - samples, - ops: hal::pass::AttachmentOps::PRESERVE, - stencil_ops: hal::pass::AttachmentOps::PRESERVE, - layouts: hal::image::Layout::General..hal::image::Layout::General, - }; - (at, hal::image::Layout::DepthStencilAttachmentOptimal) - }), + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; + let (pipeline, derived_bind_group_count, layout_id) = match device + .create_render_pipeline(device_id, desc, implicit_pipeline_ids, &hub, &mut token) + { + Ok(pair) => pair, + Err(e) => break e, }; - let vertex = { - let entry_point_name = &desc.vertex_stage.entry_point; - let flag = wgt::ShaderStage::VERTEX; + let id = hub + .render_pipelines + .register_identity(id_in, pipeline, &mut token); - let shader_module = - shader_module_guard - .get(desc.vertex_stage.module) - .map_err(|_| pipeline::CreateRenderPipelineError::Stage { - flag, - error: validation::StageError::InvalidModule, - })?; - - if let Some(ref module) = shader_module.module { - let group_layouts = match desc.layout { - Some(pipeline_layout_id) => Device::get_introspection_bind_group_layouts( - pipeline_layout_guard - .get(pipeline_layout_id) - .map_err(|_| pipeline::CreateRenderPipelineError::InvalidLayout)?, - &*bgl_guard, - ), - None => validation::IntrospectionBindGroupLayouts::Derived( - &mut derived_group_layouts, - ), - }; - - interface = validation::check_stage( - module, - group_layouts, - &entry_point_name, - flag, - interface, - ) - .map_err(|error| pipeline::CreateRenderPipelineError::Stage { flag, error })?; - validated_stages |= flag; - } - - hal::pso::EntryPoint:: { - entry: &entry_point_name, // TODO - module: &shader_module.raw, - specialization: hal::pso::Specialization::EMPTY, - } - }; - - let fragment = match &desc.fragment_stage { - Some(stage) => { - let entry_point_name = &stage.entry_point; - let flag = wgt::ShaderStage::FRAGMENT; - - let shader_module = shader_module_guard.get(stage.module).map_err(|_| { - pipeline::CreateRenderPipelineError::Stage { - flag, - error: validation::StageError::InvalidModule, - } - })?; - - let group_layouts = match desc.layout { - Some(pipeline_layout_id) => Device::get_introspection_bind_group_layouts( - pipeline_layout_guard - .get(pipeline_layout_id) - .map_err(|_| pipeline::CreateRenderPipelineError::InvalidLayout)?, - &*bgl_guard, - ), - None => validation::IntrospectionBindGroupLayouts::Derived( - &mut derived_group_layouts, - ), - }; - - if validated_stages == wgt::ShaderStage::VERTEX { - if let Some(ref module) = shader_module.module { - interface = validation::check_stage( - module, - group_layouts, - &entry_point_name, - flag, - interface, - ) - .map_err(|error| { - pipeline::CreateRenderPipelineError::Stage { flag, error } - })?; - validated_stages |= flag; - } - } - - Some(hal::pso::EntryPoint:: { - entry: &entry_point_name, - module: &shader_module.raw, - specialization: hal::pso::Specialization::EMPTY, - }) - } - None => None, - }; - - if validated_stages.contains(wgt::ShaderStage::FRAGMENT) { - for (i, state) in color_states.iter().enumerate() { - let output = &interface[&(i as wgt::ShaderLocation)]; - if !validation::check_texture_format(state.format, output) { - tracing::warn!( - "Incompatible fragment output[{}]. Shader: {:?}. Expected: {:?}", - i, - state.format, - &**output - ); - return Err( - pipeline::CreateRenderPipelineError::IncompatibleOutputFormat { - index: i as u8, - }, - ); - } - } - } - let last_stage = match desc.fragment_stage { - Some(_) => wgt::ShaderStage::FRAGMENT, - None => wgt::ShaderStage::VERTEX, - }; - if desc.layout.is_none() && !validated_stages.contains(last_stage) { - return Err(pipeline::ImplicitLayoutError::ReflectionError(last_stage).into()); - } - - let primitive_assembler = hal::pso::PrimitiveAssemblerDesc::Vertex { - buffers: &vertex_buffers, - attributes: &attributes, - input_assembler, - vertex, - tessellation: None, - geometry: None, - }; - - // TODO - let flags = hal::pso::PipelineCreationFlags::empty(); - // TODO - let parent = hal::pso::BasePipeline::None; - - let (pipeline_layout_id, derived_bind_group_count) = match desc.layout { - Some(id) => (id, 0), - None => self.derive_pipeline_layout( - device, - device_id, - implicit_pipeline_ids, - derived_group_layouts, - &mut *bgl_guard, - &mut *pipeline_layout_guard, - )?, - }; - let layout = pipeline_layout_guard - .get(pipeline_layout_id) - .map_err(|_| pipeline::CreateRenderPipelineError::InvalidLayout)?; - - let mut render_pass_cache = device.render_passes.lock(); - let pipeline_desc = hal::pso::GraphicsPipelineDesc { - primitive_assembler, - rasterizer, - fragment, - blender, - depth_stencil, - multisampling, - baked_states, - layout: &layout.raw, - subpass: hal::pass::Subpass { - index: 0, - main_pass: match render_pass_cache.entry(rp_key) { - Entry::Occupied(e) => e.into_mut(), - Entry::Vacant(e) => { - let pass = device - .create_compatible_render_pass(e.key()) - .or(Err(DeviceError::OutOfMemory))?; - e.insert(pass) - } + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace.lock().add(trace::Action::CreateRenderPipeline( + id.0, + pipeline::RenderPipelineDescriptor { + layout: Some(layout_id), + ..desc.clone() }, - }, - flags, - parent, - }; - // TODO: cache - let raw = unsafe { - device - .raw - .create_graphics_pipeline(&pipeline_desc, None) - .map_err(|err| match err { - hal::pso::CreationError::OutOfMemory(_) => DeviceError::OutOfMemory, - _ => panic!("failed to create graphics pipeline: {}", err), - })? - }; - if let Some(_) = desc.label { - //TODO-0.6: device.set_graphics_pipeline_name(&mut raw, label) + )); } - - ( - raw, - pipeline_layout_id, - layout.life_guard.add_ref(), - derived_bind_group_count, - ) + let _ = layout_id; + return (id.0, derived_bind_group_count, None); }; - let pass_context = RenderPassContext { - attachments: AttachmentData { - colors: color_states.iter().map(|state| state.format).collect(), - resolves: ArrayVec::new(), - depth_stencil: depth_stencil_state - .as_ref() - .map(|state| state.format.clone()), - }, - sample_count: samples, - }; - - let mut flags = pipeline::PipelineFlags::empty(); - for state in color_states.iter() { - if state.color_blend.uses_color() | state.alpha_blend.uses_color() { - flags |= pipeline::PipelineFlags::BLEND_COLOR; - } - } - if let Some(ds) = depth_stencil_state.as_ref() { - if ds.stencil.is_enabled() && ds.stencil.needs_ref_value() { - flags |= pipeline::PipelineFlags::STENCIL_REFERENCE; - } - if !ds.is_read_only() { - flags |= pipeline::PipelineFlags::WRITES_DEPTH_STENCIL; - } - } - - let pipeline = pipeline::RenderPipeline { - raw: raw_pipeline, - layout_id: Stored { - value: id::Valid(layout_id), - ref_count: layout_ref_count, - }, - device_id: Stored { - value: id::Valid(device_id), - ref_count: device.life_guard.add_ref(), - }, - pass_context, - flags, - index_format: desc.vertex_state.index_format, - vertex_strides, - life_guard: LifeGuard::new(desc.label.borrow_or_default()), - }; - - let id = hub - .render_pipelines - .register_identity(id_in, pipeline, &mut token); - - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace.lock().add(trace::Action::CreateRenderPipeline( - id.0, - pipeline::RenderPipelineDescriptor { - layout: Some(layout_id), - ..desc.clone() - }, - )); - } - Ok((id.0, derived_bind_group_count)) + let id = + hub.render_pipelines + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, 0, Some(error)) } /// Get an ID of one of the bind group layouts. The ID adds a refcount, @@ -3349,25 +3489,40 @@ impl Global { &self, pipeline_id: id::RenderPipelineId, index: u32, - ) -> Result { + id_in: Input, + ) -> ( + id::BindGroupLayoutId, + Option, + ) { let hub = B::hub(self); let mut token = Token::root(); let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token); - let (bgl_guard, mut token) = hub.bind_group_layouts.read(&mut token); - let (_, mut token) = hub.bind_groups.read(&mut token); - let (pipeline_guard, _) = hub.render_pipelines.read(&mut token); - let pipeline = pipeline_guard - .get(pipeline_id) - .map_err(|_| binding_model::GetBindGroupLayoutError::InvalidPipeline)?; - let id = pipeline_layout_guard[pipeline.layout_id.value] - .bind_group_layout_ids - .get(index as usize) - .ok_or(binding_model::GetBindGroupLayoutError::InvalidGroupIndex( - index, - ))?; - bgl_guard[*id].multi_ref_count.inc(); - Ok(id.0) + let error = loop { + let (bgl_guard, mut token) = hub.bind_group_layouts.read(&mut token); + let (_, mut token) = hub.bind_groups.read(&mut token); + let (pipeline_guard, _) = hub.render_pipelines.read(&mut token); + + let pipeline = match pipeline_guard.get(pipeline_id) { + Ok(pipeline) => pipeline, + Err(_) => break binding_model::GetBindGroupLayoutError::InvalidPipeline, + }; + let id = match pipeline_layout_guard[pipeline.layout_id.value] + .bind_group_layout_ids + .get(index as usize) + { + Some(id) => id, + None => break binding_model::GetBindGroupLayoutError::InvalidGroupIndex(index), + }; + + bgl_guard[*id].multi_ref_count.inc(); + return (id.0, None); + }; + + let id = hub + .bind_group_layouts + .register_error(id_in, "", &mut token); + (id, Some(error)) } pub fn render_pipeline_label(&self, id: id::RenderPipelineId) -> String { @@ -3424,150 +3579,51 @@ impl Global { desc: &pipeline::ComputePipelineDescriptor, id_in: Input, implicit_pipeline_ids: Option>, - ) -> Result< - (id::ComputePipelineId, pipeline::ImplicitBindGroupCount), - pipeline::CreateComputePipelineError, - > { + ) -> ( + id::ComputePipelineId, + pipeline::ImplicitBindGroupCount, + Option, + ) { span!(_guard, INFO, "Device::create_compute_pipeline"); let hub = B::hub(self); let mut token = Token::root(); let (device_guard, mut token) = hub.devices.read(&mut token); - let device = device_guard - .get(device_id) - .map_err(|_| DeviceError::Invalid)?; - let (raw_pipeline, layout_id, layout_ref_count, derived_bind_group_count) = { - //TODO: only lock mutable if the layout is derived - let (mut pipeline_layout_guard, mut token) = hub.pipeline_layouts.write(&mut token); - let (mut bgl_guard, mut token) = hub.bind_group_layouts.write(&mut token); + let error = loop { + let device = match device_guard.get(device_id) { + Ok(device) => device, + Err(_) => break DeviceError::Invalid.into(), + }; + let (pipeline, derived_bind_group_count, layout_id) = match device + .create_compute_pipeline(device_id, desc, implicit_pipeline_ids, &hub, &mut token) + { + Ok(pair) => pair, + Err(e) => break e, + }; - let mut derived_group_layouts = - ArrayVec::<[binding_model::BindEntryMap; MAX_BIND_GROUPS]>::new(); + let id = hub + .compute_pipelines + .register_identity(id_in, pipeline, &mut token); - let interface = validation::StageInterface::default(); - let pipeline_stage = &desc.compute_stage; - let (shader_module_guard, _) = hub.shader_modules.read(&mut token); - - let entry_point_name = &pipeline_stage.entry_point; - let shader_module = shader_module_guard - .get(pipeline_stage.module) - .map_err(|_| { - pipeline::CreateComputePipelineError::Stage( - validation::StageError::InvalidModule, - ) - })?; - - let flag = wgt::ShaderStage::COMPUTE; - if let Some(ref module) = shader_module.module { - let group_layouts = match desc.layout { - Some(pipeline_layout_id) => Device::get_introspection_bind_group_layouts( - pipeline_layout_guard - .get(pipeline_layout_id) - .map_err(|_| pipeline::CreateComputePipelineError::InvalidLayout)?, - &*bgl_guard, - ), - None => { - for _ in 0..device.limits.max_bind_groups { - derived_group_layouts.push(binding_model::BindEntryMap::default()); - } - validation::IntrospectionBindGroupLayouts::Derived( - &mut derived_group_layouts, - ) - } - }; - let _ = validation::check_stage( - module, - group_layouts, - &entry_point_name, - flag, - interface, - ) - .map_err(pipeline::CreateComputePipelineError::Stage)?; - } else if desc.layout.is_none() { - return Err(pipeline::ImplicitLayoutError::ReflectionError(flag).into()); + #[cfg(feature = "trace")] + if let Some(ref trace) = device.trace { + trace.lock().add(trace::Action::CreateComputePipeline( + id.0, + pipeline::ComputePipelineDescriptor { + layout: Some(layout_id), + ..desc.clone() + }, + )); } - - let shader = hal::pso::EntryPoint:: { - entry: &entry_point_name, // TODO - module: &shader_module.raw, - specialization: hal::pso::Specialization::EMPTY, - }; - - // TODO - let flags = hal::pso::PipelineCreationFlags::empty(); - // TODO - let parent = hal::pso::BasePipeline::None; - - let (pipeline_layout_id, derived_bind_group_count) = match desc.layout { - Some(id) => (id, 0), - None => self.derive_pipeline_layout( - device, - device_id, - implicit_pipeline_ids, - derived_group_layouts, - &mut *bgl_guard, - &mut *pipeline_layout_guard, - )?, - }; - let layout = pipeline_layout_guard - .get(pipeline_layout_id) - .map_err(|_| pipeline::CreateComputePipelineError::InvalidLayout)?; - - let pipeline_desc = hal::pso::ComputePipelineDesc { - shader, - layout: &layout.raw, - flags, - parent, - }; - - let raw = match unsafe { device.raw.create_compute_pipeline(&pipeline_desc, None) } { - Ok(pipeline) => pipeline, - Err(hal::pso::CreationError::OutOfMemory(_)) => { - return Err(pipeline::CreateComputePipelineError::Device( - DeviceError::OutOfMemory, - )) - } - other => panic!("Compute pipeline creation error: {:?}", other), - }; - if let Some(_) = desc.label { - //TODO-0.6: device.raw.set_compute_pipeline_name(&mut raw, label); - } - ( - raw, - pipeline_layout_id, - layout.life_guard.add_ref(), - derived_bind_group_count, - ) + let _ = layout_id; + return (id.0, derived_bind_group_count, None); }; - let pipeline = pipeline::ComputePipeline { - raw: raw_pipeline, - layout_id: Stored { - value: id::Valid(layout_id), - ref_count: layout_ref_count, - }, - device_id: Stored { - value: id::Valid(device_id), - ref_count: device.life_guard.add_ref(), - }, - life_guard: LifeGuard::new(desc.label.borrow_or_default()), - }; - let id = hub - .compute_pipelines - .register_identity(id_in, pipeline, &mut token); - - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - trace.lock().add(trace::Action::CreateComputePipeline( - id.0, - pipeline::ComputePipelineDescriptor { - layout: Some(layout_id), - ..desc.clone() - }, - )); - } - Ok((id.0, derived_bind_group_count)) + let id = + hub.compute_pipelines + .register_error(id_in, desc.label.borrow_or_default(), &mut token); + (id, 0, Some(error)) } /// Get an ID of one of the bind group layouts. The ID adds a refcount, @@ -3576,43 +3632,46 @@ impl Global { &self, pipeline_id: id::ComputePipelineId, index: u32, - ) -> Result { + id_in: Input, + ) -> ( + id::BindGroupLayoutId, + Option, + ) { let hub = B::hub(self); let mut token = Token::root(); let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token); - let (bgl_guard, mut token) = hub.bind_group_layouts.read(&mut token); - let (_, mut token) = hub.bind_groups.read(&mut token); - let (pipeline_guard, _) = hub.compute_pipelines.read(&mut token); - let pipeline = pipeline_guard - .get(pipeline_id) - .map_err(|_| binding_model::GetBindGroupLayoutError::InvalidPipeline)?; - let id = pipeline_layout_guard[pipeline.layout_id.value] - .bind_group_layout_ids - .get(index as usize) - .ok_or(binding_model::GetBindGroupLayoutError::InvalidGroupIndex( - index, - ))?; - bgl_guard[*id].multi_ref_count.inc(); - Ok(id.0) + let error = loop { + let (bgl_guard, mut token) = hub.bind_group_layouts.read(&mut token); + let (_, mut token) = hub.bind_groups.read(&mut token); + let (pipeline_guard, _) = hub.compute_pipelines.read(&mut token); + + let pipeline = match pipeline_guard.get(pipeline_id) { + Ok(pipeline) => pipeline, + Err(_) => break binding_model::GetBindGroupLayoutError::InvalidPipeline, + }; + let id = match pipeline_layout_guard[pipeline.layout_id.value] + .bind_group_layout_ids + .get(index as usize) + { + Some(id) => id, + None => break binding_model::GetBindGroupLayoutError::InvalidGroupIndex(index), + }; + + bgl_guard[*id].multi_ref_count.inc(); + return (id.0, None); + }; + + let id = hub + .bind_group_layouts + .register_error(id_in, "", &mut token); + (id, Some(error)) } pub fn compute_pipeline_label(&self, id: id::ComputePipelineId) -> String { B::hub(self).compute_pipelines.label_for_resource(id) } - pub fn compute_pipeline_error( - &self, - id_in: Input, - label: Option<&str>, - ) -> id::ComputePipelineId { - let hub = B::hub(self); - let mut token = Token::root(); - let (_, mut token) = hub.devices.read(&mut token); - hub.compute_pipelines - .register_error(id_in, label.unwrap_or(""), &mut token) - } - pub fn compute_pipeline_drop(&self, compute_pipeline_id: id::ComputePipelineId) { span!(_guard, INFO, "ComputePipeline::drop"); let hub = B::hub(self); diff --git a/wgpu-core/src/pipeline.rs b/wgpu-core/src/pipeline.rs index 55f271bdb..2123cf5fd 100644 --- a/wgpu-core/src/pipeline.rs +++ b/wgpu-core/src/pipeline.rs @@ -80,7 +80,7 @@ pub struct ProgrammableStageDescriptor<'a> { /// Number of implicit bind groups derived at pipeline creation. pub type ImplicitBindGroupCount = u8; -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum ImplicitLayoutError { #[error("missing IDs for deriving {0} bind groups")] MissingIds(ImplicitBindGroupCount), @@ -104,7 +104,7 @@ pub struct ComputePipelineDescriptor<'a> { pub compute_stage: ProgrammableStageDescriptor<'a>, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateComputePipelineError { #[error(transparent)] Device(#[from] DeviceError), @@ -193,7 +193,7 @@ pub struct RenderPipelineDescriptor<'a> { pub alpha_to_coverage_enabled: bool, } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum CreateRenderPipelineError { #[error(transparent)] Device(#[from] DeviceError), diff --git a/wgpu-core/src/validation.rs b/wgpu-core/src/validation.rs index 58e8de0be..455fb231d 100644 --- a/wgpu-core/src/validation.rs +++ b/wgpu-core/src/validation.rs @@ -48,7 +48,7 @@ pub fn check_texture_usage( } } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum BindingError { #[error("binding is missing from the pipeline layout")] Missing, @@ -78,7 +78,7 @@ pub enum BindingError { BadStorageFormat(wgt::TextureFormat), } -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum InputError { #[error("input is not provided by the earlier stage in the pipeline")] Missing, @@ -87,7 +87,7 @@ pub enum InputError { } /// Errors produced when validating a programmable stage of a pipeline. -#[derive(Clone, Debug, Error)] +#[derive(Clone, Debug, Error, PartialEq)] pub enum StageError { #[error("shader module is invalid")] InvalidModule, From c6bc37dbdee65195cc26bcca410db0f95466df27 Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Sat, 21 Nov 2020 00:05:56 -0500 Subject: [PATCH 8/8] [error] render bundles --- player/src/bin/play.rs | 4 +- player/src/lib.rs | 71 +++- player/tests/test.rs | 4 +- wgpu-core/src/binding_model.rs | 12 +- wgpu-core/src/command/bundle.rs | 688 ++++++++++++++++---------------- wgpu-core/src/command/mod.rs | 33 +- wgpu-core/src/device/mod.rs | 195 +++++---- wgpu-core/src/instance.rs | 2 +- wgpu-core/src/pipeline.rs | 8 +- wgpu-core/src/resource.rs | 14 +- wgpu-core/src/validation.rs | 10 +- 11 files changed, 548 insertions(+), 493 deletions(-) diff --git a/player/src/bin/play.rs b/player/src/bin/play.rs index b2ae956bb..0cc4e05f4 100644 --- a/player/src/bin/play.rs +++ b/player/src/bin/play.rs @@ -91,7 +91,9 @@ fn main() { None, id )); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } id } _ => panic!("Expected Action::Init"), diff --git a/player/src/lib.rs b/player/src/lib.rs index 255314242..d40926a5f 100644 --- a/player/src/lib.rs +++ b/player/src/lib.rs @@ -117,8 +117,12 @@ impl GlobalPlay for wgc::hub::Global { } } } - self.command_encoder_finish::(encoder, &wgt::CommandBufferDescriptor { label: None }) - .unwrap() + let (cmd_buf, error) = self + .command_encoder_finish::(encoder, &wgt::CommandBufferDescriptor { label: None }); + if let Some(e) = error { + panic!("{:?}", e); + } + cmd_buf } fn process( @@ -138,7 +142,9 @@ impl GlobalPlay for wgc::hub::Global { A::CreateBuffer(id, desc) => { self.device_maintain_ids::(device).unwrap(); let (_, error) = self.device_create_buffer::(device, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::FreeBuffer(id) => { self.buffer_destroy::(id).unwrap(); @@ -149,7 +155,9 @@ impl GlobalPlay for wgc::hub::Global { A::CreateTexture(id, desc) => { self.device_maintain_ids::(device).unwrap(); let (_, error) = self.device_create_texture::(device, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::FreeTexture(id) => { self.texture_destroy::(id).unwrap(); @@ -164,7 +172,9 @@ impl GlobalPlay for wgc::hub::Global { } => { self.device_maintain_ids::(device).unwrap(); let (_, error) = self.texture_create_view::(parent_id, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyTextureView(id) => { self.texture_view_drop::(id).unwrap(); @@ -172,7 +182,9 @@ impl GlobalPlay for wgc::hub::Global { A::CreateSampler(id, desc) => { self.device_maintain_ids::(device).unwrap(); let (_, error) = self.device_create_sampler::(device, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroySampler(id) => { self.sampler_drop::(id); @@ -187,7 +199,9 @@ impl GlobalPlay for wgc::hub::Global { } A::CreateBindGroupLayout(id, desc) => { let (_, error) = self.device_create_bind_group_layout::(device, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyBindGroupLayout(id) => { self.bind_group_layout_drop::(id); @@ -195,7 +209,9 @@ impl GlobalPlay for wgc::hub::Global { A::CreatePipelineLayout(id, desc) => { self.device_maintain_ids::(device).unwrap(); let (_, error) = self.device_create_pipeline_layout::(device, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyPipelineLayout(id) => { self.pipeline_layout_drop::(id); @@ -203,7 +219,9 @@ impl GlobalPlay for wgc::hub::Global { A::CreateBindGroup(id, desc) => { self.device_maintain_ids::(device).unwrap(); let (_, error) = self.device_create_bind_group::(device, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyBindGroup(id) => { self.bind_group_drop::(id); @@ -224,7 +242,9 @@ impl GlobalPlay for wgc::hub::Global { label, }; let (_, error) = self.device_create_shader_module::(device, &desc, id); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyShaderModule(id) => { self.shader_module_drop::(id); @@ -233,7 +253,9 @@ impl GlobalPlay for wgc::hub::Global { self.device_maintain_ids::(device).unwrap(); let (_, _, error) = self.device_create_compute_pipeline::(device, &desc, id, None); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyComputePipeline(id) => { self.compute_pipeline_drop::(id); @@ -242,7 +264,9 @@ impl GlobalPlay for wgc::hub::Global { self.device_maintain_ids::(device).unwrap(); let (_, _, error) = self.device_create_render_pipeline::(device, &desc, id, None); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyRenderPipeline(id) => { self.render_pipeline_drop::(id); @@ -250,12 +274,14 @@ impl GlobalPlay for wgc::hub::Global { A::CreateRenderBundle { id, desc, base } => { let bundle = wgc::command::RenderBundleEncoder::new(&desc, device, Some(base)).unwrap(); - self.render_bundle_encoder_finish::( + let (_, error) = self.render_bundle_encoder_finish::( bundle, &wgt::RenderBundleDescriptor { label: desc.label }, id, - ) - .unwrap(); + ); + if let Some(e) = error { + panic!("{:?}", e); + } } A::DestroyRenderBundle(id) => { self.render_bundle_drop::(id); @@ -288,13 +314,14 @@ impl GlobalPlay for wgc::hub::Global { .unwrap(); } A::Submit(_index, commands) => { - let encoder = self - .device_create_command_encoder::( - device, - &wgt::CommandEncoderDescriptor { label: None }, - comb_manager.alloc(device.backend()), - ) - .unwrap(); + let (encoder, error) = self.device_create_command_encoder::( + device, + &wgt::CommandEncoderDescriptor { label: None }, + comb_manager.alloc(device.backend()), + ); + if let Some(e) = error { + panic!("{:?}", e); + } let cmdbuf = self.encode_commands::(encoder, commands); self.queue_submit::(device, &[cmdbuf]).unwrap(); } diff --git a/player/tests/test.rs b/player/tests/test.rs index 43397c388..c96cecf5e 100644 --- a/player/tests/test.rs +++ b/player/tests/test.rs @@ -98,7 +98,9 @@ impl Test<'_> { None, device )); - assert_eq!(error, None); + if let Some(e) = error { + panic!("{:?}", e); + } let mut command_buffer_id_manager = wgc::hub::IdentityManager::default(); println!("\t\t\tRunning..."); diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs index c90a65db4..cc5d270a5 100644 --- a/wgpu-core/src/binding_model.rs +++ b/wgpu-core/src/binding_model.rs @@ -26,7 +26,7 @@ use std::{ use thiserror::Error; -#[derive(Clone, Debug, Error, PartialEq)] +#[derive(Clone, Debug, Error)] pub enum CreateBindGroupLayoutError { #[error(transparent)] Device(#[from] DeviceError), @@ -40,7 +40,7 @@ pub enum CreateBindGroupLayoutError { TooManyBindings(BindingTypeMaxCountError), } -#[derive(Clone, Debug, Error, PartialEq)] +#[derive(Clone, Debug, Error)] pub enum CreateBindGroupError { #[error(transparent)] Device(#[from] DeviceError), @@ -96,7 +96,7 @@ pub enum CreateBindGroupError { DepthStencilAspect, } -#[derive(Clone, Debug, Error, PartialEq)] +#[derive(Clone, Debug, Error)] pub enum BindingZone { #[error("stage {0:?}")] Stage(wgt::ShaderStage), @@ -104,7 +104,7 @@ pub enum BindingZone { Pipeline, } -#[derive(Clone, Debug, Error, PartialEq)] +#[derive(Clone, Debug, Error)] #[error("too many bindings of type {kind:?} in {zone}, limit is {count}")] pub struct BindingTypeMaxCountError { pub kind: BindingTypeMaxCountErrorKind, @@ -112,7 +112,7 @@ pub struct BindingTypeMaxCountError { pub count: u32, } -#[derive(Clone, Debug, PartialEq)] +#[derive(Clone, Debug)] pub enum BindingTypeMaxCountErrorKind { DynamicUniformBuffers, DynamicStorageBuffers, @@ -336,7 +336,7 @@ impl Resource for BindGroupLayout { } } -#[derive(Clone, Debug, Error, PartialEq)] +#[derive(Clone, Debug, Error)] pub enum CreatePipelineLayoutError { #[error(transparent)] Device(#[from] DeviceError), diff --git a/wgpu-core/src/command/bundle.rs b/wgpu-core/src/command/bundle.rs index 7e22267ea..591eb574f 100644 --- a/wgpu-core/src/command/bundle.rs +++ b/wgpu-core/src/command/bundle.rs @@ -44,9 +44,10 @@ use crate::{ }, conv, device::{ - AttachmentData, DeviceError, RenderPassContext, MAX_VERTEX_BUFFERS, SHADER_STAGE_COUNT, + AttachmentData, Device, DeviceError, RenderPassContext, MAX_VERTEX_BUFFERS, + SHADER_STAGE_COUNT, }, - hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Input, Resource, Storage, Token}, + hub::{GfxBackend, GlobalIdentityHandlerFactory, Hub, Resource, Storage, Token}, id, resource::BufferUse, span, @@ -55,7 +56,7 @@ use crate::{ Label, LabelHelpers, LifeGuard, Stored, MAX_BIND_GROUPS, }; use arrayvec::ArrayVec; -use std::{borrow::Cow, iter, marker::PhantomData, ops::Range}; +use std::{borrow::Cow, iter, ops::Range}; use thiserror::Error; /// Describes a [`RenderBundleEncoder`]. @@ -111,9 +112,328 @@ impl RenderBundleEncoder { }) } + pub fn dummy(parent_id: id::DeviceId) -> Self { + Self { + base: BasePass::new(), + parent_id, + context: RenderPassContext { + attachments: AttachmentData { + colors: ArrayVec::new(), + resolves: ArrayVec::new(), + depth_stencil: None, + }, + sample_count: 0, + }, + } + } + pub fn parent(&self) -> id::DeviceId { self.parent_id } + + pub(crate) fn finish( + self, + desc: &RenderBundleDescriptor, + device: &Device, + hub: &Hub, + token: &mut Token>, + ) -> Result { + let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(token); + let (bind_group_guard, mut token) = hub.bind_groups.read(&mut token); + let (pipeline_guard, mut token) = hub.render_pipelines.read(&mut token); + let (buffer_guard, _) = hub.buffers.read(&mut token); + + let mut state = State { + trackers: TrackerSet::new(self.parent_id.backend()), + index: IndexState::new(), + vertex: (0..MAX_VERTEX_BUFFERS) + .map(|_| VertexState::new()) + .collect(), + bind: (0..MAX_BIND_GROUPS).map(|_| BindState::new()).collect(), + push_constant_ranges: PushConstantState::new(), + raw_dynamic_offsets: Vec::new(), + flat_dynamic_offsets: Vec::new(), + used_bind_groups: 0, + pipeline: StateChange::new(), + }; + let mut commands = Vec::new(); + let mut base = self.base.as_ref(); + let mut pipeline_layout_id = None::>; + + for &command in base.commands { + match command { + RenderCommand::SetBindGroup { + index, + num_dynamic_offsets, + bind_group_id, + } => { + let scope = PassErrorScope::SetBindGroup(bind_group_id); + + let max_bind_groups = device.limits.max_bind_groups; + if (index as u32) >= max_bind_groups { + return Err(RenderCommandError::BindGroupIndexOutOfRange { + index, + max: max_bind_groups, + }) + .map_pass_err(scope); + } + + let offsets = &base.dynamic_offsets[..num_dynamic_offsets as usize]; + base.dynamic_offsets = &base.dynamic_offsets[num_dynamic_offsets as usize..]; + // Check for misaligned offsets. + if let Some(offset) = offsets + .iter() + .map(|offset| *offset as wgt::BufferAddress) + .find(|offset| offset % wgt::BIND_BUFFER_ALIGNMENT != 0) + { + return Err(RenderCommandError::UnalignedBufferOffset(offset)) + .map_pass_err(scope); + } + + let bind_group = state + .trackers + .bind_groups + .use_extend(&*bind_group_guard, bind_group_id, (), ()) + .map_err(|_| RenderCommandError::InvalidBindGroup(bind_group_id)) + .map_pass_err(scope)?; + if bind_group.dynamic_binding_info.len() != offsets.len() { + return Err(RenderCommandError::InvalidDynamicOffsetCount { + actual: offsets.len(), + expected: bind_group.dynamic_binding_info.len(), + }) + .map_pass_err(scope); + } + + state.set_bind_group(index, bind_group_id, bind_group.layout_id, offsets); + state + .trackers + .merge_extend(&bind_group.used) + .map_pass_err(scope)?; + } + RenderCommand::SetPipeline(pipeline_id) => { + let scope = PassErrorScope::SetPipelineRender(pipeline_id); + if state.pipeline.set_and_check_redundant(pipeline_id) { + continue; + } + + let pipeline = state + .trackers + .render_pipes + .use_extend(&*pipeline_guard, pipeline_id, (), ()) + .unwrap(); + + self.context + .check_compatible(&pipeline.pass_context) + .map_err(RenderCommandError::IncompatiblePipeline) + .map_pass_err(scope)?; + + //TODO: check read-only depth + + let layout = &pipeline_layout_guard[pipeline.layout_id.value]; + pipeline_layout_id = Some(pipeline.layout_id.value); + + state.set_pipeline( + pipeline.index_format, + &pipeline.vertex_strides, + &layout.bind_group_layout_ids, + &layout.push_constant_ranges, + ); + commands.push(command); + if let Some(iter) = state.flush_push_constants() { + commands.extend(iter) + } + } + RenderCommand::SetIndexBuffer { + buffer_id, + offset, + size, + } => { + let scope = PassErrorScope::SetIndexBuffer(buffer_id); + let buffer = state + .trackers + .buffers + .use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDEX) + .unwrap(); + check_buffer_usage(buffer.usage, wgt::BufferUsage::INDEX) + .map_pass_err(scope)?; + + let end = match size { + Some(s) => offset + s.get(), + None => buffer.size, + }; + state.index.set_buffer(buffer_id, offset..end); + } + RenderCommand::SetVertexBuffer { + slot, + buffer_id, + offset, + size, + } => { + let scope = PassErrorScope::SetVertexBuffer(buffer_id); + let buffer = state + .trackers + .buffers + .use_extend(&*buffer_guard, buffer_id, (), BufferUse::VERTEX) + .unwrap(); + check_buffer_usage(buffer.usage, wgt::BufferUsage::VERTEX) + .map_pass_err(scope)?; + + let end = match size { + Some(s) => offset + s.get(), + None => buffer.size, + }; + state.vertex[slot as usize].set_buffer(buffer_id, offset..end); + } + RenderCommand::SetPushConstant { + stages, + offset, + size_bytes, + values_offset: _, + } => { + let scope = PassErrorScope::SetPushConstant; + let end_offset = offset + size_bytes; + + let pipeline_layout_id = pipeline_layout_id + .ok_or(DrawError::MissingPipeline) + .map_pass_err(scope)?; + let pipeline_layout = &pipeline_layout_guard[pipeline_layout_id]; + + pipeline_layout + .validate_push_constant_ranges(stages, offset, end_offset) + .map_pass_err(scope)?; + + commands.push(command); + } + RenderCommand::Draw { + vertex_count, + instance_count, + first_vertex, + first_instance, + } => { + let scope = PassErrorScope::Draw; + let (vertex_limit, instance_limit) = state.vertex_limits(); + let last_vertex = first_vertex + vertex_count; + if last_vertex > vertex_limit { + return Err(DrawError::VertexBeyondLimit { + last_vertex, + vertex_limit, + }) + .map_pass_err(scope); + } + let last_instance = first_instance + instance_count; + if last_instance > instance_limit { + return Err(DrawError::InstanceBeyondLimit { + last_instance, + instance_limit, + }) + .map_pass_err(scope); + } + commands.extend(state.flush_vertices()); + commands.extend(state.flush_binds()); + commands.push(command); + } + RenderCommand::DrawIndexed { + index_count, + instance_count, + first_index, + base_vertex: _, + first_instance, + } => { + let scope = PassErrorScope::DrawIndexed; + //TODO: validate that base_vertex + max_index() is within the provided range + let (_, instance_limit) = state.vertex_limits(); + let index_limit = state.index.limit(); + let last_index = first_index + index_count; + if last_index > index_limit { + return Err(DrawError::IndexBeyondLimit { + last_index, + index_limit, + }) + .map_pass_err(scope); + } + let last_instance = first_instance + instance_count; + if last_instance > instance_limit { + return Err(DrawError::InstanceBeyondLimit { + last_instance, + instance_limit, + }) + .map_pass_err(scope); + } + commands.extend(state.index.flush()); + commands.extend(state.flush_vertices()); + commands.extend(state.flush_binds()); + commands.push(command); + } + RenderCommand::MultiDrawIndirect { + buffer_id, + offset: _, + count: None, + indexed: false, + } => { + let scope = PassErrorScope::DrawIndirect; + let buffer = state + .trackers + .buffers + .use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT) + .unwrap(); + check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT) + .map_pass_err(scope)?; + + commands.extend(state.flush_vertices()); + commands.extend(state.flush_binds()); + commands.push(command); + } + RenderCommand::MultiDrawIndirect { + buffer_id, + offset: _, + count: None, + indexed: true, + } => { + let scope = PassErrorScope::DrawIndexedIndirect; + let buffer = state + .trackers + .buffers + .use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT) + .map_err(|err| RenderCommandError::Buffer(buffer_id, err)) + .map_pass_err(scope)?; + check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT) + .map_pass_err(scope)?; + + commands.extend(state.index.flush()); + commands.extend(state.flush_vertices()); + commands.extend(state.flush_binds()); + commands.push(command); + } + RenderCommand::MultiDrawIndirect { .. } + | RenderCommand::MultiDrawIndirectCount { .. } => unimplemented!(), + RenderCommand::PushDebugGroup { color: _, len: _ } => unimplemented!(), + RenderCommand::InsertDebugMarker { color: _, len: _ } => unimplemented!(), + RenderCommand::PopDebugGroup => unimplemented!(), + RenderCommand::ExecuteBundle(_) + | RenderCommand::SetBlendColor(_) + | RenderCommand::SetStencilReference(_) + | RenderCommand::SetViewport { .. } + | RenderCommand::SetScissor(_) => unreachable!("not supported by a render bundle"), + } + } + + let _ = desc.label; //TODO: actually use + Ok(RenderBundle { + base: BasePass { + commands, + dynamic_offsets: state.flat_dynamic_offsets, + string_data: Vec::new(), + push_constant_data: Vec::new(), + }, + device_id: Stored { + value: id::Valid(self.parent_id), + ref_count: device.life_guard.add_ref(), + }, + used: state.trackers, + context: self.context, + life_guard: LifeGuard::new(desc.label.borrow_or_default()), + }) + } } /// Error type returned from `RenderBundleEncoder::new` if the sample count is invalid. @@ -150,6 +470,11 @@ unsafe impl Send for RenderBundle {} unsafe impl Sync for RenderBundle {} impl RenderBundle { + #[cfg(feature = "trace")] + pub(crate) fn to_base_pass(&self) -> BasePass { + BasePass::from_ref(self.base.as_ref()) + } + /// Actually encode the contents into a native command buffer. /// /// This is partially duplicating the logic of `command_encoder_run_render_pass`. @@ -685,6 +1010,13 @@ pub struct RenderBundleError { inner: RenderBundleErrorInner, } +impl RenderBundleError { + pub(crate) const INVALID_DEVICE: Self = RenderBundleError { + scope: PassErrorScope::Bundle, + inner: RenderBundleErrorInner::Device(DeviceError::Invalid), + }; +} + impl MapPassErr for Result where E: Into, @@ -697,356 +1029,6 @@ where } } -impl Global { - pub fn render_bundle_encoder_finish( - &self, - bundle_encoder: RenderBundleEncoder, - desc: &RenderBundleDescriptor, - id_in: Input, - ) -> Result { - span!(_guard, INFO, "RenderBundleEncoder::finish"); - let scope = PassErrorScope::Bundle; - - let hub = B::hub(self); - let mut token = Token::root(); - let (device_guard, mut token) = hub.devices.read(&mut token); - - let device = device_guard - .get(bundle_encoder.parent_id) - .map_err(|_| DeviceError::Invalid) - .map_pass_err(scope)?; - let render_bundle = { - let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token); - let (bind_group_guard, mut token) = hub.bind_groups.read(&mut token); - let (pipeline_guard, mut token) = hub.render_pipelines.read(&mut token); - let (buffer_guard, _) = hub.buffers.read(&mut token); - - let mut state = State { - trackers: TrackerSet::new(bundle_encoder.parent_id.backend()), - index: IndexState::new(), - vertex: (0..MAX_VERTEX_BUFFERS) - .map(|_| VertexState::new()) - .collect(), - bind: (0..MAX_BIND_GROUPS).map(|_| BindState::new()).collect(), - push_constant_ranges: PushConstantState::new(), - raw_dynamic_offsets: Vec::new(), - flat_dynamic_offsets: Vec::new(), - used_bind_groups: 0, - pipeline: StateChange::new(), - }; - let mut commands = Vec::new(); - let mut base = bundle_encoder.base.as_ref(); - let mut pipeline_layout_id = None::>; - - for &command in base.commands { - match command { - RenderCommand::SetBindGroup { - index, - num_dynamic_offsets, - bind_group_id, - } => { - let scope = PassErrorScope::SetBindGroup(bind_group_id); - - let max_bind_groups = device.limits.max_bind_groups; - if (index as u32) >= max_bind_groups { - return Err(RenderCommandError::BindGroupIndexOutOfRange { - index, - max: max_bind_groups, - }) - .map_pass_err(scope); - } - - let offsets = &base.dynamic_offsets[..num_dynamic_offsets as usize]; - base.dynamic_offsets = - &base.dynamic_offsets[num_dynamic_offsets as usize..]; - // Check for misaligned offsets. - if let Some(offset) = offsets - .iter() - .map(|offset| *offset as wgt::BufferAddress) - .find(|offset| offset % wgt::BIND_BUFFER_ALIGNMENT != 0) - { - return Err(RenderCommandError::UnalignedBufferOffset(offset)) - .map_pass_err(scope); - } - - let bind_group = state - .trackers - .bind_groups - .use_extend(&*bind_group_guard, bind_group_id, (), ()) - .map_err(|_| RenderCommandError::InvalidBindGroup(bind_group_id)) - .map_pass_err(scope)?; - if bind_group.dynamic_binding_info.len() != offsets.len() { - return Err(RenderCommandError::InvalidDynamicOffsetCount { - actual: offsets.len(), - expected: bind_group.dynamic_binding_info.len(), - }) - .map_pass_err(scope); - } - - state.set_bind_group(index, bind_group_id, bind_group.layout_id, offsets); - state - .trackers - .merge_extend(&bind_group.used) - .map_pass_err(scope)?; - } - RenderCommand::SetPipeline(pipeline_id) => { - let scope = PassErrorScope::SetPipelineRender(pipeline_id); - if state.pipeline.set_and_check_redundant(pipeline_id) { - continue; - } - - let pipeline = state - .trackers - .render_pipes - .use_extend(&*pipeline_guard, pipeline_id, (), ()) - .unwrap(); - - bundle_encoder - .context - .check_compatible(&pipeline.pass_context) - .map_err(RenderCommandError::IncompatiblePipeline) - .map_pass_err(scope)?; - - //TODO: check read-only depth - - let layout = &pipeline_layout_guard[pipeline.layout_id.value]; - pipeline_layout_id = Some(pipeline.layout_id.value); - - state.set_pipeline( - pipeline.index_format, - &pipeline.vertex_strides, - &layout.bind_group_layout_ids, - &layout.push_constant_ranges, - ); - commands.push(command); - if let Some(iter) = state.flush_push_constants() { - commands.extend(iter) - } - } - RenderCommand::SetIndexBuffer { - buffer_id, - offset, - size, - } => { - let scope = PassErrorScope::SetIndexBuffer(buffer_id); - let buffer = state - .trackers - .buffers - .use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDEX) - .unwrap(); - check_buffer_usage(buffer.usage, wgt::BufferUsage::INDEX) - .map_pass_err(scope)?; - - let end = match size { - Some(s) => offset + s.get(), - None => buffer.size, - }; - state.index.set_buffer(buffer_id, offset..end); - } - RenderCommand::SetVertexBuffer { - slot, - buffer_id, - offset, - size, - } => { - let scope = PassErrorScope::SetVertexBuffer(buffer_id); - let buffer = state - .trackers - .buffers - .use_extend(&*buffer_guard, buffer_id, (), BufferUse::VERTEX) - .unwrap(); - check_buffer_usage(buffer.usage, wgt::BufferUsage::VERTEX) - .map_pass_err(scope)?; - - let end = match size { - Some(s) => offset + s.get(), - None => buffer.size, - }; - state.vertex[slot as usize].set_buffer(buffer_id, offset..end); - } - RenderCommand::SetPushConstant { - stages, - offset, - size_bytes, - values_offset: _, - } => { - let scope = PassErrorScope::SetPushConstant; - let end_offset = offset + size_bytes; - - let pipeline_layout_id = pipeline_layout_id - .ok_or(DrawError::MissingPipeline) - .map_pass_err(scope)?; - let pipeline_layout = &pipeline_layout_guard[pipeline_layout_id]; - - pipeline_layout - .validate_push_constant_ranges(stages, offset, end_offset) - .map_pass_err(scope)?; - - commands.push(command); - } - RenderCommand::Draw { - vertex_count, - instance_count, - first_vertex, - first_instance, - } => { - let scope = PassErrorScope::Draw; - let (vertex_limit, instance_limit) = state.vertex_limits(); - let last_vertex = first_vertex + vertex_count; - if last_vertex > vertex_limit { - return Err(DrawError::VertexBeyondLimit { - last_vertex, - vertex_limit, - }) - .map_pass_err(scope); - } - let last_instance = first_instance + instance_count; - if last_instance > instance_limit { - return Err(DrawError::InstanceBeyondLimit { - last_instance, - instance_limit, - }) - .map_pass_err(scope); - } - commands.extend(state.flush_vertices()); - commands.extend(state.flush_binds()); - commands.push(command); - } - RenderCommand::DrawIndexed { - index_count, - instance_count, - first_index, - base_vertex: _, - first_instance, - } => { - let scope = PassErrorScope::DrawIndexed; - //TODO: validate that base_vertex + max_index() is within the provided range - let (_, instance_limit) = state.vertex_limits(); - let index_limit = state.index.limit(); - let last_index = first_index + index_count; - if last_index > index_limit { - return Err(DrawError::IndexBeyondLimit { - last_index, - index_limit, - }) - .map_pass_err(scope); - } - let last_instance = first_instance + instance_count; - if last_instance > instance_limit { - return Err(DrawError::InstanceBeyondLimit { - last_instance, - instance_limit, - }) - .map_pass_err(scope); - } - commands.extend(state.index.flush()); - commands.extend(state.flush_vertices()); - commands.extend(state.flush_binds()); - commands.push(command); - } - RenderCommand::MultiDrawIndirect { - buffer_id, - offset: _, - count: None, - indexed: false, - } => { - let scope = PassErrorScope::DrawIndirect; - let buffer = state - .trackers - .buffers - .use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT) - .unwrap(); - check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT) - .map_pass_err(scope)?; - - commands.extend(state.flush_vertices()); - commands.extend(state.flush_binds()); - commands.push(command); - } - RenderCommand::MultiDrawIndirect { - buffer_id, - offset: _, - count: None, - indexed: true, - } => { - let scope = PassErrorScope::DrawIndexedIndirect; - let buffer = state - .trackers - .buffers - .use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT) - .map_err(|err| RenderCommandError::Buffer(buffer_id, err)) - .map_pass_err(scope)?; - check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT) - .map_pass_err(scope)?; - - commands.extend(state.index.flush()); - commands.extend(state.flush_vertices()); - commands.extend(state.flush_binds()); - commands.push(command); - } - RenderCommand::MultiDrawIndirect { .. } - | RenderCommand::MultiDrawIndirectCount { .. } => unimplemented!(), - RenderCommand::PushDebugGroup { color: _, len: _ } => unimplemented!(), - RenderCommand::InsertDebugMarker { color: _, len: _ } => unimplemented!(), - RenderCommand::PopDebugGroup => unimplemented!(), - RenderCommand::ExecuteBundle(_) - | RenderCommand::SetBlendColor(_) - | RenderCommand::SetStencilReference(_) - | RenderCommand::SetViewport { .. } - | RenderCommand::SetScissor(_) => { - unreachable!("not supported by a render bundle") - } - } - } - - tracing::debug!("Render bundle {:?} = {:#?}", id_in, state.trackers); - let _ = desc.label; //TODO: actually use - //TODO: check if the device is still alive - RenderBundle { - base: BasePass { - commands, - dynamic_offsets: state.flat_dynamic_offsets, - string_data: Vec::new(), - push_constant_data: Vec::new(), - }, - device_id: Stored { - value: id::Valid(bundle_encoder.parent_id), - ref_count: device.life_guard.add_ref(), - }, - used: state.trackers, - context: bundle_encoder.context, - life_guard: LifeGuard::new(desc.label.borrow_or_default()), - } - }; - - let ref_count = render_bundle.life_guard.add_ref(); - let id = hub - .render_bundles - .register_identity(id_in, render_bundle, &mut token); - - #[cfg(feature = "trace")] - if let Some(ref trace) = device.trace { - use crate::device::trace; - let (bundle_guard, _) = hub.render_bundles.read(&mut token); - let bundle = &bundle_guard[id]; - let label = desc.label.as_ref().map(|l| l.as_ref()); - trace.lock().add(trace::Action::CreateRenderBundle { - id: id.0, - desc: trace::new_render_bundle_encoder_descriptor(label, &bundle.context), - base: BasePass::from_ref(bundle.base.as_ref()), - }); - } - - device - .trackers - .lock() - .bundles - .init(id, ref_count, PhantomData) - .unwrap(); - Ok(id.0) - } -} - pub mod bundle_ffi { use super::{RenderBundleEncoder, RenderCommand}; use crate::{id, span, RawString}; diff --git a/wgpu-core/src/command/mod.rs b/wgpu-core/src/command/mod.rs index 523b0ebd2..1093bde15 100644 --- a/wgpu-core/src/command/mod.rs +++ b/wgpu-core/src/command/mod.rs @@ -186,7 +186,7 @@ impl Global { &self, encoder_id: id::CommandEncoderId, _desc: &wgt::CommandBufferDescriptor