DPC++ Runtime
Runtime libraries for oneAPI DPC++
Classes | Namespaces | Macros | Typedefs | Functions
vector.hpp File Reference
#include <sycl/access/access.hpp>
#include <sycl/aliases.hpp>
#include <sycl/detail/common.hpp>
#include <sycl/detail/defines_elementary.hpp>
#include <sycl/detail/generic_type_lists.hpp>
#include <sycl/detail/generic_type_traits.hpp>
#include <sycl/detail/memcpy.hpp>
#include <sycl/detail/type_list.hpp>
#include <sycl/detail/type_traits.hpp>
#include <sycl/detail/vector_convert.hpp>
#include <sycl/detail/vector_traits.hpp>
#include <sycl/half_type.hpp>
#include <sycl/ext/oneapi/bfloat16.hpp>
#include <array>
#include <assert.h>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <iterator>
#include <ostream>
#include <type_traits>
#include <utility>
#include "swizzles.def"
Include dependency graph for vector.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  sycl::_V1::elem
 
struct  sycl::_V1::detail::vec_helper< T >
 
struct  sycl::_V1::detail::vec_helper< bool >
 
struct  sycl::_V1::detail::vec_helper< sycl::ext::oneapi::bfloat16 >
 
struct  sycl::_V1::detail::vec_helper< std::byte >
 
class  sycl::_V1::detail::GetOp< T >
 
struct  sycl::_V1::detail::VecStorage< T, N, V >
 
struct  sycl::_V1::detail::VecStorageImpl< T, N >
 
struct  sycl::_V1::detail::VecStorage< bool, 1, void >
 
struct  sycl::_V1::detail::VecStorage< bool, N, typename std::enable_if_t< isValidVectorSize(N)> >
 
struct  sycl::_V1::detail::VecStorage< std::byte, 1, void >
 
struct  sycl::_V1::detail::VecStorage< T, 1, typename std::enable_if_t< is_sigeninteger_v< T > > >
 
struct  sycl::_V1::detail::VecStorage< T, 1, typename std::enable_if_t< is_sugeninteger_v< T > > >
 
struct  sycl::_V1::detail::VecStorage< T, 1, typename std::enable_if_t<!is_half_or_bf16_v< T > &&is_sgenfloat_v< T > > >
 
struct  sycl::_V1::detail::VecStorage< T, N, typename std::enable_if_t< isValidVectorSize(N) &&(is_sgeninteger_v< T >||(is_sgenfloat_v< T > &&!is_half_or_bf16_v< T >))> >
 
struct  sycl::_V1::detail::VecStorage< half, 1, void >
 
struct  sycl::_V1::detail::VecStorage< sycl::ext::oneapi::bfloat16, 1, void >
 
class  sycl::_V1::vec< Type, NumElements >
 class sycl::vec ///////////////////////// Provides a cross-patform vector class template that works efficiently on SYCL devices as well as in host C++ code. More...
 
class  sycl::_V1::detail::GetScalarOp< T >
 
struct  sycl::_V1::detail::EqualTo< T >
 
struct  sycl::_V1::detail::NotEqualTo< T >
 
struct  sycl::_V1::detail::GreaterEqualTo< T >
 
struct  sycl::_V1::detail::LessEqualTo< T >
 
struct  sycl::_V1::detail::GreaterThan< T >
 
struct  sycl::_V1::detail::LessThan< T >
 
struct  sycl::_V1::detail::LogicalAnd< T >
 
struct  sycl::_V1::detail::LogicalOr< T >
 
struct  sycl::_V1::detail::RShift< T >
 
struct  sycl::_V1::detail::LShift< T >
 
class  sycl::_V1::detail::SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes >
 

Namespaces

 sycl
 
 sycl::_V1
 
 sycl::_V1::detail
 

Macros

#define __SYCL_DEFINE_HALF_VECSTORAGE(Num)
 
#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)
 
#define __SYCL_ALLOW_VECTOR_SIZES(num_elements)
 
#define __SYCL_ALLOW_VECTOR_TYPES(num_elements)
 
#define __SYCL_NOINLINE_BF16   __attribute__((noinline))
 
#define __SYCL_ACCESS_RETURN   this
 
#define __SYCL_BINOP(BINOP, OPASSIGN, CONVERT)
 
#define __SYCL_RELLOGOP(RELLOGOP)
 
#define __SYCL_UOP(UOP, OPASSIGN)
 
#define __SYCL_OPASSIGN(OPASSIGN, OP)
 
#define __SYCL_UOP(UOP, OPASSIGN)
 
#define __SYCL_BINOP(BINOP)
 
#define __SYCL_RELLOGOP(RELLOGOP)
 
#define __SYCL_ACCESS_RETURN   m_Vector
 

Typedefs

