Skip to content

Commit

Permalink
[SYCL] Make SYCL geometrical functions overloads instead of templates (…
Browse files Browse the repository at this point in the history 
…#10014)

It was decided to change all built-in functions from templates to
overloads. This patch changes non-marray part of "4.17.8. Geometric
functions".

Marray part: #10048

Spec: KhronosGroup/SYCL-Docs#428

---------

Co-authored-by: Steffen Larsen <steffen.larsen@intel.com>
  • Loading branch information
@KornevNikita @steffenlarsen
KornevNikita and steffenlarsen authored Jun 25, 2023
1 parent e860b14 commit 49bbcbf
Showing 1 changed file with 102 additions and 119 deletions.
221 changes: 102 additions & 119 deletions sycl/include/sycl/builtins.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -60,6 +60,10 @@ namespace __sycl_std = __host_std;
__SYCL_BUILTIN_DEF(TYPE##3) \
__SYCL_BUILTIN_DEF(TYPE##4)

#define __SYCL_DEF_BUILTIN_GEOCROSSVEC(TYPE) \
__SYCL_BUILTIN_DEF(TYPE##3) \
__SYCL_BUILTIN_DEF(TYPE##4)

#define __SYCL_DEF_BUILTIN_MARRAY(TYPE)

#define __SYCL_DEF_BUILTIN_CHAR_SCALAR __SYCL_BUILTIN_DEF(char)
Expand Down Expand Up @@ -255,6 +259,8 @@ namespace __sycl_std = __host_std;
#define __SYCL_DEF_BUILTIN_FLOAT_SCALAR __SYCL_BUILTIN_DEF(float)
#define __SYCL_DEF_BUILTIN_FLOAT_VEC __SYCL_DEF_BUILTIN_VEC(float)
#define __SYCL_DEF_BUILTIN_FLOAT_GEOVEC __SYCL_DEF_BUILTIN_GEOVEC(float)
#define __SYCL_DEF_BUILTIN_FLOAT_GEOCROSSVEC \
__SYCL_DEF_BUILTIN_GEOCROSSVEC(float)
#define __SYCL_DEF_BUILTIN_FLOAT_MARRAY __SYCL_DEF_BUILTIN_MARRAY(float)
#define __SYCL_DEF_BUILTIN_FLOATN \
__SYCL_DEF_BUILTIN_FLOAT_VEC \
Expand All @@ -269,6 +275,8 @@ namespace __sycl_std = __host_std;
#define __SYCL_DEF_BUILTIN_DOUBLE_SCALAR __SYCL_BUILTIN_DEF(double)
#define __SYCL_DEF_BUILTIN_DOUBLE_VEC __SYCL_DEF_BUILTIN_VEC(double)
#define __SYCL_DEF_BUILTIN_DOUBLE_GEOVEC __SYCL_DEF_BUILTIN_GEOVEC(double)
#define __SYCL_DEF_BUILTIN_DOUBLE_GEOCROSSVEC \
__SYCL_DEF_BUILTIN_GEOCROSSVEC(double)
#define __SYCL_DEF_BUILTIN_DOUBLE_MARRAY __SYCL_DEF_BUILTIN_MARRAY(double)
#define __SYCL_DEF_BUILTIN_DOUBLEN \
__SYCL_DEF_BUILTIN_DOUBLE_VEC \
Expand All @@ -283,6 +291,7 @@ namespace __sycl_std = __host_std;
#define __SYCL_DEF_BUILTIN_HALF_SCALAR __SYCL_BUILTIN_DEF(half)
#define __SYCL_DEF_BUILTIN_HALF_VEC __SYCL_DEF_BUILTIN_VEC(half)
#define __SYCL_DEF_BUILTIN_HALF_GEOVEC __SYCL_DEF_BUILTIN_GEOVEC(half)
#define __SYCL_DEF_BUILTIN_HALF_GEOCROSSVEC __SYCL_DEF_BUILTIN_GEOCROSSVEC(half)
#define __SYCL_DEF_BUILTIN_HALF_MARRAY __SYCL_DEF_BUILTIN_MARRAY(half)
#define __SYCL_DEF_BUILTIN_HALFN \
__SYCL_DEF_BUILTIN_HALF_VEC \
Expand Down Expand Up @@ -314,8 +323,17 @@ namespace __sycl_std = __host_std;
__SYCL_DEF_BUILTIN_GENGEOFLOATD \
__SYCL_DEF_BUILTIN_GENGEOFLOATH

// TODO: Replace with overloads.
#define __SYCL_DEF_BUILTIN_VGENGEOCROSSFLOAT \
__SYCL_DEF_BUILTIN_FLOAT_GEOCROSSVEC \
__SYCL_DEF_BUILTIN_DOUBLE_GEOCROSSVEC \
__SYCL_DEF_BUILTIN_HALF_GEOCROSSVEC

#define __SYCL_DEF_BUILTIN_VGENGEOFLOAT \
__SYCL_DEF_BUILTIN_FLOAT_GEOVEC \
__SYCL_DEF_BUILTIN_DOUBLE_GEOVEC \
__SYCL_DEF_BUILTIN_HALF_GEOVEC

// TODO: Replace with overloads.
#ifdef __FAST_MATH__
#define __FAST_MATH_GENFLOAT(T) \
(detail::is_svgenfloatd<T>::value || detail::is_svgenfloath<T>::value)
Expand Down Expand Up @@ -1942,141 +1960,106 @@ __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_IU_OVERLOAD(upsample, 32bit)
// double4 cross (double4 p0, double4 p1)
// half3 cross (half3 p0, half3 p1)
// half4 cross (half4 p0, half4 p1)
template <typename T>
std::enable_if_t<detail::is_gencross<T>::value, T> cross(T p0, T p1) __NOEXC {
return __sycl_std::__invoke_cross<T>(p0, p1);
}
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE cross(TYPE p0, TYPE p1) __NOEXC { \
return __sycl_std::__invoke_cross<TYPE>(p0, p1); \
}
__SYCL_DEF_BUILTIN_VGENGEOCROSSFLOAT
#undef __SYCL_BUILTIN_DEF
#undef __SYCL_DEF_BUILTIN_VGENGEOCROSSFLOAT
#undef __SYCL_DEF_BUILTIN_HALF_GEOCROSSVEC
#undef __SYCL_DEF_BUILTIN_DOUBLE_GEOCROSSVEC
#undef __SYCL_DEF_BUILTIN_FLOAT_GEOCROSSVEC
#undef __SYCL_DEF_BUILTIN_GEOCROSSVEC

// float dot (float p0, float p1)
// double dot (double p0, double p1)
// half dot (half p0, half p1)
template <typename T>
std::enable_if_t<detail::is_sgenfloat<T>::value, T> dot(T p0, T p1) __NOEXC {
return p0 * p1;
}

#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE dot(TYPE p0, TYPE p1) __NOEXC { return p0 * p1; }
__SYCL_DEF_BUILTIN_SGENFLOAT
#undef __SYCL_BUILTIN_DEF
// float dot (vgengeofloat p0, vgengeofloat p1)
template <typename T>
std::enable_if_t<detail::is_vgengeofloat<T>::value, float> dot(T p0,
T p1) __NOEXC {
return __sycl_std::__invoke_Dot<float>(p0, p1);
}

// double dot (vgengeodouble p0, vgengeodouble p1)
template <typename T>
std::enable_if_t<detail::is_vgengeodouble<T>::value, double> dot(T p0,
T p1) __NOEXC {
return __sycl_std::__invoke_Dot<double>(p0, p1);
}

// half dot (vgengeohalf p0, vgengeohalf p1)
template <typename T>
std::enable_if_t<detail::is_vgengeohalf<T>::value, half> dot(T p0,
T p1) __NOEXC {
return __sycl_std::__invoke_Dot<half>(p0, p1);
}

// float distance (gengeofloat p0, gengeofloat p1)
template <typename T,
typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
float distance(T p0, T p1) __NOEXC {
return __sycl_std::__invoke_distance<float>(p0, p1);
}

// double distance (gengeodouble p0, gengeodouble p1)
template <typename T,
typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
double distance(T p0, T p1) __NOEXC {
return __sycl_std::__invoke_distance<double>(p0, p1);
}

// half distance (gengeohalf p0, gengeohalf p1)
template <typename T,
typename = std::enable_if_t<detail::is_gengeohalf<T>::value, T>>
half distance(T p0, T p1) __NOEXC {
return __sycl_std::__invoke_distance<half>(p0, p1);
}

// float length (gengeofloat p)
template <typename T,
typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
float length(T p) __NOEXC {
return __sycl_std::__invoke_length<float>(p);
}

// double length (gengeodouble p)
template <typename T,
typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
double length(T p) __NOEXC {
return __sycl_std::__invoke_length<double>(p);
}

// half length (gengeohalf p)
template <typename T,
typename = std::enable_if_t<detail::is_gengeohalf<T>::value, T>>
half length(T p) __NOEXC {
return __sycl_std::__invoke_length<half>(p);
}
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE::element_type dot(TYPE p0, TYPE p1) __NOEXC { \
return __sycl_std::__invoke_Dot<TYPE::element_type>(p0, p1); \
}
__SYCL_DEF_BUILTIN_VGENGEOFLOAT
#undef __SYCL_BUILTIN_DEF

// float distance (float p0, float p1)
// double distance (double p0, double p1)
// half distance (half p0, half p1)
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE distance(TYPE p0, TYPE p1) __NOEXC { \
return __sycl_std::__invoke_distance<TYPE>(p0, p1); \
}
__SYCL_DEF_BUILTIN_SGENFLOAT
#undef __SYCL_BUILTIN_DEF
// float distance (vgengeofloat p0, vgengeofloat p1)
// double distance (vgengeodouble p0, vgengeodouble p1)
// half distance (vgengeohalf p0, vgengeohalf p1)
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE::element_type distance(TYPE p0, TYPE p1) __NOEXC { \
return __sycl_std::__invoke_distance<TYPE::element_type>(p0, p1); \
}
__SYCL_DEF_BUILTIN_VGENGEOFLOAT
#undef __SYCL_BUILTIN_DEF

// float length (float p0, float p1)
// double length (double p0, double p1)
// half length (half p0, half p1)
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE length(TYPE p) __NOEXC { \
return __sycl_std::__invoke_length<TYPE>(p); \
}
__SYCL_DEF_BUILTIN_SGENFLOAT
#undef __SYCL_BUILTIN_DEF
// float length (vgengeofloat p0, vgengeofloat p1)
// double length (vgengeodouble p0, vgengeodouble p1)
// half length (vgengeohalf p0, vgengeohalf p1)
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE::element_type length(TYPE p) __NOEXC { \
return __sycl_std::__invoke_length<TYPE::element_type>(p); \
}
__SYCL_DEF_BUILTIN_VGENGEOFLOAT
#undef __SYCL_BUILTIN_DEF

// gengeofloat normalize (gengeofloat p)
template <typename T>
std::enable_if_t<detail::is_gengeofloat<T>::value, T> normalize(T p) __NOEXC {
return __sycl_std::__invoke_normalize<T>(p);
}

// gengeodouble normalize (gengeodouble p)
template <typename T>
std::enable_if_t<detail::is_gengeodouble<T>::value, T> normalize(T p) __NOEXC {
return __sycl_std::__invoke_normalize<T>(p);
}

// gengeohalf normalize (gengeohalf p)
template <typename T>
std::enable_if_t<detail::is_gengeohalf<T>::value, T> normalize(T p) __NOEXC {
return __sycl_std::__invoke_normalize<T>(p);
}
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE normalize(TYPE p) __NOEXC { \
return __sycl_std::__invoke_normalize<TYPE>(p); \
}
__SYCL_DEF_BUILTIN_GENGEOFLOAT
#undef __SYCL_BUILTIN_DEF

// float fast_distance (gengeofloat p0, gengeofloat p1)
template <typename T,
typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
float fast_distance(T p0, T p1) __NOEXC {
return __sycl_std::__invoke_fast_distance<float>(p0, p1);
}

// double fast_distance (gengeodouble p0, gengeodouble p1)
template <typename T,
typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
double fast_distance(T p0, T p1) __NOEXC {
return __sycl_std::__invoke_fast_distance<double>(p0, p1);
}
#define __SYCL_BUILTIN_DEF(TYPE) \
inline float fast_distance(TYPE p0, TYPE p1) __NOEXC { \
return __sycl_std::__invoke_fast_distance<float>(p0, p1); \
}
__SYCL_DEF_BUILTIN_GENGEOFLOATF
#undef __SYCL_BUILTIN_DEF

// float fast_length (gengeofloat p)
template <typename T,
typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
float fast_length(T p) __NOEXC {
return __sycl_std::__invoke_fast_length<float>(p);
}

// double fast_length (gengeodouble p)
template <typename T,
typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
double fast_length(T p) __NOEXC {
return __sycl_std::__invoke_fast_length<double>(p);
}
#define __SYCL_BUILTIN_DEF(TYPE) \
inline float fast_length(TYPE p) __NOEXC { \
return __sycl_std::__invoke_fast_length<float>(p); \
}
__SYCL_DEF_BUILTIN_GENGEOFLOATF
#undef __SYCL_BUILTIN_DEF

// gengeofloat fast_normalize (gengeofloat p)
template <typename T>
std::enable_if_t<detail::is_gengeofloat<T>::value, T>
fast_normalize(T p) __NOEXC {
return __sycl_std::__invoke_fast_normalize<T>(p);
}

// gengeodouble fast_normalize (gengeodouble p)
template <typename T>
std::enable_if_t<detail::is_gengeodouble<T>::value, T>
fast_normalize(T p) __NOEXC {
return __sycl_std::__invoke_fast_normalize<T>(p);
}
#define __SYCL_BUILTIN_DEF(TYPE) \
inline TYPE fast_normalize(TYPE p) __NOEXC { \
return __sycl_std::__invoke_fast_normalize<TYPE>(p); \
}
__SYCL_DEF_BUILTIN_GENGEOFLOATF
#undef __SYCL_BUILTIN_DEF

// marray geometric functions

Expand Down

0 comments on commit 49bbcbf

Please sign in to comment.