mod buffers;
mod capabilities;
mod compilation;
mod creation;
mod dispatch;
mod guard;
mod submission;
pub(crate) use dispatch::{DispatchPermit, DispatchSemaphore, concurrency_budget};
pub use guard::{GuardedDeviceHandle, GuardedEncoder};
use super::autotune::{GLOBAL_TUNER, GpuCalibration, GpuDeviceForCalibration};
use crate::env_keys;
use crate::error::Result;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
pub(crate) fn poll_timeout() -> Option<Duration> {
static TIMEOUT: std::sync::LazyLock<Option<Duration>> = std::sync::LazyLock::new(|| {
let secs: u64 = std::env::var(env_keys::BARRACUDA_POLL_TIMEOUT_SECS)
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(120);
if secs == 0 {
None
} else {
Some(Duration::from_secs(secs))
}
});
*TIMEOUT
}
#[derive(Debug, Clone)]
pub struct WgpuDevice {
pub(crate) device: GuardedDeviceHandle,
pub(crate) queue: wgpu::Queue,
pub(crate) adapter_info: wgpu::AdapterInfo,
calibration: Option<GpuCalibration>,
pipeline_cache: Option<Arc<wgpu::PipelineCache>>,
pub(crate) lost: Arc<AtomicBool>,
pub(crate) oom: Arc<AtomicBool>,
gpu_lock: Arc<std::sync::Mutex<()>>,
active_encoders: Arc<std::sync::atomic::AtomicU32>,
dispatch_semaphore: Arc<DispatchSemaphore>,
quota_tracker: Option<Arc<crate::resource_quota::QuotaTracker>>,
}
impl GpuDeviceForCalibration for WgpuDevice {
fn device(&self) -> &wgpu::Device {
&self.device
}
fn name(&self) -> &str {
&self.adapter_info.name
}
fn submit_and_poll_calibration(&self, commands: impl IntoIterator<Item = wgpu::CommandBuffer>) {
self.submit_and_poll_inner(commands);
}
}
impl WgpuDevice {
#[must_use]
pub fn name(&self) -> &str {
&self.adapter_info.name
}
#[must_use]
pub fn device_type(&self) -> wgpu::DeviceType {
self.adapter_info.device_type
}
#[must_use]
pub fn is_cpu(&self) -> bool {
self.adapter_info.device_type == wgpu::DeviceType::Cpu
}
#[must_use]
pub fn is_lost(&self) -> bool {
self.lost.load(Ordering::Acquire)
}
#[must_use]
pub fn is_oom(&self) -> bool {
self.oom.load(Ordering::Acquire)
}
pub fn clear_oom(&self) {
self.oom.store(false, Ordering::Release);
}
pub fn set_oom(&self) {
self.oom.store(true, Ordering::Release);
}
pub fn set_quota_tracker(&mut self, tracker: Arc<crate::resource_quota::QuotaTracker>) {
self.quota_tracker = Some(tracker);
}
#[must_use]
pub fn quota_tracker(&self) -> Option<&Arc<crate::resource_quota::QuotaTracker>> {
self.quota_tracker.as_ref()
}
pub(crate) fn quota_try_allocate(&self, bytes: u64) -> Result<()> {
if let Some(tracker) = &self.quota_tracker {
tracker.try_allocate(bytes)?;
}
Ok(())
}
#[must_use]
pub fn has_f64_shaders(&self) -> bool {
if !self.device.features().contains(wgpu::Features::SHADER_F64) {
return false;
}
super::probe::cached_f64_builtins(self).is_none_or(|caps| caps.can_compile_f64())
}
#[must_use]
pub fn has_subgroups(&self) -> bool {
self.device.features().contains(wgpu::Features::SUBGROUP)
}
#[must_use]
pub fn has_spirv_passthrough(&self) -> bool {
self.adapter_info.backend == wgpu::Backend::Vulkan
}
#[must_use]
pub fn device(&self) -> &wgpu::Device {
&self.device
}
#[must_use]
pub fn device_clone(&self) -> wgpu::Device {
(*self.device).clone()
}
pub(crate) fn gpu_lock_arc(&self) -> Arc<std::sync::Mutex<()>> {
self.gpu_lock.clone()
}
pub(crate) fn active_encoders_arc(&self) -> Arc<std::sync::atomic::AtomicU32> {
self.active_encoders.clone()
}
pub fn encoding_guard(&self) {
self.active_encoders.fetch_add(1, Ordering::Acquire);
}
pub fn encoding_complete(&self) {
self.active_encoders.fetch_sub(1, Ordering::Release);
}
pub(crate) fn brief_encoder_wait(&self) {
for _ in 0..256 {
if self.active_encoders.load(Ordering::Acquire) == 0 {
return;
}
std::thread::yield_now();
}
}
#[must_use]
pub fn create_encoder_guarded(
&self,
desc: &wgpu::CommandEncoderDescriptor<'_>,
) -> GuardedEncoder {
self.active_encoders.fetch_add(1, Ordering::Acquire);
let encoder = self.device.create_command_encoder(desc);
GuardedEncoder::new(encoder, self.active_encoders.clone())
}
#[must_use]
pub fn adapter_info(&self) -> &wgpu::AdapterInfo {
&self.adapter_info
}
#[must_use]
pub fn pipeline_cache(&self) -> Option<&wgpu::PipelineCache> {
self.pipeline_cache.as_deref()
}
#[must_use]
pub fn queue(&self) -> &wgpu::Queue {
&self.queue
}
#[must_use]
pub fn queue_clone(&self) -> wgpu::Queue {
self.queue.clone()
}
#[must_use]
pub fn acquire_dispatch(&self) -> DispatchPermit<'_> {
self.dispatch_semaphore.acquire()
}
#[must_use]
pub fn max_concurrent_dispatches(&self) -> usize {
self.dispatch_semaphore.max_permits()
}
pub fn execute_compute(
&self,
shader_source: &str,
bind_groups: &[&wgpu::BindGroup],
workgroups: (u32, u32, u32),
) -> Result<()> {
let _permit = self.acquire_dispatch();
let commands = {
self.encoding_guard();
let shader = self.compile_shader(shader_source, Some("barraCuda Operation"));
let pipeline = self
.device
.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("barraCuda Pipeline"),
layout: None,
module: &shader,
entry_point: Some("main"),
cache: self.pipeline_cache(),
compilation_options: Default::default(),
});
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("barraCuda Encoder"),
});
{
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("barraCuda Compute"),
timestamp_writes: None,
});
pass.set_pipeline(&pipeline);
for (i, bg) in bind_groups.iter().enumerate() {
pass.set_bind_group(i as u32, Some(*bg), &[]);
}
pass.dispatch_workgroups(workgroups.0, workgroups.1, workgroups.2);
}
let cmds = encoder.finish();
self.encoding_complete();
cmds
};
self.submit_and_poll_inner(Some(commands));
Ok(())
}
pub fn get_calibration(&self) -> GpuCalibration {
GLOBAL_TUNER.get_or_calibrate(self)
}
pub fn recalibrate(&self) -> GpuCalibration {
GLOBAL_TUNER.recalibrate(self)
}
#[must_use]
pub fn optimal_workgroup_size(&self) -> u32 {
self.calibration.as_ref().map_or_else(
|| GLOBAL_TUNER.get_or_calibrate(self).optimal_workgroup_size,
|c| c.optimal_workgroup_size,
)
}
#[must_use]
pub fn peak_bandwidth_gbps(&self) -> f64 {
self.get_calibration().peak_bandwidth_gbps
}
#[must_use]
pub fn dispatch_overhead_us(&self) -> f64 {
self.get_calibration().dispatch_overhead_us
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_wgpu_device_creation() {
let Some(device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let _ = (device.name(), device.is_cpu());
}
#[tokio::test]
async fn test_enumerate_adapters() {
let adapters = WgpuDevice::enumerate_adapters().await;
assert!(
!adapters.is_empty(),
"WGPU should find at least one adapter"
);
}
#[tokio::test]
async fn test_buffer_operations() {
let Some(device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let buffer = device.create_buffer_f32(10).unwrap();
let data = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
device.write_buffer_f32(&buffer, &data).unwrap();
let read_data = device.read_buffer_f32(&buffer, 10).unwrap();
assert_eq!(read_data, data);
}
#[tokio::test]
async fn test_adapter_selector_auto() {
let _ = WgpuDevice::with_adapter_selector("auto").await;
}
#[tokio::test]
async fn test_adapter_selector_index() {
let adapters = WgpuDevice::enumerate_adapters().await;
if adapters.is_empty() {
return;
}
if let Ok(device) = WgpuDevice::with_adapter_selector("0").await {
assert_eq!(device.name(), adapters[0].name);
}
}
#[tokio::test]
async fn test_adapter_selector_name_match() {
let adapters = WgpuDevice::enumerate_adapters().await;
if adapters.is_empty() {
return;
}
let partial = adapters[0]
.name
.chars()
.take(4)
.collect::<String>()
.to_lowercase();
let _ = WgpuDevice::with_adapter_selector(&partial).await;
}
#[tokio::test]
async fn test_adapter_selector_fallthrough() {
let adapters = WgpuDevice::enumerate_adapters().await;
let large_index = (adapters.len() + 1000).to_string();
if let Err(e) = WgpuDevice::with_adapter_selector(&large_index).await {
assert!(e.to_string().contains("No adapter matches"));
}
}
#[tokio::test]
async fn test_from_env_default() {
let _ = WgpuDevice::with_adapter_selector("auto").await;
}
#[tokio::test]
async fn test_driver_detection_apis() {
let Some(device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let _ = device.is_nvk();
let _ = device.is_radv();
let _ = device.is_nvidia_proprietary();
}
#[test]
fn test_driver_detection_logic() {
fn contains_nvk_markers(driver: &str) -> bool {
let lower = driver.to_lowercase();
lower.contains("nvk") || lower.contains("nouveau") || lower.contains("mesa")
}
fn contains_radv_markers(driver: &str) -> bool {
driver.to_lowercase().contains("radv")
}
assert!(contains_nvk_markers("NVK"));
assert!(contains_nvk_markers("nouveau"));
assert!(!contains_nvk_markers("NVIDIA"));
assert!(contains_radv_markers("RADV"));
assert!(!contains_radv_markers("NVIDIA"));
}
}