AMReX_NFiles.H

Go to the documentation of this file.

 
#ifndef BL_NFILES_H
#define BL_NFILES_H
#include <AMReX_Config.H>
 
#include <AMReX_ParallelDescriptor.H>
#include <AMReX_Utility.H>
#include <AMReX_VisMFBuffer.H>
 
#include <fstream>
#include <string>
 
namespace amrex {
 
 
class NFilesIter
{
  public:
 
 
    NFilesIter(int noutfiles, std::string fileprefix,
               bool groupsets, bool setBuf);
 
 
    void SetDynamic(int deciderproc = -1);
    [[nodiscard]] bool GetDynamic() const { return ( ! useStaticSetSelection); }
 
 
    void SetSparseFPP(const Vector<int> &ranksToWrite);
    [[nodiscard]] bool GetSparseFPP() const { return useSparseFPP; }
 
 
    NFilesIter(std::string fileName,
               Vector<int> readRanks,
               bool setBuf = false,
               int mpi_tag = -1);
 
    ~NFilesIter();
 
    NFilesIter (NFilesIter const&) = delete;
    NFilesIter (NFilesIter &&) = delete;
    NFilesIter& operator= (NFilesIter const&) = delete;
    NFilesIter& operator= (NFilesIter &&) = delete;
 
    bool ReadyToWrite(bool appendFirst = false);
 
    bool ReadyToRead();
 
    NFilesIter &operator++();
 
    std::fstream &Stream() { return fileStream; }
 
 
    std::streampos SeekPos();
 
    static int LengthOfSet(int nProcs, int nOutFiles) {
      int anf(ActualNFiles(nOutFiles));
      return ((nProcs + (anf - 1)) / anf);
    }
 
    static int WhichSetPosition(int whichproc, int nprocs,
                                int noutfiles, bool groupsets)
    {
      int whichset;
      if(groupsets) {
        whichset = whichproc / noutfiles;
      } else {
        whichset = whichproc % LengthOfSet(nprocs, noutfiles);
      }
      return whichset;
    }
 
 
    static int ActualNFiles(int nOutFiles)
    {
      return( std::max(1, std::min(ParallelDescriptor::NProcs(), nOutFiles)) );
    }
 
 
    static bool CheckNFiles(int nProcs, int nOutFiles, bool groupSets);
 
    static int FileNumber(int nOutFiles, int whichProc, bool groupSets)
    {
      BL_ASSERT(whichProc >= 0 && whichProc < ParallelDescriptor::NProcs());
 
      int anf(ActualNFiles(nOutFiles));
      if(groupSets) {
        return(whichProc % anf);
      } else {
 
        int nProcs(ParallelDescriptor::NProcs());
        return(whichProc / LengthOfSet(nProcs, anf));
      }
    }
 
    [[nodiscard]] const std::string &FileName() const { return fullFileName; }
    [[nodiscard]] int FileNumber() const { return fileNumber; }
 
    static std::string FileName(int nOutFiles,
                                const std::string &filePrefix,
                                int whichProc, bool groupSets)
    {
      BL_ASSERT(whichProc >= 0 && whichProc < ParallelDescriptor::NProcs());
 
      return ( amrex::Concatenate(filePrefix,
                                   FileNumber(ActualNFiles(nOutFiles),
                                              whichProc, groupSets), minDigits ) );
    }
 
    static std::string FileName(int fileNumber,
                                const std::string &filePrefix)
    {
      return ( amrex::Concatenate(filePrefix, fileNumber, minDigits ) );
    }
 
 
    [[nodiscard]] int CoordinatorProc() const { return coordinatorProc; }
 
 
    Vector<int> FileNumbersWritten();
 
 
    [[nodiscard]] const Vector< Vector<int> > &FileNumbersWriteOrder() const { return fileNumbersWriteOrder; }
 
    void CleanUpMessages();
 
    static int  GetMinDigits()       { return minDigits; }
 
    static void SetMinDigits(int md) { minDigits = md;   }
 
  private:
 
    int myProc = -1;
    int nProcs = -1;
    int nOutFiles = -1;
    int nSets = -1;
    bool groupSets = false;
    int mySetPosition = -1;
    int fileNumber = -1;
    std::string filePrefix;
    std::string fullFileName;
    VisMFBuffer::IO_Buffer io_buffer;
    std::fstream fileStream;
    bool finishedWriting = false;
    bool isReading = false;
    bool finishedReading = false;
    Vector<int> readRanks;
    Vector< Vector<int> > fileNumbersWriteOrder;        
    int myReadIndex = -1;
    bool useStaticSetSelection = true;
    int remainingWriters = -1, deciderProc=-1, coordinatorProc = -1;
    int deciderTag = -1, coordinatorTag = -1, doneTag = -1, writeTag=-1;
    int stWriteTag = -1;
    int stReadTag = -1;
    Vector<int> availableDeciders;
    Vector<int> setZeroProcs;
    bool useSparseFPP = false;
    Vector<int> sparseWritingRanks;
    int mySparseFileNumber = -1;
 
    static int currentDeciderIndex;
 
    Vector<std::pair<int, int> > unreadMessages;    
 
    static const int indexUndefined = -1;
 
    static AMREX_EXPORT int minDigits;        
};
 
}
 
#endif  /* BL_NFILES_H */