mod gpu_resident;
mod preconditioned;
use crate::device::WgpuDevice;
use crate::error::Result;
use crate::linalg::sparse::csr::CsrMatrix;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct CgGpuResult {
pub x: Vec<f64>,
pub iterations: usize,
pub residual: f64,
pub converged: bool,
}
impl CgGpuResult {
#[must_use]
pub fn is_ok(&self) -> bool {
self.converged
}
}
pub struct CgGpu;
impl CgGpu {
fn spmv_shader() -> &'static str {
include_str!("../../../shaders/sparse/spmv_f64.wgsl")
}
fn dot_reduce_shader() -> &'static str {
include_str!("../../../shaders/sparse/dot_reduce_f64.wgsl")
}
fn cg_kernels_shader() -> &'static str {
include_str!("../../../shaders/sparse/cg_kernels_f64.wgsl")
}
pub fn solve(
device: Arc<WgpuDevice>,
a: &CsrMatrix,
b: &[f64],
tol: f64,
max_iter: usize,
) -> Result<CgGpuResult> {
Self::solve_gpu_resident(device, a, b, tol, max_iter, 1)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linalg::sparse::csr::CsrMatrix;
fn create_spd_tridiagonal(n: usize) -> CsrMatrix {
let mut triplets = Vec::new();
for i in 0..n {
triplets.push((i, i, 4.0));
if i > 0 {
triplets.push((i, i - 1, -1.0));
}
if i < n - 1 {
triplets.push((i, i + 1, -1.0));
}
}
CsrMatrix::from_triplets(n, n, &triplets)
}
#[tokio::test]
async fn test_cg_gpu_small() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return; };
let a = create_spd_tridiagonal(3);
let b = vec![1.0, 2.0, 3.0];
let result = CgGpu::solve(device, &a, &b, 1e-10, 100).unwrap();
assert!(result.converged, "CG should converge");
assert!(result.residual < 1e-10, "Residual should be small");
let ax = a.matvec(&result.x).unwrap();
for (axi, bi) in ax.iter().zip(b.iter()) {
assert!((axi - bi).abs() < 1e-8, "Ax should equal b");
}
}
#[tokio::test]
async fn test_cg_gpu_resident() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return; };
let a = create_spd_tridiagonal(100);
let b: Vec<f64> = (0..100).map(|i| (i + 1) as f64).collect();
let result = CgGpu::solve_gpu_resident(device, &a, &b, 1e-10, 500, 10).unwrap();
assert!(result.converged, "GPU-resident CG should converge");
assert!(
result.residual < 1e-10,
"Residual should be small: {}",
result.residual
);
let ax = a.matvec(&result.x).unwrap();
for (i, (axi, bi)) in ax.iter().zip(b.iter()).enumerate() {
assert!(
(axi - bi).abs() < 1e-6,
"Ax[{i}] = {axi} should equal b[{i}] = {bi}"
);
}
}
#[tokio::test]
async fn test_cg_gpu_resident_vs_original() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return; };
let a = create_spd_tridiagonal(50);
let b: Vec<f64> = (0..50).map(|i| ((i + 1) as f64).sin()).collect();
let result_original = CgGpu::solve(device.clone(), &a, &b, 1e-10, 200).unwrap();
let result_resident = CgGpu::solve_gpu_resident(device, &a, &b, 1e-10, 200, 5).unwrap();
assert!(result_original.converged, "Original CG should converge");
assert!(result_resident.converged, "GPU-resident CG should converge");
for (i, (x_orig, x_res)) in result_original
.x
.iter()
.zip(result_resident.x.iter())
.enumerate()
{
assert!(
(x_orig - x_res).abs() < 1e-8,
"Solution mismatch at {i}: orig={x_orig}, resident={x_res}"
);
}
}
#[tokio::test]
async fn test_cg_gpu_preconditioned() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return; };
let a = create_spd_tridiagonal(100);
let b: Vec<f64> = (0..100).map(|i| (i + 1) as f64).collect();
let result = CgGpu::solve_preconditioned(device, &a, &b, 1e-10, 500, 10).unwrap();
assert!(result.converged, "Preconditioned CG should converge");
assert!(
result.residual < 1e-10,
"Residual should be small: {}",
result.residual
);
let ax = a.matvec(&result.x).unwrap();
for (i, (axi, bi)) in ax.iter().zip(b.iter()).enumerate() {
assert!(
(axi - bi).abs() < 1e-6,
"Ax[{i}] = {axi} should equal b[{i}] = {bi}"
);
}
}
#[tokio::test]
async fn test_cg_preconditioned_vs_unpreconditioned() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return; };
let a = create_spd_tridiagonal(100);
let b: Vec<f64> = (0..100).map(|i| (i + 1) as f64).collect();
let result_unprecond =
CgGpu::solve_gpu_resident(device.clone(), &a, &b, 1e-10, 500, 1).unwrap();
let result_precond = CgGpu::solve_preconditioned(device, &a, &b, 1e-10, 500, 1).unwrap();
assert!(
result_unprecond.converged,
"Unpreconditioned should converge"
);
assert!(result_precond.converged, "Preconditioned should converge");
assert!(
result_unprecond.iterations < 500,
"Unpreconditioned took too many iterations: {}",
result_unprecond.iterations
);
assert!(
result_precond.iterations < 500,
"Preconditioned took too many iterations: {}",
result_precond.iterations
);
for (i, (x_u, x_p)) in result_unprecond
.x
.iter()
.zip(result_precond.x.iter())
.enumerate()
{
assert!(
(x_u - x_p).abs() < 1e-6,
"Solution mismatch at {i}: unprecond={x_u}, precond={x_p}"
);
}
}
}