Lost GPU: a dropped frame no longer crashes the window's close (#7148) (#7400)

* claim: #7148

* Lost GPU: a dropped frame no longer crashes the window's close (#7148)

On a lost device wgpu's present and discard return early and leave the
acquired frame's image in the surface, holding a swapchain acquire
semaphore. Dropping the surface later (the window closing for the
restart after the loss) then panicked in wgpu-hal. The painter now holds
the frame as AcquiredFrame, which destroys a second handle to the
frame's texture after the frame is presented or dropped; wgpu-core's
destroy of a surface texture takes the image back without checking the
device, and does nothing once a present or discard took it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
semmelrinde
2026-10-27 14:48:04 +00:00
committed by GitHub
parent 96b3ebba54
commit 02981d6bcf
3 changed files with 177 additions and 6 deletions
+6
View File
@@ -325,6 +325,12 @@ SolidCraft changes:
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`, `src/winit.rs`: the painter holds an acquired frame as `AcquiredFrame`, which
destroys a second handle to the frame's texture once the frame is presented or dropped. On a
lost device wgpu's present and discard keep the frame's image in the surface, and dropping
the surface (the window closing for the restart) then panicked in wgpu-hal ("Trying to
destroy a SwapchainAcquireSemaphore that is still in use by a SurfaceTexture", #7148); the
destroy takes the image back whatever the device's state.
- `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
+160
View File
@@ -194,6 +194,67 @@ impl DeviceLost {
}
}
/// SolidCraft: a frame acquired from a window's surface, which gives its swapchain image back
/// however the frame ends: presented, dropped unpresented, or dropped while a panic unwinds
/// (#7148).
///
/// wgpu presents or discards a frame only on a valid device. On a lost one both return early, and
/// the surface keeps the frame's image, which holds one of the swapchain's acquire semaphores.
/// Dropping or reconfiguring that surface later (the window closing as the app restarts after the
/// loss) then panics in wgpu-hal: "Trying to destroy a SwapchainAcquireSemaphore that is still in
/// use by a SurfaceTexture". So the frame keeps a second handle to its texture, and once the frame
/// is gone that handle is destroyed ([`FreeSurfaceTexture`]), which takes the image (and its
/// semaphores) back from the surface, lost device or not. After a present or discard that worked,
/// the image is already back and the destroy does nothing.
///
/// The order is the struct's: Rust drops fields in declaration order, so [`Self::frame`] always
/// goes before the texture handle is destroyed, and [`Self::present`] presents before it.
pub struct AcquiredFrame<F, T: FreeSurfaceTexture> {
/// The frame; dropped (discarded) before the texture is freed.
pub frame: F,
texture: FreeOnDrop<T>,
}
impl<F, T: FreeSurfaceTexture> AcquiredFrame<F, T> {
/// `texture` is a second handle to `frame`'s texture.
pub fn new(frame: F, texture: T) -> Self {
Self {
frame,
texture: FreeOnDrop(texture),
}
}
/// Present the frame with `present`, then free the texture.
pub fn present(self, present: impl FnOnce(F)) {
let Self { frame, texture } = self;
present(frame);
drop(texture);
}
}
/// SolidCraft: what [`AcquiredFrame`] does with its texture handle once the frame is gone.
pub trait FreeSurfaceTexture {
/// Give the surface's image back, whatever the device's state; nothing once it is back.
fn free(&self);
}
impl FreeSurfaceTexture for wgpu::Texture {
/// wgpu-core's destroy of a surface texture takes its image and drops it without checking the
/// device, and does nothing when a present or discard took it already.
fn free(&self) {
self.destroy();
}
}
/// Frees its texture when dropped, also while a panic unwinds.
struct FreeOnDrop<T: FreeSurfaceTexture>(T);
impl<T: FreeSurfaceTexture> Drop for FreeOnDrop<T> {
fn drop(&mut self) {
self.0.free();
}
}
/// Access to the render state for egui.
#[derive(Clone)]
pub struct RenderState {
@@ -1032,4 +1093,103 @@ mod device_lost_tests {
assert!(flag.load(std::sync::atomic::Ordering::Acquire));
assert_eq!(painter.reason().as_deref(), Some("Unknown: Device lost"));
}
/// A window's surface as wgpu-core treats the image of an acquired frame: a present or a
/// discard gives it back only on a valid device, a destroy of the texture always (#7148).
#[derive(Default)]
struct Surface {
lost: std::cell::Cell<bool>,
image_held: std::cell::Cell<bool>,
calls: std::cell::RefCell<Vec<&'static str>>,
}
impl Surface {
fn call(&self, name: &'static str, gives_back: bool) {
self.calls.borrow_mut().push(name);
if gives_back {
self.image_held.set(false);
}
}
}
/// A frame of [`Surface`]: discarded when dropped unpresented.
struct Frame<'s> {
surface: &'s Surface,
presented: bool,
}
impl Drop for Frame<'_> {
fn drop(&mut self) {
if !self.presented {
self.surface.call("discard", !self.surface.lost.get());
}
}
}
struct Texture<'s>(&'s Surface);
impl super::FreeSurfaceTexture for Texture<'_> {
fn free(&self) {
self.0.call("free", true);
}
}
#[derive(Clone, Copy, Debug)]
enum End {
Present,
Drop,
Panic,
}
/// Acquire a frame from `surface` and end it as `end`.
fn run_frame(surface: &Surface, end: End) {
surface.image_held.set(true);
let frame = super::AcquiredFrame::new(
Frame {
surface,
presented: false,
},
Texture(surface),
);
match end {
End::Present => frame.present(|mut frame| {
frame.presented = true;
surface.call("present", !surface.lost.get());
}),
End::Drop => drop(frame),
End::Panic => {
let unwound = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || {
let _frame = frame;
panic!("a paint callback panics while the frame is held");
}));
assert!(unwound.is_err());
}
}
}
/// However a frame ends, on a valid or a lost device, the surface has its image back by the
/// time the frame is gone, so dropping or reconfiguring the surface can't meet a semaphore
/// still in use (#7148). The texture is freed only after the present or discard: freed first,
/// a valid device's present or discard would find it destroyed.
#[test]
fn a_frame_gives_its_image_back_however_it_ends_even_on_a_lost_device() {
for lost in [false, true] {
for end in [End::Present, End::Drop, End::Panic] {
let surface = Surface::default();
surface.lost.set(lost);
run_frame(&surface, end);
let first = if matches!(end, End::Present) {
"present"
} else {
"discard"
};
assert_eq!(
*surface.calls.borrow(),
[first, "free"],
"lost {lost}, {end:?}"
);
assert!(!surface.image_held.get(), "lost {lost}, {end:?}");
}
}
}
}
+11 -6
View File
@@ -735,7 +735,7 @@ impl Painter {
output_frame
};
let output_frame = match output_frame {
let frame = match output_frame {
wgpu::CurrentSurfaceTexture::Success(frame) => frame,
wgpu::CurrentSurfaceTexture::Suboptimal(frame) => {
surface_state.needs_reconfigure = true;
@@ -770,6 +770,11 @@ impl Painter {
return vsync_sec;
}
};
// SolidCraft: however this frame ends (presented, dropped by an early return below, or
// dropped while a panic unwinds), the surface gets its image back, also on a lost device,
// where wgpu's present and discard keep it and the surface's drop then panicked (#7148).
let texture = frame.texture.clone();
let output_frame = crate::AcquiredFrame::new(frame, texture);
// SolidCraft: before the uploads, an empty submission asks the driver whether the device
// is still there. The first queue write to meet a lost device panics inside wgpu (#4172);
@@ -831,13 +836,13 @@ impl Painter {
let target_texture = if capture {
let capture_state = self.screen_capture_state.get_or_insert_with(|| {
CaptureState::new(&render_state.device, &output_frame.texture)
CaptureState::new(&render_state.device, &output_frame.frame.texture)
});
capture_state.update(&render_state.device, &output_frame.texture);
capture_state.update(&render_state.device, &output_frame.frame.texture);
&capture_state.texture
} else {
&output_frame.texture
&output_frame.frame.texture
};
let target_view = target_texture.create_view(&wgpu::TextureViewDescriptor::default());
@@ -908,7 +913,7 @@ impl Painter {
if capture && let Some(capture_state) = &mut self.screen_capture_state {
capture_buffer = Some(capture_state.copy_textures(
&render_state.device,
&output_frame,
&output_frame.frame,
&mut encoder,
));
}
@@ -962,7 +967,7 @@ impl Painter {
profiling::scope!("present");
// wgpu doesn't document where vsync can happen. Maybe here?
let start = web_time::Instant::now();
render_state.queue.present(output_frame);
output_frame.present(|frame| render_state.queue.present(frame));
vsync_sec += start.elapsed().as_secs_f32();
}