get_mapped_range return Mapping which holds the BufferState lock

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
sagudev authored and mergify[bot] committed 2026-10-08 11:08:30 +00:00
1 parent 03017a1aba
commit f4455f178d
11 files changed
+156 -53

No files matched your search

+23 -12
View File
@@ -200,7 +200,7 @@ impl GPUBuffer {
#[webidl(default = 0)] offset: u64,
#[webidl] size: Option<u64>,
) -> Result<v8::Local<'s, v8::ArrayBuffer>, BufferError> {
let (slice_pointer, range_size) = self
let mapping = self
.wgpu_buffer
.get_mapped_range(offset, size)
.map_err(BufferError::Access)?;
@@ -209,28 +209,39 @@ impl GPUBuffer {
let mode = mode.as_ref().unwrap();
let bs = if mode == &MapMode::Write {
unsafe extern "C" fn noop_deleter_callback(
// FIXME: this mapping strategy is only safe when MAPPABLE_PRIMARY_BUFFERS
// are not used, otherwise user can inspect write combing.
unsafe extern "C" fn deleter_callback(
_data: *mut std::ffi::c_void,
_byte_length: usize,
_deleter_data: *mut std::ffi::c_void,
deleter_data: *mut std::ffi::c_void,
) {
// SAFETY: Box::into_raw is down bellow
let mapping: Box<wgpu_core::resource::BufferMapping> =
unsafe { Box::from_raw(deleter_data as *mut _) };
drop(mapping);
}
let mapping: Box<wgpu_core::resource::BufferMapping> = Box::new(mapping);
// SAFETY: creating a backing store from the pointer and length provided by wgpu
unsafe {
v8::ArrayBuffer::new_backing_store_from_ptr(
slice_pointer.as_ptr() as _,
range_size as usize,
noop_deleter_callback,
std::ptr::null_mut(),
mapping.ptr().as_ptr() as _,
mapping.len() as usize,
deleter_callback,
Box::into_raw(mapping) as *mut std::ffi::c_void,
)
}
} else {
// SAFETY: creating a vector from the pointer and length provided by wgpu
let slice = unsafe {
std::slice::from_raw_parts(slice_pointer.as_ptr(), range_size as usize)
};
v8::ArrayBuffer::new_backing_store_from_vec(slice.to_vec())
// SAFETY: buffer is mapped for read
// FIXME: but there are overlapping views
let slice = unsafe { mapping.slice() };
let vec = slice.to_vec();
drop(mapping);
v8::ArrayBuffer::new_backing_store_from_vec(vec)
};
let shared_bs = bs.make_shared();
+4 -3
View File
@@ -18,7 +18,6 @@ use std::{
fs::{read_to_string, File},
io::{Read, Seek, SeekFrom},
path::{Path, PathBuf},
slice,
sync::Arc,
};
use wgc::{command::PointerReferences, device::trace::DiskTraceLoader};
@@ -118,11 +117,10 @@ impl Test<'_> {
for expect in self.expectations {
println!("\t\t\tChecking {}", expect.name);
let (ptr, size) = player
let mapping = player
.resolve_buffer_id(expect.buffer)
.get_mapped_range(expect.offset, Some(expect.data.len() as wgt::BufferAddress))
.unwrap();
let contents = unsafe { slice::from_raw_parts(ptr.as_ptr(), size as usize) };
let expected_data = match expect.data {
ExpectedData::Raw(vec) => vec,
ExpectedData::File(name, size) => {
@@ -139,11 +137,14 @@ impl Test<'_> {
.collect::<Vec<u8>>(),
};
// SAFETY: Buffer is mapped for read and this is only mapping
let contents = unsafe { mapping.slice() };
if &expected_data[..] != contents {
panic!(
"Test expectation is not met!\nBuffer content was:\n{contents:?}\nbut expected:\n{expected_data:?}"
);
}
drop(mapping);
}
}
}
+2 -3
View File
@@ -1,6 +1,5 @@
use alloc::{borrow::Cow, boxed::Box, sync::Arc, vec::Vec};
use core::ops::Deref;
use core::ptr::NonNull;
use wgpu_core_remote_types::{
encoders::{RenderBundleDescriptor, RenderBundleEncoderDescriptor},
pipelines::{ComputePipelineDescriptor, RenderPipelineDescriptor},
@@ -18,7 +17,7 @@ use wgpu_core::{
self, ProgrammableStageDescriptor, RenderPipelineVertexProcessor,
ResolvedGeneralRenderPipelineDescriptor,
},
resource::{self, BufferAccessError, BufferMapOperation, CreateBufferError},
resource::{self, BufferAccessError, BufferMapOperation, BufferMapping, CreateBufferError},
Label, LabelHelpers, SubmissionIndex,
};
@@ -1290,7 +1289,7 @@ impl Global {
buffer_id: id::BufferId,
offset: BufferAddress,
size: Option<BufferAddress>,
) -> Result<(NonNull<u8>, u64), BufferAccessError> {
) -> Result<BufferMapping, BufferAccessError> {
let hub = self.hub.borrow();
let buffer = hub.buffers.get(buffer_id);
+2 -2
View File
@@ -876,7 +876,7 @@ impl Queue {
buffer_offset: u64,
buffer_size: u64,
) -> Result<(), TransferError> {
if !matches!(&*buffer.map_state.lock(), BufferMapState::Idle) {
if !matches!(&*buffer.map_state.read(), BufferMapState::Idle) {
return Err(TransferError::BufferNotAvailable);
}
buffer.check_usage(wgt::BufferUsages::COPY_DST)?;
@@ -2135,7 +2135,7 @@ fn validate_command_buffer(
for buffer in cmd_buf_data.trackers.buffers.used_resources() {
buffer.check_destroyed(snatch_guard)?;
match *buffer.map_state.lock() {
match *buffer.map_state.read() {
BufferMapState::Idle => (),
_ => return Err(QueueSubmitError::BufferStillMapped(buffer.error_ident())),
}
+10 -4
View File
@@ -1374,7 +1374,10 @@ impl Device {
rank::BUFFER_INITIALIZATION_STATUS,
BufferInitTracker::new(tail_start),
),
map_state: Mutex::new(rank::BUFFER_MAP_STATE, resource::BufferMapState::Idle),
map_state: Arc::new(RwLock::new(
rank::BUFFER_MAP_STATE,
resource::BufferMapState::Idle,
)),
label: desc.label.to_string(),
tracking_data: TrackingData::new(self.tracker_indices.buffers.clone()),
bind_groups: Mutex::new(rank::BUFFER_BIND_GROUPS, WeakVec::new()),
@@ -1454,7 +1457,7 @@ impl Device {
map_buffer(&buffer, 0, map_size, MapMode::Write, &snatch_guard)?
};
drop(snatch_guard);
*buffer.map_state.lock() = resource::BufferMapState::Active {
*buffer.map_state.write() = resource::BufferMapState::Active {
mapping,
range: 0..map_size,
host: MapMode::Write,
@@ -1475,7 +1478,7 @@ impl Device {
staging_buffer.write_zeros();
buffer.initialization_status.write().drain(0..final_size);
*buffer.map_state.lock() = resource::BufferMapState::Init { staging_buffer };
*buffer.map_state.write() = resource::BufferMapState::Init { staging_buffer };
wgt::BufferUses::COPY_DST
};
@@ -1741,7 +1744,10 @@ impl Device {
rank::BUFFER_INITIALIZATION_STATUS,
BufferInitTracker::new(0),
),
map_state: Mutex::new(rank::BUFFER_MAP_STATE, resource::BufferMapState::Idle),
map_state: Arc::new(RwLock::new(
rank::BUFFER_MAP_STATE,
resource::BufferMapState::Idle,
)),
label: desc.label.to_string(),
tracking_data: TrackingData::new(self.tracker_indices.buffers.clone()),
bind_groups: Mutex::new(rank::BUFFER_BIND_GROUPS, WeakVec::new()),
+8 -4
View File
@@ -79,10 +79,6 @@ impl<T> Mutex<T> {
}
}
pub fn get_mut(&mut self) -> &mut T {
self.inner.get_mut()
}
pub fn into_inner(self) -> T {
self.inner.into_inner()
}
@@ -175,6 +171,14 @@ impl<T> RwLock<T> {
release(data);
unsafe { self.inner.force_unlock_read() };
}
/// Returns a reference to the underlying [`wgpu_sync::RwLock`].
///
/// Marked as unsafe because it allows bypassing the rank system,
/// defeating the purpose of this type.
pub unsafe fn underlying(&self) -> &wgpu_sync::RwLock<T> {
&self.inner
}
}
impl<'a, T> RwLockReadGuard<'a, T> {
+8 -4
View File
@@ -230,10 +230,6 @@ impl<T> Mutex<T> {
}
}
pub fn get_mut(&mut self) -> &mut T {
self.inner.get_mut()
}
pub fn into_inner(self) -> T {
self.inner.into_inner()
}
@@ -327,6 +323,14 @@ impl<T> RwLock<T> {
release(data);
unsafe { self.inner.force_unlock_read() };
}
/// Returns a reference to the underlying [`wgpu_sync::RwLock`].
///
/// Marked as unsafe because it allows bypassing the rank system,
/// defeating the purpose of this type.
pub unsafe fn underlying(&self) -> &wgpu_sync::RwLock<T> {
&self.inner
}
}
impl<'a, T> RwLockReadGuard<'a, T> {
+8 -4
View File
@@ -35,10 +35,6 @@ impl<T> Mutex<T> {
MutexGuard(self.0.lock())
}
pub fn get_mut(&mut self) -> &mut T {
self.0.get_mut()
}
pub fn into_inner(self) -> T {
self.0.into_inner()
}
@@ -106,6 +102,14 @@ impl<T> RwLock<T> {
pub unsafe fn force_unlock_read(&self, _data: RankData) {
unsafe { self.0.force_unlock_read() };
}
/// Returns a reference to the underlying [`wgpu_sync::RwLock`].
///
/// Marked as unsafe because it allows bypassing the rank system,
/// defeating the purpose of this type.
pub unsafe fn underlying(&self) -> &wgpu_sync::RwLock<T> {
&self.0
}
}
impl<'a, T> RwLockReadGuard<'a, T> {
+75 -11
View File
@@ -267,6 +267,64 @@ unsafe impl Send for BufferMapState {}
#[cfg(send_sync)]
unsafe impl Sync for BufferMapState {}
/// Represents a mapped range in the buffer.
///
/// While returned [`BufferMapping`] is alive, [`Buffer::destroy`] and [`Buffer::unmap`] calls will block until [`BufferMapping`] is dropped.
#[derive(Debug)]
pub struct BufferMapping {
ptr: NonNull<u8>,
len: u64,
// guard needs to be dropped before the lock
_guard: wgpu_sync::RwLockReadGuard<'static, BufferMapState>,
_lock: Arc<RwLock<BufferMapState>>,
}
impl BufferMapping {
fn new(ptr: NonNull<u8>, len: u64, lock: Arc<RwLock<BufferMapState>>) -> Self {
// SAFETY: We want to bypass the lock ranking system here,
// because the lock is exposed to users.
let guard = unsafe { lock.underlying() }.read();
Self {
ptr,
len,
// SAFETY: Guard is tied to the lifetime of the lock,
// and it will be dropped before the lock.
_guard: unsafe {
mem::transmute::<
wgpu_sync::RwLockReadGuard<'_, BufferMapState>,
wgpu_sync::RwLockReadGuard<'static, BufferMapState>,
>(guard)
},
_lock: lock,
}
}
/// ### How to safely use the pointer
///
/// - No other overlapping mapped range should be accessed simultaneously.
/// - Pointer is only accessed for the length returned by [`BufferMapping::len`].
/// - Writing to a [`wgt::BufferUsages::MAP_READ`] buffer can have unexpected results (visible in GPU only if it's coherent).
/// - Reading [`wgt::BufferUsages::MAP_WRITE`] buffer with [`wgt::Features::MAPPABLE_PRIMARY_BUFFERS`] feature enabled
/// can have unexpected results due to write combing.
pub fn ptr(&self) -> NonNull<u8> {
self.ptr
}
#[expect(clippy::len_without_is_empty)]
pub fn len(&self) -> u64 {
self.len
}
/// # Safety
///
/// - No other overlapping mapped range should be accessed simultaneously.
/// - Buffer was mapped with [`wgt::BufferUsages::MAP_READ`] or with [`wgt::BufferUsages::MAP_WRITE`] but without [`wgt::Features::MAPPABLE_PRIMARY_BUFFERS`],
/// otherwise one can have unexpected results due to write combing
pub unsafe fn slice(&self) -> &[u8] {
unsafe { core::slice::from_raw_parts(self.ptr().as_ptr(), self.len() as usize) }
}
}
#[cfg(send_sync)]
pub type BufferMapCallback = Box<dyn FnOnce(BufferAccessResult) + Send + 'static>;
#[cfg(not(send_sync))]
@@ -457,7 +515,7 @@ pub struct Buffer {
/// The `label` from the descriptor used to create the resource.
pub(crate) label: String,
pub(crate) tracking_data: TrackingData,
pub(crate) map_state: Mutex<BufferMapState>,
pub(crate) map_state: Arc<RwLock<BufferMapState>>,
// Bind groups that reference this buffer. May contain duplicates.
pub(crate) bind_groups: Mutex<WeakVec<BindGroup>>,
pub(crate) timestamp_normalization_bind_group: Snatchable<TimestampNormalizationBindGroup>,
@@ -482,7 +540,7 @@ impl Drop for Buffer {
raw.dispose(self.device.raw());
}
let map_state = mem::replace(self.map_state.get_mut(), BufferMapState::Idle);
let map_state = mem::replace(&mut *self.map_state.write(), BufferMapState::Idle);
let active_map = match map_state {
BufferMapState::Init { staging_buffer } => {
staging_buffer.dispose();
@@ -581,7 +639,7 @@ impl Buffer {
rank::BUFFER_INITIALIZATION_STATUS,
BufferInitTracker::new(0),
),
map_state: Mutex::new(rank::BUFFER_MAP_STATE, BufferMapState::Idle),
map_state: Arc::new(RwLock::new(rank::BUFFER_MAP_STATE, BufferMapState::Idle)),
label: desc.label.to_string(),
tracking_data: TrackingData::new(device.tracker_indices.buffers.clone()),
bind_groups: Mutex::new(rank::BUFFER_BIND_GROUPS, WeakVec::new()),
@@ -816,7 +874,7 @@ impl Buffer {
}
{
let map_state = &mut *self.map_state.lock();
let map_state = &mut *self.map_state.write();
*map_state = match *map_state {
BufferMapState::Init { .. } | BufferMapState::Active { .. } => {
return Err((op, BufferAccessError::AlreadyMapped));
@@ -835,7 +893,8 @@ impl Buffer {
if let Some(queue) = device.get_queue().as_ref() {
match queue.flush_writes_for_buffer(self, snatch_guard) {
Err(err) => {
let state = mem::replace(&mut *self.map_state.lock(), BufferMapState::Idle);
let state =
mem::replace(&mut *self.map_state.write(), BufferMapState::Idle);
let BufferMapState::Waiting(BufferPendingMapping { op, .. }) = state else {
unreachable!();
};
@@ -884,11 +943,15 @@ impl Buffer {
}
}
/// Get a guarded pointer to the mapped range of the buffer.
///
/// While returned [`BufferMapping`] is alive,
/// [`Buffer::destroy`] and [`Buffer::unmap`] calls will block until [`BufferMapping`] is dropped.
pub fn get_mapped_range(
self: &Arc<Self>,
offset: wgt::BufferAddress,
size: Option<wgt::BufferAddress>,
) -> Result<(NonNull<u8>, u64), BufferAccessError> {
) -> Result<BufferMapping, BufferAccessError> {
profiling::scope!("Buffer::get_mapped_range");
api_log!(
"Buffer::get_mapped_range {:?} offset {offset:?} size {size:?}",
@@ -913,7 +976,7 @@ impl Buffer {
if !range_size.is_multiple_of(wgt::COPY_BUFFER_ALIGNMENT) {
return Err(BufferAccessError::UnalignedRangeSize { range_size });
}
let map_state = &*self.map_state.lock();
let map_state = &*self.map_state.read();
match *map_state {
BufferMapState::Init { ref staging_buffer } => {
if offset > self.size {
@@ -932,7 +995,7 @@ impl Buffer {
}
let ptr = unsafe { staging_buffer.ptr() };
let ptr = unsafe { NonNull::new_unchecked(ptr.as_ptr().offset(offset as isize)) };
Ok((ptr, range_size))
Ok(BufferMapping::new(ptr, range_size, self.map_state.clone()))
}
BufferMapState::Active {
ref mapping,
@@ -962,9 +1025,10 @@ impl Buffer {
// rather than the beginning of the buffer.
let relative_offset = (offset - range.start) as isize;
unsafe {
Ok((
Ok(BufferMapping::new(
NonNull::new_unchecked(mapping.ptr.as_ptr().offset(relative_offset)),
range_size,
self.map_state.clone(),
))
}
}
@@ -983,7 +1047,7 @@ impl Buffer {
// `crate::device::map_buffer` and the associated call to
// `handle_hal_error`, which may invoke a device loss callback.
// See <https://github.com/gfx-rs/wgpu/issues/10031>.
let mut map_state = self.map_state.lock();
let mut map_state = self.map_state.write();
let pending_mapping = match mem::replace(&mut *map_state, BufferMapState::Idle) {
BufferMapState::Waiting(pending_mapping) => pending_mapping,
// Mapping cancelled
@@ -1062,7 +1126,7 @@ impl Buffer {
// - if the device was invalid from the start it couldn't have been mapped via `map_async` anyway
// - if the buffer was destroyed (via `Buffer::destroy`) it was first unmapped
let raw_buf = self.try_raw(&snatch_guard).ok()?;
let map_state = mem::replace(&mut *self.map_state.lock(), BufferMapState::Idle);
let map_state = mem::replace(&mut *self.map_state.write(), BufferMapState::Idle);
match map_state {
BufferMapState::Init { staging_buffer } => {
#[cfg(feature = "trace")]
+6 -2
View File
@@ -950,11 +950,13 @@ impl error::Error for MapRangeError {}
/// [`map_async`]: BufferSlice::map_async
#[derive(Debug)]
pub struct BufferView {
// we need to drop BufferMappedRange before Buffer,
// so that the buffer is not unmapped while the view is still alive
inner: dispatch::DispatchBufferMappedRange,
// `buffer, offset, size` are similar to `BufferSlice`, except that they own the buffer.
buffer: Buffer,
offset: BufferAddress,
size: BufferAddress,
inner: dispatch::DispatchBufferMappedRange,
}
/// A write-only view of a mapped buffer's bytes.
@@ -976,11 +978,13 @@ pub struct BufferView {
/// [map]: Buffer#mapping-buffers
#[derive(Debug)]
pub struct BufferViewMut {
// we need to drop BufferMappedRange before Buffer,
// so that the buffer is not unmapped while the view is still alive
inner: dispatch::DispatchBufferMappedRange,
// `buffer, offset, size` are similar to `BufferSlice`, except that they own the buffer.
buffer: Buffer,
offset: BufferAddress,
size: BufferAddress,
inner: dispatch::DispatchBufferMappedRange,
}
// `BufferView` simply dereferences. `BufferViewMut` cannot, because mapped memory may be
+10 -4
View File
@@ -15,7 +15,7 @@ use core::{
ptr::NonNull,
slice,
};
use wgc::resource::ParentDevice as _;
use wgc::resource::{BufferMapping, ParentDevice as _};
use wgt::error::WebGpuError;
use arrayvec::ArrayVec;
@@ -680,6 +680,8 @@ pub struct CoreQueueWriteBuffer {
pub struct CoreBufferMappedRange {
ptr: NonNull<u8>,
size: usize,
// Stagging
_guard: Option<BufferMapping>,
}
#[cfg(send_sync)]
@@ -1624,6 +1626,9 @@ impl dispatch::QueueInterface for CoreQueue {
mapping: CoreBufferMappedRange {
ptr,
size: size.get() as usize,
// stagging buffer is the one keeping the mapping alive
// so no guard is needed here
_guard: None,
},
}
.into(),
@@ -1825,10 +1830,11 @@ impl dispatch::BufferInterface for CoreBuffer {
let size = sub_range.end - sub_range.start;
self.wgpu_buffer
.get_mapped_range(sub_range.start, Some(size))
.map(|(ptr, size)| {
.map(|mapping| {
CoreBufferMappedRange {
ptr,
size: size as usize,
ptr: mapping.ptr(),
size: mapping.len() as usize,
_guard: Some(mapping),
}
.into()
})