diff --git a/components/constellation/constellation.rs b/components/constellation/constellation.rs index d3b3513a98e..1fe8bb034f2 100644 --- a/components/constellation/constellation.rs +++ b/components/constellation/constellation.rs @@ -2769,13 +2769,6 @@ where 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."); let receivers = self .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."); if let Some(glplayer_threads) = self.glplayer_threads.as_ref() { if let Err(e) = glplayer_threads.exit() { diff --git a/components/script/dom/gpubuffer.rs b/components/script/dom/gpubuffer.rs index 474c30dba0f..724e22f6f53 100644 --- a/components/script/dom/gpubuffer.rs +++ b/components/script/dom/gpubuffer.rs @@ -5,29 +5,32 @@ use crate::dom::bindings::cell::DomRefCell; use crate::dom::bindings::codegen::Bindings::GPUBufferBinding::{GPUBufferMethods, GPUSize64}; 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::{reflect_dom_object, Reflector}; use crate::dom::bindings::root::DomRoot; use crate::dom::bindings::str::DOMString; -use crate::dom::bindings::trace::RootedTraceableBox; use crate::dom::globalscope::GlobalScope; use crate::dom::gpu::{response_async, AsyncWGPUListener}; use crate::dom::promise::Promise; use crate::realms::InRealm; +use crate::script_runtime::JSContext; use dom_struct::dom_struct; +use js::jsapi::DetachArrayBuffer; +use js::jsapi::NewExternalArrayBuffer; 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, RefCell}; +use std::ffi::c_void; use std::ops::Range; -use std::ptr; +use std::ptr::NonNull; use std::rc::Rc; use webgpu::{ 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 #[derive(Clone, Copy, MallocSizeOf, PartialEq)] pub enum GPUBufferState { @@ -38,6 +41,17 @@ pub enum GPUBufferState { Destroyed, } +#[derive(JSTraceable, MallocSizeOf)] +pub struct GPUBufferMapInfo { + #[ignore_malloc_size_of = "Rc"] + pub mapping: Rc>>, + pub mapping_range: Range, + pub mapped_ranges: Vec>, + #[ignore_malloc_size_of = "defined in mozjs"] + pub js_buffers: Vec>>, + pub map_mode: Option, +} + #[dom_struct] pub struct GPUBuffer { reflector_: Reflector, @@ -48,11 +62,10 @@ pub struct GPUBuffer { buffer: WebGPUBuffer, device: WebGPUDevice, valid: Cell, - #[ignore_malloc_size_of = "defined in mozjs"] - mapping: RootedTraceableBox>, - mapping_range: DomRefCell>, size: GPUSize64, - map_mode: Cell>, + #[ignore_malloc_size_of = "promises are hard"] + map_promise: DomRefCell>>, + map_info: DomRefCell>, } impl GPUBuffer { @@ -63,8 +76,7 @@ impl GPUBuffer { state: GPUBufferState, size: GPUSize64, valid: bool, - mapping: RootedTraceableBox>, - mapping_range: Range, + map_info: DomRefCell>, ) -> Self { Self { reflector_: Reflector::new(), @@ -74,10 +86,9 @@ impl GPUBuffer { valid: Cell::new(valid), device, buffer, - mapping, + map_promise: DomRefCell::new(None), size, - mapping_range: DomRefCell::new(mapping_range), - map_mode: Cell::new(None), + map_info, } } @@ -90,19 +101,11 @@ impl GPUBuffer { state: GPUBufferState, size: GPUSize64, valid: bool, - mapping: RootedTraceableBox>, - mapping_range: Range, + map_info: DomRefCell>, ) -> DomRoot { reflect_dom_object( Box::new(GPUBuffer::new_inherited( - channel, - buffer, - device, - state, - size, - valid, - mapping, - mapping_range, + channel, buffer, device, state, size, valid, map_info, )), global, ) @@ -142,51 +145,32 @@ impl GPUBufferMethods for GPUBuffer { }, // Step 3 GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => { - match ArrayBuffer::from(self.mapping.get()) { - Ok(array_buffer) => { - // Step 3.2 - self.channel - .0 - .send(WebGPURequest::UnmapBuffer { - buffer_id: self.id().0, - array_buffer: array_buffer.to_vec(), - is_map_read: self.map_mode.get() == Some(GPUMapModeConstants::READ), - offset: self.mapping_range.borrow().start, - size: self.mapping_range.borrow().end - - self.mapping_range.borrow().start, - }) - .unwrap(); - // Step 3.3 - unsafe { - DetachArrayBuffer(*cx, self.mapping.handle()); - } - }, - Err(_) => { - warn!( - "Could not find ArrayBuffer of Mapped buffer ({:?})", - self.buffer.0 - ); - }, - }; + let mut info = self.map_info.borrow_mut(); + let m_info = info.as_mut().unwrap(); + let m_range = m_info.mapping_range.clone(); + if let Err(e) = self.channel.0.send(WebGPURequest::UnmapBuffer { + buffer_id: self.id().0, + array_buffer: m_info.mapping.borrow().clone(), + 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| unsafe { + DetachArrayBuffer(*cx, obj.handle()); + }); }, // Step 2 - GPUBufferState::MappingPending => unsafe { - if IsPromiseObject(self.mapping.handle()) { - let err = 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"); - } + GPUBufferState::MappingPending => { + let promise = self.map_promise.borrow_mut().take().unwrap(); + promise.reject_error(Error::Operation); }, }; - // Step 3.3 - self.mapping.set(ptr::null_mut()); // Step 4 self.state.set(GPUBufferState::Unmapped); - self.map_mode.set(None); - *self.mapping_range.borrow_mut() = 0..0; + *self.map_info.borrow_mut() = None; } /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy @@ -213,7 +197,13 @@ impl GPUBufferMethods for GPUBuffer { #[allow(unsafe_code)] /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapasync-offset-size - fn MapAsync(&self, mode: u32, offset: u64, size: u64, comp: InRealm) -> Rc { + fn MapAsync( + &self, + mode: u32, + offset: GPUSize64, + size: GPUSize64, + comp: InRealm, + ) -> Rc { let promise = Promise::new_in_current_realm(&self.global(), comp); let map_range = if size == 0 { offset..self.size @@ -237,7 +227,6 @@ impl GPUBufferMethods for GPUBuffer { promise.reject_error(Error::Abort); return promise; } - self.mapping.set(*promise.promise_obj()); let sender = response_async(&promise, self); if let Err(e) = self.channel.0.send(WebGPURequest::BufferMapAsync { @@ -255,11 +244,65 @@ impl GPUBufferMethods for GPUBuffer { } self.state.set(GPUBufferState::MappingPending); - self.map_mode.set(Some(mode)); - *self.mapping_range.borrow_mut() = map_range; + *self.map_info.borrow_mut() = Some(GPUBufferMapInfo { + mapping: Rc::new(RefCell::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()); promise } + /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-getmappedrange + #[allow(unsafe_code)] + fn GetMappedRange( + &self, + cx: JSContext, + offset: GPUSize64, + size: GPUSize64, + ) -> Fallible> { + let m_end = if size == 0 { self.size } else { offset + size }; + let mut info = self.map_info.borrow_mut(); + let m_info = info.as_mut().unwrap(); + + let mut valid = match self.state.get() { + GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => true, + _ => false, + }; + valid &= offset % RANGE_OFFSET_ALIGN_MASK == 0 && + (m_end - offset) % 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); + 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, + (m_end - offset) as usize, + m_info.mapping.borrow_mut()[offset as usize..m_end as usize].as_mut_ptr() as _, + Some(free_func), + Rc::into_raw(m_info.mapping.clone()) as _, + ) + }; + + m_info.mapped_ranges.push(offset..m_end); + m_info.js_buffers.push(Heap::boxed(array_buffer)); + + Ok(NonNull::new(array_buffer).unwrap()) + } + /// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label fn GetLabel(&self) -> Option { self.label.borrow().clone() @@ -276,21 +319,14 @@ impl AsyncWGPUListener for GPUBuffer { fn handle_response(&self, response: WebGPUResponse, promise: &Rc) { match response { WebGPUResponse::BufferMapAsync(bytes) => { - let cx = self.global().get_cx(); - rooted!(in(*cx) let mut array_buffer = ptr::null_mut::()); - 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 + .map_info + .borrow_mut() + .as_mut() + .unwrap() + .mapping + .borrow_mut() = bytes; + promise.resolve_native(&()); self.state.set(GPUBufferState::Mapped); }, _ => { @@ -298,6 +334,7 @@ impl AsyncWGPUListener for GPUBuffer { promise.reject_error(Error::Operation); }, } + *self.map_promise.borrow_mut() = None; if let Err(e) = self .channel .0 diff --git a/components/script/dom/gpudevice.rs b/components/script/dom/gpudevice.rs index 0eb5771baac..d5250f1230f 100644 --- a/components/script/dom/gpudevice.rs +++ b/components/script/dom/gpudevice.rs @@ -41,7 +41,7 @@ use crate::dom::globalscope::GlobalScope; use crate::dom::gpuadapter::GPUAdapter; use crate::dom::gpubindgroup::GPUBindGroup; use crate::dom::gpubindgrouplayout::GPUBindGroupLayout; -use crate::dom::gpubuffer::{GPUBuffer, GPUBufferState}; +use crate::dom::gpubuffer::{GPUBuffer, GPUBufferMapInfo, GPUBufferState}; use crate::dom::gpucommandencoder::GPUCommandEncoder; use crate::dom::gpucomputepipeline::GPUComputePipeline; use crate::dom::gpupipelinelayout::GPUPipelineLayout; @@ -54,8 +54,9 @@ use crate::script_runtime::JSContext as SafeJSContext; use arrayvec::ArrayVec; use dom_struct::dom_struct; use js::jsapi::{Heap, JSObject}; -use js::typedarray::{ArrayBuffer, CreateWith}; -use std::ptr::{self, NonNull}; +use std::cell::RefCell; +use std::ptr::NonNull; +use std::rc::Rc; use webgpu::wgpu::binding_model::BufferBinding; use webgpu::{self, wgt, WebGPU, WebGPUBindings, WebGPURequest}; @@ -177,26 +178,21 @@ impl GPUDeviceMethods for GPUDevice { .expect("Failed to create WebGPU buffer"); let buffer = webgpu::WebGPUBuffer(id); - let mapping = RootedTraceableBox::new(Heap::default()); + let map_info; let state; - let mapping_range; if descriptor.mappedAtCreation { - let cx = self.global().get_cx(); - rooted!(in(*cx) let mut array_buffer = ptr::null_mut::()); - unsafe { - assert!(ArrayBuffer::create( - *cx, - CreateWith::Length(descriptor.size as u32), - array_buffer.handle_mut(), - ) - .is_ok()); - } - mapping.set(array_buffer.get()); + let buf_data = vec![0u8; descriptor.size as usize]; + map_info = DomRefCell::new(Some(GPUBufferMapInfo { + mapping: Rc::new(RefCell::new(buf_data)), + mapping_range: 0..descriptor.size, + mapped_ranges: Vec::new(), + js_buffers: Vec::new(), + map_mode: None, + })); state = GPUBufferState::MappedAtCreation; - mapping_range = 0..descriptor.size; } else { + map_info = DomRefCell::new(None); state = GPUBufferState::Unmapped; - mapping_range = 0..0; } GPUBuffer::new( @@ -207,8 +203,7 @@ impl GPUDeviceMethods for GPUDevice { state, descriptor.size, true, - mapping, - mapping_range, + map_info, ) } diff --git a/components/script/dom/webidls/GPUBuffer.webidl b/components/script/dom/webidls/GPUBuffer.webidl index f3e9e29a577..4611b26c3ae 100644 --- a/components/script/dom/webidls/GPUBuffer.webidl +++ b/components/script/dom/webidls/GPUBuffer.webidl @@ -6,7 +6,7 @@ [Exposed=(Window, DedicatedWorker), Serializable, Pref="dom.webgpu.enabled"] interface GPUBuffer { Promise 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 destroy();