Implement GPUBuffer.getMappedRange()

This commit is contained in:
Kunal Mohan 2020-06-29 22:37:30 +05:30
parent 19b36bd795
commit 575036bb88
4 changed files with 132 additions and 91 deletions

View file

@ -2769,13 +2769,6 @@ where
warn!("Exit Canvas Paint thread failed ({})", e); warn!("Exit Canvas Paint thread failed ({})", e);
} }
if let Some(webgl_threads) = self.webgl_threads.as_ref() {
debug!("Exiting WebGL thread.");
if let Err(e) = webgl_threads.exit() {
warn!("Exit WebGL Thread failed ({})", e);
}
}
debug!("Exiting WebGPU threads."); debug!("Exiting WebGPU threads.");
let receivers = self let receivers = self
.browsing_context_group_set .browsing_context_group_set
@ -2800,6 +2793,13 @@ where
} }
} }
if let Some(webgl_threads) = self.webgl_threads.as_ref() {
debug!("Exiting WebGL thread.");
if let Err(e) = webgl_threads.exit() {
warn!("Exit WebGL Thread failed ({})", e);
}
}
debug!("Exiting GLPlayer thread."); debug!("Exiting GLPlayer thread.");
if let Some(glplayer_threads) = self.glplayer_threads.as_ref() { if let Some(glplayer_threads) = self.glplayer_threads.as_ref() {
if let Err(e) = glplayer_threads.exit() { if let Err(e) = glplayer_threads.exit() {

View file

@ -2,32 +2,35 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use crate::dom::bindings::cell::DomRefCell; use crate::dom::bindings::cell::{DomRefCell, RefCell};
use crate::dom::bindings::codegen::Bindings::GPUBufferBinding::{GPUBufferMethods, GPUSize64}; use crate::dom::bindings::codegen::Bindings::GPUBufferBinding::{GPUBufferMethods, GPUSize64};
use crate::dom::bindings::codegen::Bindings::GPUMapModeBinding::GPUMapModeConstants; use crate::dom::bindings::codegen::Bindings::GPUMapModeBinding::GPUMapModeConstants;
use crate::dom::bindings::error::Error; use crate::dom::bindings::error::{Error, Fallible};
use crate::dom::bindings::reflector::DomObject; use crate::dom::bindings::reflector::DomObject;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector}; use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use crate::dom::bindings::root::DomRoot; use crate::dom::bindings::root::DomRoot;
use crate::dom::bindings::str::DOMString; use crate::dom::bindings::str::DOMString;
use crate::dom::bindings::trace::RootedTraceableBox;
use crate::dom::globalscope::GlobalScope; use crate::dom::globalscope::GlobalScope;
use crate::dom::gpu::{response_async, AsyncWGPUListener}; use crate::dom::gpu::{response_async, AsyncWGPUListener};
use crate::dom::promise::Promise; use crate::dom::promise::Promise;
use crate::realms::InRealm; use crate::realms::InRealm;
use crate::script_runtime::JSContext;
use dom_struct::dom_struct; use dom_struct::dom_struct;
use js::jsapi::DetachArrayBuffer;
use js::jsapi::NewExternalArrayBuffer;
use js::jsapi::{Heap, JSObject}; use js::jsapi::{Heap, JSObject};
use js::jsval::UndefinedValue;
use js::rust::jsapi_wrapped::{DetachArrayBuffer, IsPromiseObject, RejectPromise};
use js::typedarray::{ArrayBuffer, CreateWith};
use std::cell::Cell; use std::cell::Cell;
use std::ffi::c_void;
use std::ops::Range; use std::ops::Range;
use std::ptr; use std::ptr::NonNull;
use std::rc::Rc; use std::rc::Rc;
use webgpu::{ use webgpu::{
wgpu::device::HostMap, WebGPU, WebGPUBuffer, WebGPUDevice, WebGPURequest, WebGPUResponse, wgpu::device::HostMap, WebGPU, WebGPUBuffer, WebGPUDevice, WebGPURequest, WebGPUResponse,
}; };
const RANGE_OFFSET_ALIGN_MASK: u64 = 8;
const RANGE_SIZE_ALIGN_MASK: u64 = 4;
// https://gpuweb.github.io/gpuweb/#buffer-state // https://gpuweb.github.io/gpuweb/#buffer-state
#[derive(Clone, Copy, MallocSizeOf, PartialEq)] #[derive(Clone, Copy, MallocSizeOf, PartialEq)]
pub enum GPUBufferState { pub enum GPUBufferState {
@ -49,8 +52,13 @@ pub struct GPUBuffer {
device: WebGPUDevice, device: WebGPUDevice,
valid: Cell<bool>, valid: Cell<bool>,
#[ignore_malloc_size_of = "defined in mozjs"] #[ignore_malloc_size_of = "defined in mozjs"]
mapping: RootedTraceableBox<Heap<*mut JSObject>>, mapping: Rc<RefCell<Option<Vec<u8>>>>,
mapping_range: DomRefCell<Range<u64>>, mapping_range: DomRefCell<Option<Range<u64>>>,
mapped_ranges: DomRefCell<Option<Vec<Range<u64>>>>,
#[ignore_malloc_size_of = "defined in mozjs"]
js_buffers: DomRefCell<Option<Vec<Box<Heap<*mut JSObject>>>>>,
#[ignore_malloc_size_of = "defined in mozjs"]
map_promise: DomRefCell<Option<Rc<Promise>>>,
size: GPUSize64, size: GPUSize64,
map_mode: Cell<Option<u32>>, map_mode: Cell<Option<u32>>,
} }
@ -63,7 +71,7 @@ impl GPUBuffer {
state: GPUBufferState, state: GPUBufferState,
size: GPUSize64, size: GPUSize64,
valid: bool, valid: bool,
mapping: RootedTraceableBox<Heap<*mut JSObject>>, mapping: Rc<RefCell<Option<Vec<u8>>>>,
mapping_range: Range<u64>, mapping_range: Range<u64>,
) -> Self { ) -> Self {
Self { Self {
@ -75,8 +83,11 @@ impl GPUBuffer {
device, device,
buffer, buffer,
mapping, mapping,
mapped_ranges: DomRefCell::new(None),
js_buffers: DomRefCell::new(None),
map_promise: DomRefCell::new(None),
size, size,
mapping_range: DomRefCell::new(mapping_range), mapping_range: DomRefCell::new(Some(mapping_range)),
map_mode: Cell::new(None), map_mode: Cell::new(None),
} }
} }
@ -90,7 +101,7 @@ impl GPUBuffer {
state: GPUBufferState, state: GPUBufferState,
size: GPUSize64, size: GPUSize64,
valid: bool, valid: bool,
mapping: RootedTraceableBox<Heap<*mut JSObject>>, mapping: Rc<RefCell<Option<Vec<u8>>>>,
mapping_range: Range<u64>, mapping_range: Range<u64>,
) -> DomRoot<Self> { ) -> DomRoot<Self> {
reflect_dom_object( reflect_dom_object(
@ -142,51 +153,34 @@ impl GPUBufferMethods for GPUBuffer {
}, },
// Step 3 // Step 3
GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => { GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => {
match ArrayBuffer::from(self.mapping.get()) { if let Err(e) = self.channel.0.send(WebGPURequest::UnmapBuffer {
Ok(array_buffer) => { buffer_id: self.id().0,
// Step 3.2 array_buffer: self.mapping.borrow().as_ref().unwrap().clone(),
self.channel is_map_read: self.map_mode.get() == Some(GPUMapModeConstants::READ),
.0 offset: self.mapping_range.borrow().as_ref().unwrap().start,
.send(WebGPURequest::UnmapBuffer { size: self.mapping_range.borrow().as_ref().unwrap().end -
buffer_id: self.id().0, self.mapping_range.borrow().as_ref().unwrap().start,
array_buffer: array_buffer.to_vec(), }) {
is_map_read: self.map_mode.get() == Some(GPUMapModeConstants::READ), warn!("Failed to send Buffer unmap ({:?}) ({})", self.buffer.0, e);
offset: self.mapping_range.borrow().start, }
size: self.mapping_range.borrow().end - // Step 3.3
self.mapping_range.borrow().start, let mut bufs = self.js_buffers.borrow_mut().take().unwrap();
}) bufs.drain(..).for_each(|obj| unsafe {
.unwrap(); DetachArrayBuffer(*cx, obj.handle());
// Step 3.3 });
unsafe { *self.mapped_ranges.borrow_mut() = None;
DetachArrayBuffer(*cx, self.mapping.handle()); *self.mapping.borrow_mut() = None;
}
},
Err(_) => {
warn!(
"Could not find ArrayBuffer of Mapped buffer ({:?})",
self.buffer.0
);
},
};
}, },
// Step 2 // Step 2
GPUBufferState::MappingPending => unsafe { GPUBufferState::MappingPending => {
if IsPromiseObject(self.mapping.handle()) { let promise = self.map_promise.borrow_mut().take().unwrap();
let err = Error::Operation; promise.reject_error(Error::Operation);
rooted!(in(*cx) let mut undef = UndefinedValue());
err.to_jsval(*cx, &self.global(), undef.handle_mut());
RejectPromise(*cx, self.mapping.handle(), undef.handle());
} else {
warn!("No promise object for pending mapping found");
}
}, },
}; };
// Step 3.3
self.mapping.set(ptr::null_mut());
// Step 4 // Step 4
self.state.set(GPUBufferState::Unmapped); self.state.set(GPUBufferState::Unmapped);
self.map_mode.set(None); self.map_mode.set(None);
*self.mapping_range.borrow_mut() = 0..0; *self.mapping_range.borrow_mut() = None;
} }
/// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy
@ -213,7 +207,13 @@ impl GPUBufferMethods for GPUBuffer {
#[allow(unsafe_code)] #[allow(unsafe_code)]
/// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapasync-offset-size /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapasync-offset-size
fn MapAsync(&self, mode: u32, offset: u64, size: u64, comp: InRealm) -> Rc<Promise> { fn MapAsync(
&self,
mode: u32,
offset: GPUSize64,
size: GPUSize64,
comp: InRealm,
) -> Rc<Promise> {
let promise = Promise::new_in_current_realm(&self.global(), comp); let promise = Promise::new_in_current_realm(&self.global(), comp);
let map_range = if size == 0 { let map_range = if size == 0 {
offset..self.size offset..self.size
@ -237,7 +237,6 @@ impl GPUBufferMethods for GPUBuffer {
promise.reject_error(Error::Abort); promise.reject_error(Error::Abort);
return promise; return promise;
} }
self.mapping.set(*promise.promise_obj());
let sender = response_async(&promise, self); let sender = response_async(&promise, self);
if let Err(e) = self.channel.0.send(WebGPURequest::BufferMapAsync { if let Err(e) = self.channel.0.send(WebGPURequest::BufferMapAsync {
@ -256,10 +255,72 @@ impl GPUBufferMethods for GPUBuffer {
self.state.set(GPUBufferState::MappingPending); self.state.set(GPUBufferState::MappingPending);
self.map_mode.set(Some(mode)); self.map_mode.set(Some(mode));
*self.mapping_range.borrow_mut() = map_range; *self.mapping_range.borrow_mut() = Some(map_range);
*self.map_promise.borrow_mut() = Some(promise.clone());
promise promise
} }
/// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-getmappedrange
#[allow(unsafe_code)]
fn GetMappedRange(
&self,
cx: JSContext,
offset: GPUSize64,
size: GPUSize64,
) -> Fallible<NonNull<JSObject>> {
if self.mapped_ranges.borrow().is_none() {
*self.mapped_ranges.borrow_mut() = Some(Vec::new());
}
if self.js_buffers.borrow().is_none() {
*self.js_buffers.borrow_mut() = Some(Vec::new());
}
let act_size = if size == 0 { self.size - offset } else { size };
let mut valid = match self.state.get() {
GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => true,
_ => false,
};
valid &= offset % RANGE_OFFSET_ALIGN_MASK == 0 &&
act_size % RANGE_SIZE_ALIGN_MASK == 0 &&
offset >= self.mapping_range.borrow().as_ref().unwrap().start &&
offset + act_size <= self.mapping_range.borrow().as_ref().unwrap().end;
valid &= self
.mapped_ranges
.borrow()
.as_ref()
.unwrap()
.iter()
.all(|range| range.start > offset + act_size || range.end < offset);
if !valid {
return Err(Error::Operation);
}
unsafe extern "C" fn free_func(_contents: *mut c_void, free_user_data: *mut c_void) {
let _ = Rc::from_raw(free_user_data as _);
}
let array_buffer = unsafe {
NewExternalArrayBuffer(
*cx,
act_size as usize,
self.mapping.borrow_mut().as_mut().unwrap()
[offset as usize..(offset + act_size) as usize]
.as_mut_ptr() as _,
Some(free_func),
Rc::into_raw(self.mapping.clone()) as _,
)
};
self.mapped_ranges
.borrow_mut()
.as_mut()
.map(|v| v.push(offset..offset + act_size));
self.js_buffers
.borrow_mut()
.as_mut()
.map(|a| a.push(Heap::boxed(array_buffer)));
Ok(NonNull::new(array_buffer).unwrap())
}
/// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label /// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label
fn GetLabel(&self) -> Option<DOMString> { fn GetLabel(&self) -> Option<DOMString> {
self.label.borrow().clone() self.label.borrow().clone()
@ -276,21 +337,8 @@ impl AsyncWGPUListener for GPUBuffer {
fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>) { fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>) {
match response { match response {
WebGPUResponse::BufferMapAsync(bytes) => { WebGPUResponse::BufferMapAsync(bytes) => {
let cx = self.global().get_cx(); *self.mapping.borrow_mut() = Some(bytes);
rooted!(in(*cx) let mut array_buffer = ptr::null_mut::<JSObject>()); promise.resolve_native(&());
match unsafe {
ArrayBuffer::create(*cx, CreateWith::Slice(&bytes), array_buffer.handle_mut())
} {
Ok(_) => promise.resolve_native(&()),
Err(()) => {
warn!(
"Failed to create ArrayBuffer for buffer({:?})",
self.buffer.0
);
promise.reject_error(Error::Operation);
},
}
self.mapping.set(array_buffer.get());
self.state.set(GPUBufferState::Mapped); self.state.set(GPUBufferState::Mapped);
}, },
_ => { _ => {
@ -298,6 +346,7 @@ impl AsyncWGPUListener for GPUBuffer {
promise.reject_error(Error::Operation); promise.reject_error(Error::Operation);
}, },
} }
*self.map_promise.borrow_mut() = None;
if let Err(e) = self if let Err(e) = self
.channel .channel
.0 .0

View file

@ -4,7 +4,7 @@
#![allow(unsafe_code)] #![allow(unsafe_code)]
use crate::dom::bindings::cell::DomRefCell; use crate::dom::bindings::cell::{DomRefCell, RefCell};
use crate::dom::bindings::codegen::Bindings::GPUBindGroupBinding::{ use crate::dom::bindings::codegen::Bindings::GPUBindGroupBinding::{
GPUBindGroupDescriptor, GPUBindingResource, GPUBindGroupDescriptor, GPUBindingResource,
}; };
@ -54,8 +54,8 @@ use crate::script_runtime::JSContext as SafeJSContext;
use arrayvec::ArrayVec; use arrayvec::ArrayVec;
use dom_struct::dom_struct; use dom_struct::dom_struct;
use js::jsapi::{Heap, JSObject}; use js::jsapi::{Heap, JSObject};
use js::typedarray::{ArrayBuffer, CreateWith}; use std::ptr::NonNull;
use std::ptr::{self, NonNull}; use std::rc::Rc;
use webgpu::wgpu::binding_model::BufferBinding; use webgpu::wgpu::binding_model::BufferBinding;
use webgpu::{self, wgt, WebGPU, WebGPUBindings, WebGPURequest}; use webgpu::{self, wgt, WebGPU, WebGPUBindings, WebGPURequest};
@ -177,24 +177,16 @@ impl GPUDeviceMethods for GPUDevice {
.expect("Failed to create WebGPU buffer"); .expect("Failed to create WebGPU buffer");
let buffer = webgpu::WebGPUBuffer(id); let buffer = webgpu::WebGPUBuffer(id);
let mapping = RootedTraceableBox::new(Heap::default()); let mapping;
let state; let state;
let mapping_range; let mapping_range;
if descriptor.mappedAtCreation { if descriptor.mappedAtCreation {
let cx = self.global().get_cx(); let buf_data = vec![0u8; descriptor.size as usize];
rooted!(in(*cx) let mut array_buffer = ptr::null_mut::<JSObject>()); mapping = Rc::new(RefCell::new(Some(buf_data)));
unsafe {
assert!(ArrayBuffer::create(
*cx,
CreateWith::Length(descriptor.size as u32),
array_buffer.handle_mut(),
)
.is_ok());
}
mapping.set(array_buffer.get());
state = GPUBufferState::MappedAtCreation; state = GPUBufferState::MappedAtCreation;
mapping_range = 0..descriptor.size; mapping_range = 0..descriptor.size;
} else { } else {
mapping = Rc::new(RefCell::new(None));
state = GPUBufferState::Unmapped; state = GPUBufferState::Unmapped;
mapping_range = 0..0; mapping_range = 0..0;
} }

View file

@ -6,7 +6,7 @@
[Exposed=(Window, DedicatedWorker), Serializable, Pref="dom.webgpu.enabled"] [Exposed=(Window, DedicatedWorker), Serializable, Pref="dom.webgpu.enabled"]
interface GPUBuffer { interface GPUBuffer {
Promise<void> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size = 0); Promise<void> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size = 0);
//ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size = 0); [Throws] ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size = 0);
void unmap(); void unmap();
void destroy(); void destroy();