Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-23 07:13:52 +01:00
Code Issues Projects Releases Packages Wiki Activity

Error handling for promise returning operations

Browse source
This commit is contained in:
Kunal Mohan 2020-08-02 12:45:22 +05:30
parent 8cb5fad828
commit cd8d9162e6
5 changed files with 93 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

25
components/script/dom/gpu.rs
View file

@ -41,7 +41,7 @@ impl GPU {
} }
pub trait AsyncWGPUListener { pub trait AsyncWGPUListener {
fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>); fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc<Promise>);
} }
struct WGPUResponse<T: AsyncWGPUListener + DomObject> { struct WGPUResponse<T: AsyncWGPUListener + DomObject> {
@ -53,13 +53,7 @@ impl<T: AsyncWGPUListener + DomObject> WGPUResponse<T> {
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
fn response(self, response: WebGPUResponseResult) { fn response(self, response: WebGPUResponseResult) {
let promise = self.trusted.root(); let promise = self.trusted.root();
match response { self.receiver.root().handle_response(response, &promise);
Ok(response) => self.receiver.root().handle_response(response, &promise),
Err(error) => promise.reject_error(Error::Type(format!(
"Received error from WebGPU thread: {}",
error
))),
}
} }
} }
@ -134,13 +128,13 @@ impl GPUMethods for GPU {
} }
impl AsyncWGPUListener for GPU { impl AsyncWGPUListener for GPU {
fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>) { fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc<Promise>) {
match response { match response {
WebGPUResponse::RequestAdapter { Ok(WebGPUResponse::RequestAdapter {
adapter_name, adapter_name,
adapter_id, adapter_id,
channel, channel,
} => { }) => {
let adapter = GPUAdapter::new( let adapter = GPUAdapter::new(
&self.global(), &self.global(),
channel, channel,
@ -150,7 +144,14 @@ impl AsyncWGPUListener for GPU {
); );
promise.resolve_native(&adapter); promise.resolve_native(&adapter);
}, },
_ => promise.reject_error(Error::Operation), Err(e) => {
warn!("Could not get GPUAdapter ({:?})", e);
promise.resolve_native(&None::<GPUAdapter>);
},
_ => {
warn!("GPU received wrong WebGPUResponse");
promise.reject_error(Error::Operation);
},
} }
} }
} }

17
components/script/dom/gpuadapter.rs
View file

