DPC++ Runtime
Runtime libraries for oneAPI DPC++
Namespaces | Macros | Functions
builtins.hpp File Reference
#include <sycl/detail/boolean.hpp>
#include <sycl/detail/builtins.hpp>
#include <sycl/detail/common.hpp>
#include <sycl/detail/generic_type_traits.hpp>
#include <sycl/types.hpp>
Include dependency graph for builtins.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

 sycl
 ---— Error handling, matching OpenCL plugin semantics.
 
 sycl::_V1
 
 sycl::_V1::detail
 

Macros

#define __NOEXC   /*noexcept*/
 
#define __FAST_MATH_GENFLOAT(T)   (detail::is_svgenfloat<T>::value)
 
#define __FAST_MATH_SGENFLOAT(T)   (detail::is_sgenfloat<T>::value)
 
#define __SYCL_MATH_FUNCTION_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_OVERLOAD(NAME)
 
#define __SYCL_MATH_FUNCTION_OVERLOAD_FM(NAME)
 
#define __SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_2_OVERLOAD(NAME)
 
#define __SYCL_MATH_FUNCTION_2_SGENFLOAT_Y_OVERLOAD(NAME)
 
#define __SYCL_MATH_FUNCTION_2_GENINT_Y_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_2_INT_Y_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_3_OVERLOAD(NAME)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, ...)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_UNOP_OVERLOAD(NAME, ARG, ...)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD(NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_RELATIONAL_FUNCTION_BINOP_OVERLOAD(NAME)
 
#define __SYCL_MARRAY_RELATIONAL_FUNCTION_UNOP_OVERLOAD(NAME)
 
#define __SYCL_NATIVE_MATH_FUNCTION_OVERLOAD(NAME)
 
#define __SYCL_NATIVE_MATH_FUNCTION_2_OVERLOAD(NAME)
 
#define __SYCL_HALF_PRECISION_MATH_FUNCTION_OVERLOAD(NAME)
 
#define __SYCL_HALF_PRECISION_MATH_FUNCTION_2_OVERLOAD(NAME)
 

Functions

template<class T , size_t N>
vec< T, 2 > sycl::_V1::detail::to_vec2 (marray< T, N > x, size_t start)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat< T >::value, marray< int, N > > sycl::_V1::ilogb (marray< T, N > x) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< __FAST_MATH_SGENFLOAT(T), marray< T, N > > sycl::_V1::powr (marray< T, N > x, marray< T, N > y) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat< T >::value, marray< T, N > > sycl::_V1::ldexp (marray< T, N > x, marray< int, N > k) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat< T >::value, marray< T, N > > sycl::_V1::ldexp (marray< T, N > x, int k) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat< T >::value, marray< T, N > > sycl::_V1::pown (marray< T, N > x, marray< int, N > y) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat< T >::value, marray< T, N > > sycl::_V1::rootn (marray< T, N > x, marray< int, N > y) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat< T >::value, marray< T, N > > sycl::_V1::pown (marray< T, N > x, int y) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat< T >::value, marray< T, N > > sycl::_V1::rootn (marray< T, N > x, int y) __NOEXC
 

Macro Definition Documentation

◆ __FAST_MATH_GENFLOAT

#define __FAST_MATH_GENFLOAT (   T)    (detail::is_svgenfloat<T>::value)

Definition at line 42 of file builtins.hpp.

◆ __FAST_MATH_SGENFLOAT

#define __FAST_MATH_SGENFLOAT (   T)    (detail::is_sgenfloat<T>::value)

Definition at line 43 of file builtins.hpp.

◆ __NOEXC

#define __NOEXC   /*noexcept*/

Definition at line 18 of file builtins.hpp.

◆ __SYCL_HALF_PRECISION_MATH_FUNCTION_2_OVERLOAD

#define __SYCL_HALF_PRECISION_MATH_FUNCTION_2_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME( \
marray<float, N> x, marray<float, N> y) __NOEXC { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_half_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2), detail::to_vec2(y, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = \
__sycl_std::__invoke_half_##NAME<float>(x[N - 1], y[N - 1]); \
} \
return res; \
}

◆ __SYCL_HALF_PRECISION_MATH_FUNCTION_OVERLOAD

#define __SYCL_HALF_PRECISION_MATH_FUNCTION_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME(marray<float, N> x) \
__NOEXC { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_half_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_half_##NAME<float>(x[N - 1]); \
} \
return res; \
}

◆ __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD

#define __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat<T>::value>> \
T NAME(ARG1, ARG2) __NOEXC { \
__SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL

#define __SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL (   NAME,
  ... 
)
Value:
T res; \
for (int i = 0; i < T::size(); i++) { \
res[i] = NAME(__VA_ARGS__); \
} \
return res;

◆ __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD

