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

            Line data    Source code
       1              : /**
       2              :  * @file linear_solver_redblack_omp.c
       3              :  * @brief Red-Black SOR solver - OpenMP parallel implementation
       4              :  *
       5              :  * Red-Black SOR characteristics:
       6              :  * - Two-color sweep (red then black) allows parallelization
       7              :  * - In-place updates (no temporary buffer needed)
       8              :  * - SOR acceleration (omega > 1) for faster convergence
       9              :  * - Best balance of convergence speed and parallelism
      10              :  */
      11              : 
      12              : #include "../linear_solver_internal.h"
      13              : 
      14              : #include "cfd/core/indexing.h"
      15              : #include "cfd/core/memory.h"
      16              : 
      17              : #include <math.h>
      18              : 
      19              : #ifdef CFD_ENABLE_OPENMP
      20              :     #include <omp.h>
      21              : #endif
      22              : 
      23              : /* ============================================================================
      24              :  * RED-BLACK CONTEXT
      25              :  * ============================================================================ */
      26              : 
      27              : typedef struct {
      28              :     double dx2;        /* dx^2 */
      29              :     double dy2;        /* dy^2 */
      30              :     double inv_dx2;    /* 1/dx^2 */
      31              :     double inv_dy2;    /* 1/dy^2 */
      32              :     double inv_dz2;    /* 1/dz^2 (0 for 2D) */
      33              :     double factor;     /* 2 * (1/dx^2 + 1/dy^2 + inv_dz2) */
      34              :     double inv_factor; /* 1 / factor */
      35              :     double omega;      /* SOR relaxation parameter */
      36              :     size_t stride_z;   /* nx*ny for 3D, 0 for 2D */
      37              :     size_t k_start;    /* first interior k index */
      38              :     size_t k_end;      /* one-past-last interior k index */
      39              :     int initialized;
      40              : } redblack_omp_context_t;
      41              : 
      42              : /* ============================================================================
      43              :  * RED-BLACK OPENMP IMPLEMENTATION
      44              :  * ============================================================================ */
      45              : 
      46              : #ifdef CFD_ENABLE_OPENMP
      47              : 
      48            7 : static cfd_status_t redblack_omp_init(
      49              :     poisson_solver_t* solver,
      50              :     size_t nx, size_t ny, size_t nz,
      51              :     double dx, double dy, double dz,
      52              :     const poisson_solver_params_t* params)
      53              : {
      54            7 :     redblack_omp_context_t* ctx = (redblack_omp_context_t*)cfd_calloc(1, sizeof(redblack_omp_context_t));
      55            7 :     if (!ctx) {
      56              :         return CFD_ERROR_NOMEM;
      57              :     }
      58              : 
      59            7 :     ctx->dx2 = dx * dx;
      60            7 :     ctx->dy2 = dy * dy;
      61            7 :     ctx->inv_dx2 = 1.0 / ctx->dx2;
      62            7 :     ctx->inv_dy2 = 1.0 / ctx->dy2;
      63            7 :     ctx->inv_dz2 = poisson_solver_compute_inv_dz2(dz);
      64            7 :     poisson_solver_compute_3d_bounds(nz, nx, ny, &ctx->stride_z, &ctx->k_start, &ctx->k_end);
      65            7 :     ctx->factor = 2.0 * (1.0 / ctx->dx2 + 1.0 / ctx->dy2 + ctx->inv_dz2);
      66            7 :     ctx->inv_factor = 1.0 / ctx->factor;
      67            7 :     ctx->omega = poisson_solver_resolve_omega(solver, params ? params->sor.omega : 0.0);
      68            7 :     ctx->initialized = 1;
      69              : 
      70            7 :     solver->context = ctx;
      71            7 :     return CFD_SUCCESS;
      72              : }
      73              : 
      74           10 : static void redblack_omp_destroy(poisson_solver_t* solver) {
      75           10 :     if (solver && solver->context) {
      76            7 :         cfd_free(solver->context);
      77            7 :         solver->context = NULL;
      78              :     }
      79           10 : }
      80              : 
      81          573 : static cfd_status_t redblack_omp_iterate(
      82              :     poisson_solver_t* solver,
      83              :     double* x,
      84              :     double* x_temp,
      85              :     const double* rhs,
      86              :     double* residual)
      87              : {
      88          573 :     (void)x_temp;
      89              : 
      90          573 :     redblack_omp_context_t* ctx = (redblack_omp_context_t*)solver->context;
      91          573 :     size_t nx = solver->nx;
      92          573 :     size_t ny = solver->ny;
      93          573 :     size_t nz = solver->nz;
      94          573 :     double dx2 = ctx->dx2;
      95          573 :     double dy2 = ctx->dy2;
      96          573 :     double inv_dz2 = ctx->inv_dz2;
      97          573 :     double inv_factor = ctx->inv_factor;
      98          573 :     double omega = ctx->omega;
      99          573 :     size_t stride_z = ctx->stride_z;
     100          573 :     size_t k_start = ctx->k_start;
     101          573 :     size_t k_end = ctx->k_end;
     102          573 :     int walls = poisson_solver_uses_default_walls(solver);
     103              : 
     104              :     /* Red sweep (parallel) */
     105         3344 :     for (size_t k = k_start; k < k_end; k++) {
     106         2771 :         int j;
     107         2771 : #pragma omp parallel for schedule(static)
     108              :         for (j = 1; j < (int)ny - 1; j++) {
     109              :             double w_row, w_edge;
     110              :             poisson_solver_row_omegas(walls, omega, ctx->factor, nx, ny, nz, (size_t)j, k,
     111              :                                       ctx->inv_dx2, ctx->inv_dy2, inv_dz2, &w_row, &w_edge);
     112              :             size_t i_start = ((j + k) % 2 == 0) ? 1 : 2;
     113              :             size_t i;
     114              :             for (i = i_start; i < nx - 1; i += 2) {
     115              :                 size_t idx = k * stride_z + IDX_2D(i, (size_t)j, nx);
     116              : 
     117              :                 double p_new = -(rhs[idx]
     118              :                     - (x[idx + 1] + x[idx - 1]) / dx2
     119              :                     - (x[idx + nx] + x[idx - nx]) / dy2
     120              :                     - (x[idx + stride_z] + x[idx - stride_z]) * inv_dz2
     121              :                     ) * inv_factor;
     122              : 
     123              :                 double w = (i == 1 || i == nx - 2) ? w_edge : w_row;
     124              :                 x[idx] = x[idx] + w * (p_new - x[idx]);
     125              :             }
     126              :         }
     127              :     }
     128              : 
     129              :     /* Black sweep (parallel) */
     130         3344 :     for (size_t k = k_start; k < k_end; k++) {
     131         2771 :         int j;
     132         2771 : #pragma omp parallel for schedule(static)
     133              :         for (j = 1; j < (int)ny - 1; j++) {
     134              :             double w_row, w_edge;
     135              :             poisson_solver_row_omegas(walls, omega, ctx->factor, nx, ny, nz, (size_t)j, k,
     136              :                                       ctx->inv_dx2, ctx->inv_dy2, inv_dz2, &w_row, &w_edge);
     137              :             size_t i_start = ((j + k) % 2 == 0) ? 2 : 1;
     138              :             size_t i;
     139              :             for (i = i_start; i < nx - 1; i += 2) {
     140              :                 size_t idx = k * stride_z + IDX_2D(i, (size_t)j, nx);
     141              : 
     142              :                 double p_new = -(rhs[idx]
     143              :                     - (x[idx + 1] + x[idx - 1]) / dx2
     144              :                     - (x[idx + nx] + x[idx - nx]) / dy2
     145              :                     - (x[idx + stride_z] + x[idx - stride_z]) * inv_dz2
     146              :                     ) * inv_factor;
     147              : 
     148              :                 double w = (i == 1 || i == nx - 2) ? w_edge : w_row;
     149              :                 x[idx] = x[idx] + w * (p_new - x[idx]);
     150              :             }
     151              :         }
     152              :     }
     153              : 
     154              :     /* Apply boundary conditions */
     155          573 :     poisson_solver_apply_bc(solver, x);
     156              : 
     157              :     /* Compute residual if requested */
     158          573 :     if (residual) {
     159          573 :         *residual = poisson_solver_compute_residual(solver, x, rhs);
     160              :     }
     161              : 
     162          573 :     return CFD_SUCCESS;
     163              : }
     164              : 
     165              : #endif /* CFD_ENABLE_OPENMP */
     166              : 
     167              : /* ============================================================================
     168              :  * FACTORY FUNCTION
     169              :  * ============================================================================ */
     170              : 
     171              : #ifdef CFD_ENABLE_OPENMP
     172           10 : poisson_solver_t* create_redblack_omp_solver(void) {
     173           10 :     poisson_solver_t* solver = (poisson_solver_t*)cfd_calloc(1, sizeof(poisson_solver_t));
     174           10 :     if (!solver) {
     175              :         return NULL;
     176              :     }
     177              : 
     178           10 :     solver->name = POISSON_SOLVER_TYPE_REDBLACK_OMP;
     179           10 :     solver->description = "Red-Black SOR iteration (OpenMP parallel)";
     180           10 :     solver->method = POISSON_METHOD_REDBLACK_SOR;
     181           10 :     solver->backend = POISSON_BACKEND_OMP;
     182           10 :     solver->params = poisson_solver_params_default();
     183              : 
     184           10 :     solver->init = redblack_omp_init;
     185           10 :     solver->destroy = redblack_omp_destroy;
     186           10 :     solver->solve = NULL;
     187           10 :     solver->iterate = redblack_omp_iterate;
     188           10 :     solver->apply_bc = NULL;
     189              : 
     190           10 :     return solver;
     191              : }
     192              : #endif
        

Generated by: LCOV version 2.0-1