Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(rendering): log uncaptured wgpu errors instead of panicking (#3149)

Richie McIlroy9e64986929f7
diff --git a/Cargo.lock b/Cargo.lock
index 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.rs
index 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, wgp
tracing::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.rs
index 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.toml
index 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.rs
index 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.rs
new file mode 100644
index 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}"
+ );
+}