Restore the buffer size changes

This commit is contained in:
Andy Leiserson authored and Jim Blandy committed 2025-07-10 09:52:20 -07:00
1 parent 03f1b535ca
commit 27e7408f16
26 files changed
+422 -244

No files matched your search

+35 -8
View File
@@ -95,8 +95,39 @@ impl WebGpuError for CreateBindGroupLayoutError {
}
}
//TODO: refactor this to move out `enum BindingError`.
#[derive(Clone, Debug, Error)]
#[non_exhaustive]
pub enum BindingError {
#[error(transparent)]
DestroyedResource(#[from] DestroyedResourceError),
#[error("Buffer {buffer}: Binding with size {binding_size} at offset {offset} would overflow buffer size of {buffer_size}")]
BindingRangeTooLarge {
buffer: ResourceErrorIdent,
offset: wgt::BufferAddress,
binding_size: u64,
buffer_size: u64,
},
#[error("Buffer {buffer}: Binding offset {offset} is greater than buffer size {buffer_size}")]
BindingOffsetTooLarge {
buffer: ResourceErrorIdent,
offset: wgt::BufferAddress,
buffer_size: u64,
},
}
impl WebGpuError for BindingError {
fn webgpu_error_type(&self) -> ErrorType {
match self {
Self::DestroyedResource(e) => e.webgpu_error_type(),
Self::BindingRangeTooLarge { .. } | Self::BindingOffsetTooLarge { .. } => {
ErrorType::Validation
}
}
}
}
// TODO: there may be additional variants here that can be extracted into
// `BindingError`.
#[derive(Clone, Debug, Error)]
#[non_exhaustive]
pub enum CreateBindGroupError {
@@ -104,6 +135,8 @@ pub enum CreateBindGroupError {
Device(#[from] DeviceError),
#[error(transparent)]
DestroyedResource(#[from] DestroyedResourceError),
#[error(transparent)]
BindingError(#[from] BindingError),
#[error(
"Binding count declared with at most {expected} items, but {actual} items were provided"
)]
@@ -114,12 +147,6 @@ pub enum CreateBindGroupError {
BindingArrayLengthMismatch { actual: usize, expected: usize },
#[error("Array binding provided zero elements")]
BindingArrayZeroLength,
#[error("The bound range {range:?} of {buffer} overflows its size ({size})")]
BindingRangeTooLarge {
buffer: ResourceErrorIdent,
range: Range<wgt::BufferAddress>,
size: u64,
},
#[error("Binding size {actual} of {buffer} is less than minimum {min}")]
BindingSizeTooSmall {
buffer: ResourceErrorIdent,
@@ -234,6 +261,7 @@ impl WebGpuError for CreateBindGroupError {
let e: &dyn WebGpuError = match self {
Self::Device(e) => e,
Self::DestroyedResource(e) => e,
Self::BindingError(e) => e,
Self::MissingBufferUsage(e) => e,
Self::MissingTextureUsage(e) => e,
Self::ResourceUsageCompatibility(e) => e,
@@ -241,7 +269,6 @@ impl WebGpuError for CreateBindGroupError {
Self::BindingArrayPartialLengthMismatch { .. }
| Self::BindingArrayLengthMismatch { .. }
| Self::BindingArrayZeroLength
| Self::BindingRangeTooLarge { .. }
| Self::BindingSizeTooSmall { .. }
| Self::BindingsNumMismatch { .. }
| Self::BindingZeroSize(_)
+58 -27
View File
@@ -93,6 +93,7 @@ use core::{
use arrayvec::ArrayVec;
use thiserror::Error;
use wgpu_hal::ShouldBeNonZeroExt;
use wgt::error::{ErrorType, WebGpuError};
use crate::{
@@ -504,7 +505,7 @@ impl RenderBundleEncoder {
buffer_id,
index_format,
offset,
size,
size: size.map(NonZeroU64::get),
});
}
}
@@ -602,13 +603,14 @@ fn set_pipeline(
Ok(())
}
// This function is duplicative of `render::set_index_buffer`.
fn set_index_buffer(
state: &mut State,
buffer_guard: &crate::storage::Storage<Fallible<Buffer>>,
buffer_id: id::Id<id::markers::Buffer>,
index_format: wgt::IndexFormat,
offset: u64,
size: Option<NonZeroU64>,
size: Option<wgt::BufferSizeOrZero>,
) -> Result<(), RenderBundleErrorInner> {
let buffer = buffer_guard.get(buffer_id).get()?;
@@ -620,28 +622,27 @@ fn set_index_buffer(
buffer.same_device(&state.device)?;
buffer.check_usage(wgt::BufferUsages::INDEX)?;
let end = match size {
Some(s) => offset + s.get(),
None => buffer.size,
};
let end = buffer.resolve_binding_size(offset, size)?;
state
.buffer_memory_init_actions
.extend(buffer.initialization_status.read().create_action(
&buffer,
offset..end,
offset..end.get(),
MemoryInitKind::NeedsInitializedMemory,
));
state.set_index_buffer(buffer, index_format, offset..end);
state.set_index_buffer(buffer, index_format, offset..end.get());
Ok(())
}
// This function is duplicative of `render::set_vertex_buffer`.
fn set_vertex_buffer(
state: &mut State,
buffer_guard: &crate::storage::Storage<Fallible<Buffer>>,
slot: u32,
buffer_id: id::Id<id::markers::Buffer>,
offset: u64,
size: Option<NonZeroU64>,
size: Option<wgt::BufferSizeOrZero>,
) -> Result<(), RenderBundleErrorInner> {
let max_vertex_buffers = state.device.limits.max_vertex_buffers;
if slot >= max_vertex_buffers {
@@ -662,18 +663,16 @@ fn set_vertex_buffer(
buffer.same_device(&state.device)?;
buffer.check_usage(wgt::BufferUsages::VERTEX)?;
let end = match size {
Some(s) => offset + s.get(),
None => buffer.size,
};
let end = buffer.resolve_binding_size(offset, size)?;
state
.buffer_memory_init_actions
.extend(buffer.initialization_status.read().create_action(
&buffer,
offset..end,
offset..end.get(),
MemoryInitKind::NeedsInitializedMemory,
));
state.vertex[slot as usize] = Some(VertexState::new(buffer, offset..end));
state.vertex[slot as usize] = Some(VertexState::new(buffer, offset..end.get()));
Ok(())
}
@@ -965,10 +964,14 @@ impl RenderBundle {
size,
} => {
let buffer = buffer.try_raw(snatch_guard)?;
let bb = hal::BufferBinding {
buffer,
offset: *offset,
size: *size,
let bb = unsafe {
// SAFETY: The binding size was checked against the buffer size
// in `set_index_buffer` and again in `IndexState::flush`.
hal::BufferBinding::new_unchecked(
buffer,
*offset,
size.expect("size was resolved in `RenderBundleEncoder::finish`"),
)
};
unsafe { raw.set_index_buffer(bb, *index_format) };
}
@@ -979,10 +982,14 @@ impl RenderBundle {
size,
} => {
let buffer = buffer.try_raw(snatch_guard)?;
let bb = hal::BufferBinding {
buffer,
offset: *offset,
size: *size,
let bb = unsafe {
// SAFETY: The binding size was checked against the buffer size
// in `set_vertex_buffer` and again in `VertexState::flush`.
hal::BufferBinding::new_unchecked(
buffer,
*offset,
size.expect("size was resolved in `RenderBundleEncoder::finish`"),
)
};
unsafe { raw.set_vertex_buffer(*slot, bb) };
}
@@ -1131,6 +1138,9 @@ crate::impl_trackable!(RenderBundle);
/// [`RenderBundleEncoder::finish`] records the currently set index buffer here,
/// and calls [`State::flush_index`] before any indexed draw command to produce
/// a `SetIndexBuffer` command if one is necessary.
///
/// Binding ranges must be validated against the size of the buffer before
/// being stored in `IndexState`.
#[derive(Debug)]
struct IndexState {
buffer: Arc<Buffer>,
@@ -1152,13 +1162,21 @@ impl IndexState {
/// Generate a `SetIndexBuffer` command to prepare for an indexed draw
/// command, if needed.
fn flush(&mut self) -> Option<ArcRenderCommand> {
// This was all checked before, but let's check again just in case.
let binding_size = self
.range
.end
.checked_sub(self.range.start)
.filter(|_| self.range.end <= self.buffer.size)
.expect("index range must be contained in buffer");
if self.is_dirty {
self.is_dirty = false;
Some(ArcRenderCommand::SetIndexBuffer {
buffer: self.buffer.clone(),
index_format: self.format,
offset: self.range.start,
size: wgt::BufferSize::new(self.range.end - self.range.start),
size: Some(binding_size),
})
} else {
None
@@ -1174,6 +1192,9 @@ impl IndexState {
/// calls this type's [`flush`] method just before any draw command to
/// produce a `SetVertexBuffer` commands if one is necessary.
///
/// Binding ranges must be validated against the size of the buffer before
/// being stored in `VertexState`.
///
/// [`flush`]: IndexState::flush
#[derive(Debug)]
struct VertexState {
@@ -1183,6 +1204,9 @@ struct VertexState {
}
impl VertexState {
/// Create a new `VertexState`.
///
/// The `range` must be contained within `buffer`.
fn new(buffer: Arc<Buffer>, range: Range<wgt::BufferAddress>) -> Self {
Self {
buffer,
@@ -1195,13 +1219,20 @@ impl VertexState {
///
/// `slot` is the index of the vertex buffer slot that `self` tracks.
fn flush(&mut self, slot: u32) -> Option<ArcRenderCommand> {
let binding_size = self
.range
.end
.checked_sub(self.range.start)
.filter(|_| self.range.end <= self.buffer.size)
.expect("vertex range must be contained in buffer");
if self.is_dirty {
self.is_dirty = false;
Some(ArcRenderCommand::SetVertexBuffer {
slot,
buffer: self.buffer.clone(),
offset: self.range.start,
size: wgt::BufferSize::new(self.range.end - self.range.start),
size: Some(binding_size),
})
} else {
None
@@ -1565,7 +1596,7 @@ where
pub mod bundle_ffi {
use super::{RenderBundleEncoder, RenderCommand};
use crate::{id, RawString};
use core::{convert::TryInto, slice};
use core::{convert::TryInto, num::NonZeroU64, slice};
use wgt::{BufferAddress, BufferSize, DynamicOffset, IndexFormat};
/// # Safety
@@ -1624,7 +1655,7 @@ pub mod bundle_ffi {
slot,
buffer_id,
offset,
size,
size: size.map(NonZeroU64::get),
});
}
+4 -1
View File
@@ -7,7 +7,7 @@ use wgt::error::{ErrorType, WebGpuError};
use super::bind::BinderError;
use crate::command::pass;
use crate::{
binding_model::{LateMinBufferBindingSizeMismatch, PushConstantUploadError},
binding_model::{BindingError, LateMinBufferBindingSizeMismatch, PushConstantUploadError},
resource::{
DestroyedResourceError, MissingBufferUsageError, MissingTextureUsageError,
ResourceErrorIdent,
@@ -89,6 +89,8 @@ pub enum RenderCommandError {
MissingTextureUsage(#[from] MissingTextureUsageError),
#[error(transparent)]
PushConstants(#[from] PushConstantUploadError),
#[error(transparent)]
BindingError(#[from] BindingError),
#[error("Viewport size {{ w: {w}, h: {h} }} greater than device's requested `max_texture_dimension_2d` limit {max}, or less than zero")]
InvalidViewportRectSize { w: f32, h: f32, max: u32 },
#[error("Viewport has invalid rect {rect:?} for device's requested `max_texture_dimension_2d` limit; Origin less than -2 * `max_texture_dimension_2d` ({min}), or rect extends past 2 * `max_texture_dimension_2d` - 1 ({max})")]
@@ -110,6 +112,7 @@ impl WebGpuError for RenderCommandError {
Self::MissingBufferUsage(e) => e,
Self::MissingTextureUsage(e) => e,
Self::PushConstants(e) => e,
Self::BindingError(e) => e,
Self::BindGroupIndexOutOfRange { .. }
| Self::VertexBufferIndexOutOfRange { .. }
+32 -36
View File
@@ -1,12 +1,17 @@
use alloc::{borrow::Cow, sync::Arc, vec::Vec};
use core::{fmt, num::NonZeroU32, ops::Range, str};
use core::{
fmt,
num::{NonZeroU32, NonZeroU64},
str,
};
use hal::ShouldBeNonZeroExt;
use arrayvec::ArrayVec;
use thiserror::Error;
use wgt::{
error::{ErrorType, WebGpuError},
BufferAddress, BufferSize, BufferUsages, Color, DynamicOffset, IndexFormat, ShaderStages,
TextureSelector, TextureUsages, TextureViewDimension, VertexStepMode,
BufferAddress, BufferSize, BufferSizeOrZero, BufferUsages, Color, DynamicOffset, IndexFormat,
ShaderStages, TextureSelector, TextureUsages, TextureViewDimension, VertexStepMode,
};
use crate::command::{
@@ -357,13 +362,17 @@ struct IndexState {
}
impl IndexState {
fn update_buffer(&mut self, range: Range<BufferAddress>, format: IndexFormat) {
fn update_buffer<B: hal::DynBuffer + ?Sized>(
&mut self,
binding: &hal::BufferBinding<'_, B>,
format: IndexFormat,
) {
self.buffer_format = Some(format);
let shift = match format {
IndexFormat::Uint16 => 1,
IndexFormat::Uint32 => 2,
};
self.limit = (range.end - range.start) >> shift;
self.limit = binding.size.get() >> shift;
}
fn reset(&mut self) {
@@ -2323,13 +2332,14 @@ fn set_pipeline(
Ok(())
}
// This function is duplicative of `bundle::set_index_buffer`.
fn set_index_buffer(
state: &mut State,
cmd_buf: &Arc<CommandBuffer>,
buffer: Arc<crate::resource::Buffer>,
index_format: IndexFormat,
offset: u64,
size: Option<BufferSize>,
size: Option<BufferSizeOrZero>,
) -> Result<(), RenderPassErrorInner> {
api_log!("RenderPass::set_index_buffer {}", buffer.error_ident());
@@ -2342,40 +2352,34 @@ fn set_index_buffer(
buffer.same_device_as(cmd_buf.as_ref())?;
buffer.check_usage(BufferUsages::INDEX)?;
let buf_raw = buffer.try_raw(state.general.snatch_guard)?;
let end = match size {
Some(s) => offset + s.get(),
None => buffer.size,
};
state.index.update_buffer(offset..end, index_format);
let binding = buffer
.binding(offset, size, state.general.snatch_guard)
.map_err(RenderCommandError::from)?;
state.index.update_buffer(&binding, index_format);
state.general.buffer_memory_init_actions.extend(
buffer.initialization_status.read().create_action(
&buffer,
offset..end,
offset..(offset + binding.size.get()),
MemoryInitKind::NeedsInitializedMemory,
),
);
let bb = hal::BufferBinding {
buffer: buf_raw,
offset,
size,
};
unsafe {
hal::DynCommandEncoder::set_index_buffer(state.general.raw_encoder, bb, index_format);
hal::DynCommandEncoder::set_index_buffer(state.general.raw_encoder, binding, index_format);
}
Ok(())
}
// This function is duplicative of `render::set_vertex_buffer`.
fn set_vertex_buffer(
state: &mut State,
cmd_buf: &Arc<CommandBuffer>,
slot: u32,
buffer: Arc<crate::resource::Buffer>,
offset: u64,
size: Option<BufferSize>,
size: Option<BufferSizeOrZero>,
) -> Result<(), RenderPassErrorInner> {
api_log!(
"RenderPass::set_vertex_buffer {slot} {}",
@@ -2400,30 +2404,22 @@ fn set_vertex_buffer(
}
buffer.check_usage(BufferUsages::VERTEX)?;
let buf_raw = buffer.try_raw(state.general.snatch_guard)?;
//TODO: where are we checking that the offset is in bound?
let buffer_size = match size {
Some(s) => s.get(),
None => buffer.size - offset,
};
state.vertex.buffer_sizes[slot as usize] = Some(buffer_size);
let binding = buffer
.binding(offset, size, state.general.snatch_guard)
.map_err(RenderCommandError::from)?;
state.vertex.buffer_sizes[slot as usize] = Some(binding.size.get());
state.general.buffer_memory_init_actions.extend(
buffer.initialization_status.read().create_action(
&buffer,
offset..(offset + buffer_size),
offset..(offset + binding.size.get()),
MemoryInitKind::NeedsInitializedMemory,
),
);
let bb = hal::BufferBinding {
buffer: buf_raw,
offset,
size,
};
unsafe {
hal::DynCommandEncoder::set_vertex_buffer(state.general.raw_encoder, slot, bb);
hal::DynCommandEncoder::set_vertex_buffer(state.general.raw_encoder, slot, binding);
}
if let Some(pipeline) = state.pipeline.as_ref() {
state.vertex.update_limits(&pipeline.vertex_steps);
@@ -3094,7 +3090,7 @@ impl Global {
buffer: pass_try!(base, scope, self.resolve_render_pass_buffer_id(buffer_id)),
index_format,
offset,
size,
size: size.map(NonZeroU64::get),
});
Ok(())
@@ -3115,7 +3111,7 @@ impl Global {
slot,
buffer: pass_try!(base, scope, self.resolve_render_pass_buffer_id(buffer_id)),
offset,
size,
size: size.map(NonZeroU64::get),
});
Ok(())
+23 -5
View File
@@ -1,6 +1,6 @@
use alloc::sync::Arc;
use wgt::{BufferAddress, BufferSize, Color};
use wgt::{BufferAddress, BufferSizeOrZero, Color};
use super::{Rect, RenderBundle};
use crate::{
@@ -24,13 +24,13 @@ pub enum RenderCommand {
buffer_id: id::BufferId,
index_format: wgt::IndexFormat,
offset: BufferAddress,
size: Option<BufferSize>,
size: Option<BufferSizeOrZero>,
},
SetVertexBuffer {
slot: u32,
buffer_id: id::BufferId,
offset: BufferAddress,
size: Option<BufferSize>,
size: Option<BufferSizeOrZero>,
},
SetBlendConstant(Color),
SetStencilReference(u32),
@@ -392,6 +392,17 @@ impl RenderCommand {
}
/// Equivalent to `RenderCommand` with the Ids resolved into resource Arcs.
///
/// In a render pass, commands are stored in this format between when they are
/// added to the pass, and when the pass is `end()`ed and the commands are
/// replayed to the HAL encoder. Validation occurs when the pass is ended, which
/// means that parameters stored in an `ArcRenderCommand` for a pass operation
/// have generally not been validated.
///
/// In a render bundle, commands are stored in this format between when the bundle
/// is `finish()`ed and when the bundle is executed. Validation occurs when the
/// bundle is finished, which means that parameters stored in an `ArcRenderCommand`
/// for a render bundle operation must have been validated.
#[doc(hidden)]
#[derive(Clone, Debug)]
pub enum ArcRenderCommand {
@@ -405,13 +416,20 @@ pub enum ArcRenderCommand {
buffer: Arc<Buffer>,
index_format: wgt::IndexFormat,
offset: BufferAddress,
size: Option<BufferSize>,
// For a render pass, this reflects the argument passed by the
// application, which may be `None`. For a finished render bundle, this
// reflects the validated size of the binding, and will be populated
// even in the case that the application omitted the size.
size: Option<BufferSizeOrZero>,
},
SetVertexBuffer {
slot: u32,
buffer: Arc<Buffer>,
offset: BufferAddress,
size: Option<BufferSize>,
// See comment in `SetIndexBuffer`.
size: Option<BufferSizeOrZero>,
},
SetBlendConstant(Color),
SetStencilReference(u32),
+2 -1
View File
@@ -385,6 +385,7 @@ impl Global {
/// - `hal_buffer` must be created from `device_id` corresponding raw handle.
/// - `hal_buffer` must be created respecting `desc`
/// - `hal_buffer` must be initialized
/// - `hal_buffer` must not have zero size.
pub unsafe fn create_buffer_from_hal<A: HalApi>(
&self,
hal_buffer: A::Buffer,
@@ -406,7 +407,7 @@ impl Global {
trace.add(trace::Action::CreateBuffer(fid.id(), desc.clone()));
}
let (buffer, err) = device.create_buffer_from_hal(Box::new(hal_buffer), desc);
let (buffer, err) = unsafe { device.create_buffer_from_hal(Box::new(hal_buffer), desc) };
let id = fid.assign(buffer);
api_log!("Device::create_buffer -> {id:?}");
+38 -54
View File
@@ -8,9 +8,10 @@ use alloc::{
use core::{
fmt,
mem::{self, ManuallyDrop},
num::NonZeroU32,
num::{NonZeroU32, NonZeroU64},
sync::atomic::{AtomicBool, Ordering},
};
use hal::ShouldBeNonZeroExt;
use arrayvec::ArrayVec;
use bitflags::Flags;
@@ -702,7 +703,8 @@ impl Device {
let buffer = unsafe { self.raw().create_buffer(&hal_desc) }
.map_err(|e| self.handle_hal_error_with_nonfatal_oom(e))?;
let timestamp_normalization_bind_group = Snatchable::new(
let timestamp_normalization_bind_group = Snatchable::new(unsafe {
// SAFETY: The size passed here must not overflow the buffer.
self.timestamp_normalizer
.get()
.unwrap()
@@ -710,10 +712,10 @@ impl Device {
self,
&*buffer,
desc.label.as_deref(),
desc.size,
wgt::BufferSize::new(hal_desc.size).unwrap(),
desc.usage,
)?,
);
)
}?);
let indirect_validation_bind_groups =
self.create_indirect_validation_bind_groups(buffer.as_ref(), desc.size, desc.usage)?;
@@ -809,28 +811,36 @@ impl Device {
Ok(texture)
}
pub(crate) fn create_buffer_from_hal(
/// # 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.
pub(crate) unsafe fn create_buffer_from_hal(
self: &Arc<Self>,
hal_buffer: Box<dyn hal::DynBuffer>,
desc: &resource::BufferDescriptor,
) -> (Fallible<Buffer>, Option<resource::CreateBufferError>) {
let timestamp_normalization_bind_group = match self
.timestamp_normalizer
.get()
.unwrap()
.create_normalization_bind_group(
self,
&*hal_buffer,
desc.label.as_deref(),
desc.size,
desc.usage,
) {
Ok(bg) => Snatchable::new(bg),
Err(e) => {
return (
Fallible::Invalid(Arc::new(desc.label.to_string())),
Some(e.into()),
)
let timestamp_normalization_bind_group = unsafe {
match self
.timestamp_normalizer
.get()
.unwrap()
.create_normalization_bind_group(
self,
&*hal_buffer,
desc.label.as_deref(),
wgt::BufferSize::new(desc.size).unwrap(),
desc.usage,
) {
Ok(bg) => Snatchable::new(bg),
Err(e) => {
return (
Fallible::Invalid(Arc::new(desc.label.to_string())),
Some(e.into()),
)
}
}
};
@@ -2187,31 +2197,9 @@ impl Device {
buffer.same_device(self)?;
buffer.check_usage(pub_usage)?;
let raw_buffer = buffer.try_raw(snatch_guard)?;
let (bind_size, bind_end) = match bb.size {
Some(size) => {
let end = bb.offset + size.get();
if end > buffer.size {
return Err(Error::BindingRangeTooLarge {
buffer: buffer.error_ident(),
range: bb.offset..end,
size: buffer.size,
});
}
(size.get(), end)
}
None => {
if buffer.size < bb.offset {
return Err(Error::BindingRangeTooLarge {
buffer: buffer.error_ident(),
range: bb.offset..bb.offset,
size: buffer.size,
});
}
(buffer.size - bb.offset, buffer.size)
}
};
let bb = buffer.binding(bb.offset, bb.size.map(NonZeroU64::get), snatch_guard)?;
let bind_size = bb.size.get();
if bind_size > range_limit as u64 {
return Err(Error::BufferRangeTooLarge {
@@ -2226,8 +2214,8 @@ impl Device {
dynamic_binding_info.push(binding_model::BindGroupDynamicBindingData {
binding_idx: binding,
buffer_size: buffer.size,
binding_range: bb.offset..bind_end,
maximum_dynamic_offset: buffer.size - bind_end,
binding_range: bb.offset..bb.offset + bind_size,
maximum_dynamic_offset: buffer.size - bb.offset - bind_size,
binding_type: binding_ty,
});
}
@@ -2265,11 +2253,7 @@ impl Device {
MemoryInitKind::NeedsInitializedMemory,
));
Ok(hal::BufferBinding {
buffer: raw_buffer,
offset: bb.offset,
size: bb.size,
})
Ok(bb)
}
fn create_sampler_binding<'a>(
@@ -232,10 +232,9 @@ impl Dispatch {
resource_index: 0,
count: 1,
}],
buffers: &[hal::BufferBinding {
buffer: dst_buffer.as_ref(),
offset: 0,
size: Some(DST_BUFFER_SIZE),
buffers: &[unsafe {
// SAFETY: We just created the buffer with this size.
hal::BufferBinding::new_unchecked(dst_buffer.as_ref(), 0, DST_BUFFER_SIZE)
}],
samplers: &[],
textures: &[],
@@ -278,10 +277,9 @@ impl Dispatch {
resource_index: 0,
count: 1,
}],
buffers: &[hal::BufferBinding {
buffer,
offset: 0,
size: Some(binding_size),
buffers: &[unsafe {
// SAFETY: We calculated the binding size to fit within the buffer.
hal::BufferBinding::new_unchecked(buffer, 0, binding_size)
}],
samplers: &[],
textures: &[],
+6 -8
View File
@@ -135,10 +135,9 @@ impl Draw {
resource_index: 0,
count: 1,
}],
buffers: &[hal::BufferBinding {
buffer,
offset: 0,
size: Some(binding_size),
buffers: &[unsafe {
// SAFETY: We calculated the binding size to fit within the buffer.
hal::BufferBinding::new_unchecked(buffer, 0, binding_size)
}],
samplers: &[],
textures: &[],
@@ -684,10 +683,9 @@ fn create_buffer_and_bind_group(
resource_index: 0,
count: 1,
}],
buffers: &[hal::BufferBinding {
buffer: buffer.as_ref(),
offset: 0,
size: Some(BUFFER_SIZE),
buffers: &[unsafe {
// SAFETY: We just created the buffer with this size.
hal::BufferBinding::new_unchecked(buffer.as_ref(), 0, BUFFER_SIZE)
}],
samplers: &[],
textures: &[],
+76 -1
View File
@@ -17,7 +17,7 @@ use wgt::{
#[cfg(feature = "trace")]
use crate::device::trace;
use crate::{
binding_model::BindGroup,
binding_model::{BindGroup, BindingError},
device::{
queue, resource::DeferredDestroy, BufferMapPendingClosure, Device, DeviceError,
DeviceMismatch, HostMap, MissingDownlevelFlags, MissingFeatures,
@@ -494,6 +494,81 @@ impl Buffer {
}
}
/// Resolve the size of a binding for buffer with `offset` and `size`.
///
/// If `size` is `None`, then the remainder of the buffer starting from
/// `offset` is used.
///
/// If the binding would overflow the buffer, then an error is returned.
///
/// Zero-size bindings are permitted here for historical reasons. Although
/// 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(
&self,
offset: wgt::BufferAddress,
binding_size: Option<wgt::BufferSizeOrZero>,
) -> Result<wgt::BufferSizeOrZero, BindingError> {
let buffer_size = self.size;
match binding_size {
Some(binding_size) => match offset.checked_add(binding_size) {
Some(end) if end <= buffer_size => Ok(binding_size),
_ => Err(BindingError::BindingRangeTooLarge {
buffer: self.error_ident(),
offset,
binding_size,
buffer_size,
}),
},
None => {
buffer_size
.checked_sub(offset)
.ok_or_else(|| BindingError::BindingOffsetTooLarge {
buffer: self.error_ident(),
offset,
buffer_size,
})
}
}
}
/// Create a new [`hal::BufferBinding`] for the buffer with `offset` and
/// `size`.
///
/// If `size` is `None`, then the remainder of the buffer starting from
/// `offset` is used.
///
/// If the binding would overflow the buffer, then an error is returned.
///
/// Zero-size bindings are permitted here for historical reasons. Although
/// zero-size bindings are permitted by WebGPU, they are not permitted by
/// some backends. Previous documentation for `hal::BufferBinding`
/// disallowed zero-size bindings, but this restriction was not honored
/// elsewhere in the code. Zero-size bindings need to be quashed or remapped
/// to a non-zero size, either universally in wgpu-core, or in specific
/// backends that do not support them. See
/// [#3170](https://github.com/gfx-rs/wgpu/issues/3170).
pub fn binding<'a>(
&'a self,
offset: wgt::BufferAddress,
binding_size: Option<wgt::BufferSizeOrZero>,
snatch_guard: &'a SnatchGuard,
) -> Result<hal::BufferBinding<'a, dyn hal::DynBuffer>, BindingError> {
let buf_raw = self.try_raw(snatch_guard)?;
let resolved_size = self.resolve_binding_size(offset, binding_size)?;
unsafe {
// 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,
resolved_size,
))
}
}
/// Returns the mapping callback in case of error so that the callback can be fired outside
/// of the locks that are held in this function.
pub(crate) fn map_async(
+8 -8
View File
@@ -242,12 +242,16 @@ impl TimestampNormalizer {
}
}
pub fn create_normalization_bind_group(
/// 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.
pub unsafe fn create_normalization_bind_group(
&self,
device: &Device,
buffer: &dyn hal::DynBuffer,
buffer_label: Option<&str>,
buffer_size: u64,
buffer_size: wgt::BufferSize,
buffer_usages: wgt::BufferUsages,
) -> Result<TimestampNormalizationBindGroup, DeviceError> {
unsafe {
@@ -263,7 +267,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 > device.adapter.limits().max_storage_buffer_binding_size as u64 {
if buffer_size.get() > device.adapter.limits().max_storage_buffer_binding_size as u64 {
return Err(DeviceError::OutOfMemory);
}
@@ -282,11 +286,7 @@ impl TimestampNormalizer {
.create_bind_group(&hal::BindGroupDescriptor {
label: Some(label),
layout: &*state.temporary_bind_group_layout,
buffers: &[hal::BufferBinding {
buffer,
offset: 0,
size: None,
}],
buffers: &[hal::BufferBinding::new_unchecked(buffer, 0, buffer_size)],
samplers: &[],
textures: &[],
acceleration_structures: &[],
+10 -8
View File
@@ -445,10 +445,9 @@ impl<A: hal::Api> Example<A> {
let texture_view = unsafe { device.create_texture_view(&texture, &view_desc).unwrap() };
let global_group = {
let global_buffer_binding = hal::BufferBinding {
buffer: &global_buffer,
offset: 0,
size: None,
let global_buffer_binding = unsafe {
// SAFETY: This is the same size that was specified for buffer creation.
hal::BufferBinding::new_unchecked(&global_buffer, 0, global_buffer_desc.size)
};
let texture_binding = hal::TextureBinding {
view: &texture_view,
@@ -483,10 +482,13 @@ impl<A: hal::Api> Example<A> {
};
let local_group = {
let local_buffer_binding = hal::BufferBinding {
buffer: &local_buffer,
offset: 0,
size: wgpu_types::BufferSize::new(size_of::<Locals>() as _),
let local_buffer_binding = unsafe {
// SAFETY: The size must fit within the buffer.
hal::BufferBinding::new_unchecked(
&local_buffer,
0,
wgpu_types::BufferSize::new(size_of::<Locals>() as _).unwrap(),
)
};
let local_group_desc = hal::BindGroupDescriptor {
label: Some("local"),
@@ -603,10 +603,13 @@ impl<A: hal::Api> Example<A> {
let texture_view = unsafe { device.create_texture_view(&texture, &view_desc).unwrap() };
let bind_group = {
let buffer_binding = hal::BufferBinding {
buffer: &uniform_buffer,
offset: 0,
size: None,
let buffer_binding = unsafe {
// SAFETY: The size matches the buffer allocation.
hal::BufferBinding::new_unchecked(
&uniform_buffer,
0,
wgpu_types::BufferSize::new_unchecked(uniforms_size as u64),
)
};
let texture_binding = hal::TextureBinding {
view: &texture_view,
+2 -2
View File
@@ -1136,7 +1136,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
) {
let ibv = Direct3D12::D3D12_INDEX_BUFFER_VIEW {
BufferLocation: binding.resolve_address(),
SizeInBytes: binding.resolve_size() as u32,
SizeInBytes: binding.size.try_into().unwrap(),
Format: auxil::dxgi::conv::map_index_format(format),
};
@@ -1149,7 +1149,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
) {
let vb = &mut self.pass.vertex_buffers[index as usize];
vb.BufferLocation = binding.resolve_address();
vb.SizeInBytes = binding.resolve_size() as u32;
vb.SizeInBytes = binding.size.try_into().unwrap();
self.pass.dirty_vertex_buffers |= 1 << index;
}
+1 -1
View File
@@ -1442,7 +1442,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() as u32;
let mut size = data.size.try_into().unwrap();
if has_dynamic_offset {
match ty {
-7
View File
@@ -865,13 +865,6 @@ 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,
}
}
// TODO: Return GPU handle directly?
fn resolve_address(&self) -> wgt::BufferAddress {
(unsafe { self.buffer.resource.GetGPUVirtualAddress() }) + self.offset
+3 -7
View File
@@ -534,7 +534,6 @@ impl crate::Device for super::Device {
return Ok(super::Buffer {
raw: None,
target,
size: desc.size,
map_flags: 0,
data: Some(Arc::new(MaybeMutex::new(vec![0; desc.size as usize]))),
offset_of_current_mapping: Arc::new(MaybeMutex::new(0)),
@@ -634,7 +633,6 @@ impl crate::Device for super::Device {
Ok(super::Buffer {
raw,
target,
size: desc.size,
map_flags,
data,
offset_of_current_mapping: Arc::new(MaybeMutex::new(0)),
@@ -1263,13 +1261,11 @@ impl crate::Device for super::Device {
let binding = match layout.ty {
wgt::BindingType::Buffer { .. } => {
let bb = &desc.buffers[entry.resource_index as usize];
assert!(bb.size != 0, "zero-size bindings are not supported");
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,
},
offset: bb.offset.try_into().unwrap(),
size: bb.size.try_into().unwrap(),
}
}
wgt::BindingType::Sampler { .. } => {
-1
View File
@@ -342,7 +342,6 @@ impl Drop for Queue {
pub struct Buffer {
raw: Option<glow::Buffer>,
target: BindTarget,
size: wgt::BufferAddress,
map_flags: u32,
data: Option<Arc<MaybeMutex<Vec<u8>>>>,
offset_of_current_mapping: Arc<MaybeMutex<wgt::BufferAddress>>,
+83 -19
View File
@@ -297,7 +297,7 @@ use core::{
borrow::Borrow,
error::Error,
fmt,
num::NonZeroU32,
num::{NonZeroU32, NonZeroU64},
ops::{Range, RangeInclusive},
ptr::NonNull,
};
@@ -1968,11 +1968,18 @@ pub struct PipelineLayoutDescriptor<'a, B: DynBindGroupLayout + ?Sized> {
///
/// [`BindGroup`]: Api::BindGroup
///
/// ## Construction
///
/// The recommended way to construct a `BufferBinding` is using the `binding`
/// method on a wgpu-core `Buffer`, which will validate the binding size
/// against the buffer size. An unsafe `new_unchecked` constructor is also
/// provided for cases where direct construction is necessary.
///
/// ## Accessible region
///
/// `wgpu_hal` guarantees that shaders compiled with
/// [`ShaderModuleDescriptor::runtime_checks`] set to `true` cannot read or
/// write data via this binding outside the *accessible region* of [`buffer`]:
/// write data via this binding outside the *accessible region* of a buffer:
///
/// - The accessible region starts at [`offset`].
///
@@ -1992,39 +1999,47 @@ pub struct PipelineLayoutDescriptor<'a, B: DynBindGroupLayout + ?Sized> {
/// parts of which buffers shaders might observe. This optimization is only
/// sound if shader access is bounds-checked.
///
/// [`buffer`]: BufferBinding::buffer
/// ## Zero-length bindings
///
/// Some back ends cannot tolerate zero-length regions; for example, see
/// [VUID-VkDescriptorBufferInfo-offset-00340][340] and
/// [VUID-VkDescriptorBufferInfo-range-00341][341], or the
/// documentation for GLES's [glBindBufferRange][bbr]. This documentation
/// previously stated that a `BufferBinding` must have `offset` strictly less
/// than the size of the buffer, but this restriction was not honored elsewhere
/// in the code, so has been removed. However, it remains the case that
/// some backends do not support zero-length bindings, so additional
/// logic is needed somewhere to handle this properly. See
/// [#3170](https://github.com/gfx-rs/wgpu/issues/3170).
///
/// [`offset`]: BufferBinding::offset
/// [`size`]: BufferBinding::size
/// [`Storage`]: wgt::BufferBindingType::Storage
/// [`Uniform`]: wgt::BufferBindingType::Uniform
/// [340]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-offset-00340
/// [341]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00341
/// [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> {
/// The buffer being bound.
pub buffer: &'a B,
///
/// This is not fully `pub` to prevent direct construction of
/// `BufferBinding`s, while still allowing public read access to the `offset`
/// and `size` properties.
pub(crate) buffer: &'a B,
/// The offset at which the bound region starts.
///
/// This must be less than the size of the buffer. Some back ends
/// cannot tolerate zero-length regions; for example, see
/// [VUID-VkDescriptorBufferInfo-offset-00340][340] and
/// [VUID-VkDescriptorBufferInfo-range-00341][341], or the
/// documentation for GLES's [glBindBufferRange][bbr].
///
/// [340]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-offset-00340
/// [341]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00341
/// [bbr]: https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glBindBufferRange.xhtml
/// This must be less or equal to the size of the buffer.
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<wgt::BufferSize>,
pub size: wgt::BufferSizeOrZero,
}
impl<'a, T: DynBuffer + ?Sized> Clone for BufferBinding<'a, T> {
// We must implement this manually because `B` is not necessarily `Clone`.
impl<B: DynBuffer + ?Sized> Clone for BufferBinding<'_, B> {
fn clone(&self) -> Self {
BufferBinding {
buffer: self.buffer,
@@ -2034,6 +2049,55 @@ impl<'a, T: DynBuffer + ?Sized> Clone for BufferBinding<'a, T> {
}
}
/// Temporary convenience trait to let us call `.get()` on `u64`s in code that
/// really wants to be using `NonZeroU64`.
/// TODO(<https://github.com/gfx-rs/wgpu/issues/3170>): remove this
pub trait ShouldBeNonZeroExt {
fn get(&self) -> u64;
}
impl ShouldBeNonZeroExt for NonZeroU64 {
fn get(&self) -> u64 {
NonZeroU64::get(*self)
}
}
impl ShouldBeNonZeroExt for u64 {
fn get(&self) -> u64 {
*self
}
}
impl<'a, B: DynBuffer + ?Sized> BufferBinding<'a, B> {
/// Construct a `BufferBinding` with the given contents.
///
/// When possible, use the `binding` method on a wgpu-core `Buffer` instead
/// of this method. `Buffer::binding` validates the size of the binding
/// against the size of the buffer.
///
/// It is more difficult to provide a validating constructor here, due to
/// 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 either a `u64` or a `NonZeroU64`. When the zero-size binding issue
/// is resolved, the argument should just match the type of the member.
/// TODO(<https://github.com/gfx-rs/wgpu/issues/3170>): remove the parameter
pub unsafe fn new_unchecked<S: Into<wgt::BufferSizeOrZero>>(
buffer: &'a B,
offset: wgt::BufferAddress,
size: S,
) -> Self {
Self {
buffer,
offset,
size: size.into(),
}
}
}
#[derive(Debug)]
pub struct TextureBinding<'a, T: DynTextureView + ?Sized> {
pub view: &'a T,
+6 -10
View File
@@ -4,7 +4,7 @@ use alloc::{
borrow::{Cow, ToOwned as _},
vec::Vec,
};
use core::ops::Range;
use core::{num::NonZeroU64, ops::Range};
use metal::{
MTLIndexType, MTLLoadAction, MTLPrimitiveType, MTLScissorRect, MTLSize, MTLStoreAction,
MTLViewport, MTLVisibilityResultMode, NSRange,
@@ -977,15 +977,11 @@ impl crate::CommandEncoder for super::CommandEncoder {
let encoder = self.state.render.as_ref().unwrap();
encoder.set_vertex_buffer(buffer_index, Some(&binding.buffer.raw), binding.offset);
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);
}
// https://github.com/gfx-rs/wgpu/issues/3170
let size =
NonZeroU64::new(binding.size).expect("zero-size vertex buffers are not supported");
self.state.vertex_buffer_size_map.insert(buffer_index, size);
if let Some((index, sizes)) = self
.state
+6 -15
View File
@@ -1,5 +1,5 @@
use alloc::{borrow::ToOwned as _, sync::Arc, vec::Vec};
use core::{ptr::NonNull, sync::atomic};
use core::{num::NonZeroU64, ptr::NonNull, sync::atomic};
use std::{thread, time};
use parking_lot::Mutex;
@@ -340,10 +340,6 @@ impl super::Device {
}
}
pub unsafe fn buffer_from_raw(raw: metal::Buffer, size: wgt::BufferAddress) -> super::Buffer {
super::Buffer { raw, size }
}
pub fn raw_device(&self) -> &Mutex<metal::Device> {
&self.shared.device
}
@@ -373,10 +369,7 @@ impl crate::Device for super::Device {
raw.set_label(label);
}
self.counters.buffers.add(1);
Ok(super::Buffer {
raw,
size: desc.size,
})
Ok(super::Buffer { raw })
})
}
unsafe fn destroy_buffer(&self, _buffer: super::Buffer) {
@@ -935,14 +928,12 @@ 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,
);
// https://github.com/gfx-rs/wgpu/issues/3170
let source_size = NonZeroU64::new(source.size)
.expect("zero-size bindings are not supported");
let binding_size = match ty {
wgt::BufferBindingType::Storage { .. } => {
source.size.or(remaining_size)
Some(source_size)
}
_ => None,
};
-10
View File
@@ -502,7 +502,6 @@ impl crate::Queue for Queue {
#[derive(Debug)]
pub struct Buffer {
raw: metal::Buffer,
size: wgt::BufferAddress,
}
unsafe impl Send for Buffer {}
@@ -516,15 +515,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: metal::Texture,
+3 -3
View File
@@ -1804,12 +1804,12 @@ impl crate::Device for super::Device {
(buffer_infos, local_buffer_infos) =
buffer_infos.extend(desc.buffers[start as usize..end as usize].iter().map(
|binding| {
// https://github.com/gfx-rs/wgpu/issues/3170
assert!(binding.size != 0, "zero-size bindings are not supported");
vk::DescriptorBufferInfo::default()
.buffer(binding.buffer.raw)
.offset(binding.offset)
.range(
binding.size.map_or(vk::WHOLE_SIZE, wgt::BufferSize::get),
)
.range(binding.size)
},
));
write.buffer_info(local_buffer_infos)
+6
View File
@@ -61,6 +61,12 @@ pub type BufferAddress = u64;
/// [`BufferSlice`]: ../wgpu/struct.BufferSlice.html
pub type BufferSize = core::num::NonZeroU64;
/// Integral type used for buffer sizes that may be zero.
///
/// Although the wgpu Rust API disallows zero-size `BufferSlice` and wgpu-hal
/// disallows zero-size bindings, WebGPU permits zero-size buffers and bindings.
pub type BufferSizeOrZero = u64;
/// Integral type used for binding locations in shaders.
///
/// Used in [`VertexAttribute`]s and errors.
+1
View File
@@ -324,6 +324,7 @@ impl Device {
/// - `hal_buffer` must be created from this device internal handle
/// - `hal_buffer` must be created respecting `desc`
/// - `hal_buffer` must be initialized
/// - `hal_buffer` must not have zero size
#[cfg(wgpu_core)]
#[must_use]
pub unsafe fn create_buffer_from_hal<A: wgc::hal_api::HalApi>(
+6
View File
@@ -166,6 +166,12 @@ impl ContextWgpuCore {
}
}
/// # Safety
///
/// - `hal_buffer` must be created from `device`.
/// - `hal_buffer` must be created respecting `desc`
/// - `hal_buffer` must be initialized
/// - `hal_buffer` must not have zero size.
pub unsafe fn create_buffer_from_hal<A: wgc::hal_api::HalApi>(
&self,
hal_buffer: A::Buffer,