MPIPatternP2P.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2021.                                                        *
 * The Regents of the University of Michigan and DFT-EFE developers.          *
 *                                                                            *
 * This file is part of the DFT-EFE code.                                     *
 *                                                                            *
 * DFT-EFE is free software: you can redistribute it and/or modify            *
 *   it under the terms of the Lesser GNU General Public License as           *
 *   published by the Free Software Foundation, either version 3 of           *
 *   the License, or (at your option) any later version.                      *
 *                                                                            *
 * DFT-EFE is distributed in the hope that it will be useful, but             *
 *   WITHOUT ANY WARRANTY; without even the implied warranty                  *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                     *
 *   See the Lesser GNU General Public License for more details.              *
 *                                                                            *
 * You should have received a copy of the GNU Lesser General Public           *
 *   License at the top level of DFT-EFE distribution.  If not, see           *
 *   <https://www.gnu.org/licenses/>.                                         *
 ******************************************************************************/
 
/*
 * @author Sambit Das, Bikash Kanungo
 */
 
#ifndef dftefeMPIPatternP2P_h
#define dftefeMPIPatternP2P_h
 
#include <utils/MemorySpaceType.h>
#include <utils/MemoryStorage.h>
#include <utils/MPITypes.h>
#include <utils/OptimizedIndexSet.h>
#include <vector>
namespace dftefe
{
  namespace utils
  {
    namespace mpi
    {
      template <dftefe::utils::MemorySpace memorySpace>
      class MPIPatternP2P
      {
      public:
        using SizeTypeVector = utils::MemoryStorage<size_type, memorySpace>;
        using GlobalSizeTypeVector =
          utils::MemoryStorage<global_size_type, memorySpace>;
 
      public:
        virtual ~MPIPatternP2P() = default;
 
        MPIPatternP2P(
          const std::vector<std::pair<global_size_type, global_size_type>>
            &                                          locallyOwnedRanges,
          const std::vector<dftefe::global_size_type> &ghostIndices,
          const MPIComm &                              mpiComm);
 
        MPIPatternP2P(const std::pair<global_size_type, global_size_type>
                        &locallyOwnedRange,
                      const std::vector<dftefe::global_size_type> &ghostIndices,
                      const MPIComm &                              mpiComm);
 
        MPIPatternP2P(const std::vector<size_type> &sizes);
 
        MPIPatternP2P(const size_type &size);
 
        void
        reinit(const std::vector<std::pair<global_size_type, global_size_type>>
                 &                                          locallyOwnedRanges,
               const std::vector<dftefe::global_size_type> &ghostIndices,
               const MPIComm &                              mpiComm);
 
        void
        reinit(const std::vector<size_type> &sizes);
 
        size_type
        nGlobalRanges() const;
 
        std::vector<std::pair<global_size_type, global_size_type>>
        getGlobalRanges() const;
 
        std::vector<std::pair<global_size_type, global_size_type>>
        getLocallyOwnedRanges() const;
 
        std::pair<global_size_type, global_size_type>
        getLocallyOwnedRange(size_type rangeId) const;
 
        size_type
        localOwnedSize(size_type rangeId) const;
 
        size_type
        localOwnedSize() const;
 
        size_type
        localGhostSize() const;
 
        std::pair<bool, size_type>
        inLocallyOwnedRanges(const global_size_type globalId) const;
 
        std::pair<bool, size_type>
        isGhostEntry(const global_size_type globalId) const;
 
        size_type
        globalToLocal(const global_size_type globalId) const;
 
        global_size_type
        localToGlobal(const size_type localId) const;
 
        std::pair<size_type, size_type>
        globalToLocalAndRangeId(const global_size_type globalId) const;
 
        std::pair<global_size_type, size_type>
        localToGlobalAndRangeId(const size_type localId) const;
 
        const std::vector<global_size_type> &
        getGhostIndices() const;
 
        const std::vector<size_type> &
        getGhostProcIds() const;
 
        const std::vector<size_type> &
        getNumGhostIndicesInGhostProcs() const;
 
        size_type
        getNumGhostIndicesInGhostProc(const size_type procId) const;
 
        const SizeTypeVector &
        getGhostLocalIndicesForGhostProcs() const;
 
        SizeTypeVector
        getGhostLocalIndicesForGhostProc(const size_type procId) const;
 
        const std::vector<size_type> &
        getGhostLocalIndicesRanges() const;
 
        const std::vector<size_type> &
        getTargetProcIds() const;
 
        const std::vector<size_type> &
        getNumOwnedIndicesForTargetProcs() const;
 
        size_type
        getNumOwnedIndicesForTargetProc(const size_type procId) const;
 
        size_type
        getTotalOwnedIndicesForTargetProcs() const;
 
        const SizeTypeVector &
        getOwnedLocalIndicesForTargetProcs() const;
 
        SizeTypeVector
        getOwnedLocalIndicesForTargetProc(const size_type procId) const;
 
        size_type
        nmpiProcesses() const;
 
        size_type
        thisProcessId() const;
 
        global_size_type
        nGlobalIndices() const;
 
        const MPIComm &
        mpiCommunicator() const;
 
        bool
        isCompatible(const MPIPatternP2P<memorySpace> &rhs) const;
 
      private:
        std::vector<std::pair<global_size_type, global_size_type>>
          d_locallyOwnedRanges;
 
        size_type d_nGlobalRanges;
 
 
        std::vector<std::pair<global_size_type, global_size_type>>
          d_locallyOwnedRangesSorted;
 
        std::vector<size_type> d_locallyOwnedRangesIdPermutation;
 
        std::vector<std::vector<std::pair<global_size_type, global_size_type>>>
          d_allOwnedRanges;
 
        std::vector<std::pair<global_size_type, global_size_type>>
          d_globalRanges;
 
        size_type d_numLocallyOwnedIndices;
 
        std::vector<std::pair<size_type, size_type>>
          d_locallyOwnedRangesCumulativePairs;
 
        std::vector<global_size_type> d_ghostIndices;
 
        size_type d_numGhostIndices;
 
 
        OptimizedIndexSet<global_size_type> d_ghostIndicesOptimizedIndexSet;
 
        std::vector<size_type> d_ghostIndicesRangeId;
 
        size_type d_numGhostProcs;
 
        std::vector<size_type> d_ghostProcIds;
 
        std::vector<size_type> d_numGhostIndicesInGhostProcs;
 
        SizeTypeVector d_flattenedLocalGhostIndices;
 
        std::vector<size_type> d_localGhostIndicesRanges;
 
        std::vector<std::vector<size_type>>
          d_ghostProcLocallyOwnedRangesCumulative;
 
        size_type d_numTargetProcs;
 
        std::vector<size_type> d_targetProcIds;
 
        std::vector<size_type> d_numOwnedIndicesForTargetProcs;
 
        SizeTypeVector d_flattenedLocalTargetIndices;
 
        int d_nprocs;
 
        int d_myRank;
 
        global_size_type d_nGlobalIndices;
 
        MPIComm d_mpiComm;
      };
 
    } // end of namespace mpi
  }   // end of namespace utils
} // end of namespace dftefe
 
#include <utils/MPIPatternP2P.t.cpp>
#endif // dftefeMPIPatternP2P_h