AMReX_MFIter.H

Go to the documentation of this file.

#ifndef BL_MFITER_H_
#define BL_MFITER_H_
#include <AMReX_Config.H>
 
#include <AMReX_FabArrayBase.H>
 
#include <memory>
 
namespace amrex {
 
#ifdef AMREX_USE_GPU
    inline bool TilingIfNotGPU () noexcept { return Gpu::notInLaunchRegion(); }
#else
    constexpr bool TilingIfNotGPU () noexcept { return true; }
#endif
 
template<class T> class FabArray;
 
struct MFItInfo
{
    bool do_tiling{false};
    bool dynamic{false};
    bool device_sync = true;
    bool device_sync_pre = true;
    bool device_sync_post = true;
    int  num_streams = 1;
    IntVect tilesize;
    MFItInfo () noexcept
        :  device_sync(!Gpu::inNoSyncRegion()), num_streams(Gpu::numGpuStreams()),
          tilesize(IntVect::TheZeroVector()) {}
    MFItInfo& EnableTiling (const IntVect& ts = FabArrayBase::mfiter_tile_size) noexcept {
        do_tiling = true;
        tilesize = ts;
        return *this;
    }
    MFItInfo& SetTiling (bool f) noexcept {
        do_tiling = f;
        if (do_tiling && tilesize == 0) {
            tilesize = FabArrayBase::mfiter_tile_size;
        }
        return *this;
    }
    MFItInfo& SetDynamic (bool f) noexcept {
        dynamic = f;
        return *this;
    }
    MFItInfo& DisableDeviceSync () noexcept {
        device_sync = false;
        return *this;
    }
    MFItInfo& SetDeviceSync (bool f) noexcept {
        device_sync = f;
        return *this;
    }
    MFItInfo& DisableDeviceSyncPre () noexcept {
        device_sync_pre = false;
        return *this;
    }
    MFItInfo& SetDeviceSyncPre (bool f) noexcept {
        device_sync_pre = f;
        return *this;
    }
    MFItInfo& DisableDeviceSyncPost () noexcept {
        device_sync_post = false;
        return *this;
    }
    MFItInfo& SetDeviceSyncPost (bool f) noexcept {
        device_sync_post = f;
        return *this;
    }
    MFItInfo& SetNumStreams (int n) noexcept {
        num_streams = n;
        return *this;
    }
    MFItInfo& UseDefaultStream () noexcept {
        num_streams = 1;
        return *this;
    }
};
 
class MFIter
{
public:
    enum Flags {
        Tiling        = 0x01,
        AllBoxes      = 0x02,
        NoTeamBarrier = 0x04
    };
 
    explicit MFIter (const FabArrayBase& fabarray,
                     unsigned char       flags_=0);
 
    MFIter (const FabArrayBase& fabarray,
            bool                do_tiling);
 
    MFIter (const FabArrayBase& fabarray,
            const IntVect&      tilesize,
            unsigned char       flags_=0);
 
    MFIter (const BoxArray& ba, const DistributionMapping& dm, unsigned char flags_=0);
 
    MFIter (const BoxArray& ba, const DistributionMapping& dm, bool do_tiling);
 
    MFIter (const BoxArray& ba, const DistributionMapping& dm,
            const IntVect& tilesize, unsigned char flags_=0);
 
    MFIter (const FabArrayBase& fabarray, const MFItInfo& info);
 
    MFIter (const BoxArray& ba, const DistributionMapping& dm, const MFItInfo& info);
 
    MFIter (MFIter&& rhs) = default;
    MFIter (MFIter const&) = delete;
    MFIter& operator= (MFIter const&) = delete;
    MFIter& operator= (MFIter &&) = delete;
 
    // dtor
    ~MFIter ();
 
    [[nodiscard]] Box tilebox () const noexcept;
 
    [[nodiscard]] Box tilebox (const IntVect& nodal) const noexcept;
 
    [[nodiscard]] Box tilebox (const IntVect& nodal, const IntVect& ngrow) const noexcept;
 
    [[nodiscard]] Box nodaltilebox (int dir=-1) const noexcept;
 
    [[nodiscard]] Box growntilebox (int ng=-1000000) const noexcept;
 
    [[nodiscard]] Box growntilebox (const IntVect& ng) const noexcept;
 
    [[nodiscard]] Box grownnodaltilebox (int dir=-1, int ng=-1000000) const noexcept;
 
    [[nodiscard]] Box grownnodaltilebox (int dir, const IntVect& ng) const noexcept;
 
    [[nodiscard]] Box validbox () const noexcept { return fabArray->box((*index_map)[currentIndex]); }
 
    [[nodiscard]] Box fabbox () const noexcept { return fabArray->fabbox((*index_map)[currentIndex]); }
 
    void operator++ () noexcept;
 
    [[nodiscard]] bool isValid () const noexcept { return currentIndex < endIndex; }
 
    [[nodiscard]] int index () const noexcept { return (*index_map)[currentIndex]; }
 
    [[nodiscard]] int length () const noexcept { return (endIndex - beginIndex); }
 
    [[nodiscard]] int LocalTileIndex () const noexcept {return local_tile_index_map ? (*local_tile_index_map)[currentIndex] : 0;}
 
    [[nodiscard]] int numLocalTiles() const noexcept {return num_local_tiles ? (*num_local_tiles)[currentIndex] : 1;}
 
    [[nodiscard]] int LocalIndex () const noexcept { return local_index_map ? (*local_index_map)[currentIndex] : currentIndex; }
 
    [[nodiscard]] const FabArrayBase& theFabArrayBase () const noexcept { return *fabArray; }
 
    [[nodiscard]] int tileIndex () const noexcept {return currentIndex;}
 
    [[nodiscard]] const DistributionMapping& DistributionMap () const noexcept { return fabArray->DistributionMap(); }
 
    static int allowMultipleMFIters (int allow);
 
    static int currentDepth ();
 
    void Finalize ();
 
protected:
 
    std::unique_ptr<FabArrayBase> m_fa;  
 
    const FabArrayBase* fabArray;
 
    IntVect tile_size;
 
    unsigned char flags;
    int           currentIndex;
    int           beginIndex;
    int           endIndex;
    int           streams;
    IndexType     typ;
 
    bool          dynamic;
    bool          finalized = false;
 
    struct DeviceSync {
        DeviceSync (bool f) : flag(f) {}
        DeviceSync (DeviceSync&& rhs)  noexcept : flag(std::exchange(rhs.flag,false)) {}
        ~DeviceSync () = default;
        DeviceSync (DeviceSync const&) = delete;
        DeviceSync& operator= (DeviceSync const&) = delete;
        DeviceSync& operator= (DeviceSync &&) = delete;
        explicit operator bool() const noexcept { return flag; }
        bool flag = true;
    };
    DeviceSync device_sync;
    DeviceSync device_sync_pre{true};
    DeviceSync device_sync_post{true};
 
    const Vector<int>* index_map;
    const Vector<int>* local_index_map;
    const Vector<Box>* tile_array;
    const Vector<int>* local_tile_index_map;
    const Vector<int>* num_local_tiles;
 
    static AMREX_EXPORT int nextDynamicIndex;
    static AMREX_EXPORT int depth;
    static AMREX_EXPORT int allow_multiple_mfiters;
 
    void Initialize ();
};
 
inline bool isMFIterSafe (const FabArrayBase& x, const FabArrayBase& y) {
    return x.DistributionMap() == y.DistributionMap()
        && BoxArray::SameRefs(x.boxArray(), y.boxArray());
}
 
}
 
#endif