LCOV - code coverage report
Current view: top level - solvers/linear/cpu - linear_solver_gmres.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 100.0 % 57 57
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 2 2

            Line data    Source code
       1              : /**
       2              :  * @file linear_solver_gmres.c
       3              :  * @brief Restarted GMRES(m) solver - scalar CPU implementation
       4              :  *
       5              :  * Reference backend. Supplies the scalar O(n) vector primitives to the shared
       6              :  * GMRES(m) algorithm template (gmres_template/linear_solver_gmres_template.h),
       7              :  * which documents the algorithm and holds its only implementation.
       8              :  */
       9              : 
      10              : #include "../linear_solver_internal.h"
      11              : 
      12              : #include "cfd/core/indexing.h"
      13              : 
      14              : /* ============================================================================
      15              :  * O(n) VECTOR PRIMITIVES (interior points only)
      16              :  *
      17              :  * dot_product / axpy / apply_laplacian / compute_residual / copy_vector /
      18              :  * apply_jacobi_precond mirror linear_solver_cg.c exactly. scale_vector is the
      19              :  * GMRES-specific addition.
      20              :  * ============================================================================ */
      21              : 
      22              : /** Dot product over interior points */
      23        13554 : static double dot_product(const double* a, const double* b,
      24              :                           size_t nx, size_t ny,
      25              :                           size_t k_start, size_t k_end, size_t stride_z) {
      26        13554 :     double sum = 0.0;
      27        31632 :     for (size_t k = k_start; k < k_end; k++) {
      28       387632 :         for (size_t j = 1; j < ny - 1; j++) {
      29     10458304 :             for (size_t i = 1; i < nx - 1; i++) {
      30     10088750 :                 size_t idx = (k * stride_z) + (IDX_2D(i, j, nx));
      31     10088750 :                 sum += a[idx] * b[idx];
      32              :             }
      33              :         }
      34              :     }
      35        11988 :     return sum;
      36              : }
      37              : 
      38              : /** y = y + alpha * x (interior points only) */
      39        13318 : static void axpy(double alpha, const double* x, double* y,
      40              :                  size_t nx, size_t ny,
      41              :                  size_t k_start, size_t k_end, size_t stride_z) {
      42        31038 :     for (size_t k = k_start; k < k_end; k++) {
      43       380728 :         for (size_t j = 1; j < ny - 1; j++) {
      44     10296200 :             for (size_t i = 1; i < nx - 1; i++) {
      45      9933184 :                 size_t idx = (k * stride_z) + (IDX_2D(i, j, nx));
      46      9933184 :                 y[idx] += alpha * x[idx];
      47              :             }
      48              :         }
      49              :     }
      50              : }
      51              : 
      52              : /** x = alpha * x (interior points only) */
      53         1520 : static void scale_vector(double alpha, double* x,
      54              :                          size_t nx, size_t ny,
      55              :                          size_t k_start, size_t k_end, size_t stride_z) {
      56         3622 :     for (size_t k = k_start; k < k_end; k++) {
      57        42000 :         for (size_t j = 1; j < ny - 1; j++) {
      58      1055456 :             for (size_t i = 1; i < nx - 1; i++) {
      59      1015558 :                 size_t idx = (k * stride_z) + (IDX_2D(i, j, nx));
      60      1015558 :                 x[idx] *= alpha;
      61              :             }
      62              :         }
      63              :     }
      64              : }
      65              : 
      66              : /**
      67              :  * Apply negative Laplacian operator: Ap = -nabla^2(p) (matches CG's A = -nabla^2).
      68              :  */
      69         1330 : static void apply_laplacian(const double* p, double* Ap,
      70              :                             size_t nx, size_t ny,
      71              :                             double dx2, double dy2, double inv_dz2,
      72              :                             size_t k_start, size_t k_end, size_t stride_z) {
      73         1330 :     double dx2_inv = 1.0 / dx2;
      74         1330 :     double dy2_inv = 1.0 / dy2;
      75              : 
      76         3206 :     for (size_t k = k_start; k < k_end; k++) {
      77        37488 :         for (size_t j = 1; j < ny - 1; j++) {
      78       949600 :             for (size_t i = 1; i < nx - 1; i++) {
      79       913988 :                 size_t idx = (k * stride_z) + (IDX_2D(i, j, nx));
      80              : 
      81       913988 :                 double laplacian =
      82       913988 :                     ((p[idx + 1] - (2.0 * p[idx]) + p[idx - 1]) * dx2_inv)
      83       913988 :                   + ((p[idx + (nx)] - (2.0 * p[idx]) + p[idx - (nx)]) * dy2_inv)
      84       913988 :                   + ((p[idx + (stride_z)] + p[idx - (stride_z)] - (2.0 * p[idx])) * inv_dz2);
      85       913988 :                 Ap[idx] = -laplacian;
      86              :             }
      87              :         }
      88              :     }
      89         1330 : }
      90              : 
      91              : /**
      92              :  * Compute residual r = b - A x = -rhs + nabla^2 x (matches CG convention).
      93              :  */
      94          236 : static void compute_residual(const double* x, const double* rhs, double* r,
      95              :                              size_t nx, size_t ny,
      96              :                              double dx2, double dy2, double inv_dz2,
      97              :                              size_t k_start, size_t k_end, size_t stride_z) {
      98          236 :     double dx2_inv = 1.0 / dx2;
      99          236 :     double dy2_inv = 1.0 / dy2;
     100              : 
     101          628 :     for (size_t k = k_start; k < k_end; k++) {
     102         7184 :         for (size_t j = 1; j < ny - 1; j++) {
     103       165984 :             for (size_t i = 1; i < nx - 1; i++) {
     104       159192 :                 size_t idx = (k * stride_z) + (IDX_2D(i, j, nx));
     105              : 
     106       159192 :                 double laplacian =
     107       159192 :                     ((x[idx + 1] - (2.0 * x[idx]) + x[idx - 1]) * dx2_inv)
     108       159192 :                   + ((x[idx + (nx)] - (2.0 * x[idx]) + x[idx - (nx)]) * dy2_inv)
     109       159192 :                   + ((x[idx + (stride_z)] + x[idx - (stride_z)] - (2.0 * x[idx])) * inv_dz2);
     110              : 
     111       159192 :                 r[idx] = -rhs[idx] + laplacian;
     112              :             }
     113              :         }
     114              :     }
     115          236 : }
     116              : 
     117              : /** Copy dst = src (interior points only) */
     118         1326 : static void copy_vector(const double* src, double* dst,
     119              :                         size_t nx, size_t ny,
     120              :                         size_t k_start, size_t k_end, size_t stride_z) {
     121         3156 :     for (size_t k = k_start; k < k_end; k++) {
     122        36736 :         for (size_t j = 1; j < ny - 1; j++) {
     123       937808 :             for (size_t i = 1; i < nx - 1; i++) {
     124       902902 :                 size_t idx = (k * stride_z) + (IDX_2D(i, j, nx));
     125       902902 :                 dst[idx] = src[idx];
     126              :             }
     127              :         }
     128              :     }
     129              : }
     130              : 
     131              : /** Apply Jacobi preconditioner: z = M^{-1} r = diag_inv * r (interior points) */
     132              : static void apply_jacobi_precond(const double* r, double* z,
     133              :                                  size_t nx, size_t ny,
     134              :                                  double diag_inv,
     135              :                                  size_t k_start, size_t k_end, size_t stride_z) {
     136          576 :     for (size_t k = k_start; k < k_end; k++) {
     137         4968 :         for (size_t j = 1; j < ny - 1; j++) {
     138        77400 :             for (size_t i = 1; i < nx - 1; i++) {
     139        72855 :                 size_t idx = (k * stride_z) + (IDX_2D(i, j, nx));
     140        72855 :                 z[idx] = diag_inv * r[idx];
     141              :             }
     142              :         }
     143              :     }
     144              : }
     145              : 
     146              : /* ============================================================================
     147              :  * ALGORITHM (shared GMRES(m) template)
     148              :  * ============================================================================ */
     149              : 
     150              : #define GMRES_SUFFIX            scalar
     151              : #define GMRES_SOLVER_NAME       POISSON_SOLVER_TYPE_GMRES_SCALAR
     152              : #define GMRES_DESCRIPTION       "Restarted GMRES(m) (scalar CPU)"
     153              : #define GMRES_BACKEND           POISSON_BACKEND_SCALAR
     154              : #define GMRES_LOG_TAG           "GMRES"
     155              : #define GMRES_VEC_CALLOC(count) cfd_calloc((count), sizeof(double))
     156              : #define GMRES_VEC_FREE(ptr)     cfd_free(ptr)
     157              : 
     158              : #define GMRES_DOT               dot_product
     159              : #define GMRES_AXPY              axpy
     160              : #define GMRES_SCALE             scale_vector
     161              : #define GMRES_COPY              copy_vector
     162              : #define GMRES_APPLY_A           apply_laplacian
     163              : #define GMRES_RESIDUAL          compute_residual
     164              : #define GMRES_PRECOND           apply_jacobi_precond
     165              : 
     166              : #include "../gmres_template/linear_solver_gmres_template.h"
        

Generated by: LCOV version 2.0-1