template<typename _IN , typename T8 , typename T16 , typename T32 , typename T64 >
using sycl::_V1::detail::select_apply_cl_t = std::conditional_t< sizeof(_IN)==1, T8, std::conditional_t< sizeof(_IN)==2, T16, std::conditional_t< sizeof(_IN)==4, T32, T64 > >>
 
template<typename DataT >
using sycl::_V1::detail::rel_t = typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_char), opencl::cl_char, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_short), opencl::cl_short, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_int), opencl::cl_int, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_long), opencl::cl_long, bool > >> >
 
template<typename T >
using sycl::_V1::vec_data = detail::vec_helper< T >
 
template<typename T >
using sycl::_V1::vec_data_t = typename detail::vec_helper< T >::RetType
 

Functions

constexpr bool sycl::_V1::detail::isValidVectorSize (int N)
 

Macro Definition Documentation

◆ __SYCL_ACCESS_RETURN [1/2]

#define __SYCL_ACCESS_RETURN   this

Definition at line 2084 of file vector.hpp.

◆ __SYCL_ACCESS_RETURN [2/2]

#define __SYCL_ACCESS_RETURN   m_Vector

Definition at line 2084 of file vector.hpp.

◆ __SYCL_ALLOW_VECTOR_SIZES

#define __SYCL_ALLOW_VECTOR_SIZES (   num_elements)
Value:
template <int Counter, int MaxValue, typename DataT_, class... tail> \
struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...> \
: std::conditional_t< \
Counter + (num_elements) <= MaxValue, \
SizeChecker<Counter + (num_elements), MaxValue, tail...>, \
std::false_type> {}; \
template <int Counter, int MaxValue, typename DataT_, typename T2, \
typename T3, template <typename> class T4, int... T5, \
class... tail> \
struct SizeChecker< \
Counter, MaxValue, \
detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, \
tail...> \
: std::conditional_t< \
Counter + sizeof...(T5) <= MaxValue, \
SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>, \
std::false_type> {}; \
template <int Counter, int MaxValue, typename DataT_, typename T2, \
typename T3, template <typename> class T4, int... T5, \
class... tail> \
struct SizeChecker< \
Counter, MaxValue, \
detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>, \
tail...> \
: std::conditional_t< \
Counter + sizeof...(T5) <= MaxValue, \
SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>, \
std::false_type> {};

◆ __SYCL_ALLOW_VECTOR_TYPES

#define __SYCL_ALLOW_VECTOR_TYPES (   num_elements)
Value:
template <typename DataT_> \
struct TypeChecker<vec<DataT_, num_elements>, DataT_> : std::true_type {}; \
template <typename DataT_, typename T2, typename T3, \
template <typename> class T4, int... T5> \
struct TypeChecker< \
detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>, DataT_> \
: std::true_type {}; \
template <typename DataT_, typename T2, typename T3, \
template <typename> class T4, int... T5> \
struct TypeChecker< \
detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>, \
DataT_> : std::true_type {};

◆ __SYCL_BINOP [1/2]

#define __SYCL_BINOP (   BINOP)
Value:
friend vec_t operator BINOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
vec_t Tmp = Rhs; \
return Lhs BINOP Tmp; \
} \
friend vec_t operator BINOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
vec_t Tmp = Lhs; \
return Tmp BINOP Rhs; \
} \
friend vec_t operator BINOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
vec_t Tmp = Rhs; \
return Lhs BINOP Tmp; \
} \
friend vec_t operator BINOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
vec_t Tmp = Lhs; \
return Tmp BINOP Rhs; \
}

Definition at line 1693 of file vector.hpp.

◆ __SYCL_BINOP [2/2]

#define __SYCL_BINOP (   BINOP,
  OPASSIGN,
  CONVERT 
)
Value:
friend vec operator BINOP(const vec &Lhs, const vec &Rhs) { \
vec Ret{}; \
if constexpr (NativeVec) \
Ret.m_Data = Lhs.m_Data BINOP Rhs.m_Data; \
else \
for (size_t I = 0; I < NumElements; ++I) \
Ret.setValue(I, (DataT)(vec_data<DataT>::get(Lhs.getValue( \
I)) BINOP vec_data<DataT>::get(Rhs.getValue(I)))); \
return Ret; \
} \
friend vec operator BINOP(const vec &Lhs, const DataT &Rhs) { \
return Lhs BINOP vec(Rhs); \
} \
friend vec operator BINOP(const DataT &Lhs, const vec &Rhs) { \
return vec(Lhs) BINOP Rhs; \
} \
friend vec &operator OPASSIGN(vec & Lhs, const vec & Rhs) { \
Lhs = Lhs BINOP Rhs; \
return Lhs; \
} \
template <int Num = NumElements> \
friend typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN( \
vec & Lhs, const DataT & Rhs) { \
Lhs = Lhs BINOP vec(Rhs); \
return Lhs; \
}
std::get
constexpr tuple_element< I, tuple< Types... > >::type & get(sycl::detail::tuple< Types... > &Arg) noexcept
Definition: tuple.hpp:198

