use crate::device::WgpuDevice;
use crate::device::capabilities::WORKGROUP_SIZE_1D;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
use std::sync::Arc;
pub struct QrGpu {
input: Tensor,
}
impl QrGpu {
#[must_use]
pub fn new(input: Tensor) -> Self {
Self { input }
}
fn wgsl_shader_f32() -> &'static str {
include_str!("../../shaders/linalg/qr_decomp.wgsl")
}
fn wgsl_shader_f64() -> &'static str {
include_str!("../../shaders/linalg/qr_decomp_f64.wgsl")
}
pub fn execute(self) -> Result<(Tensor, Vec<f32>)> {
let device = self.input.device();
let shape = self.input.shape();
if shape.len() != 2 {
return Err(BarracudaError::InvalidShape {
expected: vec![0, 0],
actual: shape.to_vec(),
});
}
let m = shape[0] as u32;
let n = shape[1] as u32;
let k_max = m.min(n);
let input_data = self.input.to_vec()?;
let a_buffer = device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("QR Matrix Buffer"),
contents: bytemuck::cast_slice(&input_data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
});
let v_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("QR Householder Vector"),
size: (m * 4) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let tau_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("QR Tau Buffer"),
size: (k_max * 4) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
for k in 0..k_max {
let params: [u32; 4] = [m, n, k, 0];
let params_buffer = device.create_uniform_buffer("QR Params", ¶ms);
let rows = m - k;
let sub_cols = n - k - 1;
let sub_rows = m - k;
ComputeDispatch::new(device, "qr_column_norm")
.shader(Self::wgsl_shader_f32(), "column_norm")
.uniform(0, ¶ms_buffer)
.storage_rw(1, &a_buffer)
.storage_rw(2, &v_buffer)
.storage_rw(3, &tau_buffer)
.dispatch(1, 1, 1)
.submit()?;
ComputeDispatch::new(device, "qr_compute_householder")
.shader(Self::wgsl_shader_f32(), "compute_householder")
.uniform(0, ¶ms_buffer)
.storage_rw(1, &a_buffer)
.storage_rw(2, &v_buffer)
.storage_rw(3, &tau_buffer)
.dispatch(rows.div_ceil(WORKGROUP_SIZE_1D), 1, 1)
.submit()?;
if sub_cols > 0 {
ComputeDispatch::new(device, "qr_apply_householder")
.shader(Self::wgsl_shader_f32(), "apply_householder")
.uniform(0, ¶ms_buffer)
.storage_rw(1, &a_buffer)
.storage_rw(2, &v_buffer)
.storage_rw(3, &tau_buffer)
.dispatch(sub_cols.div_ceil(16), sub_rows.div_ceil(16), 1)
.submit()?;
}
ComputeDispatch::new(device, "qr_update_column_k")
.shader(Self::wgsl_shader_f32(), "update_column_k")
.uniform(0, ¶ms_buffer)
.storage_rw(1, &a_buffer)
.storage_rw(2, &v_buffer)
.storage_rw(3, &tau_buffer)
.dispatch(rows.div_ceil(WORKGROUP_SIZE_1D), 1, 1)
.submit()?;
}
let r_data = device.read_buffer_f32(&a_buffer, (m * n) as usize)?;
let tau_data = device.read_buffer_f32(&tau_buffer, k_max as usize)?;
let r_buffer = device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("QR R Output"),
contents: bytemuck::cast_slice(&r_data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
});
let r_tensor = Tensor::from_buffer(r_buffer, shape.to_vec(), device.clone());
Ok((r_tensor, tau_data))
}
pub fn execute_f64(
device: Arc<WgpuDevice>,
data: &[f64],
m: usize,
n: usize,
) -> Result<(Vec<f64>, Vec<f64>)> {
if data.len() != m * n {
return Err(BarracudaError::InvalidInput {
message: format!(
"Expected {} elements for {}x{} matrix, got {}",
m * n,
m,
n,
data.len()
),
});
}
let mu = m as u32;
let nu = n as u32;
let k_max = mu.min(nu);
let a_buffer = Self::create_f64_buffer(&device, "QR A f64", data);
let v_buffer = Self::create_zero_f64_buffer(&device, "QR v f64", m);
let tau_buffer = Self::create_zero_f64_buffer(&device, "QR tau f64", k_max as usize);
let w_buffer = Self::create_zero_f64_buffer(&device, "QR w f64", n);
for k in 0..k_max {
let params: [u32; 4] = [mu, nu, k, 0];
let params_buffer = device.create_uniform_buffer("QR f64 Params", ¶ms);
let rows = mu - k;
let cols_remaining = nu.saturating_sub(k + 1);
ComputeDispatch::new(device.as_ref(), "qr_f64_column_norm")
.shader(Self::wgsl_shader_f64(), "column_norm")
.f64()
.uniform(0, ¶ms_buffer)
.storage_rw(1, &a_buffer)
.storage_rw(2, &v_buffer)
.storage_rw(3, &tau_buffer)
.dispatch(1, 1, 1)
.submit()?;
ComputeDispatch::new(device.as_ref(), "qr_f64_compute_householder")
.shader(Self::wgsl_shader_f64(), "compute_householder")
.f64()
.uniform(0, ¶ms_buffer)
.storage_read(1, &a_buffer)
.storage_rw(2, &v_buffer)
.storage_rw(3, &tau_buffer)
.storage_read(4, &v_buffer)
.dispatch(rows.div_ceil(WORKGROUP_SIZE_1D), 1, 1)
.submit()?;
if cols_remaining > 0 {
ComputeDispatch::new(device.as_ref(), "qr_f64_compute_vTA")
.shader(Self::wgsl_shader_f64(), "compute_vTA")
.f64()
.uniform(0, ¶ms_buffer)
.storage_read(1, &v_buffer)
.storage_rw(2, &a_buffer)
.storage_rw(3, &w_buffer)
.storage_read(4, &tau_buffer)
.dispatch(cols_remaining, 1, 1)
.submit()?;
ComputeDispatch::new(device.as_ref(), "qr_f64_apply_householder")
.shader(Self::wgsl_shader_f64(), "apply_householder")
.f64()
.uniform(0, ¶ms_buffer)
.storage_read(1, &v_buffer)
.storage_rw(2, &a_buffer)
.storage_rw(3, &w_buffer)
.storage_read(4, &tau_buffer)
.dispatch(cols_remaining.div_ceil(16), rows.div_ceil(16), 1)
.submit()?;
}
ComputeDispatch::new(device.as_ref(), "qr_f64_update_column_k")
.shader(Self::wgsl_shader_f64(), "update_column_k")
.f64()
.uniform(0, ¶ms_buffer)
.storage_read(1, &v_buffer)
.storage_rw(2, &a_buffer)
.storage_rw(3, &w_buffer)
.storage_read(4, &tau_buffer)
.dispatch(rows.div_ceil(WORKGROUP_SIZE_1D), 1, 1)
.submit()?;
}
let r_data = device.read_f64_buffer(&a_buffer, m * n)?;
let tau_data = device.read_f64_buffer(&tau_buffer, k_max as usize)?;
Ok((r_data, tau_data))
}
fn create_f64_buffer(device: &Arc<WgpuDevice>, label: &str, data: &[f64]) -> wgpu::Buffer {
let bytes: &[u8] = bytemuck::cast_slice(data);
device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(label),
contents: bytes,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
})
}
fn create_zero_f64_buffer(device: &Arc<WgpuDevice>, label: &str, count: usize) -> wgpu::Buffer {
device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: (count * 8) as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
const QR_F32_SHADER: &str = include_str!("../../shaders/linalg/qr_decomp.wgsl");
const QR_F64_SHADER: &str = include_str!("../../shaders/linalg/qr_decomp_f64.wgsl");
#[test]
fn qr_f32_shader_source_valid() {
assert!(!QR_F32_SHADER.is_empty());
assert!(QR_F32_SHADER.contains("fn ") || QR_F32_SHADER.contains("@compute"));
}
#[test]
fn qr_f64_shader_source_valid() {
assert!(!QR_F64_SHADER.is_empty());
assert!(QR_F64_SHADER.contains("fn ") || QR_F64_SHADER.contains("@compute"));
}
#[tokio::test]
async fn test_qr_gpu_identity() {
let device = crate::device::test_pool::get_test_device().await;
let a = vec![1.0f32, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
let input = Tensor::from_data(&a, vec![3, 3], device).unwrap();
let qr_gpu = QrGpu::new(input);
let (r_tensor, tau) = qr_gpu.execute().unwrap();
let r_data = r_tensor.to_vec().unwrap();
assert_eq!(r_data.len(), 9);
assert_eq!(tau.len(), 3);
}
#[tokio::test]
async fn test_qr_gpu_2x2() {
let device = crate::device::test_pool::get_test_device().await;
let a = vec![3.0f32, 4.0, 0.0, 5.0]; let input = Tensor::from_data(&a, vec![2, 2], device).unwrap();
let qr_gpu = QrGpu::new(input);
let (r_tensor, tau) = qr_gpu.execute().unwrap();
let r_data = r_tensor.to_vec().unwrap();
assert_eq!(r_data.len(), 4);
assert_eq!(tau.len(), 2);
}
}