diff --git a/deno_webgpu/buffer.rs b/deno_webgpu/buffer.rs index 580827367..02c8ac4e4 100644 --- a/deno_webgpu/buffer.rs +++ b/deno_webgpu/buffer.rs @@ -200,7 +200,7 @@ impl GPUBuffer { #[webidl(default = 0)] offset: u64, #[webidl] size: Option, ) -> Result, 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 = + unsafe { Box::from_raw(deleter_data as *mut _) }; + drop(mapping); } + let mapping: Box = 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(); diff --git a/player/tests/player/main.rs b/player/tests/player/main.rs index 526ccdbd9..486bbfa06 100644 --- a/player/tests/player/main.rs +++ b/player/tests/player/main.rs @@ -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::>(), }; + // 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); } } } diff --git a/wgpu-core-remote/src/global/device.rs b/wgpu-core-remote/src/global/device.rs index 9a0aae77f..69d1e0e42 100644 --- a/wgpu-core-remote/src/global/device.rs +++ b/wgpu-core-remote/src/global/device.rs @@ -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, - ) -> Result<(NonNull, u64), BufferAccessError> { + ) -> Result { let hub = self.hub.borrow(); let buffer = hub.buffers.get(buffer_id); diff --git a/wgpu-core/src/device/queue.rs b/wgpu-core/src/device/queue.rs index 56c9e8d2c..8f9f639e4 100644 --- a/wgpu-core/src/device/queue.rs +++ b/wgpu-core/src/device/queue.rs @@ -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())), } diff --git a/wgpu-core/src/device/resource.rs b/wgpu-core/src/device/resource.rs index 79f03aeb7..7944b3a19 100644 --- a/wgpu-core/src/device/resource.rs +++ b/wgpu-core/src/device/resource.rs @@ -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()), diff --git a/wgpu-core/src/lock/observing.rs b/wgpu-core/src/lock/observing.rs index 29f916ef9..17de8bd02 100644 --- a/wgpu-core/src/lock/observing.rs +++ b/wgpu-core/src/lock/observing.rs @@ -79,10 +79,6 @@ impl Mutex { } } - 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 RwLock { 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 { + &self.inner + } } impl<'a, T> RwLockReadGuard<'a, T> { diff --git a/wgpu-core/src/lock/ranked.rs b/wgpu-core/src/lock/ranked.rs index cbca3eda8..a7a202fbd 100644 --- a/wgpu-core/src/lock/ranked.rs +++ b/wgpu-core/src/lock/ranked.rs @@ -230,10 +230,6 @@ impl Mutex { } } - 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 RwLock { 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 { + &self.inner + } } impl<'a, T> RwLockReadGuard<'a, T> { diff --git a/wgpu-core/src/lock/vanilla.rs b/wgpu-core/src/lock/vanilla.rs index bc9f08077..f81cfdc68 100644 --- a/wgpu-core/src/lock/vanilla.rs +++ b/wgpu-core/src/lock/vanilla.rs @@ -35,10 +35,6 @@ impl Mutex { 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 RwLock { 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 { + &self.0 + } } impl<'a, T> RwLockReadGuard<'a, T> { diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs index 4fbdc3356..ebd3a53bf 100644 --- a/wgpu-core/src/resource.rs +++ b/wgpu-core/src/resource.rs @@ -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, + len: u64, + // guard needs to be dropped before the lock + _guard: wgpu_sync::RwLockReadGuard<'static, BufferMapState>, + _lock: Arc>, +} + +impl BufferMapping { + fn new(ptr: NonNull, len: u64, lock: Arc>) -> 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 { + 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; #[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, + pub(crate) map_state: Arc>, // Bind groups that reference this buffer. May contain duplicates. pub(crate) bind_groups: Mutex>, pub(crate) timestamp_normalization_bind_group: Snatchable, @@ -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, offset: wgt::BufferAddress, size: Option, - ) -> Result<(NonNull, u64), BufferAccessError> { + ) -> Result { 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 . - 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")] diff --git a/wgpu/src/api/buffer.rs b/wgpu/src/api/buffer.rs index 398bafce1..96f08df0d 100644 --- a/wgpu/src/api/buffer.rs +++ b/wgpu/src/api/buffer.rs @@ -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 diff --git a/wgpu/src/backend/wgpu_core.rs b/wgpu/src/backend/wgpu_core.rs index 05f0ee899..8a5288ece 100644 --- a/wgpu/src/backend/wgpu_core.rs +++ b/wgpu/src/backend/wgpu_core.rs @@ -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, size: usize, + // Stagging + _guard: Option, } #[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() })