use super::WgpuDevice;
use crate::device::probe;
use crate::error::{BarracudaError, Result};
use std::sync::Arc;
static DEVICE_CREATION_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
pub const ADAPTER_ENV_VAR: &str = "BARRACUDA_GPU_ADAPTER";
fn desired_features() -> Vec<wgpu::Features> {
vec![
wgpu::Features::SHADER_F64,
wgpu::Features::SHADER_F16,
wgpu::Features::SUBGROUP,
]
}
fn desired_features_extended() -> Vec<wgpu::Features> {
vec![
wgpu::Features::SHADER_F64,
wgpu::Features::SHADER_F16,
wgpu::Features::TIMESTAMP_QUERY,
wgpu::Features::SUBGROUP,
]
}
fn negotiate_features(adapter: &wgpu::Adapter, wanted: &[wgpu::Features]) -> wgpu::Features {
let available = adapter.features();
let mut required = wgpu::Features::empty();
for &f in wanted {
if available.contains(f) {
required |= f;
}
}
required
}
fn score_physical_device(device: &super::super::registry::PhysicalDevice) -> u32 {
let mut score: u32 = match device.device_type {
wgpu::DeviceType::DiscreteGpu => 100,
wgpu::DeviceType::IntegratedGpu => 50,
wgpu::DeviceType::Cpu => 10,
_ => 5,
};
if device.capabilities.f64_shaders {
score += 30;
}
score
}
impl WgpuDevice {
fn install_error_handler(
device: &wgpu::Device,
lost_flag: &Arc<std::sync::atomic::AtomicBool>,
oom_flag: &Arc<std::sync::atomic::AtomicBool>,
) {
let lost = Arc::clone(lost_flag);
let oom = Arc::clone(oom_flag);
device.on_uncaptured_error(Arc::new(move |error: wgpu::Error| {
let msg = error.to_string();
if msg.contains("lost") || msg.contains("Lost") || msg.contains("Parent device") {
lost.store(true, std::sync::atomic::Ordering::Release);
tracing::warn!("GPU device lost (flagged for pool recovery): {msg}");
return;
}
let lower = msg.to_lowercase();
if lower.contains("out of memory")
|| lower.contains("allocation failed")
|| lower.contains("not enough memory")
{
oom.store(true, std::sync::atomic::Ordering::Release);
tracing::warn!("GPU OOM detected (flagged for pool migration): {msg}");
return;
}
tracing::warn!("wgpu uncaptured error (non-fatal): {msg}");
}));
}
fn make_pipeline_cache(_device: &wgpu::Device) -> Option<Arc<wgpu::PipelineCache>> {
None
}
fn assemble(device: wgpu::Device, queue: wgpu::Queue, adapter_info: wgpu::AdapterInfo) -> Self {
let lost = Arc::new(std::sync::atomic::AtomicBool::new(false));
let oom = Arc::new(std::sync::atomic::AtomicBool::new(false));
Self::install_error_handler(&device, &lost, &oom);
let pipeline_cache = Self::make_pipeline_cache(&device);
let budget = super::concurrency_budget(adapter_info.device_type);
let active_encoders = Arc::new(std::sync::atomic::AtomicU32::new(0));
let wgpu_device = Self {
device: super::GuardedDeviceHandle::new(device, active_encoders.clone()),
queue,
adapter_info,
calibration: None,
pipeline_cache,
lost,
oom,
gpu_lock: Arc::new(std::sync::Mutex::new(())),
active_encoders,
dispatch_semaphore: Arc::new(super::DispatchSemaphore::new(budget)),
quota_tracker: None,
};
probe::seed_cache_from_heuristics(&wgpu_device);
wgpu_device
}
pub async fn new() -> Result<Self> {
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..Default::default()
});
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
})
.await
.map_err(|e| BarracudaError::device(format!("No WGPU adapter found: {e}")))?;
Self::from_adapter(adapter).await
}
pub async fn new_gpu() -> Result<Self> {
Self::new_with_filter(wgpu::Backends::all(), |info| {
matches!(
info.device_type,
wgpu::DeviceType::DiscreteGpu | wgpu::DeviceType::IntegratedGpu
)
})
.await
.map_err(|e| BarracudaError::device(format!("No GPU adapter found: {e}")))
}
pub async fn new_cpu() -> Result<Self> {
Self::new_with_filter(wgpu::Backends::all(), |info| {
info.device_type == wgpu::DeviceType::Cpu
})
.await
.map_err(|e| BarracudaError::device(format!("No CPU software rasterizer: {e}")))
}
pub async fn new_cpu_relaxed() -> Result<Self> {
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..Default::default()
});
let adapters = instance.enumerate_adapters(wgpu::Backends::all()).await;
let adapter = adapters
.into_iter()
.find(|a| a.get_info().device_type == wgpu::DeviceType::Cpu)
.ok_or_else(|| BarracudaError::device("No CPU software rasterizer available"))?;
let adapter_info = adapter.get_info();
tracing::info!(
"barraCuda (cpu-relaxed): {} ({:?})",
adapter_info.name,
adapter_info.device_type
);
let required_features = negotiate_features(&adapter, &desired_features());
let creation_guard = DEVICE_CREATION_LOCK.lock().await;
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("barraCuda cpu-relaxed"),
required_features,
required_limits: wgpu::Limits::downlevel_defaults(),
memory_hints: Default::default(),
experimental_features: Default::default(),
trace: Default::default(),
})
.await
.map_err(|e| BarracudaError::device(format!("Failed to create CPU device: {e}")))?;
drop(creation_guard);
Ok(Self::assemble(device, queue, adapter_info))
}
pub async fn new_high_capacity() -> Result<Self> {
Self::new_with_limits(super::super::tensor_context::high_capacity_limits()).await
}
pub async fn new_with_limits(limits: wgpu::Limits) -> Result<Self> {
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..Default::default()
});
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
})
.await
.map_err(|e| BarracudaError::device(format!("No WGPU adapter found: {e}")))?;
let info = adapter.get_info();
tracing::info!(
"BarraCuda (custom-limits): {} ({:?})",
info.name,
info.device_type
);
let required_features = negotiate_features(&adapter, &desired_features_extended());
let creation_guard = DEVICE_CREATION_LOCK.lock().await;
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("BarraCuda custom-limits device"),
required_features,
required_limits: limits,
memory_hints: Default::default(),
experimental_features: Default::default(),
trace: Default::default(),
})
.await
.map_err(|e| BarracudaError::device(format!("Failed to create device: {e}")))?;
drop(creation_guard);
let actual_limits = device.limits();
tracing::info!(
"Limits: max_binding={}MB, max_buffer={}MB",
actual_limits.max_storage_buffer_binding_size / (1 << 20),
actual_limits.max_buffer_size / (1 << 20),
);
Ok(Self::assemble(device, queue, info))
}
pub async fn discover_best_adapter() -> Result<Self> {
if let Ok(selector) = std::env::var(ADAPTER_ENV_VAR)
&& !selector.is_empty()
&& selector.to_lowercase() != "auto"
{
tracing::info!("discover_best_adapter: env override → {selector}");
return Self::with_adapter_selector(&selector).await;
}
let registry = super::super::registry::DeviceRegistry::global();
let best = registry
.physical_devices()
.enumerate()
.map(|(idx, dev)| (idx, score_physical_device(dev)))
.max_by_key(|&(_, s)| s);
if let Some((idx, score)) = best {
tracing::info!("discover_best_adapter: physical device {idx} (score {score})");
Self::from_physical_device(idx).await
} else {
Self::new().await
}
}
pub async fn discover_primary_and_secondary_adapters() -> Result<(Self, Option<Self>)> {
let registry = super::super::registry::DeviceRegistry::global();
let mut scored: Vec<(usize, u32)> = registry
.physical_devices()
.enumerate()
.map(|(idx, dev)| (idx, score_physical_device(dev)))
.collect();
scored.sort_by_key(|entry| std::cmp::Reverse(entry.1));
let primary = if let Some((idx, _)) = scored.first() {
Self::from_physical_device(*idx).await?
} else {
Self::new().await?
};
let secondary = if scored.len() > 1 {
match Self::from_physical_device(scored[1].0).await {
Ok(dev) => Some(dev),
Err(e) => {
tracing::debug!("secondary adapter unavailable: {e}");
None
}
}
} else {
None
};
Ok((primary, secondary))
}
pub async fn enumerate_adapters() -> Vec<wgpu::AdapterInfo> {
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..Default::default()
});
instance
.enumerate_adapters(wgpu::Backends::all())
.await
.iter()
.map(wgpu::Adapter::get_info)
.collect()
}
#[must_use]
pub fn enumerate_physical_devices() -> Vec<super::super::registry::PhysicalDevice> {
super::super::registry::DeviceRegistry::global()
.physical_devices()
.cloned()
.collect()
}
#[must_use]
pub fn registry() -> &'static super::super::registry::DeviceRegistry {
super::super::registry::DeviceRegistry::global()
}
pub async fn from_physical_device(index: usize) -> Result<Self> {
let registry = super::super::registry::DeviceRegistry::global();
let adapter_index = registry.get_preferred_adapter_index(index).ok_or_else(|| {
BarracudaError::device(format!(
"Physical device index {} out of bounds (only {} devices available)",
index,
registry.device_count()
))
})?;
Self::from_adapter_index(adapter_index).await
}
pub async fn from_physical_device_with_backend(
device_index: usize,
backend: wgpu::Backend,
) -> Result<Self> {
let registry = super::super::registry::DeviceRegistry::global();
let adapter_index = registry
.get_adapter_for_backend(device_index, backend)
.ok_or_else(|| {
let device = registry.get_device(device_index);
let backends: Vec<_> = device
.map(|d| {
d.backends
.iter()
.map(|b| format!("{:?}", b.backend))
.collect()
})
.unwrap_or_default();
BarracudaError::device(format!(
"Backend {backend:?} not available for device {device_index} (available: {backends:?})"
))
})?;
Self::from_adapter_index(adapter_index).await
}
pub async fn new_f64_capable() -> Result<Self> {
let registry = super::super::registry::DeviceRegistry::global();
for (idx, device) in registry.physical_devices().enumerate() {
if device.capabilities.f64_shaders
&& matches!(
device.device_type,
wgpu::DeviceType::DiscreteGpu | wgpu::DeviceType::IntegratedGpu
)
{
return Self::from_physical_device(idx).await;
}
}
Err(BarracudaError::device(
"No f64-capable GPU found (NVIDIA Pascal+, AMD GCN+, or Intel required)",
))
}
pub async fn from_env() -> Result<Self> {
let selector = std::env::var(ADAPTER_ENV_VAR).unwrap_or_else(|_| "auto".to_string());
Self::with_adapter_selector(&selector).await
}
pub async fn with_adapter_selector(selector: &str) -> Result<Self> {
let selector = selector.trim().to_lowercase();
if selector == "auto" || selector.is_empty() {
tracing::info!("Adapter selection: auto (HighPerformance)");
return Self::new().await;
}
let adapters = Self::enumerate_adapters().await;
if adapters.is_empty() {
return Err(BarracudaError::device("No adapters available"));
}
if let Ok(index) = selector.parse::<usize>() {
if index < adapters.len() {
tracing::info!(
"Adapter selection: index {} → {}",
index,
adapters[index].name
);
return Self::from_adapter_index(index).await;
}
tracing::debug!(
"Adapter index {} out of bounds ({}), trying name match",
index,
adapters.len()
);
}
for (index, info) in adapters.iter().enumerate() {
if info.name.to_lowercase().contains(&selector) {
tracing::info!(
"Adapter selection: '{}' → {} (index {})",
selector,
info.name,
index
);
return Self::from_adapter_index(index).await;
}
}
let available: Vec<_> = adapters.iter().map(|a| a.name.as_str()).collect();
Err(BarracudaError::device(format!(
"No adapter matches '{selector}'. Available: {available:?}"
)))
}
pub async fn new_with_backend(backends: wgpu::Backends) -> Result<Self> {
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends,
..Default::default()
});
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
})
.await
.map_err(|e| {
BarracudaError::device(format!("No WGPU adapter found for requested backend: {e}"))
})?;
Self::from_adapter(adapter).await
}
pub async fn from_adapter_index(index: usize) -> Result<Self> {
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..Default::default()
});
let adapters: Vec<wgpu::Adapter> = instance.enumerate_adapters(wgpu::Backends::all()).await;
if index >= adapters.len() {
return Err(BarracudaError::device(format!(
"Adapter index {index} out of bounds (only {} adapters available)",
adapters.len()
)));
}
let adapter = &adapters[index];
let info = adapter.get_info();
tracing::info!(
"Selecting adapter {index}: {} ({:?})",
info.name,
info.device_type
);
let required_features = negotiate_features(adapter, &desired_features_extended());
let creation_guard = DEVICE_CREATION_LOCK.lock().await;
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("BarraCuda device"),
required_features,
required_limits: super::super::tensor_context::science_limits(),
memory_hints: Default::default(),
experimental_features: Default::default(),
trace: Default::default(),
})
.await
.map_err(|e| BarracudaError::device(format!("Failed to create device: {e}")))?;
drop(creation_guard);
Ok(Self::assemble(device, queue, info))
}
pub async fn new_with_filter<F>(backends: wgpu::Backends, filter: F) -> Result<Self>
where
F: Fn(&wgpu::AdapterInfo) -> bool,
{
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends,
..Default::default()
});
let adapters = instance.enumerate_adapters(backends).await;
if adapters.is_empty() {
return Err(BarracudaError::device(
"No WGPU adapters found (need GPU or CPU software rasterizer)",
));
}
let adapter = adapters
.into_iter()
.find(|a: &wgpu::Adapter| filter(&a.get_info()))
.ok_or_else(|| BarracudaError::device("No adapter matching requested hardware type"))?;
Self::from_adapter(adapter).await
}
async fn from_adapter(adapter: wgpu::Adapter) -> Result<Self> {
let adapter_info = adapter.get_info();
tracing::info!(
"barraCuda initialized: {} ({:?})",
adapter_info.name,
adapter_info.device_type
);
let required_features = negotiate_features(&adapter, &desired_features_extended());
if required_features.contains(wgpu::Features::SHADER_F64) {
tracing::info!(" SHADER_F64: enabled");
}
let creation_guard = DEVICE_CREATION_LOCK.lock().await;
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("barraCuda Device"),
required_features,
required_limits: super::super::tensor_context::science_limits(),
memory_hints: Default::default(),
experimental_features: Default::default(),
trace: Default::default(),
})
.await
.map_err(|e| BarracudaError::device(format!("Failed to create device: {e}")))?;
drop(creation_guard);
let wgpu_device = Self::assemble(device, queue, adapter_info);
if wgpu_device
.device
.features()
.contains(wgpu::Features::SHADER_F64)
{
let caps = probe::probe_f64_builtins(&wgpu_device).await;
if caps.can_compile_f64() {
tracing::info!("f64 probe: {}/{} builtins native", caps.native_count(), 9);
} else {
tracing::warn!(
"SHADER_F64 advertised but basic f64 probe FAILED — all f64 shaders will use DF64 fallback"
);
}
}
Ok(wgpu_device)
}
#[must_use]
pub fn from_existing(
device: wgpu::Device,
queue: wgpu::Queue,
adapter_info: wgpu::AdapterInfo,
) -> Self {
let lost = Arc::new(std::sync::atomic::AtomicBool::new(false));
let oom = Arc::new(std::sync::atomic::AtomicBool::new(false));
Self::install_error_handler(&device, &lost, &oom);
let pipeline_cache = Self::make_pipeline_cache(&device);
let budget = super::concurrency_budget(adapter_info.device_type);
let active_encoders = Arc::new(std::sync::atomic::AtomicU32::new(0));
let wgpu_device = Self {
device: super::GuardedDeviceHandle::new(device, active_encoders.clone()),
queue,
adapter_info,
calibration: None,
pipeline_cache,
lost,
oom,
gpu_lock: Arc::new(std::sync::Mutex::new(())),
active_encoders,
dispatch_semaphore: Arc::new(super::DispatchSemaphore::new(budget)),
quota_tracker: None,
};
probe::seed_cache_from_heuristics(&wgpu_device);
wgpu_device
}
}