cuda_vector.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2016 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.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/communication_pattern_base.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/index_set.h>
 
#include <deal.II/lac/vector_operation.h>
 
#ifdef DEAL_II_WITH_CUDA
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#  ifndef DOXYGEN
namespace LinearAlgebra
{
  template <typename Number>
  class ReadWriteVector;
}
#  endif
 
namespace LinearAlgebra
{
  namespace CUDAWrappers
  {
    template <typename Number>
    class Vector
    {
    public:
      using value_type = Number;
      using size_type  = types::global_dof_index;
      using real_type  = typename numbers::NumberTraits<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;
 
      void
      swap(Vector<Number> &v);
 
      void
      reinit(const size_type n, const bool omit_zeroing_entries = false);
 
      void
      reinit(const Vector<Number> &V, const bool omit_zeroing_entries = false);
 
      void
      import_elements(
        const ReadWriteVector<Number> &V,
        const VectorOperation::values  operation,
        const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
          &communication_pattern = {});
 
      DEAL_II_DEPRECATED void
      import(const ReadWriteVector<Number> &V,
             VectorOperation::values        operation,
             std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
               communication_pattern = {})
      {
        import_elements(V, operation, communication_pattern);
      }
 
      Vector<Number> &
      operator=(const Number s);
 
      Vector<Number> &
      operator*=(const Number factor);
 
      Vector<Number> &
      operator/=(const Number factor);
 
      Vector<Number> &
      operator+=(const Vector<Number> &V);
 
      Vector<Number> &
      operator-=(const Vector<Number> &V);
 
      Number
      operator*(const Vector<Number> &V) const;
 
      void
      add(const Number a);
 
      void
      add(const Number a, const Vector<Number> &V);
 
      void
      add(const Number          a,
          const Vector<Number> &V,
          const Number          b,
          const Vector<Number> &W);
 
      void
      sadd(const Number s, const Number a, const Vector<Number> &V);
 
      void
      scale(const Vector<Number> &scaling_factors);
 
      void
      equ(const Number a, const Vector<Number> &V);
 
      bool
      all_zero() const;
 
      value_type
      mean_value() const;
 
      real_type
      l1_norm() const;
 
      real_type
      l2_norm() const;
 
      real_type
      norm_sqr() const;
 
      real_type
      linfty_norm() const;
 
      Number
      add_and_dot(const Number          a,
                  const Vector<Number> &V,
                  const Vector<Number> &W);
 
      Number *
      get_values() const;
 
      size_type
      size() const;
 
      ::IndexSet
      locally_owned_elements() const;
 
      void
      print(std::ostream      &out,
            const unsigned int precision  = 2,
            const bool         scientific = true,
            const bool         across     = true) const;
 
      std::size_t
      memory_consumption() const;
 
      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