Tpetra_Map_decl.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//          Tpetra: Templated Linear Algebra Services Package
//                 Copyright (2008) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// ************************************************************************
// @HEADER

#ifndef TPETRA_MAP_DECL_HPP
#define TPETRA_MAP_DECL_HPP


#include "Tpetra_ConfigDefs.hpp"
#include "Tpetra_Map_fwd.hpp"
#include "Tpetra_Directory_fwd.hpp"
#include "Tpetra_TieBreak_fwd.hpp"
#include "Tpetra_Details_LocalMap.hpp"
#include "Kokkos_DefaultNode.hpp"
#include "Kokkos_DualView.hpp"
#include "Teuchos_Array.hpp"
#include "Teuchos_Comm.hpp"
#include "Teuchos_Describable.hpp"


namespace Tpetra {

  template <class LocalOrdinal,
            class GlobalOrdinal,
            class Node>
  class Map : public Teuchos::Describable {
  public:


    using local_ordinal_type = LocalOrdinal;

    using global_ordinal_type = GlobalOrdinal;

    using device_type = typename Node::device_type;

    using execution_space = typename device_type::execution_space;

    using memory_space = typename device_type::memory_space;

    using node_type = Node;

#ifdef KOKKOS_ENABLE_CUDA
    using no_uvm_memory_space = typename std::conditional<std::is_same<memory_space, Kokkos::CudaUVMSpace>::value,
      Kokkos::CudaSpace, memory_space>::type;
    using no_uvm_device_type = Kokkos::Device<execution_space, no_uvm_memory_space>;
#else
    using no_uvm_device_type = device_type;
#endif

    using local_map_type =
      ::Tpetra::Details::LocalMap<local_ordinal_type,
                                  global_ordinal_type,
                                  device_type>;



    Map (const global_size_t numGlobalElements,
         const global_ordinal_type indexBase,
         const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
         const LocalGlobal lg=GloballyDistributed);


    Map (const global_size_t numGlobalElements,
         const size_t numLocalElements,
         const global_ordinal_type indexBase,
         const Teuchos::RCP<const Teuchos::Comm<int> > &comm);


    Map (const global_size_t numGlobalElements,
         const Kokkos::View<const global_ordinal_type*, device_type>& indexList,
         const global_ordinal_type indexBase,
         const Teuchos::RCP<const Teuchos::Comm<int> >& comm);

    Map (const global_size_t numGlobalElements,
         const global_ordinal_type indexList[],
         const local_ordinal_type indexListSize,
         const global_ordinal_type indexBase,
         const Teuchos::RCP<const Teuchos::Comm<int> >& comm);

    Map (const global_size_t numGlobalElements,
         const Teuchos::ArrayView<const global_ordinal_type>& indexList,
         const global_ordinal_type indexBase,
         const Teuchos::RCP<const Teuchos::Comm<int> >& comm);


    Map ();

    Map (const Map<local_ordinal_type, global_ordinal_type, node_type>&) = default;

    Map (Map<local_ordinal_type, global_ordinal_type, node_type>&&) = default;

    Map&
    operator= (const Map<local_ordinal_type, global_ordinal_type, node_type>&) = default;

    Map&
    operator= (Map<local_ordinal_type, global_ordinal_type, node_type>&&) = default;

    virtual ~Map ();



    bool isOneToOne () const;

    global_size_t getGlobalNumElements () const {
      return numGlobalElements_;
    }

    size_t getLocalNumElements () const {
      return numLocalElements_;
    }

    global_ordinal_type getIndexBase () const {
      return indexBase_;
    }

    local_ordinal_type getMinLocalIndex () const {
      return static_cast<local_ordinal_type> (0);
    }

    local_ordinal_type getMaxLocalIndex () const {
      if (this->getLocalNumElements () == 0) {
        return Tpetra::Details::OrdinalTraits<local_ordinal_type>::invalid ();
      } else { // Local indices are always zero-based.
        return static_cast<local_ordinal_type> (this->getLocalNumElements () - 1);
      }
    }

    global_ordinal_type getMinGlobalIndex () const {
      return minMyGID_;
    }

    global_ordinal_type getMaxGlobalIndex () const {
      return maxMyGID_;
    }

    global_ordinal_type getMinAllGlobalIndex () const {
      return minAllGID_;
    }

    global_ordinal_type getMaxAllGlobalIndex () const {
      return maxAllGID_;
    }

    local_ordinal_type getLocalElement (global_ordinal_type globalIndex) const;

    global_ordinal_type getGlobalElement (local_ordinal_type localIndex) const;

    local_map_type getLocalMap () const;

    LookupStatus
    getRemoteIndexList (const Teuchos::ArrayView<const global_ordinal_type>& GIDList,
                        const Teuchos::ArrayView<                int>& nodeIDList,
                        const Teuchos::ArrayView<       local_ordinal_type>& LIDList) const;

    LookupStatus
    getRemoteIndexList (const Teuchos::ArrayView<const global_ordinal_type> & GIDList,
                        const Teuchos::ArrayView<                int> & nodeIDList) const;

  private:
    typedef Kokkos::View<const global_ordinal_type*,
                         Kokkos::LayoutLeft,
                         Kokkos::HostSpace> global_indices_array_type;

  public:
    global_indices_array_type getMyGlobalIndices () const;

    Teuchos::ArrayView<const global_ordinal_type> getLocalElementList() const;



    bool isNodeLocalElement (local_ordinal_type localIndex) const;

    bool isNodeGlobalElement (global_ordinal_type globalIndex) const;

