eschnett/cactusamrex - Change BSMJ4V7GV3EOGY4KCSTOJQUOFE2OOCIKQETE4WC2WRNLWBQIBW3QC

Check for nans

Created by Erik Schnetter on August 29, 2019

BSMJ4V7GV3EOGY4KCSTOJQUOFE2OOCIKQETE4WC2WRNLWBQIBW3QC

Dependencies

In channels

main

master

Change contents

Replacement in AMReX/src/driver.cxx at line 273 [4.15972]

B:BD[2.1059] → [2.1059:1114]

        for (int vi = 0; vi < groupdata.numvars; ++vi)

[2.1059]

[2.1114]

        for (int vi = 0; vi < groupdata.numvars; ++vi) {

Insertion in AMReX/src/driver.cxx at line 276 [4.15972]

[2.1245]

          check_valid(coarseleveldata, coarsegroupdata, vi, tl);
        }

Replacement in AMReX/src/driver.cxx at line 290 [4.15972]
∅:D[3.71] → [5.869:922]
∅:D[2.1782] → [5.869:922]
B:BD[6.4081] → [5.869:922]
```
      for (int vi = 0; vi < groupdata.numvars; ++vi)
```
[2.1782]
[2.1783]
```
      for (int vi = 0; vi < groupdata.numvars; ++vi) {
```

Insertion in AMReX/src/driver.cxx at line 292 [4.15972]

[2.1837]

[5.1100]

        check_valid(leveldata, groupdata, vi, tl);
      }

Insertion in AMReX/src/driver.cxx at line 400 [4.15972]

[2.3354]

            check_valid(coarseleveldata, coarsegroupdata, vi, tl);
            // We cannot call this function since it would try to
            // traverse the old grid function with the new grid
            // structure.
#warning "TODO: Use explicit loop (see above)"
            // check_valid(leveldata, groupdata, vi, tl);

Replacement in AMReX/src/driver.cxx at line 426 [4.15972]

B:BD[5.1901] → [2.3531:3584]

      for (int vi = 0; vi < groupdata.numvars; ++vi)

[5.1901]

[2.3584]

      for (int vi = 0; vi < groupdata.numvars; ++vi) {

Insertion in AMReX/src/driver.cxx at line 428 [4.15972]

[2.3638]

[6.6442]

        check_valid(leveldata, groupdata, vi, tl);
      }

Insertion in AMReX/src/schedule.cxx at line 244 [7.531]

[2.5038]


// Ensure grid functions are not nan
void check_valid(const GHExt::LevelData &leveldata,
                 const GHExt::LevelData::GroupData &groupdata, int vi, int tl) {
  DECLARE_CCTK_PARAMETERS;
  if (!poison_undefined_values)
    return;
  const valid_t &valid = groupdata.valid.at(tl).at(vi);
  if (!valid.valid_int && !valid.valid_bnd)
    return;
  const auto mfitinfo = MFItInfo().SetDynamic(true).EnableTiling(
      {max_tile_size_x, max_tile_size_y, max_tile_size_z});
#pragma omp parallel
  for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {
    const GridPtrDesc grid(leveldata, mfi);
    const Array4<const CCTK_REAL> &vars = groupdata.mfab.at(tl)->array(mfi);
    const CCTK_REAL *restrict const ptr = grid.ptr(vars, vi);

Insertion in AMReX/src/schedule.cxx at line 264 [7.531]

[2.5039]

[8.16690]

    if (valid.valid_int) {
      if (valid.valid_bnd) {
        grid.loop_all(groupdata.indextype, [&](const Loop::PointDesc &p) {
          assert(!isnan(ptr[p.idx]));
        });
      } else {
        grid.loop_int(groupdata.indextype, [&](const Loop::PointDesc &p) {
          assert(!isnan(ptr[p.idx]));
        });
      }
    } else {
      if (valid.valid_bnd) {
        grid.loop_bnd(groupdata.indextype, [&](const Loop::PointDesc &p) {
          assert(!isnan(ptr[p.idx]));
        });
      } else {
        assert(0);
      }
    }
  }
} // namespace AMReX

Insertion in AMReX/src/schedule.cxx at line 1034 [7.531]
[5.10147]
[5.10147]
```
        check_valid(leveldata, groupdata, rd.vi, rd.tl);
```
Insertion in AMReX/src/schedule.cxx at line 1125 [7.531]
[5.11024]
[5.11024]
```
        check_valid(leveldata, groupdata, wr.vi, wr.tl);
```

Replacement in AMReX/src/schedule.cxx at line 1174 [7.531]

B:BD[2.7988] → [2.7988:8045]

          for (int vi = 0; vi < groupdata.numvars; ++vi)

[2.7988]

[2.8045]

          for (int vi = 0; vi < groupdata.numvars; ++vi) {

Insertion in AMReX/src/schedule.cxx at line 1176 [7.531]

[2.8103]

[9.621]

            check_valid(leveldata, groupdata, vi, tl);
          }

Replacement in AMReX/src/schedule.cxx at line 1190 [7.531]

B:BD[9.917] → [9.917:1019]

        auto &restrict coarsegroupdata =
            ghext->leveldata.at(level - 1).groupdata.at(gi);

[9.917]

[9.1019]

        const auto &restrict coarseleveldata = ghext->leveldata.at(level - 1);
        auto &restrict coarsegroupdata = coarseleveldata.groupdata.at(gi);

Replacement in AMReX/src/schedule.cxx at line 1214 [7.531]

