use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock, RwLock, Weak};
#[derive(Clone, Copy, Debug, Default)]
pub struct AdapterOptions {
pub power_preference: wgpu::PowerPreference,
pub force_fallback_adapter: bool,
}
#[derive(Clone)]
pub struct Adapter {
pub raw: Arc<wgpu::Adapter>,
pub shared: Option<Arc<Context>>,
}
#[derive(Clone, Debug)]
pub struct DeviceLoss {
pub reason: &'static str,
pub message: String,
}
pub struct Context {
pub device: Arc<wgpu::Device>,
pub queue: Arc<wgpu::Queue>,
pub adapter: Arc<wgpu::Adapter>,
loss: Arc<Mutex<Option<DeviceLoss>>>,
_owner: Option<Arc<dyn std::any::Any + Send + Sync>>,
}
impl Context {
pub fn from_shared(
adapter: Arc<wgpu::Adapter>,
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
) -> Self {
Self {
adapter,
device,
queue,
loss: Arc::new(Mutex::new(None)),
_owner: None,
}
}
pub fn from_shared_with_owner(
adapter: Arc<wgpu::Adapter>,
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
owner: Arc<dyn std::any::Any + Send + Sync>,
) -> Self {
Self {
_owner: Some(owner),
..Self::from_shared(adapter, device, queue)
}
}
pub fn notify_lost(&self, reason: &'static str, message: impl Into<String>) {
let mut loss = self.loss.lock().unwrap();
if loss.is_none() {
*loss = Some(DeviceLoss {
reason,
message: message.into(),
});
}
}
pub fn loss(&self) -> Option<DeviceLoss> {
self.loss.lock().unwrap().clone()
}
}
pub type AdapterFuture =
Pin<Box<dyn Future<Output = Result<Option<Adapter>, String>> + Send + 'static>>;
pub trait GpuHost: Send + Sync {
fn request_adapter(&self, options: AdapterOptions) -> AdapterFuture;
}
fn host_slot() -> &'static RwLock<Option<Arc<dyn GpuHost>>> {
static HOST: OnceLock<RwLock<Option<Arc<dyn GpuHost>>>> = OnceLock::new();
HOST.get_or_init(|| RwLock::new(None))
}
pub fn set_host(host: Option<Arc<dyn GpuHost>>) {
*host_slot().write().unwrap() = host;
}
pub async fn request_adapter(options: AdapterOptions) -> Result<Option<Adapter>, String> {
let host = host_slot().read().unwrap().clone();
if let Some(host) = host {
return host.request_adapter(options).await;
}
let mut descriptor = wgpu::InstanceDescriptor::new_without_display_handle();
descriptor.backends = if cfg!(target_os = "windows") {
wgpu::Backends::DX12
} else {
wgpu::Backends::PRIMARY
};
descriptor.flags |= wgpu::InstanceFlags::AUTOMATIC_TIMESTAMP_NORMALIZATION;
let instance = wgpu::Instance::new(descriptor);
match instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: options.power_preference,
force_fallback_adapter: options.force_fallback_adapter,
compatible_surface: None,
..Default::default()
})
.await
{
Ok(raw) => Ok(Some(Adapter {
raw: Arc::new(raw),
shared: None,
})),
Err(_) => Ok(None),
}
}
pub const VIRTUALIZED_FEATURES: wgpu::Features =
wgpu::Features::TIMESTAMP_QUERY.union(wgpu::Features::IMMEDIATES);
pub fn shareable_capabilities(adapter: &wgpu::Adapter) -> (wgpu::Features, wgpu::Limits) {
let features = adapter.features() & VIRTUALIZED_FEATURES;
let mut limits = wgpu::Limits::default();
if features.contains(wgpu::Features::IMMEDIATES) {
limits.max_immediate_size = adapter.limits().max_immediate_size;
}
(features, limits)
}
impl Adapter {
pub fn features(&self) -> wgpu::Features {
match &self.shared {
Some(c) if c.queue.get_timestamp_period() != 1.0 => {
c.device.features() - wgpu::Features::TIMESTAMP_QUERY
}
Some(c) => c.device.features(),
None => self.raw.features(),
}
}
pub fn limits(&self) -> wgpu::Limits {
self.shared
.as_ref()
.map_or_else(|| self.raw.limits(), |c| c.device.limits())
}
pub async fn request_device(
&self,
features: wgpu::Features,
limits: wgpu::Limits,
) -> Result<Arc<Context>, String> {
let available_features = self.features();
if !available_features.contains(features) {
return Err(format!(
"Unsupported requiredFeatures: {:?}",
features - available_features
));
}
let available_limits = self.limits();
if !limits.check_limits(&available_limits) {
let mut failures = Vec::new();
limits.check_limits_with_fail_fn(
&available_limits,
false,
|name, requested, allowed| {
failures.push(format!(
"{name}: requested {requested}, available {allowed}"
));
},
);
return Err(format!(
"Unsupported requiredLimits: {}",
failures.join(", ")
));
}
if let Some(context) = &self.shared {
let physical = context.device.limits();
let comparable = wgpu::Limits {
max_immediate_size: physical.max_immediate_size,
..limits.clone()
};
if !VIRTUALIZED_FEATURES.contains(context.device.features() - features)
|| comparable != physical
{
return Err(
"Shared WebGPU clients currently require matching physical capabilities".into(),
);
}
if context.adapter.as_ref() != self.raw.as_ref() {
return Err("Shared GPU context belongs to a different adapter".into());
}
if let Some(loss) = context.loss() {
return Err(format!("Shared GPU device is lost: {}", loss.message));
}
return Ok(context.clone());
}
let features = if limits.max_immediate_size > 0 {
features | wgpu::Features::IMMEDIATES
} else {
features
};
let (device, queue) = self
.raw
.request_device(&wgpu::DeviceDescriptor {
label: Some("redjs WebGPU"),
required_features: features,
required_limits: limits,
memory_hints: wgpu::MemoryHints::MemoryUsage,
..Default::default()
})
.await
.map_err(|e| e.to_string())?;
let context = Arc::new(Context::from_shared(
self.raw.clone(),
Arc::new(device),
Arc::new(queue),
));
let loss = context.loss.clone();
context
.device
.set_device_lost_callback(move |reason, message| {
let mut state = loss.lock().unwrap();
if state.is_none() {
*state = Some(DeviceLoss {
reason: if reason == wgpu::DeviceLostReason::Destroyed {
"destroyed"
} else {
"unknown"
},
message,
});
}
});
Ok(context)
}
}
pub fn scoped<T>(device: &wgpu::Device, operation: impl FnOnce() -> T) -> (T, Option<wgpu::Error>) {
let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
let oom = device.push_error_scope(wgpu::ErrorFilter::OutOfMemory);
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let result = operation();
let error = [
pollster::block_on(validation.pop()),
pollster::block_on(oom.pop()),
pollster::block_on(internal.pop()),
]
.into_iter()
.flatten()
.next();
(result, error)
}
pub(crate) fn pump(
device: &wgpu::Device,
pause: &mut std::time::Duration,
) -> Result<wgpu::PollStatus, wgpu::PollError> {
std::thread::sleep(*pause);
*pause = (*pause * 2).clamp(
std::time::Duration::from_micros(50),
std::time::Duration::from_millis(1),
);
device.poll(wgpu::PollType::Poll)
}
#[derive(Clone, Debug)]
pub struct GpuError {
pub kind: &'static str,
pub message: String,
}
#[derive(Default)]
struct Resources {
buffers: Vec<Weak<wgpu::Buffer>>,
textures: Vec<Weak<wgpu::Texture>>,
}
pub struct Client {
pub context: Arc<Context>,
pub id: u64,
pub features: wgpu::Features,
pub limits: wgpu::Limits,
pub destroyed: AtomicBool,
resources: Mutex<Resources>,
errors: Mutex<Vec<GpuError>>,
}
impl Client {
pub fn new(context: Arc<Context>) -> Arc<Self> {
let features = context.device.features();
let limits = context.device.limits();
Self::new_with_capabilities(context, features, limits)
}
pub fn new_with_capabilities(
context: Arc<Context>,
features: wgpu::Features,
limits: wgpu::Limits,
) -> Arc<Self> {
static NEXT: AtomicU64 = AtomicU64::new(1);
Arc::new(Self {
context,
id: NEXT.fetch_add(1, Ordering::Relaxed),
features,
limits,
destroyed: AtomicBool::new(false),
resources: Mutex::new(Resources::default()),
errors: Mutex::new(Vec::new()),
})
}
pub fn check(&self) -> Result<(), String> {
if self.destroyed.load(Ordering::Acquire) {
return Err("GPUDevice has been destroyed".into());
}
if let Some(loss) = self.context.loss() {
return Err(format!("GPUDevice is lost: {}", loss.message));
}
Ok(())
}
pub fn track_buffer(&self, buffer: &Arc<wgpu::Buffer>) {
let mut resources = self.resources.lock().unwrap();
if self.destroyed.load(Ordering::Acquire) {
drop(resources);
buffer.destroy();
} else {
resources.buffers.retain(|b| b.strong_count() != 0);
resources.buffers.push(Arc::downgrade(buffer));
}
}
pub fn track_texture(&self, texture: &Arc<wgpu::Texture>) {
let mut resources = self.resources.lock().unwrap();
if self.destroyed.load(Ordering::Acquire) {
drop(resources);
texture.destroy();
} else {
resources.textures.retain(|t| t.strong_count() != 0);
resources.textures.push(Arc::downgrade(texture));
}
}
pub(super) fn release_presented_texture(&self, texture: &Arc<wgpu::Texture>) -> bool {
let mut resources = self.resources.lock().unwrap();
if self.destroyed.load(Ordering::Acquire) {
return false;
}
resources.textures.retain(|weak| {
weak.upgrade()
.is_some_and(|raw| !Arc::ptr_eq(&raw, texture))
});
true
}
pub fn destroy(&self) {
let resources = {
let mut resources = self.resources.lock().unwrap();
if self.destroyed.swap(true, Ordering::AcqRel) {
return;
}
std::mem::take(&mut *resources)
};
for buffer in resources.buffers.into_iter().filter_map(|b| b.upgrade()) {
buffer.destroy();
}
for texture in resources.textures.into_iter().filter_map(|t| t.upgrade()) {
texture.destroy();
}
}
pub fn record_error(&self, kind: &'static str, message: impl Into<String>) {
self.errors.lock().unwrap().push(GpuError {
kind,
message: message.into(),
});
}
pub fn has_errors(&self) -> bool {
!self.errors.lock().unwrap().is_empty()
}
pub fn take_errors(&self) -> Vec<GpuError> {
std::mem::take(&mut *self.errors.lock().unwrap())
}
pub fn checked<T>(&self, operation: impl FnOnce() -> T) -> T {
let device = &self.context.device;
let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
let oom = device.push_error_scope(wgpu::ErrorFilter::OutOfMemory);
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let result = operation();
for error in [
pollster::block_on(validation.pop()),
pollster::block_on(oom.pop()),
pollster::block_on(internal.pop()),
]
.into_iter()
.flatten()
{
let kind = match &error {
wgpu::Error::Validation { .. } => "validation",
wgpu::Error::OutOfMemory { .. } => "out-of-memory",
wgpu::Error::Internal { .. } => "internal",
};
self.record_error(kind, error.to_string());
}
result
}
}