Lost GPU: the per-frame probe meets a D3D12 device reset before the first upload does (#6528) (#7767)

* claim: #6528

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

* Lost GPU: the per-frame probe opens a command list, as the upload would (#6528)

On a reset D3D12 device the empty submission before a frame's uploads
went through (it only signals a fence), and the first queue write then
panicked inside wgpu-core (PendingWrites::activate unwrapping Lost).
The probe now submits a command buffer with a debug marker: finishing it
makes the same begin_encoding call, through a path where wgpu loses the
device and runs its lost callback instead of panicking. The picture
capturer's probe does the same.

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-11-01 18:20:40 +00:00
committed by GitHub
parent 6f368a5b77
commit 862807ffc9
5 changed files with 71 additions and 18 deletions
+7 -3
View File
@@ -106,13 +106,17 @@ impl Capturer {
self.lost.load(Ordering::Acquire)
}
/// [`Capturer::is_lost`], asking the driver first: an empty submission meets a loss the
/// driver reports and marks it, where the picture's first upload would panic inside wgpu.
/// [`Capturer::is_lost`], asking the driver first: a submission that opens a command list
/// meets a loss the driver reports and marks it, where the picture's first upload would
/// panic inside wgpu. As `egui_wgpu::DeviceLost::probe`: an empty submission only signals a
/// fence, which a reset D3D12 device let through (#6528).
fn probe_lost(&self) -> bool {
if self.is_lost() {
return true;
}
self.queue.submit([]);
let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("device lost probe") });
encoder.insert_debug_marker("device lost probe");
self.queue.submit([encoder.finish()]);
self.is_lost()
}
+37 -2
View File
@@ -1189,7 +1189,7 @@ mod tests {
let capturer = solidcraft_gpu::capture::Capturer::new(&adapter, device.clone(), queue.clone()).unwrap().watching(lost.flag());
let (scene, cam) = (solidcraft_engine::render::Scene::default(), solidcraft_engine::render::Camera::default());
assert_ne!(super::picture(&capturer, &scene, &cam, 16, 16).unwrap().renderer, "cpu");
assert!(!lost.probe(&queue), "a working device isn't lost");
assert!(!lost.probe(&device, &queue), "a working device isn't lost");
// egui's renderer is made with the window, before any loss (made on a lost device, its
// uniform buffer's `create_buffer_init` panics).
@@ -1197,7 +1197,7 @@ mod tests {
device.destroy();
let _ = device.poll(wgpu::PollType::wait_indefinitely());
assert!(lost.is_lost() && lost.probe(&queue), "the lost callback marked the device");
assert!(lost.is_lost() && lost.probe(&device, &queue), "the lost callback marked the device");
assert!(lost.reason().is_some_and(|r| r.starts_with("Destroyed")), "{:?}", lost.reason());
// The next frame's uploads, as the painter would make them were it not skipping: wgpu
@@ -1210,4 +1210,39 @@ mod tests {
let picture = super::picture(&capturer, &scene, &cam, 16, 16).unwrap();
assert_eq!((picture.renderer, picture.rgba.len()), ("cpu", 16 * 16 * 4));
}
/// The probe runs before every frame's uploads, so on a working device it must cost nothing
/// visible: no error for any scope or handler, and the uploads after it go through. On a
/// reset D3D12 device an empty submission went through and the upload after it panicked
/// inside wgpu (#6528); the probe now opens a command list, the driver call that upload's
/// queue write would make first. A driver reset can't be made here: `destroy` loses the
/// device in wgpu itself, before any driver call.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn the_lost_device_probe_is_clean_on_a_working_device() {
use egui_wgpu::wgpu;
let Some((adapter, device, queue)) = super::offscreen_device() else {
eprintln!("skipping: no GPU adapter");
return;
};
let lost = egui_wgpu::DeviceLost::watch(&device);
let capturer = solidcraft_gpu::capture::Capturer::new(&adapter, device.clone(), queue.clone()).unwrap().watching(lost.flag());
let mut renderer = egui_wgpu::Renderer::new(&device, wgpu::TextureFormat::Rgba8Unorm, Default::default());
let image = egui::ImageData::Color(std::sync::Arc::new(egui::ColorImage::filled([4, 4], egui::Color32::WHITE)));
let delta = egui::epaint::ImageDelta::full(image, egui::TextureOptions::LINEAR);
let (scene, cam) = (solidcraft_engine::render::Scene::default(), solidcraft_engine::render::Camera::default());
for frame in 0..3 {
// As the painter: the probe, then the frame's first queue write.
let (was_lost, error) = egui_wgpu::capture_errors(&device, || {
let was_lost = lost.probe(&device, &queue);
renderer.update_texture(&device, &queue, egui::TextureId::Managed(0), &delta);
was_lost
});
assert!(!was_lost && error.is_none(), "frame {frame}: lost {was_lost}, {error:?}");
// A save's thumbnail, which probes too, still comes from the GPU.
assert_ne!(super::picture(&capturer, &scene, &cam, 16, 16).unwrap().renderer, "cpu");
}
let _ = device.poll(wgpu::PollType::wait_indefinitely());
assert!(!lost.is_lost() && lost.reason().is_none(), "{:?}", lost.reason());
}
}
+4 -3
View File
@@ -341,9 +341,10 @@ SolidCraft changes:
compositor wasn't showing stalled the main window behind its present.
- `src/lib.rs`, `src/winit.rs`: the device's lost callback marks `RenderState::device_lost`
(`DeviceLost`), and the painter draws nothing on a lost device. Before a frame's uploads it
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).
submits a command buffer holding a debug marker (`DeviceLost::probe`), so a device the
driver lost is found by opening that command list rather than by the first queue write,
which panicked inside wgpu-core (`PendingWrites::activate`, #4172). An empty submission
only signalled a fence, which a reset D3D12 device let through (#6528).
- `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.
+16 -6
View File
@@ -140,8 +140,8 @@ impl SurfaceConfig {
/// A lost device can't be used again. wgpu only learns of the loss when a call into the driver
/// fails: from then on every call on the device fails quietly, and the device's lost callback
/// marks this. But a queue write that is the first call to meet the loss panics inside wgpu
/// (`PendingWrites::activate`), so the painter first submits nothing ([`DeviceLost::probe`]):
/// that submission meets the loss instead, and the frame's uploads are skipped.
/// (`PendingWrites::activate`), so the painter first probes the device ([`DeviceLost::probe`]):
/// the probe meets the loss instead, and the frame's uploads are skipped.
#[derive(Clone, Debug, Default)]
pub struct DeviceLost {
lost: Arc<std::sync::atomic::AtomicBool>,
@@ -183,13 +183,23 @@ impl DeviceLost {
self.lost.clone()
}
/// Whether the device is lost, asking the driver first: an empty submission reaches the
/// driver, so a loss it reports is marked here rather than met by the next upload.
pub fn probe(&self, queue: &wgpu::Queue) -> bool {
/// Whether the device is lost, asking the driver first, so a loss it reports is marked here
/// rather than met by the next upload.
///
/// The probe opens a command list, as the upload would: a queue write's first call into the
/// driver is `begin_encoding`, and on D3D12 that is where a reset device says so. An empty
/// submission only signals a fence: #6528 met a reset D3D12 device in the upload right after
/// one. wgpu handles a failed `begin_encoding` in a command encoder's `finish` (it loses the
/// device, and the lost callback marks it); only its queue writes unwrap it.
pub fn probe(&self, device: &wgpu::Device, queue: &wgpu::Queue) -> bool {
if self.is_lost() {
return true;
}
queue.submit([]);
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("device lost probe"),
});
encoder.insert_debug_marker("device lost probe");
queue.submit([encoder.finish()]);
self.is_lost()
}
}
+7 -4
View File
@@ -806,10 +806,13 @@ impl Painter {
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);
// the submission meets it instead, marks it lost, and the frame is dropped unpresented.
if render_state.device_lost.probe(&render_state.queue) {
// SolidCraft: before the uploads, a probe asks the driver whether the device is still
// there. The first queue write to meet a lost device panics inside wgpu (#4172, #6528);
// the probe meets it instead, marks it lost, and the frame is dropped unpresented.
if render_state
.device_lost
.probe(&render_state.device, &render_state.queue)
{
if let Some(effect) = &render_state.renderer.read().frame_compositor {
effect.suspend();
}