    bool isUniform () const;

    bool isContiguous () const;

    bool isDistributed () const;

    bool isCompatible (const Map<local_ordinal_type,global_ordinal_type,Node> &map) const;

    bool isSameAs (const Map<local_ordinal_type,global_ordinal_type,Node> &map) const;

    bool locallySameAs (const Map<local_ordinal_type, global_ordinal_type, node_type>& map) const;

    bool isLocallyFitted (const Map<local_ordinal_type, global_ordinal_type, Node>& map) const;



    Teuchos::RCP<const Teuchos::Comm<int> > getComm () const;




    std::string description () const;

    void
    describe (Teuchos::FancyOStream &out,
              const Teuchos::EVerbosityLevel verbLevel =
                Teuchos::Describable::verbLevel_default) const;


    Teuchos::RCP<const Map<local_ordinal_type, global_ordinal_type, Node> >
    removeEmptyProcesses () const;

    Teuchos::RCP<const Map<local_ordinal_type, global_ordinal_type, Node> >
    replaceCommWithSubset (const Teuchos::RCP<const Teuchos::Comm<int> >& newComm) const;

  private:
    std::string
    localDescribeToString (const Teuchos::EVerbosityLevel vl) const;

    void setupDirectory () const;

    bool checkIsDist() const;

    global_size_t
    initialNonuniformDebugCheck(
      const char errorMessagePrefix[],
      const global_size_t numGlobalElements,
      const size_t numLocalElements,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm) const;

    void
    initWithNonownedHostIndexList(
      const char errorMessagePrefix[],
      const global_size_t numGlobalElements,
      const Kokkos::View<const global_ordinal_type*,
        Kokkos::LayoutLeft,
        Kokkos::HostSpace,
        Kokkos::MemoryUnmanaged>& entryList,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm);

    Teuchos::RCP<const Teuchos::Comm<int> > comm_;

    global_ordinal_type indexBase_;

    global_size_t numGlobalElements_;

    size_t numLocalElements_;

    global_ordinal_type minMyGID_;

    global_ordinal_type maxMyGID_;

    global_ordinal_type minAllGID_;

    global_ordinal_type maxAllGID_;

    global_ordinal_type firstContiguousGID_;

    global_ordinal_type lastContiguousGID_;

    bool uniform_;

    bool contiguous_;

    bool distributed_;

    mutable Kokkos::View<const global_ordinal_type*,
                         Kokkos::LayoutLeft,
                         no_uvm_device_type> lgMap_;

#ifndef SWIG
    mutable Kokkos::View<const global_ordinal_type*,
                         Kokkos::LayoutLeft,
                         Kokkos::HostSpace> lgMapHost_;
#endif

    typedef ::Tpetra::Details::FixedHashTable<global_ordinal_type,
      local_ordinal_type, no_uvm_device_type> global_to_local_table_type;

    global_to_local_table_type glMap_;

    typedef ::Tpetra::Details::FixedHashTable<
      global_ordinal_type, local_ordinal_type, Kokkos::HostSpace::device_type>
      global_to_local_table_host_type;

    global_to_local_table_host_type glMapHost_;

    mutable Teuchos::RCP<
      Directory<
        local_ordinal_type, global_ordinal_type, node_type
        >
      > directory_;
  }; // Map class

  template <class LocalOrdinal, class GlobalOrdinal>
  Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal> >
  createLocalMap (const size_t numElements,
                  const Teuchos::RCP<const Teuchos::Comm<int> >& comm);

  template <class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createLocalMapWithNode (const size_t numElements,
                          const Teuchos::RCP<const Teuchos::Comm<int> >& comm);


  template <class LocalOrdinal, class GlobalOrdinal>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal> >
  createUniformContigMap (const global_size_t numElements,
                          const Teuchos::RCP<const Teuchos::Comm<int> >& comm);

  template <class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createUniformContigMapWithNode (const global_size_t numElements,
                                  const Teuchos::RCP<const Teuchos::Comm<int> >& comm);


  template <class LocalOrdinal, class GlobalOrdinal>
  Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal> >
  createContigMap (const global_size_t numElements,
                   const size_t localNumElements,
                   const Teuchos::RCP<const Teuchos::Comm<int> >& comm);

  template <class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createContigMapWithNode (const global_size_t numElements,
                           const size_t localNumElements,
                           const Teuchos::RCP<const Teuchos::Comm<int> >& comm);


  template <class LocalOrdinal, class GlobalOrdinal>
  Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal> >
  createNonContigMap (const Teuchos::ArrayView<const GlobalOrdinal>& elementList,
                      const Teuchos::RCP<const Teuchos::Comm<int> >& comm);

  template <class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createNonContigMapWithNode (const Teuchos::ArrayView<const GlobalOrdinal> &elementList,
                              const Teuchos::RCP<const Teuchos::Comm<int> > &comm);


  template<class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createOneToOne (const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >& M);

  template<class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createOneToOne(const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> > &M,
                 const ::Tpetra::Details::TieBreak<LocalOrdinal,GlobalOrdinal> & tie_break);

} // namespace Tpetra

#include "Tpetra_Directory_decl.hpp"

template <class LocalOrdinal, class GlobalOrdinal, class Node>
bool operator== (const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map1,
                 const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map2)
{ return map1.isSameAs (map2); }

template <class LocalOrdinal, class GlobalOrdinal, class Node>
bool operator!= (const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map1,
                 const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map2)
{ return ! map1.isSameAs (map2); }


#endif // TPETRA_MAP_DECL_HPP