mirror of
https://github.com/servo/servo.git
synced 2025-07-22 23:03:42 +01:00
webgpu: Sync GPUBuffer (#33154)
* More helpers on `Promise` Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com> * Sync `GPUBuffer` Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com> * Set some good expectations Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com> * Some bad expect also on firefox Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com> * Extract DataBlock, DataView impl from GPUBuffer Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com> * Fix size check to work on 32bit platforms Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com> --------- Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
Samson
GitHub
parent
bb5926b329
commit
7fce24f9d5
12 changed files with 690 additions and 1163 deletions
|
|
@ -4,18 +4,23 @@
|
|||
|
||||
#![allow(unsafe_code)]
|
||||
|
||||
use std::borrow::BorrowMut;
|
||||
use std::ffi::c_void;
|
||||
use std::marker::PhantomData;
|
||||
use std::ops::Range;
|
||||
use std::ptr;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::sync::Arc;
|
||||
|
||||
use js::jsapi::glue::NewExternalArrayBuffer;
|
||||
use js::jsapi::{Heap, JSObject, JS_GetArrayBufferViewBuffer, JS_IsArrayBufferViewObject};
|
||||
use js::jsapi::{
|
||||
Heap, JSObject, JS_GetArrayBufferViewBuffer, JS_IsArrayBufferViewObject, NewExternalArrayBuffer,
|
||||
};
|
||||
use js::rust::wrappers::DetachArrayBuffer;
|
||||
use js::rust::{CustomAutoRooterGuard, Handle, MutableHandleObject};
|
||||
use js::typedarray::{CreateWith, TypedArray, TypedArrayElement, TypedArrayElementCreator};
|
||||
use js::typedarray::{
|
||||
ArrayBuffer, CreateWith, HeapArrayBuffer, TypedArray, TypedArrayElement,
|
||||
TypedArrayElementCreator,
|
||||
};
|
||||
|
||||
use crate::dom::globalscope::GlobalScope;
|
||||
use crate::script_runtime::JSContext;
|
||||
|
||||
/// <https://webidl.spec.whatwg.org/#BufferSource>
|
||||
|
|
@ -402,44 +407,103 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
pub fn create_new_external_array_buffer<T>(
|
||||
cx: JSContext,
|
||||
mapping: Arc<Mutex<Vec<T::Element>>>,
|
||||
offset: usize,
|
||||
range_size: usize,
|
||||
m_end: usize,
|
||||
) -> HeapBufferSource<T>
|
||||
where
|
||||
T: TypedArrayElement + TypedArrayElementCreator,
|
||||
T::Element: Clone + Copy,
|
||||
{
|
||||
/// `freeFunc()` must be threadsafe, should be safely callable from any thread
|
||||
/// without causing conflicts , unexpected behavior.
|
||||
/// <https://github.com/servo/mozjs/blob/main/mozjs-sys/mozjs/js/public/ArrayBuffer.h#L89>
|
||||
unsafe extern "C" fn free_func(_contents: *mut c_void, free_user_data: *mut c_void) {
|
||||
// Clippy warns about "creating a `Arc` from a void raw pointer" here, but suggests
|
||||
// the exact same line to fix it. Doing the cast is tricky because of the use of
|
||||
// a generic type in this parameter.
|
||||
#[allow(clippy::from_raw_with_void_ptr)]
|
||||
let _ = Arc::from_raw(free_user_data as *const _);
|
||||
}
|
||||
#[derive(JSTraceable, MallocSizeOf)]
|
||||
pub struct DataBlock {
|
||||
#[ignore_malloc_size_of = "Arc"]
|
||||
data: Arc<Box<[u8]>>,
|
||||
/// Data views (mutable subslices of data)
|
||||
data_views: Vec<DataView>,
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let mapping_slice_ptr = mapping.lock().unwrap().borrow_mut()[offset..m_end].as_mut_ptr();
|
||||
/// Returns true if two non-inclusive ranges overlap
|
||||
// https://stackoverflow.com/questions/3269434/whats-the-most-efficient-way-to-test-if-two-ranges-overlap
|
||||
fn range_overlap<T: std::cmp::PartialOrd>(range1: &Range<T>, range2: &Range<T>) -> bool {
|
||||
range1.start < range2.end && range2.start < range1.end
|
||||
}
|
||||
|
||||
// rooted! is needed to ensure memory safety and prevent potential garbage collection issues.
|
||||
// https://github.com/mozilla-spidermonkey/spidermonkey-embedding-examples/blob/esr78/docs/GC%20Rooting%20Guide.md#performance-tweaking
|
||||
rooted!(in(*cx) let array_buffer = NewExternalArrayBuffer(
|
||||
*cx,
|
||||
range_size,
|
||||
mapping_slice_ptr as _,
|
||||
Some(free_func),
|
||||
Arc::into_raw(mapping) as _,
|
||||
));
|
||||
|
||||
HeapBufferSource {
|
||||
buffer_source: BufferSource::ArrayBuffer(Heap::boxed(*array_buffer)),
|
||||
phantom: PhantomData,
|
||||
impl DataBlock {
|
||||
pub fn new_zeroed(size: usize) -> Self {
|
||||
let data = vec![0; size];
|
||||
Self {
|
||||
data: Arc::new(data.into_boxed_slice()),
|
||||
data_views: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Panics if there is any active view or src data is not same length
|
||||
pub fn load(&mut self, src: &[u8]) {
|
||||
// `Arc::get_mut` ensures there are no views
|
||||
Arc::get_mut(&mut self.data).unwrap().clone_from_slice(src)
|
||||
}
|
||||
|
||||
/// Panics if there is any active view
|
||||
pub fn data(&mut self) -> &mut [u8] {
|
||||
// `Arc::get_mut` ensures there are no views
|
||||
Arc::get_mut(&mut self.data).unwrap()
|
||||
}
|
||||
|
||||
pub fn clear_views(&mut self) {
|
||||
self.data_views.clear()
|
||||
}
|
||||
|
||||
/// Returns error if requested range is already mapped
|
||||
pub fn view(&mut self, range: Range<usize>) -> Result<&DataView, ()> {
|
||||
if self
|
||||
.data_views
|
||||
.iter()
|
||||
.any(|view| range_overlap(&view.range, &range))
|
||||
{
|
||||
return Err(());
|
||||
}
|
||||
let cx = GlobalScope::get_cx();
|
||||
/// `freeFunc()` must be threadsafe, should be safely callable from any thread
|
||||
/// without causing conflicts, unexpected behavior.
|
||||
unsafe extern "C" fn free_func(_contents: *mut c_void, free_user_data: *mut c_void) {
|
||||
// Clippy warns about "creating a `Arc` from a void raw pointer" here, but suggests
|
||||
// the exact same line to fix it. Doing the cast is tricky because of the use of
|
||||
// a generic type in this parameter.
|
||||
#[allow(clippy::from_raw_with_void_ptr)]
|
||||
drop(Arc::from_raw(free_user_data as *const _));
|
||||
}
|
||||
let raw: *mut Box<[u8]> = Arc::into_raw(Arc::clone(&self.data)) as _;
|
||||
rooted!(in(*cx) let object = unsafe {
|
||||
NewExternalArrayBuffer(
|
||||
*cx,
|
||||
range.end - range.start,
|
||||
// SAFETY: This is safe because we have checked there is no overlapping view
|
||||
(*raw)[range.clone()].as_mut_ptr() as _,
|
||||
Some(free_func),
|
||||
raw as _,
|
||||
)
|
||||
});
|
||||
self.data_views.push(DataView {
|
||||
range,
|
||||
buffer: HeapArrayBuffer::from(*object).unwrap(),
|
||||
});
|
||||
Ok(self.data_views.last().unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(JSTraceable, MallocSizeOf)]
|
||||
pub struct DataView {
|
||||
#[no_trace]
|
||||
range: Range<usize>,
|
||||
#[ignore_malloc_size_of = "defined in mozjs"]
|
||||
buffer: HeapArrayBuffer,
|
||||
}
|
||||
|
||||
impl DataView {
|
||||
pub fn array_buffer(&self) -> ArrayBuffer {
|
||||
unsafe { ArrayBuffer::from(self.buffer.underlying_object().get()).unwrap() }
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for DataView {
|
||||
#[allow(unsafe_code)]
|
||||
fn drop(&mut self) {
|
||||
let cx = GlobalScope::get_cx();
|
||||
assert!(unsafe {
|
||||
js::jsapi::DetachArrayBuffer(*cx, self.buffer.underlying_object().handle())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -61,7 +61,6 @@ use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
|
|||
use crate::dom::bindings::reflector::{DomObject, Reflector};
|
||||
use crate::dom::bindings::root::{Dom, DomRoot};
|
||||
use crate::dom::bindings::str::{DOMString, USVString};
|
||||
use crate::dom::gpubuffer::GPUBufferState;
|
||||
use crate::dom::gpucanvascontext::WebGPUContextId;
|
||||
use crate::dom::htmlimageelement::SourceSet;
|
||||
use crate::dom::htmlmediaelement::HTMLMediaElementFetchContext;
|
||||
|
|
@ -366,7 +365,6 @@ unsafe_no_jsmanaged_fields!(WindowProxyHandler);
|
|||
unsafe_no_jsmanaged_fields!(DOMString);
|
||||
unsafe_no_jsmanaged_fields!(USVString);
|
||||
unsafe_no_jsmanaged_fields!(WebGPUContextId);
|
||||
unsafe_no_jsmanaged_fields!(GPUBufferState);
|
||||
unsafe_no_jsmanaged_fields!(SourceSet);
|
||||
unsafe_no_jsmanaged_fields!(HTMLMediaElementFetchContext);
|
||||
unsafe_no_jsmanaged_fields!(StreamConsumer);
|
||||
|
|
|
|||
|
|
@ -2,19 +2,20 @@
|
|||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use std::cell::Cell;
|
||||
use std::ops::Range;
|
||||
use std::rc::Rc;
|
||||
use std::string::String;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use dom_struct::dom_struct;
|
||||
use ipc_channel::ipc::IpcSharedMemory;
|
||||
use js::typedarray::{ArrayBuffer, ArrayBufferU8};
|
||||
use js::typedarray::ArrayBuffer;
|
||||
use webgpu::wgc::device::HostMap;
|
||||
use webgpu::{WebGPU, WebGPUBuffer, WebGPURequest, WebGPUResponse};
|
||||
use webgpu::{wgt, Mapping, WebGPU, WebGPUBuffer, WebGPURequest, WebGPUResponse};
|
||||
|
||||
use super::bindings::buffer_source::{create_new_external_array_buffer, HeapBufferSource};
|
||||
use super::bindings::buffer_source::DataBlock;
|
||||
use super::bindings::codegen::Bindings::WebGPUBinding::{
|
||||
GPUBufferMapState, GPUFlagsConstant, GPUMapModeFlags,
|
||||
};
|
||||
use crate::dom::bindings::cell::DomRefCell;
|
||||
use crate::dom::bindings::codegen::Bindings::WebGPUBinding::{
|
||||
GPUBufferMethods, GPUMapModeConstants, GPUSize64,
|
||||
|
|
@ -30,31 +31,36 @@ use crate::dom::promise::Promise;
|
|||
use crate::realms::InRealm;
|
||||
use crate::script_runtime::JSContext;
|
||||
|
||||
const RANGE_OFFSET_ALIGN_MASK: u64 = 8;
|
||||
const RANGE_SIZE_ALIGN_MASK: u64 = 4;
|
||||
|
||||
// https://gpuweb.github.io/gpuweb/#buffer-state
|
||||
#[derive(Clone, Copy, MallocSizeOf, PartialEq)]
|
||||
pub enum GPUBufferState {
|
||||
Mapped,
|
||||
MappedAtCreation,
|
||||
MappingPending,
|
||||
Unmapped,
|
||||
Destroyed,
|
||||
#[derive(JSTraceable, MallocSizeOf)]
|
||||
pub struct ActiveBufferMapping {
|
||||
// TODO(sagudev): Use IpcSharedMemory when https://github.com/servo/ipc-channel/pull/356 lands
|
||||
/// <https://gpuweb.github.io/gpuweb/#active-buffer-mapping-data>
|
||||
/// <https://gpuweb.github.io/gpuweb/#active-buffer-mapping-views>
|
||||
pub data: DataBlock,
|
||||
/// <https://gpuweb.github.io/gpuweb/#active-buffer-mapping-mode>
|
||||
mode: GPUMapModeFlags,
|
||||
/// <https://gpuweb.github.io/gpuweb/#active-buffer-mapping-range>
|
||||
range: Range<u64>,
|
||||
}
|
||||
|
||||
#[derive(JSTraceable, MallocSizeOf)]
|
||||
pub struct GPUBufferMapInfo {
|
||||
#[ignore_malloc_size_of = "Arc"]
|
||||
#[no_trace]
|
||||
/// The `mapping` is wrapped in an `Arc` to ensure thread safety.
|
||||
/// This is necessary for integration with the SpiderMonkey engine,
|
||||
pub mapping: Arc<Mutex<Vec<u8>>>,
|
||||
pub mapping_range: Range<u64>,
|
||||
pub mapped_ranges: Vec<Range<u64>>,
|
||||
#[ignore_malloc_size_of = "defined in mozjs"]
|
||||
pub js_buffers: Vec<HeapBufferSource<ArrayBufferU8>>,
|
||||
pub map_mode: Option<u32>,
|
||||
impl ActiveBufferMapping {
|
||||
/// <https://gpuweb.github.io/gpuweb/#abstract-opdef-initialize-an-active-buffer-mapping>
|
||||
pub fn new(mode: GPUMapModeFlags, range: Range<u64>) -> Fallible<Self> {
|
||||
// Step 1
|
||||
let size = range.end - range.start;
|
||||
// Step 2
|
||||
if size > (1 << 53) - 1 {
|
||||
return Err(Error::Range("Over MAX_SAFE_INTEGER".to_string()));
|
||||
}
|
||||
let size: usize = size
|
||||
.try_into()
|
||||
.map_err(|_| Error::Range("Over usize".to_string()))?;
|
||||
Ok(Self {
|
||||
data: DataBlock::new_zeroed(size),
|
||||
mode,
|
||||
range,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[dom_struct]
|
||||
|
|
@ -64,14 +70,18 @@ pub struct GPUBuffer {
|
|||
#[no_trace]
|
||||
channel: WebGPU,
|
||||
label: DomRefCell<USVString>,
|
||||
state: Cell<GPUBufferState>,
|
||||
#[no_trace]
|
||||
buffer: WebGPUBuffer,
|
||||
device: Dom<GPUDevice>,
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-size>
|
||||
size: GPUSize64,
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-usage>
|
||||
usage: GPUFlagsConstant,
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-pending_map-slot>
|
||||
#[ignore_malloc_size_of = "promises are hard"]
|
||||
map_promise: DomRefCell<Option<Rc<Promise>>>,
|
||||
map_info: DomRefCell<Option<GPUBufferMapInfo>>,
|
||||
pending_map: DomRefCell<Option<Rc<Promise>>>,
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapping-slot>
|
||||
mapping: DomRefCell<Option<ActiveBufferMapping>>,
|
||||
}
|
||||
|
||||
impl GPUBuffer {
|
||||
|
|
@ -79,38 +89,37 @@ impl GPUBuffer {
|
|||
channel: WebGPU,
|
||||
buffer: WebGPUBuffer,
|
||||
device: &GPUDevice,
|
||||
state: GPUBufferState,
|
||||
size: GPUSize64,
|
||||
map_info: DomRefCell<Option<GPUBufferMapInfo>>,
|
||||
usage: GPUFlagsConstant,
|
||||
mapping: Option<ActiveBufferMapping>,
|
||||
label: USVString,
|
||||
) -> Self {
|
||||
Self {
|
||||
reflector_: Reflector::new(),
|
||||
channel,
|
||||
label: DomRefCell::new(label),
|
||||
state: Cell::new(state),
|
||||
device: Dom::from_ref(device),
|
||||
buffer,
|
||||
map_promise: DomRefCell::new(None),
|
||||
pending_map: DomRefCell::new(None),
|
||||
size,
|
||||
map_info,
|
||||
usage,
|
||||
mapping: DomRefCell::new(mapping),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
global: &GlobalScope,
|
||||
channel: WebGPU,
|
||||
buffer: WebGPUBuffer,
|
||||
device: &GPUDevice,
|
||||
state: GPUBufferState,
|
||||
size: GPUSize64,
|
||||
map_info: DomRefCell<Option<GPUBufferMapInfo>>,
|
||||
usage: GPUFlagsConstant,
|
||||
mapping: Option<ActiveBufferMapping>,
|
||||
label: USVString,
|
||||
) -> DomRoot<Self> {
|
||||
reflect_dom_object(
|
||||
Box::new(GPUBuffer::new_inherited(
|
||||
channel, buffer, device, state, size, map_info, label,
|
||||
channel, buffer, device, size, usage, mapping, label,
|
||||
)),
|
||||
global,
|
||||
)
|
||||
|
|
@ -121,86 +130,49 @@ impl GPUBuffer {
|
|||
pub fn id(&self) -> WebGPUBuffer {
|
||||
self.buffer
|
||||
}
|
||||
|
||||
pub fn state(&self) -> GPUBufferState {
|
||||
self.state.get()
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for GPUBuffer {
|
||||
fn drop(&mut self) {
|
||||
if matches!(self.state(), GPUBufferState::Destroyed) {
|
||||
return;
|
||||
}
|
||||
if let Err(e) = self
|
||||
.channel
|
||||
.0
|
||||
.send(WebGPURequest::DropBuffer(self.buffer.0))
|
||||
{
|
||||
warn!(
|
||||
"Failed to send WebGPURequest::DropBuffer({:?}) ({})",
|
||||
self.buffer.0, e
|
||||
);
|
||||
};
|
||||
self.Destroy()
|
||||
}
|
||||
}
|
||||
|
||||
impl GPUBufferMethods for GPUBuffer {
|
||||
#[allow(unsafe_code)]
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-unmap>
|
||||
fn Unmap(&self) -> Fallible<()> {
|
||||
let cx = GlobalScope::get_cx();
|
||||
fn Unmap(&self) {
|
||||
// Step 1
|
||||
match self.state.get() {
|
||||
GPUBufferState::Unmapped | GPUBufferState::Destroyed => {
|
||||
// TODO: Record validation error on the current scope
|
||||
return Ok(());
|
||||
},
|
||||
// Step 3
|
||||
GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => {
|
||||
let mut info = self.map_info.borrow_mut();
|
||||
let m_info = if let Some(m_info) = info.as_mut() {
|
||||
m_info
|
||||
} else {
|
||||
return Err(Error::Operation);
|
||||
};
|
||||
let m_range = m_info.mapping_range.clone();
|
||||
if let Err(e) = self.channel.0.send(WebGPURequest::UnmapBuffer {
|
||||
buffer_id: self.id().0,
|
||||
device_id: self.device.id().0,
|
||||
array_buffer: IpcSharedMemory::from_bytes(&m_info.mapping.lock().unwrap()),
|
||||
is_map_read: m_info.map_mode == Some(GPUMapModeConstants::READ),
|
||||
offset: m_range.start,
|
||||
size: m_range.end - m_range.start,
|
||||
}) {
|
||||
warn!("Failed to send Buffer unmap ({:?}) ({})", self.buffer.0, e);
|
||||
}
|
||||
// Step 3.3
|
||||
m_info.js_buffers.drain(..).for_each(|obj| {
|
||||
obj.detach_buffer(cx);
|
||||
});
|
||||
},
|
||||
// Step 2
|
||||
GPUBufferState::MappingPending => {
|
||||
let promise = self.map_promise.borrow_mut().take().unwrap();
|
||||
promise.reject_error(Error::Operation);
|
||||
},
|
||||
if let Some(promise) = self.pending_map.borrow_mut().take() {
|
||||
promise.reject_error(Error::Abort);
|
||||
}
|
||||
// Step 2
|
||||
let mut mapping = self.mapping.borrow_mut().take();
|
||||
let mapping = if let Some(mapping) = mapping.as_mut() {
|
||||
mapping
|
||||
} else {
|
||||
return;
|
||||
};
|
||||
// Step 4
|
||||
self.state.set(GPUBufferState::Unmapped);
|
||||
*self.map_info.borrow_mut() = None;
|
||||
Ok(())
|
||||
|
||||
// Step 3
|
||||
mapping.data.clear_views();
|
||||
// Step 5&7
|
||||
if let Err(e) = self.channel.0.send(WebGPURequest::UnmapBuffer {
|
||||
buffer_id: self.id().0,
|
||||
array_buffer: IpcSharedMemory::from_bytes(mapping.data.data()),
|
||||
write_back: mapping.mode >= GPUMapModeConstants::WRITE,
|
||||
offset: mapping.range.start,
|
||||
size: mapping.range.end - mapping.range.start,
|
||||
}) {
|
||||
warn!("Failed to send Buffer unmap ({:?}) ({})", self.buffer.0, e);
|
||||
}
|
||||
}
|
||||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy>
|
||||
fn Destroy(&self) -> Fallible<()> {
|
||||
let state = self.state.get();
|
||||
match state {
|
||||
GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => {
|
||||
self.Unmap()?;
|
||||
},
|
||||
GPUBufferState::Destroyed => return Ok(()),
|
||||
_ => {},
|
||||
};
|
||||
/// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy
|
||||
fn Destroy(&self) {
|
||||
// Step 1
|
||||
self.Unmap();
|
||||
// Step 2
|
||||
if let Err(e) = self
|
||||
.channel
|
||||
.0
|
||||
|
|
@ -211,11 +183,9 @@ impl GPUBufferMethods for GPUBuffer {
|
|||
self.buffer.0, e
|
||||
);
|
||||
};
|
||||
self.state.set(GPUBufferState::Destroyed);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapasync-offset-size>
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapasync>
|
||||
fn MapAsync(
|
||||
&self,
|
||||
mode: u32,
|
||||
|
|
@ -224,22 +194,16 @@ impl GPUBufferMethods for GPUBuffer {
|
|||
comp: InRealm,
|
||||
) -> Rc<Promise> {
|
||||
let promise = Promise::new_in_current_realm(comp);
|
||||
let range_size = if let Some(s) = size {
|
||||
s
|
||||
} else if offset >= self.size {
|
||||
// Step 2
|
||||
if self.pending_map.borrow().is_some() {
|
||||
promise.reject_error(Error::Operation);
|
||||
return promise;
|
||||
} else {
|
||||
self.size - offset
|
||||
};
|
||||
if self.state.get() != GPUBufferState::Unmapped {
|
||||
self.device
|
||||
.dispatch_error(webgpu::Error::Validation(String::from(
|
||||
"Buffer is not Unmapped",
|
||||
)));
|
||||
promise.reject_error(Error::Abort);
|
||||
return promise;
|
||||
}
|
||||
// Step 4
|
||||
*self.pending_map.borrow_mut() = Some(promise.clone());
|
||||
// Step 5
|
||||
|
||||
// This should be bitflags in wgpu-core
|
||||
let host_map = match mode {
|
||||
GPUMapModeConstants::READ => HostMap::Read,
|
||||
GPUMapModeConstants::WRITE => HostMap::Write,
|
||||
|
|
@ -248,13 +212,11 @@ impl GPUBufferMethods for GPUBuffer {
|
|||
.dispatch_error(webgpu::Error::Validation(String::from(
|
||||
"Invalid MapModeFlags",
|
||||
)));
|
||||
promise.reject_error(Error::Abort);
|
||||
self.map_failure(&promise);
|
||||
return promise;
|
||||
},
|
||||
};
|
||||
|
||||
let map_range = offset..offset + range_size;
|
||||
|
||||
let sender = response_async(&promise, self);
|
||||
if let Err(e) = self.channel.0.send(WebGPURequest::BufferMapAsync {
|
||||
sender,
|
||||
|
|
@ -262,80 +224,53 @@ impl GPUBufferMethods for GPUBuffer {
|
|||
device_id: self.device.id().0,
|
||||
host_map,
|
||||
offset,
|
||||
size: Some(range_size),
|
||||
size,
|
||||
}) {
|
||||
warn!(
|
||||
"Failed to send BufferMapAsync ({:?}) ({})",
|
||||
self.buffer.0, e
|
||||
);
|
||||
promise.reject_error(Error::Operation);
|
||||
self.map_failure(&promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
self.state.set(GPUBufferState::MappingPending);
|
||||
*self.map_info.borrow_mut() = Some(GPUBufferMapInfo {
|
||||
mapping: Arc::new(Mutex::new(Vec::with_capacity(0))),
|
||||
mapping_range: map_range,
|
||||
mapped_ranges: Vec::new(),
|
||||
js_buffers: Vec::new(),
|
||||
map_mode: Some(mode),
|
||||
});
|
||||
*self.map_promise.borrow_mut() = Some(promise.clone());
|
||||
// Step 6
|
||||
promise
|
||||
}
|
||||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-getmappedrange>
|
||||
#[allow(unsafe_code)]
|
||||
fn GetMappedRange(
|
||||
&self,
|
||||
cx: JSContext,
|
||||
_cx: JSContext,
|
||||
offset: GPUSize64,
|
||||
size: Option<GPUSize64>,
|
||||
) -> Fallible<ArrayBuffer> {
|
||||
let range_size = if let Some(s) = size {
|
||||
s
|
||||
} else if offset >= self.size {
|
||||
return Err(Error::Operation);
|
||||
} else {
|
||||
self.size - offset
|
||||
self.size.checked_sub(offset).unwrap_or(0)
|
||||
};
|
||||
let m_end = offset + range_size;
|
||||
let mut info = self.map_info.borrow_mut();
|
||||
let m_info = if let Some(m_info) = info.as_mut() {
|
||||
m_info
|
||||
} else {
|
||||
return Err(Error::Operation);
|
||||
};
|
||||
let mut valid = matches!(
|
||||
self.state.get(),
|
||||
GPUBufferState::Mapped | GPUBufferState::MappedAtCreation
|
||||
);
|
||||
// Step 2: validation
|
||||
let mut mapping = self.mapping.borrow_mut();
|
||||
let mapping = mapping.as_mut().ok_or(Error::Operation)?;
|
||||
|
||||
valid &= offset % RANGE_OFFSET_ALIGN_MASK == 0 &&
|
||||
range_size % RANGE_SIZE_ALIGN_MASK == 0 &&
|
||||
offset >= m_info.mapping_range.start &&
|
||||
m_end <= m_info.mapping_range.end;
|
||||
valid &= m_info
|
||||
.mapped_ranges
|
||||
.iter()
|
||||
.all(|range| range.start >= m_end || range.end <= offset);
|
||||
let valid = offset % wgt::MAP_ALIGNMENT == 0 &&
|
||||
range_size % wgt::COPY_BUFFER_ALIGNMENT == 0 &&
|
||||
offset >= mapping.range.start &&
|
||||
offset + range_size <= mapping.range.end;
|
||||
if !valid {
|
||||
return Err(Error::Operation);
|
||||
}
|
||||
|
||||
let heap_typed_array = create_new_external_array_buffer::<ArrayBufferU8>(
|
||||
cx,
|
||||
Arc::clone(&m_info.mapping),
|
||||
offset as usize,
|
||||
range_size as usize,
|
||||
m_end as usize,
|
||||
);
|
||||
|
||||
let result = heap_typed_array.get_buffer().map_err(|_| Error::JSFailed);
|
||||
|
||||
m_info.mapped_ranges.push(offset..m_end);
|
||||
m_info.js_buffers.push(heap_typed_array);
|
||||
|
||||
result
|
||||
// Step 4
|
||||
// only mapping.range is mapped with mapping.range.start at 0
|
||||
// so we need to rebase range to mapped.range
|
||||
let rebased_offset = (offset - mapping.range.start) as usize;
|
||||
mapping
|
||||
.data
|
||||
.view(rebased_offset..rebased_offset + range_size as usize)
|
||||
.map(|view| view.array_buffer())
|
||||
.map_err(|()| Error::Operation)
|
||||
}
|
||||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label>
|
||||
|
|
@ -347,30 +282,96 @@ impl GPUBufferMethods for GPUBuffer {
|
|||
fn SetLabel(&self, value: USVString) {
|
||||
*self.label.borrow_mut() = value;
|
||||
}
|
||||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-size>
|
||||
fn Size(&self) -> GPUSize64 {
|
||||
self.size
|
||||
}
|
||||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-usage>
|
||||
fn Usage(&self) -> GPUFlagsConstant {
|
||||
self.usage
|
||||
}
|
||||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapstate>
|
||||
fn MapState(&self) -> GPUBufferMapState {
|
||||
// Step 1&2&3
|
||||
if self.mapping.borrow().is_some() {
|
||||
GPUBufferMapState::Mapped
|
||||
} else if self.pending_map.borrow().is_some() {
|
||||
GPUBufferMapState::Pending
|
||||
} else {
|
||||
GPUBufferMapState::Unmapped
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl GPUBuffer {
|
||||
fn map_failure(&self, p: &Rc<Promise>) {
|
||||
let mut pending_map = self.pending_map.borrow_mut();
|
||||
// Step 1
|
||||
if pending_map.as_ref() != Some(p) {
|
||||
assert!(p.is_rejected());
|
||||
return;
|
||||
}
|
||||
// Step 2
|
||||
assert!(p.is_pending());
|
||||
// Step 3
|
||||
pending_map.take();
|
||||
// Step 4
|
||||
if self.device.is_lost() {
|
||||
p.reject_error(Error::Abort);
|
||||
} else {
|
||||
p.reject_error(Error::Operation);
|
||||
}
|
||||
}
|
||||
|
||||
fn map_success(&self, p: &Rc<Promise>, wgpu_mapping: Mapping) {
|
||||
let mut pending_map = self.pending_map.borrow_mut();
|
||||
|
||||
// Step 1
|
||||
if pending_map.as_ref() != Some(p) {
|
||||
assert!(p.is_rejected());
|
||||
return;
|
||||
}
|
||||
|
||||
// Step 2
|
||||
assert!(p.is_pending());
|
||||
|
||||
// Step 4
|
||||
let mapping = ActiveBufferMapping::new(
|
||||
match wgpu_mapping.mode {
|
||||
HostMap::Read => GPUMapModeConstants::READ,
|
||||
HostMap::Write => GPUMapModeConstants::WRITE,
|
||||
},
|
||||
wgpu_mapping.range,
|
||||
);
|
||||
|
||||
match mapping {
|
||||
Err(error) => {
|
||||
*pending_map = None;
|
||||
p.reject_error(error.clone());
|
||||
},
|
||||
Ok(mut mapping) => {
|
||||
// Step 5
|
||||
mapping.data.load(&wgpu_mapping.data);
|
||||
// Step 6
|
||||
self.mapping.borrow_mut().replace(mapping);
|
||||
// Step 7
|
||||
pending_map.take();
|
||||
p.resolve_native(&());
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl AsyncWGPUListener for GPUBuffer {
|
||||
#[allow(unsafe_code)]
|
||||
fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>) {
|
||||
match response {
|
||||
WebGPUResponse::BufferMapAsync(Ok(bytes)) => {
|
||||
*self
|
||||
.map_info
|
||||
.borrow_mut()
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.mapping
|
||||
.lock()
|
||||
.unwrap()
|
||||
.as_mut() = bytes.to_vec();
|
||||
promise.resolve_native(&());
|
||||
self.state.set(GPUBufferState::Mapped);
|
||||
},
|
||||
WebGPUResponse::BufferMapAsync(Err(e)) => {
|
||||
warn!("Could not map buffer({:?})", e);
|
||||
promise.reject_error(Error::Abort);
|
||||
},
|
||||
_ => unreachable!("GPUBuffer received wrong WebGPUResponse"),
|
||||
WebGPUResponse::BufferMapAsync(Ok(mapping)) => self.map_success(promise, mapping),
|
||||
WebGPUResponse::BufferMapAsync(Err(_)) => self.map_failure(promise),
|
||||
_ => unreachable!("Wrong response received on AsyncWGPUListener for GPUBuffer"),
|
||||
}
|
||||
*self.map_promise.borrow_mut() = None;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ use std::hash::{Hash, Hasher};
|
|||
use dom_struct::dom_struct;
|
||||
use webgpu::{WebGPU, WebGPUCommandBuffer, WebGPURequest};
|
||||
|
||||
use crate::dom::bindings::cell::{DomRefCell, Ref};
|
||||
use crate::dom::bindings::cell::DomRefCell;
|
||||
use crate::dom::bindings::codegen::Bindings::WebGPUBinding::GPUCommandBufferMethods;
|
||||
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
|
||||
use crate::dom::bindings::root::{Dom, DomRoot};
|
||||
|
|
@ -89,10 +89,6 @@ impl GPUCommandBuffer {
|
|||
pub fn id(&self) -> WebGPUCommandBuffer {
|
||||
self.command_buffer
|
||||
}
|
||||
|
||||
pub fn buffers(&self) -> Ref<HashSet<Dom<GPUBuffer>>> {
|
||||
self.buffers.borrow()
|
||||
}
|
||||
}
|
||||
|
||||
impl GPUCommandBufferMethods for GPUCommandBuffer {
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@ use std::cell::Cell;
|
|||
use std::collections::HashMap;
|
||||
use std::num::NonZeroU64;
|
||||
use std::rc::Rc;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use dom_struct::dom_struct;
|
||||
use js::jsapi::{Heap, JSObject};
|
||||
|
|
@ -24,7 +23,9 @@ use webgpu::{
|
|||
WebGPUResponse,
|
||||
};
|
||||
|
||||
use super::bindings::codegen::Bindings::WebGPUBinding::{GPUPipelineErrorReason, GPUTextureFormat};
|
||||
use super::bindings::codegen::Bindings::WebGPUBinding::{
|
||||
GPUMapModeConstants, GPUPipelineErrorReason, GPUTextureFormat,
|
||||
};
|
||||
use super::bindings::codegen::UnionTypes::GPUPipelineLayoutOrGPUAutoLayoutMode;
|
||||
use super::bindings::error::Fallible;
|
||||
use super::gpu::AsyncWGPUListener;
|
||||
|
|
@ -55,7 +56,7 @@ use crate::dom::gpu::response_async;
|
|||
use crate::dom::gpuadapter::GPUAdapter;
|
||||
use crate::dom::gpubindgroup::GPUBindGroup;
|
||||
use crate::dom::gpubindgrouplayout::GPUBindGroupLayout;
|
||||
use crate::dom::gpubuffer::{GPUBuffer, GPUBufferMapInfo, GPUBufferState};
|
||||
use crate::dom::gpubuffer::{ActiveBufferMapping, GPUBuffer};
|
||||
use crate::dom::gpucommandencoder::GPUCommandEncoder;
|
||||
use crate::dom::gpucomputepipeline::GPUComputePipeline;
|
||||
use crate::dom::gpuconvert::{
|
||||
|
|
@ -213,6 +214,10 @@ impl GPUDevice {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn is_lost(&self) -> bool {
|
||||
self.lost_promise.borrow().is_fulfilled()
|
||||
}
|
||||
|
||||
fn get_pipeline_layout_data(
|
||||
&self,
|
||||
layout: &GPUPipelineLayoutOrGPUAutoLayoutMode,
|
||||
|
|
@ -452,31 +457,23 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
.expect("Failed to create WebGPU buffer");
|
||||
|
||||
let buffer = webgpu::WebGPUBuffer(id);
|
||||
let map_info;
|
||||
let state;
|
||||
if descriptor.mappedAtCreation {
|
||||
let buf_data = vec![0u8; descriptor.size as usize];
|
||||
map_info = DomRefCell::new(Some(GPUBufferMapInfo {
|
||||
mapping: Arc::new(Mutex::new(buf_data)),
|
||||
mapping_range: 0..descriptor.size,
|
||||
mapped_ranges: Vec::new(),
|
||||
js_buffers: Vec::new(),
|
||||
map_mode: None,
|
||||
}));
|
||||
state = GPUBufferState::MappedAtCreation;
|
||||
let mapping = if descriptor.mappedAtCreation {
|
||||
Some(ActiveBufferMapping::new(
|
||||
GPUMapModeConstants::WRITE,
|
||||
0..descriptor.size,
|
||||
)?)
|
||||
} else {
|
||||
map_info = DomRefCell::new(None);
|
||||
state = GPUBufferState::Unmapped;
|
||||
}
|
||||
None
|
||||
};
|
||||
|
||||
Ok(GPUBuffer::new(
|
||||
&self.global(),
|
||||
self.channel.clone(),
|
||||
buffer,
|
||||
self,
|
||||
state,
|
||||
descriptor.size,
|
||||
map_info,
|
||||
descriptor.usage,
|
||||
mapping,
|
||||
descriptor.parent.label.clone(),
|
||||
))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
|
|||
use crate::dom::bindings::root::{Dom, DomRoot};
|
||||
use crate::dom::bindings::str::USVString;
|
||||
use crate::dom::globalscope::GlobalScope;
|
||||
use crate::dom::gpubuffer::{GPUBuffer, GPUBufferState};
|
||||
use crate::dom::gpubuffer::GPUBuffer;
|
||||
use crate::dom::gpucommandbuffer::GPUCommandBuffer;
|
||||
use crate::dom::gpuconvert::{
|
||||
convert_ic_texture, convert_image_data_layout, convert_texture_size_to_dict,
|
||||
|
|
@ -80,21 +80,6 @@ impl GPUQueueMethods for GPUQueue {
|
|||
|
||||
/// <https://gpuweb.github.io/gpuweb/#dom-gpuqueue-submit>
|
||||
fn Submit(&self, command_buffers: Vec<DomRoot<GPUCommandBuffer>>) {
|
||||
let valid = command_buffers.iter().all(|cb| {
|
||||
cb.buffers()
|
||||
.iter()
|
||||
.all(|b| matches!(b.state(), GPUBufferState::Unmapped))
|
||||
});
|
||||
if !valid {
|
||||
self.device
|
||||
.borrow()
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.dispatch_error(webgpu::Error::Validation(String::from(
|
||||
"Referenced GPUBuffer(s) are not Unmapped",
|
||||
)));
|
||||
return;
|
||||
}
|
||||
let command_buffers = command_buffers.iter().map(|cb| cb.id().0).collect();
|
||||
self.channel
|
||||
.0
|
||||
|
|
|
|||
|
|
@ -52,6 +52,12 @@ pub struct Promise {
|
|||
permanent_js_root: Heap<JSVal>,
|
||||
}
|
||||
|
||||
impl PartialEq for Promise {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.reflector == other.reflector
|
||||
}
|
||||
}
|
||||
|
||||
/// Private helper to enable adding new methods to `Rc<Promise>`.
|
||||
trait PromiseHelper {
|
||||
fn initialize(&self, cx: SafeJSContext);
|
||||
|
|
@ -231,6 +237,18 @@ impl Promise {
|
|||
matches!(state, PromiseState::Rejected | PromiseState::Fulfilled)
|
||||
}
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
pub fn is_rejected(&self) -> bool {
|
||||
let state = unsafe { GetPromiseState(self.promise_obj()) };
|
||||
matches!(state, PromiseState::Rejected)
|
||||
}
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
let state = unsafe { GetPromiseState(self.promise_obj()) };
|
||||
matches!(state, PromiseState::Pending)
|
||||
}
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
pub fn promise_obj(&self) -> HandleObject {
|
||||
let obj = self.reflector().get_jsobject();
|
||||
|
|
|
|||
|
|
@ -165,17 +165,28 @@ GPUDevice includes GPUObjectBase;
|
|||
|
||||
[Exposed=(Window, DedicatedWorker), Serializable, Pref="dom.webgpu.enabled"]
|
||||
interface GPUBuffer {
|
||||
readonly attribute GPUSize64Out size;
|
||||
readonly attribute GPUFlagsConstant usage;
|
||||
|
||||
readonly attribute GPUBufferMapState mapState;
|
||||
|
||||
[NewObject]
|
||||
Promise<undefined> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size);
|
||||
[NewObject, Throws]
|
||||
ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size);
|
||||
[Throws]
|
||||
undefined unmap();
|
||||
[Throws]
|
||||
|
||||
undefined destroy();
|
||||
};
|
||||
GPUBuffer includes GPUObjectBase;
|
||||
|
||||
|
||||
enum GPUBufferMapState {
|
||||
"unmapped",
|
||||
"pending",
|
||||
"mapped",
|
||||
};
|
||||
|
||||
dictionary GPUBufferDescriptor : GPUObjectDescriptorBase {
|
||||
required GPUSize64 size;
|
||||
required GPUBufferUsageFlags usage;
|
||||
|
|
@ -184,24 +195,24 @@ dictionary GPUBufferDescriptor : GPUObjectDescriptorBase {
|
|||
|
||||
typedef [EnforceRange] unsigned long GPUBufferUsageFlags;
|
||||
[Exposed=(Window, DedicatedWorker), Pref="dom.webgpu.enabled"]
|
||||
interface GPUBufferUsage {
|
||||
const GPUBufferUsageFlags MAP_READ = 0x0001;
|
||||
const GPUBufferUsageFlags MAP_WRITE = 0x0002;
|
||||
const GPUBufferUsageFlags COPY_SRC = 0x0004;
|
||||
const GPUBufferUsageFlags COPY_DST = 0x0008;
|
||||
const GPUBufferUsageFlags INDEX = 0x0010;
|
||||
const GPUBufferUsageFlags VERTEX = 0x0020;
|
||||
const GPUBufferUsageFlags UNIFORM = 0x0040;
|
||||
const GPUBufferUsageFlags STORAGE = 0x0080;
|
||||
const GPUBufferUsageFlags INDIRECT = 0x0100;
|
||||
const GPUBufferUsageFlags QUERY_RESOLVE = 0x0200;
|
||||
namespace GPUBufferUsage {
|
||||
const GPUFlagsConstant MAP_READ = 0x0001;
|
||||
const GPUFlagsConstant MAP_WRITE = 0x0002;
|
||||
const GPUFlagsConstant COPY_SRC = 0x0004;
|
||||
const GPUFlagsConstant COPY_DST = 0x0008;
|
||||
const GPUFlagsConstant INDEX = 0x0010;
|
||||
const GPUFlagsConstant VERTEX = 0x0020;
|
||||
const GPUFlagsConstant UNIFORM = 0x0040;
|
||||
const GPUFlagsConstant STORAGE = 0x0080;
|
||||
const GPUFlagsConstant INDIRECT = 0x0100;
|
||||
const GPUFlagsConstant QUERY_RESOLVE = 0x0200;
|
||||
};
|
||||
|
||||
typedef [EnforceRange] unsigned long GPUMapModeFlags;
|
||||
[Exposed=(Window, DedicatedWorker), Pref="dom.webgpu.enabled"]
|
||||
interface GPUMapMode {
|
||||
const GPUMapModeFlags READ = 0x0001;
|
||||
const GPUMapModeFlags WRITE = 0x0002;
|
||||
namespace GPUMapMode {
|
||||
const GPUFlagsConstant READ = 0x0001;
|
||||
const GPUFlagsConstant WRITE = 0x0002;
|
||||
};
|
||||
|
||||
[Exposed=(Window, DedicatedWorker), Serializable , Pref="dom.webgpu.enabled"]
|
||||
|
|
|
|||
|
|
@ -267,9 +267,8 @@ pub enum WebGPURequest {
|
|||
},
|
||||
UnmapBuffer {
|
||||
buffer_id: id::BufferId,
|
||||
device_id: id::DeviceId,
|
||||
array_buffer: IpcSharedMemory,
|
||||
is_map_read: bool,
|
||||
write_back: bool,
|
||||
offset: u64,
|
||||
size: u64,
|
||||
},
|
||||
|
|
|
|||
|
|
@ -4,10 +4,13 @@
|
|||
|
||||
//! IPC messages that are send to WebGPU DOM objects.
|
||||
|
||||
use std::ops::Range;
|
||||
|
||||
use ipc_channel::ipc::IpcSharedMemory;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use wgc::id;
|
||||
use wgc::pipeline::CreateShaderModuleError;
|
||||
use wgpu_core::device::HostMap;
|
||||
use wgpu_core::instance::{RequestAdapterError, RequestDeviceError};
|
||||
use wgpu_core::resource::BufferAccessError;
|
||||
pub use {wgpu_core as wgc, wgpu_types as wgt};
|
||||
|
|
@ -72,6 +75,13 @@ pub struct Pipeline<T: std::fmt::Debug + Serialize> {
|
|||
pub label: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Mapping {
|
||||
pub data: IpcSharedMemory,
|
||||
pub mode: HostMap,
|
||||
pub range: Range<u64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[allow(clippy::large_enum_variant)]
|
||||
pub enum WebGPUResponse {
|
||||
|
|
@ -85,7 +95,7 @@ pub enum WebGPUResponse {
|
|||
Result<wgt::DeviceDescriptor<Option<String>>, RequestDeviceError>,
|
||||
),
|
||||
),
|
||||
BufferMapAsync(Result<IpcSharedMemory, BufferAccessError>),
|
||||
BufferMapAsync(Result<Mapping, BufferAccessError>),
|
||||
SubmittedWorkDone,
|
||||
PoppedErrorScope(Result<Option<Error>, PopError>),
|
||||
CompilationInfo(Option<ShaderCompilationInfo>),
|
||||
|
|
|
|||
|
|
@ -40,8 +40,8 @@ use crate::gpu_error::ErrorScope;
|
|||
use crate::poll_thread::Poller;
|
||||
use crate::render_commands::apply_render_command;
|
||||
use crate::{
|
||||
Adapter, ComputePassId, Error, Pipeline, PopError, PresentationData, RenderPassId, WebGPU,
|
||||
WebGPUAdapter, WebGPUDevice, WebGPUMsg, WebGPUQueue, WebGPURequest, WebGPUResponse,
|
||||
Adapter, ComputePassId, Error, Mapping, Pipeline, PopError, PresentationData, RenderPassId,
|
||||
WebGPU, WebGPUAdapter, WebGPUDevice, WebGPUMsg, WebGPUQueue, WebGPURequest, WebGPUResponse,
|
||||
};
|
||||
|
||||
pub const PRESENTATION_BUFFER_COUNT: usize = 10;
|
||||
|
|
@ -191,11 +191,11 @@ impl WGPU {
|
|||
let callback = BufferMapCallback::from_rust(Box::from(
|
||||
move |result: BufferAccessResult| {
|
||||
drop(token);
|
||||
let response = result.map(|_| {
|
||||
let response = result.and_then(|_| {
|
||||
let global = &glob;
|
||||
let (slice_pointer, range_size) = gfx_select!(buffer_id =>
|
||||
global.buffer_get_mapped_range(buffer_id, 0, None))
|
||||
.unwrap();
|
||||
global.buffer_get_mapped_range(buffer_id, offset, size))
|
||||
?;
|
||||
// SAFETY: guarantee to be safe from wgpu
|
||||
let data = unsafe {
|
||||
slice::from_raw_parts(
|
||||
|
|
@ -204,7 +204,11 @@ impl WGPU {
|
|||
)
|
||||
};
|
||||
|
||||
IpcSharedMemory::from_bytes(data)
|
||||
Ok(Mapping {
|
||||
data: IpcSharedMemory::from_bytes(data),
|
||||
range: offset..offset + range_size,
|
||||
mode: host_map,
|
||||
})
|
||||
});
|
||||
if let Err(e) =
|
||||
resp_sender.send(WebGPUResponse::BufferMapAsync(response))
|
||||
|
|
@ -226,13 +230,6 @@ impl WGPU {
|
|||
operation
|
||||
));
|
||||
self.poller.wake();
|
||||
if let Err(e) = &result {
|
||||
if let Err(w) =
|
||||
sender.send(WebGPUResponse::BufferMapAsync(Err(e.to_owned())))
|
||||
{
|
||||
warn!("Failed to send BufferMapAsync Response ({:?})", w);
|
||||
}
|
||||
}
|
||||
// Per spec we also need to raise validation error here
|
||||
self.maybe_dispatch_wgpu_error(device_id, result.err());
|
||||
},
|
||||
|
|
@ -1208,31 +1205,31 @@ impl WGPU {
|
|||
},
|
||||
WebGPURequest::UnmapBuffer {
|
||||
buffer_id,
|
||||
device_id,
|
||||
array_buffer,
|
||||
is_map_read,
|
||||
write_back,
|
||||
offset,
|
||||
size,
|
||||
} => {
|
||||
let global = &self.global;
|
||||
if !is_map_read {
|
||||
let (slice_pointer, range_size) =
|
||||
gfx_select!(buffer_id => global.buffer_get_mapped_range(
|
||||
if write_back {
|
||||
if let Ok((slice_pointer, range_size)) = gfx_select!(
|
||||
buffer_id => global.buffer_get_mapped_range(
|
||||
buffer_id,
|
||||
offset,
|
||||
Some(size)
|
||||
))
|
||||
.unwrap();
|
||||
unsafe {
|
||||
slice::from_raw_parts_mut(
|
||||
slice_pointer.as_ptr(),
|
||||
range_size as usize,
|
||||
)
|
||||
) {
|
||||
unsafe {
|
||||
slice::from_raw_parts_mut(
|
||||
slice_pointer.as_ptr(),
|
||||
range_size as usize,
|
||||
)
|
||||
}
|
||||
.copy_from_slice(&array_buffer);
|
||||
}
|
||||
.copy_from_slice(&array_buffer);
|
||||
}
|
||||
let result = gfx_select!(buffer_id => global.buffer_unmap(buffer_id));
|
||||
self.maybe_dispatch_wgpu_error(device_id, result.err());
|
||||
// Ignore result because this operation always succeed from user perspective
|
||||
let _result = gfx_select!(buffer_id => global.buffer_unmap(buffer_id));
|
||||
},
|
||||
WebGPURequest::WriteBuffer {
|
||||
device_id,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue