use crate::device::WgpuDevice;
use crate::error::{BarracudaError, Result};
use bytemuck;
use std::sync::Arc;
pub struct BatchedStatefulF64 {
device: Arc<WgpuDevice>,
state_a: wgpu::Buffer,
state_b: wgpu::Buffer,
current_is_a: bool,
n_cells: usize,
n_state_per_cell: usize,
}
impl BatchedStatefulF64 {
pub fn new(
device: Arc<WgpuDevice>,
n_cells: usize,
n_state_per_cell: usize,
initial_state: &[f64],
) -> Result<Self> {
let expected = n_cells * n_state_per_cell;
if initial_state.len() != expected {
return Err(BarracudaError::InvalidInput {
message: format!(
"initial_state length {} != n_cells({}) * n_state_per_cell({})",
initial_state.len(),
n_cells,
n_state_per_cell,
),
});
}
let bytes: &[u8] = bytemuck::cast_slice(initial_state);
let buf_usage = wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST;
let state_a = device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("BatchedStateful:A"),
contents: bytes,
usage: buf_usage,
});
let state_b = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("BatchedStateful:B"),
size: (expected * 8) as u64,
usage: buf_usage,
mapped_at_creation: false,
});
Ok(Self {
device,
state_a,
state_b,
current_is_a: true,
n_cells,
n_state_per_cell,
})
}
#[must_use]
pub fn state_in(&self) -> &wgpu::Buffer {
if self.current_is_a {
&self.state_a
} else {
&self.state_b
}
}
#[must_use]
pub fn state_out(&self) -> &wgpu::Buffer {
if self.current_is_a {
&self.state_b
} else {
&self.state_a
}
}
pub fn swap(&mut self) {
self.current_is_a = !self.current_is_a;
}
pub fn read_state(&self) -> Result<Vec<f64>> {
self.device
.read_f64_buffer(self.state_in(), self.n_cells * self.n_state_per_cell)
}
pub fn write_state(&self, state: &[f64]) -> Result<()> {
let expected = self.n_cells * self.n_state_per_cell;
if state.len() != expected {
return Err(BarracudaError::InvalidInput {
message: format!("state length {} != expected {expected}", state.len()),
});
}
let bytes: &[u8] = bytemuck::cast_slice(state);
self.device.queue.write_buffer(self.state_in(), 0, bytes);
Ok(())
}
#[must_use]
pub fn state_len(&self) -> usize {
self.n_cells * self.n_state_per_cell
}
#[must_use]
pub fn n_cells(&self) -> usize {
self.n_cells
}
#[must_use]
pub fn n_state_per_cell(&self) -> usize {
self.n_state_per_cell
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::device::test_pool::get_test_gpu_device;
#[tokio::test]
async fn test_batched_stateful_roundtrip() {
let Some(device) = get_test_gpu_device().await else {
return;
};
let initial = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
let stateful = BatchedStatefulF64::new(device, 3, 2, &initial).unwrap();
let readback = stateful.read_state().unwrap();
assert_eq!(readback.len(), 6);
for (i, (&got, &expected)) in readback.iter().zip(initial.iter()).enumerate() {
assert!(
(got - expected).abs() < 1e-15,
"state[{i}] = {got}, expected {expected}"
);
}
}
#[tokio::test]
async fn test_batched_stateful_swap() {
let Some(device) = get_test_gpu_device().await else {
return;
};
let initial = vec![10.0, 20.0];
let mut stateful = BatchedStatefulF64::new(device, 2, 1, &initial).unwrap();
assert!(std::ptr::eq(
stateful.state_in(),
&raw const stateful.state_a
));
assert!(std::ptr::eq(
stateful.state_out(),
&raw const stateful.state_b
));
stateful.swap();
assert!(std::ptr::eq(
stateful.state_in(),
&raw const stateful.state_b
));
assert!(std::ptr::eq(
stateful.state_out(),
&raw const stateful.state_a
));
}
#[tokio::test]
async fn test_batched_stateful_write() {
let Some(device) = get_test_gpu_device().await else {
return;
};
let initial = vec![0.0; 4];
let stateful = BatchedStatefulF64::new(device, 2, 2, &initial).unwrap();
let new_state = vec![7.0, 8.0, 9.0, 10.0];
stateful.write_state(&new_state).unwrap();
}
}