From abdbc6ee8ea7decd06d122ed8db4551b730bdf7c Mon Sep 17 00:00:00 2001 From: DingusMcRinkyDinky <127614779+DingusMcRinkyDinky@users.noreply.github.com> Date: Wed, 4 Nov 2026 12:58:03 +0100 Subject: [PATCH] GPU tests: keep one instance in photocraft-gpu's tests; follow WGPU_BACKEND photocraft-gpu's own tests made and dropped an instance each, so they could still hit the libvulkan teardown crash. They now share one instance, kept for the whole run and made from WGPU_BACKEND (one test used wgpu's defaults, which ignore it). The kept Vulkan instance in gpu_lock ignored WGPU_BACKEND, so setting it to keep a broken Vulkan driver out of the tests didn't. With Vulkan left out, no instance is kept. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01EZbgszHyuEuWAzxaamteuU --- crates/gpu/tests/it/camera_raw.rs | 2 +- crates/gpu/tests/it/device_loss.rs | 2 +- crates/gpu/tests/it/main.rs | 8 ++++++++ crates/gpu/tests/it/parity.rs | 7 ++----- crates/gpu/tests/it/pipeline_errors.rs | 2 +- crates/gpu/tests/it/timing.rs | 2 +- crates/gpu/tests/it/uniform_limits.rs | 2 +- crates/gpu/tests/it/vector_mask.rs | 2 +- crates/testkit/src/gpu.rs | 26 +++++++++++++++++++++++--- 9 files changed, 39 insertions(+), 14 deletions(-) diff --git a/crates/gpu/tests/it/camera_raw.rs b/crates/gpu/tests/it/camera_raw.rs index ff841c825a..a96bcafd20 100644 --- a/crates/gpu/tests/it/camera_raw.rs +++ b/crates/gpu/tests/it/camera_raw.rs @@ -25,7 +25,7 @@ fn gpu() -> Option { let lock = crate::GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner); let required = std::env::var_os("WGPU_BACKEND").is_some(); // `WGPU_BACKEND` picks the backend; `PHOTOCRAFT_TEST_FALLBACK_ADAPTER=1` the software one (WARP). - let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()); + let instance = crate::instance(); let fallback = std::env::var_os("PHOTOCRAFT_TEST_FALLBACK_ADAPTER").is_some(); let options = wgpu::RequestAdapterOptions { force_fallback_adapter: fallback, ..Default::default() }; let adapter = match pollster::block_on(instance.request_adapter(&options)) { diff --git a/crates/gpu/tests/it/device_loss.rs b/crates/gpu/tests/it/device_loss.rs index 2e8839de12..a4e691d52e 100644 --- a/crates/gpu/tests/it/device_loss.rs +++ b/crates/gpu/tests/it/device_loss.rs @@ -12,7 +12,7 @@ use photocraft_raster::Surface; use crate::GPU_LOCK; fn device() -> Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue)> { - let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()); + let instance = crate::instance(); let adapter = match pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())) { Ok(a) => a, Err(e) => { diff --git a/crates/gpu/tests/it/main.rs b/crates/gpu/tests/it/main.rs index 027db9d995..38cb481b3d 100644 --- a/crates/gpu/tests/it/main.rs +++ b/crates/gpu/tests/it/main.rs @@ -4,6 +4,14 @@ /// creates a device takes this lock and holds it until the device is dropped. static GPU_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); +/// The wgpu instance every test uses (`WGPU_BACKEND` picks its backends), kept for the whole +/// run: the last instance going away tears the Vulkan loader down, and an instance made while +/// that happens can crash in libvulkan. +pub(crate) fn instance() -> wgpu::Instance { + static KEPT: std::sync::OnceLock = std::sync::OnceLock::new(); + KEPT.get_or_init(|| wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env())).clone() +} + mod camera_raw; mod device_loss; mod parity; diff --git a/crates/gpu/tests/it/parity.rs b/crates/gpu/tests/it/parity.rs index e8ab0b91c4..f132adbc6b 100644 --- a/crates/gpu/tests/it/parity.rs +++ b/crates/gpu/tests/it/parity.rs @@ -101,7 +101,7 @@ fn timed(what: &str, run: impl FnOnce() -> T) -> T { fn gpu() -> Option { let lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner); let required = std::env::var_os("WGPU_BACKEND").is_some(); - let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()); + let instance = crate::instance(); let adapter = match pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())) { Ok(a) => a, Err(e) => { @@ -145,10 +145,7 @@ fn gpu() -> Option { /// The returned guard holds [`GPU_LOCK`] until the device is dropped. fn any_device() -> Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue, std::sync::MutexGuard<'static, ()>)> { let lock = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner); - let adapter = pollster::block_on( - wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()).request_adapter(&wgpu::RequestAdapterOptions::default()), - ) - .ok()?; + let adapter = pollster::block_on(crate::instance().request_adapter(&wgpu::RequestAdapterOptions::default())).ok()?; let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).ok()?; Some((adapter, device, queue, lock)) } diff --git a/crates/gpu/tests/it/pipeline_errors.rs b/crates/gpu/tests/it/pipeline_errors.rs index 28d7a56791..721be483aa 100644 --- a/crates/gpu/tests/it/pipeline_errors.rs +++ b/crates/gpu/tests/it/pipeline_errors.rs @@ -12,7 +12,7 @@ use photocraft_gpu::{Compositor, render_to_vec}; use crate::GPU_LOCK; fn device() -> Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue)> { - let instance = wgpu::Instance::default(); + let instance = crate::instance(); let Ok(adapter) = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())) else { eprintln!("skipping: no adapter"); return None; diff --git a/crates/gpu/tests/it/timing.rs b/crates/gpu/tests/it/timing.rs index 68ebc9d0be..5f631c0519 100644 --- a/crates/gpu/tests/it/timing.rs +++ b/crates/gpu/tests/it/timing.rs @@ -38,7 +38,7 @@ fn block_on(f: F) -> F::Output { /// A real GPU with timestamp queries, or `None` with the reason printed. fn gpu() -> Option<(wgpu::Device, wgpu::Queue, Compositor)> { let options = wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, ..Default::default() }; - let Ok(adapter) = block_on(wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()).request_adapter(&options)) else { + let Ok(adapter) = block_on(crate::instance().request_adapter(&options)) else { eprintln!("SKIP gpu timing: no adapter"); return None; }; diff --git a/crates/gpu/tests/it/uniform_limits.rs b/crates/gpu/tests/it/uniform_limits.rs index e562a8ca9d..0916a8bdab 100644 --- a/crates/gpu/tests/it/uniform_limits.rs +++ b/crates/gpu/tests/it/uniform_limits.rs @@ -20,7 +20,7 @@ fn fills_size(count: usize, size: Size) -> Document { } fn constrained_device() -> Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue)> { - let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()); + let instance = crate::instance(); let adapter = match pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())) { Ok(adapter) => adapter, Err(error) => { diff --git a/crates/gpu/tests/it/vector_mask.rs b/crates/gpu/tests/it/vector_mask.rs index feb8597b8e..7135d72a8d 100644 --- a/crates/gpu/tests/it/vector_mask.rs +++ b/crates/gpu/tests/it/vector_mask.rs @@ -6,7 +6,7 @@ use photocraft_doc::{Adjustment, Document, Effect, Layer, LayerContent, LayerMas use photocraft_geom::Rect; fn gpu() -> Option<(wgpu::Device, wgpu::Queue, photocraft_gpu::Compositor)> { - let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()); + let instance = crate::instance(); let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())).ok()?; let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).ok()?; // Exact comparison needs 32-bit float targets (see parity.rs); skip on adapters without them. diff --git a/crates/testkit/src/gpu.rs b/crates/testkit/src/gpu.rs index 10a8620e68..e3113857dd 100644 --- a/crates/testkit/src/gpu.rs +++ b/crates/testkit/src/gpu.rs @@ -40,12 +40,22 @@ pub fn gpu_lock() -> MutexGuard<'static, ()> { guard } -/// Creates the Vulkan instance that stays for the rest of the process. +/// Creates the Vulkan instance that stays for the rest of the process, unless `WGPU_BACKEND` +/// leaves Vulkan out (to keep a broken Vulkan driver out of the tests). #[cfg(target_os = "linux")] fn keep_vulkan() { use wgpu::{Backends, Instance, InstanceDescriptor}; - static KEPT: std::sync::OnceLock = std::sync::OnceLock::new(); - KEPT.get_or_init(|| Instance::new(InstanceDescriptor { backends: Backends::VULKAN, ..InstanceDescriptor::new_without_display_handle() })); + static KEPT: std::sync::OnceLock> = std::sync::OnceLock::new(); + KEPT.get_or_init(|| { + kept_backends(Backends::from_env()).map(|backends| Instance::new(InstanceDescriptor { backends, ..InstanceDescriptor::new_without_display_handle() })) + }); +} + +/// The backends of the kept instance for a `WGPU_BACKEND` of `env`: Vulkan, if it allows it. +#[cfg(target_os = "linux")] +fn kept_backends(env: Option) -> Option { + let vulkan = env.unwrap_or(wgpu::Backends::VULKAN) & wgpu::Backends::VULKAN; + (!vulkan.is_empty()).then_some(vulkan) } #[cfg(test)] @@ -73,6 +83,16 @@ mod tests { } } + /// `WGPU_BACKEND=gl` keeps Vulkan out of the tests: no Vulkan instance is kept then. + #[cfg(target_os = "linux")] + #[test] + fn the_kept_instance_follows_wgpu_backend() { + use wgpu::Backends; + assert_eq!(kept_backends(None), Some(Backends::VULKAN)); + assert_eq!(kept_backends(Some(Backends::GL)), None); + assert_eq!(kept_backends(Some(Backends::GL | Backends::VULKAN)), Some(Backends::VULKAN)); + } + #[test] fn a_panicked_holder_does_not_block_the_next_test() { let _ = std::thread::spawn(|| {