Definition at line 1693 of file vector.hpp.

◆ __SYCL_DEFINE_BF16_VECSTORAGE

#define __SYCL_DEFINE_BF16_VECSTORAGE (   Num)
Value:
template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> { \
using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT; \
using VectorDataType = \
sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT; \
};
sycl::_V1::detail::half_impl::StorageT
detail::host_half_impl::half StorageT
Definition: half_type.hpp:258
sycl
Definition: access.hpp:18

Definition at line 337 of file vector.hpp.

◆ __SYCL_DEFINE_HALF_VECSTORAGE

#define __SYCL_DEFINE_HALF_VECSTORAGE (   Num)
Value:
template <> struct VecStorage<half, Num, void> { \
using DataType = sycl::detail::half_impl::Vec##Num##StorageT; \
};
sycl::_V1::half
sycl::detail::half_impl::half half
Definition: aliases.hpp:101

Definition at line 317 of file vector.hpp.

◆ __SYCL_NOINLINE_BF16

#define __SYCL_NOINLINE_BF16   __attribute__((noinline))

◆ __SYCL_OPASSIGN

#define __SYCL_OPASSIGN (   OPASSIGN,
  OP 
)
Value:
SwizzleOp &operator OPASSIGN(const DataT & Rhs) { \
operatorHelper<OP>(vec_t(Rhs)); \
return *this; \
} \
template <typename RhsOperation> \
SwizzleOp &operator OPASSIGN(const RhsOperation & Rhs) { \
operatorHelper<OP>(Rhs); \
return *this; \
}

Definition at line 1623 of file vector.hpp.

◆ __SYCL_RELLOGOP [1/2]

#define __SYCL_RELLOGOP (   RELLOGOP)
Value:
friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs, \
const vec & Rhs) { \
vec<rel_t, NumElements> Ret{}; \
for (size_t I = 0; I < NumElements; ++I) { \
/* We cannot use SetValue here as the operator is not a friend of*/ \
/* Ret on Windows. */ \
Ret[I] = static_cast<rel_t>(-(vec_data<DataT>::get( \
Lhs.getValue(I)) RELLOGOP vec_data<DataT>::get(Rhs.getValue(I)))); \
} \
return Ret; \
} \
friend vec<rel_t, NumElements> operator RELLOGOP(const vec & Lhs, \
const DataT & Rhs) { \
return Lhs RELLOGOP vec(Rhs); \
} \
friend vec<rel_t, NumElements> operator RELLOGOP(const DataT & Lhs, \
const vec & Rhs) { \
return vec(Lhs) RELLOGOP Rhs; \
}
sycl::_V1::detail::rel_t
typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_char), opencl::cl_char, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_short), opencl::cl_short, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_int), opencl::cl_int, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_long), opencl::cl_long, bool > >> > rel_t
Definition: vector.hpp:174

Definition at line 1729 of file vector.hpp.

◆ __SYCL_RELLOGOP [2/2]

#define __SYCL_RELLOGOP (   RELLOGOP)
Value:
friend vec_rel_t operator RELLOGOP(const DataT &Lhs, const SwizzleOp &Rhs) { \
vec_t Tmp = Rhs; \
return Lhs RELLOGOP Tmp; \
} \
friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const DataT &Rhs) { \
vec_t Tmp = Lhs; \
return Tmp RELLOGOP Rhs; \
} \
friend vec_rel_t operator RELLOGOP(const vec_t &Lhs, const SwizzleOp &Rhs) { \
vec_t Tmp = Rhs; \
return Lhs RELLOGOP Tmp; \
} \
friend vec_rel_t operator RELLOGOP(const SwizzleOp &Lhs, const vec_t &Rhs) { \
vec_t Tmp = Lhs; \
return Tmp RELLOGOP Rhs; \
}

Definition at line 1729 of file vector.hpp.

◆ __SYCL_UOP [1/2]

#define __SYCL_UOP (   UOP,
  OPASSIGN 
)
Value:
friend vec &operator UOP(vec & Rhs) { \
Rhs OPASSIGN vec_data<DataT>::get(1); \
return Rhs; \
} \
friend vec operator UOP(vec &Lhs, int) { \
vec Ret(Lhs); \
Lhs OPASSIGN vec_data<DataT>::get(1); \
return Ret; \
}

Definition at line 1649 of file vector.hpp.

◆ __SYCL_UOP [2/2]

#define __SYCL_UOP (   UOP,
  OPASSIGN 
)
Value:
SwizzleOp &operator UOP() { \
*this OPASSIGN static_cast<DataT>(1); \
return *this; \
} \
vec_t operator UOP(int) { \
vec_t Ret = *this; \
*this OPASSIGN static_cast<DataT>(1); \
return Ret; \
}

Definition at line 1649 of file vector.hpp.