types.hpp

Go to the documentation of this file.

 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// Copyright (c) Lawrence Livermore National Security, LLC and other
// RAJA Project Developers. See top-level LICENSE and COPYRIGHT
// files for dates and other details. No copyright assignment is required
// to contribute to RAJA.
//
// SPDX-License-Identifier: (BSD-3-Clause)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
 
#ifndef RAJA_Types_HPP
#define RAJA_Types_HPP
 
#include "RAJA/config.hpp"
 
#include <cstddef>
 
#if defined(RAJA_USE_COMPLEX)
#include <complex>
#endif
 
#include "camp/helpers.hpp"
 
#include "RAJA/util/macros.hpp"
 
namespace RAJA
{
 
enum named_usage : int
{
  ignored     = -1,
  unspecified = 0
};
 
enum struct named_dim : int
{
  x = 0,
  y = 1,
  z = 2
};
 
enum struct kernel_sync_requirement : int
{
  none = 0,
  sync = 1
};
 
namespace iteration_mapping
{
 
struct DirectUncheckedBase
{};
 
struct DirectBase
{};
 
struct LoopBase
{};
 
struct ContiguousLoopBase : LoopBase
{};
 
struct StridedLoopBase : LoopBase
{};
 
struct UnsizedLoopBase
{};
 
struct SizedLoopBase
{};
 
template<size_t t_max_iterations>
struct SizedLoopSpecifyingBase : SizedLoopBase
{
  static constexpr size_t max_iterations = t_max_iterations;
};
 
struct DirectUnchecked : DirectUncheckedBase
{};
 
struct Direct : DirectBase
{};
 
template<size_t max_iterations>
struct Contiguousloop
    : ContiguousLoopBase,
      std::conditional_t<(max_iterations != named_usage::unspecified),
                         SizedLoopSpecifyingBase<max_iterations>,
                         UnsizedLoopBase>
{};
 
template<size_t max_iterations>
struct StridedLoop
    : StridedLoopBase,
      std::conditional_t<(max_iterations != named_usage::unspecified),
                         SizedLoopSpecifyingBase<max_iterations>,
                         UnsizedLoopBase>
{};
 
}  // namespace iteration_mapping
 
enum IndexOwnership
{
  Unowned,
  Owned
};
 
using Index_type = std::ptrdiff_t;
 
const int UndefinedValue = -9999999;
 
template<Index_type... Sizes>
struct SizeList
{};
 
template<typename int_t, int_t numerator, int_t denominator>
struct Fraction
{
  static_assert(denominator != int_t(0), "denominator must not be zero");
 
  using inverse = Fraction<int_t, denominator, numerator>;
 
  template<typename new_int_t>
  using rebind =
      Fraction<new_int_t, new_int_t(numerator), new_int_t(denominator)>;
 
  static constexpr int_t multiply(int_t val) noexcept
  {
    return (val / denominator) * numerator +
           (val % denominator) * numerator / denominator;
  }
};
 
#if defined(RAJA_USE_DOUBLE)
using Real_type = double;
 
#elif defined(RAJA_USE_FLOAT)
using Real_type = float;
 
#else
#error RAJA Real_type is undefined!
 
#endif
 
#if defined(RAJA_USE_COMPLEX)
using Complex_type = std::complex<Real_type>;
#endif
 
/*
 ******************************************************************************
 *
 * The following items include some setup items for definitions that follow.
 *
 ******************************************************************************
 */
 
#if defined(RAJA_COMPILER_ICC)
//
// alignment attribute supported for versions > 12
//
#if __ICC >= 1300
using TDRAReal_ptr =
    Real_type* RAJA_RESTRICT __attribute__((align_value(RAJA::DATA_ALIGN)));
 
using const_TDRAReal_ptr = const TDRAReal_ptr;
#endif
 
#elif defined(RAJA_COMPILER_GNU)
 
#elif defined(RAJA_COMPILER_CLANG)
using TDRAReal_ptr =
    Real_type* RAJA_RESTRICT __attribute__((aligned(RAJA::DATA_ALIGN)));
 
using const_TDRAReal_ptr = const TDRAReal_ptr;
 
#else
 
using TDRAReal_ptr = Real_type* RAJA_RESTRICT;
 
using const_TDRAReal_ptr = const TDRAReal_ptr;
 
#endif
 
#if defined(RAJA_USE_PTR_CLASS)
class ConstRestrictRealPtr
{
public:
 
