use crate::device::WgpuDevice;
use crate::error::Result;
use crate::unified_hardware::{HardwareType, TensorStorage};
use crate::unified_math::{DType, TensorDescriptor};
use bytes::Bytes;
use std::sync::Arc;
pub(crate) struct GpuTensorStorage {
pub(crate) descriptor: TensorDescriptor,
pub(crate) device: Arc<WgpuDevice>,
pub(crate) buffer: Arc<wgpu::Buffer>,
}
impl GpuTensorStorage {
pub(crate) fn new(descriptor: TensorDescriptor, device: Arc<WgpuDevice>) -> Self {
let byte_size = (descriptor.numel * descriptor.dtype.size_bytes()) as u64;
let buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("GpuTensorStorage"),
size: byte_size.max(4), usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
Self {
descriptor,
device,
buffer: Arc::new(buffer),
}
}
pub(crate) fn from_tensor(tensor: &crate::tensor::Tensor, dtype: DType) -> Self {
let shape = tensor.shape().to_vec();
let numel: usize = shape.iter().product();
let desc = TensorDescriptor::new(shape, dtype);
if let Some(arc) = tensor.try_arc_buffer() {
Self {
descriptor: desc,
device: tensor.device().clone(),
buffer: arc,
}
} else {
let new = Self::new(desc, tensor.device().clone());
let byte_size = (numel * dtype.size_bytes()) as u64;
let mut enc = new
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("GpuTensorStorage copy"),
});
enc.copy_buffer_to_buffer(tensor.buffer(), 0, &new.buffer, 0, byte_size);
new.device.submit_commands(Some(enc.finish()));
new
}
}
}
impl TensorStorage for GpuTensorStorage {
fn descriptor(&self) -> &TensorDescriptor {
&self.descriptor
}
fn hardware_type(&self) -> HardwareType {
HardwareType::GPU
}
fn as_wgpu_buffer(&self) -> Option<Arc<wgpu::Buffer>> {
Some(self.buffer.clone())
}
fn read_to_cpu(
&self,
) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Bytes>> + Send + '_>> {
let device = self.device.clone();
let buffer = self.buffer.clone();
let numel = self.descriptor.numel;
let elem_size = self.descriptor.dtype.size_bytes();
Box::pin(async move {
let byte_size = (numel * elem_size) as u64;
let staging = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("GpuTensorStorage read staging"),
size: byte_size.max(4),
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = device.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("GpuTensorStorage read"),
});
encoder.copy_buffer_to_buffer(&buffer, 0, &staging, 0, byte_size);
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);
});
device.poll_safe()?;
rx.recv()
.map_err(|_| {
crate::error::BarracudaError::Gpu("map_async channel closed".to_string())
})?
.map_err(|e| {
crate::error::BarracudaError::Gpu(format!("Buffer map failed: {e:?}"))
})?;
let data = slice.get_mapped_range();
let bytes = Bytes::copy_from_slice(&data);
staging.unmap();
Ok(bytes)
})
}
fn write_from_cpu(
&mut self,
data: &[u8],
) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + '_>> {
let device = self.device.clone();
let buffer = self.buffer.clone();
let data = data.to_vec();
Box::pin(async move {
device.queue.write_buffer(&buffer, 0, &data);
Ok(())
})
}
}