Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(rendering): fall back to the next GPU adapter when the preferred one cannot make a device (#3257)

Richie McIlroyfa35c7aacd7d
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
index e5c2d0ec4..20d492a70 100644
--- a/crates/rendering/src/lib.rs
+++ b/crates/rendering/src/lib.rs
@@ -2595,7 +2595,7 @@ pub async fn create_shared_device() -> Result<SharedWgpuDevice, RenderingError>
}
let adapter_phase = readiness::Phase::start("wgpu.adapter");
- let hardware_adapter = if force_software_adapter {
+ let preferred = if force_software_adapter {
None
} else {
instance
@@ -2607,55 +2607,118 @@ pub async fn create_shared_device() -> Result<SharedWgpuDevice, RenderingError>
.await
.ok()
};
+ adapter_phase.finish(if preferred.is_some() {
+ "preferred"
+ } else {
+ "none"
+ });
- let (adapter, is_software_adapter) = if let Some(adapter) = hardware_adapter {
- let adapter_info = adapter.get_info();
- let is_software = is_software_wgpu_adapter(&adapter_info);
-
- if is_software {
- tracing::warn!(
- adapter_name = adapter_info.name,
- adapter_backend = ?adapter_info.backend,
- adapter_device_type = ?adapter_info.device_type,
- "Hardware adapter behaves like a software renderer"
- );
- } else {
- tracing::info!(
- adapter_name = adapter_info.name,
- adapter_backend = ?adapter_info.backend,
- adapter_device_type = ?adapter_info.device_type,
- "Using hardware GPU adapter"
- );
+ let device_phase = readiness::Phase::start("wgpu.device");
+ let mut last_error = None;
+ let mut created = None;
+ if let Some(adapter) = preferred {
+ match try_rendering_device(adapter).await {
+ Ok(found) => created = Some(found),
+ Err(error) => last_error = Some(error),
+ }
+ }
+ // A driver can list an adapter it cannot make a device on (a GL context
+ // without compute shaders, a broken install). Only then are the others
+ // enumerated, hardware first, then the fallback adapter.
+ if created.is_none() {
+ for adapter in other_wgpu_adapters(&instance, force_software_adapter).await {
+ match try_rendering_device(adapter).await {
+ Ok(found) => {
+ created = Some(found);
+ break;
+ }
+ Err(error) => last_error = Some(error),
+ }
}
+ }
+ let Some((adapter, device, queue)) = created else {
+ device_phase.finish("failed");
+ return Err(last_error.map_or(RenderingError::NoAdapter, Into::into));
+ };
+ device_phase.finish("returned");
- (adapter, is_software)
+ let adapter_info = adapter.get_info();
+ let is_software_adapter = is_software_wgpu_adapter(&adapter_info);
+ if is_software_adapter {
+ tracing::warn!(
+ adapter_name = adapter_info.name,
+ adapter_backend = ?adapter_info.backend,
+ adapter_device_type = ?adapter_info.device_type,
+ "Using software adapter (CPU rendering - performance may be reduced)"
+ );
} else {
- tracing::warn!("No hardware GPU adapter found, attempting software fallback");
- let software_adapter = instance
- .request_adapter(&wgpu::RequestAdapterOptions {
- power_preference: wgpu::PowerPreference::LowPower,
- force_fallback_adapter: true,
- compatible_surface: None,
- })
- .await
- .map_err(|_| RenderingError::NoAdapter)?;
-
- let adapter_info = software_adapter.get_info();
tracing::info!(
adapter_name = adapter_info.name,
adapter_backend = ?adapter_info.backend,
adapter_device_type = ?adapter_info.device_type,
- "Using software adapter (CPU rendering - performance may be reduced)"
+ "Using hardware GPU adapter"
);
- (software_adapter, true)
- };
+ }
+ log_uncaptured_errors(&device, "cap-rendering-device");
+ Ok(SharedWgpuDevice {
+ instance,
+ adapter,
+ device,
+ queue,
+ is_software_adapter,
+ })
+}
- adapter_phase.finish(if is_software_adapter {
- "software"
+// Identical cards report identical `AdapterInfo` (wgpu 25 has no bus id), so
+// the preferred adapter is not filtered out: one more failed attempt on it is
+// cheaper than skipping a working twin.
+#[cfg(not(target_arch = "wasm32"))]
+async fn other_wgpu_adapters(
+ instance: &wgpu::Instance,
+ force_software_adapter: bool,
+) -> Vec<wgpu::Adapter> {
+ let mut adapters = if force_software_adapter {
+ Vec::new()
} else {
- "hardware"
- });
+ instance.enumerate_adapters(wgpu::Backends::all())
+ };
+ adapters.sort_by_key(|adapter| is_software_wgpu_adapter(&adapter.get_info()));
+ if let Ok(fallback) = instance
+ .request_adapter(&wgpu::RequestAdapterOptions {
+ power_preference: wgpu::PowerPreference::LowPower,
+ force_fallback_adapter: true,
+ compatible_surface: None,
+ })
+ .await
+ {
+ adapters.push(fallback);
+ }
+ adapters
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+async fn try_rendering_device(
+ adapter: wgpu::Adapter,
+) -> Result<(wgpu::Adapter, wgpu::Device, wgpu::Queue), wgpu::RequestDeviceError> {
+ let info = adapter.get_info();
+ match request_rendering_device(&adapter).await {
+ Ok((device, queue)) => Ok((adapter, device, queue)),
+ Err(error) => {
+ tracing::warn!(
+ adapter_name = info.name,
+ adapter_backend = ?info.backend,
+ %error,
+ "Could not create a rendering device; trying the next adapter"
+ );
+ Err(error)
+ }
+ }
+}
+#[cfg(not(target_arch = "wasm32"))]
+async fn request_rendering_device(
+ adapter: &wgpu::Adapter,
+) -> Result<(wgpu::Device, wgpu::Queue), wgpu::RequestDeviceError> {
let mut required_features = wgpu::Features::empty();
if adapter.features().contains(wgpu::Features::PIPELINE_CACHE) {
required_features |= wgpu::Features::PIPELINE_CACHE;
@@ -2666,24 +2729,13 @@ pub async fn create_shared_device() -> Result<SharedWgpuDevice, RenderingError>
{
required_features |= wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES;
}
-
- let device_descriptor = wgpu::DeviceDescriptor {
- label: Some("cap-rendering-device"),
- required_features,
- ..Default::default()
- };
-
- 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,
- device,
- queue,
- is_software_adapter,
- })
+ adapter
+ .request_device(&wgpu::DeviceDescriptor {
+ label: Some("cap-rendering-device"),
+ required_features,
+ ..Default::default()
+ })
+ .await
}
/// wgpu panics on an error nothing captured. After a device is lost (a driver