#define __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat<T>::value>> \
T NAME(ARG1, ARG2, ARG3) __NOEXC { \
__SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_COMMON_FUNCTION_UNOP_OVERLOAD

#define __SYCL_MARRAY_COMMON_FUNCTION_UNOP_OVERLOAD (   NAME,
  ARG,
  ... 
)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat<T>::value>> \
T NAME(ARG) __NOEXC { \
__SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_RELATIONAL_FUNCTION_BINOP_OVERLOAD

#define __SYCL_MARRAY_RELATIONAL_FUNCTION_BINOP_OVERLOAD (   NAME)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat<T>::value>> \
sycl::marray<bool, T::size()> NAME(T x, T y) __NOEXC { \
sycl::marray<bool, T::size()> res; \
for (int i = 0; i < x.size(); i++) { \
res[i] = NAME(x[i], y[i]); \
} \
return res; \
}

◆ __SYCL_MARRAY_RELATIONAL_FUNCTION_UNOP_OVERLOAD

#define __SYCL_MARRAY_RELATIONAL_FUNCTION_UNOP_OVERLOAD (   NAME)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat<T>::value>> \
sycl::marray<bool, T::size()> NAME(T x) __NOEXC { \
sycl::marray<bool, T::size()> res; \
for (int i = 0; i < x.size(); i++) { \
res[i] = NAME(x[i]); \
} \
return res; \
}

◆ __SYCL_MATH_FUNCTION_2_GENINT_Y_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_2_GENINT_Y_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N; i++) { \
res[i] = __sycl_std::__invoke_##NAME<T>(x[i], y[i]); \
} \
return res;

Definition at line 237 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_2_INT_Y_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_2_INT_Y_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N; i++) { \
res[i] = __sycl_std::__invoke_##NAME<T>(x[i], y); \
} \
return res;

Definition at line 260 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_2_OVERLOAD

#define __SYCL_MATH_FUNCTION_2_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat<T>::value, marray<T, N>> \
NAME(marray<T, N> x, marray<T, N> y) __NOEXC { \
__SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL(NAME) \
}

Definition at line 158 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_##NAME<vec<T, 2>>( \
detail::to_vec2(x, i * 2), detail::to_vec2(y, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_##NAME<T>(x[N - 1], y[N - 1]); \
} \
return res;

Definition at line 146 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_2_SGENFLOAT_Y_OVERLOAD

#define __SYCL_MATH_FUNCTION_2_SGENFLOAT_Y_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat<T>::value, marray<T, N>> \
NAME(marray<T, N> x, T y) __NOEXC { \
marray<T, N> res; \
sycl::vec<T, 2> y_vec{y, y}; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_##NAME<vec<T, 2>>( \
detail::to_vec2(x, i * 2), y_vec); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_##NAME<T>(x[N - 1], y_vec[0]); \
} \
return res; \
}

Definition at line 190 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_3_OVERLOAD

#define __SYCL_MATH_FUNCTION_3_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat<T>::value, marray<T, N>> \
NAME(marray<T, N> x, marray<T, N> y, marray<T, N> z) __NOEXC { \
marray<T, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_##NAME<vec<T, 2>>( \
detail::to_vec2(x, i * 2), detail::to_vec2(y, i * 2), \
detail::to_vec2(z, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = \
__sycl_std::__invoke_##NAME<T>(x[N - 1], y[N - 1], z[N - 1]); \
} \
return res; \
}

Definition at line 282 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_OVERLOAD

#define __SYCL_MATH_FUNCTION_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat<T>::value, marray<T, N>> \
NAME(marray<T, N> x) __NOEXC { \
__SYCL_MATH_FUNCTION_OVERLOAD_IMPL(NAME) \
}

Definition at line 65 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_OVERLOAD_FM

#define __SYCL_MATH_FUNCTION_OVERLOAD_FM (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<__FAST_MATH_SGENFLOAT(T), marray<T, N>> \
NAME(marray<T, N> x) __NOEXC { \
__SYCL_MATH_FUNCTION_OVERLOAD_IMPL(NAME) \
}

Definition at line 106 of file builtins.hpp.

◆ __SYCL_MATH_FUNCTION_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
vec<T, 2> partial_res = \
__sycl_std::__invoke_##NAME<vec<T, 2>>(detail::to_vec2(x, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_##NAME<T>(x[N - 1]); \
} \
return res;

Definition at line 53 of file builtins.hpp.

◆ __SYCL_NATIVE_MATH_FUNCTION_2_OVERLOAD

#define __SYCL_NATIVE_MATH_FUNCTION_2_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME( \
marray<float, N> x, marray<float, N> y) __NOEXC { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_native_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2), detail::to_vec2(y, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = \
__sycl_std::__invoke_native_##NAME<float>(x[N - 1], y[N - 1]); \
} \
return res; \
}

◆ __SYCL_NATIVE_MATH_FUNCTION_OVERLOAD

#define __SYCL_NATIVE_MATH_FUNCTION_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME(marray<float, N> x) \
__NOEXC { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_native_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_native_##NAME<float>(x[N - 1]); \
} \
return res; \
}
__NOEXC
#define __NOEXC
Definition: builtins.hpp:18
__SYCL_ALWAYS_INLINE
#define __SYCL_ALWAYS_INLINE
Definition: defines_elementary.hpp:25
sycl::_V1::detail::memcpy
void memcpy(void *Dst, const void *Src, size_t Size)
Definition: memcpy.hpp:16
sycl::_V1::detail::enable_if_t
typename std::enable_if< B, T >::type enable_if_t
Definition: stl_type_traits.hpp:24
sycl::_V1::ext::intel::experimental::esimd::bfn_t::x
@ x
sycl::_V1::detail::to_vec2
vec< T, 2 > to_vec2(marray< T, N > x, size_t start)
Definition: builtins.hpp:25
sycl::_V1::ext::intel::experimental::esimd::bfn_t::y
@ y
__FAST_MATH_SGENFLOAT
#define __FAST_MATH_SGENFLOAT(T)
Definition: builtins.hpp:43