cuda_sparse_matrix.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_cuda_sparse_matrix_h
#define dealii_cuda_sparse_matrix_h

#include <deal.II/base/config.h>

#include <deal.II/base/subscriptor.h>

#ifdef DEAL_II_WITH_CUDA
#  include <deal.II/base/cuda.h>

#  include <deal.II/lac/cuda_vector.h>
#  include <deal.II/lac/sparse_matrix.h>

#  include <cusparse.h>

DEAL_II_NAMESPACE_OPEN

namespace CUDAWrappers
{
  template <typename Number>
  class SparseMatrix : public virtual Subscriptor
  {
  public:
    using size_type = unsigned int;

    using value_type = Number;

    using real_type = Number;

    SparseMatrix();

    SparseMatrix(Utilities::CUDA::Handle &             handle,
                 const ::SparseMatrix<Number> &sparse_matrix_host);

    SparseMatrix(CUDAWrappers::SparseMatrix<Number> &&);

    SparseMatrix(const CUDAWrappers::SparseMatrix<Number> &) = delete;

    ~SparseMatrix();

    void
    reinit(Utilities::CUDA::Handle &             handle,
           const ::SparseMatrix<Number> &sparse_matrix_host);

    size_type
    m() const;

    size_type
    n() const;

    std::size_t
    n_nonzero_elements() const;

    SparseMatrix &
    operator*=(const Number factor);

    SparseMatrix &
    operator/=(const Number factor);

    void
    vmult(LinearAlgebra::CUDAWrappers::Vector<Number> &      dst,
          const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;

    void
    Tvmult(LinearAlgebra::CUDAWrappers::Vector<Number> &      dst,
           const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;

    void
    vmult_add(LinearAlgebra::CUDAWrappers::Vector<Number> &      dst,
              const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;

    void
    Tvmult_add(LinearAlgebra::CUDAWrappers::Vector<Number> &      dst,
               const LinearAlgebra::CUDAWrappers::Vector<Number> &src) const;

    Number
    matrix_norm_square(
      const LinearAlgebra::CUDAWrappers::Vector<Number> &v) const;

    Number
    matrix_scalar_product(
      const LinearAlgebra::CUDAWrappers::Vector<Number> &u,
      const LinearAlgebra::CUDAWrappers::Vector<Number> &v) const;

    Number
    residual(LinearAlgebra::CUDAWrappers::Vector<Number> &      dst,
             const LinearAlgebra::CUDAWrappers::Vector<Number> &x,
             const LinearAlgebra::CUDAWrappers::Vector<Number> &b) const;

    Number
    l1_norm() const;

    Number
    linfty_norm() const;

    Number
    frobenius_norm() const;

    std::tuple<Number *, int *, int *, cusparseMatDescr_t>
    get_cusparse_matrix() const;

  private:
    mutable cusparseHandle_t cusparse_handle;

    int nnz;

    int n_rows;

    int n_cols;

    Number *val_dev;

    int *column_index_dev;

    int *row_ptr_dev;

    cusparseMatDescr_t descr;
  };



  template <typename Number>
  inline unsigned int
  SparseMatrix<Number>::m() const
  {
    return n_rows;
  }



  template <typename Number>
  inline unsigned int
  SparseMatrix<Number>::n() const
  {
    return n_cols;
  }



  template <typename Number>
  inline std::size_t
  SparseMatrix<Number>::n_nonzero_elements() const
  {
    return nnz;
  }
} // namespace CUDAWrappers

DEAL_II_NAMESPACE_CLOSE

#endif
#endif