From ce7dad30260e3ff6fe26acef948e1a9fc954e02f Mon Sep 17 00:00:00 2001 From: Genna Wingert <1058083+wingertge@users.noreply.github.com> Date: Tue, 3 Mar 2026 18:01:54 +0100 Subject: [PATCH] fix: Change type of `max_*_buffer_binding_size` to follow spec --- CHANGELOG.md | 1 + deno_webgpu/adapter.rs | 6 ++++-- tests/tests/wgpu-gpu/device.rs | 2 +- wgpu-core/src/binding_model.rs | 4 ++-- wgpu-core/src/device/resource.rs | 4 ++-- wgpu-core/src/indirect_validation/draw.rs | 22 +++++++++----------- wgpu-core/src/timestamp_normalization/mod.rs | 2 +- wgpu-hal/src/auxil/mod.rs | 2 +- wgpu-hal/src/dx12/adapter.rs | 4 ++-- wgpu-hal/src/gles/adapter.rs | 4 ++-- wgpu-hal/src/metal/adapter.rs | 6 +++--- wgpu-hal/src/noop/mod.rs | 4 ++-- wgpu-hal/src/vulkan/adapter.rs | 6 ++++-- wgpu-types/src/limits.rs | 4 ++-- wgpu/src/backend/webgpu.rs | 4 ++-- 15 files changed, 39 insertions(+), 36 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1196a875e..4f6b88e03 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -167,6 +167,7 @@ depth_stencil: Some(wgpu::DepthStencilState::stencil( - Removed the `NegativeRange` variant in favor of new `MapStartOffsetUnderrun` and `MapStartOffsetOverrun` variants. - Split the `TransferError::BufferOverrun` variant into new `BufferStartOffsetOverrun` and `BufferEndOffsetOverrun` variants. - The various "max resources per stage" limits are now capped at 100, so that their total remains below `max_bindings_per_bind_group`, as required by WebGPU. By @andyleiserson in [#9118](https://github.com/gfx-rs/wgpu/pull/9118). +- The `max_uniform_buffer_binding_size` and `max_storage_buffer_binding_size` limits are now `u64` instead of `u32`, to match WebGPU. By @wingertge in [#9146](https://github.com/gfx-rs/wgpu/pull/9146). #### Metal diff --git a/deno_webgpu/adapter.rs b/deno_webgpu/adapter.rs index 3e0e2b2cb..9fc76089f 100644 --- a/deno_webgpu/adapter.rs +++ b/deno_webgpu/adapter.rs @@ -375,12 +375,14 @@ impl GPUSupportedLimits { } #[getter] - fn maxUniformBufferBindingSize(&self) -> u32 { + #[number] + fn maxUniformBufferBindingSize(&self) -> u64 { self.0.max_uniform_buffer_binding_size } #[getter] - fn maxStorageBufferBindingSize(&self) -> u32 { + #[number] + fn maxStorageBufferBindingSize(&self) -> u64 { self.0.max_storage_buffer_binding_size } diff --git a/tests/tests/wgpu-gpu/device.rs b/tests/tests/wgpu-gpu/device.rs index ca8c7cd21..1d76536aa 100644 --- a/tests/tests/wgpu-gpu/device.rs +++ b/tests/tests/wgpu-gpu/device.rs @@ -419,7 +419,7 @@ static DEVICE_DESTROY_THEN_MORE: GpuTestConfiguration = GpuTestConfiguration::ne ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, min_binding_size: std::num::NonZeroU64::new( - (ctx.device.limits().max_uniform_buffer_binding_size * 2) as u64, + ctx.device.limits().max_uniform_buffer_binding_size * 2, ), }, count: None, diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs index b509d397b..5d6ef973a 100644 --- a/wgpu-core/src/binding_model.rs +++ b/wgpu-core/src/binding_model.rs @@ -181,8 +181,8 @@ pub enum CreateBindGroupError { )] BufferRangeTooLarge { binding: u32, - given: u32, - limit: u32, + given: u64, + limit: u64, }, #[error("Binding {binding} has a different type ({actual:?}) than the one in the layout ({expected:?})")] WrongBindingType { diff --git a/wgpu-core/src/device/resource.rs b/wgpu-core/src/device/resource.rs index 315c7072a..dec178a5b 100644 --- a/wgpu-core/src/device/resource.rs +++ b/wgpu-core/src/device/resource.rs @@ -2895,10 +2895,10 @@ impl Device { let bind_end = bb.offset + bind_size; - if bind_size > range_limit as u64 { + if bind_size > range_limit { return Err(Error::BufferRangeTooLarge { binding, - given: bind_size as u32, + given: bind_size, limit: range_limit, }); } diff --git a/wgpu-core/src/indirect_validation/draw.rs b/wgpu-core/src/indirect_validation/draw.rs index 29473202a..71e25b2af 100644 --- a/wgpu-core/src/indirect_validation/draw.rs +++ b/wgpu-core/src/indirect_validation/draw.rs @@ -14,10 +14,7 @@ use crate::{ FastHashMap, }; use alloc::{boxed::Box, string::ToString, sync::Arc, vec, vec::Vec}; -use core::{ - mem::{size_of, size_of_val}, - num::NonZeroU64, -}; +use core::{mem::size_of, num::NonZeroU64}; use wgt::Limits; /// Note: This needs to be under: @@ -653,7 +650,7 @@ fn create_bind_group_layout( /// Returns the largest binding size that when combined with dynamic offsets can address the whole buffer. fn calculate_src_buffer_binding_size(buffer_size: u64, limits: &Limits) -> u64 { - let max_storage_buffer_binding_size = limits.max_storage_buffer_binding_size as u64; + let max_storage_buffer_binding_size = limits.max_storage_buffer_binding_size; let min_storage_buffer_offset_alignment = limits.min_storage_buffer_offset_alignment as u64; if buffer_size <= max_storage_buffer_binding_size { @@ -893,12 +890,13 @@ impl MetadataEntry { vertex_or_index_limit: u64, instance_limit: u64, ) -> Self { - debug_assert_eq!( - 4, - size_of_val(&Limits::default().max_storage_buffer_binding_size) - ); + const U32_MAX_AS_U64: u64 = u32::MAX as u64; - let src_offset = src_offset as u32; // max_storage_buffer_binding_size is a u32 + // NOTE: buffer sizes should never exceed `u32::MAX`. + assert!(src_offset <= U32_MAX_AS_U64); + assert!(dst_offset <= U32_MAX_AS_U64); + + let src_offset = src_offset as u32; let src_offset = src_offset / 4; // translate byte offset to offset in u32's // `src_offset` needs at most 30 bits, @@ -906,7 +904,7 @@ impl MetadataEntry { let src_offset = src_offset | ((indexed as u32) << 31); // max value for limits since first_X and X_count indirect draw arguments are u32 - let max_limit = u32::MAX as u64 + u32::MAX as u64; // 1 11111111 11111111 11111111 11111110 + let max_limit = U32_MAX_AS_U64 + U32_MAX_AS_U64; // 1 11111111 11111111 11111111 11111110 let vertex_or_index_limit = vertex_or_index_limit.min(max_limit); let vertex_or_index_limit_bit_32 = (vertex_or_index_limit >> 32) as u32; // extract bit 32 @@ -916,7 +914,7 @@ impl MetadataEntry { let instance_limit_bit_32 = (instance_limit >> 32) as u32; // extract bit 32 let instance_limit = instance_limit as u32; // truncate the limit to a u32 - let dst_offset = dst_offset as u32; // max_storage_buffer_binding_size is a u32 + let dst_offset = dst_offset as u32; let dst_offset = dst_offset / 4; // translate byte offset to offset in u32's // `dst_offset` needs at most 30 bits, diff --git a/wgpu-core/src/timestamp_normalization/mod.rs b/wgpu-core/src/timestamp_normalization/mod.rs index 426e14b97..e6ddbad4f 100644 --- a/wgpu-core/src/timestamp_normalization/mod.rs +++ b/wgpu-core/src/timestamp_normalization/mod.rs @@ -276,7 +276,7 @@ impl TimestampNormalizer { // at once to normalize the timestamps, we can't use it. We force the buffer to fail // to allocate. The lowest max binding size is 128MB, and query sets must be small // (no more than 4096), so this should never be hit in practice by sane programs. - if buffer_size.get() > device.adapter.limits().max_storage_buffer_binding_size as u64 { + if buffer_size.get() > device.adapter.limits().max_storage_buffer_binding_size { return Err(DeviceError::OutOfMemory); } diff --git a/wgpu-hal/src/auxil/mod.rs b/wgpu-hal/src/auxil/mod.rs index 26c37fb53..9a083e672 100644 --- a/wgpu-hal/src/auxil/mod.rs +++ b/wgpu-hal/src/auxil/mod.rs @@ -192,7 +192,7 @@ pub(crate) fn apply_hal_limits(mut limits: wgt::Limits) -> wgt::Limits { // Round some limits down to the WebGPU alignment requirement, to avoid // suggesting values that won't work. (In particular, the CTS queries limits // and then tests the exact limit value.) - limits.max_storage_buffer_binding_size &= !(wgt::STORAGE_BINDING_SIZE_ALIGNMENT - 1); + limits.max_storage_buffer_binding_size &= !(wgt::STORAGE_BINDING_SIZE_ALIGNMENT - 1) as u64; limits.max_vertex_buffer_array_stride &= !(wgt::VERTEX_ALIGNMENT as u32 - 1); limits diff --git a/wgpu-hal/src/dx12/adapter.rs b/wgpu-hal/src/dx12/adapter.rs index dcf6c8a10..41ef283e6 100644 --- a/wgpu-hal/src/dx12/adapter.rs +++ b/wgpu-hal/src/dx12/adapter.rs @@ -809,8 +809,8 @@ impl super::Adapter { max_binding_array_elements_per_shader_stage: full_heap_count, max_binding_array_sampler_elements_per_shader_stage: full_heap_count, max_uniform_buffer_binding_size: - Direct3D12::D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * 16, - max_storage_buffer_binding_size: auxil::MAX_I32_BINDING_SIZE, + Direct3D12::D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT as u64 * 16, + max_storage_buffer_binding_size: auxil::MAX_I32_BINDING_SIZE as u64, max_vertex_buffers: Direct3D12::D3D12_VS_INPUT_REGISTER_COUNT, max_vertex_attributes: Direct3D12::D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT, max_vertex_buffer_array_stride: Direct3D12::D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES, diff --git a/wgpu-hal/src/gles/adapter.rs b/wgpu-hal/src/gles/adapter.rs index c2628ae43..4746d9796 100644 --- a/wgpu-hal/src/gles/adapter.rs +++ b/wgpu-hal/src/gles/adapter.rs @@ -717,12 +717,12 @@ impl super::Adapter { max_binding_array_sampler_elements_per_shader_stage: 0, max_uniform_buffer_binding_size: unsafe { gl.get_parameter_i32(glow::MAX_UNIFORM_BLOCK_SIZE) - } as u32, + } as u64, max_storage_buffer_binding_size: if supports_storage { unsafe { gl.get_parameter_i32(glow::MAX_SHADER_STORAGE_BLOCK_SIZE) } } else { 0 - } as u32, + } as u64, max_vertex_buffers: if private_caps .contains(super::PrivateCapabilities::VERTEX_BUFFER_LAYOUT) { diff --git a/wgpu-hal/src/metal/adapter.rs b/wgpu-hal/src/metal/adapter.rs index 1a6e5d560..c14f90421 100644 --- a/wgpu-hal/src/metal/adapter.rs +++ b/wgpu-hal/src/metal/adapter.rs @@ -1179,9 +1179,9 @@ impl super::PrivateCapabilities { max_binding_array_sampler_elements_per_shader_stage: self .max_sampler_binding_array_elements, // 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) as u32, - max_storage_buffer_binding_size: self.max_buffer_size.min(!0u32 as u64) as u32 - & !(wgt::STORAGE_BINDING_SIZE_ALIGNMENT - 1), + 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) + & !(wgt::STORAGE_BINDING_SIZE_ALIGNMENT as u64 - 1), max_vertex_buffers: self.max_vertex_buffers, max_vertex_attributes: 31, max_vertex_buffer_array_stride: base.max_vertex_buffer_array_stride, diff --git a/wgpu-hal/src/noop/mod.rs b/wgpu-hal/src/noop/mod.rs index cc6fe1947..dec3b8bc5 100644 --- a/wgpu-hal/src/noop/mod.rs +++ b/wgpu-hal/src/noop/mod.rs @@ -176,8 +176,8 @@ 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_uniform_buffer_binding_size: ALLOC_MAX_U32, - max_storage_buffer_binding_size: ALLOC_MAX_U32, + max_uniform_buffer_binding_size: ALLOC_MAX_U32 as u64, + max_storage_buffer_binding_size: ALLOC_MAX_U32 as u64, max_vertex_buffers: ALLOC_MAX_U32, max_buffer_size: ALLOC_MAX_U32 as u64, max_vertex_attributes: ALLOC_MAX_U32, diff --git a/wgpu-hal/src/vulkan/adapter.rs b/wgpu-hal/src/vulkan/adapter.rs index 9406b9a8b..1a64536ed 100644 --- a/wgpu-hal/src/vulkan/adapter.rs +++ b/wgpu-hal/src/vulkan/adapter.rs @@ -1457,10 +1457,12 @@ impl PhysicalDeviceProperties { max_binding_array_sampler_elements_per_shader_stage: max_sampler_binding_array_elements, max_uniform_buffer_binding_size: limits .max_uniform_buffer_range - .min(crate::auxil::MAX_I32_BINDING_SIZE), + .min(crate::auxil::MAX_I32_BINDING_SIZE) + as u64, max_storage_buffer_binding_size: limits .max_storage_buffer_range - .min(crate::auxil::MAX_I32_BINDING_SIZE), + .min(crate::auxil::MAX_I32_BINDING_SIZE) + as u64, max_vertex_buffers: limits.max_vertex_input_bindings, max_vertex_attributes: limits.max_vertex_input_attributes, max_vertex_buffer_array_stride: limits.max_vertex_input_binding_stride, diff --git a/wgpu-types/src/limits.rs b/wgpu-types/src/limits.rs index 71c48a2b2..61b651166 100644 --- a/wgpu-types/src/limits.rs +++ b/wgpu-types/src/limits.rs @@ -160,9 +160,9 @@ pub struct Limits { /// This "defaults" to 0. However if binding arrays are supported, all devices can support 1,000. Higher is "better". pub max_binding_array_sampler_elements_per_shader_stage: u32, /// Maximum size in bytes of a binding to a uniform buffer. Defaults to 64 KiB. Higher is "better". - pub max_uniform_buffer_binding_size: u32, + pub max_uniform_buffer_binding_size: u64, /// Maximum size in bytes of a binding to a storage buffer. Defaults to 128 MiB. Higher is "better". - pub max_storage_buffer_binding_size: u32, + pub max_storage_buffer_binding_size: u64, /// Maximum length of `VertexState::buffers` when creating a `RenderPipeline`. /// Defaults to 8. Higher is "better". pub max_vertex_buffers: u32, diff --git a/wgpu/src/backend/webgpu.rs b/wgpu/src/backend/webgpu.rs index aa1ebf55f..2e60c37fe 100644 --- a/wgpu/src/backend/webgpu.rs +++ b/wgpu/src/backend/webgpu.rs @@ -804,8 +804,8 @@ 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_uniform_buffer_binding_size: limits.max_uniform_buffer_binding_size() as u32, - max_storage_buffer_binding_size: limits.max_storage_buffer_binding_size() as u32, + 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(), max_buffer_size: limits.max_buffer_size() as u64, max_vertex_attributes: limits.max_vertex_attributes(),