diff --git a/crates/ui-egui/src/surface_errors_tests.rs b/crates/ui-egui/src/surface_errors_tests.rs index 9d3b41f61..8d5ea044d 100644 --- a/crates/ui-egui/src/surface_errors_tests.rs +++ b/crates/ui-egui/src/surface_errors_tests.rs @@ -5,9 +5,14 @@ //! driver's refusal can't be provoked here, so these check the capture on a real device with an //! error the validation always reports, and the retry policy with a stand-in clock and device. //! An error no scope catches at all is reported by the device's handler -//! (`gpu::log_uncaptured_errors`) instead of panicking (#5486). +//! (`gpu::log_uncaptured_errors`) instead of panicking (#5486). A configure that meets a lost +//! device isn't taken as configured, and an acquire wgpu refuses configures the surface again +//! (#7007). -use egui_wgpu::{Attempt, ConfigureRetry, SURFACE_RECREATE_AFTER, capture_errors, wgpu}; +use egui_wgpu::{ + Attempt, ConfigureError, ConfigureRetry, DeviceLost, SURFACE_RECREATE_AFTER, SurfaceErrorAction, WgpuConfiguration, capture_errors, + configure_captured, wgpu, +}; use std::time::Duration; use web_time::Instant; @@ -27,6 +32,57 @@ fn an_error_under_capture_is_returned_not_a_panic() { assert_eq!(buffer.size(), 4); } +/// A driver reset found by a surface configure (D3D12 waits for the present queue after wgpu has +/// dropped the surface's old configuration) reports nothing: wgpu passes device-loss errors to no +/// error scope. The configure was taken, the next acquire met a surface without a configuration, +/// and the device's default handler panicked: "Surface is not configured for presentation" +/// (#7007). `destroy` loses the device as a driver reset does; wgpu calls the lost callback once +/// it has polled. +#[test] +fn a_configure_that_meets_a_lost_device_is_not_taken() { + // The queue is kept: wgpu calls a destroyed device's lost callback only while it has one. + let Some((_, device, _queue)) = crate::gpu::offscreen_device() else { return }; + let lost = DeviceLost::watch(&device); + let bad = wgpu::BufferDescriptor { label: Some("bad"), size: 3, usage: wgpu::BufferUsages::MAP_WRITE, mapped_at_creation: true }; + // On a working device a clean configure is taken and a refused one returns its error. + assert!(configure_captured(&device, &lost, || {}).is_ok()); + let refused = configure_captured(&device, &lost, || { + let _ = device.create_buffer(&bad); + }); + assert!(matches!(refused, Err(ConfigureError::Refused(wgpu::Error::Validation { .. }))), "{refused:?}"); + + // The device is lost during the configure, which goes on and fails quietly. + let met_loss = configure_captured(&device, &lost, || { + device.destroy(); + let _ = device.poll(wgpu::PollType::wait_indefinitely()); + let _ = device.create_buffer(&bad); + }); + assert!(matches!(met_loss, Err(ConfigureError::DeviceLost)), "{met_loss:?}"); + assert!(met_loss.is_err_and(|e| e.to_string() == "the graphics device was lost")); + // Why the scope alone can't tell: on the lost device the same invalid call reports nothing. + let (_, error) = capture_errors(&device, || device.create_buffer(&bad)); + assert!(error.is_none(), "{error:?}"); +} + +/// wgpu hands back `CurrentSurfaceTexture::Validation` for an acquire whose error was captured: +/// most often a surface without a configuration. Skipping the frame, as before, met the same +/// error on every later frame (#7007); the surface is configured again instead. The other +/// statuses keep their actions. +#[test] +fn an_acquire_wgpu_refuses_configures_the_surface_again() { + let status = WgpuConfiguration::default().on_surface_status; + let action = |s: wgpu::CurrentSurfaceTexture| match status(&s) { + SurfaceErrorAction::SkipFrame => "skip", + SurfaceErrorAction::Reconfigure => "reconfigure", + SurfaceErrorAction::RecreateSurface => "recreate", + }; + assert_eq!(action(wgpu::CurrentSurfaceTexture::Validation), "reconfigure"); + assert_eq!(action(wgpu::CurrentSurfaceTexture::Outdated), "reconfigure"); + assert_eq!(action(wgpu::CurrentSurfaceTexture::Lost), "recreate"); + assert_eq!(action(wgpu::CurrentSurfaceTexture::Occluded), "skip"); + assert_eq!(action(wgpu::CurrentSurfaceTexture::Timeout), "skip"); +} + /// An error no scope caught on the window's device used to reach wgpu's default handler, which /// panics ("wgpu error: Out of Memory", #5486). With the handler installed it is reported and /// the device goes on working. diff --git a/vendor/README.md b/vendor/README.md index 408a8a10d..aaf33cc51 100644 --- a/vendor/README.md +++ b/vendor/README.md @@ -318,6 +318,13 @@ SolidCraft changes: submits nothing (`DeviceLost::probe`), so a device the driver lost is found by that submission rather than by the first queue write, which panicked inside wgpu-core (`PendingWrites::activate`, #4172). +- `src/lib.rs`, `src/winit.rs`: a surface configure that meets a lost device is not taken as + configured (`configure_captured`): wgpu reports device-loss errors to no error scope, and on + D3D12 a driver reset found by the configure has already dropped the surface's configuration. + The next acquire failed with "Surface is not configured for presentation" and the device's + default handler panicked (#7007). An unsupported surface is a refused configure too. The + acquire runs under `capture_errors`, and the `Validation` status it then returns reconfigures + the surface instead of skipping every later frame. - `src/lib.rs`: creation of the egui renderer uses validation, internal and out-of-memory error scopes, awaiting every result before returning it. A refused UI pipeline (D3D12 `egui_pipeline` shader compilation, #6648) returns `WgpuError::CreateRendererError` through diff --git a/vendor/egui-wgpu/src/lib.rs b/vendor/egui-wgpu/src/lib.rs index 0bba44e09..ca4d9c1e0 100644 --- a/vendor/egui-wgpu/src/lib.rs +++ b/vendor/egui-wgpu/src/lib.rs @@ -568,6 +568,13 @@ impl Default for WgpuConfiguration { log::trace!("Skipping frame due to occlusion."); SurfaceErrorAction::SkipFrame } + wgpu::CurrentSurfaceTexture::Validation => { + // SolidCraft: the acquire's error was captured; most often the surface has + // no configuration ("Surface is not configured for presentation", #7007). + // Skipping alone would meet the same error on every frame after. + log::debug!("Dropped frame with error: {status:?}"); + SurfaceErrorAction::Reconfigure + } _ => { log::warn!("Dropped frame with error: {status:?}"); SurfaceErrorAction::SkipFrame @@ -830,6 +837,50 @@ pub fn capture_errors(device: &wgpu::Device, f: impl FnOnce() -> T) -> (T, Op (value, failed) } +/// SolidCraft: why a surface configure ([`configure_captured`]) left the surface without its +/// configuration. +#[derive(Debug)] +pub enum ConfigureError { + /// The device refused it, with this error (#1935). + Refused(wgpu::Error), + /// The device was lost (#7007). + DeviceLost, + /// The adapter doesn't support the surface. + Unsupported, +} + +impl std::fmt::Display for ConfigureError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Refused(error) => error.fmt(f), + Self::DeviceLost => f.write_str("the graphics device was lost"), + Self::Unsupported => f.write_str("the surface isn't supported by this adapter"), + } + } +} + +/// SolidCraft: run a surface configure on `device` under [`capture_errors`], and say whether the +/// surface has its configuration. A configure that meets a lost device reports nothing: wgpu +/// passes device-loss errors to no error scope and no handler, only to the lost callback. On +/// D3D12 a driver reset is found that way, when the configure waits for the present queue, after +/// wgpu has dropped the surface's old configuration. Taken as configured, the surface's next +/// acquire failed with "Surface is not configured for presentation", and the device's default +/// error handler panicked (#7007). `lost` is the device's [`DeviceLost`], marked by then. +pub fn configure_captured( + device: &wgpu::Device, + lost: &DeviceLost, + configure: impl FnOnce(), +) -> Result<(), ConfigureError> { + let ((), failed) = capture_errors(device, configure); + if let Some(error) = failed { + return Err(ConfigureError::Refused(error)); + } + if lost.is_lost() { + return Err(ConfigureError::DeviceLost); + } + Ok(()) +} + /// SolidCraft: refused configures in a row after which the surface is recreated (#1935). pub const SURFACE_RECREATE_AFTER: u32 = 3; diff --git a/vendor/egui-wgpu/src/winit.rs b/vendor/egui-wgpu/src/winit.rs index c78ac8c4f..9f728d835 100644 --- a/vendor/egui-wgpu/src/winit.rs +++ b/vendor/egui-wgpu/src/winit.rs @@ -107,13 +107,14 @@ impl Painter { /// SolidCraft: a configuration the device refuses (D3D12: "Failed to wait for GPU to come /// idle before reconfiguring the Surface", #1935) comes back as the error instead of reaching - /// the device's uncaptured-error handler, which panics. Called only through - /// [`Self::try_configure`], which says what follows. + /// the device's uncaptured-error handler, which panics; so does a configure that met a lost + /// device, or a surface the adapter doesn't support, neither of which configured it (#7007). + /// Called only through [`Self::try_configure`], which says what follows. fn configure_surface( surface_state: &SurfaceState, render_state: &RenderState, config: &SurfaceConfig, - ) -> Result<(), wgpu::Error> { + ) -> Result<(), crate::ConfigureError> { profiling::function_scope!(); let SurfaceConfig { @@ -133,13 +134,12 @@ impl Painter { let width = surface_state.width; let height = surface_state.height; - // SolidCraft: an unsupported surface is logged, not a panic. + // SolidCraft: an unsupported surface is a refused configure, not a panic. let Some(default_config) = surface_state .surface .get_default_config(&render_state.adapter, width, height) else { - log::error!("The surface isn't supported by this adapter"); - return Ok(()); + return Err(crate::ConfigureError::Unsupported); }; let mut surf_config = wgpu::SurfaceConfiguration { usage: wgpu::TextureUsages::RENDER_ATTACHMENT, @@ -155,10 +155,9 @@ impl Painter { } let device = &render_state.device; - let ((), failed) = crate::capture_errors(device, || { - surface_state.surface.configure(device, &surf_config) - }); - failed.map_or(Ok(()), Err) + crate::configure_captured(device, &render_state.device_lost, || { + surface_state.surface.configure(device, &surf_config); + }) } /// SolidCraft: configures the surface at `now` unless a refused configure's retry isn't due @@ -723,7 +722,15 @@ impl Painter { if !FIRST_PRESENT.swap(true, std::sync::atomic::Ordering::Relaxed) { crate::startup_step(crate::STEP_FIRST_PRESENT, ""); } - let output_frame = surface_state.surface.get_current_texture(); + // SolidCraft: an acquire wgpu refuses (a surface left without its configuration, + // #7007) comes back as `CurrentSurfaceTexture::Validation` instead of reaching the + // device's uncaptured-error handler, which panics by default. + let (output_frame, failed) = crate::capture_errors(&render_state.device, || { + surface_state.surface.get_current_texture() + }); + if let Some(error) = failed { + log::warn!("The surface gave no frame: {error}"); + } vsync_sec += start.elapsed().as_secs_f32(); output_frame };