use super::{
Arc, WgpuDevice, get_test_device, get_test_device_for_shader_validation,
get_test_device_if_f64_gpu_available, get_test_device_if_gpu_available, get_test_device_sync,
tokio_block_on,
};
use crate::tensor::Tensor;
pub use crate::device::test_harness::{
ShaderValidationBackend, baseline_path, coral_available, coral_validation_available,
fused_ops_healthy, gpu_section, is_software_adapter, shader_validation_backend, with_coral,
};
pub async fn test_device() -> Arc<WgpuDevice> {
get_test_device().await
}
#[must_use]
pub fn test_device_blocking() -> Arc<WgpuDevice> {
get_test_device_sync()
}
pub async fn test_shader_device() -> Arc<WgpuDevice> {
get_test_device_for_shader_validation().await
}
pub async fn test_f64_shader_device() -> Option<Arc<WgpuDevice>> {
super::get_test_device_for_f64_shader_validation().await
}
pub async fn test_gpu_device() -> Option<Arc<WgpuDevice>> {
get_test_device_if_gpu_available().await
}
pub async fn test_f64_device() -> Option<Arc<WgpuDevice>> {
get_test_device_if_f64_gpu_available().await
}
pub async fn test_f64_transcendental_device() -> Option<Arc<WgpuDevice>> {
super::get_test_device_if_f64_transcendentals_available().await
}
pub async fn test_tensor(data: &[f32], shape: &[usize], device: &Arc<WgpuDevice>) -> Tensor {
Tensor::from_vec_on(data.to_vec(), shape.to_vec(), Arc::clone(device))
.await
.expect("Failed to create test tensor")
}
#[must_use]
pub fn test_tensor_blocking(data: &[f32], shape: &[usize], device: &Arc<WgpuDevice>) -> Tensor {
tokio_block_on(test_tensor(data, shape, device))
}
pub async fn test_zeros(shape: &[usize], device: &Arc<WgpuDevice>) -> Tensor {
Tensor::zeros_on(shape.to_vec(), Arc::clone(device))
.await
.expect("Failed to create zeros tensor")
}
pub async fn test_randn(shape: &[usize], device: &Arc<WgpuDevice>) -> Tensor {
use rand::Rng;
let size: usize = shape.iter().product();
let mut rng = rand::rng();
let mut data = Vec::with_capacity(size);
for _ in 0..(size / 2) {
let u1: f32 = rng.random::<f32>().max(1e-10);
let u2: f32 = rng.random();
let r = (-2.0 * u1.ln()).sqrt();
let theta = 2.0 * std::f32::consts::PI * u2;
data.push(r * theta.cos());
data.push(r * theta.sin());
}
if size % 2 == 1 {
let u1: f32 = rng.random::<f32>().max(1e-10);
let u2: f32 = rng.random();
data.push((-2.0 * u1.ln()).sqrt() * (2.0 * std::f32::consts::PI * u2).cos());
}
data.truncate(size);
Tensor::from_vec_on(data, shape.to_vec(), Arc::clone(device))
.await
.expect("Failed to create randn tensor")
}
pub async fn test_rand(shape: &[usize], device: &Arc<WgpuDevice>) -> Tensor {
use rand::Rng;
let size: usize = shape.iter().product();
let data: Vec<f32> = (0..size).map(|_| rand::rng().random()).collect();
Tensor::from_vec_on(data, shape.to_vec(), Arc::clone(device))
.await
.expect("Failed to create rand tensor")
}
#[cfg(test)]
#[macro_export]
macro_rules! assert_shader_math {
(
$wgsl:expr,
$entry:expr,
inputs: { $( ($ig:expr, $ib:expr) => $idata:expr ),* $(,)? },
outputs: { $( ($og:expr, $ob:expr) => $osize:expr ),* $(,)? },
expected: $expected:expr,
tolerance: $tol:expr
) => {{
use barracuda_naga_exec::{NagaExecutor, SimBuffer};
use std::collections::BTreeMap;
let exec = NagaExecutor::new($wgsl, $entry)
.expect("WGSL parse/validation failed in assert_shader_math!");
let mut bindings = BTreeMap::new();
$( bindings.insert(($ig, $ib), SimBuffer::from_f32_readonly($idata)); )*
$( bindings.insert(($og, $ob), SimBuffer::from_f32(&vec![0.0f32; $osize])); )*
let total_elements: usize = 0 $( + $osize )*;
exec.dispatch(
(total_elements.max(1) as u32, 1, 1),
&mut bindings,
)
.expect("NagaExecutor dispatch failed in assert_shader_math!");
let expected_slice: &[f32] = $expected;
let mut result_idx = 0usize;
$(
let result = bindings[&($og, $ob)].as_f32();
for (i, &val) in result.iter().enumerate() {
let exp = expected_slice[result_idx + i];
assert!(
(val - exp).abs() < $tol,
"shader math mismatch at output({}, {})[{}]: got {}, expected {}, tol={}",
$og, $ob, i, val, exp, $tol
);
}
result_idx += result.len();
)*
let _ = result_idx;
}};
}
#[cfg(test)]
#[macro_export]
macro_rules! assert_shader_math_f64 {
(
$wgsl:expr,
$entry:expr,
inputs: { $( ($ig:expr, $ib:expr) => $idata:expr ),* $(,)? },
outputs: { $( ($og:expr, $ob:expr) => $osize:expr ),* $(,)? },
expected: $expected:expr,
tolerance: $tol:expr
) => {{
use barracuda_naga_exec::{NagaExecutor, SimBuffer};
use std::collections::BTreeMap;
let exec = NagaExecutor::new($wgsl, $entry)
.expect("WGSL parse/validation failed in assert_shader_math_f64!");
let mut bindings = BTreeMap::new();
$( bindings.insert(($ig, $ib), SimBuffer::from_f64($idata)); )*
$( bindings.insert(($og, $ob), SimBuffer::from_f64(&vec![0.0f64; $osize])); )*
let total_elements: usize = 0 $( + $osize )*;
exec.dispatch(
(total_elements.max(1) as u32, 1, 1),
&mut bindings,
)
.expect("NagaExecutor dispatch failed in assert_shader_math_f64!");
let expected_slice: &[f64] = $expected;
let mut result_idx = 0usize;
$(
let result = bindings[&($og, $ob)].as_f64();
for (i, &val) in result.iter().enumerate() {
let exp = expected_slice[result_idx + i];
assert!(
(val - exp).abs() < $tol,
"f64 shader math mismatch at output({}, {})[{}]: got {}, expected {}, tol={}",
$og, $ob, i, val, exp, $tol
);
}
result_idx += result.len();
)*
let _ = result_idx;
}};
}
pub async fn with_device_retry<F, Fut>(f: F)
where
F: Fn(Arc<WgpuDevice>) -> Fut,
Fut: std::future::Future<Output = crate::error::Result<()>>,
{
let device = super::get_test_device_if_gpu_available().await;
let Some(device) = device else {
return;
};
let result = f(Arc::clone(&device)).await;
match result {
Ok(()) => {}
Err(e) if e.is_retriable() => {
tracing::warn!("test: retriable GPU error ({e}), retrying with fresh device");
drop(device);
let Some(fresh) = super::get_test_device_if_gpu_available().await else {
tracing::warn!("GPU unavailable on retry — skipping test");
return;
};
match f(fresh).await {
Ok(()) => {}
Err(e) if e.is_retriable() => {
tracing::warn!("test still failing after retry ({e}) — skipping on llvmpipe");
}
Err(e) => panic!("test failed on retry: {e}"),
}
}
Err(e) => panic!("test failed: {e}"),
}
}