  constexpr ConstRestrictRealPtr() : dptr(0) { ; }
 
  constexpr ConstRestrictRealPtr(const Real_type* d) : dptr(d) { ; }
 
  constexpr ConstRestrictRealPtr& operator=(const Real_type* d)
  {
    ConstRestrictRealPtr copy(d);
    std::swap(dptr, copy.dptr);
    return *this;
  }
 
 
  constexpr operator const Real_type*() { return dptr; }
 
  constexpr const Real_type* get() const { return dptr; }
 
  constexpr const Real_type& operator[](Index_type i) const
  {
    return ((const Real_type* RAJA_RESTRICT)dptr)[i];
  }
 
  constexpr const Real_type* operator+(Index_type i) const { return dptr + i; }
 
private:
  const Real_type* dptr;
};
 
class RestrictRealPtr
{
public:
 
  constexpr RestrictRealPtr() : dptr(0) { ; }
 
  constexpr RestrictRealPtr(Real_type* d) : dptr(d) { ; }
 
  constexpr RestrictRealPtr& operator=(Real_type* d)
  {
    RestrictRealPtr copy(d);
    std::swap(dptr, copy.dptr);
    return *this;
  }
 
 
  constexpr operator Real_type*() { return dptr; }
 
  constexpr operator const Real_type*() const { return dptr; }
 
  constexpr Real_type* get() { return dptr; }
 
  constexpr const Real_type* get() const { return dptr; }
 
  constexpr operator ConstRestrictRealPtr()
  {
    return ConstRestrictRealPtr(dptr);
  }
 
  constexpr Real_type& operator[](Index_type i)
  {
    return ((Real_type * RAJA_RESTRICT) dptr)[i];
  }
 
  constexpr Real_type* operator+(Index_type i) { return dptr + i; }
 
  constexpr const Real_type* operator+(Index_type i) const { return dptr + i; }
 
private:
  Real_type* dptr;
};
 
class ConstRestrictAlignedRealPtr
{
public:
 
  constexpr ConstRestrictAlignedRealPtr() : dptr(0) { ; }
 
  constexpr ConstRestrictAlignedRealPtr(const Real_type* d) : dptr(d) { ; }
 
  constexpr ConstRestrictAlignedRealPtr& operator=(const Real_type* d)
  {
    ConstRestrictAlignedRealPtr copy(d);
    std::swap(dptr, copy.dptr);
    return *this;
  }
 
 
  constexpr operator const Real_type*() { return dptr; }
 
  constexpr const Real_type* get() const { return dptr; }
 
 
#if defined(RAJA_COMPILER_ICC)
  constexpr const Real_type& operator[](Index_type i) const
  {
#if __ICC < 1300  // use alignment intrinsic
    RAJA_ALIGN_DATA(dptr);
    return ((const Real_type* RAJA_RESTRICT)dptr)[i];
#else  // use alignment attribute
    return ((const_TDRAReal_ptr)dptr)[i];
#endif
  }
 
#elif defined(RAJA_COMPILER_GNU)
  constexpr const Real_type& operator[](Index_type i) const
  {
#if 1  // NOTE: alignment instrinsic not available for older GNU compilers
    return ((const Real_type* RAJA_RESTRICT)RAJA_ALIGN_DATA(dptr))[i];
#else
    return ((const Real_type* RAJA_RESTRICT)dptr)[i];
#endif
  }
 
#elif defined(RAJA_COMPILER_XLC)
  constexpr const Real_type& operator[](Index_type i) const
  {
    RAJA_ALIGN_DATA(dptr);
    return ((const Real_type* RAJA_RESTRICT)dptr)[i];
  }
 
#elif defined(RAJA_COMPILER_CLANG)
  constexpr const Real_type& operator[](Index_type i) const
  {
    return ((const_TDRAReal_ptr)dptr)[i];
  }
 
#else
#error RAJA compiler macro is undefined!
 
#endif
 
