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"
|