B:BD[2.8476] → [2.8476:8533]

          for (int vi = 0; vi < groupdata.numvars; ++vi)

[2.8476]

[2.8533]

          for (int vi = 0; vi < groupdata.numvars; ++vi) {

Insertion in AMReX/src/schedule.cxx at line 1216 [7.531]

[2.8591]

[10.11380]

            check_valid(coarseleveldata, coarsegroupdata, vi, tl);
            check_valid(leveldata, groupdata, vi, tl);
          }

Replacement in AMReX/src/schedule.cxx at line 1232 [7.531]

B:BD[2.8593] → [2.8593:8691]

      for (int tl = 0; tl < sync_tl; ++tl)
        for (int vi = 0; vi < groupdata.numvars; ++vi)

[2.8593]

[2.8691]

      for (int tl = 0; tl < sync_tl; ++tl) {
        for (int vi = 0; vi < groupdata.numvars; ++vi) {

Insertion in AMReX/src/schedule.cxx at line 1235 [7.531]

[2.8747]

[11.4311]

          check_valid(leveldata, groupdata, vi, tl);
        }
      }

Replacement in AMReX/src/schedule.cxx at line 1256 [7.531]

B:BD[12.504] → [13.29:92]

  const auto &fine_leveldata = ghext->leveldata.at(level + 1);

[12.504]

[12.566]

  const auto &fineleveldata = ghext->leveldata.at(level + 1);

Replacement in AMReX/src/schedule.cxx at line 1262 [7.531]

B:BD[12.681] → [13.93:159]

    const auto &fine_groupdata = fine_leveldata.groupdata.at(gi);

[12.681]

[12.745]

    const auto &finegroupdata = fineleveldata.groupdata.at(gi);

Replacement in AMReX/src/schedule.cxx at line 1274 [7.531]

B:BD[2.8876] → [2.8876:9020]

        all_invalid &= !fine_groupdata.valid.at(tl).at(vi).valid_int &&
                       !fine_groupdata.valid.at(tl).at(vi).valid_bnd &&

[2.8876]

[2.9020]

        all_invalid &= !finegroupdata.valid.at(tl).at(vi).valid_int &&
                       !finegroupdata.valid.at(tl).at(vi).valid_bnd &&

Replacement in AMReX/src/schedule.cxx at line 1287 [7.531]

B:BD[2.9314] → [2.9314:9499]

        for (int vi = 0; vi < groupdata.numvars; ++vi)
          assert(fine_groupdata.valid.at(tl).at(vi).valid_int &&
                 fine_groupdata.valid.at(tl).at(vi).valid_bnd &&

[2.9314]

[2.9499]

        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          assert(finegroupdata.valid.at(tl).at(vi).valid_int &&
                 finegroupdata.valid.at(tl).at(vi).valid_bnd &&

Insertion in AMReX/src/schedule.cxx at line 1291 [7.531]

[2.9558]

          check_valid(fineleveldata, finegroupdata, vi, tl);
          check_valid(leveldata, groupdata, vi, tl);
        }

Replacement in AMReX/src/schedule.cxx at line 1296 [7.531]

B:BD[2.9620] → [2.9620:9741]

          average_down_nodal(*fine_groupdata.mfab.at(tl),
                             *groupdata.mfab.at(tl), reffact);

[2.9620]

[2.9741]

          average_down_nodal(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                             reffact);

Replacement in AMReX/src/schedule.cxx at line 1301 [7.531]

B:BD[2.9943] → [2.9943:10064]

          average_down_edges(*fine_groupdata.mfab.at(tl),
                             *groupdata.mfab.at(tl), reffact);

[2.9943]

[2.10064]

          average_down_edges(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                             reffact);

Replacement in AMReX/src/schedule.cxx at line 1306 [7.531]

B:BD[2.10266] → [2.10266:10387]

          average_down_faces(*fine_groupdata.mfab.at(tl),
                             *groupdata.mfab.at(tl), reffact);

[2.10266]

[2.10387]

          average_down_faces(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                             reffact);

Replacement in AMReX/src/schedule.cxx at line 1309 [7.531]

B:BD[2.10453] → [2.10453:10532]

          average_down(*fine_groupdata.mfab.at(tl), *groupdata.mfab.at(tl), 0,

[2.10453]

[2.10532]

          average_down(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl), 0,

Replacement in AMReX/src/schedule.cxx at line 1316 [7.531]

B:BD[2.10729] → [2.10729:10851]

              fine_groupdata.valid.at(tl).at(vi).valid_int &&
              fine_groupdata.valid.at(tl).at(vi).valid_bnd;

[2.10729]

[2.10851]

              finegroupdata.valid.at(tl).at(vi).valid_int &&
              finegroupdata.valid.at(tl).at(vi).valid_bnd;

Replacement in AMReX/src/schedule.cxx at line 1322 [7.531]

B:BD[2.10912] → [2.10912:10965]

      for (int vi = 0; vi < groupdata.numvars; ++vi)

[2.10912]

[2.10965]

      for (int vi = 0; vi < groupdata.numvars; ++vi) {

Insertion in AMReX/src/schedule.cxx at line 1324 [7.531]

[2.11019]

[14.1809]

        check_valid(leveldata, groupdata, vi, tl);
      }

Insertion in AMReX/src/schedule.hxx at line 74 [7.5992]

[2.11179]

[15.18748]

void check_valid(const GHExt::LevelData &leveldata,
                 const GHExt::LevelData::GroupData &groupdata, int vi, int tl);