cuda_vector.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2016 - 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_vector_h
#define dealii_cuda_vector_h

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

#include <deal.II/base/exceptions.h>
#include <deal.II/base/index_set.h>

#include <deal.II/lac/vector_operation.h>
#include <deal.II/lac/vector_space_vector.h>

#ifdef DEAL_II_WITH_CUDA

DEAL_II_NAMESPACE_OPEN

class CommunicationPatternBase;
template <typename Number>
class ReadWriteVector;

namespace LinearAlgebra
{
  namespace CUDAWrappers
  {
    template <typename Number>
    class Vector : public VectorSpaceVector<Number>
    {
    public:
      using value_type = typename VectorSpaceVector<Number>::value_type;
      using size_type  = typename VectorSpaceVector<Number>::size_type;
      using real_type  = typename VectorSpaceVector<Number>::real_type;

      Vector();

      Vector(const Vector<Number> &V);

      Vector(Vector<Number> &&) noexcept = default;

      explicit Vector(const size_type n);

      Vector &
      operator=(const Vector<Number> &v);

      Vector &
      operator=(Vector<Number> &&v) noexcept = default;

      virtual void
      swap(Vector<Number> &v);

      void
      reinit(const size_type n, const bool omit_zeroing_entries = false);

      virtual void
      reinit(const VectorSpaceVector<Number> &V,
             const bool omit_zeroing_entries = false) override;

      virtual void
      import(
        const ReadWriteVector<Number> &                 V,
        VectorOperation::values                         operation,
        std::shared_ptr<const CommunicationPatternBase> communication_pattern =
          std::shared_ptr<const CommunicationPatternBase>()) override;

      virtual Vector<Number> &
      operator=(const Number s) override;

      virtual Vector<Number> &
      operator*=(const Number factor) override;

      virtual Vector<Number> &
      operator/=(const Number factor) override;

      virtual Vector<Number> &
      operator+=(const VectorSpaceVector<Number> &V) override;

      virtual Vector<Number> &
      operator-=(const VectorSpaceVector<Number> &V) override;

      virtual Number
      operator*(const VectorSpaceVector<Number> &V) const override;

      virtual void
      add(const Number a) override;

      virtual void
      add(const Number a, const VectorSpaceVector<Number> &V) override;

      virtual void
      add(const Number                     a,
          const VectorSpaceVector<Number> &V,
          const Number                     b,
          const VectorSpaceVector<Number> &W) override;

      virtual void
      sadd(const Number                     s,
           const Number                     a,
           const VectorSpaceVector<Number> &V) override;

      virtual void
      scale(const VectorSpaceVector<Number> &scaling_factors) override;

      virtual void
      equ(const Number a, const VectorSpaceVector<Number> &V) override;

      virtual bool
      all_zero() const override;

      virtual value_type
      mean_value() const override;

      virtual real_type
      l1_norm() const override;

      virtual real_type
      l2_norm() const override;

      real_type
      norm_sqr() const;

      virtual real_type
      linfty_norm() const override;

      virtual Number
      add_and_dot(const Number                     a,
                  const VectorSpaceVector<Number> &V,
                  const VectorSpaceVector<Number> &W) override;

      Number *
      get_values() const;

      virtual size_type
      size() const override;

      virtual ::IndexSet
      locally_owned_elements() const override;

      virtual void
      print(std::ostream &     out,
            const unsigned int precision  = 2,
            const bool         scientific = true,
            const bool         across     = true) const override;

      virtual std::size_t
      memory_consumption() const override;

      DeclException0(ExcVectorTypeNotCompatible);

    private:
      std::unique_ptr<Number[], void (*)(Number *)> val;

      size_type n_elements;
    };
  } // namespace CUDAWrappers
} // namespace LinearAlgebra

// ---------------------------- Inline functions --------------------------

template <typename Number>
inline void
swap(LinearAlgebra::CUDAWrappers::Vector<Number> &u,
     LinearAlgebra::CUDAWrappers::Vector<Number> &v)
{
  u.swap(v);
}

namespace LinearAlgebra
{
  namespace CUDAWrappers
  {
    template <typename Number>
    inline Number *
    Vector<Number>::get_values() const
    {
      return val.get();
    }



    template <typename Number>
    inline typename Vector<Number>::size_type
    Vector<Number>::size() const
    {
      return n_elements;
    }


    template <typename Number>
    inline IndexSet
    Vector<Number>::locally_owned_elements() const
    {
      return complete_index_set(n_elements);
    }



    template <typename Number>
    inline void
    Vector<Number>::swap(Vector<Number> &v)
    {
      std::swap(val, v.val);
      std::swap(n_elements, v.n_elements);
    }
  } // namespace CUDAWrappers
} // namespace LinearAlgebra

DEAL_II_NAMESPACE_CLOSE

#endif

#endif