Ifpack2_RILUK_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//       Ifpack2: Templated Object-Oriented Algebraic Preconditioner Package
//
// Copyright 2009 NTESS and the Ifpack2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER


#ifndef IFPACK2_CRSRILUK_DECL_HPP
#define IFPACK2_CRSRILUK_DECL_HPP

#include "KokkosSparse_spiluk.hpp"

#include "Ifpack2_Preconditioner.hpp"
#include "Ifpack2_Details_CanChangeMatrix.hpp"
#include "Tpetra_CrsMatrix_decl.hpp"
#include "Ifpack2_ScalingType.hpp"
#include "Ifpack2_IlukGraph.hpp"
#include "Ifpack2_LocalSparseTriangularSolver_decl.hpp"

#include <memory>
#include <type_traits>

namespace Teuchos {
  class ParameterList; // forward declaration
}

namespace Ifpack2 {

template<class MatrixType>
class RILUK:
    virtual public Ifpack2::Preconditioner<typename MatrixType::scalar_type,
                                           typename MatrixType::local_ordinal_type,
                                           typename MatrixType::global_ordinal_type,
                                           typename MatrixType::node_type>,
    virtual public Ifpack2::Details::CanChangeMatrix<Tpetra::RowMatrix<typename MatrixType::scalar_type,
                                                                       typename MatrixType::local_ordinal_type,
                                                                       typename MatrixType::global_ordinal_type,
                                                                       typename MatrixType::node_type> >
{
 public:
  typedef typename MatrixType::scalar_type scalar_type;

  typedef typename MatrixType::local_ordinal_type local_ordinal_type;

  typedef typename MatrixType::global_ordinal_type global_ordinal_type;

  typedef typename MatrixType::node_type node_type;

  typedef typename Teuchos::ScalarTraits<scalar_type>::magnitudeType magnitude_type;

  typedef typename node_type::device_type device_type;

  typedef typename node_type::execution_space execution_space;

  typedef Tpetra::RowMatrix<scalar_type,
                            local_ordinal_type,
                            global_ordinal_type,
                            node_type> row_matrix_type;


  static_assert(std::is_same<MatrixType, row_matrix_type>::value, "Ifpack2::RILUK: The template parameter MatrixType must be a Tpetra::RowMatrix specialization.  Please don't use Tpetra::CrsMatrix (a subclass of Tpetra::RowMatrix) here anymore.");

  typedef Tpetra::CrsMatrix<scalar_type,
                            local_ordinal_type,
                            global_ordinal_type,
                            node_type> crs_matrix_type;

  typedef typename crs_matrix_type::impl_scalar_type impl_scalar_type;

  template <class NewMatrixType> friend class RILUK;

  typedef typename crs_matrix_type::global_inds_host_view_type global_inds_host_view_type;
  typedef typename crs_matrix_type::local_inds_host_view_type local_inds_host_view_type;
  typedef typename crs_matrix_type::values_host_view_type values_host_view_type;


  typedef typename crs_matrix_type::nonconst_global_inds_host_view_type nonconst_global_inds_host_view_type;
  typedef typename crs_matrix_type::nonconst_local_inds_host_view_type nonconst_local_inds_host_view_type;
  typedef typename crs_matrix_type::nonconst_values_host_view_type nonconst_values_host_view_type;




  typedef typename crs_matrix_type::local_matrix_device_type local_matrix_device_type;
  typedef typename local_matrix_device_type::StaticCrsGraphType::row_map_type lno_row_view_t;
  typedef typename local_matrix_device_type::StaticCrsGraphType::entries_type lno_nonzero_view_t;
  typedef typename local_matrix_device_type::values_type scalar_nonzero_view_t;
  typedef typename local_matrix_device_type::StaticCrsGraphType::device_type::memory_space TemporaryMemorySpace;
  typedef typename local_matrix_device_type::StaticCrsGraphType::device_type::memory_space PersistentMemorySpace;
  typedef typename local_matrix_device_type::StaticCrsGraphType::device_type::execution_space HandleExecSpace;
  typedef typename KokkosKernels::Experimental::KokkosKernelsHandle
    <typename lno_row_view_t::const_value_type, typename lno_nonzero_view_t::const_value_type, typename scalar_nonzero_view_t::value_type,
    HandleExecSpace, TemporaryMemorySpace,PersistentMemorySpace > kk_handle_type;
  typedef Ifpack2::IlukGraph<Tpetra::CrsGraph<local_ordinal_type, global_ordinal_type, node_type>, kk_handle_type> iluk_graph_type;

  RILUK (const Teuchos::RCP<const row_matrix_type>& A_in);

  RILUK (const Teuchos::RCP<const crs_matrix_type>& A_in);

 private:
  RILUK (const RILUK<MatrixType> & src);

 public:
  virtual ~RILUK ();

  void setParameters (const Teuchos::ParameterList& params);

  void initialize ();

  void compute ();

  bool isInitialized () const {
    return isInitialized_;
  }
  bool isComputed () const {
    return isComputed_;
  }

  int getNumInitialize () const {
    return numInitialize_;
  }
  int getNumCompute () const {
    return numCompute_;
  }
  int getNumApply () const {
    return numApply_;
  }

  double getInitializeTime () const {
    return initializeTime_;
  }
  double getComputeTime () const {
    return computeTime_;
  }
  double getApplyTime () const {
    return applyTime_;
  }

  size_t getNodeSmootherComplexity() const;





  virtual void
  setMatrix (const Teuchos::RCP<const row_matrix_type>& A);



  std::string description () const;



  Teuchos::RCP<const Tpetra::Map<local_ordinal_type,global_ordinal_type,node_type> >
  getDomainMap () const;

  Teuchos::RCP<const Tpetra::Map<local_ordinal_type,global_ordinal_type,node_type> >
  getRangeMap () const;

  void
  apply (const Tpetra::MultiVector<scalar_type,local_ordinal_type,global_ordinal_type,node_type>& X,
         Tpetra::MultiVector<scalar_type,local_ordinal_type,global_ordinal_type,node_type>& Y,
         Teuchos::ETransp mode = Teuchos::NO_TRANS,
         scalar_type alpha = Teuchos::ScalarTraits<scalar_type>::one (),
         scalar_type beta = Teuchos::ScalarTraits<scalar_type>::zero ()) const;

private:
  void
  multiply (const Tpetra::MultiVector<scalar_type,local_ordinal_type,global_ordinal_type,node_type>& X,
            Tpetra::MultiVector<scalar_type,local_ordinal_type,global_ordinal_type,node_type>& Y,
            const Teuchos::ETransp mode = Teuchos::NO_TRANS) const;
public:

  Teuchos::RCP<const row_matrix_type> getMatrix () const;

  // Attribute access functions

  magnitude_type getRelaxValue () const { return RelaxValue_; }

  magnitude_type getAbsoluteThreshold () const { return Athresh_; }

  magnitude_type getRelativeThreshold () const {return Rthresh_;}

  int getLevelOfFill () const { return LevelOfFill_; }

  Tpetra::CombineMode getOverlapMode () {
    TEUCHOS_TEST_FOR_EXCEPTION(
      true, std::logic_error, "Ifpack2::RILUK::SetOverlapMode: "
      "RILUK no longer implements overlap on its own.  "
      "Use RILUK with AdditiveSchwarz if you want overlap.");
  }

  Tpetra::global_size_t getGlobalNumEntries () const {
    return getL ().getGlobalNumEntries () + getU ().getGlobalNumEntries ();
  }

  Teuchos::RCP<Ifpack2::IlukGraph<Tpetra::CrsGraph<local_ordinal_type,
                                                   global_ordinal_type,
                                                   node_type>, kk_handle_type> > getGraph () const {
    return Graph_;
  }

  const crs_matrix_type& getL () const;

  const Tpetra::Vector<scalar_type,local_ordinal_type,global_ordinal_type,node_type>&
  getD () const;

  const crs_matrix_type& getU () const;

  Teuchos::RCP<const crs_matrix_type> getCrsMatrix () const;

  static Teuchos::RCP<const row_matrix_type>
  makeLocalFilter (const Teuchos::RCP<const row_matrix_type>& A);

private:
  typedef Tpetra::MultiVector<scalar_type,local_ordinal_type,global_ordinal_type,node_type> MV;
  typedef Teuchos::ScalarTraits<scalar_type> STS;
  typedef Teuchos::ScalarTraits<magnitude_type> STM;

  void allocateSolvers ();
  void allocate_L_and_U ();
  static void checkOrderingConsistency (const row_matrix_type& A);
  void initAllValues (const row_matrix_type& A);

  void compute_serial();
  void compute_kkspiluk();
// Workaround Cuda limitation of KOKKOS_LAMBDA in private/protected member functions
#ifdef KOKKOS_ENABLE_CUDA
public:
#endif
  void compute_kkspiluk_stream();
#ifdef KOKKOS_ENABLE_CUDA
private:
#endif

protected:
  typedef Tpetra::Vector<scalar_type,local_ordinal_type,global_ordinal_type,node_type> vec_type;

  Teuchos::RCP<const row_matrix_type> A_;

  Teuchos::RCP<iluk_graph_type> Graph_;
  std::vector< Teuchos::RCP<iluk_graph_type> > Graph_v_;
  Teuchos::RCP<const row_matrix_type> A_local_;
  Teuchos::RCP<const crs_matrix_type> A_local_crs_;
  Teuchos::RCP<crs_matrix_type> A_local_crs_nc_;
  std::vector<local_matrix_device_type> A_local_diagblks;
  std::vector< lno_row_view_t > A_local_diagblks_rowmap_v_;
  std::vector< lno_nonzero_view_t > A_local_diagblks_entries_v_;
  std::vector< scalar_nonzero_view_t > A_local_diagblks_values_v_;

  Teuchos::RCP<crs_matrix_type> L_;
  std::vector< Teuchos::RCP<crs_matrix_type> > L_v_;
  Teuchos::RCP<LocalSparseTriangularSolver<row_matrix_type> > L_solver_;
  Teuchos::RCP<crs_matrix_type> U_;
  std::vector< Teuchos::RCP<crs_matrix_type> > U_v_;
  Teuchos::RCP<LocalSparseTriangularSolver<row_matrix_type> > U_solver_;

  Teuchos::RCP<vec_type> D_;

  int LevelOfFill_;
  double Overalloc_;

  bool isAllocated_;
  bool isInitialized_;
  bool isComputed_;

  int numInitialize_;
  int numCompute_;
  mutable int numApply_;

  double initializeTime_;
  double computeTime_;
  mutable double applyTime_;

  magnitude_type RelaxValue_;
  magnitude_type Athresh_;
  magnitude_type Rthresh_;

  bool isKokkosKernelsSpiluk_;
  Teuchos::RCP<kk_handle_type> KernelHandle_;
  std::vector< Teuchos::RCP<kk_handle_type> > KernelHandle_v_;
  bool isKokkosKernelsStream_;
  int num_streams_;
  std::vector<execution_space> exec_space_instances_;
  bool hasStreamReordered_;
  std::vector<typename lno_nonzero_view_t::non_const_type> perm_v_;
  std::vector<typename lno_nonzero_view_t::non_const_type> reverse_perm_v_;
  mutable std::unique_ptr<MV> Y_tmp_;
  mutable std::unique_ptr<MV> reordered_x_;
  mutable std::unique_ptr<MV> reordered_y_;
};

// NOTE (mfh 11 Feb 2015) This used to exist in order to deal with
// different behavior of Tpetra::Crs{Graph,Matrix} for
// KokkosClassic::ThrustGPUNode.  In particular, fillComplete on a
// CrsMatrix used to make the graph go away by default, so we had to
// pass in a parameter to keep a host copy of the graph.  With the new
// (Kokkos refactor) version of Tpetra, this problem has gone away.
namespace detail {
  template<class MatrixType, class NodeType>
  struct setLocalSolveParams{
    static Teuchos::RCP<Teuchos::ParameterList>
    setParams (const Teuchos::RCP<Teuchos::ParameterList>& param) {
      return param;
    }
  };
} // namespace detail

} // namespace Ifpack2

#endif /* IFPACK2_CRSRILUK_DECL_HPP */