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

#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_space_vector.h>
#include <deal.II/lac/vector_operation.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:
      typedef typename VectorSpaceVector<Number>::value_type value_type;
      typedef typename VectorSpaceVector<Number>::size_type  size_type;
      typedef typename VectorSpaceVector<Number>::real_type  real_type;

      Vector();

      Vector(const Vector<Number> &V);

      explicit Vector(const size_type n);

      ~Vector();

      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;

      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:
      Number *val;

      size_type n_elements;
    };



    // ------------------------------ Inline functions -----------------------------
    template <typename Number>
    inline
    Number *Vector<Number>::get_values() const
    {
      return val;
    }



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

DEAL_II_NAMESPACE_CLOSE

#endif

#endif