move indirect validation code to its own folder

rename items appropriately
internalize indirect buffer bind groups

Author: teoxoy

wgpu-core/src/command/bundle.rs

@@ -810,7 +810,7 @@ fn multi_draw_indirect(
     };
     let instance_limit = vertex_limits.instance_limit;
 
-    let buffer_uses = if state.device.indirect_draw_validation.is_some() {
+    let buffer_uses = if state.device.indirect_validation.is_some() {
         wgt::BufferUses::STORAGE_READ_ONLY
     } else {
         wgt::BufferUses::INDIRECT
@@ -901,8 +901,8 @@ impl RenderBundle {
     pub(super) unsafe fn execute(
         &self,
         raw: &mut dyn hal::DynCommandEncoder,
-        indirect_draw_validation_resources: &mut crate::indirect_draw_validation::IndirectDrawValidationResources,
-        indirect_draw_validation_batcher: &mut crate::indirect_draw_validation::IndirectDrawValidationBatcher,
+        indirect_draw_validation_resources: &mut crate::indirect_validation::DrawResources,
+        indirect_draw_validation_batcher: &mut crate::indirect_validation::DrawBatcher,
         snatch_guard: &SnatchGuard,
     ) -> Result<(), ExecutionError> {
         let mut offsets = self.base.dynamic_offsets.as_slice();
@@ -1050,7 +1050,7 @@ impl RenderBundle {
                     vertex_or_index_limit,
                     instance_limit,
                 } => {
-                    let (buffer, offset) = if self.device.indirect_draw_validation.is_some() {
+                    let (buffer, offset) = if self.device.indirect_validation.is_some() {
                         let (dst_resource_index, offset) = indirect_draw_validation_batcher.add(
                             indirect_draw_validation_resources,
                             &self.device,

wgpu-core/src/command/compute.rs

@@ -892,7 +892,9 @@ fn dispatch_indirect(
         ));
 
     if let Some(ref indirect_validation) = state.device.indirect_validation {
-        let params = indirect_validation.params(&state.device.limits, offset, buffer.size);
+        let params = indirect_validation
+            .dispatch
+            .params(&state.device.limits, offset, buffer.size);
 
         unsafe {
             state.raw_encoder.set_compute_pipeline(params.pipeline);
@@ -921,9 +923,10 @@ fn dispatch_indirect(
                 1,
                 Some(
                     buffer
-                        .raw_indirect_validation_bind_group
+                        .indirect_validation_bind_groups
                         .get(&state.snatch_guard)
                         .unwrap()
+                        .dispatch
                         .as_ref(),
                 ),
                 &[params.aligned_offset as u32],

wgpu-core/src/command/mod.rs

@@ -436,8 +436,7 @@ pub(crate) struct BakedCommands {
     pub(crate) encoder: CommandEncoder,
     pub(crate) trackers: Tracker,
     pub(crate) temp_resources: Vec<TempResource>,
-    pub(crate) indirect_draw_validation_resources:
-        crate::indirect_draw_validation::IndirectDrawValidationResources,
+    pub(crate) indirect_draw_validation_resources: crate::indirect_validation::DrawResources,
     buffer_memory_init_actions: Vec<BufferInitTrackerAction>,
     texture_memory_actions: CommandBufferTextureMemoryActions,
 }
@@ -468,8 +467,7 @@ pub struct CommandBufferMutable {
     tlas_actions: Vec<TlasAction>,
     temp_resources: Vec<TempResource>,
 
-    indirect_draw_validation_resources:
-        crate::indirect_draw_validation::IndirectDrawValidationResources,
+    indirect_draw_validation_resources: crate::indirect_validation::DrawResources,
 
     #[cfg(feature = "trace")]
     pub(crate) commands: Option<Vec<TraceCommand>>,
@@ -559,9 +557,7 @@ impl CommandBuffer {
                     tlas_actions: Default::default(),
                     temp_resources: Default::default(),
                     indirect_draw_validation_resources:
-                        crate::indirect_draw_validation::IndirectDrawValidationResources::new(
-                            device.clone(),
-                        ),
+                        crate::indirect_validation::DrawResources::new(device.clone()),
                     #[cfg(feature = "trace")]
                     commands: if device.trace.lock().is_some() {
                         Some(Vec::new())

wgpu-core/src/command/render.rs

@@ -1631,8 +1631,7 @@ impl Global {
         let device = &cmd_buf.device;
         let snatch_guard = &device.snatchable_lock.read();
 
-        let mut indirect_draw_validation_batcher =
-            crate::indirect_draw_validation::IndirectDrawValidationBatcher::new();
+        let mut indirect_draw_validation_batcher = crate::indirect_validation::DrawBatcher::new();
 
         let (scope, pending_discard_init_fixups) = {
             device.check_is_valid().map_pass_err(pass_scope)?;
@@ -1997,8 +1996,9 @@ impl Global {
 
             CommandBuffer::insert_barriers_from_scope(transit, tracker, &scope, snatch_guard);
 
-            if let Some(ref indirect_draw_validation) = device.indirect_draw_validation {
-                indirect_draw_validation
+            if let Some(ref indirect_validation) = device.indirect_validation {
+                indirect_validation
+                    .draw
                     .inject_validation_pass(
                         device,
                         snatch_guard,
@@ -2494,8 +2494,8 @@ fn draw_indexed(
 
 fn multi_draw_indirect(
     state: &mut State,
-    indirect_draw_validation_resources: &mut crate::indirect_draw_validation::IndirectDrawValidationResources,
-    indirect_draw_validation_batcher: &mut crate::indirect_draw_validation::IndirectDrawValidationBatcher,
+    indirect_draw_validation_resources: &mut crate::indirect_validation::DrawResources,
+    indirect_draw_validation_batcher: &mut crate::indirect_validation::DrawBatcher,
     cmd_buf: &Arc<CommandBuffer>,
     indirect_buffer: Arc<crate::resource::Buffer>,
     offset: u64,
@@ -2563,7 +2563,7 @@ fn multi_draw_indirect(
         }
     }
 
-    if state.device.indirect_draw_validation.is_some() {
+    if state.device.indirect_validation.is_some() {
         state
             .info
             .usage_scope
@@ -2580,10 +2580,8 @@ fn multi_draw_indirect(
             raw_encoder: &'a mut dyn hal::DynCommandEncoder,
             device: &'a Device,
 
-            indirect_draw_validation_resources:
-                &'a mut crate::indirect_draw_validation::IndirectDrawValidationResources,
-            indirect_draw_validation_batcher:
-                &'a mut crate::indirect_draw_validation::IndirectDrawValidationBatcher,
+            indirect_draw_validation_resources: &'a mut crate::indirect_validation::DrawResources,
+            indirect_draw_validation_batcher: &'a mut crate::indirect_validation::DrawBatcher,
 
             indirect_buffer: Arc<crate::resource::Buffer>,
             indexed: bool,
@@ -2866,8 +2864,8 @@ fn write_timestamp(
 
 fn execute_bundle(
     state: &mut State,
-    indirect_draw_validation_resources: &mut crate::indirect_draw_validation::IndirectDrawValidationResources,
-    indirect_draw_validation_batcher: &mut crate::indirect_draw_validation::IndirectDrawValidationBatcher,
+    indirect_draw_validation_resources: &mut crate::indirect_validation::DrawResources,
+    indirect_draw_validation_batcher: &mut crate::indirect_validation::DrawBatcher,
     cmd_buf: &Arc<CommandBuffer>,
     bundle: Arc<super::RenderBundle>,
 ) -> Result<(), RenderPassErrorInner> {

wgpu-core/src/device/queue.rs

@@ -268,8 +268,7 @@ pub(crate) struct EncoderInFlight {
     pub(crate) trackers: Tracker,
     pub(crate) temp_resources: Vec<TempResource>,
     /// We only need to keep these resources alive.
-    _indirect_draw_validation_resources:
-        crate::indirect_draw_validation::IndirectDrawValidationResources,
+    _indirect_draw_validation_resources: crate::indirect_validation::DrawResources,
 
     /// These are the buffers that have been tracked by `PendingWrites`.
     pub(crate) pending_buffers: FastHashMap<TrackerIndex, Arc<Buffer>>,
@@ -380,10 +379,9 @@ impl PendingWrites {
                 },
                 trackers: Tracker::new(),
                 temp_resources: mem::take(&mut self.temp_resources),
-                _indirect_draw_validation_resources:
-                    crate::indirect_draw_validation::IndirectDrawValidationResources::new(
-                        device.clone(),
-                    ),
+                _indirect_draw_validation_resources: crate::indirect_validation::DrawResources::new(
+                    device.clone(),
+                ),
                 pending_buffers,
                 pending_textures,
             };

wgpu-core/src/device/resource.rs

@@ -130,8 +130,6 @@ pub struct Device {
     pub(crate) usage_scopes: UsageScopePool,
     pub(crate) last_acceleration_structure_build_command_index: AtomicU64,
     pub(crate) indirect_validation: Option<crate::indirect_validation::IndirectValidation>,
-    pub(crate) indirect_draw_validation:
-        Option<crate::indirect_draw_validation::IndirectDrawValidation>,
     // needs to be dropped last
     #[cfg(feature = "trace")]
     pub(crate) trace: Mutex<Option<trace::Trace>>,
@@ -164,9 +162,6 @@ impl Drop for Device {
         if let Some(indirect_validation) = self.indirect_validation.take() {
             indirect_validation.dispose(self.raw.as_ref());
         }
-        if let Some(indirect_draw_validation) = self.indirect_draw_validation.take() {
-            indirect_draw_validation.dispose(self.raw.as_ref());
-        }
         unsafe {
             self.raw.destroy_buffer(zero_buffer);
             self.raw.destroy_fence(fence);
@@ -258,31 +253,11 @@ impl Device {
                 .contains(wgt::DownlevelFlags::INDIRECT_EXECUTION);
 
         let indirect_validation = if enable_indirect_validation {
-            match crate::indirect_validation::IndirectValidation::new(
+            Some(crate::indirect_validation::IndirectValidation::new(
                 raw_device.as_ref(),
                 &desc.required_limits,
-            ) {
-                Ok(indirect_validation) => Some(indirect_validation),
-                Err(e) => {
-                    log::error!("indirect-validation error: {e:?}");
-                    return Err(DeviceError::Lost);
-                }
-            }
-        } else {
-            None
-        };
-
-        let indirect_draw_validation = if enable_indirect_validation {
-            match crate::indirect_draw_validation::IndirectDrawValidation::new(
-                raw_device.as_ref(),
                 &desc.required_features,
-            ) {
-                Ok(indirect_draw_validation) => Some(indirect_draw_validation),
-                Err(e) => {
-                    log::error!("indirect-draw-validation error: {e:?}");
-                    return Err(DeviceError::Lost);
-                }
-            }
+            )?)
         } else {
             None
         };
@@ -333,7 +308,6 @@ impl Device {
             // By starting at one, we can put the result in a NonZeroU64.
             last_acceleration_structure_build_command_index: AtomicU64::new(1),
             indirect_validation,
-            indirect_draw_validation,
         })
     }
 
@@ -671,11 +645,8 @@ impl Device {
         let buffer =
             unsafe { self.raw().create_buffer(&hal_desc) }.map_err(|e| self.handle_hal_error(e))?;
 
-        let raw_indirect_validation_bind_group =
-            self.create_indirect_validation_bind_group(buffer.as_ref(), desc.size, desc.usage)?;
-
-        let raw_indirect_draw_validation_bind_group = self
-            .create_indirect_draw_validation_bind_group(buffer.as_ref(), desc.size, desc.usage)?;
+        let indirect_validation_bind_groups =
+            self.create_indirect_validation_bind_groups(buffer.as_ref(), desc.size, desc.usage)?;
 
         let buffer = Buffer {
             raw: Snatchable::new(buffer),
@@ -690,8 +661,7 @@ impl Device {
             label: desc.label.to_string(),
             tracking_data: TrackingData::new(self.tracker_indices.buffers.clone()),
             bind_groups: Mutex::new(rank::BUFFER_BIND_GROUPS, WeakVec::new()),
-            raw_indirect_validation_bind_group,
-            raw_indirect_draw_validation_bind_group,
+            indirect_validation_bind_groups,
         };
 
         let buffer = Arc::new(buffer);
@@ -773,7 +743,7 @@ impl Device {
         hal_buffer: Box<dyn hal::DynBuffer>,
         desc: &resource::BufferDescriptor,
     ) -> (Fallible<Buffer>, Option<resource::CreateBufferError>) {
-        let raw_indirect_validation_bind_group = match self.create_indirect_validation_bind_group(
+        let indirect_validation_bind_groups = match self.create_indirect_validation_bind_groups(
             hal_buffer.as_ref(),
             desc.size,
             desc.usage,
@@ -782,13 +752,6 @@ impl Device {
             Err(e) => return (Fallible::Invalid(Arc::new(desc.label.to_string())), Some(e)),
         };
 
-        let raw_indirect_draw_validation_bind_group = match self
-            .create_indirect_draw_validation_bind_group(hal_buffer.as_ref(), desc.size, desc.usage)
-        {
-            Ok(ok) => ok,
-            Err(e) => return (Fallible::Invalid(Arc::new(desc.label.to_string())), Some(e)),
-        };
-
         unsafe { self.raw().add_raw_buffer(&*hal_buffer) };
 
         let buffer = Buffer {
@@ -804,8 +767,7 @@ impl Device {
             label: desc.label.to_string(),
             tracking_data: TrackingData::new(self.tracker_indices.buffers.clone()),
             bind_groups: Mutex::new(rank::BUFFER_BIND_GROUPS, WeakVec::new()),
-            raw_indirect_validation_bind_group,
-            raw_indirect_draw_validation_bind_group,
+            indirect_validation_bind_groups,
         };
 
         let buffer = Arc::new(buffer);
@@ -818,12 +780,13 @@ impl Device {
         (Fallible::Valid(buffer), None)
     }
 
-    fn create_indirect_validation_bind_group(
+    fn create_indirect_validation_bind_groups(
         &self,
         raw_buffer: &dyn hal::DynBuffer,
         buffer_size: u64,
         usage: wgt::BufferUsages,
-    ) -> Result<Snatchable<Box<dyn hal::DynBindGroup>>, resource::CreateBufferError> {
+    ) -> Result<Snatchable<crate::indirect_validation::BindGroups>, resource::CreateBufferError>
+    {
         if !usage.contains(wgt::BufferUsages::INDIRECT) {
             return Ok(Snatchable::empty());
         }
@@ -832,40 +795,19 @@ impl Device {
             return Ok(Snatchable::empty());
         };
 
-        let bind_group = indirect_validation
-            .create_src_bind_group(self.raw(), &self.limits, buffer_size, raw_buffer)
-            .map_err(resource::CreateBufferError::IndirectValidationBindGroup)?;
-
-        let Some(bind_group) = bind_group else {
-            return Ok(Snatchable::empty());
-        };
-
-        Ok(Snatchable::new(bind_group))
-    }
+        let bind_groups = crate::indirect_validation::BindGroups::new(
+            indirect_validation,
+            self,
+            buffer_size,
+            raw_buffer,
+        )
+        .map_err(resource::CreateBufferError::IndirectValidationBindGroup)?;
 
-    fn create_indirect_draw_validation_bind_group(
-        &self,
-        raw_buffer: &dyn hal::DynBuffer,
-        buffer_size: u64,
-        usage: wgt::BufferUsages,
-    ) -> Result<Snatchable<Box<dyn hal::DynBindGroup>>, resource::CreateBufferError> {
-        if !usage.contains(wgt::BufferUsages::INDIRECT) {
-            return Ok(Snatchable::empty());
+        if let Some(bind_groups) = bind_groups {
+            Ok(Snatchable::new(bind_groups))
+        } else {
+            Ok(Snatchable::empty())
         }
-
-        let Some(ref indirect_draw_validation) = self.indirect_draw_validation else {
-            return Ok(Snatchable::empty());
-        };
-
-        let bind_group = indirect_draw_validation
-            .create_src_bind_group(self.raw(), &self.adapter.limits(), buffer_size, raw_buffer)
-            .map_err(resource::CreateBufferError::IndirectValidationBindGroup)?;
-
-        let Some(bind_group) = bind_group else {
-            return Ok(Snatchable::empty());
-        };
-
-        Ok(Snatchable::new(bind_group))
     }
 
     pub(crate) fn create_texture(