@ -20,7 +20,7 @@ use dom_struct::dom_struct;
use js::jsapi::{Heap, JSObject}; use js::jsapi::{Heap, JSObject};
use std::ptr::NonNull; use std::ptr::NonNull;
use std::rc::Rc; use std::rc::Rc;
use webgpu::{wgt, WebGPU, WebGPUAdapter, WebGPURequest, WebGPUResponse}; use webgpu::{wgt, WebGPU, WebGPUAdapter, WebGPURequest, WebGPUResponse, WebGPUResponseResult};
#[dom_struct] #[dom_struct]
pub struct GPUAdapter { pub struct GPUAdapter {
@ -114,14 +114,14 @@ impl GPUAdapterMethods for GPUAdapter {
} }
impl AsyncWGPUListener for GPUAdapter { impl AsyncWGPUListener for GPUAdapter {
fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>) { fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc<Promise>) {
match response { match response {
WebGPUResponse::RequestDevice { Ok(WebGPUResponse::RequestDevice {
device_id, device_id,
queue_id, queue_id,
_descriptor, _descriptor,
label, label,
} => { }) => {
let device = GPUDevice::new( let device = GPUDevice::new(
&self.global(), &self.global(),
self.channel.clone(), self.channel.clone(),
@ -135,7 +135,14 @@ impl AsyncWGPUListener for GPUAdapter {
self.global().add_gpu_device(&device); self.global().add_gpu_device(&device);
promise.resolve_native(&device); promise.resolve_native(&device);
}, },
_ => promise.reject_error(Error::Operation), Err(e) => {
warn!("Could not get GPUDevice({:?})", e);
promise.reject_error(Error::Operation);
},
_ => {
warn!("GPUAdapter received wrong WebGPUResponse");
promise.reject_error(Error::Operation);
},
} }
} }
} }

56
components/script/dom/gpubuffer.rs
View file

@ -26,7 +26,10 @@ use std::ffi::c_void;
use std::ops::Range; use std::ops::Range;
use std::ptr::NonNull; use std::ptr::NonNull;
use std::rc::Rc; use std::rc::Rc;
use webgpu::{wgpu::device::HostMap, WebGPU, WebGPUBuffer, WebGPURequest, WebGPUResponse}; use webgpu::{
wgpu::device::HostMap, WebGPU, WebGPUBuffer, WebGPURequest, WebGPUResponse,
WebGPUResponseResult,
};
const RANGE_OFFSET_ALIGN_MASK: u64 = 8; const RANGE_OFFSET_ALIGN_MASK: u64 = 8;
const RANGE_SIZE_ALIGN_MASK: u64 = 4; const RANGE_SIZE_ALIGN_MASK: u64 = 4;
@ -197,19 +200,21 @@ impl GPUBufferMethods for GPUBuffer {
&self, &self,
mode: u32, mode: u32,
offset: GPUSize64, offset: GPUSize64,
size: GPUSize64, size: Option<GPUSize64>,
comp: InRealm, comp: InRealm,
) -> Rc<Promise> { ) -> 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 { if self.state.get() != GPUBufferState::Unmapped {
offset..self.size promise.reject_error(Error::Abort);
return promise;
}
let range_size = if let Some(s) = size {
s
} else if offset >= self.size {
promise.reject_error(Error::Operation);
return promise;
} else { } else {
if offset + size > self.size { self.size - offset
warn!("Requested mapping size is greated than buffer size");
promise.reject_error(Error::Abort);
return promise;
}
offset..offset + size
}; };
let host_map = match mode { let host_map = match mode {
GPUMapModeConstants::READ => HostMap::Read, GPUMapModeConstants::READ => HostMap::Read,
@ -219,10 +224,8 @@ impl GPUBufferMethods for GPUBuffer {
return promise; return promise;
}, },
}; };
if self.state.get() != GPUBufferState::Unmapped {
promise.reject_error(Error::Abort); let map_range = offset..offset + range_size;
return promise;
}
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 {
@ -257,9 +260,16 @@ impl GPUBufferMethods for GPUBuffer {
&self, &self,
cx: JSContext, cx: JSContext,
offset: GPUSize64, offset: GPUSize64,
size: GPUSize64, size: Option<GPUSize64>,
) -> Fallible<NonNull<JSObject>> { ) -> Fallible<NonNull<JSObject>> {
let m_end = if size == 0 { self.size } else { offset + size }; let range_size = if let Some(s) = size {
s
} else if offset >= self.size {
return Err(Error::Operation);
} else {
self.size - offset
};
let m_end = offset + range_size;
let mut info = self.map_info.borrow_mut(); let mut info = self.map_info.borrow_mut();
let m_info = info.as_mut().unwrap(); let m_info = info.as_mut().unwrap();
@ -268,7 +278,7 @@ impl GPUBufferMethods for GPUBuffer {
_ => false, _ => false,
}; };
valid &= offset % RANGE_OFFSET_ALIGN_MASK == 0 && valid &= offset % RANGE_OFFSET_ALIGN_MASK == 0 &&
(m_end - offset) % RANGE_SIZE_ALIGN_MASK == 0 && range_size % RANGE_SIZE_ALIGN_MASK == 0 &&
offset >= m_info.mapping_range.start && offset >= m_info.mapping_range.start &&
m_end <= m_info.mapping_range.end; m_end <= m_info.mapping_range.end;
valid &= m_info valid &= m_info
@ -286,7 +296,7 @@ impl GPUBufferMethods for GPUBuffer {
let array_buffer = unsafe { let array_buffer = unsafe {
NewExternalArrayBuffer( NewExternalArrayBuffer(
*cx, *cx,
(m_end - offset) as usize, range_size as usize,
m_info.mapping.borrow_mut()[offset as usize..m_end as usize].as_mut_ptr() as _, m_info.mapping.borrow_mut()[offset as usize..m_end as usize].as_mut_ptr() as _,
Some(free_func), Some(free_func),
Rc::into_raw(m_info.mapping.clone()) as _, Rc::into_raw(m_info.mapping.clone()) as _,
@ -312,9 +322,9 @@ impl GPUBufferMethods for GPUBuffer {
impl AsyncWGPUListener for GPUBuffer { impl AsyncWGPUListener for GPUBuffer {
#[allow(unsafe_code)] #[allow(unsafe_code)]
fn handle_response(&self, response: WebGPUResponse, promise: &Rc<Promise>) { fn handle_response(&self, response: WebGPUResponseResult, promise: &Rc<Promise>) {
match response { match response {
WebGPUResponse::BufferMapAsync(bytes) => { Ok(WebGPUResponse::BufferMapAsync(bytes)) => {
*self *self
.map_info .map_info
.borrow_mut() .borrow_mut()
@ -325,8 +335,12 @@ impl AsyncWGPUListener for GPUBuffer {
promise.resolve_native(&()); promise.resolve_native(&());
self.state.set(GPUBufferState::Mapped); self.state.set(GPUBufferState::Mapped);
}, },
Err(e) => {
warn!("Could not map buffer({:?})", e);
promise.reject_error(Error::Abort);
},
_ => { _ => {
warn!("Wrong WebGPUResponse received"); warn!("GPUBuffer received wrong WebGPUResponse");
promise.reject_error(Error::Operation); promise.reject_error(Error::Operation);
}, },
} }

4
components/script/dom/webidls/GPUBuffer.webidl
View file

@ -5,8 +5,8 @@
// https://gpuweb.github.io/gpuweb/#gpubuffer // https://gpuweb.github.io/gpuweb/#gpubuffer
[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);
[Throws] ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size = 0); [Throws] ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size);
void unmap(); void unmap();
void destroy(); void destroy();

46
components/webgpu/lib.rs
View file

@ -412,7 +412,7 @@ impl<'a> WGPU<'a> {
} => { } => {
let map_info = BufferMapInfo { let map_info = BufferMapInfo {
buffer_id, buffer_id,
sender, sender: sender.clone(),
global: &self.global, global: &self.global,
size: (map_range.end - map_range.start) as usize, size: (map_range.end - map_range.start) as usize,
external_id: None, external_id: None,
@ -426,22 +426,24 @@ impl<'a> WGPU<'a> {
let info = Rc::from_raw( let info = Rc::from_raw(
userdata as *const BufferMapInfo<WebGPUResponseResult>, userdata as *const BufferMapInfo<WebGPUResponseResult>,
); );
match status { let msg = match status {
BufferMapAsyncStatus::Success => { BufferMapAsyncStatus::Success => {
let global = &info.global; let global = &info.global;
let data_pt = gfx_select!(info.buffer_id => let data_pt = gfx_select!(info.buffer_id =>
global.buffer_get_mapped_range(info.buffer_id, 0, None)) global.buffer_get_mapped_range(info.buffer_id, 0, None))
.unwrap(); .unwrap();
let data = slice::from_raw_parts(data_pt, info.size); let data = slice::from_raw_parts(data_pt, info.size);
if let Err(e) = Ok(WebGPUResponse::BufferMapAsync(IpcSharedMemory::from_bytes(
info.sender.send(Ok(WebGPUResponse::BufferMapAsync( data,
IpcSharedMemory::from_bytes(data), )))
)))
{
warn!("Could not send BufferMapAsync Response ({})", e);
}
}, },
_ => error!("Could not map buffer({:?})", info.buffer_id), _ => {
warn!("Could not map buffer({:?})", info.buffer_id);
Err(String::from("Failed to map Buffer"))
},
};
if let Err(e) = info.sender.send(msg) {
warn!("Could not send BufferMapAsync Response ({})", e);
} }
} }
@ -453,7 +455,12 @@ impl<'a> WGPU<'a> {
), ),
}; };
let global = &self.global; let global = &self.global;
let _ = gfx_select!(buffer_id => global.buffer_map_async(buffer_id, map_range, operation)); let result = gfx_select!(buffer_id => global.buffer_map_async(buffer_id, map_range, operation));
if let Err(e) = result {
if let Err(w) = sender.send(Err(format!("{:?}", e))) {
warn!("Failed to send BufferMapAsync Response ({:?})", w);
}
}
}, },
WebGPURequest::BufferMapComplete(buffer_id) => { WebGPURequest::BufferMapComplete(buffer_id) => {
self.buffer_maps.remove(&buffer_id); self.buffer_maps.remove(&buffer_id);
@ -892,14 +899,23 @@ impl<'a> WGPU<'a> {
label, label,
} => { } => {
let global = &self.global; let global = &self.global;
let result = gfx_select!(device_id => global.adapter_request_device( let id = match gfx_select!(device_id => global.adapter_request_device(
adapter_id.0, adapter_id.0,
&descriptor, &descriptor,
None, None,
device_id device_id
)); )) {
// TODO: Handle error gracefully acc. to spec. Ok(id) => id,
let id = result.unwrap(); Err(e) => {
if let Err(w) = sender.send(Err(format!("{:?}", e))) {
warn!(
"Failed to send response to WebGPURequest::RequestDevice ({})",
w
)
}
return;
},
};
let device = WebGPUDevice(id); let device = WebGPUDevice(id);
// Note: (zakorgy) Note sure if sending the queue is needed at all, // Note: (zakorgy) Note sure if sending the queue is needed at all,
// since wgpu-core uses the same id for the device and the queue // since wgpu-core uses the same id for the device and the queue