pub mod batched_stateful;
pub mod gpu_view;
pub mod reduce;
pub mod stateful;
pub use gpu_view::{GpuView, GpuViewElement, GpuViewF32, GpuViewF64, GpuViewU32};
pub use reduce::ReduceScalarPipeline;
pub use stateful::{PipelineStage, StatefulPipeline, WaterBalanceState};
use crate::device::WgpuDevice;
use crate::error::{BarracudaError, Result};
use crate::utils::chunk_to_array;
use bytemuck;
use std::collections::HashMap;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct BufferSpec {
pub size: u64,
pub usage: wgpu::BufferUsages,
pub label: Option<String>,
}
impl BufferSpec {
#[must_use]
pub fn f64(count: usize) -> Self {
Self {
size: (count * 8) as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
label: None,
}
}
#[must_use]
pub fn f32(count: usize) -> Self {
Self {
size: (count * 4) as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
label: None,
}
}
#[must_use]
pub fn u32(count: usize) -> Self {
Self {
size: (count * 4) as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
label: None,
}
}
#[must_use]
pub fn bytes(size: u64) -> Self {
Self {
size,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
label: None,
}
}
#[must_use]
pub fn with_label(mut self, label: impl Into<String>) -> Self {
self.label = Some(label.into());
self
}
#[must_use]
pub fn with_uniform(mut self) -> Self {
self.usage |= wgpu::BufferUsages::UNIFORM;
self
}
}
pub struct Stage {
pub name: String,
pub pipeline: Arc<wgpu::ComputePipeline>,
pub bind_group_layout: Arc<wgpu::BindGroupLayout>,
pub inputs: Vec<String>,
pub outputs: Vec<String>,
pub workgroups: (u32, u32, u32),
}
impl Stage {
pub fn new(
name: impl Into<String>,
pipeline: Arc<wgpu::ComputePipeline>,
bind_group_layout: Arc<wgpu::BindGroupLayout>,
) -> Self {
Self {
name: name.into(),
pipeline,
bind_group_layout,
inputs: Vec::new(),
outputs: Vec::new(),
workgroups: (1, 1, 1),
}
}
#[must_use]
pub fn with_inputs(mut self, inputs: &[&str]) -> Self {
self.inputs = inputs
.iter()
.map(std::string::ToString::to_string)
.collect();
self
}
#[must_use]
pub fn with_outputs(mut self, outputs: &[&str]) -> Self {
self.outputs = outputs
.iter()
.map(std::string::ToString::to_string)
.collect();
self
}
#[must_use]
pub fn with_workgroups(mut self, x: u32, y: u32, z: u32) -> Self {
self.workgroups = (x, y, z);
self
}
}
struct CompiledStage {
name: String,
pipeline: Arc<wgpu::ComputePipeline>,
bind_group: wgpu::BindGroup,
workgroups: (u32, u32, u32),
}
pub struct PipelineBuilder {
device: Arc<WgpuDevice>,
buffer_specs: HashMap<String, BufferSpec>,
stages: Vec<Stage>,
}
impl PipelineBuilder {
#[must_use]
pub fn new(device: Arc<WgpuDevice>) -> Self {
Self {
device,
buffer_specs: HashMap::new(),
stages: Vec::new(),
}
}
#[must_use]
pub fn create_buffer(mut self, name: &str, spec: BufferSpec) -> Self {
self.buffer_specs.insert(name.to_string(), spec);
self
}
#[must_use]
pub fn add_stage(mut self, stage: Stage) -> Self {
self.stages.push(stage);
self
}
pub fn build(self) -> Result<ComputePipeline> {
let mut buffers = HashMap::new();
for (name, spec) in &self.buffer_specs {
let label = spec
.label
.clone()
.unwrap_or_else(|| format!("Pipeline:{name}"));
let buffer = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some(&label),
size: spec.size,
usage: spec.usage,
mapped_at_creation: false,
});
buffers.insert(name.clone(), Arc::new(buffer));
}
let mut compiled_stages = Vec::new();
for stage in self.stages {
for input in &stage.inputs {
if !buffers.contains_key(input) {
return Err(BarracudaError::InvalidInput {
message: format!(
"Stage '{}' references unknown input buffer '{}'",
stage.name, input
),
});
}
}
for output in &stage.outputs {
if !buffers.contains_key(output) {
return Err(BarracudaError::InvalidInput {
message: format!(
"Stage '{}' references unknown output buffer '{}'",
stage.name, output
),
});
}
}
let mut entries = Vec::new();
let mut binding = 0u32;
for input in &stage.inputs {
entries.push(wgpu::BindGroupEntry {
binding,
resource: buffers[input].as_entire_binding(),
});
binding += 1;
}
for output in &stage.outputs {
entries.push(wgpu::BindGroupEntry {
binding,
resource: buffers[output].as_entire_binding(),
});
binding += 1;
}
let bind_group = self
.device
.device
.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some(&format!("Pipeline:{}:BG", stage.name)),
layout: &stage.bind_group_layout,
entries: &entries,
});
compiled_stages.push(CompiledStage {
name: stage.name,
pipeline: stage.pipeline,
bind_group,
workgroups: stage.workgroups,
});
}
Ok(ComputePipeline {
device: self.device,
buffers,
stages: compiled_stages,
})
}
}
pub struct ComputePipeline {
device: Arc<WgpuDevice>,
buffers: HashMap<String, Arc<wgpu::Buffer>>,
stages: Vec<CompiledStage>,
}
impl ComputePipeline {
pub fn write_f64(&self, name: &str, data: &[f64]) -> Result<()> {
let buffer = self
.buffers
.get(name)
.ok_or_else(|| BarracudaError::InvalidInput {
message: format!("Unknown buffer: {name}"),
})?;
let bytes: &[u8] = bytemuck::cast_slice(data);
self.device.queue.write_buffer(buffer, 0, bytes);
Ok(())
}
pub fn write_f32(&self, name: &str, data: &[f32]) -> Result<()> {
let buffer = self
.buffers
.get(name)
.ok_or_else(|| BarracudaError::InvalidInput {
message: format!("Unknown buffer: {name}"),
})?;
let bytes: &[u8] = bytemuck::cast_slice(data);
self.device.queue.write_buffer(buffer, 0, bytes);
Ok(())
}
pub fn write_bytes(&self, name: &str, data: &[u8]) -> Result<()> {
let buffer = self
.buffers
.get(name)
.ok_or_else(|| BarracudaError::InvalidInput {
message: format!("Unknown buffer: {name}"),
})?;
self.device.queue.write_buffer(buffer, 0, data);
Ok(())
}
pub fn execute(&self) -> Result<()> {
let mut encoder = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("Pipeline Encoder"),
});
for stage in &self.stages {
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some(&stage.name),
timestamp_writes: None,
});
pass.set_pipeline(&stage.pipeline);
pass.set_bind_group(0, Some(&stage.bind_group), &[]);
pass.dispatch_workgroups(stage.workgroups.0, stage.workgroups.1, stage.workgroups.2);
}
self.device.submit_commands(Some(encoder.finish()));
Ok(())
}
pub fn read_f64(&self, name: &str) -> Result<Vec<f64>> {
let buffer = self
.buffers
.get(name)
.ok_or_else(|| BarracudaError::InvalidInput {
message: format!("Unknown buffer: {name}"),
})?;
let size = buffer.size() as usize;
let staging = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Pipeline Read Staging"),
size: size as u64,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("Pipeline Read"),
});
encoder.copy_buffer_to_buffer(buffer, 0, &staging, 0, size as u64);
self.device.submit_commands(Some(encoder.finish()));
let slice = staging.slice(..);
let (sender, receiver) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |result| {
let _ = sender.send(result);
});
self.device.poll_safe()?;
receiver
.recv()
.map_err(|_| BarracudaError::execution_failed("GPU buffer mapping channel closed"))?
.map_err(|e| BarracudaError::execution_failed(e.to_string()))?;
let data = slice.get_mapped_range();
let result: Vec<f64> = data
.chunks_exact(8)
.map(|chunk| chunk_to_array::<8>(chunk).map(f64::from_le_bytes))
.collect::<Result<Vec<_>>>()?;
drop(data);
staging.unmap();
Ok(result)
}
pub fn read_f32(&self, name: &str) -> Result<Vec<f32>> {
let buffer = self
.buffers
.get(name)
.ok_or_else(|| BarracudaError::InvalidInput {
message: format!("Unknown buffer: {name}"),
})?;
let size = buffer.size() as usize;
let staging = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Pipeline Read Staging"),
size: size as u64,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("Pipeline Read"),
});
encoder.copy_buffer_to_buffer(buffer, 0, &staging, 0, size as u64);
self.device.submit_commands(Some(encoder.finish()));
let slice = staging.slice(..);
let (sender, receiver) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |result| {
let _ = sender.send(result);
});
self.device.poll_safe()?;
receiver
.recv()
.map_err(|_| BarracudaError::execution_failed("GPU buffer mapping channel closed"))?
.map_err(|e| BarracudaError::execution_failed(e.to_string()))?;
let data = slice.get_mapped_range();
let result: Vec<f32> = data
.chunks_exact(4)
.map(|chunk| chunk_to_array::<4>(chunk).map(f32::from_le_bytes))
.collect::<Result<Vec<_>>>()?;
drop(data);
staging.unmap();
Ok(result)
}
#[must_use]
pub fn buffer(&self, name: &str) -> Option<&wgpu::Buffer> {
self.buffers.get(name).map(std::convert::AsRef::as_ref)
}
#[must_use]
pub fn stage_count(&self) -> usize {
self.stages.len()
}
#[must_use]
pub fn buffer_count(&self) -> usize {
self.buffers.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_buffer_spec_f64() {
let spec = BufferSpec::f64(100);
assert_eq!(spec.size, 800); }
#[test]
fn test_buffer_spec_f32() {
let spec = BufferSpec::f32(100);
assert_eq!(spec.size, 400); }
#[test]
fn test_buffer_spec_with_label() {
let spec = BufferSpec::f64(10).with_label("my_buffer");
assert_eq!(spec.label, Some("my_buffer".to_string()));
}
#[test]
fn test_buffer_spec_with_uniform() {
let spec = BufferSpec::f64(10).with_uniform();
assert!(spec.usage.contains(wgpu::BufferUsages::UNIFORM));
assert!(spec.usage.contains(wgpu::BufferUsages::STORAGE));
}
}