diff --git a/CHANGELOG.md b/CHANGELOG.md index eceb51f88..35b5105e2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -153,6 +153,10 @@ By @sagudev in [#10109](https://github.com/gfx-rs/wgpu/pull/10109). - Added `naga::valid::Capabilities::LINEAR_INTERPOLATION`, which is now required in order to use `@interpolate(linear)`. By @emilk in [#9972](https://github.com/gfx-rs/wgpu/pull/9972). - The GLSL backend's `MissingFeatures` error now names the GLSL version that lacks the features, e.g. `GLSL 300 es doesn't support the required feature(s): NOPERSPECTIVE_QUALIFIER`. By @emilk in [#9972](https://github.com/gfx-rs/wgpu/pull/9972). +#### Metal + +- Removed the `size` argument to `wgpu_hal::metal::Device::buffer_from_raw`. The passed size value was previously used only to resolve vertex buffer bindings without an explicit size, possibly incorrectly. Binding sizes are now resolved in `wgpu-core`. By @andyleiserson in [#9848](https://github.com/gfx-rs/wgpu/pull/9848). + ### Bug Fixes #### General diff --git a/tests/tests/wgpu-gpu/zero_init.rs b/tests/tests/wgpu-gpu/zero_init.rs index c16b6cf42..bebb70c58 100644 --- a/tests/tests/wgpu-gpu/zero_init.rs +++ b/tests/tests/wgpu-gpu/zero_init.rs @@ -2921,7 +2921,7 @@ async fn check_mark_externally_initialized_case(ctx: &TestingContex let hal_device = ctx.device.as_hal::().expect("adapter backend mismatch"); let hal_texture = texture.as_hal::().expect("adapter backend mismatch"); - let staging_buffer = hal_device + let (staging_buffer, _allocated_size) = hal_device .create_buffer(&hal::BufferDescriptor { label: Some("mark_externally_initialized staging"), size: buffer_size, diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs index 0df1cf0ab..a7a72d50f 100644 --- a/wgpu-core/src/binding_model.rs +++ b/wgpu-core/src/binding_model.rs @@ -120,6 +120,17 @@ pub enum BindingError { offset: wgt::BufferAddress, buffer_size: u64, }, + /// The supplied binding offset was equal to the buffer size. + /// + /// A binding offset equal to the buffer size is legal for vertex and index buffer + /// bindings, but not for storage/uniform buffer bindings, thus this error should only + /// be raised for the latter. + #[error("Buffer {buffer}: Binding offset {offset} must be strictly less than buffer size {buffer_size}")] + BindingOffsetEqualsSize { + buffer: ResourceErrorIdent, + offset: wgt::BufferAddress, + buffer_size: u64, + }, #[error("Unbinding vertex buffer at slot {slot} expects offset to be 0. However an offset of {offset} was provided.")] UnbindingVertexBufferOffsetNotZero { slot: u32, offset: u64 }, #[error("Unbinding vertex buffer at slot {slot} expects size to be 0. However a size of {size} was provided.")] @@ -132,6 +143,7 @@ impl WebGpuError for BindingError { Self::DestroyedResource(e) => e.webgpu_error_type(), Self::BindingRangeTooLarge { .. } | Self::BindingOffsetTooLarge { .. } + | Self::BindingOffsetEqualsSize { .. } | BindingError::UnbindingVertexBufferOffsetNotZero { .. } | BindingError::UnbindingVertexBufferSizeNotZero { .. } => ErrorType::Validation, } diff --git a/wgpu-core/src/command/bundle.rs b/wgpu-core/src/command/bundle.rs index 9e45d658a..4075bdc3a 100644 --- a/wgpu-core/src/command/bundle.rs +++ b/wgpu-core/src/command/bundle.rs @@ -1024,7 +1024,10 @@ fn set_index_buffer( } .into()); } - let end = offset + buffer.resolve_binding_size(offset, size)?; + let end = offset + + buffer + .resolve_binding_size::(offset, size)? + .get(); state .buffer_memory_init_actions @@ -1069,7 +1072,7 @@ fn set_vertex_buffer( return Err(RenderCommandError::UnalignedVertexBuffer { slot, offset }.into()); } let binding_size = buffer.resolve_binding_size(offset, size)?; - let buffer_range = offset..(offset + binding_size); + let buffer_range = offset..(offset + binding_size.get()); state .buffer_memory_init_actions @@ -1535,7 +1538,13 @@ impl RenderBundle { let buffer = buffer.try_raw(snatch_guard)?; // SAFETY: The binding size was checked against the buffer size // in `set_index_buffer` and again in `IndexState::flush`. - let bb = hal::BufferBinding::new_unchecked(buffer, *offset, *size); + let bb = hal::BufferBinding::new_unchecked( + buffer, + *offset, + size.expect( + "Index buffer binding size should already be resolved when executing bundle", + ), + ); unsafe { raw.set_index_buffer(bb, *index_format) }; } Cmd::SetVertexBuffer { @@ -1547,7 +1556,13 @@ impl RenderBundle { let buffer = buffer.as_ref().unwrap().try_raw(snatch_guard)?; // SAFETY: The binding size was checked against the buffer size // in `set_vertex_buffer` and again in `VertexState::flush`. - let bb = hal::BufferBinding::new_unchecked(buffer, *offset, *size); + let bb = hal::BufferBinding::new_unchecked( + buffer, + *offset, + size.expect( + "Vertex buffer binding size should already be resolved when executing bundle", + ), + ); unsafe { raw.set_vertex_buffer(*slot, bb) }; } Cmd::SetImmediate { offset, data } => { @@ -1828,7 +1843,7 @@ impl State { slot, buffer: Some(buffer.clone()), offset, - size, + size: Some(size), }); }); } diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs index d5193f97a..439c80171 100644 --- a/wgpu-core/src/command/render.rs +++ b/wgpu-core/src/command/render.rs @@ -636,7 +636,7 @@ impl VertexState { /// Call `f` for each dirty slot with `(slot_index, buffer, offset, size)` and mark them clean. pub(crate) fn flush(&mut self, mut f: F) where - F: FnMut(u32, &Arc, BufferAddress, Option), + F: FnMut(u32, &Arc, BufferAddress, BufferSize), { for (i, slot) in self.slots.iter_mut().enumerate() { let Some(slot) = slot.as_mut() else { continue }; @@ -649,7 +649,8 @@ impl VertexState { i as u32, &slot.buffer, slot.range.start, - BufferSize::new(size), + BufferSize::new(size) + .expect("TODO(#3170): empty vertex buffer bindings temporarily unsupported"), ); } } @@ -2836,10 +2837,10 @@ fn set_index_buffer( } .into()); } - let (binding, resolved_size) = buffer + let binding = buffer .binding(offset, size, state.pass.base.snatch_guard) .map_err(RenderCommandError::from)?; - let end = offset + resolved_size; + let end = offset + binding.size.get(); state.index.update_buffer(offset..end, index_format); state.pass.base.buffer_memory_init_actions.extend( @@ -2897,7 +2898,7 @@ fn set_vertex_buffer( let binding_size = buffer .resolve_binding_size(offset, size) .map_err(RenderCommandError::from)?; - let buffer_range = offset..(offset + binding_size); + let buffer_range = offset..(offset + binding_size.get()); state .pass diff --git a/wgpu-core/src/command/render_command.rs b/wgpu-core/src/command/render_command.rs index 1e7b00d87..7dec0802a 100644 --- a/wgpu-core/src/command/render_command.rs +++ b/wgpu-core/src/command/render_command.rs @@ -23,13 +23,13 @@ pub enum RenderCommand { buffer: R::Buffer, index_format: wgt::IndexFormat, offset: BufferAddress, - size: Option, + size: Option, // optional in encoder; must be `Some` in a finished render bundle }, SetVertexBuffer { slot: u32, buffer: Option, offset: BufferAddress, - size: Option, + size: Option, // optional in encoder; must be `Some` in a finished render bundle }, SetBlendConstant(Color), SetStencilReference(u32), diff --git a/wgpu-core/src/device/ray_tracing.rs b/wgpu-core/src/device/ray_tracing.rs index 4c5b022bd..286c6250a 100644 --- a/wgpu-core/src/device/ray_tracing.rs +++ b/wgpu-core/src/device/ray_tracing.rs @@ -207,6 +207,7 @@ impl Device { memory_flags: hal::MemoryFlags::PREFER_COHERENT, }) .map_err(DeviceError::from_hal)? + .0 })) } else { None @@ -317,7 +318,7 @@ impl Device { .raw_tlas_instance_size .checked_mul(desc.max_instances.max(1)) .expect("max_tlas_instance_count should not allow excessive buffer size"); - let instance_buffer = unsafe { + let (instance_buffer, _) = unsafe { self.raw().create_buffer(&hal::BufferDescriptor { label: hal_label(Some("(wgpu-core) instances_buffer"), self.instance_flags), size: u64::from(instance_buffer_size), diff --git a/wgpu-core/src/device/resource.rs b/wgpu-core/src/device/resource.rs index cdb2fd49b..48aa5999c 100644 --- a/wgpu-core/src/device/resource.rs +++ b/wgpu-core/src/device/resource.rs @@ -8,9 +8,8 @@ use alloc::{ use core::{ fmt, mem::{self, ManuallyDrop}, - num::NonZeroU32, + num::{NonZeroU32, NonZeroU64}, }; -use hal::ShouldBeNonZeroExt; use arrayvec::ArrayVec; use bitflags::Flags; @@ -172,6 +171,9 @@ pub struct ExternalTextureParams { pub _padding: [u8; 4], } +const _: () = + assert!(size_of::() == wgpu_hal::EXTERNAL_TEXTURE_PARAMS_SIZE as usize); + impl ExternalTextureParams { pub fn from_desc(desc: &wgt::ExternalTextureDescriptor) -> Self { let gamut_conversion_matrix = [ @@ -525,7 +527,8 @@ impl Device { memory_flags: hal::MemoryFlags::empty(), }) } - .map_err(DeviceError::from_hal)?; + .map_err(DeviceError::from_hal)? + .0; let zero_buffer = guard(zero_buffer, |buffer| unsafe { raw.destroy_buffer(buffer) }); let empty_bgl = unsafe { @@ -546,12 +549,13 @@ impl Device { Some("(wgpu internal) default external texture params buffer"), instance_flags, ), - size: size_of::() as _, + size: align_to(size_of::() as _, 256), usage: wgt::BufferUses::COPY_DST | wgt::BufferUses::UNIFORM, memory_flags: hal::MemoryFlags::empty(), }) } - .map_err(DeviceError::from_hal)?; + .map_err(DeviceError::from_hal)? + .0; let default_external_texture_params_buffer = guard(default_external_texture_params_buffer, |buffer| unsafe { raw.destroy_buffer(buffer) @@ -1217,34 +1221,45 @@ impl Device { // The great thing about buffer sizes is there are so many to choose from! // - The application may request an arbitrary byte-aligned size. - // - We add an extra byte if it's a vertex buffer so that we can simulate binding an - // empty range at the end of the buffer, which Vulkan does not natively allow. - // - The overall buffer size must be a non-zero multiple of 4. - // Because initialization operates at multiples of 4 bytes, and initialization - // tracking will never determine that it is necessary to initialize a region outside - // the application-visible range, we eagerly zero-initialize anything beyond that. - let actual_size = if desc.size == 0 { + // - We add an extra byte if it's a vertex or index buffer so that we can simulate + // binding an empty range at the end of the buffer, which Vulkan does not natively + // allow. + // - The overall buffer size must generally be a non-zero multiple of + // COPY_BUFFER_ALIGNMENT (4), but in special cases an additional platform-dependent + // requirement may apply (e.g. 256 for D3D12 constant buffers). + // + // Because initialization operates at multiples of COPY_BUFFER_ALIGNMENT, and + // initialization tracking will never determine that it is necessary to initialize a + // region outside the application-visible range, round the tracked initialization range + // down to a multiple of COPY_BUFFER_ALIGNMENT (tail_start), and eagerly zero-initialize + // from there to the buffer's true end offset. + + let padded_size = if desc.size == 0 { wgt::COPY_BUFFER_ALIGNMENT - } else if desc.usage.contains(wgt::BufferUsages::VERTEX) { + } else if desc + .usage + .intersects(wgt::BufferUsages::VERTEX | wgt::BufferUsages::INDEX) + { desc.size + 1 } else { desc.size }; - let actual_size = align_to(actual_size, wgt::COPY_BUFFER_ALIGNMENT); let tail_start = desc.size & !(wgt::COPY_BUFFER_ALIGNMENT - 1); - debug_assert!(actual_size - 4 <= tail_start); let hal_desc = hal::BufferDescriptor { label: desc.label.to_hal(self.instance_flags), - size: actual_size, + size: padded_size, usage, memory_flags: hal::MemoryFlags::empty(), }; - let buffer = unsafe { self.raw().create_buffer(&hal_desc) } + let (buffer, final_size) = unsafe { self.raw().create_buffer(&hal_desc) } .map_err(|e| self.handle_hal_error_with_nonfatal_oom(e))?; + debug_assert!(final_size >= padded_size); + let timestamp_normalization_bind_group = Snatchable::new(unsafe { - // SAFETY: The size passed here must not overflow the buffer. + // SAFETY: The size passed here must be 4B aligned, >= the application size, and + // <= the buffer size. self.timestamp_normalizer .get() .unwrap() @@ -1285,7 +1300,7 @@ impl Device { let mapping = map_buffer( buffer, tail_start, - actual_size - tail_start, + final_size - tail_start, HostMap::Write, snatch_guard, )?; @@ -1294,11 +1309,13 @@ impl Device { .expect("newly-created buffer cannot be destroyed"); unsafe { // SAFETY: The buffer tail is valid and aligned. - mapping.ptr.cast::().as_ptr().write(0); + mapping + .ptr + .write_bytes(0, (final_size - tail_start) as usize); if !mapping.is_coherent { #[allow(clippy::single_range_in_vec_init)] self.raw() - .flush_mapped_ranges(raw, &[tail_start..actual_size]); + .flush_mapped_ranges(raw, &[tail_start..final_size]); } self.raw().unmap_buffer(raw); } @@ -1306,7 +1323,7 @@ impl Device { }; let buffer_use = if !desc.mapped_at_creation { - if tail_start == actual_size { + if tail_start == final_size { // No tail init necessary } else if desc.usage.contains(wgt::BufferUsages::MAP_WRITE) { // Tail init by mapping @@ -1323,7 +1340,7 @@ impl Device { pending_writes.clear_buffer( self, &buffer, - tail_start..actual_size, + tail_start..final_size, &snatch_guard, )?; return Ok(buffer); @@ -1336,7 +1353,7 @@ impl Device { // application-visible portion of the buffer. Don't do both in the same // mapping, because the application shouldn't see the tail. let snatch_guard = self.snatchable_lock.read(); - if tail_start != actual_size { + if tail_start != final_size { init_buffer_tail(&buffer, &snatch_guard)?; } let map_size = buffer.size; @@ -1363,12 +1380,12 @@ impl Device { // which may cause problems for its shaders if they read out-of-bounds, but // won't cause problems in wgpu. let mut staging_buffer = - StagingBuffer::new(self, wgt::BufferSize::new(actual_size).unwrap())?; + StagingBuffer::new(self, wgt::BufferSize::new(final_size).unwrap())?; // Zero initialize memory and then mark the buffer as initialized // (it's guaranteed that this is the case by the time the buffer is usable) staging_buffer.write_zeros(); - buffer.initialization_status.write().drain(0..actual_size); + buffer.initialization_status.write().drain(0..final_size); *buffer.map_state.lock() = resource::BufferMapState::Init { staging_buffer }; wgt::BufferUses::COPY_DST @@ -1568,7 +1585,8 @@ impl Device { /// # Safety /// /// - `hal_buffer` must have been created on this device. - /// - `hal_buffer` must have been created respecting `desc` (in particular, the size). + /// - `hal_buffer` must have been created respecting `desc` (in particular, the size, + /// which must always be a multiple of 4, and may be subject to other requirements). /// - `hal_buffer` must be initialized. /// - `hal_buffer` must not have zero size. pub unsafe fn create_buffer_from_hal( @@ -1595,16 +1613,15 @@ impl Device { /// # Safety /// - /// - `hal_buffer` must have been created on this device. - /// - `hal_buffer` must have been created respecting `desc` (in particular, the size). - /// - `hal_buffer` must be initialized. - /// - `hal_buffer` must not have zero size. + /// Same safety requirements as `create_buffer_from_hal`. pub(crate) unsafe fn create_buffer_from_hal_inner( self: &Arc, hal_buffer: Box, desc: &resource::BufferDescriptor, ) -> Result, resource::CreateBufferError> { let timestamp_normalization_bind_group = Snatchable::new(unsafe { + // SAFETY: The size passed here must be 4B aligned, >= the application size, and + // <= the buffer size. self.timestamp_normalizer .get() .unwrap() @@ -1654,6 +1671,10 @@ impl Device { Ok(buffer) } + /// If needed, creates the bind groups for indirect validation shaders to read + /// from `raw_buffer`. + /// + /// `buffer_size` is the user-requested size of the buffer. fn create_indirect_validation_bind_groups( &self, raw_buffer: &dyn hal::DynBuffer, @@ -3234,7 +3255,7 @@ impl Device { late_buffer_binding_sizes: &mut FastHashMap, used: &mut BindGroupStates, snatch_guard: &'a SnatchGuard<'a>, - ) -> Result, CreateBindGroupError> { + ) -> Result, CreateBindGroupError> { use crate::binding_model::CreateBindGroupError as Error; let (binding_ty, dynamic, min_size) = match decl.ty { @@ -3296,7 +3317,8 @@ impl Device { // Requested zero size Some(None) => return Err(CreateBindGroupError::BindingZeroSize(buffer.error_ident())), }; - let (bb, bind_size) = buffer.binding(bb.offset, req_size, snatch_guard)?; + let bb = buffer.binding(bb.offset, req_size, snatch_guard)?; + let bind_size = bb.size.get(); if matches!(binding_ty, wgt::BufferBindingType::Storage { .. }) && bind_size % u64::from(wgt::STORAGE_BINDING_SIZE_ALIGNMENT) != 0 @@ -3566,8 +3588,7 @@ impl Device { ); let params = external_texture_state .params - .binding(0, None, snatch_guard)? - .0; + .binding(0, None, snatch_guard)?; Ok(hal::ExternalTextureBinding { planes, params }) } @@ -3620,7 +3641,7 @@ impl Device { let params = hal::BufferBinding::new_unchecked( self.default_external_texture_params_buffer.as_ref(), 0, - None, + NonZeroU64::new(size_of::() as u64).unwrap(), ); Ok(hal::ExternalTextureBinding { planes, params }) diff --git a/wgpu-core/src/indirect_validation/dispatch.rs b/wgpu-core/src/indirect_validation/dispatch.rs index f74cacf39..4c0e9a444 100644 --- a/wgpu-core/src/indirect_validation/dispatch.rs +++ b/wgpu-core/src/indirect_validation/dispatch.rs @@ -249,7 +249,7 @@ impl Dispatch { usage: wgt::BufferUses::INDIRECT | wgt::BufferUses::STORAGE_READ_WRITE, memory_flags: hal::MemoryFlags::empty(), }; - let dst_buffer = + let (dst_buffer, _) = unsafe { device.create_buffer(&dst_buffer_desc) }.map_err(DeviceError::from_hal)?; let dst_buffer = guard(dst_buffer, |buffer| unsafe { device.destroy_buffer(buffer) @@ -270,7 +270,7 @@ impl Dispatch { buffers: &[hal::BufferBinding::new_unchecked( dst_buffer.as_ref(), 0, - Some(DST_BUFFER_SIZE), + DST_BUFFER_SIZE, )], samplers: &[], textures: &[], diff --git a/wgpu-core/src/indirect_validation/draw.rs b/wgpu-core/src/indirect_validation/draw.rs index 072177238..07bc06edf 100644 --- a/wgpu-core/src/indirect_validation/draw.rs +++ b/wgpu-core/src/indirect_validation/draw.rs @@ -770,7 +770,7 @@ fn create_buffer_and_bind_group( usage, memory_flags: hal::MemoryFlags::empty(), }; - let buffer = unsafe { device.create_buffer(&buffer_desc) }?; + let (buffer, _) = unsafe { device.create_buffer(&buffer_desc) }?; let bind_group_desc = hal::BindGroupDescriptor { label: bind_group_label, layout: bind_group_layout, diff --git a/wgpu-core/src/indirect_validation/mod.rs b/wgpu-core/src/indirect_validation/mod.rs index ea3549071..c2f20d489 100644 --- a/wgpu-core/src/indirect_validation/mod.rs +++ b/wgpu-core/src/indirect_validation/mod.rs @@ -80,6 +80,10 @@ pub(crate) struct BindGroups { } impl BindGroups { + /// Creates the bind groups for indirect validation shaders to read from `buffer`. + /// + /// `buffer_size` is the user-requested size of the buffer. + /// /// `Ok(None)` will only be returned if `buffer_size` is `0`. pub(crate) fn new( indirect_validation: &IndirectValidation, diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs index d92f49a23..e3e5648e8 100644 --- a/wgpu-core/src/resource.rs +++ b/wgpu-core/src/resource.rs @@ -601,32 +601,44 @@ impl Buffer { /// zero-size bindings are permitted by WebGPU, they are not permitted by /// some backends. See [`Buffer::binding`] and /// [#3170](https://github.com/gfx-rs/wgpu/issues/3170). - pub fn resolve_binding_size( + pub fn resolve_binding_size< + S: Copy + Into + TryFrom, + >( &self, offset: wgt::BufferAddress, - binding_size: Option, - ) -> Result { + binding_size: Option, + ) -> Result { let buffer_size = self.size; match binding_size { - Some(binding_size) => match offset.checked_add(binding_size.get()) { - Some(end) if end <= buffer_size => Ok(binding_size.get()), + Some(binding_size) => match offset.checked_add(binding_size.into()) { + Some(end) if end <= buffer_size => Ok(binding_size), _ => Err(BindingError::BindingRangeTooLarge { buffer: self.error_ident(), offset, - binding_size: binding_size.get(), + binding_size: binding_size.into(), buffer_size, }), }, - None => { - buffer_size - .checked_sub(offset) - .ok_or_else(|| BindingError::BindingOffsetTooLarge { - buffer: self.error_ident(), - offset, - buffer_size, - }) - } + None => buffer_size + .checked_sub(offset) + .and_then(|remaining| S::try_from(remaining).ok()) + .ok_or_else(|| { + if offset <= buffer_size { + debug_assert_eq!(offset, buffer_size); + BindingError::BindingOffsetEqualsSize { + buffer: self.error_ident(), + offset, + buffer_size, + } + } else { + BindingError::BindingOffsetTooLarge { + buffer: self.error_ident(), + offset, + buffer_size, + } + } + }), } } @@ -655,13 +667,14 @@ impl Buffer { offset: wgt::BufferAddress, binding_size: Option, snatch_guard: &'a SnatchGuard, - ) -> Result<(hal::BufferBinding<'a, dyn hal::DynBuffer>, u64), BindingError> { + ) -> Result, BindingError> { let buf_raw = self.try_raw(snatch_guard)?; let resolved_size = self.resolve_binding_size(offset, binding_size)?; // SAFETY: The offset and size passed to hal::BufferBinding::new_unchecked must // define a binding contained within the buffer. - Ok(( - hal::BufferBinding::new_unchecked(buf_raw, offset, binding_size), + Ok(hal::BufferBinding::new_unchecked( + buf_raw, + offset, resolved_size, )) } @@ -1341,7 +1354,7 @@ impl StagingBuffer { memory_flags: hal::MemoryFlags::TRANSIENT, }; - let raw = unsafe { device.raw().create_buffer(&stage_desc) } + let (raw, _) = unsafe { device.raw().create_buffer(&stage_desc) } .map_err(|e| device.handle_hal_error(e))?; let mapping = unsafe { device.raw().map_buffer(raw.as_ref(), 0..size.get()) } .map_err(|e| device.handle_hal_error(e))?; diff --git a/wgpu-core/src/scratch.rs b/wgpu-core/src/scratch.rs index 797f9db14..074ab4f10 100644 --- a/wgpu-core/src/scratch.rs +++ b/wgpu-core/src/scratch.rs @@ -14,7 +14,7 @@ pub struct ScratchBuffer { impl ScratchBuffer { pub(crate) fn new(device: &Arc, size: wgt::BufferSize) -> Result { - let raw = unsafe { + let (raw, _) = unsafe { device .raw() .create_buffer(&hal::BufferDescriptor { diff --git a/wgpu-core/src/timestamp_normalization/mod.rs b/wgpu-core/src/timestamp_normalization/mod.rs index deac00cef..e11dd6b74 100644 --- a/wgpu-core/src/timestamp_normalization/mod.rs +++ b/wgpu-core/src/timestamp_normalization/mod.rs @@ -253,8 +253,16 @@ impl TimestampNormalizer { /// Create a bind group for normalizing timestamps in `buffer`. /// - /// This function is unsafe because it does not know that `buffer_size` is - /// the true size of the buffer. + /// `buffer_size` must be 4B-aligned, so that it is valid as a storage binding, + /// must be the same or more than the application-visible buffer size, and must + /// not overrun the buffer. This function is unsafe because it does not know and + /// cannot check whether `buffer_size` meets these requirements. + /// + /// The buffer size passed here is used to construct a binding that must be + /// able to access the full application-visible range of the buffer. It is + /// not used to check the destination range of query resolution requests. That + /// uses the application-requested buffer size, obtained from the `wgpu_core` + /// `Buffer`. pub unsafe fn create_normalization_bind_group( &self, device: &Device, diff --git a/wgpu-hal/examples/halmark/main.rs b/wgpu-hal/examples/halmark/main.rs index 5ccbd2928..92ee10af9 100644 --- a/wgpu-hal/examples/halmark/main.rs +++ b/wgpu-hal/examples/halmark/main.rs @@ -300,7 +300,7 @@ impl Example { usage: wgpu_types::BufferUses::MAP_WRITE | wgpu_types::BufferUses::COPY_SRC, memory_flags: hal::MemoryFlags::TRANSIENT | hal::MemoryFlags::PREFER_COHERENT, }; - let staging_buffer = unsafe { device.create_buffer(&staging_buffer_desc).unwrap() }; + let (staging_buffer, _) = unsafe { device.create_buffer(&staging_buffer_desc).unwrap() }; unsafe { let mapping = device .map_buffer(&staging_buffer, 0..staging_buffer_desc.size) @@ -421,7 +421,7 @@ impl Example { memory_flags: hal::MemoryFlags::PREFER_COHERENT, }; let global_buffer = unsafe { - let buffer = device.create_buffer(&global_buffer_desc).unwrap(); + let (buffer, _) = device.create_buffer(&global_buffer_desc).unwrap(); let mapping = device .map_buffer(&buffer, 0..global_buffer_desc.size) .unwrap(); @@ -446,7 +446,7 @@ impl Example { usage: wgpu_types::BufferUses::MAP_WRITE | wgpu_types::BufferUses::UNIFORM, memory_flags: hal::MemoryFlags::PREFER_COHERENT, }; - let local_buffer = unsafe { device.create_buffer(&local_buffer_desc).unwrap() }; + let (local_buffer, _) = unsafe { device.create_buffer(&local_buffer_desc).unwrap() }; let view_desc = hal::TextureViewDescriptor { label: None, @@ -463,7 +463,7 @@ impl Example { let global_buffer_binding = hal::BufferBinding::new_unchecked( &global_buffer, 0, - NonZeroU64::new(global_buffer_desc.size), + NonZeroU64::new(global_buffer_desc.size).unwrap(), ); let texture_binding = hal::TextureBinding { view: &texture_view, @@ -503,7 +503,7 @@ impl Example { let local_buffer_binding = hal::BufferBinding::new_unchecked( &local_buffer, 0, - wgpu_types::BufferSize::new(size_of::() as _), + wgpu_types::BufferSize::new(size_of::() as _).unwrap(), ); let local_group_desc = hal::BindGroupDescriptor { label: Some("local"), diff --git a/wgpu-hal/examples/ray-traced-triangle/main.rs b/wgpu-hal/examples/ray-traced-triangle/main.rs index 6f9e66e46..89ce6310f 100644 --- a/wgpu-hal/examples/ray-traced-triangle/main.rs +++ b/wgpu-hal/examples/ray-traced-triangle/main.rs @@ -429,7 +429,7 @@ impl Example { let indices_size_in_bytes = indices.len() * 4; let vertices_buffer = unsafe { - let vertices_buffer = device + let (vertices_buffer, _) = device .create_buffer(&hal::BufferDescriptor { label: Some("vertices buffer"), size: vertices_size_in_bytes as u64, @@ -455,7 +455,7 @@ impl Example { let indices_buffer = if index_buffer { unsafe { - let indices_buffer = device + let (indices_buffer, _) = device .create_buffer(&hal::BufferDescriptor { label: Some("indices buffer"), size: indices_size_in_bytes as u64, @@ -565,7 +565,7 @@ impl Example { let instances_buffer_size = instances.len() * size_of::(); let instances_buffer = unsafe { - let instances_buffer = device + let (instances_buffer, _) = device .create_buffer(&hal::BufferDescriptor { label: Some("instances_buffer"), size: instances_buffer_size as u64, @@ -631,7 +631,7 @@ impl Example { let uniforms_size = size_of::(); let uniform_buffer = unsafe { - let uniform_buffer = device + let (uniform_buffer, _) = device .create_buffer(&hal::BufferDescriptor { label: Some("uniform buffer"), size: uniforms_size as u64, @@ -722,7 +722,7 @@ impl Example { unsafe { device.create_bind_group(&group_desc).unwrap() } }; - let scratch_buffer = unsafe { + let (scratch_buffer, _) = unsafe { device .create_buffer(&hal::BufferDescriptor { label: Some("scratch buffer"), diff --git a/wgpu-hal/src/dx12/command.rs b/wgpu-hal/src/dx12/command.rs index 2f3a3cd5f..fc2096ccb 100644 --- a/wgpu-hal/src/dx12/command.rs +++ b/wgpu-hal/src/dx12/command.rs @@ -479,7 +479,7 @@ impl super::CommandEncoder { )); super::Buffer { resource, - size: size.get(), + allocated_size: size.get(), allocation, } }; @@ -1425,12 +1425,12 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_index_buffer<'a>( &mut self, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferAddress>, format: wgt::IndexFormat, ) { let ibv = Direct3D12::D3D12_INDEX_BUFFER_VIEW { BufferLocation: binding.resolve_address(), - SizeInBytes: binding.resolve_size().try_into().unwrap(), + SizeInBytes: binding.size.try_into().unwrap(), Format: auxil::dxgi::conv::map_index_format(format), }; @@ -1439,11 +1439,11 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferAddress>, ) { let vb = &mut self.pass.vertex_buffers[index as usize]; vb.BufferLocation = binding.resolve_address(); - vb.SizeInBytes = binding.resolve_size().try_into().unwrap(); + vb.SizeInBytes = binding.size.try_into().unwrap(); self.pass.dirty_vertex_buffers |= 1 << index; } diff --git a/wgpu-hal/src/dx12/device.rs b/wgpu-hal/src/dx12/device.rs index 6047ea6c9..293238448 100644 --- a/wgpu-hal/src/dx12/device.rs +++ b/wgpu-hal/src/dx12/device.rs @@ -491,7 +491,7 @@ impl super::Device { ) -> super::Buffer { super::Buffer { resource, - size, + allocated_size: size, allocation: suballocation::Allocation::none( suballocation::AllocationType::Buffer, size, @@ -506,7 +506,7 @@ impl crate::Device for super::Device { unsafe fn create_buffer( &self, desc: &crate::BufferDescriptor, - ) -> Result { + ) -> Result<(super::Buffer, wgt::BufferAddress), crate::DeviceError> { let mut desc = desc.clone(); if desc.usage.contains(wgt::BufferUses::UNIFORM) { @@ -520,11 +520,14 @@ impl crate::Device for super::Device { self.counters.buffers.add(1); - Ok(super::Buffer { - resource, - size: desc.size, - allocation, - }) + Ok(( + super::Buffer { + resource, + allocated_size: desc.size, + allocation, + }, + desc.size, + )) } unsafe fn destroy_buffer(&self, buffer: super::Buffer) { @@ -1595,7 +1598,7 @@ impl crate::Device for super::Device { let end = start + entry.count as usize; for data in &desc.buffers[start..end] { let gpu_address = data.resolve_address(); - let mut size = data.resolve_size().try_into().unwrap(); + let mut size = data.size.get().try_into().unwrap(); if has_dynamic_offset { match ty { @@ -1607,8 +1610,13 @@ impl crate::Device for super::Device { )); continue; } + // TODO(https://github.com/gfx-rs/wgpu/issues/9865): There is not currently + // any mechanism to check that shader accesses are within the valid range + // of a dynamic offset binding, and while using the actual size of the buffer + // here would be slightly closer to being correct, it isn't sufficient + // (because the upper bound moves with the dynamic offset). wgt::BufferBindingType::Storage { .. } => { - size = (data.buffer.size - data.offset) as u32; + size = (data.buffer.allocated_size - data.offset) as u32; dynamic_buffers.push(super::DynamicBuffer::Storage); } } @@ -1789,7 +1797,7 @@ impl crate::Device for super::Device { cpu_views.as_mut().unwrap().stage.push(plane_handle.raw); } let gpu_address = external_texture.params.resolve_address(); - let size = external_texture.params.resolve_size() as u32; + let size = crate::EXTERNAL_TEXTURE_PARAMS_SIZE as u32; let inner = cpu_views.as_mut().unwrap(); let cpu_index = inner.stage.len() as u32; let params_handle = desc.layout.cpu_heap_views.as_ref().unwrap().at(cpu_index); diff --git a/wgpu-hal/src/dx12/mod.rs b/wgpu-hal/src/dx12/mod.rs index 72bef7f84..7fe591b73 100644 --- a/wgpu-hal/src/dx12/mod.rs +++ b/wgpu-hal/src/dx12/mod.rs @@ -917,10 +917,14 @@ unsafe impl Sync for CommandBuffer {} #[derive(Debug)] pub struct Buffer { resource: Direct3D12::ID3D12Resource, - // While the allocation also has _a_ size, it may not - // be the same as the original size of the buffer, - // as the allocation size varies for assorted reasons. - size: wgt::BufferAddress, + /// The allocated size of the buffer. + /// + /// This may not be the same as the size the application requested. + // + // TODO(https://github.com/gfx-rs/wgpu/issues/9865): Consider removing this. + // The usage associated with the TODO is currently the only usage. Computing + // things from the allocated buffer size is usually incorrect. + allocated_size: wgt::BufferAddress, allocation: suballocation::Allocation, } @@ -935,14 +939,7 @@ unsafe impl Sync for Buffer {} impl crate::DynBuffer for Buffer {} -impl crate::BufferBinding<'_, Buffer> { - fn resolve_size(&self) -> wgt::BufferAddress { - match self.size { - Some(size) => size.get(), - None => self.buffer.size - self.offset, - } - } - +impl crate::BufferBinding<'_, Buffer, S> { // TODO: Return GPU handle directly? fn resolve_address(&self) -> wgt::BufferAddress { (unsafe { self.buffer.resource.GetGPUVirtualAddress() }) + self.offset diff --git a/wgpu-hal/src/dynamic/command.rs b/wgpu-hal/src/dynamic/command.rs index 71ce21fff..2961b2364 100644 --- a/wgpu-hal/src/dynamic/command.rs +++ b/wgpu-hal/src/dynamic/command.rs @@ -101,14 +101,14 @@ pub trait DynCommandEncoder: DynResource + core::fmt::Debug { unsafe fn set_index_buffer<'a>( &mut self, - binding: BufferBinding<'a, dyn DynBuffer>, + binding: BufferBinding<'a, dyn DynBuffer, wgt::BufferSize>, format: wgt::IndexFormat, ); unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: BufferBinding<'a, dyn DynBuffer>, + binding: BufferBinding<'a, dyn DynBuffer, wgt::BufferSize>, ); unsafe fn set_viewport(&mut self, rect: &Rect, depth_range: Range); unsafe fn set_scissor_rect(&mut self, rect: &Rect); @@ -645,7 +645,7 @@ impl DynCommandEncoder for C { unsafe fn set_index_buffer<'a>( &mut self, - binding: BufferBinding<'a, dyn DynBuffer>, + binding: BufferBinding<'a, dyn DynBuffer, wgt::BufferSize>, format: wgt::IndexFormat, ) { let binding = binding.expect_downcast(); @@ -655,7 +655,7 @@ impl DynCommandEncoder for C { unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: BufferBinding<'a, dyn DynBuffer>, + binding: BufferBinding<'a, dyn DynBuffer, wgt::BufferSize>, ) { let binding = binding.expect_downcast(); unsafe { self.set_vertex_buffer(index, binding) }; diff --git a/wgpu-hal/src/dynamic/device.rs b/wgpu-hal/src/dynamic/device.rs index 13917a4d9..04932c98c 100644 --- a/wgpu-hal/src/dynamic/device.rs +++ b/wgpu-hal/src/dynamic/device.rs @@ -21,7 +21,7 @@ pub trait DynDevice: DynResource { unsafe fn create_buffer( &self, desc: &BufferDescriptor, - ) -> Result, DeviceError>; + ) -> Result<(Box, wgt::BufferAddress), DeviceError>; unsafe fn destroy_buffer(&self, buffer: Box); unsafe fn add_raw_buffer(&self, buffer: &dyn DynBuffer); @@ -186,8 +186,9 @@ impl DynDevice for D { unsafe fn create_buffer( &self, desc: &BufferDescriptor, - ) -> Result, DeviceError> { - unsafe { D::create_buffer(self, desc) }.map(|b| -> Box { Box::new(b) }) + ) -> Result<(Box, wgt::BufferAddress), DeviceError> { + unsafe { D::create_buffer(self, desc) } + .map(|(b, size)| -> (Box, _) { (Box::new(b), size) }) } unsafe fn destroy_buffer(&self, buffer: Box) { diff --git a/wgpu-hal/src/dynamic/mod.rs b/wgpu-hal/src/dynamic/mod.rs index cce4d3b66..abb222929 100644 --- a/wgpu-hal/src/dynamic/mod.rs +++ b/wgpu-hal/src/dynamic/mod.rs @@ -116,8 +116,8 @@ pub trait DynSurfaceTexture: pub trait DynTexture: DynResource + fmt::Debug {} pub trait DynTextureView: DynResource + fmt::Debug {} -impl<'a> BufferBinding<'a, dyn DynBuffer> { - pub fn expect_downcast(self) -> BufferBinding<'a, B> { +impl<'a, S> BufferBinding<'a, dyn DynBuffer, S> { + pub fn expect_downcast(self) -> BufferBinding<'a, B, S> { BufferBinding { buffer: self.buffer.expect_downcast_ref(), offset: self.offset, diff --git a/wgpu-hal/src/gles/command.rs b/wgpu-hal/src/gles/command.rs index 3a7cdb199..cb9a8dd63 100644 --- a/wgpu-hal/src/gles/command.rs +++ b/wgpu-hal/src/gles/command.rs @@ -1023,7 +1023,7 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_index_buffer<'a>( &mut self, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferSize>, format: wgt::IndexFormat, ) { self.state.index_offset = binding.offset; @@ -1035,7 +1035,7 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferSize>, ) { self.state.dirty_vbuf_mask |= 1 << index; let (_, ref mut vb) = self.state.vertex_buffers[index as usize]; diff --git a/wgpu-hal/src/gles/device.rs b/wgpu-hal/src/gles/device.rs index 190261de3..b053e2b7f 100644 --- a/wgpu-hal/src/gles/device.rs +++ b/wgpu-hal/src/gles/device.rs @@ -301,7 +301,6 @@ impl super::Device { super::Buffer { raw: Some(glow::NativeBuffer(name)), target, - size: desc.size, map_flags, map_state: Arc::new(Mutex::new(super::BufferMapState { mapped: false, @@ -685,7 +684,7 @@ impl crate::Device for super::Device { unsafe fn create_buffer( &self, desc: &crate::BufferDescriptor, - ) -> Result { + ) -> Result<(super::Buffer, wgt::BufferAddress), crate::DeviceError> { let target = if desc.usage.contains(wgt::BufferUses::INDEX) { glow::ELEMENT_ARRAY_BUFFER } else { @@ -702,18 +701,20 @@ impl crate::Device for super::Device { .contains(PrivateCapabilities::BUFFER_ALLOCATION); if emulate_map && desc.usage.intersects(wgt::BufferUses::MAP_WRITE) { - return Ok(super::Buffer { - raw: None, - target, - size: desc.size, - map_flags: 0, - map_state: Arc::new(Mutex::new(super::BufferMapState { - mapped: false, - data: Some(vec![0; desc.size as usize]), - offset_of_current_mapping: 0, - })), - drop_guard: None, - }); + return Ok(( + super::Buffer { + raw: None, + target, + map_flags: 0, + map_state: Arc::new(Mutex::new(super::BufferMapState { + mapped: false, + data: Some(vec![0; desc.size as usize]), + offset_of_current_mapping: 0, + })), + drop_guard: None, + }, + desc.size, + )); } let gl = &self.shared.context.lock(); @@ -806,18 +807,20 @@ impl crate::Device for super::Device { self.counters.buffers.add(1); - Ok(super::Buffer { - raw, - target, - size: desc.size, - map_flags, - map_state: Arc::new(Mutex::new(super::BufferMapState { - mapped: false, - data, - offset_of_current_mapping: 0, - })), - drop_guard: None, - }) + Ok(( + super::Buffer { + raw, + target, + map_flags, + map_state: Arc::new(Mutex::new(super::BufferMapState { + mapped: false, + data, + offset_of_current_mapping: 0, + })), + drop_guard: None, + }, + desc.size, + )) } unsafe fn destroy_buffer(&self, buffer: super::Buffer) { @@ -1491,10 +1494,7 @@ impl crate::Device for super::Device { super::RawBinding::Buffer { raw: bb.buffer.raw.unwrap(), offset: bb.offset as i32, - size: match bb.size { - Some(s) => s.get() as i32, - None => (bb.buffer.size - bb.offset) as i32, - }, + size: bb.size.get() as i32, } } wgt::BindingType::Sampler { .. } => { diff --git a/wgpu-hal/src/gles/mod.rs b/wgpu-hal/src/gles/mod.rs index caa37f4d7..875f35588 100644 --- a/wgpu-hal/src/gles/mod.rs +++ b/wgpu-hal/src/gles/mod.rs @@ -384,7 +384,6 @@ impl Drop for Queue { pub struct Buffer { raw: Option, target: BindTarget, - size: wgt::BufferAddress, /// Flags to use within calls to [`Device::map_buffer`](crate::Device::map_buffer). map_flags: u32, /// Buffer mapping state. diff --git a/wgpu-hal/src/lib.rs b/wgpu-hal/src/lib.rs index 5359657eb..784301599 100644 --- a/wgpu-hal/src/lib.rs +++ b/wgpu-hal/src/lib.rs @@ -323,6 +323,7 @@ pub const MAX_MIP_LEVELS: u32 = 16; /// Size of a single occlusion/timestamp query, when copied into a buffer, in bytes. /// cbindgen:ignore pub const QUERY_SIZE: wgt::BufferAddress = 8; +pub const EXTERNAL_TEXTURE_PARAMS_SIZE: wgt::BufferAddress = 208; pub type Label<'a> = Option<&'a str>; pub type MemoryRange = Range; @@ -924,7 +925,7 @@ pub trait Device: WasmNotSendSync { unsafe fn create_buffer( &self, desc: &BufferDescriptor, - ) -> Result<::Buffer, DeviceError>; + ) -> Result<(::Buffer, wgt::BufferAddress), DeviceError>; /// Free `buffer` and any GPU resources it owns. /// @@ -1676,13 +1677,13 @@ pub trait CommandEncoder: WasmNotSendSync + fmt::Debug { unsafe fn set_index_buffer<'a>( &mut self, - binding: BufferBinding<'a, ::Buffer>, + binding: BufferBinding<'a, ::Buffer, wgt::BufferSize>, format: wgt::IndexFormat, ); unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: BufferBinding<'a, ::Buffer>, + binding: BufferBinding<'a, ::Buffer, wgt::BufferSize>, ); unsafe fn set_viewport(&mut self, rect: &Rect, depth_range: Range); unsafe fn set_scissor_rect(&mut self, rect: &Rect); @@ -2211,6 +2212,15 @@ pub struct BufferMapping { #[derive(Clone, Debug)] pub struct BufferDescriptor<'a> { pub label: Label<'a>, + + /// The requested size of the buffer. + /// + /// `wgpu-hal` may allocate more bytes than requested, if required by the + /// platform. The actual allocation size is returned by `create_buffer`. + /// Where platforms offer bounds checking, it will operate based on the + /// allocated size, not the requested size, so other means may be necessary + /// to prevent access beyond the original requested size. The content of + /// newly-created buffers is undefined. pub size: wgt::BufferAddress, pub usage: wgt::BufferUses, pub memory_flags: MemoryFlags, @@ -2360,7 +2370,7 @@ pub struct PipelineLayoutDescriptor<'a, B: DynBindGroupLayout + ?Sized> { /// [bbr]: https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glBindBufferRange.xhtml /// [woob]: https://gpuweb.github.io/gpuweb/wgsl/#out-of-bounds-access-sec #[derive(Debug)] -pub struct BufferBinding<'a, B: DynBuffer + ?Sized> { +pub struct BufferBinding<'a, B: DynBuffer + ?Sized, S> { /// The buffer being bound. /// /// This is not fully `pub` to prevent direct construction of @@ -2375,15 +2385,11 @@ pub struct BufferBinding<'a, B: DynBuffer + ?Sized> { pub offset: wgt::BufferAddress, /// The size of the region bound, in bytes. - /// - /// If `None`, the region extends from `offset` to the end of the - /// buffer. Given the restrictions on `offset`, this means that - /// the size is always greater than zero. - pub size: Option, + pub size: S, } // We must implement this manually because `B` is not necessarily `Clone`. -impl Clone for BufferBinding<'_, B> { +impl Clone for BufferBinding<'_, B, S> { fn clone(&self) -> Self { BufferBinding { buffer: self.buffer, @@ -2421,7 +2427,7 @@ impl ShouldBeNonZeroExt for Option { } } -impl<'a, B: DynBuffer + ?Sized> BufferBinding<'a, B> { +impl<'a, B: DynBuffer + ?Sized, S> BufferBinding<'a, B, S> { /// Construct a `BufferBinding` with the given contents. /// /// When possible, use the `binding` method on a wgpu-core `Buffer` instead @@ -2432,21 +2438,13 @@ impl<'a, B: DynBuffer + ?Sized> BufferBinding<'a, B> { /// not having direct access to the size of a `DynBuffer`. /// /// SAFETY: The caller is responsible for ensuring that a binding of `size` - /// bytes starting at `offset` is contained within the buffer. - /// - /// The `S` type parameter is a temporary convenience to allow callers to - /// pass a zero size. When the zero-size binding issue is resolved, the - /// argument should just match the type of the member. - /// TODO(): remove the parameter - pub fn new_unchecked>>( - buffer: &'a B, - offset: wgt::BufferAddress, - size: S, - ) -> Self { + /// bytes starting at `offset` is contained within the buffer. `size` + /// may be zero only for vertex/index buffer bindings. + pub fn new_unchecked(buffer: &'a B, offset: wgt::BufferAddress, size: S) -> Self { Self { buffer, offset, - size: size.into(), + size, } } @@ -2474,7 +2472,7 @@ impl<'a, T: DynTextureView + ?Sized> Clone for TextureBinding<'a, T> { #[derive(Debug)] pub struct ExternalTextureBinding<'a, B: DynBuffer + ?Sized, T: DynTextureView + ?Sized> { pub planes: [TextureBinding<'a, T>; 3], - pub params: BufferBinding<'a, B>, + pub params: BufferBinding<'a, B, wgt::BufferSize>, } impl<'a, B: DynBuffer + ?Sized, T: DynTextureView + ?Sized> Clone @@ -2516,7 +2514,7 @@ pub struct BindGroupDescriptor< > { pub label: Label<'a>, pub layout: &'a Bgl, - pub buffers: &'a [BufferBinding<'a, B>], + pub buffers: &'a [BufferBinding<'a, B, wgt::BufferSize>], pub samplers: &'a [&'a S], pub textures: &'a [TextureBinding<'a, T>], pub entries: &'a [BindGroupEntry], diff --git a/wgpu-hal/src/metal/command.rs b/wgpu-hal/src/metal/command.rs index 4b67ac290..081d00b80 100644 --- a/wgpu-hal/src/metal/command.rs +++ b/wgpu-hal/src/metal/command.rs @@ -1408,7 +1408,7 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_index_buffer<'a>( &mut self, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferSize>, format: wgt::IndexFormat, ) { let (stride, raw_type) = conv::map_index_format(format); @@ -1423,7 +1423,7 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferSize>, ) { let buffer_index = MAX_BUFFERS - 1 - index; let encoder = self.state.render.as_ref().unwrap(); @@ -1435,15 +1435,14 @@ impl crate::CommandEncoder for super::CommandEncoder { ) }; - let buffer_size = binding.resolve_size(); - if buffer_size > 0 { - self.state.vertex_buffer_size_map.insert( - buffer_index, - core::num::NonZeroU64::new(buffer_size).unwrap(), - ); - } else { - self.state.vertex_buffer_size_map.remove(&buffer_index); - } + // TODO(#3170): temporary + //if let Some(size) = NonZeroU64::new(binding.size) { + self.state + .vertex_buffer_size_map + .insert(buffer_index, binding.size); + //} else { + // self.state.vertex_buffer_size_map.remove(&buffer_index); + //} if let Some((index, sizes)) = self .state diff --git a/wgpu-hal/src/metal/device.rs b/wgpu-hal/src/metal/device.rs index efed62141..04ba3fab4 100644 --- a/wgpu-hal/src/metal/device.rs +++ b/wgpu-hal/src/metal/device.rs @@ -447,11 +447,8 @@ impl super::Device { } } - pub unsafe fn buffer_from_raw( - raw: Retained>, - size: wgt::BufferAddress, - ) -> super::Buffer { - super::Buffer { raw, size } + pub unsafe fn buffer_from_raw(raw: Retained>) -> super::Buffer { + super::Buffer { raw } } pub fn raw_device(&self) -> &Retained> { @@ -462,7 +459,10 @@ impl super::Device { impl crate::Device for super::Device { type A = super::Api; - unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult { + unsafe fn create_buffer( + &self, + desc: &crate::BufferDescriptor, + ) -> DeviceResult<(super::Buffer, wgt::BufferAddress)> { let map_read = desc.usage.contains(wgt::BufferUses::MAP_READ); let map_write = desc.usage.contains(wgt::BufferUses::MAP_WRITE); @@ -487,10 +487,7 @@ impl crate::Device for super::Device { raw.setLabel(Some(&NSString::from_str(label))); } self.counters.buffers.add(1); - Ok(super::Buffer { - raw, - size: desc.size, - }) + Ok((super::Buffer { raw }, desc.size)) }) } unsafe fn destroy_buffer(&self, _buffer: super::Buffer) { @@ -1147,12 +1144,7 @@ impl crate::Device for super::Device { } if let wgt::BufferBindingType::Storage { .. } = ty { - let remaining_size = wgt::BufferSize::new( - source.buffer.size - source.offset, - ); - if let Some(binding_size) = source.size.or(remaining_size) { - array_element_sizes.push((idx as u32, binding_size)); - } + array_element_sizes.push((idx as u32, source.size)); } let use_info = bg @@ -1241,14 +1233,9 @@ impl crate::Device for super::Device { let end = start + 1; bg.buffers .extend(desc.buffers[start..end].iter().map(|source| { - // Given the restrictions on `BufferBinding::offset`, - // this should never be `None`. - let remaining_size = wgt::BufferSize::new( - source.buffer.size - source.offset, - ); let binding_size = match ty { wgt::BufferBindingType::Storage { .. } => { - source.size.or(remaining_size) + Some(source.size) } _ => None, }; diff --git a/wgpu-hal/src/metal/mod.rs b/wgpu-hal/src/metal/mod.rs index 65c9d4588..f42827582 100644 --- a/wgpu-hal/src/metal/mod.rs +++ b/wgpu-hal/src/metal/mod.rs @@ -844,7 +844,6 @@ impl crate::Queue for Queue { #[derive(Debug)] pub struct Buffer { raw: Retained>, - size: wgt::BufferAddress, } unsafe impl Send for Buffer {} @@ -858,15 +857,6 @@ impl Buffer { } } -impl crate::BufferBinding<'_, Buffer> { - fn resolve_size(&self) -> wgt::BufferAddress { - match self.size { - Some(size) => size.get(), - None => self.buffer.size - self.offset, - } - } -} - #[derive(Debug)] pub struct Texture { raw: Retained>, diff --git a/wgpu-hal/src/noop/buffer.rs b/wgpu-hal/src/noop/buffer.rs index 1a12913e5..bad0440fa 100644 --- a/wgpu-hal/src/noop/buffer.rs +++ b/wgpu-hal/src/noop/buffer.rs @@ -8,12 +8,6 @@ pub struct Buffer { /// This data is potentially accessed mutably in arbitrary non-overlapping slices, /// so we must store it in `UnsafeCell` to avoid making any too-strong no-aliasing claims. storage: Arc>, - - /// Size of the allocation. - /// - /// This is redundant with `storage.get().len()`, but that method is not - /// available until our MSRV is 1.79 or greater. - size: usize, } /// SAFETY: @@ -24,7 +18,9 @@ unsafe impl Send for Buffer {} unsafe impl Sync for Buffer {} impl Buffer { - pub(super) fn new(desc: &crate::BufferDescriptor) -> Result { + pub(super) fn new( + desc: &crate::BufferDescriptor, + ) -> Result<(Self, wgt::BufferAddress), crate::DeviceError> { let &crate::BufferDescriptor { label: _, size, @@ -48,7 +44,7 @@ impl Buffer { let storage: Arc> = unsafe { Arc::from_raw(Arc::into_raw(storage) as *mut UnsafeCell<[u8]>) }; - Ok(Buffer { storage, size }) + Ok((Buffer { storage }, desc.size)) } /// Returns a pointer to the memory owned by this buffer within the given `range`. @@ -58,7 +54,7 @@ impl Buffer { /// to a reference. pub(super) fn get_slice_ptr(&self, range: crate::MemoryRange) -> *mut [u8] { let base_ptr = self.storage.get(); - let range = range_to_usize(range, self.size); + let range = range_to_usize(range, self.storage.get().len()); // We must obtain a slice pointer without ever creating a slice reference // that could alias with another slice. diff --git a/wgpu-hal/src/noop/command.rs b/wgpu-hal/src/noop/command.rs index 16cca58d4..4abe228a2 100644 --- a/wgpu-hal/src/noop/command.rs +++ b/wgpu-hal/src/noop/command.rs @@ -172,14 +172,14 @@ impl crate::CommandEncoder for CommandBuffer { unsafe fn set_index_buffer<'a>( &mut self, - binding: crate::BufferBinding<'a, Buffer>, + binding: crate::BufferBinding<'a, Buffer, wgt::BufferSize>, format: wgt::IndexFormat, ) { } unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: crate::BufferBinding<'a, Buffer>, + binding: crate::BufferBinding<'a, Buffer, wgt::BufferSize>, ) { } unsafe fn set_viewport(&mut self, rect: &crate::Rect, depth_range: Range) {} diff --git a/wgpu-hal/src/noop/mod.rs b/wgpu-hal/src/noop/mod.rs index c42f00d73..3926fddd2 100644 --- a/wgpu-hal/src/noop/mod.rs +++ b/wgpu-hal/src/noop/mod.rs @@ -299,7 +299,10 @@ impl crate::Queue for Context { impl crate::Device for Context { type A = Api; - unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult { + unsafe fn create_buffer( + &self, + desc: &crate::BufferDescriptor, + ) -> DeviceResult<(Buffer, wgt::BufferAddress)> { Buffer::new(desc) } diff --git a/wgpu-hal/src/vulkan/command.rs b/wgpu-hal/src/vulkan/command.rs index 90f8ebaed..877806390 100644 --- a/wgpu-hal/src/vulkan/command.rs +++ b/wgpu-hal/src/vulkan/command.rs @@ -1033,7 +1033,7 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_index_buffer<'a>( &mut self, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferSize>, format: wgt::IndexFormat, ) { unsafe { @@ -1048,7 +1048,7 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, - binding: crate::BufferBinding<'a, super::Buffer>, + binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferSize>, ) { let vk_buffers = [binding.buffer.raw]; let vk_offsets = [binding.offset]; diff --git a/wgpu-hal/src/vulkan/device.rs b/wgpu-hal/src/vulkan/device.rs index f0b3d95fc..43a9e59a0 100644 --- a/wgpu-hal/src/vulkan/device.rs +++ b/wgpu-hal/src/vulkan/device.rs @@ -997,7 +997,7 @@ impl crate::Device for super::Device { unsafe fn create_buffer( &self, desc: &crate::BufferDescriptor, - ) -> Result { + ) -> Result<(super::Buffer, wgt::BufferAddress), crate::DeviceError> { let vk_info = vk::BufferCreateInfo::default() .size(desc.size) .usage(conv::map_buffer_usage(desc.usage)) @@ -1073,12 +1073,15 @@ impl crate::Device for super::Device { self.counters.buffer_memory.add(allocation.size() as isize); self.counters.buffers.add(1); - Ok(super::Buffer { - raw, - ownership: super::BufferOwnership::Managed(Mutex::new( - super::BufferMemoryBacking::Managed(allocation), - )), - }) + Ok(( + super::Buffer { + raw, + ownership: super::BufferOwnership::Managed(Mutex::new( + super::BufferMemoryBacking::Managed(allocation), + )), + }, + desc.size, + )) } unsafe fn destroy_buffer(&self, buffer: super::Buffer) { match buffer.ownership { @@ -1826,9 +1829,7 @@ impl crate::Device for super::Device { vk::DescriptorBufferInfo::default() .buffer(binding.buffer.raw) .offset(binding.offset) - .range( - binding.size.map_or(vk::WHOLE_SIZE, wgt::BufferSize::get), - ) + .range(binding.size.get()) }, )); writes.push(