eschnett/cactusamrex - Change DTKQAPJB6JCJZYLQ4MOFA5QHDCCIQ3KG5ED6PVF5PGEH33YSJFBAC

CarpetX: New looping construct for looping over ghosts There are now two looping constructs for ghost zones: - loop_ghosts: Loop over ghost points, but exclude boundary points - loop_ghosts_incl: Loop over ghosts, and also over boundary points that are ghost points

Created by Erik Schnetter on January 11, 2020

DTKQAPJB6JCJZYLQ4MOFA5QHDCCIQ3KG5ED6PVF5PGEH33YSJFBAC

Dependencies

In channels

master

main

Change contents

Replacement in CarpetX/src/loop.hxx at line 246 [5.5481]

B:BD[3.9951] → [4.2416:2479]

enum class where_t { everywhere, interior, boundary, ghosts };

[3.9869]

[6.6221]

enum class where_t { everywhere, interior, boundary, ghosts_inclusive, ghosts };

Insertion in CarpetX/src/loop.hxx at line 331 [5.5481]

[3.10414]

[5.7089]


    const auto kernel{[&](const int i, const int j,
                          const int k) CCTK_ATTRIBUTE_ALWAYS_INLINE {
      const CCTK_REAL x = x0[0] + (lbnd[0] + i + CCTK_REAL(CI - 1) / 2) * dx[0];
      const CCTK_REAL y = x0[1] + (lbnd[1] + j + CCTK_REAL(CJ - 1) / 2) * dx[1];
      const CCTK_REAL z = x0[2] + (lbnd[2] + k + CCTK_REAL(CK - 1) / 2) * dx[2];
      const int idx = i * di + j * dj + k * dk;
      const vect<int, dim> I{{i, j, k}};
      const PointDesc p{i, j, k, x, y, z, idx, dj, dk, I, inormal};
      f(p);
    }};
    array<bool, dim> bforward;
    for (int d = 0; d < dim; ++d)
      bforward[d] = inormal[d] >= 0;
    bool all_forward = true;
    for (int d = 0; d < dim; ++d)
      all_forward &= bforward[d];
    if (all_forward) {
      for (int k = imin[2]; k < imax[2]; ++k) {
        for (int j = imin[1]; j < imax[1]; ++j) {
#pragma omp simd
          for (int i = imin[0]; i < imax[0]; ++i) {
            kernel(i, j, k);
          }
        }
      }

Replacement in CarpetX/src/loop.hxx at line 361 [5.5481]

B:BD[5.7090] → [5.7090:7184]

    for (int k = imin[2]; k < imax[2]; ++k) {
      for (int j = imin[1]; j < imax[1]; ++j) {

[5.7090]

[5.7184]

    } else {
      // At least one direction is reversed; loop from the inside out
      for (int k0 = 0; k0 < imax[2] - imin[2]; ++k0) {
        for (int j0 = 0; j0 < imax[1] - imin[1]; ++j0) {

Replacement in CarpetX/src/loop.hxx at line 367 [5.5481]

B:BD[5.7201] → [5.7201:7251]

B:BD[5.7251] → [3.10415:10652]

∅:D[3.10652] → [5.7251:7297]

B:BD[5.7251] → [5.7251:7297]

B:BD[5.7297] → [7.1758:1797]

B:BD[7.1797] → [4.2745:2817]

∅:D[8.562] → [3.10734:10750]

∅:D[7.1860] → [3.10734:10750]

∅:D[4.2817] → [3.10734:10750]

B:BD[3.10734] → [3.10734:10750]

        for (int i = imin[0]; i < imax[0]; ++i) {
          CCTK_REAL x = x0[0] + (lbnd[0] + i + CCTK_REAL(CI - 1) / 2) * dx[0];
          CCTK_REAL y = x0[1] + (lbnd[1] + j + CCTK_REAL(CJ - 1) / 2) * dx[1];
          CCTK_REAL z = x0[2] + (lbnd[2] + k + CCTK_REAL(CK - 1) / 2) * dx[2];
          int idx = i * di + j * dj + k * dk;
          vect<int, dim> I{{i, j, k}};
          const PointDesc p{i, j, k, x, y, z, idx, dj, dk, I, inormal};
          f(p);

[5.7201]

[5.7324]

          for (int i0 = 0; i0 < imax[0] - imin[0]; ++i0) {
            const int i = bforward[0] ? imin[0] + i0 : imax[0] - 1 - i0;
            const int j = bforward[1] ? imin[1] + j0 : imax[1] - 1 - j0;
            const int k = bforward[2] ? imin[2] + k0 : imax[2] - 1 - k0;
            kernel(i, j, k);
          }

Replacement in CarpetX/src/loop.hxx at line 410 [5.5481]

B:BD[5.7993] → [5.7993:8047]

  // includes ghost edges/corners on non-ghost faces.

[5.7993]

[3.11346]

  // includes ghost edges/corners on non-ghost faces. Loop over faces first,
  // then edges, then corners.

Replacement in CarpetX/src/loop.hxx at line 416 [5.5481]

B:BD[3.11484] → [4.3018:3321]

    for (int nk = -1; nk <= +1; ++nk) {
      for (int nj = -1; nj <= +1; ++nj) {
        for (int ni = -1; ni <= +1; ++ni) {
          if ((ni != 0 && bbox[0 + (ni == -1 ? 0 : 1)]) ||
              (nj != 0 && bbox[2 + (nj == -1 ? 0 : 1)]) ||
              (nk != 0 && bbox[4 + (nk == -1 ? 0 : 1)])) {

[3.11484]

[4.3321]

    for (int rank = dim - 1; rank >= 0; --rank) {
      for (int nk = -1; nk <= +1; ++nk) {
        for (int nj = -1; nj <= +1; ++nj) {
          for (int ni = -1; ni <= +1; ++ni) {
            if ((ni == 0) + (nj == 0) + (nk == 0) == rank) {
              if ((ni != 0 && bbox[0 + (ni == -1 ? 0 : 1)]) ||
                  (nj != 0 && bbox[2 + (nj == -1 ? 0 : 1)]) ||
                  (nk != 0 && bbox[4 + (nk == -1 ? 0 : 1)])) {

Replacement in CarpetX/src/loop.hxx at line 427 [5.5481]

B:BD[4.3322] → [4.3322:3377]

            const array<int, dim> inormal{ni, nj, nk};

[4.3322]

[5.8228]

                const array<int, dim> inormal{ni, nj, nk};

Replacement in CarpetX/src/loop.hxx at line 429 [5.5481]

B:BD[5.8229] → [4.3378:4285]

            array<int, dim> imin, imax;
            for (int d = 0; d < dim; ++d) {
              const int ghost_offset = nghostzones[d] - group_nghostzones[d];
              const int begin_bnd = ghost_offset;
              const int begin_int = nghostzones[d];
              const int end_int = lsh[d] + offset[d] - nghostzones[d];
              const int end_bnd = lsh[d] + offset[d] - ghost_offset;
              switch (inormal[d]) {
              case -1: // lower boundary
                imin[d] = begin_bnd;
                imax[d] = begin_int;
                break;
              case 0: // interior
                imin[d] = begin_int;
                imax[d] = end_int;
                break;
              case +1: // upper boundary
                imin[d] = end_int;
                imax[d] = end_bnd;
                break;
              default:
                assert(0);
              }

[5.8229]

[5.8440]

                array<int, dim> imin, imax;
                for (int d = 0; d < dim; ++d) {
                  const int ghost_offset =
                      nghostzones[d] - group_nghostzones[d];
                  const int begin_bnd = ghost_offset;
                  const int begin_int = nghostzones[d];
                  const int end_int = lsh[d] + offset[d] - nghostzones[d];
                  const int end_bnd = lsh[d] + offset[d] - ghost_offset;
                  switch (inormal[d]) {
                  case -1: // lower boundary
                    imin[d] = begin_bnd;
                    imax[d] = begin_int;
                    break;
                  case 0: // interior
                    imin[d] = begin_int;
                    imax[d] = end_int;
                    break;
                  case +1: // upper boundary
                    imin[d] = end_int;
                    imax[d] = end_bnd;
                    break;
                  default:
                    assert(0);
                  }

Replacement in CarpetX/src/loop.hxx at line 454 [5.5481]

B:BD[5.8441] → [2.370:545]

∅:D[3.11608] → [5.8724:8738]

∅:D[4.4436] → [5.8724:8738]

∅:D[2.545] → [5.8724:8738]

B:BD[5.8724] → [5.8724:8738]

              imin[d] = std::max(tmin[d], imin[d]);
              imax[d] = std::min(tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0),
                                 imax[d]);
            }

[5.8441]

[5.8930]

                  imin[d] = std::max(tmin[d], imin[d]);
                  imax[d] = std::min(
                      tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0), imax[d]);
                }

Replacement in CarpetX/src/loop.hxx at line 459 [5.5481]

B:BD[5.8931] → [4.4437:4495]

            loop_box<CI, CJ, CK>(f, imin, imax, inormal);

[5.8931]

[5.9063]

                loop_box<CI, CJ, CK>(f, imin, imax, inormal);
              }
            } // if rank

Replacement in CarpetX/src/loop.hxx at line 465 [5.5481]
B:BD[4.4514] → [4.4514:4520]
```
    }
```
[4.4514]
[4.4520]
```
    } // for rank
```
Replacement in CarpetX/src/loop.hxx at line 470 [5.5481]
B:BD[4.4601] → [4.4601:4623]
```
  // non-ghost faces.
```
[4.4601]
[4.4623]
```
  // non-ghost faces. Loop over faces first, then edges, then corners.
```

Replacement in CarpetX/src/loop.hxx at line 472 [5.5481]

B:BD[4.4671] → [4.4671:4752]

  void loop_ghosts(const array<int, dim> &group_nghostzones, const F &f) const {

[4.4671]

[4.4752]

  void loop_ghosts_inclusive(const array<int, dim> &group_nghostzones,
                             const F &f) const {

Replacement in CarpetX/src/loop.hxx at line 476 [5.5481]

B:BD[5.9076] → [4.4806:5112]

    for (int nk = -1; nk <= +1; ++nk) {
      for (int nj = -1; nj <= +1; ++nj) {
        for (int ni = -1; ni <= +1; ++ni) {
          if ((ni != 0 && !bbox[0 + (ni == -1 ? 0 : 1)]) ||
              (nj != 0 && !bbox[2 + (nj == -1 ? 0 : 1)]) ||
              (nk != 0 && !bbox[4 + (nk == -1 ? 0 : 1)])) {

[5.9076]

[4.5112]

    for (int rank = dim - 1; rank >= 0; --rank) {
      for (int nk = -1; nk <= +1; ++nk) {
        for (int nj = -1; nj <= +1; ++nj) {
          for (int ni = -1; ni <= +1; ++ni) {
            if ((ni == 0) + (nj == 0) + (nk == 0) == rank) {
              if ((ni != 0 && !bbox[0 + (ni == -1 ? 0 : 1)]) ||
                  (nj != 0 && !bbox[2 + (nj == -1 ? 0 : 1)]) ||
                  (nk != 0 && !bbox[4 + (nk == -1 ? 0 : 1)])) {
                const array<int, dim> inormal{ni, nj, nk};
                array<int, dim> imin, imax;
                for (int d = 0; d < dim; ++d) {
                  const int ghost_offset =
                      nghostzones[d] - group_nghostzones[d];
                  const int begin_bnd = ghost_offset;
                  const int begin_int = nghostzones[d];
                  const int end_int = lsh[d] + offset[d] - nghostzones[d];
                  const int end_bnd = lsh[d] + offset[d] - ghost_offset;
                  switch (inormal[d]) {
                  case -1: // lower boundary
                    imin[d] = begin_bnd;
                    imax[d] = begin_int;
                    break;
                  case 0: // interior
                    imin[d] = begin_int;
                    imax[d] = end_int;
                    break;
                  case +1: // upper boundary
                    imin[d] = end_int;
                    imax[d] = end_bnd;
                    break;
                  default:
                    assert(0);
                  }

Replacement in CarpetX/src/loop.hxx at line 514 [5.5481]

B:BD[4.5113] → [4.5113:5168]

            const array<int, dim> inormal{ni, nj, nk};

[4.5113]

[4.5168]

                  imin[d] = std::max(tmin[d], imin[d]);
                  imax[d] = std::min(
                      tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0), imax[d]);
                }

Replacement in CarpetX/src/loop.hxx at line 519 [5.5481]

B:BD[4.5169] → [4.5169:6060]

            array<int, dim> imin, imax;
            for (int d = 0; d < dim; ++d) {
              const int ghost_offset = nghostzones[d] - group_nghostzones[d];
              const int begin_bnd = ghost_offset;
              const int begin_int = nghostzones[d];
              const int end_int = lsh[d] + offset[d] - nghostzones[d];
              const int end_bnd = lsh[d] + offset[d] - ghost_offset;
              switch (inormal[d]) {
              case -1: // lower boundary
                imin[d] = begin_bnd;
                imax[d] = begin_int;
                break;
              case 0: // interior
                imin[d] = begin_int;
                imax[d] = end_int;
                break;
              case +1: // upper boundary
                imin[d] = end_int;
                imax[d] = end_bnd;
                break;
              default:
                assert(0);

[4.5169]

[4.6060]

                loop_box<CI, CJ, CK>(f, imin, imax, inormal);

Insertion in CarpetX/src/loop.hxx at line 521 [5.5481]

[4.6076]

            } // if rank
          }
        }
      }
    } // for rank
  }
  // Loop over all outer ghost points. This excludes ghost edges/corners on
  // non-ghost faces. Loop over faces first, then edges, then corners.
  template <int CI, int CJ, int CK, typename F>
  void loop_ghosts(const array<int, dim> &group_nghostzones, const F &f) const {
    constexpr array<int, dim> offset{!CI, !CJ, !CK};

Replacement in CarpetX/src/loop.hxx at line 534 [5.5481]

B:BD[4.6077] → [2.546:721]

∅:D[2.721] → [4.6227:6241]

B:BD[4.6227] → [4.6227:6241]

              imin[d] = std::max(tmin[d], imin[d]);
              imax[d] = std::min(tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0),
                                 imax[d]);
            }

[4.6077]

[4.6241]

    for (int rank = dim - 1; rank >= 0; --rank) {
      for (int nk = -1; nk <= +1; ++nk) {
        for (int nj = -1; nj <= +1; ++nj) {
          for (int ni = -1; ni <= +1; ++ni) {
            if ((ni == 0) + (nj == 0) + (nk == 0) == rank) {
              if ((ni == 0 || !bbox[0 + (ni == -1 ? 0 : 1)]) &&
                  (nj == 0 || !bbox[2 + (nj == -1 ? 0 : 1)]) &&
                  (nk == 0 || !bbox[4 + (nk == -1 ? 0 : 1)])) {
                const array<int, dim> inormal{ni, nj, nk};

Replacement in CarpetX/src/loop.hxx at line 547 [5.5481]

B:BD[4.6242] → [4.6242:6300]

            loop_box<CI, CJ, CK>(f, imin, imax, inormal);

[4.6242]

[4.6300]

                array<int, dim> imin, imax;
                for (int d = 0; d < dim; ++d) {
                  const int ghost_offset =
                      nghostzones[d] - group_nghostzones[d];
                  const int begin_bnd = ghost_offset;
                  const int begin_int = nghostzones[d];
                  const int end_int = lsh[d] + offset[d] - nghostzones[d];
                  const int end_bnd = lsh[d] + offset[d] - ghost_offset;
                  switch (inormal[d]) {
                  case -1: // lower boundary
                    imin[d] = begin_bnd;
                    imax[d] = begin_int;
                    break;
                  case 0: // interior
                    imin[d] = begin_int;
                    imax[d] = end_int;
                    break;
                  case +1: // upper boundary
                    imin[d] = end_int;
                    imax[d] = end_bnd;
                    break;
                  default:
                    assert(0);
                  }
                  imin[d] = std::max(tmin[d], imin[d]);
                  imax[d] = std::min(
                      tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0), imax[d]);
                }
                loop_box<CI, CJ, CK>(f, imin, imax, inormal);
              }
            } // if rank

Replacement in CarpetX/src/loop.hxx at line 583 [5.5481]
B:BD[5.9129] → [3.11825:11831]
```
    }
```
[5.9129]
[3.11831]
```
    } // for rank
```

Insertion in CarpetX/src/loop.hxx at line 596 [5.5481]

[6.7217]

[4.6313]

    case where_t::ghosts_inclusive:
      return loop_ghosts_inclusive<CI, CJ, CK>(group_nghostzones, f);

Insertion in CarpetX/src/loop.hxx at line 674 [5.5481]

[6.9132]

[4.6400]

}
template <int CI, int CJ, int CK, typename F>
void loop_ghosts_inclusive(const cGH *cctkGH, const F &f) {
  loop<CI, CJ, CK>(cctkGH, where_t::ghosts_inclusive, f);