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 {

  namespace Details {

    template<class OutMapType, class InMapType>
    struct MapCloner {
      typedef typename OutMapType::node_type out_node_type;
      typedef typename InMapType::node_type in_node_type;

      static OutMapType
      clone (const InMapType& mapIn,
             const Teuchos::RCP<out_node_type>& node2);
    };

  } // namespace Details

  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;

    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 getNodeNumElements () 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->getNodeNumElements () == 0) {
        return Tpetra::Details::OrdinalTraits<local_ordinal_type>::invalid ();
      } else { // Local indices are always zero-based.
        return static_cast<local_ordinal_type> (this->getNodeNumElements () - 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,
                         device_type> global_indices_array_type;

  public:
    global_indices_array_type getMyGlobalIndices () const;

    Teuchos::ArrayView<const global_ordinal_type> getNodeElementList() 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;

  protected:
    // This lets other specializations of Map access all of this
    // specialization's internal methods and data, so that we can
    // implement clone() without exposing the details of Map to users.
    template <class LO, class GO, class N> friend class Map;

  private:
    template<class OutMapType, class InMapType>
    friend struct Details::MapCloner;

    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,
                         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, device_type>
      global_to_local_table_type;

    global_to_local_table_type glMap_;

    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"

namespace Tpetra {
  namespace Details {

    template<class OutMapType, class InMapType>
    OutMapType TPETRA_DEPRECATED
    MapCloner<OutMapType, InMapType>::
    clone (const InMapType& mapIn,
           const Teuchos::RCP<out_node_type>& /* nodeOut */)
    {
      static_assert (std::is_same<typename OutMapType::local_ordinal_type,
                                  typename InMapType::local_ordinal_type>::value,
                     "Tpetra::Map clone: The LocalOrdinal template parameter "
                     "of the input and output Map types must be the same.");
      static_assert (std::is_same<typename OutMapType::global_ordinal_type,
                                  typename InMapType::global_ordinal_type>::value,
                     "Tpetra::Map clone: The GlobalOrdinal template parameter "
                     "of the input and output Map types must be the same.");
      typedef typename OutMapType::local_ordinal_type LO;
      typedef typename OutMapType::global_ordinal_type GO;
      typedef ::Tpetra::Directory<LO, GO,
                                  typename OutMapType::node_type> out_dir_type;
      typedef typename OutMapType::global_to_local_table_type out_table_type;
      typedef typename OutMapType::device_type out_device_type;

      OutMapType mapOut; // Make an empty Map.

      // Fill the new Map with (possibly) shallow copies of all of the
      // original Map's data.  This is safe because Map is immutable,
      // so users can't change the original Map.
      mapOut.comm_              = mapIn.comm_;
      mapOut.indexBase_         = mapIn.indexBase_;
      mapOut.numGlobalElements_ = mapIn.numGlobalElements_;
      mapOut.numLocalElements_  = mapIn.numLocalElements_;
      mapOut.minMyGID_          = mapIn.minMyGID_;
      mapOut.maxMyGID_          = mapIn.maxMyGID_;
      mapOut.minAllGID_         = mapIn.minAllGID_;
      mapOut.maxAllGID_         = mapIn.maxAllGID_;
      mapOut.firstContiguousGID_= mapIn.firstContiguousGID_;
      mapOut.lastContiguousGID_ = mapIn.lastContiguousGID_;
      mapOut.uniform_           = mapIn.uniform_;
      mapOut.contiguous_        = mapIn.contiguous_;
      mapOut.distributed_       = mapIn.distributed_;
      {
        // mfh 25 Dec 2015, 11 Jan 2016: We really only need to make a
        // deep copy if the two Map types have different memory
        // spaces.  However, if you're calling clone(), it is likely
        // the case that the memory spaces differ, so it doesn't hurt
        // to make a deep copy here.
        Kokkos::View<GO*, Kokkos::LayoutLeft, out_device_type>
          lgMapOut ("lgMap", mapIn.lgMap_.extent (0));
        Kokkos::deep_copy (lgMapOut, mapIn.lgMap_);
        mapOut.lgMap_ = lgMapOut; // cast to const

        // mfh 11 Apr 2016: We can't just assign mapIn.lgMapHost_ to
        // mapOut.lgMapHost_ either.  This is because the memory space
        // of the host mirror of a CudaUVMSpace View is also
        // CudaUVMSpace, but the memory space of the host mirror of a
        // HostSpace View is HostSpace.  We can't assign one View to
        // another View with a different memory space.
        //
        // What we _can_ do here, though, is avoid a deep_copy in case
        // we're not using CUDA, by exploiting host mirrors.

        // lgMapOut is nonconst, so use it here instead of mapOut.lgMap_.
        auto lgMapHostOut =
          Kokkos::create_mirror_view (Kokkos::HostSpace (), lgMapOut);
        Kokkos::deep_copy (lgMapHostOut, lgMapOut);
        mapOut.lgMapHost_ = lgMapHostOut;
      }
      // This makes a deep copy only if necessary.  We could have
      // defined operator= to do this, but that would violate
      // expectations.  (Kokkos::View::operator= only does a shallow
      // copy, EVER.)
      mapOut.glMap_ = out_table_type (mapIn.glMap_);

      // We could cleverly clone the Directory here if it is
      // initialized, but there is no harm in simply creating it
      // uninitialized.
      mapOut.directory_ = Teuchos::rcp (new out_dir_type ());

      return mapOut;
    }
  } // namespace Details


} // namespace Tpetra

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