  constexpr const Real_type* operator+(Index_type i) const { return dptr + i; }
 
private:
  const Real_type* dptr;
};
 
class RestrictAlignedRealPtr
{
public:
 
  constexpr RestrictAlignedRealPtr() : dptr(0) { ; }
 
  constexpr RestrictAlignedRealPtr(Real_type* d) : dptr(d) { ; }
 
  constexpr RestrictAlignedRealPtr& operator=(Real_type* d)
  {
    RestrictAlignedRealPtr copy(d);
    std::swap(dptr, copy.dptr);
    return *this;
  }
 
 
  constexpr operator Real_type*() { return dptr; }
 
  constexpr operator const Real_type*() const { return dptr; }
 
  constexpr Real_type* get() { return dptr; }
 
  constexpr const Real_type* get() const { return dptr; }
 
  constexpr operator ConstRestrictAlignedRealPtr()
  {
    return ConstRestrictAlignedRealPtr(dptr);
  }
 
 
#if defined(RAJA_COMPILER_ICC)
  constexpr Real_type& operator[](Index_type i)
  {
#if __ICC < 1300  // use alignment intrinsic
    RAJA_ALIGN_DATA(dptr);
    return ((Real_type * RAJA_RESTRICT) dptr)[i];
#else  // use alignment attribute
    return ((TDRAReal_ptr)dptr)[i];
#endif
  }
 
  constexpr const Real_type& operator[](Index_type i) const
  {
#if __ICC < 1300  // use alignment intrinsic
    RAJA_ALIGN_DATA(dptr);
    return ((Real_type * RAJA_RESTRICT) dptr)[i];
#else  // use alignment attribute
    return ((TDRAReal_ptr)dptr)[i];
#endif
  }
 
#elif defined(RAJA_COMPILER_GNU)
  constexpr Real_type& operator[](Index_type i)
  {
#if 1  // NOTE: alignment instrinsic not available for older GNU compilers
    return ((Real_type * RAJA_RESTRICT) RAJA_ALIGN_DATA(dptr))[i];
#else
    return ((Real_type * RAJA_RESTRICT) dptr)[i];
#endif
  }
 
  constexpr const Real_type& operator[](Index_type i) const
  {
#if 1  // NOTE: alignment instrinsic not available for older GNU compilers
    return ((Real_type * RAJA_RESTRICT) RAJA_ALIGN_DATA(dptr))[i];
#else
    return ((Real_type * RAJA_RESTRICT) dptr)[i];
#endif
  }
 
#elif defined(RAJA_COMPILER_XLC)
  constexpr Real_type& operator[](Index_type i)
  {
    RAJA_ALIGN_DATA(dptr);
    return ((Real_type * RAJA_RESTRICT) dptr)[i];
  }
 
  constexpr const Real_type& operator[](Index_type i) const
  {
    RAJA_ALIGN_DATA(dptr);
    return ((Real_type * RAJA_RESTRICT) dptr)[i];
  }
 
#elif defined(RAJA_COMPILER_CLANG)
  constexpr Real_type& operator[](Index_type i)
  {
    return ((TDRAReal_ptr)dptr)[i];
  }
 
  const Real_type& operator[](Index_type i) const
  {
    return ((TDRAReal_ptr)dptr)[i];
  }
 
#else
#error RAJA compiler macro is undefined!
 
#endif
 
  constexpr Real_type* operator+(Index_type i) { return dptr + i; }
 
  constexpr const Real_type* operator+(Index_type i) const { return dptr + i; }
 
private:
  Real_type* dptr;
};
 
#if defined(RAJA_USE_COMPLEX)
class ConstRestrictComplexPtr
{
public:
 
  constexpr ConstRestrictComplexPtr() : dptr(0) { ; }
 
  constexpr ConstRestrictComplexPtr(const Complex_type* d) : dptr(d) { ; }
 
  constexpr ConstRestrictComplexPtr& operator=(const Complex_type* d)
  {
    ConstRestrictComplexPtr copy(d);
    std::swap(dptr, copy.dptr);
    return *this;
  }
 
 
  constexpr operator const Complex_type*() const { return dptr; }
 
