From ab72ad7bb19f08d78218d3558545f9f58e5b36e7 Mon Sep 17 00:00:00 2001 From: Anton Khirnov Date: Thu, 25 Jun 2020 20:51:02 +0200 Subject: Switch to external ndarray library. --- mg2d.c | 70 +++++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 35 insertions(+), 35 deletions(-) (limited to 'mg2d.c') diff --git a/mg2d.c b/mg2d.c index 3255ce7..08a91df 100644 --- a/mg2d.c +++ b/mg2d.c @@ -26,6 +26,7 @@ #include #include +#include #include "common.h" #include "components.h" @@ -36,7 +37,6 @@ #include "mg2d_boundary.h" #include "mg2d_boundary_internal.h" #include "mg2d_constants.h" -#include "ndarray.h" #include "timer.h" #include "transfer.h" @@ -505,7 +505,7 @@ static int restrict_diff_coeffs(MG2DContext *ctx, MG2DLevel *l) NDArray *a_dc = l->depth > 0 ? l->solver->diff_coeffs[dc_idx] : priv->diff_coeffs_tmp[dc_idx]; if (!l->depth) - mg2di_ndarray_copy(a_dc, priv->root->solver->diff_coeffs[dc_idx]); + ndarray_copy(a_dc, priv->root->solver->diff_coeffs[dc_idx]); for (int bnd_idx = 0; bnd_idx < ARRAY_ELEMS(dc->boundaries); bnd_idx++) { const int ci = mg2d_bnd_coord_idx(bnd_idx); @@ -636,12 +636,12 @@ static int diff_coeffs_fixup(MG2DContext *ctx, MG2DLevel *l) const ptrdiff_t stride_dst = a_dst->stride[ci]; const size_t size_dst = l->solver->domain_size[!ci]; - ret = mg2di_ndarray_slice(&dc_src, priv->dc_bnd_val[i][bnd_idx], - &SLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1)); + ret = ndarray_slice(&dc_src, priv->dc_bnd_val[i][bnd_idx], + &NDASLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1)); if (ret < 0) goto fail; - ret = mg2di_ndarray_alloc(&dc_dst, 1, &size_dst, 0); + ret = ndarray_alloc(&dc_dst, 1, &size_dst, 0); if (ret < 0) goto fail; @@ -675,8 +675,8 @@ static int diff_coeffs_fixup(MG2DContext *ctx, MG2DLevel *l) fail: mg2di_gt_free(>_bnd); - mg2di_ndarray_free(&dc_src); - mg2di_ndarray_free(&dc_dst); + ndarray_free(&dc_src); + ndarray_free(&dc_dst); if (ret < 0) return ret; } @@ -788,26 +788,26 @@ static int mg_levels_init(MG2DContext *ctx) prev = NULL; if (priv->u) { - ret = mg2di_ndarray_copy(cur->solver->u, priv->u); + ret = ndarray_copy(cur->solver->u, priv->u); if (ret < 0) return ret; - mg2di_ndarray_free(&priv->u); + ndarray_free(&priv->u); ctx->u = cur->solver->u->data; ctx->u_stride = cur->solver->u->stride[0]; } if (priv->rhs) { - ret = mg2di_ndarray_copy(cur->solver->rhs, priv->rhs); + ret = ndarray_copy(cur->solver->rhs, priv->rhs); if (ret < 0) return ret; - mg2di_ndarray_free(&priv->rhs); + ndarray_free(&priv->rhs); ctx->rhs = cur->solver->rhs->data; ctx->rhs_stride = cur->solver->rhs->stride[0]; } if (ctx->diff_coeffs[0]->data == priv->diff_coeffs_tmp[0]->data) { for (int i = 0; i < ARRAY_ELEMS(ctx->diff_coeffs); i++) { - mg2di_ndarray_copy(cur->solver->diff_coeffs[i], priv->diff_coeffs_tmp[i]); + ndarray_copy(cur->solver->diff_coeffs[i], priv->diff_coeffs_tmp[i]); ctx->diff_coeffs[i]->data = cur->solver->diff_coeffs[i]->data; ctx->diff_coeffs[i]->stride = cur->solver->diff_coeffs[i]->stride[0]; } @@ -1139,7 +1139,7 @@ int mg2d_solve(MG2DContext *ctx) mg2di_log(&priv->logger, MG2D_LOG_INFO, "converged on iteration %d, residual %g\n", i, res_cur); - //mg2di_ndarray_copy(priv->u, s_root->u); + //ndarray_copy(priv->u, s_root->u); goto finish; } @@ -1214,11 +1214,11 @@ static void mg_level_free(MG2DLevel **plevel) free(level->prolong_recvcounts); free(level->prolong_recvdispl); - mg2di_ndarray_free(&level->restrict_dst); - mg2di_ndarray_free(&level->prolong_dst); + ndarray_free(&level->restrict_dst); + ndarray_free(&level->prolong_dst); - mg2di_ndarray_free(&level->prolong_tmp); - mg2di_ndarray_free(&level->prolong_tmp_base); + ndarray_free(&level->prolong_tmp); + ndarray_free(&level->prolong_tmp_base); mg2di_egs_free(&level->solver); mg2di_gt_free(&level->transfer_restrict); @@ -1247,12 +1247,12 @@ static MG2DLevel *mg_level_alloc(const DomainGeometry *dg, level->mpi_comm = comm; - ret = mg2di_ndarray_alloc(&level->prolong_tmp_base, 2, + ret = ndarray_alloc(&level->prolong_tmp_base, 2, (size_t [2]){dc->interior.size[1] + 1, dc->interior.size[0] + 1}, 0); if (ret < 0) goto fail; - ret = mg2di_ndarray_slice(&level->prolong_tmp, level->prolong_tmp_base, (Slice [2]){ SLICE(0, -1, 1), SLICE(0, -1, 1) }); + ret = ndarray_slice(&level->prolong_tmp, level->prolong_tmp_base, (NDASlice [2]){ NDASLICE(0, -1, 1), NDASLICE(0, -1, 1) }); if (ret < 0) goto fail; @@ -1359,12 +1359,12 @@ static int mg_interdomain_setup(MG2DContext *ctx, MG2DLevel *level) if (dg_fine->nb_components == 1) goto finish; - ret = mg2di_ndarray_alloc(&level->restrict_dst, 2, + ret = ndarray_alloc(&level->restrict_dst, 2, (size_t [2]){ restrict_components[lc].size[1], restrict_components[lc].size[0] }, 0); if (ret < 0) goto finish; - ret = mg2di_ndarray_alloc(&level->prolong_dst, 2, + ret = ndarray_alloc(&level->prolong_dst, 2, (size_t [2]){ prolong_components[lc].size[1], prolong_components[lc].size[0] }, 0); if (ret < 0) goto finish; @@ -1600,14 +1600,14 @@ static MG2DContext *solver_alloc(DomainGeometry *dg, unsigned int local_componen } } - ret = mg2di_ndarray_alloc(&priv->u, 2, (size_t [2]){ domain_size[1], domain_size[0] }, + ret = ndarray_alloc(&priv->u, 2, (size_t [2]){ domain_size[1], domain_size[0] }, NDARRAY_ALLOC_ZERO); if (ret < 0) goto fail; ctx->u = priv->u->data; ctx->u_stride = priv->u->stride[0]; - ret = mg2di_ndarray_alloc(&priv->rhs, 2, (size_t [2]){ domain_size[1], domain_size[0] }, + ret = ndarray_alloc(&priv->rhs, 2, (size_t [2]){ domain_size[1], domain_size[0] }, NDARRAY_ALLOC_ZERO); if (ret < 0) goto fail; @@ -1616,17 +1616,17 @@ static MG2DContext *solver_alloc(DomainGeometry *dg, unsigned int local_componen for (int i = 0; i < ARRAY_ELEMS(ctx->diff_coeffs); i++) { MG2DDiffCoeffs *dc; - const Slice slice[2] = { SLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1), - SLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1) }; + const NDASlice slice[2] = { NDASLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1), + NDASLICE(FD_STENCIL_MAX, -FD_STENCIL_MAX, 1) }; - ret = mg2di_ndarray_alloc(&priv->diff_coeffs_base[i], 2, + ret = ndarray_alloc(&priv->diff_coeffs_base[i], 2, (size_t [2]){ domain_size[1] + 2 * FD_STENCIL_MAX, domain_size[0] + 2 * FD_STENCIL_MAX }, NDARRAY_ALLOC_ZERO); if (ret < 0) goto fail; - ret = mg2di_ndarray_slice(&priv->diff_coeffs_tmp[i], priv->diff_coeffs_base[i], slice); + ret = ndarray_slice(&priv->diff_coeffs_tmp[i], priv->diff_coeffs_base[i], slice); if (ret < 0) goto fail; @@ -1641,7 +1641,7 @@ static MG2DContext *solver_alloc(DomainGeometry *dg, unsigned int local_componen for (int bnd_idx = 0; bnd_idx < ARRAY_ELEMS(dc->boundaries); bnd_idx++) { const int ci = mg2d_bnd_coord_idx(bnd_idx); - ret = mg2di_ndarray_alloc(&priv->dc_bnd_val[i][bnd_idx], 1, + ret = ndarray_alloc(&priv->dc_bnd_val[i][bnd_idx], 1, (size_t [1]){ dg->domain_size[!ci] + 2 * FD_STENCIL_MAX }, NDARRAY_ALLOC_ZERO); if (ret < 0) @@ -1820,15 +1820,15 @@ void mg2d_solver_free(MG2DContext **pctx) mg2di_gt_free(&ctx->priv->transfer_init); - mg2di_ndarray_free(&ctx->priv->u); - mg2di_ndarray_free(&ctx->priv->rhs); + ndarray_free(&ctx->priv->u); + ndarray_free(&ctx->priv->rhs); for (int i = 0; i < ARRAY_ELEMS(ctx->priv->diff_coeffs_base); i++) { for (int j = 0; j < ARRAY_ELEMS(ctx->priv->dc_bnd_val[i]); j++) - mg2di_ndarray_free(&ctx->priv->dc_bnd_val[i][j]); + ndarray_free(&ctx->priv->dc_bnd_val[i][j]); free(ctx->diff_coeffs[i]); - mg2di_ndarray_free(&ctx->priv->diff_coeffs_tmp[i]); - mg2di_ndarray_free(&ctx->priv->diff_coeffs_base[i]); + ndarray_free(&ctx->priv->diff_coeffs_tmp[i]); + ndarray_free(&ctx->priv->diff_coeffs_base[i]); } mg2di_dg_free(&ctx->priv->dg); @@ -2019,13 +2019,13 @@ int mg2d_init_guess(MG2DContext *ctx, const double *src, return ret; } - ret = mg2di_ndarray_wrap(&a_src, 2, (size_t [2]){ src_size[1], src_size[0] }, src, + ret = ndarray_wrap(&a_src, 2, (size_t [2]){ src_size[1], src_size[0] }, src, (ptrdiff_t [2]){ src_stride, 1 }); if (ret < 0) return ret; ret = mg2di_gt_transfer(priv->transfer_init, priv->u ? priv->u : priv->root->solver->u, a_src); - mg2di_ndarray_free(&a_src); + ndarray_free(&a_src); return ret; } -- cgit v1.2.3