use crate::device::WgpuDevice;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::Result;
use bytemuck::{Pod, Zeroable};
use std::sync::Arc;
const SHADER: &str = include_str!("../shaders/special/tridiag_eigh_f64.wgsl");
const DEFAULT_MAX_ITER: u32 = 100;
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct TridiagParams {
n: u32,
n_batches: u32,
max_iter: u32,
_pad: u32,
}
#[derive(Debug, Clone)]
pub struct TridiagEighResult {
pub eigenvalues: Vec<f64>,
pub eigenvectors: Vec<f64>,
}
pub struct BatchedTridiagEighGpu {
device: Arc<WgpuDevice>,
}
impl BatchedTridiagEighGpu {
#[must_use]
pub fn new(device: Arc<WgpuDevice>) -> Self {
Self { device }
}
pub fn solve(
&self,
diagonals: &[f64],
subdiagonals: &[f64],
n: u32,
n_batches: u32,
) -> Result<TridiagEighResult> {
let params = TridiagParams {
n,
n_batches,
max_iter: DEFAULT_MAX_ITER,
_pad: 0,
};
let n_usize = n as usize;
let nb = n_batches as usize;
let diag_buf = self
.device
.create_buffer_f64_init("tridiag:diag", diagonals);
let subdiag_buf = self
.device
.create_buffer_f64_init("tridiag:subdiag", subdiagonals);
let eigvec_buf = self.device.create_buffer_f64(nb * n_usize * n_usize)?;
let params_buf = self.device.create_uniform_buffer("tridiag:params", ¶ms);
ComputeDispatch::new(&self.device, "tridiag_eigh")
.shader(SHADER, "main")
.f64()
.storage_rw(0, &diag_buf)
.storage_rw(1, &subdiag_buf)
.storage_rw(2, &eigvec_buf)
.uniform(3, ¶ms_buf)
.dispatch(n_batches, 1, 1)
.submit()?;
let eigenvalues = self.device.read_f64_buffer(&diag_buf, nb * n_usize)?;
let eigenvectors = self
.device
.read_f64_buffer(&eigvec_buf, nb * n_usize * n_usize)?;
Ok(TridiagEighResult {
eigenvalues,
eigenvectors,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn params_layout() {
assert_eq!(std::mem::size_of::<TridiagParams>(), 16);
}
#[test]
fn shader_source_valid() {
assert!(SHADER.contains("Wilkinson"));
assert!(SHADER.contains("eigvecs"));
assert!(SHADER.contains("Params"));
}
}