pub(crate) mod buffer;
mod ops;
use buffer::TensorBuffer;
use crate::device::tensor_context::PooledBuffer;
use crate::device::{Auto, Device, WgpuDevice, WorkloadHint};
use crate::error::{BarracudaError, Result};
use std::sync::Arc;
pub struct Tensor {
buffer: TensorBuffer,
shape: Vec<usize>,
device: Arc<WgpuDevice>,
name: Option<String>,
}
impl Tensor {
#[must_use]
pub fn from_buffer(buffer: wgpu::Buffer, shape: Vec<usize>, device: Arc<WgpuDevice>) -> Self {
Self {
buffer: TensorBuffer::Owned(Arc::new(buffer)),
shape,
device,
name: None,
}
}
#[must_use]
pub fn from_arc_buffer(
buffer: Arc<wgpu::Buffer>,
shape: Vec<usize>,
device: Arc<WgpuDevice>,
) -> Self {
Self {
buffer: TensorBuffer::Owned(buffer),
shape,
device,
name: None,
}
}
#[must_use]
pub fn try_arc_buffer(&self) -> Option<Arc<wgpu::Buffer>> {
self.buffer.try_arc()
}
pub(crate) fn from_pooled_buffer(
buffer: PooledBuffer,
shape: Vec<usize>,
device: Arc<WgpuDevice>,
) -> Self {
Self {
buffer: TensorBuffer::Pooled(Arc::new(buffer)),
shape,
device,
name: None,
}
}
pub(crate) fn buffer(&self) -> &wgpu::Buffer {
self.buffer.as_ref()
}
#[must_use]
pub fn is_pooled(&self) -> bool {
matches!(self.buffer, TensorBuffer::Pooled(_))
}
#[must_use]
pub fn query_device(&self) -> Device {
match self.device.device_type() {
wgpu::DeviceType::DiscreteGpu | wgpu::DeviceType::IntegratedGpu => Device::GPU,
wgpu::DeviceType::VirtualGpu => Device::GPU,
wgpu::DeviceType::Cpu => Device::CPU,
wgpu::DeviceType::Other => Device::Auto,
}
}
#[must_use]
pub fn prefer_device(&self, _device: Device) -> Self {
tracing::debug!("Device preference noted; migration deferred (D-S18-003)");
self.clone()
}
#[must_use]
pub fn with_hint(&self, hint: WorkloadHint) -> Self {
let preferred_device = Device::select_for_workload(&hint);
tracing::debug!("Workload hint: {:?} → Device: {}", hint, preferred_device);
self.clone()
}
pub fn from_data(data: &[f32], shape: Vec<usize>, device: Arc<WgpuDevice>) -> Result<Self> {
Self::from_data_pod(data, shape, device)
}
pub fn from_data_pod<T: bytemuck::Pod>(
data: &[T],
shape: Vec<usize>,
device: Arc<WgpuDevice>,
) -> Result<Self> {
let label = format!(
"Tensor Data {}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_nanos()
);
let buffer = device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(&label),
contents: bytemuck::cast_slice(data),
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
});
Ok(Self {
buffer: TensorBuffer::Owned(Arc::new(buffer)),
shape,
device,
name: None,
})
}
#[must_use]
pub fn new(data: Vec<f32>, shape: Vec<usize>, device: Arc<WgpuDevice>) -> Self {
let buffer = if data.is_empty() {
device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Tensor Empty"),
size: 4, usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
})
} else {
device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Tensor"),
contents: bytemuck::cast_slice(&data),
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
})
};
Self {
buffer: TensorBuffer::Owned(Arc::new(buffer)),
shape,
device,
name: None,
}
}
}
impl Clone for Tensor {
fn clone(&self) -> Self {
Self {
buffer: self.buffer.clone(), shape: self.shape.clone(),
device: self.device.clone(),
name: self.name.clone(),
}
}
}
impl Tensor {
pub fn deep_clone(&self) -> Result<Self> {
let size = self.len();
let new_buffer = self.device.create_buffer_f32(size)?;
let mut encoder = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("Tensor Deep Clone Encoder"),
});
encoder.copy_buffer_to_buffer(
self.buffer(),
0,
&new_buffer,
0,
(size * std::mem::size_of::<f32>()) as u64,
);
self.device.submit_commands(Some(encoder.finish()));
Ok(Self {
buffer: TensorBuffer::Owned(Arc::new(new_buffer)),
shape: self.shape.clone(),
device: self.device.clone(),
name: self.name.clone(),
})
}
}
impl Tensor {
pub async fn from_vec(data: Vec<f32>, shape: Vec<usize>) -> Result<Self> {
let device = Auto::new_wgpu().await?;
Self::from_vec_on(data, shape, device).await
}
pub async fn from_vec_on(
data: Vec<f32>,
shape: Vec<usize>,
device: Arc<WgpuDevice>,
) -> Result<Self> {
Self::from_vec_on_sync(data, shape, device)
}
pub fn from_vec_on_sync(
data: Vec<f32>,
shape: Vec<usize>,
device: Arc<WgpuDevice>,
) -> Result<Self> {
let expected_size: usize = shape.iter().product();
if data.len() != expected_size {
return Err(BarracudaError::shape_mismatch(
vec![expected_size],
vec![data.len()],
));
}
let buffer = device.create_buffer_f32(data.len())?;
device.write_buffer_f32(&buffer, &data)?;
Ok(Self {
buffer: TensorBuffer::Owned(Arc::new(buffer)),
shape,
device,
name: None,
})
}
pub async fn zeros(shape: Vec<usize>) -> Result<Self> {
let device = Auto::new_wgpu().await?;
Self::zeros_on(shape, device).await
}
pub async fn zeros_on(shape: Vec<usize>, device: Arc<WgpuDevice>) -> Result<Self> {
let size: usize = shape.iter().product();
let data = vec![0.0; size];
Self::from_vec_on(data, shape, device).await
}
pub async fn ones(shape: Vec<usize>) -> Result<Self> {
let device = Auto::new_wgpu().await?;
Self::ones_on(shape, device).await
}
pub async fn ones_on(shape: Vec<usize>, device: Arc<WgpuDevice>) -> Result<Self> {
let size: usize = shape.iter().product();
let data = vec![1.0; size];
Self::from_vec_on(data, shape, device).await
}
#[must_use]
pub fn shape(&self) -> &[usize] {
&self.shape
}
#[must_use]
pub fn len(&self) -> usize {
self.shape.iter().product()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
#[must_use]
pub fn device(&self) -> &Arc<WgpuDevice> {
&self.device
}
#[must_use]
pub fn with_name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
#[must_use]
pub fn name(&self) -> Option<&str> {
self.name.as_deref()
}
pub fn to_vec(&self) -> Result<Vec<f32>> {
self.device.read_buffer_f32(self.buffer(), self.len())
}
pub fn to_vec_u32(&self) -> Result<Vec<u32>> {
self.device.read_buffer_u32(self.buffer(), self.len())
}
pub fn to_f64_vec(&self) -> Result<Vec<f64>> {
self.device.read_buffer_f64(self.buffer(), self.len())
}
pub fn from_f64_data(data: &[f64], shape: Vec<usize>, device: Arc<WgpuDevice>) -> Result<Self> {
Self::from_data_pod(data, shape, device)
}
pub async fn to_device(&self, target_device: Arc<WgpuDevice>) -> Result<Self> {
let data = self.to_vec()?;
Self::from_vec_on(data, self.shape.clone(), target_device).await
}
pub fn reshape(&self, new_shape: Vec<usize>) -> Result<Self> {
let old_size: usize = self.shape.iter().product();
let new_size: usize = new_shape.iter().product();
if old_size != new_size {
return Err(BarracudaError::shape_mismatch(
vec![new_size],
vec![old_size],
));
}
Ok(Self {
buffer: self.buffer.clone(), shape: new_shape,
device: self.device.clone(),
name: self.name.clone(),
})
}
}
impl std::fmt::Debug for Tensor {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Tensor")
.field("shape", &self.shape)
.field("device", &self.device.name())
.field("name", &self.name)
.field("len", &self.len())
.finish()
}
}
impl std::fmt::Display for Tensor {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"Tensor{:?} on {} ({})",
self.shape,
self.device.name(),
self.name.as_deref().unwrap_or("unnamed"),
)
}
}
#[cfg(test)]
#[path = "tensor_tests.rs"]
mod tests;