use crate::{error::GpuResult, DevicePreferences, GpuError};
use std::sync::Arc;
use wgpu::{Adapter, Device, Features, Limits, Queue};
#[derive(Clone)]
pub struct GpuDevice {
device: Arc<Device>,
queue: Arc<Queue>,
adapter: Arc<Adapter>,
capabilities: DeviceCapabilities,
}
impl GpuDevice {
pub fn new(device: Device, queue: Queue, adapter: Adapter) -> Self {
let capabilities = DeviceCapabilities::from_adapter(&adapter);
Self {
device: Arc::new(device),
queue: Arc::new(queue),
adapter: Arc::new(adapter),
capabilities,
}
}
pub fn device(&self) -> &Device {
&self.device
}
pub fn queue(&self) -> &Queue {
&self.queue
}
pub fn adapter(&self) -> &Adapter {
&self.adapter
}
pub fn capabilities(&self) -> &DeviceCapabilities {
&self.capabilities
}
pub fn supports_features(&self, features: Features) -> bool {
self.device.features().contains(features)
}
pub fn meets_limits(&self, limits: &Limits) -> bool {
self.device.limits().max_buffer_size >= limits.max_buffer_size
}
}
#[derive(Debug, Clone)]
pub struct DeviceCapabilities {
pub name: String,
pub device_type: wgpu::DeviceType,
pub features: Features,
pub limits: Limits,
pub memory_info: MemoryInfo,
pub vendor_id: u32,
pub device_id: u32,
}
impl DeviceCapabilities {
pub fn from_adapter(adapter: &Adapter) -> Self {
let info = adapter.get_info();
let features = adapter.features();
let limits = adapter.limits();
let limits_clone = limits.clone();
Self {
name: info.name,
device_type: info.device_type,
features,
limits,
memory_info: MemoryInfo::estimate_from_limits(&limits_clone),
vendor_id: info.vendor,
device_id: info.device,
}
}
pub fn meets_preferences(&self, preferences: &DevicePreferences) -> bool {
if self.memory_info.total_memory < preferences.min_memory {
return false;
}
if !self.features.contains(preferences.required_features) {
return false;
}
if !self.meets_limits_approx(&preferences.required_limits) {
return false;
}
true
}
fn meets_limits_approx(&self, required: &Limits) -> bool {
self.limits.max_texture_dimension_1d >= required.max_texture_dimension_1d
&& self.limits.max_texture_dimension_2d >= required.max_texture_dimension_2d
&& self.limits.max_texture_dimension_3d >= required.max_texture_dimension_3d
&& self.limits.max_buffer_size >= required.max_buffer_size
&& self.limits.max_storage_buffers_per_shader_stage
>= required.max_storage_buffers_per_shader_stage
}
pub fn quality_score(&self, preferences: &DevicePreferences) -> u32 {
let mut score = 0;
if preferences.prefer_discrete && self.device_type == wgpu::DeviceType::DiscreteGpu {
score += 100;
}
score += (self.memory_info.total_memory / (1024 * 1024)) as u32;
score += self.features.bits().count_ones() * 10;
score
}
}
#[derive(Debug, Clone)]
pub struct MemoryInfo {
pub total_memory: u64,
pub available_memory: u64,
}
impl MemoryInfo {
pub fn estimate_from_limits(limits: &Limits) -> Self {
let estimated_total = (limits.max_buffer_size as u64).min(4 * 1024 * 1024 * 1024);
Self {
total_memory: estimated_total,
available_memory: estimated_total, }
}
}
pub struct GpuDeviceManager {
instance: wgpu::Instance,
primary_device: GpuDevice,
available_devices: Vec<GpuDevice>,
}
impl GpuDeviceManager {
pub async fn new() -> GpuResult<Self> {
Self::with_preferences(DevicePreferences::default()).await
}
pub async fn with_preferences(preferences: DevicePreferences) -> GpuResult<Self> {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..Default::default()
});
let mut best_adapter = None;
let mut best_score = 0;
for adapter in instance.enumerate_adapters(wgpu::Backends::all()) {
let capabilities = DeviceCapabilities::from_adapter(&adapter);
if capabilities.meets_preferences(&preferences) {
let score = capabilities.quality_score(&preferences);
if score > best_score {
best_score = score;
best_adapter = Some(adapter);
}
}
}
let adapter = best_adapter.ok_or(GpuError::NoSuitableDevice)?;
let (device, queue) = adapter
.request_device(
&wgpu::DeviceDescriptor {
label: Some("Moirai GPU Device"),
required_features: preferences.required_features,
required_limits: preferences.required_limits.clone(),
},
None,
)
.await?;
let primary_device = GpuDevice::new(device, queue, adapter);
Ok(Self {
instance,
primary_device,
available_devices: vec![], })
}
pub fn primary_device(&self) -> &GpuDevice {
&self.primary_device
}
pub fn available_devices(&self) -> &[GpuDevice] {
&self.available_devices
}
pub fn instance(&self) -> &wgpu::Instance {
&self.instance
}
}