Add max_binding_array_acceleration_structure_elements_per_shader_stage limit

This commit is contained in:
Dzmitry Malyshau authored and Jim Blandy committed 2026-03-11 08:18:38 -07:00
1 parent e39b3aec8e
commit adc3534f1c
11 files changed
+70 -22

No files matched your search

+6 -10
View File
@@ -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()));
+22 -3
View File
@@ -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,
+6 -1
View File
@@ -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 {
+1
View File
@@ -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,
+1
View File
@@ -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)
+1
View File
@@ -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,
+8
View File
@@ -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)
+2
View File
@@ -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}")?;
+12
View File
@@ -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, // * +
+1
View File
@@ -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(),
+10 -8
View File
@@ -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[..];