  constexpr const Complex_type* get() const { return dptr; }
 
  constexpr const Complex_type& operator[](Index_type i) const
  {
    return ((const Complex_type* RAJA_RESTRICT)dptr)[i];
  }
 
  constexpr const Complex_type* operator+(Index_type i) const
  {
    return dptr + i;
  }
 
private:
  const Complex_type* dptr;
};
 
class RestrictComplexPtr
{
public:
 
  constexpr RestrictComplexPtr() : dptr(0) { ; }
 
  constexpr RestrictComplexPtr(Complex_type* d) : dptr(d) { ; }
 
  constexpr RestrictComplexPtr& operator=(Complex_type* d)
  {
    RestrictComplexPtr copy(d);
    std::swap(dptr, copy.dptr);
    return *this;
  }
 
 
  constexpr operator Complex_type*() { return dptr; }
 
  constexpr operator const Complex_type*() const { return dptr; }
 
  constexpr Complex_type* get() { return dptr; }
 
  constexpr const Complex_type* get() const { return dptr; }
 
  constexpr operator ConstRestrictComplexPtr()
  {
    return ConstRestrictComplexPtr(dptr);
  }
 
  constexpr Complex_type& operator[](Index_type i)
  {
    return ((Complex_type * RAJA_RESTRICT) dptr)[i];
  }
 
  constexpr const Complex_type& operator[](Index_type i) const
  {
    return ((Complex_type * RAJA_RESTRICT) dptr)[i];
  }
 
  constexpr Complex_type* operator+(Index_type i) { return dptr + i; }
 
  constexpr const Complex_type* operator+(Index_type i) const
  {
    return dptr + i;
  }
 
private:
  Complex_type* dptr;
};
#endif  // defined(RAJA_USE_COMPLEX)
 
#endif  // defined(RAJA_USE_PTR_CLASS)
 
/*
 ******************************************************************************
 *
 * Finally, we define data pointer types based on definitions above and
 * -D value given at compile time.
 *
 ******************************************************************************
 */
#if defined(RAJA_USE_BARE_PTR)
using Real_ptr       = Real_type*;
using const_Real_ptr = const Real_type*;
 
#if defined(RAJA_USE_COMPLEX)
using Complex_ptr       = Complex_type*;
using const_Complex_ptr = const Complex_type*;
#endif
 
using UnalignedReal_ptr       = Real_type*;
using const_UnalignedReal_ptr = const Real_type*;
 
#elif defined(RAJA_USE_RESTRICT_PTR)
using Real_ptr       = Real_type* RAJA_RESTRICT;
using const_Real_ptr = const Real_type* RAJA_RESTRICT;
 
#if defined(RAJA_USE_COMPLEX)
using Complex_ptr       = Complex_type* RAJA_RESTRICT;
using const_Complex_ptr = const Complex_type* RAJA_RESTRICT;
#endif
 
using UnalignedReal_ptr       = Real_type* RAJA_RESTRICT;
using const_UnalignedReal_ptr = const Real_type* RAJA_RESTRICT;
 
#elif defined(RAJA_USE_RESTRICT_ALIGNED_PTR)
using Real_ptr       = TDRAReal_ptr;
using const_Real_ptr = const_TDRAReal_ptr;
 
#if defined(RAJA_USE_COMPLEX)
using Complex_ptr       = Complex_type* RAJA_RESTRICT;
using const_Complex_ptr = const Complex_type* RAJA_RESTRICT;
#endif
 
using UnalignedReal_ptr       = Real_type* RAJA_RESTRICT;
using const_UnalignedReal_ptr = const Real_type* RAJA_RESTRICT;
 
#elif defined(RAJA_USE_PTR_CLASS)
using Real_ptr       = RestrictAlignedRealPtr;
using const_Real_ptr = ConstRestrictAlignedRealPtr;
 
#if defined(RAJA_USE_COMPLEX)
using Complex_ptr       = RestrictComplexPtr;
using const_Complex_ptr = ConstRestrictComplexPtr;
#endif
 
using UnalignedReal_ptr       = RestrictRealPtr;
using const_UnalignedReal_ptr = ConstRestrictRealPtr;
 
#else
#error RAJA pointer type is undefined!
 
#endif
 
 
namespace detail
{
 
struct DefaultAccessor
{
  template<typename T>
  static RAJA_HOST_DEVICE RAJA_INLINE constexpr T get(T* ptr, size_t i)
  {
    return ptr[i];
  }
 
