Tpetra_DirectoryImpl_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef __Tpetra_DirectoryImpl_decl_hpp
#define __Tpetra_DirectoryImpl_decl_hpp
 
 
#include "Tpetra_TieBreak.hpp"
#include "Tpetra_Map_fwd.hpp"
 
//
// mfh 13-15 May 2013: HAVE_TPETRA_DIRECTORY_SPARSE_MAP_FIX governs
// the fix for Bug 5822.  The fix is enabled by default.  To disable
// the fix, uncomment out the three lines below that undefine
// HAVE_TPETRA_DIRECTORY_SPARSE_MAP_FIX, and comment out the three
// lines below them that define that macro.
//
// mfh 23 Mar 2014: I want Bug 5822 to stay fixed, so I am removing
// all references to HAVE_TPETRA_DIRECTORY_SPARSE_MAP_FIX.  I hope no
// downstream code is using that macro, but just in case, I will leave
// it defined.
 
#ifndef HAVE_TPETRA_DIRECTORY_SPARSE_MAP_FIX
#define HAVE_TPETRA_DIRECTORY_SPARSE_MAP_FIX 1
#endif  // HAVE_TPETRA_DIRECTORY_SPARSE_MAP_FIX
 
#include "Tpetra_Details_FixedHashTable_decl.hpp"
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// Forward declaration of Teuchos::Comm
namespace Teuchos {
template <class OrdinalType>
class Comm;
}  // namespace Teuchos
#endif  // DOXYGEN_SHOULD_SKIP_THIS
 
namespace Tpetra {
namespace Details {
template <class LocalOrdinal, class GlobalOrdinal, class NodeType>
class Directory : public Teuchos::Describable {
 public:
  typedef LocalOrdinal local_ordinal_type;
  typedef GlobalOrdinal global_ordinal_type;
  typedef NodeType node_type;
  typedef ::Tpetra::Map<LocalOrdinal, GlobalOrdinal, NodeType> map_type;
 
  Directory() = default;
 
  virtual ~Directory() = default;
 
  LookupStatus
  getEntries(const map_type &map,
             const Teuchos::ArrayView<const GlobalOrdinal> &globalIDs,
             const Teuchos::ArrayView<int> &nodeIDs,
             const Teuchos::ArrayView<LocalOrdinal> &localIDs,
             const bool computeLIDs) const;
 
  virtual bool isOneToOne(const Teuchos::Comm<int> &comm) const = 0;
 
 protected:
  virtual LookupStatus
  getEntriesImpl(const map_type &map,
                 const Teuchos::ArrayView<const GlobalOrdinal> &globalIDs,
                 const Teuchos::ArrayView<int> &nodeIDs,
                 const Teuchos::ArrayView<LocalOrdinal> &localIDs,
                 const bool computeLIDs) const = 0;
};
 
template <class LocalOrdinal, class GlobalOrdinal, class NodeType>
class ReplicatedDirectory : public Directory<LocalOrdinal, GlobalOrdinal, NodeType> {
 public:
  typedef Directory<LocalOrdinal, GlobalOrdinal, NodeType> base_type;
  typedef typename base_type::map_type map_type;
 
  ReplicatedDirectory() = default;
 
  ReplicatedDirectory(const map_type &map);
 
  ~ReplicatedDirectory() override = default;
 
  bool isOneToOne(const Teuchos::Comm<int> &comm) const override;
 
 
 
  std::string description() const override;
 protected:
  LookupStatus
  getEntriesImpl(const map_type &map,
                 const Teuchos::ArrayView<const GlobalOrdinal> &globalIDs,
                 const Teuchos::ArrayView<int> &nodeIDs,
                 const Teuchos::ArrayView<LocalOrdinal> &localIDs,
                 const bool computeLIDs) const override;
 
 private:
  const int numProcs_ = 0;
};
 
template <class LocalOrdinal, class GlobalOrdinal, class NodeType>
class ContiguousUniformDirectory : public Directory<LocalOrdinal, GlobalOrdinal, NodeType> {
 private:
  // This friend declaration lets us implement clone().
  template <class LO, class GO, class N>
  friend class ContiguousUniformDirectory;
 
 public:
  typedef Directory<LocalOrdinal, GlobalOrdinal, NodeType> base_type;
  typedef typename base_type::map_type map_type;
 
  ContiguousUniformDirectory() = default;
  ContiguousUniformDirectory(const map_type &map);
  ~ContiguousUniformDirectory() override = default;
 
