Method AsyncWriteDoit

Src/Base/AMReX_VisMF.cpp:2345–2578

}

void
VisMF::AsyncWriteDoit (const FabArray<FArrayBox>& mf, const std::string& mf_name,
                       bool is_rvalue, bool valid_cells_only)
{
    BL_PROFILE("VisMF::AsyncWrite()");

    AMREX_ASSERT(!mf_name.empty() && mf_name.back() != '/');
    static_assert(sizeof(int64_t) == sizeof(Real)*2 || sizeof(int64_t) == sizeof(Real),
                  "AsyncWrite: unsupported Real size");

    const DistributionMapping& dm = mf.DistributionMap();

    const int myproc = ParallelDescriptor::MyProc();
    const int nprocs = ParallelDescriptor::NProcs();
    const int io_proc = nprocs - 1;

    RealDescriptor const& whichRD = FPC::NativeRealDescriptor();

    auto hdr = std::make_shared<VisMF::Header>(mf, VisMF::NFiles, VisMF::Header::Version_v1, false);
    if (valid_cells_only) { hdr->m_ngrow = IntVect(0); }

    constexpr int sizeof_int64_over_real = sizeof(int64_t) / sizeof(Real);
    const int n_local_fabs = mf.local_size();
    const int n_global_fabs = mf.size();
    const int ncomp = mf.nComp();
    const Long n_fab_reals = 2*ncomp;
    const Long n_fab_int64 = 1;
    const Long n_fab_nums = (n_fab_reals/sizeof_int64_over_real) + n_fab_int64;
    const Long n_local_nums = n_fab_nums * n_local_fabs + 1;
    Vector<int64_t> localdata(n_local_nums);

    bool data_on_device = mf.arena()->isManaged() || mf.arena()->isDevice();
    bool run_on_device = data_on_device && Gpu::inLaunchRegion();
    amrex::ignore_unused(run_on_device);

    bool strip_ghost = valid_cells_only && mf.nGrowVect() != 0;

    int64_t total_bytes = 0;
    if (localdata.size() > 1) {
        char* pld = (char*)(&(localdata[1]));
        const FABio& fio = FArrayBox::getFABio();
        for (MFIter mfi(mf); mfi.isValid(); ++mfi)
        {
            std::memcpy(pld, &total_bytes, sizeof(int64_t));
            pld += sizeof(int64_t);

            const FArrayBox& fab = mf[mfi];
            const Box& bx = mfi.validbox();

            std::stringstream hss;
            FArrayBox valid_fab(bx, ncomp, false);
            FArrayBox const& header_fab = (strip_ghost) ? valid_fab : fab;
            fio.write_header(hss, header_fab, ncomp);
            total_bytes += static_cast<std::streamoff>(hss.tellp());
            total_bytes += header_fab.size() * whichRD.numBytes();

            // compute min and max
            for (int icomp = 0; icomp < ncomp; ++icomp) {