More pass validation

Author: Vecvec

tests/tests/wgpu-gpu/ray_tracing/pipelines.rs

@@ -10,6 +10,7 @@ use wgpu_types::AccelerationStructureFlags;
 
 pub fn all_tests(tests: &mut Vec<GpuTestInitializer>) {
     tests.push(PIPELINE_CREATE_USE);
+    tests.push(RAY_TRACING_PASS_NO_FEATURE);
 }
 
 #[apply(gpu_test!)]
@@ -199,3 +200,19 @@ fn pipeline_create_use(ctx: TestingContext) {
         None,
     );
 }
+
+#[apply(gpu_test!)]
+static RAY_TRACING_PASS_NO_FEATURE: GpuTestConfiguration = GpuTestConfiguration::new()
+    .parameters(TestParameters::default())
+    .run_sync(ray_tracing_pass_no_feature);
+
+fn ray_tracing_pass_no_feature(ctx: TestingContext) {
+    let mut encoder = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor::default());
+
+    let pass = encoder.begin_ray_tracing_pass(&RayTracingPassDescriptor::default());
+    drop(pass);
+
+    fail(&ctx.device, || encoder.finish(), None);
+}

wgpu-core/src/command/ray_tracing_pass.rs

@@ -69,17 +69,24 @@ impl fmt::Debug for RayTracingPass {
 
 impl RayTracingPass {
     /// If the parent command encoder is invalid, the returned pass will be invalid.
-    fn new(parent: Arc<CommandEncoder>, desc: RayTracingPassDescriptor) -> Self {
+    fn new(
+        parent: Arc<CommandEncoder>,
+        desc: RayTracingPassDescriptor,
+    ) -> Result<Self, MissingFeatures> {
+        parent
+            .device
+            .require_features(wgt::Features::EXPERIMENTAL_RAY_TRACING_PIPELINES)?;
+
         let RayTracingPassDescriptor { label } = desc;
 
-        Self {
+        Ok(Self {
             base: BasePass::new(&label),
             device: parent.device.clone(),
             parent: Some(parent),
 
             current_bind_groups: BindGroupStateChange::new(),
             current_pipeline: StateChange::new(),
-        }
+        })
     }
 
     fn new_invalid(parent: Arc<CommandEncoder>, label: &Label, err: RayTracingPassError) -> Self {
@@ -193,6 +200,10 @@ pub enum TraceRayError {
     TooManyTotal { current: u32, limit: u32 },
     #[error(transparent)]
     BindingSizeTooSmall(#[from] LateMinBufferBindingSizeMismatch),
+    #[error("Not all immediate data required by the pipeline has been set via set_immediates (missing byte ranges: {missing})")]
+    MissingImmediateData {
+        missing: naga::valid::ImmediateSlots,
+    },
 }
 
 impl WebGpuError for TraceRayError {
@@ -328,6 +339,18 @@ impl<'scope, 'snatch_guard, 'cmd_enc> State<'scope, 'snatch_guard, 'cmd_enc> {
         if let Some(pipeline) = self.pipeline.as_ref() {
             self.pass.binder.check_compatibility(pipeline.as_ref())?;
             self.pass.binder.check_late_buffer_bindings()?;
+            if !self
+                .pass
+                .immediate_state
+                .immediate_slots_set
+                .contains(pipeline.immediate_slots_required)
+            {
+                return Err(TraceRayError::MissingImmediateData {
+                    missing: pipeline
+                        .immediate_slots_required
+                        .difference(self.pass.immediate_state.immediate_slots_set),
+                });
+            }
             Ok(())
         } else {
             Err(TraceRayError::MissingPipeline(pass::MissingPipeline))
@@ -558,6 +581,7 @@ impl CommandEncoder {
         let label = desc.label.as_deref().map(Cow::Borrowed);
 
         let scope = PassErrorScope::Pass;
+
         let mut cmd_buf_data = self.data.lock();
 
         match cmd_buf_data.lock_encoder() {
@@ -570,10 +594,26 @@ impl CommandEncoder {
                     );
                 }
 
-                (
-                    RayTracingPass::new(self.clone(), RayTracingPassDescriptor { label }),
-                    None,
-                )
+                let pass = match RayTracingPass::new(
+                    self.clone(),
+                    RayTracingPassDescriptor {
+                        label: label.clone(),
+                    },
+                ) {
+                    Ok(pass) => pass,
+                    Err(err) => {
+                        return (
+                            RayTracingPass::new_invalid(
+                                self.clone(),
+                                &label,
+                                err.map_pass_err(scope),
+                            ),
+                            None,
+                        );
+                    }
+                };
+
+                (pass, None)
             }
             Err(err @ SErr::Locked) => {
                 // Attempting to open a new pass while the encoder is locked
@@ -818,9 +858,15 @@ fn trace_rays(
     // `saturating_mul` is fine here as it is the limit, so a lower limit if it would overflow is just a
     // slightly greater restriction.
     let dim_size_limit = [
-        limits.max_compute_workgroup_size_x.saturating_mul(limits.max_compute_workgroups_per_dimension),
-        limits.max_compute_workgroup_size_y.saturating_mul(limits.max_compute_workgroups_per_dimension),
-        limits.max_compute_workgroup_size_z.saturating_mul(limits.max_compute_workgroups_per_dimension),
+        limits
+            .max_compute_workgroup_size_x
+            .saturating_mul(limits.max_compute_workgroups_per_dimension),
+        limits
+            .max_compute_workgroup_size_y
+            .saturating_mul(limits.max_compute_workgroups_per_dimension),
+        limits
+            .max_compute_workgroup_size_z
+            .saturating_mul(limits.max_compute_workgroups_per_dimension),
     ];
 
     if dims[0] > dim_size_limit[0] {
@@ -850,7 +896,9 @@ fn trace_rays(
         ));
     }
 
-    let tot_rays = dims[0].checked_mul(dims[1]).and_then(|tmp| tmp.checked_mul(dims[2]));
+    let tot_rays = dims[0]
+        .checked_mul(dims[1])
+        .and_then(|tmp| tmp.checked_mul(dims[2]));
 
     if tot_rays.is_none_or(|tot_rays| tot_rays > limits.max_ray_dispatch_count) {
         return Err(RayTracingPassErrorInner::TraceRay(

wgpu-core/src/device/ray_tracing.rs

@@ -750,6 +750,14 @@ impl Device {
             desc.intersections.len(),
         )?;
 
+        let naga::valid::ImmediateUsage::Valid {
+            slots: immediate_slots_required,
+            size: _,
+        } = io.immediates
+        else {
+            unreachable!("Immediates exceeding maxImmediateSize should have been rejected");
+        };
+
         let pipeline = pipeline::RayTracingPipeline {
             state: ResourceState::Valid(pipeline::RayTracingPipelineState {
                 raw: ManuallyDrop::new(raw),
@@ -759,6 +767,7 @@ impl Device {
             }),
             device: self.clone(),
             late_sized_buffer_groups,
+            immediate_slots_required,
             label: desc.label.to_string(),
             tracking_data: TrackingData::new(self.tracker_indices.ray_tracing_pipelines.clone()),
         };

wgpu-core/src/pipeline.rs

@@ -1436,6 +1436,7 @@ pub struct RayTracingPipeline {
     pub(crate) state: ResourceState<RayTracingPipelineState>,
     pub(crate) device: Arc<Device>,
     pub(crate) late_sized_buffer_groups: ArrayVec<LateSizedBufferGroup, { hal::MAX_BIND_GROUPS }>,
+    pub(crate) immediate_slots_required: naga::valid::ImmediateSlots,
     /// The `label` from the descriptor used to create the resource.
     pub(crate) label: String,
     pub(crate) tracking_data: TrackingData,
@@ -1486,6 +1487,7 @@ impl RayTracingPipeline {
             tracking_data: TrackingData::new(device.tracker_indices.compute_pipelines.clone()),
             state: ResourceState::Invalid,
             device,
+            immediate_slots_required: naga::valid::ImmediateSlots::default(),
             late_sized_buffer_groups: ArrayVec::new(),
             label,
         })