use crate::device::WgpuDevice;
use crate::error::{BarracudaError, Result};
use std::marker::PhantomData;
use std::sync::Arc;
pub struct GpuView<T: GpuViewElement> {
device: Arc<WgpuDevice>,
buffer: wgpu::Buffer,
len: usize,
_phantom: PhantomData<T>,
}
pub trait GpuViewElement: Copy + bytemuck::Pod {
const ELEMENT_SIZE: usize;
}
impl GpuViewElement for f64 {
const ELEMENT_SIZE: usize = 8;
}
impl GpuViewElement for f32 {
const ELEMENT_SIZE: usize = 4;
}
impl GpuViewElement for u32 {
const ELEMENT_SIZE: usize = 4;
}
impl GpuViewElement for i32 {
const ELEMENT_SIZE: usize = 4;
}
impl<T: GpuViewElement> GpuView<T> {
pub fn upload(device: Arc<WgpuDevice>, data: &[T]) -> Result<Self> {
if data.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "GpuView: cannot create from empty data".into(),
});
}
let buffer = device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("GpuView"),
contents: bytemuck::cast_slice(data),
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
});
Ok(Self {
device,
buffer,
len: data.len(),
_phantom: PhantomData,
})
}
pub fn uninit(device: Arc<WgpuDevice>, len: usize) -> Result<Self> {
if len == 0 {
return Err(BarracudaError::InvalidInput {
message: "GpuView: cannot create zero-length view".into(),
});
}
let buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("GpuView:uninit"),
size: (len * T::ELEMENT_SIZE) as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
Ok(Self {
device,
buffer,
len,
_phantom: PhantomData,
})
}
pub fn download(&self) -> Result<Vec<T>> {
let byte_size = (self.len * T::ELEMENT_SIZE) as u64;
let staging = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("GpuView:download:staging"),
size: byte_size,
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("GpuView:download"),
});
encoder.copy_buffer_to_buffer(&self.buffer, 0, &staging, 0, byte_size);
self.device.submit_commands(Some(encoder.finish()));
let slice = staging.slice(..);
let (tx, rx) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |r| {
let _ = tx.send(r);
});
self.device.poll_safe()?;
rx.recv()
.map_err(|_| BarracudaError::execution_failed("GpuView: staging channel closed"))?
.map_err(|e| BarracudaError::execution_failed(e.to_string()))?;
let data = slice.get_mapped_range();
let result: Vec<T> = bytemuck::cast_slice(&data).to_vec();
drop(data);
staging.unmap();
Ok(result)
}
pub fn upload_into(&self, data: &[T]) -> Result<()> {
if data.len() != self.len {
return Err(BarracudaError::InvalidInput {
message: format!(
"GpuView: upload_into length {} != view length {}",
data.len(),
self.len
),
});
}
self.device
.queue
.write_buffer(&self.buffer, 0, bytemuck::cast_slice(data));
Ok(())
}
#[must_use]
pub fn len(&self) -> usize {
self.len
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len == 0
}
#[must_use]
pub fn byte_size(&self) -> u64 {
(self.len * T::ELEMENT_SIZE) as u64
}
#[must_use]
pub fn buffer(&self) -> &wgpu::Buffer {
&self.buffer
}
#[must_use]
pub fn device(&self) -> &Arc<WgpuDevice> {
&self.device
}
}
pub type GpuViewF64 = GpuView<f64>;
pub type GpuViewF32 = GpuView<f32>;
pub type GpuViewU32 = GpuView<u32>;
impl GpuViewF64 {
pub fn mean_variance(&self, ddof: usize) -> Result<[f64; 2]> {
let var_op = crate::ops::variance_f64_wgsl::VarianceF64::new(Arc::clone(&self.device))?;
let data = self.download()?;
var_op.mean_variance(&data, ddof)
}
pub fn sum(&self) -> Result<f64> {
let data = self.download()?;
crate::ops::sum_reduce_f64::SumReduceF64::sum(Arc::clone(&self.device), &data)
}
pub fn correlation(a: &Self, b: &Self) -> Result<f64> {
if a.len() != b.len() {
return Err(BarracudaError::InvalidInput {
message: format!(
"GpuView::correlation: length mismatch ({} vs {})",
a.len(),
b.len()
),
});
}
let data_a = a.download()?;
let data_b = b.download()?;
let corr = crate::ops::correlation_f64_wgsl::CorrelationF64::new(Arc::clone(&a.device))?;
corr.correlation(&data_a, &data_b)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::device::test_pool::get_test_gpu_device;
#[tokio::test]
async fn test_gpu_view_upload_download_roundtrip() {
let Some(device) = get_test_gpu_device().await else {
return;
};
let data = vec![1.0_f64, 2.0, 3.0, 4.0, 5.0];
let view = GpuViewF64::upload(device, &data).unwrap();
assert_eq!(view.len(), 5);
let result = view.download().unwrap();
for (i, (&got, &expected)) in result.iter().zip(data.iter()).enumerate() {
assert!(
(got - expected).abs() < 1e-15,
"element[{i}] = {got}, expected {expected}"
);
}
}
#[tokio::test]
async fn test_gpu_view_upload_into() {
let Some(device) = get_test_gpu_device().await else {
return;
};
let initial = vec![0.0_f64; 4];
let view = GpuViewF64::upload(Arc::clone(&device), &initial).unwrap();
let new_data = vec![7.0, 8.0, 9.0, 10.0];
view.upload_into(&new_data).unwrap();
let result = view.download().unwrap();
assert_eq!(result, new_data);
}
#[tokio::test]
async fn test_gpu_view_uninit() {
let Some(device) = get_test_gpu_device().await else {
return;
};
let view = GpuViewF64::uninit(device, 100).unwrap();
assert_eq!(view.len(), 100);
assert_eq!(view.byte_size(), 800);
}
#[tokio::test]
async fn test_gpu_view_f32() {
let Some(device) = get_test_gpu_device().await else {
return;
};
let data = vec![1.0_f32, 2.0, 3.0];
let view = GpuViewF32::upload(device, &data).unwrap();
let result = view.download().unwrap();
assert_eq!(result, data);
}
#[test]
fn test_gpu_view_element_sizes() {
assert_eq!(f64::ELEMENT_SIZE, 8);
assert_eq!(f32::ELEMENT_SIZE, 4);
assert_eq!(u32::ELEMENT_SIZE, 4);
}
}