  bool isOneToOne(const Teuchos::Comm<int> &) const override {
    return true;
  }
 
 
 
  std::string description() const override;
 
 protected:
  LookupStatus
  getEntriesImpl(const map_type &map,
                 const Teuchos::ArrayView<const GlobalOrdinal> &globalIDs,
                 const Teuchos::ArrayView<int> &nodeIDs,
                 const Teuchos::ArrayView<LocalOrdinal> &localIDs,
                 const bool computeLIDs) const override;
};
 
template <class LocalOrdinal, class GlobalOrdinal, class NodeType>
class DistributedContiguousDirectory : public Directory<LocalOrdinal, GlobalOrdinal, NodeType> {
 private:
  template <class LO, class GO, class N>
  friend class DistributedContiguousDirectory;
 
 public:
  typedef Directory<LocalOrdinal, GlobalOrdinal, NodeType> base_type;
  typedef typename base_type::map_type map_type;
 
  DistributedContiguousDirectory() = default;
  DistributedContiguousDirectory(const map_type &map);
  ~DistributedContiguousDirectory() override = default;
 
  bool isOneToOne(const Teuchos::Comm<int> &) const override {
    return true;
  }
 
 
 
  std::string description() const override;
 
 protected:
  LookupStatus
  getEntriesImpl(const map_type &map,
                 const Teuchos::ArrayView<const GlobalOrdinal> &globalIDs,
                 const Teuchos::ArrayView<int> &nodeIDs,
                 const Teuchos::ArrayView<LocalOrdinal> &localIDs,
                 const bool computeLIDs) const override;
 
 private:
  Teuchos::ArrayRCP<GlobalOrdinal> allMinGIDs_;
};
 
template <class LocalOrdinal, class GlobalOrdinal, class NodeType>
class DistributedNoncontiguousDirectory : public Directory<LocalOrdinal, GlobalOrdinal, NodeType> {
 private:
  template <class LO, class GO, class N>
  friend class DistributedNoncontiguousDirectory;
 
 public:
  typedef Tpetra::Details::TieBreak<LocalOrdinal, GlobalOrdinal> tie_break_type;
  using base_type = Directory<LocalOrdinal, GlobalOrdinal, NodeType>;
  using map_type  = typename base_type::map_type;
 
  DistributedNoncontiguousDirectory() = default;
  DistributedNoncontiguousDirectory(const map_type &map);
  DistributedNoncontiguousDirectory(const map_type &map,
                                    const tie_break_type &tie_break);
  ~DistributedNoncontiguousDirectory() override = default;
 
  bool isOneToOne(const Teuchos::Comm<int> &comm) const override;
 
 
 
  std::string description() const override;
 protected:
  LookupStatus
  getEntriesImpl(const map_type &map,
                 const Teuchos::ArrayView<const GlobalOrdinal> &globalIDs,
                 const Teuchos::ArrayView<int> &nodeIDs,
                 const Teuchos::ArrayView<LocalOrdinal> &localIDs,
                 const bool computeLIDs) const override;
 
 private:
  void
  initialize(const map_type &map,
             Teuchos::Ptr<const tie_break_type> tie_break);
 
  bool isLocallyOneToOne() const {
    return locallyOneToOne_;
  }
 
  Teuchos::RCP<const map_type> directoryMap_;
 
 
 
  Teuchos::ArrayRCP<int> PIDs_;
 
  Teuchos::ArrayRCP<LocalOrdinal> LIDs_;
 
 
 
  typedef typename Details::FixedHashTable<LocalOrdinal, int,
                                           Kokkos::HostSpace::device_type>
      lidToPidTable_type;
  Teuchos::RCP<lidToPidTable_type> lidToPidTable_;
 
  typedef typename Details::FixedHashTable<LocalOrdinal, LocalOrdinal,
                                           Kokkos::HostSpace::device_type>
      lidToLidTable_type;
  Teuchos::RCP<lidToLidTable_type> lidToLidTable_;
 
  mutable enum EOneToOneResult {
    ONE_TO_ONE_NOT_CALLED_YET,
    ONE_TO_ONE_FALSE,
    ONE_TO_ONE_TRUE
  } oneToOneResult_;
 
  bool locallyOneToOne_;
 
  bool useHashTables_;
};
}  // namespace Details
}  // namespace Tpetra
 
#endif  // __Tpetra_DirectoryImpl_decl_hpp