use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
pub struct Cholesky {
input: Tensor,
}
impl Cholesky {
#[must_use]
pub fn new(input: Tensor) -> Self {
Self { input }
}
fn wgsl_shader() -> &'static str {
include_str!("../../shaders/linalg/cholesky.wgsl")
}
fn wgsl_shader_f64() -> &'static str {
include_str!("../../shaders/linalg/cholesky_f64.wgsl")
}
pub fn execute(self) -> Result<Tensor> {
let device = self.input.device();
let shape = self.input.shape();
if shape.len() != 2 || shape[0] != shape[1] {
return Err(BarracudaError::InvalidShape {
expected: vec![0, 0],
actual: shape.to_vec(),
});
}
let n = shape[0];
let size = n * n;
let output_buffer = device.create_buffer_f32(size)?;
let params_buffer = device.create_uniform_buffer("Cholesky Params", &[n as u32]);
ComputeDispatch::new(device.as_ref(), "Cholesky")
.shader(Self::wgsl_shader(), "main")
.storage_read(0, self.input.buffer())
.storage_rw(1, &output_buffer)
.uniform(2, ¶ms_buffer)
.dispatch(1, 1, 1)
.submit()?;
Ok(Tensor::from_buffer(
output_buffer,
shape.to_vec(),
device.clone(),
))
}
pub fn execute_with_transpose(self) -> Result<(Tensor, Tensor)> {
let l = self.execute()?;
let l_t = l.transpose()?;
Ok((l, l_t))
}
}
pub struct CholeskyF64;
impl CholeskyF64 {
pub fn execute(
device: std::sync::Arc<crate::device::WgpuDevice>,
data: &[f64],
n: usize,
) -> Result<Vec<f64>> {
if data.len() != n * n {
return Err(BarracudaError::InvalidShape {
expected: vec![n * n],
actual: vec![data.len()],
});
}
let input_buffer = device.create_buffer_f64(n * n)?;
device
.queue
.write_buffer(&input_buffer, 0, bytemuck::cast_slice(data));
let output_buffer = device.create_buffer_f64(n * n)?;
let params_buffer = device.create_uniform_buffer("Cholesky F64 Params", &[n as u32]);
ComputeDispatch::new(device.as_ref(), "Cholesky F64")
.shader(Cholesky::wgsl_shader_f64(), "cholesky_f64")
.f64()
.storage_read(0, &input_buffer)
.storage_rw(1, &output_buffer)
.uniform(2, ¶ms_buffer)
.dispatch(1, 1, 1)
.submit()?;
crate::utils::read_buffer_f64(&device, &output_buffer, n * n)
}
pub fn execute_batch(
device: std::sync::Arc<crate::device::WgpuDevice>,
data: &[f64],
n: usize,
batch_size: usize,
) -> Result<Vec<f64>> {
let mat_size = n * n;
if data.len() != batch_size * mat_size {
return Err(BarracudaError::InvalidShape {
expected: vec![batch_size * mat_size],
actual: vec![data.len()],
});
}
let input_buffer = device.create_buffer_f64(batch_size * mat_size)?;
device
.queue
.write_buffer(&input_buffer, 0, bytemuck::cast_slice(data));
let output_buffer = device.create_buffer_f64(batch_size * mat_size)?;
let params_buffer = device.create_uniform_buffer("Cholesky F64 Batch Params", &[n as u32]);
ComputeDispatch::new(device.as_ref(), "Cholesky F64 Batch")
.shader(Cholesky::wgsl_shader_f64(), "cholesky_f64_batched")
.f64()
.storage_read(0, &input_buffer)
.storage_rw(1, &output_buffer)
.uniform(2, ¶ms_buffer)
.dispatch(batch_size as u32, 1, 1)
.submit()?;
crate::utils::read_buffer_f64(&device, &output_buffer, batch_size * mat_size)
}
}
impl Tensor {
pub fn cholesky(self) -> Result<Self> {
Cholesky::new(self).execute()
}
pub fn cholesky_with_transpose(self) -> Result<(Self, Self)> {
Cholesky::new(self).execute_with_transpose()
}
}
#[cfg(test)]
#[path = "cholesky_tests.rs"]
mod tests;