Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
fix(rendering): log uncaptured wgpu errors instead of panicking (#3149)
Richie McIlroy9e64986929f7
diff --git a/Cargo.lock b/Cargo.lockindex 5edf1df15..92f63bd7c 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2051,6 +2051,7 @@ dependencies = ["tiny-skia","tokio","tracing",+ "tracing-subscriber","wgpu","wgpu-core","wgpu-hal",diff --git a/apps/desktop-gpui/src/camera_blur.rs b/apps/desktop-gpui/src/camera_blur.rsindex d9a478c63..1223d234a 100644--- a/apps/desktop-gpui/src/camera_blur.rs+++ b/apps/desktop-gpui/src/camera_blur.rs@@ -209,6 +209,7 @@ fn shared_device(runtime: &tokio::runtime::Runtime) -> Option<(wgpu::Device, wgptracing::warn!("camera blur device unavailable: {error}");}).ok()?;+ cap_rendering::log_uncaptured_errors(&device, "camera-preview-blur");Some((device, queue))})})diff --git a/apps/desktop-gpui/src/camera_blur_portable.rs b/apps/desktop-gpui/src/camera_blur_portable.rsindex d8e2ca620..f5080c215 100644--- a/apps/desktop-gpui/src/camera_blur_portable.rs+++ b/apps/desktop-gpui/src/camera_blur_portable.rs@@ -106,6 +106,7 @@ impl PortableCameraBlur {}).await.map_err(|error| anyhow!("camera blur device: {error}"))?;+ cap_rendering::log_uncaptured_errors(&device, "camera-preview-blur");anyhow::Ok((format, device, queue))})?;device.push_error_scope(wgpu::ErrorFilter::Validation);diff --git a/crates/rendering/Cargo.toml b/crates/rendering/Cargo.tomlindex 90557746a..de9690088 100644--- a/crates/rendering/Cargo.toml+++ b/crates/rendering/Cargo.toml@@ -75,6 +75,7 @@ cap-verify-expect = { path = "../verify-expect" }tempfile = "3"pollster = "0.4.0"pretty_assertions = "1.4.1"+tracing-subscriber = "0.3.19"[build-dependencies]build-time = "0.1"diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rsindex c1301660c..56a1020e3 100644--- a/crates/rendering/src/lib.rs+++ b/crates/rendering/src/lib.rs@@ -2674,6 +2674,7 @@ pub async fn create_shared_device() -> Result<SharedWgpuDevice, RenderingError>let device_phase = readiness::Phase::start("wgpu.device");let (device, queue) = adapter.request_device(&device_descriptor).await?;device_phase.finish("returned");+ log_uncaptured_errors(&device, "cap-rendering-device");Ok(SharedWgpuDevice {instance,adapter,@@ -2683,6 +2684,33 @@ pub async fn create_shared_device() -> Result<SharedWgpuDevice, RenderingError>})}+/// wgpu panics on an error nothing captured. After a device is lost (a driver+/// reset, sleep, a GPU switch) every call on it fails validation, so that+/// default ended the app at the next frame or export. Log those errors+/// instead, at most a few per second; the operation that hit them fails on+/// its own (a readback that cannot map, a frame that never presents) and the+/// next device request gets a new device.+pub fn log_uncaptured_errors(device: &wgpu::Device, label: &'static str) {+ use std::sync::{+ Mutex,+ atomic::{AtomicU64, Ordering},+ };+ const MIN_INTERVAL: std::time::Duration = std::time::Duration::from_millis(500);+ let last = Mutex::new(None::<std::time::Instant>);+ let suppressed = AtomicU64::new(0);+ device.on_uncaptured_error(Box::new(move |error| {+ let now = std::time::Instant::now();+ let mut last = last.lock().unwrap_or_else(|error| error.into_inner());+ if last.is_some_and(|last| now.duration_since(last) < MIN_INTERVAL) {+ suppressed.fetch_add(1, Ordering::Relaxed);+ return;+ }+ *last = Some(now);+ let suppressed = suppressed.swap(0, Ordering::Relaxed);+ tracing::error!(device = label, suppressed, %error, "uncaptured wgpu error");+ }));+}+#[derive(Clone, Debug)]pub struct SharedWgpuDevice {pub instance: wgpu::Instance,diff --git a/crates/rendering/tests/uncaptured_wgpu_errors.rs b/crates/rendering/tests/uncaptured_wgpu_errors.rsnew file mode 100644index 000000000..64884da58--- /dev/null+++ b/crates/rendering/tests/uncaptured_wgpu_errors.rs@@ -0,0 +1,82 @@+//! An error no scope captured must not end the process. 0.6.0 editors died+//! with `wgpu error: Validation Error ... Parent device is lost` because+//! wgpu's default handler panics.++fn device() -> Option<wgpu::Device> {+ let instance = cap_rendering::create_wgpu_instance_sync();+ let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {+ force_fallback_adapter: cap_rendering::force_software_wgpu_adapter(),+ ..Default::default()+ }))+ .ok()?;+ let (device, _queue) =+ pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).ok()?;+ Some(device)+}++fn texture(device: &wgpu::Device) -> wgpu::Texture {+ device.create_texture(&wgpu::TextureDescriptor {+ label: Some("Frame Composite texture"),+ size: wgpu::Extent3d {+ width: 64,+ height: 64,+ depth_or_array_layers: 1,+ },+ mip_level_count: 1,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::Rgba8Unorm,+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,+ view_formats: &[],+ })+}++#[derive(Clone, Default)]+struct Logs(std::sync::Arc<std::sync::Mutex<Vec<u8>>>);++impl std::io::Write for Logs {+ fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {+ self.0.lock().unwrap().extend_from_slice(bytes);+ Ok(bytes.len())+ }++ fn flush(&mut self) -> std::io::Result<()> {+ Ok(())+ }+}++#[test]+fn validation_errors_on_a_lost_device_are_logged_not_fatal() {+ let Some(device) = device() else {+ eprintln!("no wgpu adapter; skipping");+ return;+ };+ let logs = Logs::default();+ let writer = logs.clone();+ let _subscriber = tracing::subscriber::set_default(+ tracing_subscriber::fmt()+ .with_ansi(false)+ .with_writer(move || writer.clone())+ .finish(),+ );+ cap_rendering::log_uncaptured_errors(&device, "test-device");++ let _invalid = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("read and write mapped"),+ size: 4,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::MAP_WRITE,+ mapped_at_creation: false,+ });++ device.destroy();+ for _ in 0..3 {+ let _ = texture(&device);+ }+ let _ = device.poll(wgpu::PollType::Wait);++ let logs = String::from_utf8(logs.0.lock().unwrap().clone()).unwrap();+ assert!(+ logs.contains("uncaptured wgpu error") && logs.contains("device=\"test-device\""),+ "{logs}"+ );+}