use crate::{Error, Result};
#[derive(Debug)]
pub struct Gpu {
device: wgpu::Device,
queue: wgpu::Queue,
report: AdapterReport,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AdapterReport {
pub name: String,
pub backend: wgpu::Backend,
pub device_type: wgpu::DeviceType,
pub driver: String,
pub max_storage_buffer_binding_size: u64,
pub max_compute_workgroups_per_dimension: u32,
pub subgroup_min_size: u32,
pub subgroup_max_size: u32,
}
impl Gpu {
pub fn new() -> Result<Self> {
Self::open(wgpu::Features::empty())
}
pub fn with_timestamps() -> Result<Self> {
Self::open(wgpu::Features::TIMESTAMP_QUERY)
}
pub fn with_subgroups() -> Result<Self> {
Self::open(wgpu::Features::SUBGROUP)
}
fn open(required: wgpu::Features) -> Result<Self> {
let instance =
wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
let adapter =
crate::block_on::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
force_fallback_adapter: false,
compatible_surface: None,
apply_limit_buckets: false,
}))
.map_err(|_| Error::NoAdapter)?;
let info = adapter.get_info();
let limits = adapter.limits();
if !adapter.features().contains(required) {
return Err(Error::FeaturesUnsupported {
missing: required.difference(adapter.features()),
});
}
let report = AdapterReport {
name: info.name,
backend: info.backend,
device_type: info.device_type,
driver: info.driver,
max_storage_buffer_binding_size: limits.max_storage_buffer_binding_size,
max_compute_workgroups_per_dimension: limits.max_compute_workgroups_per_dimension,
subgroup_min_size: info.subgroup_min_size,
subgroup_max_size: info.subgroup_max_size,
};
let (device, queue) =
crate::block_on::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("isomesh headless"),
required_features: required,
required_limits: limits,
memory_hints: wgpu::MemoryHints::Performance,
experimental_features: wgpu::ExperimentalFeatures::disabled(),
trace: wgpu::Trace::Off,
}))
.map_err(|_| Error::DeviceUnavailable)?;
Ok(Self {
device,
queue,
report,
})
}
#[must_use]
pub const fn device(&self) -> &wgpu::Device {
&self.device
}
#[must_use]
pub const fn queue(&self) -> &wgpu::Queue {
&self.queue
}
#[must_use]
pub const fn report(&self) -> &AdapterReport {
&self.report
}
}
#[cfg(test)]
pub(crate) fn shared() -> &'static Gpu {
static SHARED: std::sync::OnceLock<Gpu> = std::sync::OnceLock::new();
SHARED.get_or_init(|| {
Gpu::new().expect("a GPU adapter -- there is no software fallback, by design")
})
}
#[cfg(test)]
mod tests;