#[cfg(feature = "cpu-shader")]
use crate::device::capabilities::WORKGROUP_SIZE_1D;
use crate::error::Result;
pub struct ShaderBinding<'a> {
pub group: u32,
pub binding: u32,
pub data: &'a mut [u8],
pub read_only: bool,
}
pub trait ShaderDispatch: Send + Sync {
fn dispatch_wgsl(
&self,
wgsl: &str,
entry: &str,
bindings: &mut [ShaderBinding<'_>],
workgroups: (u32, u32, u32),
) -> Result<()>;
fn substrate_name(&self) -> &'static str;
}
#[cfg(feature = "cpu-shader")]
pub struct CpuShaderDispatch;
#[cfg(feature = "cpu-shader")]
impl CpuShaderDispatch {
#[must_use]
pub fn new() -> Self {
Self
}
}
#[cfg(feature = "cpu-shader")]
impl Default for CpuShaderDispatch {
fn default() -> Self {
Self::new()
}
}
#[cfg(feature = "cpu-shader")]
impl ShaderDispatch for CpuShaderDispatch {
fn dispatch_wgsl(
&self,
wgsl: &str,
entry: &str,
bindings: &mut [ShaderBinding<'_>],
workgroups: (u32, u32, u32),
) -> Result<()> {
use barracuda_naga_exec::{NagaExecutor, SimBuffer, SimBufferUsage};
use std::collections::BTreeMap;
let executor = NagaExecutor::new(wgsl, entry)
.map_err(|e| crate::error::BarracudaError::device(format!("naga-exec: {e}")))?;
let mut sim_bindings: BTreeMap<(u32, u32), SimBuffer> = BTreeMap::new();
for b in bindings.iter() {
let usage = if b.read_only {
SimBufferUsage::StorageReadOnly
} else {
SimBufferUsage::Storage
};
sim_bindings.insert(
(b.group, b.binding),
SimBuffer {
data: b.data.to_vec(),
usage,
},
);
}
executor
.dispatch(workgroups, &mut sim_bindings)
.map_err(|e| {
crate::error::BarracudaError::device(format!("naga-exec dispatch: {e}"))
})?;
for b in bindings.iter_mut() {
if !b.read_only
&& let Some(sim) = sim_bindings.get(&(b.group, b.binding))
{
let copy_len = b.data.len().min(sim.data.len());
b.data[..copy_len].copy_from_slice(&sim.data[..copy_len]);
}
}
Ok(())
}
fn substrate_name(&self) -> &'static str {
"CPU (naga-exec)"
}
}
#[cfg(feature = "cpu-shader")]
pub fn shader_batch_unary_f64(wgsl: &str, entry: &str, input: &[f64]) -> Result<Vec<f64>> {
let dispatcher = CpuShaderDispatch::new();
let mut in_buf: Vec<u8> = input.iter().flat_map(|v| v.to_le_bytes()).collect();
let mut out_buf = vec![0u8; in_buf.len()];
let n = input.len() as u32;
let workgroups = (n.div_ceil(WORKGROUP_SIZE_1D), 1, 1);
let mut bindings = vec![
ShaderBinding {
group: 0,
binding: 0,
data: &mut in_buf,
read_only: true,
},
ShaderBinding {
group: 0,
binding: 1,
data: &mut out_buf,
read_only: false,
},
];
dispatcher.dispatch_wgsl(wgsl, entry, &mut bindings, workgroups)?;
Ok(out_buf
.chunks_exact(8)
.map(|c| f64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]]))
.collect())
}
#[cfg(feature = "cpu-shader")]
pub fn shader_batch_unary_f64_with_size(
wgsl: &str,
entry: &str,
input: &[f64],
) -> Result<Vec<f64>> {
let dispatcher = CpuShaderDispatch::new();
let mut in_buf: Vec<u8> = input.iter().flat_map(|v| v.to_le_bytes()).collect();
let mut out_buf = vec![0u8; in_buf.len()];
let n = input.len() as u32;
let workgroups = (n.div_ceil(WORKGROUP_SIZE_1D), 1, 1);
let mut meta_buf = vec![0u8; 16]; meta_buf[..4].copy_from_slice(&n.to_le_bytes());
let mut bindings = vec![
ShaderBinding {
group: 0,
binding: 0,
data: &mut in_buf,
read_only: true,
},
ShaderBinding {
group: 0,
binding: 1,
data: &mut out_buf,
read_only: false,
},
ShaderBinding {
group: 0,
binding: 2,
data: &mut meta_buf,
read_only: true,
},
];
dispatcher.dispatch_wgsl(wgsl, entry, &mut bindings, workgroups)?;
Ok(out_buf
.chunks_exact(8)
.map(|c| f64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]]))
.collect())
}
#[cfg(all(test, feature = "cpu-shader"))]
mod tests {
use super::*;
#[test]
fn cpu_shader_dispatch_elementwise_add() {
let dispatcher = CpuShaderDispatch::new();
let wgsl = r"
@group(0) @binding(0) var<storage, read> a: array<f32>;
@group(0) @binding(1) var<storage, read> b: array<f32>;
@group(0) @binding(2) var<storage, read_write> out: array<f32>;
@compute @workgroup_size(1)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
out[gid.x] = a[gid.x] + b[gid.x];
}
";
let a_data: Vec<u8> = [1.0f32, 2.0, 3.0, 4.0]
.iter()
.flat_map(|v| v.to_le_bytes())
.collect();
let b_data: Vec<u8> = [10.0f32, 20.0, 30.0, 40.0]
.iter()
.flat_map(|v| v.to_le_bytes())
.collect();
let mut out_data = vec![0u8; 16];
let mut a_buf = a_data;
let mut b_buf = b_data;
let mut bindings = vec![
ShaderBinding {
group: 0,
binding: 0,
data: &mut a_buf,
read_only: true,
},
ShaderBinding {
group: 0,
binding: 1,
data: &mut b_buf,
read_only: true,
},
ShaderBinding {
group: 0,
binding: 2,
data: &mut out_data,
read_only: false,
},
];
dispatcher
.dispatch_wgsl(wgsl, "main", &mut bindings, (4, 1, 1))
.unwrap();
let result: Vec<f32> = out_data
.chunks_exact(4)
.map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
.collect();
assert_eq!(result, vec![11.0, 22.0, 33.0, 44.0]);
}
#[test]
fn cpu_shader_dispatch_substrate_name() {
let d = CpuShaderDispatch::new();
assert_eq!(d.substrate_name(), "CPU (naga-exec)");
}
}