/* This Source Code Form is subject to the terms of the Mozilla Public * 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 log::{error, warn}; use wgpu::gfx_select; pub use {wgpu_core as wgpu, wgpu_types as wgt}; pub mod identity; use std::borrow::Cow; use std::cell::RefCell; use std::collections::HashMap; use std::num::NonZeroU64; use std::rc::Rc; use std::slice; use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; use arrayvec::ArrayVec; use euclid::default::Size2D; use identity::{IdentityRecyclerFactory, WebGPUMsg, WebGPUOpResult}; use ipc_channel::ipc::{self, IpcReceiver, IpcSender, IpcSharedMemory}; use malloc_size_of::{MallocSizeOf, MallocSizeOfOps}; use msg::constellation_msg::PipelineId; use serde::{Deserialize, Serialize}; use servo_config::pref; use smallvec::SmallVec; use webrender_api::{ DirtyRect, DocumentId, ExternalImageId, ImageData, ImageDescriptor, ImageKey, RenderApi, RenderApiSender, Transaction, }; use webrender_traits::{ WebrenderExternalImageApi, WebrenderExternalImageRegistry, WebrenderImageHandlerType, WebrenderImageSource, }; use wgpu::binding_model::{ BindGroupDescriptor, BindGroupLayoutDescriptor, PipelineLayoutDescriptor, }; use wgpu::command::{ ComputePass, ImageCopyBuffer, ImageCopyTexture, RenderBundleDescriptor, RenderBundleEncoder, RenderPass, }; use wgpu::device::{DeviceDescriptor, HostMap, ImplicitPipelineIds}; use wgpu::id; use wgpu::instance::RequestAdapterOptions; use wgpu::pipeline::{ComputePipelineDescriptor, RenderPipelineDescriptor, ShaderModuleDescriptor}; use wgpu::resource::{ BufferDescriptor, BufferMapAsyncStatus, BufferMapCallback, BufferMapCallbackC, BufferMapOperation, SamplerDescriptor, TextureDescriptor, TextureViewDescriptor, }; use wgt::{Dx12Compiler, InstanceDescriptor}; pub type ErrorScopeId = NonZeroU64; const DEVICE_POLL_INTERVAL: u64 = 100; pub const PRESENTATION_BUFFER_COUNT: usize = 10; #[derive(Debug, Deserialize, Serialize)] pub enum WebGPUResponse { RequestAdapter { adapter_info: wgt::AdapterInfo, adapter_id: WebGPUAdapter, limits: wgt::Limits, channel: WebGPU, }, RequestDevice { device_id: WebGPUDevice, queue_id: WebGPUQueue, descriptor: wgt::DeviceDescriptor>, }, BufferMapAsync(IpcSharedMemory), } pub type WebGPUResponseResult = Result; #[derive(Debug, Deserialize, Serialize)] pub enum WebGPURequest { BufferMapAsync { sender: IpcSender, buffer_id: id::BufferId, device_id: id::DeviceId, host_map: HostMap, map_range: std::ops::Range, }, BufferMapComplete(id::BufferId), CommandEncoderFinish { command_encoder_id: id::CommandEncoderId, device_id: id::DeviceId, is_error: bool, // TODO(zakorgy): Serialize CommandBufferDescriptor in wgpu-core // wgpu::command::CommandBufferDescriptor, }, CopyBufferToBuffer { command_encoder_id: id::CommandEncoderId, source_id: id::BufferId, source_offset: wgt::BufferAddress, destination_id: id::BufferId, destination_offset: wgt::BufferAddress, size: wgt::BufferAddress, }, CopyBufferToTexture { command_encoder_id: id::CommandEncoderId, source: ImageCopyBuffer, destination: ImageCopyTexture, copy_size: wgt::Extent3d, }, CopyTextureToBuffer { command_encoder_id: id::CommandEncoderId, source: ImageCopyTexture, destination: ImageCopyBuffer, copy_size: wgt::Extent3d, }, CopyTextureToTexture { command_encoder_id: id::CommandEncoderId, source: ImageCopyTexture, destination: ImageCopyTexture, copy_size: wgt::Extent3d, }, CreateBindGroup { device_id: id::DeviceId, bind_group_id: id::BindGroupId, descriptor: BindGroupDescriptor<'static>, }, CreateBindGroupLayout { device_id: id::DeviceId, bind_group_layout_id: id::BindGroupLayoutId, descriptor: Option>, }, CreateBuffer { device_id: id::DeviceId, buffer_id: id::BufferId, descriptor: Option>, }, CreateCommandEncoder { device_id: id::DeviceId, // TODO(zakorgy): Serialize CommandEncoderDescriptor in wgpu-core // wgpu::command::CommandEncoderDescriptor, command_encoder_id: id::CommandEncoderId, label: Option>, }, CreateComputePipeline { device_id: id::DeviceId, compute_pipeline_id: id::ComputePipelineId, descriptor: ComputePipelineDescriptor<'static>, implicit_ids: Option<(id::PipelineLayoutId, Vec)>, }, CreateContext(IpcSender), CreatePipelineLayout { device_id: id::DeviceId, pipeline_layout_id: id::PipelineLayoutId, descriptor: PipelineLayoutDescriptor<'static>, }, CreateRenderPipeline { device_id: id::DeviceId, render_pipeline_id: id::RenderPipelineId, descriptor: Option>, implicit_ids: Option<(id::PipelineLayoutId, Vec)>, }, CreateSampler { device_id: id::DeviceId, sampler_id: id::SamplerId, descriptor: SamplerDescriptor<'static>, }, CreateShaderModule { device_id: id::DeviceId, program_id: id::ShaderModuleId, program: String, label: Option, }, CreateSwapChain { device_id: id::DeviceId, buffer_ids: ArrayVec, external_id: u64, sender: IpcSender, image_desc: ImageDescriptor, image_data: ImageData, }, CreateTexture { device_id: id::DeviceId, texture_id: id::TextureId, descriptor: Option>, }, CreateTextureView { texture_id: id::TextureId, texture_view_id: id::TextureViewId, device_id: id::DeviceId, descriptor: Option>, }, DestroyBuffer(id::BufferId), DestroyDevice(id::DeviceId), DestroySwapChain { external_id: u64, image_key: ImageKey, }, DestroyTexture(id::TextureId), Exit(IpcSender<()>), FreeCommandBuffer(id::CommandBufferId), FreeDevice(id::DeviceId), RenderBundleEncoderFinish { render_bundle_encoder: RenderBundleEncoder, descriptor: RenderBundleDescriptor<'static>, render_bundle_id: id::RenderBundleId, device_id: id::DeviceId, }, RequestAdapter { sender: IpcSender, options: RequestAdapterOptions, ids: SmallVec<[id::AdapterId; 4]>, }, RequestDevice { sender: IpcSender, adapter_id: WebGPUAdapter, descriptor: wgt::DeviceDescriptor>, device_id: id::DeviceId, pipeline_id: PipelineId, }, RunComputePass { command_encoder_id: id::CommandEncoderId, compute_pass: Option, }, RunRenderPass { command_encoder_id: id::CommandEncoderId, render_pass: Option, }, Submit { queue_id: id::QueueId, command_buffers: Vec, }, SwapChainPresent { external_id: u64, texture_id: id::TextureId, encoder_id: id::CommandEncoderId, }, UnmapBuffer { buffer_id: id::BufferId, device_id: id::DeviceId, array_buffer: IpcSharedMemory, is_map_read: bool, offset: u64, size: u64, }, UpdateWebRenderData { buffer_id: id::BufferId, external_id: u64, buffer_size: usize, }, WriteBuffer { queue_id: id::QueueId, buffer_id: id::BufferId, buffer_offset: u64, data: IpcSharedMemory, }, WriteTexture { queue_id: id::QueueId, texture_cv: ImageCopyTexture, data_layout: wgt::ImageDataLayout, size: wgt::Extent3d, data: IpcSharedMemory, }, } struct BufferMapInfo<'a, T> { buffer_id: id::BufferId, sender: IpcSender, global: &'a wgpu::global::Global, size: usize, external_id: Option, } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct WebGPU(pub IpcSender<(Option, WebGPURequest)>); impl WebGPU { pub fn new( webrender_api_sender: RenderApiSender, webrender_document: DocumentId, external_images: Arc>, wgpu_image_map: Arc>>, ) -> Option<(Self, IpcReceiver)> { if !pref!(dom.webgpu.enabled) { return None; } let (sender, receiver) = match ipc::channel() { Ok(sender_and_receiver) => sender_and_receiver, Err(e) => { warn!( "Failed to create sender and receiver for WGPU thread ({})", e ); return None; }, }; let sender_clone = sender.clone(); let (script_sender, script_recv) = match ipc::channel() { Ok(sender_and_receiver) => sender_and_receiver, Err(e) => { warn!( "Failed to create receiver and sender for WGPU thread ({})", e ); return None; }, }; if let Err(e) = std::thread::Builder::new() .name("WGPU".to_owned()) .spawn(move || { WGPU::new( receiver, sender_clone, script_sender, webrender_api_sender, webrender_document, external_images, wgpu_image_map, ) .run(); }) { warn!("Failed to spwan WGPU thread ({})", e); return None; } Some((WebGPU(sender), script_recv)) } pub fn exit(&self, sender: IpcSender<()>) -> Result<(), &'static str> { self.0 .send((None, WebGPURequest::Exit(sender))) .map_err(|_| "Failed to send Exit message") } } struct WGPU<'a> { receiver: IpcReceiver<(Option, WebGPURequest)>, sender: IpcSender<(Option, WebGPURequest)>, script_sender: IpcSender, global: wgpu::global::Global, adapters: Vec, devices: HashMap, // Track invalid adapters https://gpuweb.github.io/gpuweb/#invalid _invalid_adapters: Vec, // Buffers with pending mapping buffer_maps: HashMap>>, // Presentation Buffers with pending mapping present_buffer_maps: HashMap, WebGPURequest)>>>, //TODO: Remove this (https://github.com/gfx-rs/wgpu/issues/867) error_command_encoders: RefCell>, webrender_api: RenderApi, webrender_document: DocumentId, external_images: Arc>, wgpu_image_map: Arc>>, last_poll: Instant, } impl<'a> WGPU<'a> { fn new( receiver: IpcReceiver<(Option, WebGPURequest)>, sender: IpcSender<(Option, WebGPURequest)>, script_sender: IpcSender, webrender_api_sender: RenderApiSender, webrender_document: DocumentId, external_images: Arc>, wgpu_image_map: Arc>>, ) -> Self { let factory = IdentityRecyclerFactory { sender: script_sender.clone(), self_sender: sender.clone(), }; WGPU { receiver, sender, script_sender, global: wgpu::global::Global::new( "wgpu-core", factory, InstanceDescriptor { backends: wgt::Backends::PRIMARY, dx12_shader_compiler: Dx12Compiler::default(), }, ), adapters: Vec::new(), devices: HashMap::new(), _invalid_adapters: Vec::new(), buffer_maps: HashMap::new(), present_buffer_maps: HashMap::new(), error_command_encoders: RefCell::new(HashMap::new()), webrender_api: webrender_api_sender.create_api(), webrender_document, external_images, wgpu_image_map, last_poll: Instant::now(), } } fn run(&'a mut self) { loop { if self.last_poll.elapsed() >= Duration::from_millis(DEVICE_POLL_INTERVAL) { let _ = self.global.poll_all_devices(false); self.last_poll = Instant::now(); } if let Ok((scope_id, msg)) = self.receiver.try_recv() { match msg { WebGPURequest::BufferMapAsync { sender, buffer_id, device_id, host_map, map_range, } => { let map_info = BufferMapInfo { buffer_id, sender: sender.clone(), global: &self.global, size: (map_range.end - map_range.start) as usize, external_id: None, }; self.buffer_maps.insert(buffer_id, Rc::new(map_info)); // TODO(sagudev): replace with safe callback unsafe extern "C" fn callback( status: BufferMapAsyncStatus, userdata: *mut u8, ) { let info = Rc::from_raw( userdata as *const BufferMapInfo, ); let msg = match status { BufferMapAsyncStatus::Success => { let global = &info.global; let (slice_pointer, range_size) = gfx_select!(info.buffer_id => global.buffer_get_mapped_range(info.buffer_id, 0, None)) .unwrap(); let data = slice::from_raw_parts(slice_pointer, range_size as usize); Ok(WebGPUResponse::BufferMapAsync(IpcSharedMemory::from_bytes( data, ))) }, _ => { 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); } } let operation = BufferMapOperation { host: host_map, callback: unsafe { BufferMapCallback::from_c(BufferMapCallbackC { callback, user_data: convert_to_pointer( self.buffer_maps.get(&buffer_id).unwrap().clone(), ), }) }, }; let global = &self.global; let result = gfx_select!(buffer_id => global.buffer_map_async(buffer_id, map_range, operation)); if let Err(ref e) = result { if let Err(w) = sender.send(Err(format!("{:?}", e))) { warn!("Failed to send BufferMapAsync Response ({:?})", w); } } self.send_result(device_id, scope_id, result); }, WebGPURequest::BufferMapComplete(buffer_id) => { self.buffer_maps.remove(&buffer_id); }, WebGPURequest::CommandEncoderFinish { command_encoder_id, device_id, is_error, } => { let global = &self.global; let result = if is_error { Err(String::from("Invalid GPUCommandEncoder")) } else if let Some(err) = self .error_command_encoders .borrow() .get(&command_encoder_id) { Err(err.clone()) } else { tuple_to_result( gfx_select!(command_encoder_id => global.command_encoder_finish( command_encoder_id, &wgt::CommandBufferDescriptor::default() )), ) .map_err(|e| format!("{:?}", e)) }; self.encoder_record_error(command_encoder_id, &result); self.send_result(device_id, scope_id, result); }, WebGPURequest::CopyBufferToBuffer { command_encoder_id, source_id, source_offset, destination_id, destination_offset, size, } => { let global = &self.global; let result = gfx_select!(command_encoder_id => global.command_encoder_copy_buffer_to_buffer( command_encoder_id, source_id, source_offset, destination_id, destination_offset, size )); self.encoder_record_error(command_encoder_id, &result); }, WebGPURequest::CopyBufferToTexture { command_encoder_id, source, destination, copy_size, } => { let global = &self.global; let result = gfx_select!(command_encoder_id => global.command_encoder_copy_buffer_to_texture( command_encoder_id, &source, &destination, ©_size )); self.encoder_record_error(command_encoder_id, &result); }, WebGPURequest::CopyTextureToBuffer { command_encoder_id, source, destination, copy_size, } => { let global = &self.global; let result = gfx_select!(command_encoder_id => global.command_encoder_copy_texture_to_buffer( command_encoder_id, &source, &destination, ©_size )); self.encoder_record_error(command_encoder_id, &result); }, WebGPURequest::CopyTextureToTexture { command_encoder_id, source, destination, copy_size, } => { let global = &self.global; let result = gfx_select!(command_encoder_id => global.command_encoder_copy_texture_to_texture( command_encoder_id, &source, &destination, ©_size )); self.encoder_record_error(command_encoder_id, &result); }, WebGPURequest::CreateBindGroup { device_id, bind_group_id, descriptor, } => { let global = &self.global; let result = tuple_to_result(gfx_select!(bind_group_id => global.device_create_bind_group(device_id, &descriptor, bind_group_id))); self.send_result(device_id, scope_id, result); }, WebGPURequest::CreateBindGroupLayout { device_id, bind_group_layout_id, descriptor, } => { let global = &self.global; if let Some(desc) = descriptor { let result = tuple_to_result(gfx_select!(bind_group_layout_id => global.device_create_bind_group_layout(device_id, &desc, bind_group_layout_id))); self.send_result(device_id, scope_id, result); } }, WebGPURequest::CreateBuffer { device_id, buffer_id, descriptor, } => { let global = &self.global; if let Some(desc) = descriptor { let result = tuple_to_result(gfx_select!(buffer_id => global.device_create_buffer(device_id, &desc, buffer_id))); self.send_result(device_id, scope_id, result); } }, WebGPURequest::CreateCommandEncoder { device_id, command_encoder_id, label, } => { let global = &self.global; let desc = wgt::CommandEncoderDescriptor { label }; let result = tuple_to_result(gfx_select!(command_encoder_id => global.device_create_command_encoder(device_id, &desc, command_encoder_id))); self.send_result(device_id, scope_id, result); }, WebGPURequest::CreateComputePipeline { device_id, compute_pipeline_id, descriptor, implicit_ids, } => { let global = &self.global; let bgls = implicit_ids .as_ref() .map_or(Vec::with_capacity(0), |(_, bgls)| bgls.clone()); let implicit = implicit_ids .as_ref() .map(|(layout, _)| ImplicitPipelineIds { root_id: *layout, group_ids: bgls.as_slice(), }); let result = tuple_to_result( gfx_select!(compute_pipeline_id => global.device_create_compute_pipeline( device_id, &descriptor, compute_pipeline_id, implicit )), ); self.send_result(device_id, scope_id, result); }, WebGPURequest::CreateContext(sender) => { let id = self .external_images .lock() .expect("Lock poisoned?") .next_id(WebrenderImageHandlerType::WebGPU); if let Err(e) = sender.send(id) { warn!("Failed to send ExternalImageId to new context ({})", e); }; }, WebGPURequest::CreatePipelineLayout { device_id, pipeline_layout_id, descriptor, } => { let global = &self.global; let result = tuple_to_result(gfx_select!(pipeline_layout_id => global.device_create_pipeline_layout(device_id, &descriptor, pipeline_layout_id))); self.send_result(device_id, scope_id, result); }, WebGPURequest::CreateRenderPipeline { device_id, render_pipeline_id, descriptor, implicit_ids, } => { let global = &self.global; let bgls = implicit_ids .as_ref() .map_or(Vec::with_capacity(0), |(_, bgls)| bgls.clone()); let implicit = implicit_ids .as_ref() .map(|(layout, _)| ImplicitPipelineIds { root_id: *layout, group_ids: bgls.as_slice(), }); if let Some(desc) = descriptor { let result = tuple_to_result(gfx_select!(render_pipeline_id => global.device_create_render_pipeline(device_id, &desc, render_pipeline_id, implicit))); self.send_result(device_id, scope_id, result); } }, WebGPURequest::CreateSampler { device_id, sampler_id, descriptor, } => { let global = &self.global; let result = tuple_to_result( gfx_select!(sampler_id => global.device_create_sampler( device_id, &descriptor, sampler_id )), ); self.send_result(device_id, scope_id, result); }, WebGPURequest::CreateShaderModule { device_id, program_id, program, label, } => { let global = &self.global; let source = wgpu_core::pipeline::ShaderModuleSource::Wgsl( crate::Cow::Owned(program), ); let desc = ShaderModuleDescriptor { label: label.map(|s| s.into()), shader_bound_checks: wgt::ShaderBoundChecks::default(), }; let result = tuple_to_result(gfx_select!(program_id => global.device_create_shader_module(device_id, &desc, source, program_id))); self.send_result(device_id, scope_id, result); }, WebGPURequest::CreateSwapChain { device_id, buffer_ids, external_id, sender, image_desc, image_data, } => { let height = image_desc.size.height; let width = image_desc.size.width; let buffer_stride = ((width * 4) as u32 | (wgt::COPY_BYTES_PER_ROW_ALIGNMENT - 1)) + 1; let image_key = self.webrender_api.generate_image_key(); if let Err(e) = sender.send(image_key) { warn!("Failed to send ImageKey ({})", e); } let _ = self.wgpu_image_map.lock().unwrap().insert( external_id, PresentationData { device_id, queue_id: device_id, data: vec![255; (buffer_stride * height as u32) as usize], size: Size2D::new(width, height), unassigned_buffer_ids: buffer_ids, available_buffer_ids: ArrayVec::< id::BufferId, PRESENTATION_BUFFER_COUNT, >::new(), queued_buffer_ids: ArrayVec::< id::BufferId, PRESENTATION_BUFFER_COUNT, >::new(), buffer_stride, image_key, image_desc, image_data: image_data.clone(), }, ); let mut txn = Transaction::new(); txn.add_image(image_key, image_desc, image_data, None); self.webrender_api .send_transaction(self.webrender_document, txn); }, WebGPURequest::CreateTexture { device_id, texture_id, descriptor, } => { let global = &self.global; if let Some(desc) = descriptor { let result = tuple_to_result( gfx_select!(texture_id => global.device_create_texture( device_id, &desc, texture_id )), ); self.send_result(device_id, scope_id, result); } }, WebGPURequest::CreateTextureView { texture_id, texture_view_id, device_id, descriptor, } => { let global = &self.global; if let Some(desc) = descriptor { let result = tuple_to_result( gfx_select!(texture_view_id => global.texture_create_view( texture_id, &desc, texture_view_id )), ); self.send_result(device_id, scope_id, result); } }, WebGPURequest::DestroyBuffer(buffer) => { let global = &self.global; gfx_select!(buffer => global.buffer_drop(buffer, false)); }, WebGPURequest::DestroyDevice(device) => { let global = &self.global; gfx_select!(device => global.device_drop(device)); }, WebGPURequest::DestroySwapChain { external_id, image_key, } => { let data = self .wgpu_image_map .lock() .unwrap() .remove(&external_id) .unwrap(); let global = &self.global; for b_id in data.available_buffer_ids.iter() { gfx_select!(b_id => global.buffer_drop(*b_id, false)); } for b_id in data.queued_buffer_ids.iter() { gfx_select!(b_id => global.buffer_drop(*b_id, false)); } for b_id in data.unassigned_buffer_ids.iter() { if let Err(e) = self.script_sender.send(WebGPUMsg::FreeBuffer(*b_id)) { warn!("Unable to send FreeBuffer({:?}) ({:?})", *b_id, e); }; } let mut txn = Transaction::new(); txn.delete_image(image_key); self.webrender_api .send_transaction(self.webrender_document, txn); }, WebGPURequest::DestroyTexture(texture) => { let global = &self.global; gfx_select!(texture => global.texture_drop(texture, true)); }, WebGPURequest::Exit(sender) => { if let Err(e) = self.script_sender.send(WebGPUMsg::Exit) { warn!("Failed to send WebGPUMsg::Exit to script ({})", e); } if let Err(e) = sender.send(()) { warn!("Failed to send response to WebGPURequest::Exit ({})", e) } return; }, WebGPURequest::FreeCommandBuffer(command_buffer_id) => { self.error_command_encoders .borrow_mut() .remove(&command_buffer_id); }, WebGPURequest::FreeDevice(device_id) => { let device = WebGPUDevice(device_id); let pipeline_id = self.devices.remove(&device).unwrap(); if let Err(e) = self.script_sender.send(WebGPUMsg::CleanDevice { device, pipeline_id, }) { warn!("Unable to send CleanDevice({:?}) ({:?})", device_id, e); } }, WebGPURequest::RenderBundleEncoderFinish { render_bundle_encoder, descriptor, render_bundle_id, device_id, } => { let global = &self.global; let result = tuple_to_result( gfx_select!(render_bundle_id => global.render_bundle_encoder_finish( render_bundle_encoder, &descriptor, render_bundle_id )), ); self.send_result(device_id, scope_id, result); }, WebGPURequest::RequestAdapter { sender, options, ids, } => { let adapter_id = match self.global.request_adapter( &options, wgpu::instance::AdapterInputs::IdSet(&ids, |id| id.backend()), ) { Ok(id) => id, Err(w) => { if let Err(e) = sender.send(Err(format!("{:?}", w))) { warn!( "Failed to send response to WebGPURequest::RequestAdapter ({})", e ) } return; }, }; let adapter = WebGPUAdapter(adapter_id); self.adapters.push(adapter); let global = &self.global; let info = gfx_select!(adapter_id => global.adapter_get_info(adapter_id)).unwrap(); let limits = gfx_select!(adapter_id => global.adapter_limits(adapter_id)).unwrap(); if let Err(e) = sender.send(Ok(WebGPUResponse::RequestAdapter { adapter_info: info, adapter_id: adapter, limits, channel: WebGPU(self.sender.clone()), })) { warn!( "Failed to send response to WebGPURequest::RequestAdapter ({})", e ) } }, WebGPURequest::RequestDevice { sender, adapter_id, descriptor, device_id, pipeline_id, } => { let desc = DeviceDescriptor { label: descriptor.label.as_ref().map(|l| crate::Cow::from(l)), features: descriptor.features.clone(), limits: descriptor.limits.clone(), }; let global = &self.global; let id = match tuple_to_result( gfx_select!(device_id => global.adapter_request_device( adapter_id.0, &desc, None, device_id )), ) { Ok(id) => id, 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); // 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 let queue = WebGPUQueue(id); self.devices.insert(device, pipeline_id); if let Err(e) = sender.send(Ok(WebGPUResponse::RequestDevice { device_id: device, queue_id: queue, descriptor, })) { warn!( "Failed to send response to WebGPURequest::RequestDevice ({})", e ) } }, WebGPURequest::RunComputePass { command_encoder_id, compute_pass, } => { let global = &self.global; let result = if let Some(pass) = compute_pass { gfx_select!(command_encoder_id => global.command_encoder_run_compute_pass( command_encoder_id, &pass )).map_err(|e| format!("{:?}", e)) } else { Err(String::from("Invalid ComputePass")) }; self.encoder_record_error(command_encoder_id, &result); }, WebGPURequest::RunRenderPass { command_encoder_id, render_pass, } => { let global = &self.global; let result = if let Some(pass) = render_pass { gfx_select!(command_encoder_id => global.command_encoder_run_render_pass( command_encoder_id, &pass )).map_err(|e| format!("{:?}", e)) } else { Err(String::from("Invalid RenderPass")) }; self.encoder_record_error(command_encoder_id, &result); }, WebGPURequest::Submit { queue_id, command_buffers, } => { let global = &self.global; let cmd_id = command_buffers .iter() .find(|id| self.error_command_encoders.borrow().contains_key(id)); let result = if cmd_id.is_some() { Err(String::from("Invalid command buffer submitted")) } else { gfx_select!(queue_id => global.queue_submit(queue_id, &command_buffers)) .map_err(|e| format!("{:?}", e)) }; self.send_result(queue_id, scope_id, result); }, WebGPURequest::SwapChainPresent { external_id, texture_id, encoder_id, } => { let global = &self.global; let device_id; let queue_id; let size; let buffer_id; let buffer_stride; { if let Some(present_data) = self.wgpu_image_map.lock().unwrap().get_mut(&external_id) { size = present_data.size; device_id = present_data.device_id; queue_id = present_data.queue_id; buffer_stride = present_data.buffer_stride; buffer_id = if let Some(b_id) = present_data.available_buffer_ids.pop() { b_id } else if let Some(b_id) = present_data.unassigned_buffer_ids.pop() { let buffer_size = (buffer_stride * size.height as u32) as wgt::BufferAddress; let buffer_desc = wgt::BufferDescriptor { label: None, size: buffer_size, usage: wgt::BufferUsages::MAP_READ | wgt::BufferUsages::COPY_DST, mapped_at_creation: false, }; let _ = gfx_select!(b_id => global.device_create_buffer( device_id, &buffer_desc, b_id )); b_id } else { warn!( "No staging buffer available for ExternalImageId({:?})", external_id ); continue; }; present_data.queued_buffer_ids.push(buffer_id); } else { warn!("Data not found for ExternalImageId({:?})", external_id); continue; } } let buffer_size = (size.height as u32 * buffer_stride) as wgt::BufferAddress; let comm_desc = wgt::CommandEncoderDescriptor { label: None }; let _ = gfx_select!(encoder_id => global.device_create_command_encoder( device_id, &comm_desc, encoder_id )); let buffer_cv = ImageCopyBuffer { buffer: buffer_id, layout: wgt::ImageDataLayout { offset: 0, bytes_per_row: Some(buffer_stride), rows_per_image: None, }, }; let texture_cv = ImageCopyTexture { texture: texture_id, mip_level: 0, origin: wgt::Origin3d::ZERO, aspect: wgt::TextureAspect::All, }; let copy_size = wgt::Extent3d { width: size.width as u32, height: size.height as u32, depth_or_array_layers: 1, }; let _ = gfx_select!(encoder_id => global.command_encoder_copy_texture_to_buffer( encoder_id, &texture_cv, &buffer_cv, ©_size )); let _ = gfx_select!(encoder_id => global.command_encoder_finish( encoder_id, &wgt::CommandBufferDescriptor::default() )); let _ = gfx_select!(queue_id => global.queue_submit( queue_id, &[encoder_id] )); let map_info = BufferMapInfo { buffer_id, sender: self.sender.clone(), global: &self.global, size: buffer_size as usize, external_id: Some(external_id), }; self.present_buffer_maps .insert(buffer_id, Rc::new(map_info)); // TODO(sagudev): replace with safe callback unsafe extern "C" fn callback( status: BufferMapAsyncStatus, userdata: *mut u8, ) { let info = Rc::from_raw( userdata as *const BufferMapInfo<(Option, WebGPURequest)>, ); match status { BufferMapAsyncStatus::Success => { if let Err(e) = info.sender.send(( None, WebGPURequest::UpdateWebRenderData { buffer_id: info.buffer_id, buffer_size: info.size, external_id: info.external_id.unwrap(), }, )) { warn!("Could not send UpdateWebRenderData ({})", e); } }, _ => error!("Could not map buffer({:?})", info.buffer_id), } } let map_op = BufferMapOperation { host: HostMap::Read, callback: unsafe { BufferMapCallback::from_c(BufferMapCallbackC { callback, user_data: convert_to_pointer( self.present_buffer_maps.get(&buffer_id).unwrap().clone(), ), }) }, }; let _ = gfx_select!(buffer_id => global.buffer_map_async(buffer_id, 0..buffer_size, map_op)); }, WebGPURequest::UnmapBuffer { buffer_id, device_id, array_buffer, is_map_read, offset, size, } => { let global = &self.global; if !is_map_read { let (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, range_size as usize) } .copy_from_slice(&array_buffer); } let result = gfx_select!(buffer_id => global.buffer_unmap(buffer_id)); self.send_result(device_id, scope_id, result); }, WebGPURequest::UpdateWebRenderData { buffer_id, buffer_size, external_id, } => { let global = &self.global; let (slice_pointer, range_size) = gfx_select!(buffer_id => global.buffer_get_mapped_range(buffer_id, 0, Some(buffer_size as u64))) .unwrap(); let data = unsafe { slice::from_raw_parts(slice_pointer, range_size as usize) } .to_vec(); if let Some(present_data) = self.wgpu_image_map.lock().unwrap().get_mut(&external_id) { present_data.data = data; let mut txn = Transaction::new(); txn.update_image( present_data.image_key, present_data.image_desc, present_data.image_data.clone(), &DirtyRect::All, ); self.webrender_api .send_transaction(self.webrender_document, txn); present_data .queued_buffer_ids .retain(|b_id| *b_id != buffer_id); present_data.available_buffer_ids.push(buffer_id); } else { warn!("Data not found for ExternalImageId({:?})", external_id); } let _ = gfx_select!(buffer_id => global.buffer_unmap(buffer_id)); self.present_buffer_maps.remove(&buffer_id); }, WebGPURequest::WriteBuffer { queue_id, buffer_id, buffer_offset, data, } => { let global = &self.global; //TODO: Report result to content process let result = gfx_select!(queue_id => global.queue_write_buffer( queue_id, buffer_id, buffer_offset as wgt::BufferAddress, &data )); self.send_result(queue_id, scope_id, result); }, WebGPURequest::WriteTexture { queue_id, texture_cv, data_layout, size, data, } => { let global = &self.global; //TODO: Report result to content process let result = gfx_select!(queue_id => global.queue_write_texture( queue_id, &texture_cv, &data, &data_layout, &size )); self.send_result(queue_id, scope_id, result); }, } } } } fn send_result( &self, device_id: id::DeviceId, scope_id: Option, result: Result, ) { let &pipeline_id = self.devices.get(&WebGPUDevice(device_id)).unwrap(); if let Err(w) = self.script_sender.send(WebGPUMsg::WebGPUOpResult { device: WebGPUDevice(device_id), scope_id, pipeline_id, result: if let Err(e) = result { let err = format!("{:?}", e); if err.contains("OutOfMemory") { WebGPUOpResult::OutOfMemoryError } else { WebGPUOpResult::ValidationError(err) } } else { WebGPUOpResult::Success }, }) { warn!("Failed to send WebGPUOpResult ({})", w); } } fn encoder_record_error( &self, encoder_id: id::CommandEncoderId, result: &Result, ) { if let Err(ref e) = result { self.error_command_encoders .borrow_mut() .entry(encoder_id) .or_insert_with(|| format!("{:?}", e)); } } } fn convert_to_pointer(obj: Rc) -> *mut u8 { Rc::into_raw(obj) as *mut u8 } fn tuple_to_result(res: (T, Option)) -> Result { if let Some(err) = res.1 { Err(err) } else { Ok(res.0) } } macro_rules! webgpu_resource { ($name:ident, $id:ty) => { #[derive(Clone, Copy, Debug, Deserialize, Hash, PartialEq, Serialize)] pub struct $name(pub $id); impl MallocSizeOf for $name { fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize { 0 } } impl Eq for $name {} }; } webgpu_resource!(WebGPUAdapter, id::AdapterId); webgpu_resource!(WebGPUBindGroup, id::BindGroupId); webgpu_resource!(WebGPUBindGroupLayout, id::BindGroupLayoutId); webgpu_resource!(WebGPUBuffer, id::BufferId); webgpu_resource!(WebGPUCommandBuffer, id::CommandBufferId); webgpu_resource!(WebGPUCommandEncoder, id::CommandEncoderId); webgpu_resource!(WebGPUComputePipeline, id::ComputePipelineId); webgpu_resource!(WebGPUDevice, id::DeviceId); webgpu_resource!(WebGPUPipelineLayout, id::PipelineLayoutId); webgpu_resource!(WebGPUQueue, id::QueueId); webgpu_resource!(WebGPURenderBundle, id::RenderBundleId); webgpu_resource!(WebGPURenderPipeline, id::RenderPipelineId); webgpu_resource!(WebGPUSampler, id::SamplerId); webgpu_resource!(WebGPUShaderModule, id::ShaderModuleId); webgpu_resource!(WebGPUSurface, id::SurfaceId); webgpu_resource!(WebGPUTexture, id::TextureId); webgpu_resource!(WebGPUTextureView, id::TextureViewId); pub struct WGPUExternalImages { pub images: Arc>>, pub locked_ids: HashMap>, } impl WGPUExternalImages { pub fn new() -> Self { Self { images: Arc::new(Mutex::new(HashMap::new())), locked_ids: HashMap::new(), } } } impl WebrenderExternalImageApi for WGPUExternalImages { fn lock(&mut self, id: u64) -> (WebrenderImageSource, Size2D) { let size; let data; if let Some(present_data) = self.images.lock().unwrap().get(&id) { size = present_data.size; data = present_data.data.clone(); } else { size = Size2D::new(0, 0); data = Vec::new(); } let _ = self.locked_ids.insert(id, data); ( WebrenderImageSource::Raw(self.locked_ids.get(&id).unwrap().as_slice()), size, ) } fn unlock(&mut self, id: u64) { let _ = self.locked_ids.remove(&id); } } pub struct PresentationData { device_id: id::DeviceId, queue_id: id::QueueId, pub data: Vec, pub size: Size2D, unassigned_buffer_ids: ArrayVec, available_buffer_ids: ArrayVec, queued_buffer_ids: ArrayVec, buffer_stride: u32, image_key: ImageKey, image_desc: ImageDescriptor, image_data: ImageData, }