mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-20 14:31:08 +01:00
add Limits::max_buffers_and_acceleration_structures_per_shader_stage
This commit is contained in:
1 parent
0853e7bdc1
commit
995ee7b3f1
17 files changed
+489
-39
No files matched your search
@@ -168,6 +168,7 @@ By @stuartparmenter in [#9658](https://github.com/gfx-rs/wgpu/pull/9658).
|
||||
- Implemented `QuerySet::destroy` by @sagudev in [#9671](https://github.com/gfx-rs/wgpu/pull/9671)
|
||||
- Implemented query set initialization tracking, ensuring unwritten query slots resolve to 0; avoiding UB. By @teoxoy in [#9664](https://github.com/gfx-rs/wgpu/pull/9664).
|
||||
- Add `Surface::display_hdr_info`, a read-only snapshot of the backing display's HDR characteristics (luminance in nits, EDR headroom, primaries, bit depth, and a coarse dynamic-range/gamut bucket) for tone-mapping. `DisplayHdrInfo::tone_map_headroom()` folds it into the one multiplier most tone-mappers want; whether to request an HDR surface at all is a separate, capability question answered by `SurfaceCapabilities`, not by this live value. Populated on DX12 and Vulkan on Windows, Metal on macOS, and the web. By @stuartparmenter.
|
||||
- Added `Limits::max_buffers_and_acceleration_structures_per_shader_stage`, a combined limit for all buffer types (storage, uniform, vertex buffers, and acceleration structures) that share Metal's buffer argument table. On Metal without `InstanceFlags::STRICT_WEBGPU_COMPLIANCE` set, the new limit and the individual per-type limits (`max_storage_buffers_per_shader_stage`, `max_uniform_buffers_per_shader_stage`, `max_vertex_buffers`, `max_acceleration_structures_per_shader_stage`) are set to 29. By @teoxoy in [#9709](https://github.com/gfx-rs/wgpu/pull/9709).
|
||||
|
||||
#### Metal
|
||||
|
||||
|
||||
@@ -0,0 +1,339 @@
|
||||
/// Tests for `max_buffers_and_acceleration_structures_per_shader_stage`.
|
||||
///
|
||||
/// This limit only has a meaningful finite value on Metal (non-strict mode), where all buffer
|
||||
/// types (storage, uniform, vertex buffers, acceleration structures) share a single argument
|
||||
/// table of 31 slots with 2 reserved for internal use, leaving 29 user-visible slots.
|
||||
///
|
||||
/// On all other backends the limit is `u32::MAX`, so these tests are skipped there to avoid
|
||||
/// hitting other, lower per-type limits while trying to reach the combined limit.
|
||||
use wgpu_test::{
|
||||
fail, gpu_test, valid, FailureCase, GpuTestConfiguration, GpuTestInitializer, TestParameters,
|
||||
};
|
||||
|
||||
pub fn all_tests(vec: &mut Vec<GpuTestInitializer>) {
|
||||
vec.extend([
|
||||
BUFFERS_AND_ACCEL_STRUCTS_VALID_WITHIN_LIMIT,
|
||||
BUFFERS_AND_ACCEL_STRUCTS_VALID_VERTEX_STAGE_AT_LIMIT,
|
||||
BUFFERS_AND_ACCEL_STRUCTS_EXCEEDS_SINGLE_BGL,
|
||||
BUFFERS_AND_ACCEL_STRUCTS_EXCEEDS_ACROSS_BGLS,
|
||||
BUFFERS_AND_ACCEL_STRUCTS_VERTEX_STAGE_EXCEEDS_WITH_VERTEX_BUFFERS,
|
||||
]);
|
||||
}
|
||||
|
||||
/// Skip on every backend except Metal. The combined limit is `u32::MAX` on other backends,
|
||||
/// so reaching it would require an impractical number of resources and would run into the
|
||||
/// individual per-type limits instead.
|
||||
fn skip_non_metal() -> FailureCase {
|
||||
FailureCase::backend(!wgpu::Backends::METAL)
|
||||
}
|
||||
|
||||
/// Device limits that reflect Metal's combined buffer slot constraint.
|
||||
///
|
||||
/// `max_buffers_and_acceleration_structures_per_shader_stage` is set to 29 (Metal's limit).
|
||||
/// The per-type limits are raised above the default 8/12 so that tests can exercise the
|
||||
/// *combined* limit without being blocked by an individual per-type limit first.
|
||||
///
|
||||
/// Setting `max_storage_buffers_per_shader_stage: 29` also means the test is automatically
|
||||
/// skipped on Metal in STRICT_WEBGPU_COMPLIANCE mode, where the adapter only supports 8.
|
||||
fn metal_limits() -> wgpu::Limits {
|
||||
wgpu::Limits {
|
||||
max_storage_buffers_per_shader_stage: 29,
|
||||
max_uniform_buffers_per_shader_stage: 29,
|
||||
max_vertex_buffers: 16,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: 29,
|
||||
..wgpu::Limits::defaults()
|
||||
}
|
||||
}
|
||||
|
||||
fn storage_entries(n: u32, visibility: wgpu::ShaderStages) -> Vec<wgpu::BindGroupLayoutEntry> {
|
||||
(0..n)
|
||||
.map(|i| wgpu::BindGroupLayoutEntry {
|
||||
binding: i,
|
||||
visibility,
|
||||
ty: wgpu::BindingType::Buffer {
|
||||
ty: wgpu::BufferBindingType::Storage { read_only: true },
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: None,
|
||||
},
|
||||
count: None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn uniform_entries(
|
||||
n: u32,
|
||||
binding_offset: u32,
|
||||
visibility: wgpu::ShaderStages,
|
||||
) -> Vec<wgpu::BindGroupLayoutEntry> {
|
||||
(0..n)
|
||||
.map(|i| wgpu::BindGroupLayoutEntry {
|
||||
binding: binding_offset + i,
|
||||
visibility,
|
||||
ty: wgpu::BindingType::Buffer {
|
||||
ty: wgpu::BufferBindingType::Uniform,
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: None,
|
||||
},
|
||||
count: None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 14 storage + 14 uniform = 28 combined in a BGL.
|
||||
/// Pipeline layout creation must succeed since 28 < 29.
|
||||
#[gpu_test]
|
||||
static BUFFERS_AND_ACCEL_STRUCTS_VALID_WITHIN_LIMIT: GpuTestConfiguration =
|
||||
GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.limits(metal_limits())
|
||||
.skip(skip_non_metal()),
|
||||
)
|
||||
.run_sync(|ctx| {
|
||||
let mut entries = storage_entries(14, wgpu::ShaderStages::COMPUTE);
|
||||
entries.extend(uniform_entries(14, 14, wgpu::ShaderStages::COMPUTE));
|
||||
|
||||
valid(&ctx.device, || {
|
||||
let bgl = ctx
|
||||
.device
|
||||
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: None,
|
||||
entries: &entries,
|
||||
});
|
||||
let _ = ctx
|
||||
.device
|
||||
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[Some(&bgl)],
|
||||
immediate_size: 0,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
/// 20 storage buffers + 9 vertex buffers = 29 combined.
|
||||
/// Render pipeline creation must succeed since 29 == limit.
|
||||
#[gpu_test]
|
||||
static BUFFERS_AND_ACCEL_STRUCTS_VALID_VERTEX_STAGE_AT_LIMIT: GpuTestConfiguration =
|
||||
GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.limits(metal_limits())
|
||||
.skip(skip_non_metal()),
|
||||
)
|
||||
.run_sync(|ctx| {
|
||||
let entries = storage_entries(20, wgpu::ShaderStages::VERTEX);
|
||||
|
||||
let bgl = ctx
|
||||
.device
|
||||
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: None,
|
||||
entries: &entries,
|
||||
});
|
||||
let pipeline_layout =
|
||||
ctx.device
|
||||
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[Some(&bgl)],
|
||||
immediate_size: 0,
|
||||
});
|
||||
|
||||
let shader = ctx
|
||||
.device
|
||||
.create_shader_module(wgpu::ShaderModuleDescriptor {
|
||||
label: None,
|
||||
source: wgpu::ShaderSource::Wgsl(
|
||||
"@vertex fn vs() -> @builtin(position) vec4f { return vec4f(0.0); }
|
||||
@fragment fn fs() -> @location(0) vec4f { return vec4f(0.0); }"
|
||||
.into(),
|
||||
),
|
||||
});
|
||||
|
||||
const EMPTY_VB: Option<wgpu::VertexBufferLayout<'static>> =
|
||||
Some(wgpu::VertexBufferLayout {
|
||||
array_stride: 4,
|
||||
step_mode: wgpu::VertexStepMode::Vertex,
|
||||
attributes: &[],
|
||||
});
|
||||
|
||||
valid(&ctx.device, || {
|
||||
let _ = ctx
|
||||
.device
|
||||
.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: None,
|
||||
layout: Some(&pipeline_layout),
|
||||
vertex: wgpu::VertexState {
|
||||
module: &shader,
|
||||
entry_point: Some("vs"),
|
||||
compilation_options: Default::default(),
|
||||
buffers: &[EMPTY_VB; 9],
|
||||
},
|
||||
fragment: Some(wgpu::FragmentState {
|
||||
module: &shader,
|
||||
entry_point: Some("fs"),
|
||||
compilation_options: Default::default(),
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format: wgpu::TextureFormat::Rgba8Unorm,
|
||||
blend: None,
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
}),
|
||||
primitive: wgpu::PrimitiveState::default(),
|
||||
depth_stencil: None,
|
||||
multisample: wgpu::MultisampleState::default(),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
/// 15 storage + 15 uniform = 30 combined in a single BGL.
|
||||
/// Must fail at BGL creation since the combined limit is 29.
|
||||
#[gpu_test]
|
||||
static BUFFERS_AND_ACCEL_STRUCTS_EXCEEDS_SINGLE_BGL: GpuTestConfiguration =
|
||||
GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.limits(metal_limits())
|
||||
.skip(skip_non_metal()),
|
||||
)
|
||||
.run_sync(|ctx| {
|
||||
let mut entries = storage_entries(15, wgpu::ShaderStages::COMPUTE);
|
||||
entries.extend(uniform_entries(15, 15, wgpu::ShaderStages::COMPUTE));
|
||||
|
||||
fail(
|
||||
&ctx.device,
|
||||
|| {
|
||||
let _ = ctx
|
||||
.device
|
||||
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: None,
|
||||
entries: &entries,
|
||||
});
|
||||
},
|
||||
Some("max_buffers_and_acceleration_structures_per_shader_stage"),
|
||||
);
|
||||
});
|
||||
|
||||
/// Two BGLs where one has 15 storage buffers and the other has 15 uniform
|
||||
/// buffers. Each individual BGL is within the combined limit, and neither
|
||||
/// per-type limit is exceeded across both BGLs. However their combined use
|
||||
/// in a pipeline layout adds up to 30 total buffer slots, exceeding the limit.
|
||||
#[gpu_test]
|
||||
static BUFFERS_AND_ACCEL_STRUCTS_EXCEEDS_ACROSS_BGLS: GpuTestConfiguration =
|
||||
GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.limits(metal_limits())
|
||||
.skip(skip_non_metal()),
|
||||
)
|
||||
.run_sync(|ctx| {
|
||||
let storage = storage_entries(15, wgpu::ShaderStages::COMPUTE);
|
||||
let uniform = uniform_entries(15, 0, wgpu::ShaderStages::COMPUTE);
|
||||
|
||||
let bgl_a = ctx
|
||||
.device
|
||||
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: Some("bgl_a"),
|
||||
entries: &storage,
|
||||
});
|
||||
let bgl_b = ctx
|
||||
.device
|
||||
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: Some("bgl_b"),
|
||||
entries: &uniform,
|
||||
});
|
||||
|
||||
fail(
|
||||
&ctx.device,
|
||||
|| {
|
||||
let _ = ctx
|
||||
.device
|
||||
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[Some(&bgl_a), Some(&bgl_b)],
|
||||
immediate_size: 0,
|
||||
});
|
||||
},
|
||||
Some("max_buffers_and_acceleration_structures_per_shader_stage"),
|
||||
);
|
||||
});
|
||||
|
||||
/// 20 storage buffers + 10 vertex buffers = 30 combined in the vertex stage,
|
||||
/// which exceeds the limit of 29. Render pipeline creation must fail.
|
||||
#[gpu_test]
|
||||
static BUFFERS_AND_ACCEL_STRUCTS_VERTEX_STAGE_EXCEEDS_WITH_VERTEX_BUFFERS: GpuTestConfiguration =
|
||||
GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.limits(metal_limits())
|
||||
.skip(skip_non_metal()),
|
||||
)
|
||||
.run_sync(|ctx| {
|
||||
let entries = storage_entries(20, wgpu::ShaderStages::VERTEX);
|
||||
|
||||
let bgl = ctx
|
||||
.device
|
||||
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: None,
|
||||
entries: &entries,
|
||||
});
|
||||
let pipeline_layout =
|
||||
ctx.device
|
||||
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[Some(&bgl)],
|
||||
immediate_size: 0,
|
||||
});
|
||||
|
||||
let shader = ctx
|
||||
.device
|
||||
.create_shader_module(wgpu::ShaderModuleDescriptor {
|
||||
label: None,
|
||||
source: wgpu::ShaderSource::Wgsl(
|
||||
"@vertex fn vs() -> @builtin(position) vec4f { return vec4f(0.0); }
|
||||
@fragment fn fs() -> @location(0) vec4f { return vec4f(0.0); }"
|
||||
.into(),
|
||||
),
|
||||
});
|
||||
|
||||
const EMPTY_VB: Option<wgpu::VertexBufferLayout<'static>> =
|
||||
Some(wgpu::VertexBufferLayout {
|
||||
array_stride: 4,
|
||||
step_mode: wgpu::VertexStepMode::Vertex,
|
||||
attributes: &[],
|
||||
});
|
||||
|
||||
fail(
|
||||
&ctx.device,
|
||||
|| {
|
||||
let _ = ctx
|
||||
.device
|
||||
.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: None,
|
||||
layout: Some(&pipeline_layout),
|
||||
vertex: wgpu::VertexState {
|
||||
module: &shader,
|
||||
entry_point: Some("vs"),
|
||||
compilation_options: Default::default(),
|
||||
buffers: &[EMPTY_VB; 10],
|
||||
},
|
||||
fragment: Some(wgpu::FragmentState {
|
||||
module: &shader,
|
||||
entry_point: Some("fs"),
|
||||
compilation_options: Default::default(),
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format: wgpu::TextureFormat::Rgba8Unorm,
|
||||
blend: None,
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
}),
|
||||
primitive: wgpu::PrimitiveState::default(),
|
||||
depth_stencil: None,
|
||||
multisample: wgpu::MultisampleState::default(),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
},
|
||||
Some("vertex-stage buffers and acceleration structures"),
|
||||
);
|
||||
});
|
||||
@@ -20,6 +20,7 @@ mod bind_groups;
|
||||
mod binding_array;
|
||||
mod buffer;
|
||||
mod buffer_copy;
|
||||
mod buffer_resource_limits;
|
||||
mod buffer_usages;
|
||||
mod clear_texture;
|
||||
mod clip_distances;
|
||||
@@ -90,6 +91,7 @@ fn all_tests() -> Vec<wgpu_test::GpuTestInitializer> {
|
||||
|
||||
adapter::all_tests(&mut tests);
|
||||
bgra8unorm_storage::all_tests(&mut tests);
|
||||
buffer_resource_limits::all_tests(&mut tests);
|
||||
bind_group_layout_dedup::all_tests(&mut tests);
|
||||
bind_groups::all_tests(&mut tests);
|
||||
binding_array::all_tests(&mut tests);
|
||||
|
||||
@@ -334,6 +334,7 @@ pub enum BindingTypeMaxCountErrorKind {
|
||||
BindingArraySamplerElements,
|
||||
BindingArrayAccelerationStructureElements,
|
||||
AccelerationStructures,
|
||||
BuffersAndAccelerationStructures,
|
||||
}
|
||||
|
||||
impl BindingTypeMaxCountErrorKind {
|
||||
@@ -366,6 +367,9 @@ impl BindingTypeMaxCountErrorKind {
|
||||
BindingTypeMaxCountErrorKind::AccelerationStructures => {
|
||||
"max_acceleration_structures_per_shader_stage"
|
||||
}
|
||||
BindingTypeMaxCountErrorKind::BuffersAndAccelerationStructures => {
|
||||
"max_buffers_and_acceleration_structures_per_shader_stage"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -534,7 +538,11 @@ impl BindingTypeMaxCountValidator {
|
||||
.merge(&other.binding_array_acceleration_structure_elements);
|
||||
}
|
||||
|
||||
pub(crate) fn validate(&self, limits: &wgt::Limits) -> Result<(), BindingTypeMaxCountError> {
|
||||
pub(crate) fn validate(
|
||||
&self,
|
||||
limits: &wgt::Limits,
|
||||
instance_flags: wgt::InstanceFlags,
|
||||
) -> Result<(), BindingTypeMaxCountError> {
|
||||
if limits.max_dynamic_uniform_buffers_per_pipeline_layout < self.dynamic_uniform_buffers {
|
||||
return Err(BindingTypeMaxCountError {
|
||||
kind: BindingTypeMaxCountErrorKind::DynamicUniformBuffers,
|
||||
@@ -588,9 +596,29 @@ impl BindingTypeMaxCountValidator {
|
||||
limits.max_acceleration_structures_per_shader_stage,
|
||||
BindingTypeMaxCountErrorKind::AccelerationStructures,
|
||||
)?;
|
||||
|
||||
if !instance_flags.contains(wgt::InstanceFlags::STRICT_WEBGPU_COMPLIANCE) {
|
||||
self.buffers_and_acceleration_structures().validate(
|
||||
limits.max_buffers_and_acceleration_structures_per_shader_stage,
|
||||
BindingTypeMaxCountErrorKind::BuffersAndAccelerationStructures,
|
||||
)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn buffers_and_acceleration_structures(&self) -> PerStageBindingTypeCounter {
|
||||
let mut buffers_and_acceleration_structures = PerStageBindingTypeCounter::default();
|
||||
buffers_and_acceleration_structures.merge(&self.uniform_buffers);
|
||||
buffers_and_acceleration_structures.merge(&self.storage_buffers);
|
||||
buffers_and_acceleration_structures.merge(&self.acceleration_structures);
|
||||
buffers_and_acceleration_structures
|
||||
}
|
||||
|
||||
pub(crate) fn buffers_and_acceleration_structures_in_vertex_stage(&self) -> u32 {
|
||||
self.buffers_and_acceleration_structures().vertex.0
|
||||
}
|
||||
|
||||
/// Validate that the bind group layout does not contain both a binding array and a dynamic offset array.
|
||||
///
|
||||
/// This allows us to use `UPDATE_AFTER_BIND` on vulkan for bindless arrays. Vulkan does not allow
|
||||
@@ -1005,6 +1033,7 @@ pub struct PipelineLayout {
|
||||
pub(crate) label: String,
|
||||
pub(crate) bind_group_layouts: ArrayVec<Option<Arc<BindGroupLayout>>, { hal::MAX_BIND_GROUPS }>,
|
||||
pub(crate) immediate_size: u32,
|
||||
pub(crate) buffers_and_acceleration_structures_in_vertex_stage: u32,
|
||||
}
|
||||
|
||||
impl Drop for PipelineLayout {
|
||||
@@ -1111,6 +1140,7 @@ impl PipelineLayout {
|
||||
label,
|
||||
bind_group_layouts: ArrayVec::new(),
|
||||
immediate_size: 0,
|
||||
buffers_and_acceleration_structures_in_vertex_stage: 0,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2952,7 +2952,7 @@ impl Device {
|
||||
// If a single bind group layout violates limits, the pipeline layout is
|
||||
// definitely going to violate limits too, lets catch it now.
|
||||
count_validator
|
||||
.validate(&self.limits)
|
||||
.validate(&self.limits, self.instance_flags)
|
||||
.map_err(CreateBindGroupLayoutError::TooManyBindings)?;
|
||||
|
||||
// Validate that binding arrays don't conflict with dynamic offsets.
|
||||
@@ -3902,9 +3902,12 @@ impl Device {
|
||||
}
|
||||
|
||||
count_validator
|
||||
.validate(&self.limits)
|
||||
.validate(&self.limits, self.instance_flags)
|
||||
.map_err(Error::TooManyBindings)?;
|
||||
|
||||
let buffers_and_acceleration_structures_in_vertex_stage =
|
||||
count_validator.buffers_and_acceleration_structures_in_vertex_stage();
|
||||
|
||||
let get_bgl_iter = || {
|
||||
desc.bind_group_layouts
|
||||
.iter()
|
||||
@@ -3945,6 +3948,7 @@ impl Device {
|
||||
label: desc.label.to_string(),
|
||||
bind_group_layouts,
|
||||
immediate_size: desc.immediate_size,
|
||||
buffers_and_acceleration_structures_in_vertex_stage,
|
||||
};
|
||||
|
||||
let layout = Arc::new(layout);
|
||||
@@ -4900,6 +4904,26 @@ impl Device {
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
let given = pipeline_layout
|
||||
.buffers_and_acceleration_structures_in_vertex_stage
|
||||
.saturating_add(vertex.buffers.len() as u32);
|
||||
if !self
|
||||
.instance_flags
|
||||
.contains(wgt::InstanceFlags::STRICT_WEBGPU_COMPLIANCE)
|
||||
{
|
||||
let limit = self
|
||||
.limits
|
||||
.max_buffers_and_acceleration_structures_per_shader_stage;
|
||||
if given > limit {
|
||||
return Err(
|
||||
pipeline::CreateRenderPipelineError::TooManyBuffersAndAccelerationStructuresInVertexStage {
|
||||
given,
|
||||
limit,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Multiview is only supported if the feature is enabled
|
||||
|
||||
@@ -362,6 +362,7 @@ const BUCKET_M1: Bucket = Bucket {
|
||||
max_dynamic_uniform_buffers_per_pipeline_layout: 12,
|
||||
max_sampled_textures_per_shader_stage: 48,
|
||||
max_storage_buffer_binding_size: 1 << 30, // 1 GB,
|
||||
max_storage_buffers_per_shader_stage: 9,
|
||||
max_vertex_attributes: 31,
|
||||
..UPLEVEL.limits
|
||||
},
|
||||
|
||||
@@ -772,6 +772,8 @@ pub enum CreateRenderPipelineError {
|
||||
TooManyVertexBuffers { given: u32, limit: u32 },
|
||||
#[error("The number of bind groups + vertex buffers {given} exceeds the limit {limit}")]
|
||||
TooManyBindGroupsPlusVertexBuffers { given: u32, limit: u32 },
|
||||
#[error("The number of vertex-stage buffers and acceleration structures {given} exceeds the limit {limit}")]
|
||||
TooManyBuffersAndAccelerationStructuresInVertexStage { given: u32, limit: u32 },
|
||||
#[error("The total number of vertex attributes {given} exceeds the limit {limit}")]
|
||||
TooManyVertexAttributes { given: u32, limit: u32 },
|
||||
#[error("Vertex attribute location {given} must be less than limit {limit}")]
|
||||
@@ -853,6 +855,7 @@ impl WebGpuError for CreateRenderPipelineError {
|
||||
| Self::InvalidSampleCount(_)
|
||||
| Self::TooManyVertexBuffers { .. }
|
||||
| Self::TooManyBindGroupsPlusVertexBuffers { .. }
|
||||
| Self::TooManyBuffersAndAccelerationStructuresInVertexStage { .. }
|
||||
| Self::TooManyVertexAttributes { .. }
|
||||
| Self::VertexAttributeLocationTooLarge { .. }
|
||||
| Self::VertexStrideTooLarge { .. }
|
||||
|
||||
@@ -1013,6 +1013,7 @@ impl super::Adapter {
|
||||
0
|
||||
},
|
||||
max_acceleration_structures_per_shader_stage,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: u32::MAX,
|
||||
max_binding_array_acceleration_structure_elements_per_shader_stage:
|
||||
max_acceleration_structures_per_shader_stage,
|
||||
max_multiview_view_count,
|
||||
|
||||
@@ -904,6 +904,7 @@ impl super::Adapter {
|
||||
max_blas_geometry_count: 0,
|
||||
max_tlas_instance_count: 0,
|
||||
max_acceleration_structures_per_shader_stage: 0,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: u32::MAX,
|
||||
|
||||
max_multiview_view_count: 0,
|
||||
|
||||
|
||||
@@ -47,22 +47,11 @@ fn device_class_responds_to(device: &ProtocolObject<dyn MTLDevice>, sel: Sel) ->
|
||||
/// [new command buffer]: https://developer.apple.com/documentation/metal/mtlcommandqueue/makecommandbuffer()?language=objc
|
||||
pub(super) const MAX_COMMAND_BUFFERS: usize = 4096;
|
||||
|
||||
// Metal has a single buffer limit that we must split across 3 WebGPU limits:
|
||||
// The Metal limit is: 31 "Maximum number of entries in the buffer argument table, per graphics or kernel function".
|
||||
// We must split it across:
|
||||
// - maxStorageBuffersPerShaderStage; must be at least 8
|
||||
// - maxUniformBuffersPerShaderStage; must be at least 12
|
||||
// - maxVertexBuffers; must be at least 8
|
||||
// We require 2 additional internal buffers:
|
||||
// - one for immediate data
|
||||
// - one for sizes of other buffers
|
||||
// We use the last buffer for an acceleration structure.
|
||||
const MAX_STORAGE_BUFFERS_PER_SHADER_STAGE: u32 = 8;
|
||||
const MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE: u32 = 12;
|
||||
const MAX_VERTEX_BUFFERS: u32 = 8;
|
||||
const MAX_ACCELERATION_STRUCTURES_PER_SHADER_STAGE: u32 = 1;
|
||||
// Use the end of the range for vertex buffers.
|
||||
pub const VERTEX_BUFFER_SLOT_START: u32 = 31 - 8;
|
||||
/// "Maximum number of entries in the buffer argument table, per graphics or kernel function"
|
||||
///
|
||||
/// Vertex buffers are placed at the end of the table (highest indices),
|
||||
/// counting down from MAX_BUFFERS - 1.
|
||||
pub const MAX_BUFFERS: u32 = 31;
|
||||
|
||||
impl super::Adapter {
|
||||
pub(super) fn new(shared: Arc<super::AdapterShared>) -> Self {
|
||||
@@ -1341,7 +1330,7 @@ impl super::CapabilitiesQuery {
|
||||
features
|
||||
}
|
||||
|
||||
pub fn capabilities(&self) -> crate::Capabilities {
|
||||
pub fn capabilities(&self, instance_flags: wgt::InstanceFlags) -> crate::Capabilities {
|
||||
let mut downlevel = wgt::DownlevelCapabilities::default();
|
||||
downlevel.flags.set(
|
||||
wgt::DownlevelFlags::FRAGMENT_WRITABLE_STORAGE,
|
||||
@@ -1378,6 +1367,34 @@ impl super::CapabilitiesQuery {
|
||||
self.format_bc || (self.format_eac_etc && self.format_astc),
|
||||
);
|
||||
|
||||
let max_storage_buffers_per_shader_stage;
|
||||
let max_uniform_buffers_per_shader_stage;
|
||||
let max_vertex_buffers;
|
||||
let max_acceleration_structures_per_shader_stage;
|
||||
let max_buffers_and_acceleration_structures_per_shader_stage;
|
||||
|
||||
// Metal has a single buffer limit that we must split across 3 WebGPU limits:
|
||||
// - maxStorageBuffersPerShaderStage; must be at least 8
|
||||
// - maxUniformBuffersPerShaderStage; must be at least 12
|
||||
// - maxVertexBuffers; must be at least 8
|
||||
// We also have to reserve 2 additional internal buffers:
|
||||
// - one for immediate data
|
||||
// - one for sizes of other buffers
|
||||
if instance_flags.contains(wgt::InstanceFlags::STRICT_WEBGPU_COMPLIANCE) {
|
||||
max_storage_buffers_per_shader_stage = 9;
|
||||
max_uniform_buffers_per_shader_stage = 12;
|
||||
max_vertex_buffers = 8;
|
||||
max_acceleration_structures_per_shader_stage = 0;
|
||||
max_buffers_and_acceleration_structures_per_shader_stage = u32::MAX;
|
||||
} else {
|
||||
const MAX_USABLE_BUFFERS: u32 = MAX_BUFFERS - 2;
|
||||
max_storage_buffers_per_shader_stage = MAX_USABLE_BUFFERS;
|
||||
max_uniform_buffers_per_shader_stage = MAX_USABLE_BUFFERS;
|
||||
max_vertex_buffers = MAX_USABLE_BUFFERS;
|
||||
max_acceleration_structures_per_shader_stage = MAX_USABLE_BUFFERS;
|
||||
max_buffers_and_acceleration_structures_per_shader_stage = MAX_USABLE_BUFFERS;
|
||||
}
|
||||
|
||||
let limits = crate::auxil::adjust_raw_limits(wgt::Limits {
|
||||
//
|
||||
// WebGPU LIMITS:
|
||||
@@ -1394,16 +1411,16 @@ impl super::CapabilitiesQuery {
|
||||
// No limit.
|
||||
max_bindings_per_bind_group: u32::MAX,
|
||||
// No limit, use maxUniformBuffersPerShaderStage.
|
||||
max_dynamic_uniform_buffers_per_pipeline_layout: MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE,
|
||||
max_dynamic_uniform_buffers_per_pipeline_layout: max_uniform_buffers_per_shader_stage,
|
||||
// No limit, use maxStorageBuffersPerShaderStage.
|
||||
max_dynamic_storage_buffers_per_pipeline_layout: MAX_STORAGE_BUFFERS_PER_SHADER_STAGE,
|
||||
max_dynamic_storage_buffers_per_pipeline_layout: max_storage_buffers_per_shader_stage,
|
||||
// "Maximum number of entries in the sampler state argument table, per graphics or kernel function"
|
||||
max_samplers_per_shader_stage: 16,
|
||||
max_sampled_textures_per_shader_stage: self.max_textures_per_stage.0,
|
||||
max_storage_textures_per_shader_stage: self.max_textures_per_stage.1,
|
||||
max_storage_buffers_per_shader_stage: MAX_STORAGE_BUFFERS_PER_SHADER_STAGE,
|
||||
max_uniform_buffers_per_shader_stage: MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE,
|
||||
max_vertex_buffers: MAX_VERTEX_BUFFERS,
|
||||
max_storage_buffers_per_shader_stage,
|
||||
max_uniform_buffers_per_shader_stage,
|
||||
max_vertex_buffers,
|
||||
max_buffer_size: self.max_buffer_size,
|
||||
// No limit, use maxBufferSize.
|
||||
max_uniform_buffer_binding_size: self.max_buffer_size,
|
||||
@@ -1445,8 +1462,8 @@ impl super::CapabilitiesQuery {
|
||||
// From 2.17.7 in https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
|
||||
// > [Acceleration structures] are opaque objects that can be bound directly using
|
||||
// buffer binding points or via argument buffers
|
||||
max_acceleration_structures_per_shader_stage:
|
||||
MAX_ACCELERATION_STRUCTURES_PER_SHADER_STAGE,
|
||||
max_acceleration_structures_per_shader_stage,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage,
|
||||
|
||||
max_multiview_view_count: if self.supported_vertex_amplification_factor > 1 {
|
||||
self.supported_vertex_amplification_factor
|
||||
|
||||
@@ -14,7 +14,7 @@ use objc2_metal::{
|
||||
};
|
||||
|
||||
use super::{
|
||||
adapter::{self, VERTEX_BUFFER_SLOT_START},
|
||||
adapter::{self, MAX_BUFFERS},
|
||||
conv, TimestampQuerySupport,
|
||||
};
|
||||
use crate::CommandEncoder as _;
|
||||
@@ -1411,7 +1411,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
|
||||
index: u32,
|
||||
binding: crate::BufferBinding<'a, super::Buffer>,
|
||||
) {
|
||||
let buffer_index = VERTEX_BUFFER_SLOT_START + index;
|
||||
let buffer_index = MAX_BUFFERS - 1 - index;
|
||||
let encoder = self.state.render.as_ref().unwrap();
|
||||
unsafe {
|
||||
encoder.setVertexBuffer_offset_atIndex(
|
||||
|
||||
@@ -24,7 +24,7 @@ use objc2_metal::{
|
||||
};
|
||||
use parking_lot::{Condvar, Mutex, RwLock};
|
||||
|
||||
use super::{adapter::VERTEX_BUFFER_SLOT_START, conv, PassthroughShader, ShaderModuleSource};
|
||||
use super::{adapter::MAX_BUFFERS, conv, PassthroughShader, ShaderModuleSource};
|
||||
use crate::{auxil::map_naga_stage, DropCallback, DropGuard, TlasInstance};
|
||||
|
||||
type DeviceResult<T> = Result<T, crate::DeviceError>;
|
||||
@@ -1423,7 +1423,7 @@ impl crate::Device for super::Device {
|
||||
}
|
||||
|
||||
let mapping = naga::back::msl::VertexBufferMapping {
|
||||
id: VERTEX_BUFFER_SLOT_START + i as u32,
|
||||
id: MAX_BUFFERS - 1 - i as u32,
|
||||
stride: if vbl.array_stride > 0 {
|
||||
vbl.array_stride.try_into().unwrap()
|
||||
} else {
|
||||
@@ -1491,7 +1491,7 @@ impl crate::Device for super::Device {
|
||||
continue;
|
||||
};
|
||||
|
||||
let buffer_index = VERTEX_BUFFER_SLOT_START as usize + i;
|
||||
let buffer_index = MAX_BUFFERS as usize - 1 - i;
|
||||
let buffer_desc = unsafe {
|
||||
vertex_descriptor
|
||||
.layouts()
|
||||
|
||||
@@ -137,7 +137,9 @@ impl OsFeatures {
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Instance {}
|
||||
pub struct Instance {
|
||||
flags: wgt::InstanceFlags,
|
||||
}
|
||||
|
||||
impl Instance {
|
||||
pub fn create_surface_from_layer(&self, layer: &CAMetalLayer) -> Surface {
|
||||
@@ -148,11 +150,11 @@ impl Instance {
|
||||
impl crate::Instance for Instance {
|
||||
type A = Api;
|
||||
|
||||
unsafe fn init(_desc: &crate::InstanceDescriptor<'_>) -> Result<Self, crate::InstanceError> {
|
||||
unsafe fn init(desc: &crate::InstanceDescriptor<'_>) -> Result<Self, crate::InstanceError> {
|
||||
profiling::scope!("Init Metal Backend");
|
||||
// We do not enable metal validation based on the validation flags as it affects the entire
|
||||
// process. Instead, we enable the validation inside the test harness itself in tests/src/native.rs.
|
||||
Ok(Instance {})
|
||||
Ok(Instance { flags: desc.flags })
|
||||
}
|
||||
|
||||
unsafe fn create_surface(
|
||||
@@ -190,8 +192,11 @@ impl crate::Instance for Instance {
|
||||
_surface_hint: Option<&Surface>,
|
||||
) -> Vec<crate::ExposedAdapter<Api>> {
|
||||
let devices = objc2_metal::MTLCopyAllDevices();
|
||||
let mut adapters: Vec<crate::ExposedAdapter<Api>> =
|
||||
devices.into_iter().map(AdapterShared::expose).collect();
|
||||
let instance_flags = self.flags;
|
||||
let mut adapters: Vec<crate::ExposedAdapter<Api>> = devices
|
||||
.into_iter()
|
||||
.map(|d| AdapterShared::expose(d, instance_flags))
|
||||
.collect();
|
||||
adapters.sort_by_key(|ad| {
|
||||
(
|
||||
ad.adapter.shared.private_caps.low_power,
|
||||
@@ -420,13 +425,16 @@ impl AdapterShared {
|
||||
}
|
||||
}
|
||||
|
||||
fn expose(device: Retained<ProtocolObject<dyn MTLDevice>>) -> crate::ExposedAdapter<Api> {
|
||||
fn expose(
|
||||
device: Retained<ProtocolObject<dyn MTLDevice>>,
|
||||
instance_flags: wgt::InstanceFlags,
|
||||
) -> crate::ExposedAdapter<Api> {
|
||||
autoreleasepool(|_| {
|
||||
let name = device.name().to_string();
|
||||
let capabilities_query = CapabilitiesQuery::new(&device);
|
||||
let shared = AdapterShared::new(device, &capabilities_query);
|
||||
let features = capabilities_query.features();
|
||||
let capabilities = capabilities_query.capabilities();
|
||||
let capabilities = capabilities_query.capabilities(instance_flags);
|
||||
crate::ExposedAdapter {
|
||||
info: wgt::AdapterInfo {
|
||||
name,
|
||||
|
||||
@@ -1780,6 +1780,7 @@ impl PhysicalDeviceProperties {
|
||||
max_blas_geometry_count,
|
||||
max_tlas_instance_count,
|
||||
max_acceleration_structures_per_shader_stage,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: u32::MAX,
|
||||
|
||||
max_multiview_view_count,
|
||||
|
||||
|
||||
@@ -201,6 +201,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
|
||||
max_blas_geometry_count,
|
||||
max_tlas_instance_count,
|
||||
max_acceleration_structures_per_shader_stage,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage,
|
||||
|
||||
max_multiview_view_count,
|
||||
|
||||
@@ -262,6 +263,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
|
||||
writeln!(output, "\t\t Max BLAS Geometry count: {max_blas_geometry_count}")?;
|
||||
writeln!(output, "\t\t Max TLAS Instance count: {max_tlas_instance_count}")?;
|
||||
writeln!(output, "\t\t Max Acceleration Structures Per Shader Stage: {max_acceleration_structures_per_shader_stage}")?;
|
||||
writeln!(output, " Max Buffers And Acceleration Structures Per Shader Stage: {max_buffers_and_acceleration_structures_per_shader_stage}")?;
|
||||
|
||||
writeln!(output, "\t\t Max Multiview View Count: {max_multiview_view_count}")?;
|
||||
writeln!(output, "\t\t Max Ray Dispatch Count: {max_ray_dispatch_count}")?;
|
||||
|
||||
@@ -87,6 +87,10 @@ macro_rules! with_limits {
|
||||
$macro_name!(max_blas_geometry_count, Ordering::Less);
|
||||
$macro_name!(max_tlas_instance_count, Ordering::Less);
|
||||
$macro_name!(max_acceleration_structures_per_shader_stage, Ordering::Less);
|
||||
$macro_name!(
|
||||
max_buffers_and_acceleration_structures_per_shader_stage,
|
||||
Ordering::Less
|
||||
);
|
||||
|
||||
$macro_name!(max_multiview_view_count, Ordering::Less);
|
||||
|
||||
@@ -316,6 +320,9 @@ pub struct Limits {
|
||||
/// Requesting more than 0 during device creation only makes sense if [`Features::EXPERIMENTAL_RAY_QUERY`]
|
||||
/// is enabled.
|
||||
pub max_acceleration_structures_per_shader_stage: u32,
|
||||
/// The combined number of buffers (storage and uniform), vertex buffers, and acceleration
|
||||
/// structures that can be bound in a single shader stage.
|
||||
pub max_buffers_and_acceleration_structures_per_shader_stage: u32,
|
||||
|
||||
/// The maximum number of views that can be used in multiview rendering
|
||||
pub max_multiview_view_count: u32,
|
||||
@@ -401,6 +408,7 @@ impl Limits {
|
||||
/// max_blas_geometry_count: 0,
|
||||
/// max_tlas_instance_count: 0,
|
||||
/// max_acceleration_structures_per_shader_stage: 0,
|
||||
/// max_buffers_and_acceleration_structures_per_shader_stage: 28, // sum of storage buffers, uniform buffers and vertex buffers limits
|
||||
/// max_multiview_view_count: 0,
|
||||
/// max_ray_dispatch_count: 0,
|
||||
/// max_ray_recursion_depth: 0,
|
||||
@@ -467,6 +475,7 @@ impl Limits {
|
||||
max_blas_geometry_count: 0,
|
||||
max_tlas_instance_count: 0,
|
||||
max_acceleration_structures_per_shader_stage: 0,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: 28,
|
||||
|
||||
max_multiview_view_count: 0,
|
||||
|
||||
@@ -536,6 +545,7 @@ impl Limits {
|
||||
/// max_blas_geometry_count: 0,
|
||||
/// max_tlas_instance_count: 0,
|
||||
/// max_acceleration_structures_per_shader_stage: 0,
|
||||
/// max_buffers_and_acceleration_structures_per_shader_stage: 24, // * sum of storage buffers, uniform buffers and vertex buffers limits
|
||||
///
|
||||
/// max_multiview_view_count: 0,
|
||||
///
|
||||
@@ -555,6 +565,7 @@ impl Limits {
|
||||
max_color_attachments: 4,
|
||||
// see: https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf#page=7
|
||||
max_compute_workgroup_storage_size: 16352,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: 24,
|
||||
..Self::defaults()
|
||||
}
|
||||
}
|
||||
@@ -621,6 +632,7 @@ impl Limits {
|
||||
/// max_blas_geometry_count: 0,
|
||||
/// max_tlas_instance_count: 0,
|
||||
/// max_acceleration_structures_per_shader_stage: 0,
|
||||
/// max_buffers_and_acceleration_structures_per_shader_stage: 19, // * sum of storage buffers, uniform buffers and vertex buffers limits
|
||||
///
|
||||
/// max_multiview_view_count: 0,
|
||||
///
|
||||
@@ -647,6 +659,8 @@ impl Limits {
|
||||
// Value supported by Intel Celeron B830 on Windows (OpenGL 3.1)
|
||||
max_inter_stage_shader_variables: 15,
|
||||
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: 19,
|
||||
|
||||
// Most of the values should be the same as the downlevel defaults
|
||||
..Self::downlevel_defaults()
|
||||
}
|
||||
@@ -722,6 +736,7 @@ impl Limits {
|
||||
max_blas_geometry_count: ALLOC_MAX_U32,
|
||||
max_tlas_instance_count: ALLOC_MAX_U32,
|
||||
max_acceleration_structures_per_shader_stage: ALLOC_MAX_U32,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: ALLOC_MAX_U32,
|
||||
|
||||
max_multiview_view_count: ALLOC_MAX_U32,
|
||||
max_ray_dispatch_count: ALLOC_MAX_U32,
|
||||
@@ -765,6 +780,7 @@ impl Limits {
|
||||
max_blas_primitive_count: 1 << 28, // 2^28: Metal's minimum
|
||||
// On metal acceleration structures are limited because they share buffer slots
|
||||
max_acceleration_structures_per_shader_stage: 1,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: 29,
|
||||
..self
|
||||
}
|
||||
}
|
||||
@@ -779,6 +795,8 @@ impl Limits {
|
||||
max_blas_primitive_count: other.max_blas_primitive_count,
|
||||
max_acceleration_structures_per_shader_stage: other
|
||||
.max_acceleration_structures_per_shader_stage,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: other
|
||||
.max_buffers_and_acceleration_structures_per_shader_stage,
|
||||
..self
|
||||
}
|
||||
}
|
||||
|
||||
@@ -907,6 +907,8 @@ fn map_wgt_limits(limits: webgpu_sys::GpuSupportedLimits) -> wgt::Limits {
|
||||
max_tlas_instance_count: wgt::Limits::default().max_tlas_instance_count,
|
||||
max_acceleration_structures_per_shader_stage: wgt::Limits::default()
|
||||
.max_acceleration_structures_per_shader_stage,
|
||||
max_buffers_and_acceleration_structures_per_shader_stage: wgt::Limits::default()
|
||||
.max_buffers_and_acceleration_structures_per_shader_stage,
|
||||
|
||||
max_multiview_view_count: wgt::Limits::default().max_multiview_view_count,
|
||||
|
||||
|
||||
Reference in new issue
Block a user