From adc3534f1ccda4989e2fcc6d22d5e596a29ed703 Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Sun, 25 Jan 2026 20:39:46 -0800 Subject: [PATCH] Add max_binding_array_acceleration_structure_elements_per_shader_stage limit --- tests/tests/wgpu-gpu/binding_array/tlas.rs | 16 ++++++-------- wgpu-core/src/binding_model.rs | 25 +++++++++++++++++++--- wgpu-hal/src/dx12/adapter.rs | 7 +++++- wgpu-hal/src/gles/adapter.rs | 1 + wgpu-hal/src/metal/adapter.rs | 1 + wgpu-hal/src/noop/mod.rs | 1 + wgpu-hal/src/vulkan/adapter.rs | 8 +++++++ wgpu-info/src/human.rs | 2 ++ wgpu-types/src/limits.rs | 12 +++++++++++ wgpu/src/backend/webgpu.rs | 1 + wgpu/src/backend/wgpu_core.rs | 18 +++++++++------- 11 files changed, 70 insertions(+), 22 deletions(-) diff --git a/tests/tests/wgpu-gpu/binding_array/tlas.rs b/tests/tests/wgpu-gpu/binding_array/tlas.rs index a0ad565e1..0669c13d4 100644 --- a/tests/tests/wgpu-gpu/binding_array/tlas.rs +++ b/tests/tests/wgpu-gpu/binding_array/tlas.rs @@ -19,13 +19,11 @@ static BINDING_ARRAY_TLAS: GpuTestConfiguration = GpuTestConfiguration::new() .features( Features::EXPERIMENTAL_RAY_QUERY | Features::ACCELERATION_STRUCTURE_BINDING_ARRAY, ) - .limits({ - let mut limits = - Limits::default().using_minimum_supported_acceleration_structure_values(); - // Keep this small; we only need a couple of array elements. - limits.max_binding_array_elements_per_shader_stage = 8; - limits.max_acceleration_structures_per_shader_stage = 8; - limits + .limits(Limits { + max_binding_array_elements_per_shader_stage: 8, + max_acceleration_structures_per_shader_stage: 8, + max_binding_array_acceleration_structure_elements_per_shader_stage: 8, + ..Limits::default().using_minimum_supported_acceleration_structure_values() }) // As of writing, Metal's HAL does not implement binding acceleration structures. .skip(FailureCase::backend(Backends::METAL)), @@ -163,9 +161,7 @@ async fn binding_array_tlas(ctx: TestingContext) { transform_buffer_offset: None, }]), }), - std::iter::empty::<&wgpu::Tlas>() - .chain(std::iter::once(&tlas_a)) - .chain(std::iter::once(&tlas_b)), + [&tlas_a, &tlas_b], ); ctx.queue.submit(Some(encoder.finish())); diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs index b5423a53d..9db83a720 100644 --- a/wgpu-core/src/binding_model.rs +++ b/wgpu-core/src/binding_model.rs @@ -327,6 +327,7 @@ pub enum BindingTypeMaxCountErrorKind { UniformBuffers, BindingArrayElements, BindingArraySamplerElements, + BindingArrayAccelerationStructureElements, AccelerationStructures, } @@ -354,6 +355,9 @@ impl BindingTypeMaxCountErrorKind { BindingTypeMaxCountErrorKind::BindingArraySamplerElements => { "max_binding_array_sampler_elements_per_shader_stage" } + BindingTypeMaxCountErrorKind::BindingArrayAccelerationStructureElements => { + "max_binding_array_acceleration_structure_elements_per_shader_stage" + } BindingTypeMaxCountErrorKind::AccelerationStructures => { "max_acceleration_structures_per_shader_stage" } @@ -433,6 +437,7 @@ pub(crate) struct BindingTypeMaxCountValidator { acceleration_structures: PerStageBindingTypeCounter, binding_array_elements: PerStageBindingTypeCounter, binding_array_sampler_elements: PerStageBindingTypeCounter, + binding_array_acceleration_structure_elements: PerStageBindingTypeCounter, has_bindless_array: bool, } @@ -444,9 +449,16 @@ impl BindingTypeMaxCountValidator { self.binding_array_elements.add(binding.visibility, count); self.has_bindless_array = true; - if let wgt::BindingType::Sampler(_) = binding.ty { - self.binding_array_sampler_elements - .add(binding.visibility, count); + match binding.ty { + wgt::BindingType::Sampler(_) => { + self.binding_array_sampler_elements + .add(binding.visibility, count); + } + wgt::BindingType::AccelerationStructure { .. } => { + self.binding_array_acceleration_structure_elements + .add(binding.visibility, count); + } + _ => {} } } else { match binding.ty { @@ -513,6 +525,8 @@ impl BindingTypeMaxCountValidator { .merge(&other.binding_array_elements); self.binding_array_sampler_elements .merge(&other.binding_array_sampler_elements); + self.binding_array_acceleration_structure_elements + .merge(&other.binding_array_acceleration_structure_elements); } pub(crate) fn validate(&self, limits: &wgt::Limits) -> Result<(), BindingTypeMaxCountError> { @@ -560,6 +574,11 @@ impl BindingTypeMaxCountValidator { limits.max_binding_array_sampler_elements_per_shader_stage, BindingTypeMaxCountErrorKind::BindingArraySamplerElements, )?; + self.binding_array_acceleration_structure_elements + .validate( + limits.max_binding_array_acceleration_structure_elements_per_shader_stage, + BindingTypeMaxCountErrorKind::BindingArrayAccelerationStructureElements, + )?; self.acceleration_structures.validate( limits.max_acceleration_structures_per_shader_stage, BindingTypeMaxCountErrorKind::AccelerationStructures, diff --git a/wgpu-hal/src/dx12/adapter.rs b/wgpu-hal/src/dx12/adapter.rs index a30993977..38765f5e8 100644 --- a/wgpu-hal/src/dx12/adapter.rs +++ b/wgpu-hal/src/dx12/adapter.rs @@ -925,7 +925,12 @@ impl super::Adapter { } else { 0 }, - + max_binding_array_acceleration_structure_elements_per_shader_stage: + if supports_ray_tracing { + max_srv_count / 2 + } else { + 0 + }, max_multiview_view_count, }), alignments: crate::Alignments { diff --git a/wgpu-hal/src/gles/adapter.rs b/wgpu-hal/src/gles/adapter.rs index 4746d9796..9f25e81c9 100644 --- a/wgpu-hal/src/gles/adapter.rs +++ b/wgpu-hal/src/gles/adapter.rs @@ -715,6 +715,7 @@ impl super::Adapter { max_uniform_buffers_per_shader_stage, max_binding_array_elements_per_shader_stage: 0, max_binding_array_sampler_elements_per_shader_stage: 0, + max_binding_array_acceleration_structure_elements_per_shader_stage: 0, max_uniform_buffer_binding_size: unsafe { gl.get_parameter_i32(glow::MAX_UNIFORM_BLOCK_SIZE) } as u64, diff --git a/wgpu-hal/src/metal/adapter.rs b/wgpu-hal/src/metal/adapter.rs index c14f90421..cae067521 100644 --- a/wgpu-hal/src/metal/adapter.rs +++ b/wgpu-hal/src/metal/adapter.rs @@ -1178,6 +1178,7 @@ impl super::PrivateCapabilities { max_binding_array_elements_per_shader_stage: self.max_binding_array_elements, max_binding_array_sampler_elements_per_shader_stage: self .max_sampler_binding_array_elements, + max_binding_array_acceleration_structure_elements_per_shader_stage: 0, // Note: any adjustment here will not be reflected in the stored `PrivateCapabilities`. max_uniform_buffer_binding_size: self.max_buffer_size.min(!0u32 as u64), max_storage_buffer_binding_size: self.max_buffer_size.min(!0u32 as u64) diff --git a/wgpu-hal/src/noop/mod.rs b/wgpu-hal/src/noop/mod.rs index c9fb9d0e9..82dfc2c30 100644 --- a/wgpu-hal/src/noop/mod.rs +++ b/wgpu-hal/src/noop/mod.rs @@ -179,6 +179,7 @@ pub const CAPABILITIES: crate::Capabilities = { max_uniform_buffers_per_shader_stage: ALLOC_MAX_U32, max_binding_array_elements_per_shader_stage: ALLOC_MAX_U32, max_binding_array_sampler_elements_per_shader_stage: ALLOC_MAX_U32, + max_binding_array_acceleration_structure_elements_per_shader_stage: ALLOC_MAX_U32, max_uniform_buffer_binding_size: ALLOC_MAX_U64, max_storage_buffer_binding_size: ALLOC_MAX_U64, max_vertex_buffers: ALLOC_MAX_U32, diff --git a/wgpu-hal/src/vulkan/adapter.rs b/wgpu-hal/src/vulkan/adapter.rs index a3521f594..3e0eca274 100644 --- a/wgpu-hal/src/vulkan/adapter.rs +++ b/wgpu-hal/src/vulkan/adapter.rs @@ -1478,6 +1478,14 @@ impl PhysicalDeviceProperties { max_uniform_buffers_per_shader_stage: limits.max_per_stage_descriptor_uniform_buffers, max_binding_array_elements_per_shader_stage: max_binding_array_elements, max_binding_array_sampler_elements_per_shader_stage: max_sampler_binding_array_elements, + max_binding_array_acceleration_structure_elements_per_shader_stage: if self + .descriptor_indexing + .is_some() + { + max_acceleration_structures_per_shader_stage + } else { + 0 + }, max_uniform_buffer_binding_size: limits .max_uniform_buffer_range .min(crate::auxil::MAX_I32_BINDING_SIZE) diff --git a/wgpu-info/src/human.rs b/wgpu-info/src/human.rs index 48317f8d0..c666e5107 100644 --- a/wgpu-info/src/human.rs +++ b/wgpu-info/src/human.rs @@ -158,6 +158,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize max_uniform_buffers_per_shader_stage, max_binding_array_elements_per_shader_stage, max_binding_array_sampler_elements_per_shader_stage, + max_binding_array_acceleration_structure_elements_per_shader_stage, max_uniform_buffer_binding_size, max_storage_buffer_binding_size, max_vertex_buffers, @@ -212,6 +213,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize writeln!(output, "\t\t Max Uniform Buffers Per Shader Stage: {max_uniform_buffers_per_shader_stage}")?; writeln!(output, "\t\t Max Binding Array Elements Per Shader Stage: {max_binding_array_elements_per_shader_stage}")?; writeln!(output, "\t\tMax Binding Array Sampler Elements Per Shader Stage: {max_binding_array_sampler_elements_per_shader_stage}")?; + writeln!(output, "\t\t Max Binding Array AS Elements Per Shader Stage: {max_binding_array_acceleration_structure_elements_per_shader_stage}")?; writeln!(output, "\t\t Max Uniform Buffer Binding Size: {max_uniform_buffer_binding_size}")?; writeln!(output, "\t\t Max Storage Buffer Binding Size: {max_storage_buffer_binding_size}")?; writeln!(output, "\t\t Max Buffer Size: {max_buffer_size}")?; diff --git a/wgpu-types/src/limits.rs b/wgpu-types/src/limits.rs index 61b651166..686f0705a 100644 --- a/wgpu-types/src/limits.rs +++ b/wgpu-types/src/limits.rs @@ -38,6 +38,10 @@ macro_rules! with_limits { $macro_name!(max_storage_textures_per_shader_stage, Ordering::Less); $macro_name!(max_uniform_buffers_per_shader_stage, Ordering::Less); $macro_name!(max_binding_array_elements_per_shader_stage, Ordering::Less); + $macro_name!( + max_binding_array_acceleration_structure_elements_per_shader_stage, + Ordering::Less + ); $macro_name!(max_uniform_buffer_binding_size, Ordering::Less); $macro_name!(max_storage_buffer_binding_size, Ordering::Less); $macro_name!(max_vertex_buffers, Ordering::Less); @@ -155,6 +159,10 @@ pub struct Limits { /// /// This "defaults" to 0. However if binding arrays are supported, all devices can support 500,000. Higher is "better". pub max_binding_array_elements_per_shader_stage: u32, + /// Amount of individual acceleration structures within binding arrays that can be accessed in a single shader stage. + /// + /// This "defaults" to 0. Higher is "better". + pub max_binding_array_acceleration_structure_elements_per_shader_stage: u32, /// Amount of individual samplers within binding arrays that can be accessed in a single shader stage. /// /// This "defaults" to 0. However if binding arrays are supported, all devices can support 1,000. Higher is "better". @@ -318,6 +326,7 @@ impl Limits { /// max_storage_textures_per_shader_stage: 4, /// max_uniform_buffers_per_shader_stage: 12, /// max_binding_array_elements_per_shader_stage: 0, + /// max_binding_array_acceleration_structure_elements_per_shader_stage: 0, /// max_binding_array_sampler_elements_per_shader_stage: 0, /// max_uniform_buffer_binding_size: 64 << 10, // (64 KiB) /// max_storage_buffer_binding_size: 128 << 20, // (128 MiB) @@ -376,6 +385,7 @@ impl Limits { max_storage_textures_per_shader_stage: 4, max_uniform_buffers_per_shader_stage: 12, max_binding_array_elements_per_shader_stage: 0, + max_binding_array_acceleration_structure_elements_per_shader_stage: 0, max_binding_array_sampler_elements_per_shader_stage: 0, max_uniform_buffer_binding_size: 64 << 10, // (64 KiB) max_storage_buffer_binding_size: 128 << 20, // (128 MiB) @@ -438,6 +448,7 @@ impl Limits { /// max_storage_textures_per_shader_stage: 4, /// max_uniform_buffers_per_shader_stage: 12, /// max_binding_array_elements_per_shader_stage: 0, + /// max_binding_array_acceleration_structure_elements_per_shader_stage: 0, /// max_binding_array_sampler_elements_per_shader_stage: 0, /// max_uniform_buffer_binding_size: 16 << 10, // * (16 KiB) /// max_storage_buffer_binding_size: 128 << 20, // (128 MiB) @@ -516,6 +527,7 @@ impl Limits { /// max_storage_textures_per_shader_stage: 0, // + /// max_uniform_buffers_per_shader_stage: 11, // + /// max_binding_array_elements_per_shader_stage: 0, + /// max_binding_array_acceleration_structure_elements_per_shader_stage: 0, /// max_binding_array_sampler_elements_per_shader_stage: 0, /// max_uniform_buffer_binding_size: 16 << 10, // * (16 KiB) /// max_storage_buffer_binding_size: 0, // * + diff --git a/wgpu/src/backend/webgpu.rs b/wgpu/src/backend/webgpu.rs index 22872bc04..7da5ada21 100644 --- a/wgpu/src/backend/webgpu.rs +++ b/wgpu/src/backend/webgpu.rs @@ -804,6 +804,7 @@ fn map_wgt_limits(limits: webgpu_sys::GpuSupportedLimits) -> wgt::Limits { max_uniform_buffers_per_shader_stage: limits.max_uniform_buffers_per_shader_stage(), max_binding_array_elements_per_shader_stage: 0, max_binding_array_sampler_elements_per_shader_stage: 0, + max_binding_array_acceleration_structure_elements_per_shader_stage: 0, max_uniform_buffer_binding_size: limits.max_uniform_buffer_binding_size() as u64, max_storage_buffer_binding_size: limits.max_storage_buffer_binding_size() as u64, max_vertex_buffers: limits.max_vertex_buffers(), diff --git a/wgpu/src/backend/wgpu_core.rs b/wgpu/src/backend/wgpu_core.rs index 57c8db9b1..8f3e6e3ae 100644 --- a/wgpu/src/backend/wgpu_core.rs +++ b/wgpu/src/backend/wgpu_core.rs @@ -1193,15 +1193,17 @@ impl dispatch::DeviceInterface for CoreDevice { } let mut remaining_arrayed_buffer_bindings = &arrayed_buffer_bindings[..]; - // Gather all the TLAS IDs used by TLAS arrays first (same pattern as other arrayed resources). - // - // Note: there isn't currently a dedicated feature flag for TLAS binding arrays at the wgpu API - // layer; validation happens in wgpu-core against `BindGroupLayoutEntry::count`. let mut arrayed_acceleration_structures = Vec::new(); - for entry in desc.entries.iter() { - if let BindingResource::AccelerationStructureArray(array) = entry.resource { - arrayed_acceleration_structures - .extend(array.iter().map(|tlas| tlas.inner.as_core().id)); + if self + .features + .contains(Features::ACCELERATION_STRUCTURE_BINDING_ARRAY) + { + // Gather all the TLAS IDs used by TLAS arrays first (same pattern as other arrayed resources). + for entry in desc.entries.iter() { + if let BindingResource::AccelerationStructureArray(array) = entry.resource { + arrayed_acceleration_structures + .extend(array.iter().map(|tlas| tlas.inner.as_core().id)); + } } } let mut remaining_arrayed_acceleration_structures = &arrayed_acceleration_structures[..];