eschnett/cactusamrex - Change W4XMGPEHBCV6AAPJBI4SSEMCDB6KKCGRUC2X2F5YLBY22OR3ICPAC

AMReX: Check and invalidate grid scalars only once, not once per level Also poison invalid input data.

Created by Erik Schnetter on October 18, 2019

W4XMGPEHBCV6AAPJBI4SSEMCDB6KKCGRUC2X2F5YLBY22OR3ICPAC

Dependencies

In channels

master

main

Change contents

Insertion in AMReX/src/driver.hxx at line 111 [4.15275]
[3.3027]
[3.3027]
```
      // TODO: use unique_ptr
```

Insertion in AMReX/src/schedule.cxx at line 277 [6.531]

[5.733]

// TODO: Parallelize this loop (and poison_invalid) further out, at
// the loop over time levels and grid variables

Deletion in AMReX/src/schedule.cxx at line 1262 [6.531]
B:BD[7.9041] → [8.5:62]
```
    const auto &restrict globaldata = ghext->globaldata;
```

Replacement in AMReX/src/schedule.cxx at line 1264 [6.531]

B:BD[7.9199] → [7.9199:9332]

B:BD[7.9332] → [3.11868:11963]

      for (int level = min_level; level < max_level; ++level) {
        const auto &restrict leveldata = ghext->leveldata.at(level);
        cGroup group;
        int ierr = CCTK_GroupData(rd.gi, &group);
        assert(!ierr);

[7.9199]

[3.11963]

      if (CCTK_GroupTypeI(rd.gi) == CCTK_GF) {

Replacement in AMReX/src/schedule.cxx at line 1266 [6.531]

B:BD[3.11964] → [2.1584:2085]

        // TODO: something about this cast
        // (https://stackoverflow.com/questions/6179314/casting-pointers-and-the-ternary-operator-have-i-reinvented-the-wheel)
        const GHExt::CommonGroupData *groupdata =
            group.grouptype == CCTK_GF
                ? static_cast<const GHExt::CommonGroupData *>(
                      &leveldata.groupdata.at(rd.gi))
                : static_cast<const GHExt::CommonGroupData *>(
                      &globaldata.scalargroupdata.at(rd.gi));

[3.11964]

[7.9404]

        for (int level = min_level; level < max_level; ++level) {
          const auto &restrict leveldata = ghext->leveldata.at(level);
          const auto &restrict groupdata = leveldata.groupdata.at(rd.gi);
          const valid_t &need = rd.valid;
          const valid_t &have = groupdata.valid.at(rd.tl).at(rd.vi);
          // "x <= y" for booleans means "x implies y"
          const bool cond = need.valid_int <= have.valid_int &&
                            need.valid_bnd <= have.valid_bnd;
          if (!cond)
            CCTK_VERROR(
                "Found invalid input data: iteration %d %s: %s::%s, level %d, "
                "variable %s%s: need %s, have %s",
                cctkGH->cctk_iteration, attribute->where, attribute->thorn,
                attribute->routine, leveldata.level,
                CCTK_FullVarName(groupdata.firstvarindex + rd.vi),
                string("_p", rd.tl).c_str(), string(need).c_str(),
                string(have).c_str());
          check_valid(leveldata, groupdata, rd.vi, rd.tl, [&]() {
            ostringstream buf;
            buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
                << attribute->where << ": " << attribute->thorn
                << "::" << attribute->routine << " checking input";
            return buf.str();
          });
        }
      } else { // CCTK_SCALAR
        const auto &restrict scalargroupdata =
            ghext->globaldata.scalargroupdata.at(rd.gi);

Replacement in AMReX/src/schedule.cxx at line 1297 [6.531]

B:BD[7.9444] → [3.12386:12454]

        const valid_t &have = groupdata->valid.at(rd.tl).at(rd.vi);

[7.9444]

[7.9511]

        const valid_t &have = scalargroupdata.valid.at(rd.tl).at(rd.vi);

Replacement in AMReX/src/schedule.cxx at line 1302 [6.531]

B:BD[7.9705] → [7.9705:9980]

B:BD[7.9980] → [3.12455:12521]

∅:D[3.12521] → [7.10045:10147]

B:BD[7.10045] → [7.10045:10147]

B:BD[7.10147] → [3.12522:12564]

B:BD[3.12564] → [2.2086:2496]

∅:D[9.907] → [3.12643:12660]

∅:D[2.2496] → [3.12643:12660]

B:BD[3.12643] → [3.12643:12660]

B:BD[3.12660] → [2.2497:2903]

∅:D[9.1275] → [3.12735:12745]

∅:D[2.2903] → [3.12735:12745]

B:BD[3.12735] → [3.12735:12745]

          CCTK_VERROR(
              "Found invalid input data: iteration %d %s: %s::%s, level %d, "
              "variable %s%s: need %s, have %s",
              cctkGH->cctk_iteration, attribute->where, attribute->thorn,
              attribute->routine, leveldata.level,
              CCTK_FullVarName(groupdata->firstvarindex + rd.vi),
              string("_p", rd.tl).c_str(), string(need).c_str(),
              string(have).c_str());
        if (group.grouptype == CCTK_GF) {
          check_valid(
              leveldata, leveldata.groupdata.at(rd.gi), rd.vi, rd.tl, [&]() {
                ostringstream buf;
                buf << "CallFunction iteration " << cctkGH->cctk_iteration
                    << " " << attribute->where << ": " << attribute->thorn
                    << "::" << attribute->routine << " checking input";
                return buf.str();
              });
        } else {
          check_valid(
              globaldata.scalargroupdata.at(rd.gi), rd.vi, rd.tl, [&]() {
                ostringstream buf;
                buf << "CallFunction iteration " << cctkGH->cctk_iteration
                    << " " << attribute->where << ": " << attribute->thorn
                    << "::" << attribute->routine << " checking input";
                return buf.str();
              });
        }

[7.9705]

[7.10147]

          CCTK_VERROR("Found invalid input data: iteration %d %s: %s::%s, "
                      "variable %s%s: need %s, have %s",
                      cctkGH->cctk_iteration, attribute->where,
                      attribute->thorn, attribute->routine,
                      CCTK_FullVarName(scalargroupdata.firstvarindex + rd.vi),
                      string("_p", rd.tl).c_str(), string(need).c_str(),
                      string(have).c_str());
        check_valid(scalargroupdata, rd.vi, rd.tl, [&]() {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking input";
          return buf.str();
        });

Deletion in AMReX/src/schedule.cxx at line 1322 [6.531]
B:BD[10.6694] → [3.12746:12797]
```
    auto &restrict globaldata = ghext->globaldata;
```

Replacement in AMReX/src/schedule.cxx at line 1338 [6.531]

B:BD[10.7307] → [10.7307:7476]

B:BD[10.7476] → [3.12798:12893]

      const valid_t &provided = wr.valid;
      for (int level = min_level; level < max_level; ++level) {
        auto &restrict leveldata = ghext->leveldata.at(level);
        cGroup group;
        int ierr = CCTK_GroupData(wr.gi, &group);
        assert(!ierr);

[10.7307]

[3.12893]

      if (CCTK_GroupTypeI(wr.gi) == CCTK_GF) {
        for (int level = min_level; level < max_level; ++level) {
          auto &restrict leveldata = ghext->leveldata.at(level);
          auto &restrict groupdata = leveldata.groupdata.at(wr.gi);
          const valid_t &provided = wr.valid;
          valid_t &have = groupdata.valid.at(wr.tl).at(wr.vi);
          have.valid_int &= need.valid_int || !provided.valid_int;
          have.valid_bnd &= need.valid_bnd || !provided.valid_bnd;
          poison_invalid(leveldata, groupdata, wr.vi, wr.tl);
        }
      } else { // CCTK_SCALAR

Replacement in AMReX/src/schedule.cxx at line 1352 [6.531]

B:BD[3.12894] → [2.2904:3217]

∅:D[2.3217] → [3.13138:13200]

B:BD[3.13138] → [3.13138:13200]

        GHExt::CommonGroupData *groupdata =
            group.grouptype == CCTK_GF
                ? static_cast<GHExt::CommonGroupData *>(
                      &leveldata.groupdata.at(wr.gi))
                : static_cast<GHExt::CommonGroupData *>(
                      &globaldata.scalargroupdata.at(wr.gi));
        valid_t &have = groupdata->valid.at(wr.tl).at(wr.vi);

[3.12894]

[10.7603]

        auto &restrict scalargroupdata =
            ghext->globaldata.scalargroupdata.at(wr.gi);
        const valid_t &provided = wr.valid;
        valid_t &have = scalargroupdata.valid.at(wr.tl).at(wr.vi);

Insertion in AMReX/src/schedule.cxx at line 1358 [6.531]
[10.7733]
[10.7733]
```
        poison_invalid(scalargroupdata, wr.vi, wr.tl);
```
Deletion in AMReX/src/schedule.cxx at line 1416 [6.531]
B:BD[7.10435] → [8.63:114]
```
    auto &restrict globaldata = ghext->globaldata;
```

Replacement in AMReX/src/schedule.cxx at line 1418 [6.531]

B:BD[7.10597] → [7.10597:10724]

B:BD[7.10724] → [3.13253:13348]

      for (int level = min_level; level < max_level; ++level) {
        auto &restrict leveldata = ghext->leveldata.at(level);
        cGroup group;
        int ierr = CCTK_GroupData(wr.gi, &group);
        assert(!ierr);

[7.10597]

[3.13348]

      if (CCTK_GroupTypeI(wr.gi) == CCTK_GF) {
        for (int level = min_level; level < max_level; ++level) {
          auto &restrict leveldata = ghext->leveldata.at(level);
          auto &restrict groupdata = leveldata.groupdata.at(wr.gi);
          const valid_t &provided = wr.valid;
          valid_t &have = groupdata.valid.at(wr.tl).at(wr.vi);
          have.valid_int |= provided.valid_int;
          have.valid_bnd |= provided.valid_bnd;
          check_valid(leveldata, groupdata, wr.vi, wr.tl, [&]() {
            ostringstream buf;
            buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
                << attribute->where << ": " << attribute->thorn
                << "::" << attribute->routine << " checking output";
            return buf.str();
          });
        }
      } else { // CCTK_SCALAR

Replacement in AMReX/src/schedule.cxx at line 1438 [6.531]

B:BD[3.13349] → [2.3218:3531]

        GHExt::CommonGroupData *groupdata =
            group.grouptype == CCTK_GF
                ? static_cast<GHExt::CommonGroupData *>(
                      &leveldata.groupdata.at(wr.gi))
                : static_cast<GHExt::CommonGroupData *>(
                      &globaldata.scalargroupdata.at(wr.gi));

[3.13349]

[7.10790]

        auto &restrict scalargroupdata =
            ghext->globaldata.scalargroupdata.at(wr.gi);

Replacement in AMReX/src/schedule.cxx at line 1441 [6.531]

B:BD[7.10834] → [3.13594:13656]

∅:D[3.13656] → [7.10895:10932]

B:BD[7.10895] → [7.10895:10932]

        valid_t &have = groupdata->valid.at(wr.tl).at(wr.vi);
        // Code cannot invalidate...

[7.10834]

[7.10932]

        valid_t &have = scalargroupdata.valid.at(wr.tl).at(wr.vi);

Replacement in AMReX/src/schedule.cxx at line 1444 [6.531]

B:BD[7.11024] → [3.13657:13699]

B:BD[3.13699] → [2.3532:3943]

∅:D[9.1648] → [3.13778:13795]

∅:D[2.3943] → [3.13778:13795]

B:BD[3.13778] → [3.13778:13795]

B:BD[3.13795] → [2.3944:4351]

∅:D[9.2017] → [3.13870:13880]

∅:D[2.4351] → [3.13870:13880]

B:BD[3.13870] → [3.13870:13880]

        if (group.grouptype == CCTK_GF) {
          check_valid(
              leveldata, leveldata.groupdata.at(wr.gi), wr.vi, wr.tl, [&]() {
                ostringstream buf;
                buf << "CallFunction iteration " << cctkGH->cctk_iteration
                    << " " << attribute->where << ": " << attribute->thorn
                    << "::" << attribute->routine << " checking output";
                return buf.str();
              });
        } else {
          check_valid(
              globaldata.scalargroupdata.at(wr.gi), wr.vi, wr.tl, [&]() {
                ostringstream buf;
                buf << "CallFunction iteration " << cctkGH->cctk_iteration
                    << " " << attribute->where << ": " << attribute->thorn
                    << "::" << attribute->routine << " checking output";
                return buf.str();
              });
        }

[7.11024]

        check_valid(scalargroupdata, wr.vi, wr.tl, [&]() {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking output";
          return buf.str();
        });

Insertion in AMReX/src/schedule.cxx at line 1454 [6.531]
[6.5914]
[11.374]
Deletion in AMReX/src/schedule.cxx at line 1457 [6.531]
B:BD[11.429] → [9.2018:2069]
```
    auto &restrict globaldata = ghext->globaldata;
```

Replacement in AMReX/src/schedule.cxx at line 1460 [6.531]

B:BD[11.551] → [11.551:678]

B:BD[11.678] → [9.2070:2166]

      for (int level = min_level; level < max_level; ++level) {
        auto &restrict leveldata = ghext->leveldata.at(level);
        cGroup group;
        int ierr = CCTK_GroupData(inv.gi, &group);
        assert(!ierr);

[11.551]

[9.2166]

      if (CCTK_GroupTypeI(inv.gi) == CCTK_GF) {
        for (int level = min_level; level < max_level; ++level) {
          auto &restrict leveldata = ghext->leveldata.at(level);
          auto &restrict groupdata = leveldata.groupdata.at(inv.gi);
          const valid_t &provided = inv.valid;
          valid_t &have = groupdata.valid.at(inv.tl).at(inv.vi);
          have.valid_int &= !provided.valid_int;
          have.valid_bnd &= !provided.valid_bnd;
          check_valid(leveldata, groupdata, inv.vi, inv.tl, [&]() {
            ostringstream buf;
            buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
                << attribute->where << ": " << attribute->thorn
                << "::" << attribute->routine << " checking output";
            return buf.str();
          });
        }
      } else { // CCTK_SCALAR

Replacement in AMReX/src/schedule.cxx at line 1480 [6.531]

B:BD[9.2167] → [2.4444:4759]

        GHExt::CommonGroupData *groupdata =
            group.grouptype == CCTK_GF
                ? static_cast<GHExt::CommonGroupData *>(
                      &leveldata.groupdata.at(inv.gi))
                : static_cast<GHExt::CommonGroupData *>(
                      &globaldata.scalargroupdata.at(inv.gi));

[9.2167]

[11.745]

        auto &restrict scalargroupdata =
            ghext->globaldata.scalargroupdata.at(inv.gi);

Replacement in AMReX/src/schedule.cxx at line 1483 [6.531]

B:BD[11.790] → [9.2414:2478]

∅:D[9.2478] → [11.853:890]

B:BD[11.853] → [11.853:890]

        valid_t &have = groupdata->valid.at(inv.tl).at(inv.vi);
        // Code cannot invalidate...

[11.790]

[11.890]

        valid_t &have = scalargroupdata.valid.at(inv.tl).at(inv.vi);

Replacement in AMReX/src/schedule.cxx at line 1486 [6.531]

B:BD[11.984] → [9.2479:2521]

B:BD[9.2521] → [2.4760:5174]

∅:D[2.5174] → [9.2896:2913]

B:BD[9.2896] → [9.2896:2913]

B:BD[9.2913] → [2.5175:5585]

∅:D[2.5585] → [9.3284:3294]

B:BD[9.3284] → [9.3284:3294]

        if (group.grouptype == CCTK_GF) {
          check_valid(
              leveldata, leveldata.groupdata.at(inv.gi), inv.vi, inv.tl, [&]() {
                ostringstream buf;
                buf << "CallFunction iteration " << cctkGH->cctk_iteration
                    << " " << attribute->where << ": " << attribute->thorn
                    << "::" << attribute->routine << " checking output";
                return buf.str();
              });
        } else {
          check_valid(
              globaldata.scalargroupdata.at(inv.gi), inv.vi, inv.tl, [&]() {
                ostringstream buf;
                buf << "CallFunction iteration " << cctkGH->cctk_iteration
                    << " " << attribute->where << ": " << attribute->thorn
                    << "::" << attribute->routine << " checking output";
                return buf.str();
              });
        }

[11.984]

[11.1324]

        check_valid(scalargroupdata, inv.vi, inv.tl, [&]() {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking output";
          return buf.str();
        });