Tpetra_Experimental_BlockMultiVector_decl.hpp

// @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.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
// @HEADER

#ifndef TPETRA_EXPERIMENTAL_BLOCKMULTIVECTOR_DECL_HPP
#define TPETRA_EXPERIMENTAL_BLOCKMULTIVECTOR_DECL_HPP

#include "Tpetra_Experimental_BlockMultiVector_fwd.hpp"
#include "Tpetra_Experimental_BlockCrsMatrix_fwd.hpp"
#include "Tpetra_MultiVector.hpp"
#include <memory>
#include <utility>

namespace Tpetra {
namespace Experimental {

template<class Scalar,
         class LO,
         class GO,
         class Node>
class BlockMultiVector :
    public Tpetra::DistObject<Scalar, LO, GO, Node>
{
private:
  using dist_object_type = Tpetra::DistObject<Scalar, LO, GO, Node>;
  using STS = Teuchos::ScalarTraits<Scalar>;
  using packet_type = typename dist_object_type::packet_type;

public:


  using map_type = Tpetra::Map<LO, GO, Node>;
  using mv_type = Tpetra::MultiVector<Scalar, LO, GO, Node>;

  using scalar_type = Scalar;
  using impl_scalar_type = typename mv_type::impl_scalar_type;
  using local_ordinal_type = LO;
  using global_ordinal_type = GO;
  using device_type = typename mv_type::device_type;

  using node_type = Node;

  using buffer_device_type = typename dist_object_type::buffer_device_type;

  typedef Kokkos::View<impl_scalar_type*,
                       Kokkos::LayoutRight,
                       device_type,
                       Kokkos::MemoryTraits<Kokkos::Unmanaged> >
          little_vec_type;

  typedef Kokkos::View<const impl_scalar_type*,
                       Kokkos::LayoutRight,
                       device_type,
                       Kokkos::MemoryTraits<Kokkos::Unmanaged> >
          const_little_vec_type;



  BlockMultiVector (const map_type& meshMap,
                    const LO blockSize,
                    const LO numVecs);

  BlockMultiVector (const map_type& meshMap,
                    const map_type& pointMap,
                    const LO blockSize,
                    const LO numVecs);

  BlockMultiVector (const mv_type& X_mv,
                    const map_type& meshMap,
                    const LO blockSize);

  BlockMultiVector (const BlockMultiVector<Scalar, LO, GO, Node>& X,
                    const map_type& newMeshMap,
                    const map_type& newPointMap,
                    const size_t offset = 0);

  BlockMultiVector (const BlockMultiVector<Scalar, LO, GO, Node>& X,
                    const map_type& newMeshMap,
                    const size_t offset = 0);

  BlockMultiVector ();



  static map_type
  makePointMap (const map_type& meshMap, const LO blockSize);

  map_type getPointMap () const {
    return pointMap_;
  }

  LO getBlockSize () const {
    return blockSize_;
  }

  LO getNumVectors () const {
    return static_cast<LO> (mv_.getNumVectors ());
  }

  mv_type getMultiVectorView () const;



  void putScalar (const Scalar& val);

  void scale (const Scalar& val);

  void
  update (const Scalar& alpha,
          const BlockMultiVector<Scalar, LO, GO, Node>& X,
          const Scalar& beta);

  void
  blockWiseMultiply (const Scalar& alpha,
                     const Kokkos::View<const impl_scalar_type***,
                       device_type, Kokkos::MemoryUnmanaged>& D,
                     const BlockMultiVector<Scalar, LO, GO, Node>& X);

  void
  blockJacobiUpdate (const Scalar& alpha,
                     const Kokkos::View<const impl_scalar_type***,
                       device_type, Kokkos::MemoryUnmanaged>& D,
                     const BlockMultiVector<Scalar, LO, GO, Node>& X,
                     BlockMultiVector<Scalar, LO, GO, Node>& Z,
                     const Scalar& beta);



  template<class TargetMemorySpace>
  void sync () {
    mv_.template sync<typename TargetMemorySpace::memory_space> ();
  }

  void sync_host() {
    mv_.sync_host();
  }

  void sync_device() {
    mv_.sync_device();
  }

  template<class TargetMemorySpace>
  bool need_sync () const {
    return mv_.template need_sync<typename TargetMemorySpace::memory_space> ();
  }

  bool need_sync_host() const {
    return mv_.need_sync_host();
  }

  bool need_sync_device() const {
    return mv_.need_sync_device();
  }

  template<class TargetMemorySpace>
  void modify () {
    mv_.template modify<typename TargetMemorySpace::memory_space> ();
  }

  void modify_host() {
    mv_.modify_host();
  }

  void modify_device() {
    mv_.modify_device();
  }


  bool replaceLocalValues (const LO localRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool replaceGlobalValues (const GO globalRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool sumIntoLocalValues (const LO localRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool sumIntoGlobalValues (const GO globalRowIndex, const LO colIndex, const Scalar vals[]) const;

  bool getLocalRowView (const LO localRowIndex, const LO colIndex, Scalar*& vals) const;

  bool getGlobalRowView (const GO globalRowIndex, const LO colIndex, Scalar*& vals) const;

  typename little_vec_type::HostMirror
  getLocalBlock (const LO localRowIndex, const LO colIndex) const;

protected:


  virtual bool checkSizes (const Tpetra::SrcDistObject& source);

  virtual void
#ifdef TPETRA_ENABLE_DEPRECATED_CODE
  copyAndPermuteNew
#else // TPETRA_ENABLE_DEPRECATED_CODE
  copyAndPermute
#endif // TPETRA_ENABLE_DEPRECATED_CODE
  (const SrcDistObject& source,
   const size_t numSameIDs,
   const Kokkos::DualView<const local_ordinal_type*,
     buffer_device_type>& permuteToLIDs,
   const Kokkos::DualView<const local_ordinal_type*,
     buffer_device_type>& permuteFromLIDs);

  virtual void
#ifdef TPETRA_ENABLE_DEPRECATED_CODE
  packAndPrepareNew
#else // TPETRA_ENABLE_DEPRECATED_CODE
  packAndPrepare
#endif // TPETRA_ENABLE_DEPRECATED_CODE
  (const SrcDistObject& source,
   const Kokkos::DualView<const local_ordinal_type*,
     buffer_device_type>& exportLIDs,
   Kokkos::DualView<packet_type*,
     buffer_device_type>& exports,
   Kokkos::DualView<size_t*,
     buffer_device_type> numPacketsPerLID,
   size_t& constantNumPackets,
   Distributor& distor);

  virtual void
#ifdef TPETRA_ENABLE_DEPRECATED_CODE
  unpackAndCombineNew
#else // TPETRA_ENABLE_DEPRECATED_CODE
  unpackAndCombine
#endif // TPETRA_ENABLE_DEPRECATED_CODE
  (const Kokkos::DualView<const local_ordinal_type*,
     buffer_device_type>& importLIDs,
   Kokkos::DualView<packet_type*,
     buffer_device_type> imports,
   Kokkos::DualView<size_t*,
     buffer_device_type> numPacketsPerLID,
   const size_t constantNumPackets,
   Distributor& distor,
   const CombineMode combineMode);


protected:
  impl_scalar_type* getRawPtr () const {
    return mvData_;
  }

  size_t getStrideX () const {
    return static_cast<size_t> (1);
  }

  size_t getStrideY () const {
    return mv_.getStride ();
  }

  bool isValidLocalMeshIndex (const LO meshLocalIndex) const;

private:
  map_type meshMap_;

  map_type pointMap_;

protected:
  mv_type mv_;

private:
  impl_scalar_type* mvData_;

  LO blockSize_;

  void
  replaceLocalValuesImpl (const LO localRowIndex,
                          const LO colIndex,
                          const Scalar vals[]) const;
  void
  sumIntoLocalValuesImpl (const LO localRowIndex,
                          const LO colIndex,
                          const Scalar vals[]) const;

  static Teuchos::RCP<const mv_type>
  getMultiVectorFromSrcDistObject (const Tpetra::SrcDistObject&);

  static Teuchos::RCP<const BlockMultiVector<Scalar, LO, GO, Node> >
  getBlockMultiVectorFromSrcDistObject (const Tpetra::SrcDistObject& src);

  std::pair<int, std::unique_ptr<std::string>>
  copyAndPermuteImpl
    (const BlockMultiVector<Scalar, LO, GO, Node>& src,
     const size_t numSameIDs,
     const Kokkos::DualView<
       const local_ordinal_type*,
       buffer_device_type
     >& permuteToLIDs,
     const Kokkos::DualView<
       const local_ordinal_type*,
       buffer_device_type
     >& permuteFromLIDs);

  std::pair<int, std::unique_ptr<std::string>>
  packAndPrepareImpl
    (const Kokkos::DualView<
       const local_ordinal_type*,
       buffer_device_type
     >& exportLIDs,
     Kokkos::DualView<
       impl_scalar_type*,
       buffer_device_type
     >& exports,
     Kokkos::DualView<
       size_t*,
       buffer_device_type
     > /* numPacketsPerLID */,
     size_t& constantNumPackets,
     Distributor& /* distor */ ) const;

  std::pair<int, std::unique_ptr<std::string>>
  unpackAndCombineImpl
    (const Kokkos::DualView<
       const local_ordinal_type*,
       buffer_device_type
     >& importLIDs,
     Kokkos::DualView<
       impl_scalar_type*,
       buffer_device_type
     > imports,
     Kokkos::DualView<
       size_t*,
       buffer_device_type
     > numPacketsPerLID,
     const size_t constantNumPackets,
     Distributor& distor,
     const CombineMode combineMode);
};

} // namespace Experimental
} // namespace Tpetra

#endif // TPETRA_EXPERIMENTAL_BLOCKMULTIVECTOR_DECL_HPP