From 6f647a6dd1918a9ae763d9e56b8be49b1e20bc03 Mon Sep 17 00:00:00 2001 From: Achintya Sunil Date: Wed, 22 Oct 2025 10:53:40 -0400 Subject: [PATCH 1/9] Zero norm breakdown handling --- resolve/GramSchmidt.cpp | 12 ++++++------ resolve/LinSolverIterativeFGMRES.cpp | 11 +++++++++-- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/resolve/GramSchmidt.cpp b/resolve/GramSchmidt.cpp index 18b702771..5f76a3adb 100644 --- a/resolve/GramSchmidt.cpp +++ b/resolve/GramSchmidt.cpp @@ -172,7 +172,7 @@ namespace ReSolve } else { - assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + //assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; @@ -222,7 +222,7 @@ namespace ReSolve } else { - assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + //assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; @@ -279,7 +279,7 @@ namespace ReSolve } else { - assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + //assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); return 1; } h_rv = nullptr; @@ -364,7 +364,7 @@ namespace ReSolve } else { - assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + //assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); return 1; } h_rv = nullptr; @@ -395,13 +395,13 @@ namespace ReSolve } else { - assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + //assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; default: - assert(0 && "Iterative refinement failed, wrong orthogonalization.\n"); + //assert(0 && "Iterative refinement failed, wrong orthogonalization.\n"); return 1; } // switch diff --git a/resolve/LinSolverIterativeFGMRES.cpp b/resolve/LinSolverIterativeFGMRES.cpp index 643f23a46..24a923988 100644 --- a/resolve/LinSolverIterativeFGMRES.cpp +++ b/resolve/LinSolverIterativeFGMRES.cpp @@ -202,12 +202,19 @@ namespace ReSolve // V_{i+1}=A*Z_i vec_v.setData(vec_V_->getData(i + 1, memspace_), memspace_); - + vec_v.setToZero(memspace_); matrix_handler_->matvec(A_, &vec_z, &vec_v, &ONE, &ZERO, memspace_); // orthogonalize V[i+1], form a column of h_H_ - GS_->orthogonalize(n_, vec_V_, h_H_, i); + int gs_status = GS_->orthogonalize(n_, vec_V_, h_H_, i); + + if (gs_status != 0) // checking for successful breakdown + { + notconv = 0; // exiting outer loop + break; + } + if (i != 0) { for (index_type k = 1; k <= i; k++) From 8ddafaf7cc37a43fbcf4f92484f0c041a52c5e16 Mon Sep 17 00:00:00 2001 From: Achintya Sunil Date: Fri, 24 Oct 2025 10:05:46 -0400 Subject: [PATCH 2/9] Computes updated for Ax = b when residual norm is below RHS --- resolve/LinSolverIterativeFGMRES.cpp | 90 ++++++++++++++++++++++++---- resolve/LinSolverIterativeFGMRES.hpp | 2 + 2 files changed, 81 insertions(+), 11 deletions(-) diff --git a/resolve/LinSolverIterativeFGMRES.cpp b/resolve/LinSolverIterativeFGMRES.cpp index 24a923988..b2af7c57a 100644 --- a/resolve/LinSolverIterativeFGMRES.cpp +++ b/resolve/LinSolverIterativeFGMRES.cpp @@ -109,6 +109,7 @@ namespace ReSolve // io::Logger::setVerbosity(io::Logger::EVERYTHING); int outer_flag = 1; + int update_flag= 1; int notconv = 1; int i = 0; int it = 0; @@ -120,25 +121,52 @@ namespace ReSolve real_type rnorm = 0.0; real_type bnorm = 0.0; real_type tolrel; + real_type rhsnorm = 0.0; vector_type vec_v(n_); vector_type vec_z(n_); + + // Compute the residual + vec_R_->setToZero(memspace_); + vec_R_->copyDataFrom(rhs, memspace_, memspace_); + matrix_handler_->matvec(A_, x, vec_R_, &MINUS_ONE, &ONE, memspace_); + + // Arnoldi Basis + vec_Z_->setToZero(memspace_); + vec_V_->setToZero(memspace_); + + // Initializing Residual and Update + vec_Y_->setToZero(memspace_); + // V[0] = b-A*x_0 // debug vec_Z_->setToZero(memspace_); vec_V_->setToZero(memspace_); - rhs->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); - matrix_handler_->matvec(A_, x, vec_V_, &MINUS_ONE, &ONE, memspace_); + // Computing the first Arnodi basis vector + vec_R_->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); rnorm = 0.0; - bnorm = vector_handler_->dot(rhs, rhs, memspace_); + bnorm = vector_handler_->dot(vec_R_, vec_R_, memspace_); rnorm = vector_handler_->dot(vec_V_, vec_V_, memspace_); - // rnorm = ||V_1|| rnorm = std::sqrt(rnorm); + + // Checking if rnorm > norm of RHS + rhsnorm = vector_handler_->dot(rhs, rhs, memspace_); + rhsnorm = std::sqrt(rhsnorm); + if (rnorm > rhsnorm) + { + std::cout << "Initial guess is invalid. Refining Ax = b instead of Ay = r" << std::endl; + vec_Y_->copyDataFrom(x, memspace_, memspace_); + vec_R_->copyDataFrom(rhs, memspace_, memspace_); + update_flag = 0; + } + bnorm = std::sqrt(bnorm); io::Logger::misc() << "it 0: norm of residual " << std::scientific << std::setprecision(16) << rnorm << " Norm of rhs: " << bnorm << "\n"; initial_residual_norm_ = rnorm; + + while (outer_flag) { if (it == 0) @@ -169,6 +197,7 @@ namespace ReSolve outer_flag = 0; final_residual_norm_ = rnorm; initial_residual_norm_ = rnorm; + update_flag = 1; total_iters_ = 0; break; } @@ -278,7 +307,7 @@ namespace ReSolve for (j = 0; j <= i; j++) { vec_z.setData(vec_Z_->getData(j, memspace_), memspace_); - vector_handler_->axpy(&h_rs_[j], &vec_z, x, memspace_); + vector_handler_->axpy(&h_rs_[j], &vec_z, vec_Y_, memspace_); } } else @@ -294,11 +323,11 @@ namespace ReSolve vec_v.setData(vec_V_->getData(memspace_), memspace_); this->precV(&vec_z, &vec_v); - // and add to x - vector_handler_->axpy(&ONE, &vec_v, x, memspace_); + // and add to update + vector_handler_->axpy(&ONE, &vec_v, vec_Y_, memspace_); } - /* test solution */ + /* test update */ if (rnorm <= tolrel || it >= maxit_) { @@ -306,8 +335,8 @@ namespace ReSolve outer_flag = 0; } - rhs->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); - matrix_handler_->matvec(A_, x, vec_V_, &MINUS_ONE, &ONE, memspace_); + vec_R_->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); + matrix_handler_->matvec(A_, vec_Y_, vec_V_, &MINUS_ONE, &ONE, memspace_); rnorm = vector_handler_->dot(vec_V_, vec_V_, memspace_); // rnorm = ||V_1|| rnorm = std::sqrt(rnorm); @@ -321,7 +350,37 @@ namespace ReSolve << rnorm << "\n"; } } // outer while - return 0; + + if (update_flag) + { + vector_handler_->axpy(&ONE, x, vec_Y_, memspace_); + vec_R_->copyDataFrom(rhs, memspace_, memspace_); + matrix_handler_->matvec(A_, vec_Y_, vec_R_, &MINUS_ONE, &ONE, memspace_); + final_residual_norm_ = vector_handler_->dot(vec_R_, vec_R_, memspace_); + final_residual_norm_ = std::sqrt(final_residual_norm_); + + // Compare this with initial and update x accordingly + if (final_residual_norm_ < initial_residual_norm_) + { + std::cout << "Update to intial guess is successful, final residual (solution plus update) " + << std::scientific << std::setprecision(16) + << final_residual_norm_/rhsnorm << "\n"; + + x->copyDataFrom(vec_Y_, memspace_, memspace_); + } + else + { + std::cout << "Update to intial guess is not successful, final residual greater than initial residual " + << std::scientific << std::setprecision(16) + << final_residual_norm_/rhsnorm << "\n"; + } + } + else + { + x->copyDataFrom(vec_Y_, memspace_, memspace_); + } + + return 0; } int LinSolverIterativeFGMRES::setupPreconditioner(std::string type, LinSolverDirect* LU_solver) @@ -566,6 +625,11 @@ namespace ReSolve { vec_V_ = new vector_type(n_, restart_ + 1); vec_V_->allocate(memspace_); + vec_Y_ = new vector_type(n_); + vec_Y_->allocate(memspace_); + vec_R_ = new vector_type(n_); + vec_R_->allocate(memspace_); + if (flexible_) { vec_Z_ = new vector_type(n_, restart_ + 1); @@ -592,6 +656,8 @@ namespace ReSolve delete[] h_rs_; delete vec_V_; delete vec_Z_; + delete vec_R_; + delete vec_Y_; h_H_ = nullptr; h_c_ = nullptr; @@ -599,6 +665,8 @@ namespace ReSolve h_rs_ = nullptr; vec_V_ = nullptr; vec_Z_ = nullptr; + vec_Y_ = nullptr; + vec_R_ = nullptr; return 0; } diff --git a/resolve/LinSolverIterativeFGMRES.hpp b/resolve/LinSolverIterativeFGMRES.hpp index 388875793..7461959a4 100644 --- a/resolve/LinSolverIterativeFGMRES.hpp +++ b/resolve/LinSolverIterativeFGMRES.hpp @@ -97,6 +97,8 @@ namespace ReSolve vector_type* vec_V_{nullptr}; vector_type* vec_Z_{nullptr}; + vector_type* vec_R_{nullptr}; + vector_type* vec_Y_{nullptr}; real_type* h_H_{nullptr}; real_type* h_c_{nullptr}; From 87d7f562705677c183e9935ee393b5f34c8dbbd4 Mon Sep 17 00:00:00 2001 From: ASunil-17 Date: Fri, 24 Oct 2025 14:26:07 +0000 Subject: [PATCH 3/9] Apply pre-commmit fixes --- resolve/GramSchmidt.cpp | 12 +++---- resolve/LinSolverIterativeFGMRES.cpp | 53 ++++++++++++++-------------- 2 files changed, 32 insertions(+), 33 deletions(-) diff --git a/resolve/GramSchmidt.cpp b/resolve/GramSchmidt.cpp index 5f76a3adb..430dde240 100644 --- a/resolve/GramSchmidt.cpp +++ b/resolve/GramSchmidt.cpp @@ -172,7 +172,7 @@ namespace ReSolve } else { - //assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + // assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; @@ -222,7 +222,7 @@ namespace ReSolve } else { - //assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + // assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; @@ -279,7 +279,7 @@ namespace ReSolve } else { - //assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + // assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); return 1; } h_rv = nullptr; @@ -364,7 +364,7 @@ namespace ReSolve } else { - //assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + // assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); return 1; } h_rv = nullptr; @@ -395,13 +395,13 @@ namespace ReSolve } else { - //assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + // assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; default: - //assert(0 && "Iterative refinement failed, wrong orthogonalization.\n"); + // assert(0 && "Iterative refinement failed, wrong orthogonalization.\n"); return 1; } // switch diff --git a/resolve/LinSolverIterativeFGMRES.cpp b/resolve/LinSolverIterativeFGMRES.cpp index b2af7c57a..929e90022 100644 --- a/resolve/LinSolverIterativeFGMRES.cpp +++ b/resolve/LinSolverIterativeFGMRES.cpp @@ -108,14 +108,14 @@ namespace ReSolve // io::Logger::setVerbosity(io::Logger::EVERYTHING); - int outer_flag = 1; - int update_flag= 1; - int notconv = 1; - int i = 0; - int it = 0; - int j = 0; - int k = 0; - int k1 = 0; + int outer_flag = 1; + int update_flag = 1; + int notconv = 1; + int i = 0; + int it = 0; + int j = 0; + int k = 0; + int k1 = 0; real_type t = 0.0; real_type rnorm = 0.0; @@ -166,7 +166,6 @@ namespace ReSolve << rnorm << " Norm of rhs: " << bnorm << "\n"; initial_residual_norm_ = rnorm; - while (outer_flag) { if (it == 0) @@ -197,7 +196,7 @@ namespace ReSolve outer_flag = 0; final_residual_norm_ = rnorm; initial_residual_norm_ = rnorm; - update_flag = 1; + update_flag = 1; total_iters_ = 0; break; } @@ -238,11 +237,11 @@ namespace ReSolve int gs_status = GS_->orthogonalize(n_, vec_V_, h_H_, i); - if (gs_status != 0) // checking for successful breakdown + if (gs_status != 0) // checking for successful breakdown { - notconv = 0; // exiting outer loop - break; - } + notconv = 0; // exiting outer loop + break; + } if (i != 0) { @@ -351,8 +350,8 @@ namespace ReSolve } } // outer while - if (update_flag) - { + if (update_flag) + { vector_handler_->axpy(&ONE, x, vec_Y_, memspace_); vec_R_->copyDataFrom(rhs, memspace_, memspace_); matrix_handler_->matvec(A_, vec_Y_, vec_R_, &MINUS_ONE, &ONE, memspace_); @@ -363,24 +362,24 @@ namespace ReSolve if (final_residual_norm_ < initial_residual_norm_) { std::cout << "Update to intial guess is successful, final residual (solution plus update) " - << std::scientific << std::setprecision(16) - << final_residual_norm_/rhsnorm << "\n"; + << std::scientific << std::setprecision(16) + << final_residual_norm_ / rhsnorm << "\n"; x->copyDataFrom(vec_Y_, memspace_, memspace_); } else { - std::cout << "Update to intial guess is not successful, final residual greater than initial residual " - << std::scientific << std::setprecision(16) - << final_residual_norm_/rhsnorm << "\n"; + std::cout << "Update to intial guess is not successful, final residual greater than initial residual " + << std::scientific << std::setprecision(16) + << final_residual_norm_ / rhsnorm << "\n"; } - } - else - { - x->copyDataFrom(vec_Y_, memspace_, memspace_); - } + } + else + { + x->copyDataFrom(vec_Y_, memspace_, memspace_); + } - return 0; + return 0; } int LinSolverIterativeFGMRES::setupPreconditioner(std::string type, LinSolverDirect* LU_solver) From 242fbf733fa02c7e0ddd575f3cf6d8087d38dff7 Mon Sep 17 00:00:00 2001 From: Achintya Sunil Date: Fri, 24 Oct 2025 10:20:27 -0400 Subject: [PATCH 4/9] restoring GS --- resolve/GramSchmidt.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/resolve/GramSchmidt.cpp b/resolve/GramSchmidt.cpp index 430dde240..18b702771 100644 --- a/resolve/GramSchmidt.cpp +++ b/resolve/GramSchmidt.cpp @@ -172,7 +172,7 @@ namespace ReSolve } else { - // assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; @@ -222,7 +222,7 @@ namespace ReSolve } else { - // assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; @@ -279,7 +279,7 @@ namespace ReSolve } else { - // assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); return 1; } h_rv = nullptr; @@ -364,7 +364,7 @@ namespace ReSolve } else { - // assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); return 1; } h_rv = nullptr; @@ -395,13 +395,13 @@ namespace ReSolve } else { - // assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); return 1; } return 0; default: - // assert(0 && "Iterative refinement failed, wrong orthogonalization.\n"); + assert(0 && "Iterative refinement failed, wrong orthogonalization.\n"); return 1; } // switch From 22746d6425382fbe1e2f5693026155d4b437d982 Mon Sep 17 00:00:00 2001 From: Achintya Sunil Date: Fri, 24 Oct 2025 10:50:34 -0400 Subject: [PATCH 5/9] Update feature added to Rand and some cleanup for FGMRES --- resolve/LinSolverIterativeFGMRES.cpp | 5 -- resolve/LinSolverIterativeRandFGMRES.cpp | 88 ++++++++++++++++++++---- resolve/LinSolverIterativeRandFGMRES.hpp | 2 + 3 files changed, 77 insertions(+), 18 deletions(-) diff --git a/resolve/LinSolverIterativeFGMRES.cpp b/resolve/LinSolverIterativeFGMRES.cpp index 929e90022..90e17638c 100644 --- a/resolve/LinSolverIterativeFGMRES.cpp +++ b/resolve/LinSolverIterativeFGMRES.cpp @@ -137,11 +137,6 @@ namespace ReSolve // Initializing Residual and Update vec_Y_->setToZero(memspace_); - // V[0] = b-A*x_0 - // debug - vec_Z_->setToZero(memspace_); - vec_V_->setToZero(memspace_); - // Computing the first Arnodi basis vector vec_R_->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); rnorm = 0.0; diff --git a/resolve/LinSolverIterativeRandFGMRES.cpp b/resolve/LinSolverIterativeRandFGMRES.cpp index db26b0077..2bad57238 100644 --- a/resolve/LinSolverIterativeRandFGMRES.cpp +++ b/resolve/LinSolverIterativeRandFGMRES.cpp @@ -140,6 +140,7 @@ namespace ReSolve int outer_flag = 1; int notconv = 1; + int update_flag= 1; index_type i = 0; int it = 0; int j; @@ -150,16 +151,25 @@ namespace ReSolve real_type rnorm; real_type bnorm; real_type tolrel; + real_type rhsnorm; vector_type vec_v(n_); vector_type vec_z(n_); vector_type vec_s(k_rand_); - // V[0] = b-A*x_0 - // debug + + // Compute the residual + vec_R_->setToZero(memspace_); + vec_R_->copyDataFrom(rhs, memspace_, memspace_); + matrix_handler_->matvec(A_, x, vec_R_, &MINUS_ONE, &ONE, memspace_); + + // Arnoldi Basis vec_Z_->setToZero(memspace_); vec_V_->setToZero(memspace_); - rhs->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); - matrix_handler_->matvec(A_, x, vec_V_, &MINUS_ONE, &ONE, memspace_); + // Initializing Residual and Update + vec_Y_->setToZero(memspace_); + + // Computing the first Arnodi basis vector + vec_R_->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); vec_v.setData(vec_V_->getData(0, memspace_), memspace_); vec_s.setData(vec_S_->getData(0, memspace_), memspace_); @@ -173,15 +183,28 @@ namespace ReSolve mem_.deviceSynchronize(); rnorm = 0.0; - bnorm = vector_handler_->dot(rhs, rhs, memspace_); + bnorm = vector_handler_->dot(vec_R_, vec_R_, memspace_); rnorm = vector_handler_->dot(&vec_s, &vec_s, memspace_); - rnorm = std::sqrt(rnorm); // rnorm = ||V_1|| + rnorm = std::sqrt(rnorm); bnorm = std::sqrt(bnorm); io::Logger::misc() << "it 0: norm of residual " << std::scientific << std::setprecision(16) << rnorm << " Norm of rhs: " << bnorm << "\n"; initial_residual_norm_ = rnorm; + + // Checking if rnorm > norm of RHS + rhsnorm = vector_handler_->dot(rhs, rhs, memspace_); + rhsnorm = std::sqrt(rhsnorm); + + if (rnorm > rhsnorm) + { + std::cout << "Initial guess is invalid. Refining Ax = b instead of Ay = r" << std::endl; + vec_Y_->copyDataFrom(x, memspace_, memspace_); + vec_R_->copyDataFrom(rhs, memspace_, memspace_); + update_flag = 0; + } + while (outer_flag) { if (it == 0) @@ -210,6 +233,7 @@ namespace ReSolve if (exit_cond) { outer_flag = 0; + update_flag = 1; final_residual_norm_ = rnorm; initial_residual_norm_ = rnorm; total_iters_ = 0; @@ -333,13 +357,13 @@ namespace ReSolve h_rs_[k] = t / h_H_[k * (restart_ + 1) + k]; } - // get solution + // get update if (flexible_) { for (j = 0; j <= i; j++) { vec_z.setData(vec_Z_->getData(j, memspace_), memspace_); - vector_handler_->axpy(&h_rs_[j], &vec_z, x, memspace_); + vector_handler_->axpy(&h_rs_[j], &vec_z, vec_Y_, memspace_); } } else @@ -355,18 +379,18 @@ namespace ReSolve vec_v.setData(vec_V_->getData(memspace_), memspace_); this->precV(&vec_z, &vec_v); - // and add to x - vector_handler_->axpy(&ONE, &vec_v, x, memspace_); + // and add to update + vector_handler_->axpy(&ONE, &vec_v, vec_Y_, memspace_); } - /* test solution */ + /* test update */ if (rnorm <= tolrel || it >= maxit_) { outer_flag = 0; } - rhs->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); - matrix_handler_->matvec(A_, x, vec_V_, &MINUS_ONE, &ONE, memspace_); + vec_R_->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); + matrix_handler_->matvec(A_, vec_Y_, vec_V_, &MINUS_ONE, &ONE, memspace_); if (outer_flag) { @@ -403,6 +427,35 @@ namespace ReSolve total_iters_ = it; } } // outer while + + if (update_flag) + { + vector_handler_->axpy(&ONE, x, vec_Y_, memspace_); + vec_R_->copyDataFrom(rhs, memspace_, memspace_); + matrix_handler_->matvec(A_, vec_Y_, vec_R_, &MINUS_ONE, &ONE, memspace_); + final_residual_norm_ = vector_handler_->dot(vec_R_, vec_R_, memspace_); + final_residual_norm_ = std::sqrt(final_residual_norm_); + + // Compare this with initial and update x accordingly + if (final_residual_norm_ < initial_residual_norm_) + { + std::cout << "Update to intial guess is successful, final residual (solution plus update) " + << std::scientific << std::setprecision(16) + << final_residual_norm_ / rhsnorm << "\n"; + + x->copyDataFrom(vec_Y_, memspace_, memspace_); + } + else + { + std::cout << "Update to intial guess is not successful, final residual greater than initial residual " + << std::scientific << std::setprecision(16) + << final_residual_norm_ / rhsnorm << "\n"; + } + } + else + { + x->copyDataFrom(vec_Y_, memspace_, memspace_); + } return 0; } @@ -680,6 +733,11 @@ namespace ReSolve { vec_V_ = new vector_type(n_, restart_ + 1); vec_V_->allocate(memspace_); + vec_Y_ = new vector_type(n_); + vec_Y_->allocate(memspace_); + vec_R_ = new vector_type(n_); + vec_R_->allocate(memspace_); + if (flexible_) { vec_Z_ = new vector_type(n_, restart_ + 1); @@ -710,6 +768,8 @@ namespace ReSolve delete[] h_rs_; delete vec_V_; delete vec_Z_; + delete vec_Y_; + delete vec_R_; delete vec_aux_; h_H_ = nullptr; @@ -719,6 +779,8 @@ namespace ReSolve vec_V_ = nullptr; vec_Z_ = nullptr; vec_aux_ = nullptr; + vec_Y_ = nullptr; + vec_R_ = nullptr; is_solver_set_ = false; return 0; diff --git a/resolve/LinSolverIterativeRandFGMRES.hpp b/resolve/LinSolverIterativeRandFGMRES.hpp index c16f77116..fd5e24a00 100644 --- a/resolve/LinSolverIterativeRandFGMRES.hpp +++ b/resolve/LinSolverIterativeRandFGMRES.hpp @@ -116,6 +116,8 @@ namespace ReSolve vector_type* vec_Z_{nullptr}; // for performing Gram-Schmidt vector_type* vec_S_{nullptr}; ///< this is where sketched vectors are stored + vector_type* vec_Y_{nullptr}; + vector_type* vec_R_{nullptr}; real_type* h_H_{nullptr}; real_type* h_c_{nullptr}; From 472083c399cf27625fe1e352aebfd70b81573be6 Mon Sep 17 00:00:00 2001 From: ASunil-17 Date: Fri, 24 Oct 2025 14:59:09 +0000 Subject: [PATCH 6/9] Apply pre-commmit fixes --- resolve/LinSolverIterativeRandFGMRES.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/resolve/LinSolverIterativeRandFGMRES.cpp b/resolve/LinSolverIterativeRandFGMRES.cpp index 2bad57238..725bfefdd 100644 --- a/resolve/LinSolverIterativeRandFGMRES.cpp +++ b/resolve/LinSolverIterativeRandFGMRES.cpp @@ -138,11 +138,11 @@ namespace ReSolve // io::Logger::setVerbosity(io::Logger::EVERYTHING); - int outer_flag = 1; - int notconv = 1; - int update_flag= 1; - index_type i = 0; - int it = 0; + int outer_flag = 1; + int notconv = 1; + int update_flag = 1; + index_type i = 0; + int it = 0; int j; int k; int k1; From e530660c34d2ce84d7146fb8bbb4e4abbc1bfd20 Mon Sep 17 00:00:00 2001 From: Achintya Sunil Date: Sat, 1 Nov 2025 18:04:19 -0400 Subject: [PATCH 7/9] solving scaled RHS FGMRES --- resolve/LinSolverIterativeFGMRES.cpp | 39 +++++++++++++++++------- resolve/LinSolverIterativeRandFGMRES.cpp | 10 ++---- 2 files changed, 31 insertions(+), 18 deletions(-) diff --git a/resolve/LinSolverIterativeFGMRES.cpp b/resolve/LinSolverIterativeFGMRES.cpp index 90e17638c..a58138c6e 100644 --- a/resolve/LinSolverIterativeFGMRES.cpp +++ b/resolve/LinSolverIterativeFGMRES.cpp @@ -124,12 +124,20 @@ namespace ReSolve real_type rhsnorm = 0.0; vector_type vec_v(n_); vector_type vec_z(n_); + vector_type vec_u(n_); // Compute the residual vec_R_->setToZero(memspace_); vec_R_->copyDataFrom(rhs, memspace_, memspace_); matrix_handler_->matvec(A_, x, vec_R_, &MINUS_ONE, &ONE, memspace_); + // DEBUG: Normalizing RHS + bnorm = vector_handler_->dot(vec_R_, vec_R_, memspace_); + bnorm = std::sqrt(bnorm); + t = 1.0 / bnorm; + vector_handler_->scal(&t, vec_R_, memspace_); + std::cout << "DEBUG: Norm of the vec_R_ " << vector_handler_->dot(vec_R_, vec_R_, memspace_) << std::endl; + // Arnoldi Basis vec_Z_->setToZero(memspace_); vec_V_->setToZero(memspace_); @@ -139,19 +147,18 @@ namespace ReSolve // Computing the first Arnodi basis vector vec_R_->copyDataTo(vec_V_->getData(memspace_), 0, memspace_); - rnorm = 0.0; - bnorm = vector_handler_->dot(vec_R_, vec_R_, memspace_); rnorm = vector_handler_->dot(vec_V_, vec_V_, memspace_); rnorm = std::sqrt(rnorm); - // Checking if rnorm > norm of RHS + std::cout << "DEBUG: Norm of the vec_V_ " << rnorm << std::endl; + + // Checking if bnorm > norm of RHS rhsnorm = vector_handler_->dot(rhs, rhs, memspace_); rhsnorm = std::sqrt(rhsnorm); - if (rnorm > rhsnorm) + if (bnorm > rhsnorm) { - std::cout << "Initial guess is invalid. Refining Ax = b instead of Ay = r" << std::endl; - vec_Y_->copyDataFrom(x, memspace_, memspace_); - vec_R_->copyDataFrom(rhs, memspace_, memspace_); + std::cout << "Initial guess is invalid. Quitting iterative refinement" << std::endl; + outer_flag = 0; update_flag = 0; } @@ -163,6 +170,7 @@ namespace ReSolve while (outer_flag) { + std::cout << "DEBUG: Starting FGMRES outerloop " << std::endl; if (it == 0) { tolrel = tol_ * rnorm; @@ -211,6 +219,10 @@ namespace ReSolve // Z_i = (LU)^{-1}*V_i vec_v.setData(vec_V_->getData(i, memspace_), memspace_); + vec_u.copyDataFrom(&vec_v, memspace_, memspace_); + std::cout << "DEBUG: norm of squared norm of vec_v " << vector_handler_->dot(&vec_v, &vec_v, memspace_) << std::endl; + std::cout << "DEBUG: norm of squared norm of vec_u " << vector_handler_->dot(&vec_u, &vec_u, memspace_) << std::endl; + if (flexible_) { vec_z.setData(vec_Z_->getData(i, memspace_), memspace_); @@ -220,6 +232,8 @@ namespace ReSolve vec_z.setData(vec_Z_->getData(0, memspace_), memspace_); } this->precV(&vec_v, &vec_z); + std::cout << "DEBUG: norm of vec_v after preconditioning " << vector_handler_->dot(&vec_z, &vec_z, memspace_) << std::endl; + mem_.deviceSynchronize(); // V_{i+1}=A*Z_i @@ -227,6 +241,11 @@ namespace ReSolve vec_v.setData(vec_V_->getData(i + 1, memspace_), memspace_); vec_v.setToZero(memspace_); matrix_handler_->matvec(A_, &vec_z, &vec_v, &ONE, &ZERO, memspace_); + std::cout << "DEBUG: norm of squared norm of vec_v after A*z_i " << vector_handler_->dot(&vec_v, &vec_v, memspace_) << std::endl; + + // V_{i} - V_{i+1} + vector_handler_->axpy(&MINUS_ONE, &vec_v, &vec_u, memspace_); + std::cout << "DEBUG: Difference between v_i and Az_i " << vector_handler_->dot(&vec_u, &vec_u, memspace_) << std::endl; // orthogonalize V[i+1], form a column of h_H_ @@ -347,6 +366,8 @@ namespace ReSolve if (update_flag) { + t = bnorm; + vector_handler_->scal(&t, vec_Y_, memspace_); vector_handler_->axpy(&ONE, x, vec_Y_, memspace_); vec_R_->copyDataFrom(rhs, memspace_, memspace_); matrix_handler_->matvec(A_, vec_Y_, vec_R_, &MINUS_ONE, &ONE, memspace_); @@ -369,10 +390,6 @@ namespace ReSolve << final_residual_norm_ / rhsnorm << "\n"; } } - else - { - x->copyDataFrom(vec_Y_, memspace_, memspace_); - } return 0; } diff --git a/resolve/LinSolverIterativeRandFGMRES.cpp b/resolve/LinSolverIterativeRandFGMRES.cpp index 725bfefdd..3453f38b2 100644 --- a/resolve/LinSolverIterativeRandFGMRES.cpp +++ b/resolve/LinSolverIterativeRandFGMRES.cpp @@ -199,10 +199,9 @@ namespace ReSolve if (rnorm > rhsnorm) { - std::cout << "Initial guess is invalid. Refining Ax = b instead of Ay = r" << std::endl; - vec_Y_->copyDataFrom(x, memspace_, memspace_); - vec_R_->copyDataFrom(rhs, memspace_, memspace_); + std::cout << "Initial guess is invalid. Quitting iterative refinement." << std::endl; update_flag = 0; + outer_flag = 0; } while (outer_flag) @@ -452,10 +451,7 @@ namespace ReSolve << final_residual_norm_ / rhsnorm << "\n"; } } - else - { - x->copyDataFrom(vec_Y_, memspace_, memspace_); - } + return 0; } From f6eaa31fe15a91da832f2636764895250b773620 Mon Sep 17 00:00:00 2001 From: Achintya Sunil Date: Wed, 19 Nov 2025 13:55:45 -0500 Subject: [PATCH 8/9] Changed GramSchmidt for better error handling --- examples/._ExampleHelper.hpp | Bin 0 -> 4097 bytes resolve/._LinSolverIterativeFGMRES.cpp | Bin 0 -> 4097 bytes resolve/GramSchmidt.cpp | 10 ++-- resolve/LinSolverIterativeFGMRES.cpp | 65 +++++++++++----------- resolve/LinSolverIterativeRandFGMRES.cpp | 24 +++++--- tests/functionality/._CMakeLists.txt | Bin 0 -> 4097 bytes tests/functionality/._testRandGmres.cpp | Bin 0 -> 4097 bytes tests/functionality/._testSysGmres.cpp | Bin 0 -> 4097 bytes tests/functionality/CMakeLists.txt | 68 ++++++++++++----------- 9 files changed, 91 insertions(+), 76 deletions(-) create mode 100755 examples/._ExampleHelper.hpp create mode 100755 resolve/._LinSolverIterativeFGMRES.cpp create mode 100755 tests/functionality/._CMakeLists.txt create mode 100755 tests/functionality/._testRandGmres.cpp create mode 100755 tests/functionality/._testSysGmres.cpp diff --git a/examples/._ExampleHelper.hpp b/examples/._ExampleHelper.hpp new file mode 100755 index 0000000000000000000000000000000000000000..75f4b12f6e5d829bdd5ab12533182e9d3f26f514 GIT binary patch literal 4097 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWIUt(=a103vf+zv$ zV3+~K+-O=D5#plB`MG+D1qC^&dId%KWvO|IdC92^Kn3}&uV%X6y&Mz%WPE|$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWIUt(=a103vf+zv$ zU^oE8(hxqJ1etyShy@rJq>}S<^%4sTa#Hnj5{pYpi&Ill5=&B*1A?KdF92z71_n`t zx`Lwovedl9yyR4d1&-30Aa&wWY^)%fk%1w<_0>%GyO#?<+)*$Z0;3@?8UmvsFd71* zAut*OqaiRF0;3@?8UmvsFoHq=*e3+_3n4%*BqOs}p(wRDzqBYhRUs|EC|e;juOv0E pBr`uRF(;=|AtyDhL?J0BF)tg~7lvsY$~3C~;XaXJko*6i3jjiDHKPCk literal 0 HcmV?d00001 diff --git a/resolve/GramSchmidt.cpp b/resolve/GramSchmidt.cpp index 18b702771..018a24982 100644 --- a/resolve/GramSchmidt.cpp +++ b/resolve/GramSchmidt.cpp @@ -172,7 +172,7 @@ namespace ReSolve } else { - assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + std::cout << "Encountered loss of Orthogonality, exiting gracefully at step " << i + 1 << std::endl; return 1; } return 0; @@ -222,7 +222,7 @@ namespace ReSolve } else { - assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + std::cout << "Encountered loss of Orthogonality, exiting gracefully at step " << i + 1 << std::endl; return 1; } return 0; @@ -279,7 +279,7 @@ namespace ReSolve } else { - assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + std::cout << "Encountered loss of Orthogonality, exiting gracefully at step " << i + 1 << std::endl; return 1; } h_rv = nullptr; @@ -364,7 +364,7 @@ namespace ReSolve } else { - assert(0 && "Iterative refinement failed, Krylov vector with ZERO norm\n"); + std::cout << "Encountered loss of Orthogonality, exiting gracefully at step " << i + 1 << std::endl; return 1; } h_rv = nullptr; @@ -395,7 +395,7 @@ namespace ReSolve } else { - assert(0 && "Gram-Schmidt failed, vector with ZERO norm\n"); + std::cout << "Encountered loss of Orthogonality, exiting gracefully at step " << i + 1 << std::endl; return 1; } return 0; diff --git a/resolve/LinSolverIterativeFGMRES.cpp b/resolve/LinSolverIterativeFGMRES.cpp index a58138c6e..b0f5afcf8 100644 --- a/resolve/LinSolverIterativeFGMRES.cpp +++ b/resolve/LinSolverIterativeFGMRES.cpp @@ -124,19 +124,17 @@ namespace ReSolve real_type rhsnorm = 0.0; vector_type vec_v(n_); vector_type vec_z(n_); - vector_type vec_u(n_); // Compute the residual vec_R_->setToZero(memspace_); vec_R_->copyDataFrom(rhs, memspace_, memspace_); matrix_handler_->matvec(A_, x, vec_R_, &MINUS_ONE, &ONE, memspace_); - // DEBUG: Normalizing RHS + // Normalizing the RHS bnorm = vector_handler_->dot(vec_R_, vec_R_, memspace_); bnorm = std::sqrt(bnorm); - t = 1.0 / bnorm; + t = 1 / bnorm; vector_handler_->scal(&t, vec_R_, memspace_); - std::cout << "DEBUG: Norm of the vec_R_ " << vector_handler_->dot(vec_R_, vec_R_, memspace_) << std::endl; // Arnoldi Basis vec_Z_->setToZero(memspace_); @@ -150,27 +148,25 @@ namespace ReSolve rnorm = vector_handler_->dot(vec_V_, vec_V_, memspace_); rnorm = std::sqrt(rnorm); - std::cout << "DEBUG: Norm of the vec_V_ " << rnorm << std::endl; - // Checking if bnorm > norm of RHS rhsnorm = vector_handler_->dot(rhs, rhs, memspace_); rhsnorm = std::sqrt(rhsnorm); if (bnorm > rhsnorm) { std::cout << "Initial guess is invalid. Quitting iterative refinement" << std::endl; - outer_flag = 0; - update_flag = 0; + initial_residual_norm_ = bnorm; + final_residual_norm_ = bnorm; // Set final norm to initial norm as no work was done. + total_iters_ = 0; + return 0; } - bnorm = std::sqrt(bnorm); io::Logger::misc() << "it 0: norm of residual " << std::scientific << std::setprecision(16) << rnorm << " Norm of rhs: " << bnorm << "\n"; - initial_residual_norm_ = rnorm; + initial_residual_norm_ = bnorm; while (outer_flag) { - std::cout << "DEBUG: Starting FGMRES outerloop " << std::endl; if (it == 0) { tolrel = tol_ * rnorm; @@ -204,9 +200,6 @@ namespace ReSolve break; } - // normalize first vector - t = 1.0 / rnorm; - vector_handler_->scal(&t, vec_V_, memspace_); // initialize norm history h_rs_[0] = rnorm; i = -1; @@ -219,10 +212,6 @@ namespace ReSolve // Z_i = (LU)^{-1}*V_i vec_v.setData(vec_V_->getData(i, memspace_), memspace_); - vec_u.copyDataFrom(&vec_v, memspace_, memspace_); - std::cout << "DEBUG: norm of squared norm of vec_v " << vector_handler_->dot(&vec_v, &vec_v, memspace_) << std::endl; - std::cout << "DEBUG: norm of squared norm of vec_u " << vector_handler_->dot(&vec_u, &vec_u, memspace_) << std::endl; - if (flexible_) { vec_z.setData(vec_Z_->getData(i, memspace_), memspace_); @@ -232,20 +221,11 @@ namespace ReSolve vec_z.setData(vec_Z_->getData(0, memspace_), memspace_); } this->precV(&vec_v, &vec_z); - std::cout << "DEBUG: norm of vec_v after preconditioning " << vector_handler_->dot(&vec_z, &vec_z, memspace_) << std::endl; - mem_.deviceSynchronize(); // V_{i+1}=A*Z_i - vec_v.setData(vec_V_->getData(i + 1, memspace_), memspace_); - vec_v.setToZero(memspace_); matrix_handler_->matvec(A_, &vec_z, &vec_v, &ONE, &ZERO, memspace_); - std::cout << "DEBUG: norm of squared norm of vec_v after A*z_i " << vector_handler_->dot(&vec_v, &vec_v, memspace_) << std::endl; - - // V_{i} - V_{i+1} - vector_handler_->axpy(&MINUS_ONE, &vec_v, &vec_u, memspace_); - std::cout << "DEBUG: Difference between v_i and Az_i " << vector_handler_->dot(&vec_u, &vec_u, memspace_) << std::endl; // orthogonalize V[i+1], form a column of h_H_ @@ -253,8 +233,7 @@ namespace ReSolve if (gs_status != 0) // checking for successful breakdown { - notconv = 0; // exiting outer loop - break; + notconv = 0; // exiting outer loop after one inner loop iteration } if (i != 0) @@ -301,7 +280,18 @@ namespace ReSolve << std::scientific << std::setprecision(16) << rnorm << "\n"; // solve tri system - h_rs_[i] = h_rs_[i] / h_H_[i * (restart_ + 1) + i]; + real_type H_ii_diag = h_H_[i * (restart_ + 1) + i]; + + // FIX: Check for division by zero before starting back-substitution + if (std::abs(H_ii_diag) < MACHINE_EPSILON) + { + h_rs_[i] = ZERO; // Last element of solution is set to 0 + } + else + { + h_rs_[i] = h_rs_[i] / H_ii_diag; + } + for (int ii = 2; ii <= i + 1; ii++) { k = i - ii + 1; @@ -311,7 +301,17 @@ namespace ReSolve { t -= h_H_[j * (restart_ + 1) + k] * h_rs_[j]; } - h_rs_[k] = t / h_H_[k * (restart_ + 1) + k]; + + // Checking for division by zero inside the loop as well + real_type H_diag_k = h_H_[k * (restart_ + 1) + k]; + if (std::abs(H_diag_k) < MACHINE_EPSILON) + { + h_rs_[k] = ZERO; + } + else + { + h_rs_[k] = t / H_diag_k; + } } // get solution @@ -366,6 +366,7 @@ namespace ReSolve if (update_flag) { + // renormalizing t = bnorm; vector_handler_->scal(&t, vec_Y_, memspace_); vector_handler_->axpy(&ONE, x, vec_Y_, memspace_); @@ -388,6 +389,8 @@ namespace ReSolve std::cout << "Update to intial guess is not successful, final residual greater than initial residual " << std::scientific << std::setprecision(16) << final_residual_norm_ / rhsnorm << "\n"; + + final_residual_norm_ = initial_residual_norm_; } } diff --git a/resolve/LinSolverIterativeRandFGMRES.cpp b/resolve/LinSolverIterativeRandFGMRES.cpp index 3453f38b2..e744303d1 100644 --- a/resolve/LinSolverIterativeRandFGMRES.cpp +++ b/resolve/LinSolverIterativeRandFGMRES.cpp @@ -161,6 +161,12 @@ namespace ReSolve vec_R_->copyDataFrom(rhs, memspace_, memspace_); matrix_handler_->matvec(A_, x, vec_R_, &MINUS_ONE, &ONE, memspace_); + // Normalizing the residual + bnorm = vector_handler_->dot(vec_R_, vec_R_, memspace_); + bnorm = std::sqrt(bnorm); + t = 1 / bnorm; + vector_handler_->scal(&t, vec_R_, memspace_); + // Arnoldi Basis vec_Z_->setToZero(memspace_); vec_V_->setToZero(memspace_); @@ -183,25 +189,25 @@ namespace ReSolve mem_.deviceSynchronize(); rnorm = 0.0; - bnorm = vector_handler_->dot(vec_R_, vec_R_, memspace_); rnorm = vector_handler_->dot(&vec_s, &vec_s, memspace_); rnorm = std::sqrt(rnorm); - bnorm = std::sqrt(bnorm); io::Logger::misc() << "it 0: norm of residual " << std::scientific << std::setprecision(16) << rnorm << " Norm of rhs: " << bnorm << "\n"; - initial_residual_norm_ = rnorm; + initial_residual_norm_ = bnorm; // Checking if rnorm > norm of RHS rhsnorm = vector_handler_->dot(rhs, rhs, memspace_); rhsnorm = std::sqrt(rhsnorm); - if (rnorm > rhsnorm) + if (bnorm > rhsnorm) { - std::cout << "Initial guess is invalid. Quitting iterative refinement." << std::endl; - update_flag = 0; - outer_flag = 0; + std::cout << "Initial guess is invalid. Quitting iterative refinement" << std::endl; + initial_residual_norm_ = bnorm; + final_residual_norm_ = bnorm; // Set final norm to initial norm as no work was done. + total_iters_ = 0; + return 0; } while (outer_flag) @@ -429,6 +435,8 @@ namespace ReSolve if (update_flag) { + t = bnorm; + vector_handler_->scal(&t, vec_Y_, memspace_); vector_handler_->axpy(&ONE, x, vec_Y_, memspace_); vec_R_->copyDataFrom(rhs, memspace_, memspace_); matrix_handler_->matvec(A_, vec_Y_, vec_R_, &MINUS_ONE, &ONE, memspace_); @@ -449,6 +457,8 @@ namespace ReSolve std::cout << "Update to intial guess is not successful, final residual greater than initial residual " << std::scientific << std::setprecision(16) << final_residual_norm_ / rhsnorm << "\n"; + + final_residual_norm_ = initial_residual_norm_; } } diff --git a/tests/functionality/._CMakeLists.txt b/tests/functionality/._CMakeLists.txt new file mode 100755 index 0000000000000000000000000000000000000000..db89664f66199d6a2d7b3fcd681e6e7a34186f9e GIT binary patch literal 4097 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWIUt(=a103vf+zv$ zU^oE8(hxqJ1etyShy@rJq>}S<^%4sTa#Hnj5{pYpi&Ill5=&B*1A?KdF92z71_n`t zx`Lwovedl9yyR4dbzE|pAa%dCIkJIhMh1rb)>kv#?_MqdaYw;u2#kinXb6mkz-S1J zhQMeDjE2By2#kinXb6mkzz7NfV4o1wFN6TOkc`Y?g`(8r{L-T2RE4zsqHKlCypq(s plFa$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWIUt(=a103vf+zv$ zU^oE8(hxqJ1etyShy@rJq>}S<^%4sTa#Hnj5{pYpi&Ill5=&B*1A?KdF92z71_n`t zx`Lwovedl9yyR4dP9C{TkUBZm%Nih>k%1w<_0>%GyO#?<+)*$Z0;3@?8UmvsFd71* zAut*OqaiRF0;3@?8UmvsFoHq=*e3+_3n4%*BqOs}p(wRDzqBYhRUs|EC|e;juOv0E pBr`uRF(;=|AtyDhL?J0BF)tg~7lvsY$~3C~;XaXJko*6i3jkO9Haq|T literal 0 HcmV?d00001 diff --git a/tests/functionality/._testSysGmres.cpp b/tests/functionality/._testSysGmres.cpp new file mode 100755 index 0000000000000000000000000000000000000000..722d157ad1b867e7e370894abcb7bbef97343b57 GIT binary patch literal 4097 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWIUt(=a103vf+zv$ zU^oE8(hxqJ1etyShy@rJq>}S<^%4sTa#Hnj5{pYpi&Ill5=&B*1A?KdF92z71_n`t zx`Lwovedl9yyR4ddOo>Kkh+Tn{a}|dGBD(~zMAQN_i_PL`zSRU0;3@?8UmvsFd71* zAut*OqaiRF0;3@?8UmvsFj7JQ*e7HFVK9&j$;d2LC`v8PFD*(=RY=P(%2vqCD@n~O p$;{77%*m-#$Vp8rQAo;3%*zJ$g`v8JG==JaxL0Ht @@ -7,7 +6,7 @@ ]] # Build basic version test -add_executable(version.exe testVersion.cpp) +add_executable(version.exe testVersion.cpp) target_link_libraries(version.exe PRIVATE ReSolve) # Build test for Krylov solvers @@ -35,7 +34,6 @@ if(RESOLVE_USE_KLU) # System solver test with GLU (to be subsumed in testSysRefactor.cpp) add_executable(sys_glu_test.exe testSysGLU.cpp) target_link_libraries(sys_glu_test.exe PRIVATE ReSolve) - endif(RESOLVE_USE_CUDA) endif(RESOLVE_USE_KLU) @@ -54,7 +52,7 @@ if(RESOLVE_USE_KLU) list(APPEND installable_tests klu_klu_test.exe) if(RESOLVE_USE_GPU) list(APPEND installable_tests klu_rf_test.exe - sys_refactor_test.exe) + sys_refactor_test.exe) endif(RESOLVE_USE_GPU) if(RESOLVE_USE_CUDA) @@ -66,7 +64,7 @@ if(RESOLVE_USE_LUSOL) list(APPEND installable_tests lusol_test.exe) endif() -install(TARGETS ${installable_tests} +install(TARGETS ${installable_tests} RUNTIME DESTINATION bin/resolve/tests/functionality) # Install directory with data files @@ -87,58 +85,62 @@ if(RESOLVE_USE_LUSOL) endif() # Krylov solvers tests (FGMRES) -add_test(NAME sys_rand_count_fgmres_cgs2_test COMMAND $ "-i" "randgmres" "-g" "cgs2" "-s" "count") -add_test(NAME sys_rand_count_fgmres_mgs_test COMMAND $ "-i" "randgmres" "-g" "mgs" "-s" "count") +add_test(NAME sys_rand_count_fgmres_cgs2_test COMMAND $ "-i" "randgmres" "-g" "cgs2" "-s" "count") +add_test(NAME sys_rand_count_fgmres_mgs_test COMMAND $ "-i" "randgmres" "-g" "mgs" "-s" "count") add_test(NAME sys_rand_count_fgmres_mgs2sync_test COMMAND $ "-i" "randgmres" "-g" "mgs_two_sync" "-s" "count") -add_test(NAME sys_rand_count_fgmres_mgspm_test COMMAND $ "-i" "randgmres" "-g" "mgs_pm" "-s" "count") -add_test(NAME sys_rand_fwht_fgmres_cgs2_test COMMAND $ "-i" "randgmres" "-g" "cgs2" "-s" "fwht") -add_test(NAME sys_rand_fwht_fgmres_mgs_test COMMAND $ "-i" "randgmres" "-g" "mgs" "-s" "fwht") -add_test(NAME sys_rand_fwht_fgmres_mgs2sync_test COMMAND $ "-i" "randgmres" "-g" "mgs_two_sync" "-s" "fwht") -add_test(NAME sys_rand_fwht_fgmres_mgspm_test COMMAND $ "-i" "randgmres" "-g" "mgs_pm" "-s" "fwht") -add_test(NAME sys_fgmres_cgs2_test COMMAND $ "-i" "fgmres" "-g" "cgs2") -add_test(NAME sys_fgmres_mgs_test COMMAND $ "-i" "fgmres" "-g" "mgs") +add_test(NAME sys_rand_count_fgmres_mgspm_test COMMAND $ "-i" "randgmres" "-g" "mgs_pm" "-s" "count") +add_test(NAME sys_rand_fwht_fgmres_cgs2_test COMMAND $ "-i" "randgmres" "-g" "cgs2" "-s" "fwht") +add_test(NAME sys_rand_fwht_fgmres_mgs_test COMMAND $ "-i" "randgmres" "-g" "mgs" "-s" "fwht") +add_test(NAME sys_rand_fwht_fgmres_mgs2sync_test COMMAND $ "-i" "randgmres" "-g" "mgs_two_sync" "-s" "fwht") +add_test(NAME sys_rand_fwht_fgmres_mgspm_test COMMAND $ "-i" "randgmres" "-g" "mgs_pm" "-s" "fwht") +add_test(NAME sys_fgmres_cgs2_test COMMAND $ "-i" "fgmres" "-g" "cgs2") +add_test(NAME sys_fgmres_mgs_test COMMAND $ "-i" "fgmres" "-g" "mgs") add_test(NAME sys_fgmres_mgs2sync_test COMMAND $ "-i" "fgmres" "-g" "mgs_two_sync") -add_test(NAME sys_fgmres_mgspm_test COMMAND $ "-i" "fgmres" "-g" "mgs_pm") +add_test(NAME sys_fgmres_mgspm_test COMMAND $ "-i" "fgmres" "-g" "mgs_pm") # Krylov solvers tests (GMRES) -add_test(NAME sys_rand_count_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "cgs2" "-s" "count") -add_test(NAME sys_rand_count_gmres_mgs_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs" "-s" "count") +add_test(NAME sys_rand_count_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "cgs2" "-s" "count") +add_test(NAME sys_rand_count_gmres_mgs_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs" "-s" "count") add_test(NAME sys_rand_count_gmres_mgs2sync_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_two_sync" "-s" "count") -add_test(NAME sys_rand_count_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_pm" "-s" "count") -add_test(NAME sys_rand_fwht_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "cgs2" "-s" "fwht") -add_test(NAME sys_rand_fwht_gmres_mgs_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs" "-s" "fwht") -add_test(NAME sys_rand_fwht_gmres_mgs2sync_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_two_sync" "-s" "fwht") -add_test(NAME sys_rand_fwht_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_pm" "-s" "fwht") -add_test(NAME sys_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "cgs2") -add_test(NAME sys_gmres_mgs_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs") +add_test(NAME sys_rand_count_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_pm" "-s" "count") +add_test(NAME sys_rand_fwht_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "cgs2" "-s" "fwht") +add_test(NAME sys_rand_fwht_gmres_mgs_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs" "-s" "fwht") +add_test(NAME sys_rand_fwht_gmres_mgs2sync_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_two_sync" "-s" "fwht") +add_test(NAME sys_rand_fwht_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_pm" "-s" "fwht") +add_test(NAME sys_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "cgs2") +add_test(NAME sys_gmres_mgs_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs") add_test(NAME sys_gmres_mgs2sync_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs_two_sync") -add_test(NAME sys_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs_pm") +add_test(NAME sys_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs_pm") + +# Adding bad initial guess test (GMRES) +add_test(NAME sys_bad_x0_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "cgs2" "-b" "yes") +add_test(NAME sys_bad_x0_gmres_mgs_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs" "-b" "yes") # Randomized GMRES solvers tested without SystemSolver class add_test(NAME rand_gmres_test COMMAND $) if(RESOLVE_USE_KLU) # Using KLU as refactorization solver - add_test(NAME klu_klu_test COMMAND $ "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") + add_test(NAME klu_klu_test COMMAND $ "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") add_test(NAME klu_klu_ir_test COMMAND $ "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}" "-i") add_test(NAME klu_klu_asym_test COMMAND $ "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") - add_test(NAME klu_klu_asym_ir_test COMMAND $ "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}" "-i") + add_test(NAME klu_klu_asym_ir_test COMMAND $ "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}" "-i") # CUDA-SDK specific tests if(RESOLVE_USE_CUDA) - add_test(NAME klu_rf_cuda_test COMMAND $ "-d" "${test_data_dir}") + add_test(NAME klu_rf_cuda_test COMMAND $ "-d" "${test_data_dir}") add_test(NAME klu_rf_ir_cuda_test COMMAND $ "-d" "${test_data_dir}" "-i") - add_test(NAME klu_glu_cuda_test COMMAND $ "-d" "${test_data_dir}" "-s" "glu") + add_test(NAME klu_glu_cuda_test COMMAND $ "-d" "${test_data_dir}" "-s" "glu") add_test(NAME sys_refactor_cuda_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") - add_test(NAME sys_refactor_cuda_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") + add_test(NAME sys_refactor_cuda_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") add_test(NAME sys_glu_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") - add_test(NAME sys_glu_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") + add_test(NAME sys_glu_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") endif(RESOLVE_USE_CUDA) # ROCm specific tests if(RESOLVE_USE_HIP) - add_test(NAME rocsolver_rf_test COMMAND $ "-d" "${test_data_dir}") - add_test(NAME rocsolver_rf_ir_test COMMAND $ "-d" "${test_data_dir}" "-i") + add_test(NAME rocsolver_rf_test COMMAND $ "-d" "${test_data_dir}") + add_test(NAME rocsolver_rf_ir_test COMMAND $ "-d" "${test_data_dir}" "-i") add_test(NAME sys_refactor_hip_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") add_test(NAME sys_refactor_hip_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") endif(RESOLVE_USE_HIP) From d9347c62194b5353cecf593ebe046fe13e94211c Mon Sep 17 00:00:00 2001 From: Achintya Sunil Date: Wed, 19 Nov 2025 14:00:17 -0500 Subject: [PATCH 9/9] Reverted CMake back to original --- tests/functionality/CMakeLists.txt | 219 ++++++++++++++++++++++------- 1 file changed, 169 insertions(+), 50 deletions(-) diff --git a/tests/functionality/CMakeLists.txt b/tests/functionality/CMakeLists.txt index 66343e961..ab8c24135 100644 --- a/tests/functionality/CMakeLists.txt +++ b/tests/functionality/CMakeLists.txt @@ -1,4 +1,5 @@ #[[ + @brief Build Re::Solve functionality tests @author Slaven Peles @@ -34,6 +35,7 @@ if(RESOLVE_USE_KLU) # System solver test with GLU (to be subsumed in testSysRefactor.cpp) add_executable(sys_glu_test.exe testSysGLU.cpp) target_link_libraries(sys_glu_test.exe PRIVATE ReSolve) + endif(RESOLVE_USE_CUDA) endif(RESOLVE_USE_KLU) @@ -42,7 +44,6 @@ if(RESOLVE_USE_LUSOL) target_link_libraries(lusol_test.exe PRIVATE ReSolve) endif() - # Install tests set(installable_tests version.exe) list(APPEND installable_tests rand_gmres_test.exe) @@ -51,8 +52,7 @@ list(APPEND installable_tests sys_rand_gmres_test.exe) if(RESOLVE_USE_KLU) list(APPEND installable_tests klu_klu_test.exe) if(RESOLVE_USE_GPU) - list(APPEND installable_tests klu_rf_test.exe - sys_refactor_test.exe) + list(APPEND installable_tests klu_rf_test.exe sys_refactor_test.exe) endif(RESOLVE_USE_GPU) if(RESOLVE_USE_CUDA) @@ -65,7 +65,8 @@ if(RESOLVE_USE_LUSOL) endif() install(TARGETS ${installable_tests} - RUNTIME DESTINATION bin/resolve/tests/functionality) + RUNTIME DESTINATION bin/resolve/tests/functionality +) # Install directory with data files install(DIRECTORY data DESTINATION bin/resolve/tests/functionality) @@ -77,71 +78,189 @@ set(sym_rhs_path /data/rhs_ACTIVSg200_AC_renumbered_add9_ones_) set(asym_matrix_path /data/A_asymmetric) set(asym_rhs_path /data/b_asymmetric) - add_test(NAME version COMMAND $) if(RESOLVE_USE_LUSOL) - add_test(NAME lusol_test COMMAND $ "${test_data_dir}") + add_test(NAME lusol_test COMMAND $ + "${test_data_dir}" + ) endif() # Krylov solvers tests (FGMRES) -add_test(NAME sys_rand_count_fgmres_cgs2_test COMMAND $ "-i" "randgmres" "-g" "cgs2" "-s" "count") -add_test(NAME sys_rand_count_fgmres_mgs_test COMMAND $ "-i" "randgmres" "-g" "mgs" "-s" "count") -add_test(NAME sys_rand_count_fgmres_mgs2sync_test COMMAND $ "-i" "randgmres" "-g" "mgs_two_sync" "-s" "count") -add_test(NAME sys_rand_count_fgmres_mgspm_test COMMAND $ "-i" "randgmres" "-g" "mgs_pm" "-s" "count") -add_test(NAME sys_rand_fwht_fgmres_cgs2_test COMMAND $ "-i" "randgmres" "-g" "cgs2" "-s" "fwht") -add_test(NAME sys_rand_fwht_fgmres_mgs_test COMMAND $ "-i" "randgmres" "-g" "mgs" "-s" "fwht") -add_test(NAME sys_rand_fwht_fgmres_mgs2sync_test COMMAND $ "-i" "randgmres" "-g" "mgs_two_sync" "-s" "fwht") -add_test(NAME sys_rand_fwht_fgmres_mgspm_test COMMAND $ "-i" "randgmres" "-g" "mgs_pm" "-s" "fwht") -add_test(NAME sys_fgmres_cgs2_test COMMAND $ "-i" "fgmres" "-g" "cgs2") -add_test(NAME sys_fgmres_mgs_test COMMAND $ "-i" "fgmres" "-g" "mgs") -add_test(NAME sys_fgmres_mgs2sync_test COMMAND $ "-i" "fgmres" "-g" "mgs_two_sync") -add_test(NAME sys_fgmres_mgspm_test COMMAND $ "-i" "fgmres" "-g" "mgs_pm") +add_test(NAME sys_rand_count_fgmres_cgs2_test + COMMAND $ "-i" "randgmres" "-g" + "cgs2" "-s" "count" +) +add_test(NAME sys_rand_count_fgmres_mgs_test + COMMAND $ "-i" "randgmres" "-g" + "mgs" "-s" "count" +) +add_test(NAME sys_rand_count_fgmres_mgs2sync_test + COMMAND $ "-i" "randgmres" "-g" + "mgs_two_sync" "-s" "count" +) +add_test(NAME sys_rand_count_fgmres_mgspm_test + COMMAND $ "-i" "randgmres" "-g" + "mgs_pm" "-s" "count" +) +add_test(NAME sys_rand_fwht_fgmres_cgs2_test + COMMAND $ "-i" "randgmres" "-g" + "cgs2" "-s" "fwht" +) +add_test(NAME sys_rand_fwht_fgmres_mgs_test + COMMAND $ "-i" "randgmres" "-g" + "mgs" "-s" "fwht" +) +add_test(NAME sys_rand_fwht_fgmres_mgs2sync_test + COMMAND $ "-i" "randgmres" "-g" + "mgs_two_sync" "-s" "fwht" +) +add_test(NAME sys_rand_fwht_fgmres_mgspm_test + COMMAND $ "-i" "randgmres" "-g" + "mgs_pm" "-s" "fwht" +) +add_test(NAME sys_fgmres_cgs2_test + COMMAND $ "-i" "fgmres" "-g" + "cgs2" +) +add_test(NAME sys_fgmres_mgs_test COMMAND $ + "-i" "fgmres" "-g" "mgs" +) +add_test(NAME sys_fgmres_mgs2sync_test + COMMAND $ "-i" "fgmres" "-g" + "mgs_two_sync" +) +add_test(NAME sys_fgmres_mgspm_test + COMMAND $ "-i" "fgmres" "-g" + "mgs_pm" +) # Krylov solvers tests (GMRES) -add_test(NAME sys_rand_count_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "cgs2" "-s" "count") -add_test(NAME sys_rand_count_gmres_mgs_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs" "-s" "count") -add_test(NAME sys_rand_count_gmres_mgs2sync_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_two_sync" "-s" "count") -add_test(NAME sys_rand_count_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_pm" "-s" "count") -add_test(NAME sys_rand_fwht_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "cgs2" "-s" "fwht") -add_test(NAME sys_rand_fwht_gmres_mgs_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs" "-s" "fwht") -add_test(NAME sys_rand_fwht_gmres_mgs2sync_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_two_sync" "-s" "fwht") -add_test(NAME sys_rand_fwht_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "randgmres" "-g" "mgs_pm" "-s" "fwht") -add_test(NAME sys_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "cgs2") -add_test(NAME sys_gmres_mgs_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs") -add_test(NAME sys_gmres_mgs2sync_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs_two_sync") -add_test(NAME sys_gmres_mgspm_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs_pm") - -# Adding bad initial guess test (GMRES) -add_test(NAME sys_bad_x0_gmres_cgs2_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "cgs2" "-b" "yes") -add_test(NAME sys_bad_x0_gmres_mgs_test COMMAND $ "-x" "no" "-i" "fgmres" "-g" "mgs" "-b" "yes") +add_test(NAME sys_rand_count_gmres_cgs2_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "cgs2" "-s" "count" +) +add_test(NAME sys_rand_count_gmres_mgs_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "mgs" "-s" "count" +) +add_test(NAME sys_rand_count_gmres_mgs2sync_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "mgs_two_sync" "-s" "count" +) +add_test(NAME sys_rand_count_gmres_mgspm_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "mgs_pm" "-s" "count" +) +add_test(NAME sys_rand_fwht_gmres_cgs2_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "cgs2" "-s" "fwht" +) +add_test(NAME sys_rand_fwht_gmres_mgs_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "mgs" "-s" "fwht" +) +add_test(NAME sys_rand_fwht_gmres_mgs2sync_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "mgs_two_sync" "-s" "fwht" +) +add_test(NAME sys_rand_fwht_gmres_mgspm_test + COMMAND $ "-x" "no" "-i" + "randgmres" "-g" "mgs_pm" "-s" "fwht" +) +add_test(NAME sys_gmres_cgs2_test COMMAND $ + "-x" "no" "-i" "fgmres" "-g" "cgs2" +) +add_test(NAME sys_gmres_mgs_test COMMAND $ + "-x" "no" "-i" "fgmres" "-g" "mgs" +) +add_test(NAME sys_gmres_mgs2sync_test + COMMAND $ "-x" "no" "-i" "fgmres" + "-g" "mgs_two_sync" +) +add_test(NAME sys_gmres_mgspm_test + COMMAND $ "-x" "no" "-i" "fgmres" + "-g" "mgs_pm" +) # Randomized GMRES solvers tested without SystemSolver class -add_test(NAME rand_gmres_test COMMAND $) +add_test(NAME rand_gmres_test COMMAND $) if(RESOLVE_USE_KLU) # Using KLU as refactorization solver - add_test(NAME klu_klu_test COMMAND $ "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") - add_test(NAME klu_klu_ir_test COMMAND $ "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}" "-i") - add_test(NAME klu_klu_asym_test COMMAND $ "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") - add_test(NAME klu_klu_asym_ir_test COMMAND $ "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}" "-i") + add_test(NAME klu_klu_test + COMMAND $ "-d" "${test_data_dir}" "-m" + "${sym_matrix_path}" "-r" "${sym_rhs_path}" + ) + add_test(NAME klu_klu_ir_test + COMMAND $ "-d" "${test_data_dir}" "-m" + "${sym_matrix_path}" "-r" "${sym_rhs_path}" "-i" + ) + add_test(NAME klu_klu_asym_test + COMMAND $ "-d" "${test_data_dir}" "-m" + "${asym_matrix_path}" "-r" "${asym_rhs_path}" + ) + add_test(NAME klu_klu_asym_ir_test + COMMAND $ "-d" "${test_data_dir}" "-m" + "${asym_matrix_path}" "-r" "${asym_rhs_path}" "-i" + ) # CUDA-SDK specific tests if(RESOLVE_USE_CUDA) - add_test(NAME klu_rf_cuda_test COMMAND $ "-d" "${test_data_dir}") - add_test(NAME klu_rf_ir_cuda_test COMMAND $ "-d" "${test_data_dir}" "-i") - add_test(NAME klu_glu_cuda_test COMMAND $ "-d" "${test_data_dir}" "-s" "glu") - add_test(NAME sys_refactor_cuda_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") - add_test(NAME sys_refactor_cuda_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") - add_test(NAME sys_glu_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") - add_test(NAME sys_glu_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") + add_test(NAME klu_rf_cuda_test COMMAND $ "-d" + "${test_data_dir}" + ) + add_test(NAME klu_rf_ir_cuda_test COMMAND $ + "-d" "${test_data_dir}" "-i" + ) + add_test(NAME klu_glu_cuda_test COMMAND $ "-d" + "${test_data_dir}" "-s" "glu" + ) + add_test( + NAME sys_refactor_cuda_test + COMMAND + $ "${test_data_dir}" "-d" + "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}" + ) + add_test( + NAME sys_refactor_cuda_asym_test + COMMAND + $ "${test_data_dir}" "-d" + "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}" + ) + add_test( + NAME sys_glu_test + COMMAND + $ "${test_data_dir}" "-d" + "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}" + ) + add_test( + NAME sys_glu_asym_test + COMMAND + $ "${test_data_dir}" "-d" + "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}" + ) endif(RESOLVE_USE_CUDA) # ROCm specific tests if(RESOLVE_USE_HIP) - add_test(NAME rocsolver_rf_test COMMAND $ "-d" "${test_data_dir}") - add_test(NAME rocsolver_rf_ir_test COMMAND $ "-d" "${test_data_dir}" "-i") - add_test(NAME sys_refactor_hip_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}") - add_test(NAME sys_refactor_hip_asym_test COMMAND $ "${test_data_dir}" "-d" "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}") + add_test(NAME rocsolver_rf_test COMMAND $ "-d" + "${test_data_dir}" + ) + add_test(NAME rocsolver_rf_ir_test COMMAND $ + "-d" "${test_data_dir}" "-i" + ) + add_test( + NAME sys_refactor_hip_test + COMMAND + $ "${test_data_dir}" "-d" + "${test_data_dir}" "-m" "${sym_matrix_path}" "-r" "${sym_rhs_path}" + ) + add_test( + NAME sys_refactor_hip_asym_test + COMMAND + $ "${test_data_dir}" "-d" + "${test_data_dir}" "-m" "${asym_matrix_path}" "-r" "${asym_rhs_path}" + ) endif(RESOLVE_USE_HIP) endif(RESOLVE_USE_KLU)