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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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/sparse_matrix.h>
#include <deal.II/lac/cuda_vector.h>
#include <cusparse.h>

DEAL_II_NAMESPACE_OPEN

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

    typedef Number value_type;

    typedef Number real_type;

    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;
  }
}

DEAL_II_NAMESPACE_CLOSE

#endif
#endif