From 575036bb88163807abbfb46773b7e124fd196fa4 Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Mon, 29 Jun 2020 22:37:30 +0530 Subject: [PATCH 1/2] Implement GPUBuffer.getMappedRange() --- components/constellation/constellation.rs | 14 +- components/script/dom/gpubuffer.rs | 185 +++++++++++------- components/script/dom/gpudevice.rs | 22 +-- .../script/dom/webidls/GPUBuffer.webidl | 2 +- 4 files changed, 132 insertions(+), 91 deletions(-) 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..e238057eb9a 100644 --- a/components/script/dom/gpubuffer.rs +++ b/components/script/dom/gpubuffer.rs @@ -2,32 +2,35 @@ * 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 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::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::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 { @@ -49,8 +52,13 @@ pub struct GPUBuffer { device: WebGPUDevice, valid: Cell, #[ignore_malloc_size_of = "defined in mozjs"] - mapping: RootedTraceableBox>, - mapping_range: DomRefCell>, + mapping: Rc>>>, + mapping_range: DomRefCell>>, + mapped_ranges: DomRefCell>>>, + #[ignore_malloc_size_of = "defined in mozjs"] + js_buffers: DomRefCell>>>>, + #[ignore_malloc_size_of = "defined in mozjs"] + map_promise: DomRefCell>>, size: GPUSize64, map_mode: Cell>, } @@ -63,7 +71,7 @@ impl GPUBuffer { state: GPUBufferState, size: GPUSize64, valid: bool, - mapping: RootedTraceableBox>, + mapping: Rc>>>, mapping_range: Range, ) -> Self { Self { @@ -75,8 +83,11 @@ impl GPUBuffer { device, buffer, mapping, + mapped_ranges: DomRefCell::new(None), + js_buffers: DomRefCell::new(None), + map_promise: DomRefCell::new(None), size, - mapping_range: DomRefCell::new(mapping_range), + mapping_range: DomRefCell::new(Some(mapping_range)), map_mode: Cell::new(None), } } @@ -90,7 +101,7 @@ impl GPUBuffer { state: GPUBufferState, size: GPUSize64, valid: bool, - mapping: RootedTraceableBox>, + mapping: Rc>>>, mapping_range: Range, ) -> DomRoot { reflect_dom_object( @@ -142,51 +153,34 @@ 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 - ); - }, - }; + if let Err(e) = self.channel.0.send(WebGPURequest::UnmapBuffer { + buffer_id: self.id().0, + array_buffer: self.mapping.borrow().as_ref().unwrap().clone(), + is_map_read: self.map_mode.get() == Some(GPUMapModeConstants::READ), + offset: self.mapping_range.borrow().as_ref().unwrap().start, + size: self.mapping_range.borrow().as_ref().unwrap().end - + self.mapping_range.borrow().as_ref().unwrap().start, + }) { + warn!("Failed to send Buffer unmap ({:?}) ({})", self.buffer.0, e); + } + // Step 3.3 + let mut bufs = self.js_buffers.borrow_mut().take().unwrap(); + bufs.drain(..).for_each(|obj| unsafe { + DetachArrayBuffer(*cx, obj.handle()); + }); + *self.mapped_ranges.borrow_mut() = None; + *self.mapping.borrow_mut() = None; }, // 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.mapping_range.borrow_mut() = None; } /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy @@ -213,7 +207,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 +237,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 { @@ -256,10 +255,72 @@ impl GPUBufferMethods for GPUBuffer { self.state.set(GPUBufferState::MappingPending); 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 } + /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-getmappedrange + #[allow(unsafe_code)] + fn GetMappedRange( + &self, + cx: JSContext, + offset: GPUSize64, + size: GPUSize64, + ) -> Fallible> { + 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 fn GetLabel(&self) -> Option { self.label.borrow().clone() @@ -276,21 +337,8 @@ 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.mapping.borrow_mut() = Some(bytes); + promise.resolve_native(&()); self.state.set(GPUBufferState::Mapped); }, _ => { @@ -298,6 +346,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..fba76b2d40f 100644 --- a/components/script/dom/gpudevice.rs +++ b/components/script/dom/gpudevice.rs @@ -4,7 +4,7 @@ #![allow(unsafe_code)] -use crate::dom::bindings::cell::DomRefCell; +use crate::dom::bindings::cell::{DomRefCell, RefCell}; use crate::dom::bindings::codegen::Bindings::GPUBindGroupBinding::{ GPUBindGroupDescriptor, GPUBindingResource, }; @@ -54,8 +54,8 @@ 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::ptr::NonNull; +use std::rc::Rc; use webgpu::wgpu::binding_model::BufferBinding; use webgpu::{self, wgt, WebGPU, WebGPUBindings, WebGPURequest}; @@ -177,24 +177,16 @@ impl GPUDeviceMethods for GPUDevice { .expect("Failed to create WebGPU buffer"); let buffer = webgpu::WebGPUBuffer(id); - let mapping = RootedTraceableBox::new(Heap::default()); + let mapping; 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]; + mapping = Rc::new(RefCell::new(Some(buf_data))); state = GPUBufferState::MappedAtCreation; mapping_range = 0..descriptor.size; } else { + mapping = Rc::new(RefCell::new(None)); state = GPUBufferState::Unmapped; mapping_range = 0..0; } 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(); From 891a3bd30ee918f426d9d1bc47013d9c5e5ab3db Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Wed, 1 Jul 2020 14:26:35 +0530 Subject: [PATCH 2/2] Encapsulate buffer map fields in a separate struct --- components/script/dom/gpubuffer.rs | 128 +++++++++++++---------------- components/script/dom/gpudevice.rs | 23 +++--- 2 files changed, 71 insertions(+), 80 deletions(-) diff --git a/components/script/dom/gpubuffer.rs b/components/script/dom/gpubuffer.rs index e238057eb9a..724e22f6f53 100644 --- a/components/script/dom/gpubuffer.rs +++ b/components/script/dom/gpubuffer.rs @@ -2,7 +2,7 @@ * 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 crate::dom::bindings::cell::{DomRefCell, RefCell}; +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, Fallible}; @@ -19,7 +19,7 @@ use dom_struct::dom_struct; use js::jsapi::DetachArrayBuffer; use js::jsapi::NewExternalArrayBuffer; use js::jsapi::{Heap, JSObject}; -use std::cell::Cell; +use std::cell::{Cell, RefCell}; use std::ffi::c_void; use std::ops::Range; use std::ptr::NonNull; @@ -41,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, @@ -51,16 +62,10 @@ pub struct GPUBuffer { buffer: WebGPUBuffer, device: WebGPUDevice, valid: Cell, - #[ignore_malloc_size_of = "defined in mozjs"] - mapping: Rc>>>, - mapping_range: DomRefCell>>, - mapped_ranges: DomRefCell>>>, - #[ignore_malloc_size_of = "defined in mozjs"] - js_buffers: DomRefCell>>>>, - #[ignore_malloc_size_of = "defined in mozjs"] - map_promise: DomRefCell>>, size: GPUSize64, - map_mode: Cell>, + #[ignore_malloc_size_of = "promises are hard"] + map_promise: DomRefCell>>, + map_info: DomRefCell>, } impl GPUBuffer { @@ -71,8 +76,7 @@ impl GPUBuffer { state: GPUBufferState, size: GPUSize64, valid: bool, - mapping: Rc>>>, - mapping_range: Range, + map_info: DomRefCell>, ) -> Self { Self { reflector_: Reflector::new(), @@ -82,13 +86,9 @@ impl GPUBuffer { valid: Cell::new(valid), device, buffer, - mapping, - mapped_ranges: DomRefCell::new(None), - js_buffers: DomRefCell::new(None), map_promise: DomRefCell::new(None), size, - mapping_range: DomRefCell::new(Some(mapping_range)), - map_mode: Cell::new(None), + map_info, } } @@ -101,19 +101,11 @@ impl GPUBuffer { state: GPUBufferState, size: GPUSize64, valid: bool, - mapping: Rc>>>, - 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, ) @@ -153,23 +145,22 @@ impl GPUBufferMethods for GPUBuffer { }, // Step 3 GPUBufferState::Mapped | GPUBufferState::MappedAtCreation => { + 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: self.mapping.borrow().as_ref().unwrap().clone(), - is_map_read: self.map_mode.get() == Some(GPUMapModeConstants::READ), - offset: self.mapping_range.borrow().as_ref().unwrap().start, - size: self.mapping_range.borrow().as_ref().unwrap().end - - self.mapping_range.borrow().as_ref().unwrap().start, + 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 - let mut bufs = self.js_buffers.borrow_mut().take().unwrap(); - bufs.drain(..).for_each(|obj| unsafe { + m_info.js_buffers.drain(..).for_each(|obj| unsafe { DetachArrayBuffer(*cx, obj.handle()); }); - *self.mapped_ranges.borrow_mut() = None; - *self.mapping.borrow_mut() = None; }, // Step 2 GPUBufferState::MappingPending => { @@ -179,8 +170,7 @@ impl GPUBufferMethods for GPUBuffer { }; // Step 4 self.state.set(GPUBufferState::Unmapped); - self.map_mode.set(None); - *self.mapping_range.borrow_mut() = None; + *self.map_info.borrow_mut() = None; } /// https://gpuweb.github.io/gpuweb/#dom-gpubuffer-destroy @@ -254,8 +244,13 @@ impl GPUBufferMethods for GPUBuffer { } self.state.set(GPUBufferState::MappingPending); - self.map_mode.set(Some(mode)); - *self.mapping_range.borrow_mut() = Some(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 } @@ -268,28 +263,22 @@ impl GPUBufferMethods for GPUBuffer { offset: GPUSize64, size: GPUSize64, ) -> Fallible> { - 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 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 && - 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 + (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 - .borrow() - .as_ref() - .unwrap() .iter() - .all(|range| range.start > offset + act_size || range.end < offset); + .all(|range| range.start >= m_end || range.end <= offset); if !valid { return Err(Error::Operation); } @@ -301,22 +290,15 @@ impl GPUBufferMethods for GPUBuffer { 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 _, + (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(self.mapping.clone()) as _, + Rc::into_raw(m_info.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))); + + m_info.mapped_ranges.push(offset..m_end); + m_info.js_buffers.push(Heap::boxed(array_buffer)); Ok(NonNull::new(array_buffer).unwrap()) } @@ -337,7 +319,13 @@ impl AsyncWGPUListener for GPUBuffer { fn handle_response(&self, response: WebGPUResponse, promise: &Rc) { match response { WebGPUResponse::BufferMapAsync(bytes) => { - *self.mapping.borrow_mut() = Some(bytes); + *self + .map_info + .borrow_mut() + .as_mut() + .unwrap() + .mapping + .borrow_mut() = bytes; promise.resolve_native(&()); self.state.set(GPUBufferState::Mapped); }, diff --git a/components/script/dom/gpudevice.rs b/components/script/dom/gpudevice.rs index fba76b2d40f..d5250f1230f 100644 --- a/components/script/dom/gpudevice.rs +++ b/components/script/dom/gpudevice.rs @@ -4,7 +4,7 @@ #![allow(unsafe_code)] -use crate::dom::bindings::cell::{DomRefCell, RefCell}; +use crate::dom::bindings::cell::DomRefCell; use crate::dom::bindings::codegen::Bindings::GPUBindGroupBinding::{ GPUBindGroupDescriptor, GPUBindingResource, }; @@ -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,6 +54,7 @@ use crate::script_runtime::JSContext as SafeJSContext; use arrayvec::ArrayVec; use dom_struct::dom_struct; use js::jsapi::{Heap, JSObject}; +use std::cell::RefCell; use std::ptr::NonNull; use std::rc::Rc; use webgpu::wgpu::binding_model::BufferBinding; @@ -177,18 +178,21 @@ impl GPUDeviceMethods for GPUDevice { .expect("Failed to create WebGPU buffer"); let buffer = webgpu::WebGPUBuffer(id); - let mapping; + let map_info; let state; - let mapping_range; if descriptor.mappedAtCreation { let buf_data = vec![0u8; descriptor.size as usize]; - mapping = Rc::new(RefCell::new(Some(buf_data))); + 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 { - mapping = Rc::new(RefCell::new(None)); + map_info = DomRefCell::new(None); state = GPUBufferState::Unmapped; - mapping_range = 0..0; } GPUBuffer::new( @@ -199,8 +203,7 @@ impl GPUDeviceMethods for GPUDevice { state, descriptor.size, true, - mapping, - mapping_range, + map_info, ) }