mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-22 07:21:04 +01:00
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:
1 parent
03017a1aba
commit
f4455f178d
11 files changed
+156
-53
No files matched your search
+23
-12
@@ -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();
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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())),
|
||||
}
|
||||
|
||||
@@ -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()),
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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
@@ -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")]
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()
|
||||
})
|
||||
|
||||
Reference in new issue
Block a user