  template<typename T>
  static RAJA_HOST_DEVICE RAJA_INLINE constexpr void set(T* ptr,
                                                         size_t i,
                                                         T val)
  {
    ptr[i] = val;
  }
};
 
template<typename T,
         size_t min_integer_type_size = 1,
         size_t max_integer_type_size = sizeof(unsigned long long)>
struct AsIntegerArray
{
  static_assert(min_integer_type_size <= max_integer_type_size,
                "incompatible min and max integer type size");
  using integer_type = std::conditional_t<
      ((alignof(T) >= alignof(unsigned long long) &&
        sizeof(unsigned long long) <= max_integer_type_size) ||
       sizeof(unsigned long) < min_integer_type_size),
      unsigned long long,
      std::conditional_t<
          ((alignof(T) >= alignof(unsigned long) &&
            sizeof(unsigned long) <= max_integer_type_size) ||
           sizeof(unsigned int) < min_integer_type_size),
          unsigned long,
          std::conditional_t<
              ((alignof(T) >= alignof(unsigned int) &&
                sizeof(unsigned int) <= max_integer_type_size) ||
               sizeof(unsigned short) < min_integer_type_size),
              unsigned int,
              std::conditional_t<
                  ((alignof(T) >= alignof(unsigned short) &&
                    sizeof(unsigned short) <= max_integer_type_size) ||
                   sizeof(unsigned char) < min_integer_type_size),
                  unsigned short,
                  std::conditional_t<((alignof(T) >= alignof(unsigned char) &&
                                       sizeof(unsigned char) <=
                                           max_integer_type_size)),
                                     unsigned char,
                                     void>>>>>;
  static_assert(!std::is_same<integer_type, void>::value,
                "could not find a compatible integer type");
  static_assert(sizeof(integer_type) >= min_integer_type_size,
                "integer_type smaller than min integer type size");
  static_assert(sizeof(integer_type) <= max_integer_type_size,
                "integer_type greater than max integer type size");
 
  static constexpr size_t num_integer_type =
      (sizeof(T) + sizeof(integer_type) - 1) / sizeof(integer_type);
 
  integer_type array[num_integer_type] = {0};
 
  AsIntegerArray() = default;
 
  RAJA_HOST_DEVICE constexpr size_t array_size() const
  {
    return num_integer_type;
  }
 
  RAJA_HOST_DEVICE T get_value() const
  {
    T value;
    memcpy(&value, &array[0], sizeof(T));
    return value;
  }
 
  RAJA_HOST_DEVICE void set_value(T value)
  {
    memcpy(&array[0], &value, sizeof(T));
  }
};
 
template<typename T>
struct ScopedAssignment
{
  constexpr ScopedAssignment(T& val, T const& new_val)
      : m_ref_to_val(val),
        m_prev_val(std::move(val))
  {
    m_ref_to_val = new_val;
  }
 
  constexpr ScopedAssignment(T& val, T&& new_val)
      : m_ref_to_val(val),
        m_prev_val(std::move(val))
  {
    m_ref_to_val = std::move(new_val);
  }
 
  ScopedAssignment(ScopedAssignment const&)            = delete;
  ScopedAssignment(ScopedAssignment&&)                 = delete;
  ScopedAssignment& operator=(ScopedAssignment const&) = delete;
  ScopedAssignment& operator=(ScopedAssignment&&)      = delete;
 
  // constexpr in c++20
  ~ScopedAssignment() { m_ref_to_val = std::move(m_prev_val); }
 
private:
  T& m_ref_to_val;
  T m_prev_val;
};
 
}  // namespace detail
 
}  // namespace RAJA
 
#endif  // closing endif for header file include guard