DPC++ Runtime
Runtime libraries for oneAPI DPC++
generic_type_traits.hpp
Go to the documentation of this file.
1 //==----------- generic_type_traits - SYCL type traits ---------------------==//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #pragma once
10 
11 #include <sycl/access/access.hpp> // for decorated, address_space
12 #include <sycl/aliases.hpp> // for half, cl_char, cl_double
13 #include <sycl/detail/generic_type_lists.hpp> // for nonconst_address_space...
14 #include <sycl/detail/helpers.hpp> // for marray
15 #include <sycl/detail/type_list.hpp> // for is_contained, find_sam...
16 #include <sycl/detail/type_traits.hpp> // for is_gen_based_on_type_s...
17 #include <sycl/half_type.hpp> // for BIsRepresentationT
18 #include <sycl/multi_ptr.hpp> // for multi_ptr, address_spa...
19 
20 #include <cstddef> // for byte
21 #include <cstdint> // for uint8_t
22 #include <limits> // for numeric_limits
23 #include <type_traits> // for enable_if_t, condition...
24 
25 namespace sycl {
26 inline namespace _V1 {
27 namespace detail {
28 
29 template <typename T> using is_floatn = is_contained<T, gtl::vector_float_list>;
30 
31 template <typename T> using is_genfloatf = is_contained<T, gtl::float_list>;
32 
33 template <typename T>
35 
36 template <typename T>
38 
39 template <typename T> using is_genfloatd = is_contained<T, gtl::double_list>;
40 
41 template <typename T>
43 
44 template <typename T> using is_halfn = is_contained<T, gtl::vector_half_list>;
45 
46 template <typename T> using is_genfloath = is_contained<T, gtl::half_list>;
47 
48 template <typename T> using is_half = is_contained<T, gtl::scalar_half_list>;
49 
50 template <typename T>
52 
53 template <typename T> using is_genfloat = is_contained<T, gtl::floating_list>;
54 
55 template <typename T>
57 
58 template <typename T>
60 
61 template <typename T>
63 
64 template <typename T>
65 using is_mgenfloat = std::bool_constant<
66  std::is_same_v<T, sycl::marray<marray_element_t<T>, T::size()>> &&
68 
69 template <typename T>
71 
72 template <typename T>
74 
75 template <typename T>
77 
78 template <typename T>
80 
81 template <typename T> using is_gengeohalf = is_contained<T, gtl::geo_half_list>;
82 
83 template <typename T>
85 
86 template <typename T>
88 
89 template <typename T>
91 
92 template <typename T> using is_sgengeo = is_contained<T, gtl::scalar_geo_list>;
93 
94 template <typename T> using is_vgengeo = is_contained<T, gtl::vector_geo_list>;
95 
96 template <typename T>
98 
99 template <typename T>
101 
102 template <typename T>
104 
105 template <typename T>
107 
108 template <typename T>
110 
111 template <typename T>
113 
114 template <typename T>
116 
117 template <typename T>
119 
120 template <typename T>
122 
123 template <typename T>
125 
126 template <typename T> using is_genchar = is_contained<T, gtl::char_list>;
127 
128 template <typename T>
130 
131 template <typename T>
133 
134 template <typename T>
136 
137 template <typename T>
139 
140 template <typename T>
142 
143 template <typename T>
145 
146 template <typename T>
148 
149 template <typename T> using is_genint = is_contained<T, gtl::signed_int_list>;
150 
151 template <typename T>
153 
154 template <typename T>
156 
157 template <typename T>
159 
160 template <typename T>
162 
163 template <typename T>
165 
166 template <typename T>
168 
169 template <typename T> using is_geninteger = is_contained<T, gtl::integer_list>;
170 
171 template <typename T>
173 
174 template <typename T>
176 
177 template <typename T>
179 
180 template <typename T>
182 
183 template <typename T>
185 
186 template <typename T>
188 
189 template <typename T>
191 
192 template <typename T>
194 
195 template <typename T> using is_genbool = is_contained<T, gtl::bool_list>;
196 
197 template <typename T> using is_gentype = is_contained<T, gtl::basic_list>;
198 
199 template <typename T>
201 
202 template <typename T>
204 
205 template <typename T>
207 
208 template <typename T>
210 
211 template <typename T>
213 
214 template <typename T>
216 
217 template <typename T>
219 
220 template <typename T>
222 
223 template <typename T>
225 
226 template <typename T>
228 
229 template <typename T>
231 
232 template <typename T>
234 
235 template <typename T>
237 
238 template <typename T>
240 
241 template <typename T>
242 using is_genintptr = std::bool_constant<
245 
246 template <typename T, access::address_space AddressSpace,
247  access::decorated IsDecorated>
248 using is_genintptr_marray = std::bool_constant<
249  std::is_same_v<T, sycl::marray<marray_element_t<T>, T::size()>> &&
253  (IsDecorated == access::decorated::yes ||
254  IsDecorated == access::decorated::no)>;
255 
256 template <typename T>
257 using is_genfloatptr = std::bool_constant<
260 
261 template <typename T, access::address_space AddressSpace,
262  access::decorated IsDecorated>
263 using is_genfloatptr_marray = std::bool_constant<
267  (IsDecorated == access::decorated::yes ||
268  IsDecorated == access::decorated::no)>;
269 
270 template <typename T>
271 using is_genptr = std::bool_constant<
274 
275 template <typename T> using is_nan_type = is_contained<T, gtl::nan_list>;
276 
277 // nan_types
278 template <typename T, typename Enable = void> struct nan_types;
279 
280 template <typename T>
281 struct nan_types<
282  T, std::enable_if_t<is_contained<T, gtl::unsigned_short_list>::value, T>> {
285 };
286 
287 template <typename T>
288 struct nan_types<
289  T, std::enable_if_t<is_contained<T, gtl::unsigned_int_list>::value, T>> {
292 };
293 
294 template <typename T>
295 struct nan_types<
296  T, std::enable_if_t<is_contained<T, gtl::unsigned_long_integer_list>::value,
297  T>> {
299  using arg_type =
301 };
302 
303 template <typename T> using nan_return_t = typename nan_types<T, T>::ret_type;
304 
305 template <typename T>
307 
308 template <typename T>
310 
311 template <typename T>
313 
314 template <typename T>
317 
318 template <typename T, typename B, typename Enable = void>
320 
321 template <typename T, typename B>
323  std::enable_if_t<is_sgentype<T>::value, T>> {
324  B operator()(T t) { return static_cast<B>(t); }
325 };
326 
327 template <typename T, typename B>
329  std::enable_if_t<is_vgentype<T>::value, T>> {
330  vec<B, T::size()> operator()(T t) { return t.template convert<B>(); }
331 };
332 
333 template <typename T, typename B>
335 
336 // TryToGetPointerT<T>::type is T::pointer_t (legacy) or T::pointer if those
337 // exist, otherwise T.
338 template <typename T> class TryToGetPointerT {
339  static T check(...);
340  template <typename A> static typename A::pointer_t check(const A &);
341  template <typename A> static typename A::pointer check(const A &);
342 
343 public:
344  using type = decltype(check(T()));
345  static constexpr bool value =
346  std::is_pointer_v<T> || !std::is_same_v<T, type>;
347 };
348 
349 // TryToGetElementType<T>::type is T::element_type or T::value_type if those
350 // exist, otherwise T.
351 template <typename T> class TryToGetElementType {
352  static T check(...);
353  template <typename A> static typename A::element_type check(const A &);
354  template <typename A> static typename A::value_type check(const A &);
355 
356 public:
357  using type = decltype(check(T()));
358  static constexpr bool value = !std::is_same_v<T, type>;
359 };
360 
361 // TryToGetVectorT<T>::type is T::vector_t if that exists, otherwise T.
362 template <typename T> class TryToGetVectorT {
363  static T check(...);
364  template <typename A> static typename A::vector_t check(const A &);
365 
366 public:
367  using type = decltype(check(T()));
368  static constexpr bool value = !std::is_same_v<T, type>;
369 };
370 
371 // Try to get pointer_t (if pointer_t indicates on the type with_remainder
372 // vector_t creates a pointer type on vector_t), otherwise T
373 template <typename T> class TryToGetPointerVecT {
374  static T check(...);
375  template <typename A>
376  static typename DecoratedType<
379  check(const A &);
380  template <typename A>
381  static typename TryToGetVectorT<A>::type *check(const A *);
382 
383 public:
384  using type = decltype(check(T()));
385 };
386 
387 template <typename To> struct PointerConverter {
388  template <typename From> static To Convert(From *t) {
389  return reinterpret_cast<To>(t);
390  }
391 
392  template <typename From> static To Convert(From &t) {
393  if constexpr (is_non_legacy_multi_ptr_v<From>) {
394  return detail::cast_AS<To>(t.get_decorated());
395  } else if constexpr (is_legacy_multi_ptr_v<From>) {
396  return detail::cast_AS<To>(t.get());
397  } else {
398  // TODO find the better way to get the pointer to underlying data from vec
399  // class
400  return reinterpret_cast<To>(t.get());
401  }
402  }
403 };
404 
405 template <typename ElementType, access::address_space Space,
406  access::decorated DecorateAddress>
407 struct PointerConverter<multi_ptr<ElementType, Space, DecorateAddress>> {
408  template <typename From>
410  return address_space_cast<Space, DecorateAddress>(
411  reinterpret_cast<remove_decoration_t<From *>>(t));
412  }
413 
414  template <typename From>
416  return address_space_cast<Space, DecorateAddress>(
417  reinterpret_cast<remove_decoration_t<decltype(t.get())>>(t.get()));
418  }
419 
420  template <typename From>
423  return t;
424  }
425 };
426 
427 template <typename To, typename From,
428  typename = typename std::enable_if_t<TryToGetPointerT<From>::value>>
429 To ConvertNonVectorType(From &t) {
431 }
432 
433 template <typename To, typename From> To ConvertNonVectorType(From *t) {
435 }
436 
437 template <typename To, typename From>
438 typename std::enable_if_t<!TryToGetPointerT<From>::value, To>
440  return static_cast<To>(t);
441 }
442 
443 template <typename T, typename = void> struct mptr_or_vec_elem_type {
444  using type = typename T::element_type;
445 };
446 template <typename ElementType, access::address_space Space,
447  access::decorated IsDecorated>
449  multi_ptr<ElementType, Space, IsDecorated>,
450  std::enable_if_t<IsDecorated == access::decorated::no ||
451  IsDecorated == access::decorated::yes>> {
453 };
454 template <typename ElementType, access::address_space Space,
455  access::decorated IsDecorated>
456 struct mptr_or_vec_elem_type<const multi_ptr<ElementType, Space, IsDecorated>>
457  : mptr_or_vec_elem_type<multi_ptr<ElementType, Space, IsDecorated>> {};
458 
459 template <typename T>
461 
462 // select_apply_cl_scalar_t selects from T8/T16/T32/T64 basing on
463 // sizeof(IN). expected to handle scalar types.
464 template <typename T, typename T8, typename T16, typename T32, typename T64>
465 using select_apply_cl_scalar_t = std::conditional_t<
466  sizeof(T) == 1, T8,
467  std::conditional_t<sizeof(T) == 2, T16,
468  std::conditional_t<sizeof(T) == 4, T32, T64>>>;
469 
470 // Shortcuts for selecting scalar int/unsigned int/fp type.
471 template <typename T>
475 
476 template <typename T>
480 
481 template <typename T>
485 
486 // Use SFINAE so that std::complex specialization could be implemented in
487 // include/sycl/stl_wrappers/complex that would only be available if STL's
488 // <complex> is included by users.
489 template <typename T, typename = void> struct select_cl_scalar_complex_or_T {
490  using type = T;
491 };
492 
493 template <typename T>
496 
497 template <typename T>
499  std::conditional_t<std::is_signed_v<T>,
502 
503 // select_cl_scalar_t picks corresponding cl_* type for input
504 // scalar T or returns T if T is not scalar.
505 template <typename T>
506 using select_cl_scalar_t = std::conditional_t<
507  std::is_integral_v<T>, select_cl_scalar_integral_t<T>,
508  std::conditional_t<
509  std::is_floating_point_v<T>, select_cl_scalar_float_t<T>,
510  // half is a special case: it is implemented differently on
511  // host and device and therefore, might lower to different
512  // types
513  std::conditional_t<is_half<T>::value,
516 
517 // select_cl_vector_or_scalar_or_ptr does cl_* type selection for element type
518 // of a vector type T, pointer type substitution, and scalar type substitution.
519 // If T is not vector, scalar, or pointer unmodified T is returned.
520 template <typename T, typename Enable = void>
522 
523 template <typename T>
525  T, typename std::enable_if_t<is_vgentype<T>::value>> {
526  using type =
527  // select_cl_scalar_t returns _Float16, so, we try to instantiate vec
528  // class with _Float16 DataType, which is not expected there
529  // So, leave vector<half, N> as-is
533  T::size()>;
534 };
535 
536 template <typename T>
538  T, typename std::enable_if_t<!is_vgentype<T>::value &&
539  !std::is_pointer_v<T>>> {
541 };
542 
543 template <typename T>
545  T,
546  typename std::enable_if_t<!is_vgentype<T>::value && std::is_pointer_v<T>>> {
548  std::remove_pointer_t<T>>::type *;
549 #ifdef __SYCL_DEVICE_ONLY__
551 #else
553 #endif
554 };
555 
556 // select_cl_mptr_or_vector_or_scalar_or_ptr does cl_* type selection for type
557 // pointed by multi_ptr, for raw pointers, for element type of a vector type T,
558 // and does scalar type substitution. If T is not mutlti_ptr or vector or
559 // scalar or pointer unmodified T is returned.
560 template <typename T, typename Enable = void>
562 
563 // this struct helps to use std::uint8_t instead of std::byte,
564 // which is not supported on device
565 template <typename T> struct TypeHelper {
566  using RetType = T;
567 };
568 
569 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
570 template <> struct TypeHelper<std::byte> {
571  using RetType = std::uint8_t;
572 };
573 #endif
574 
575 template <typename T> struct TypeHelper<const T> {
576  using RetType = const typename TypeHelper<T>::RetType;
577 };
578 
579 template <typename T> struct TypeHelper<volatile T> {
580  using RetType = volatile typename TypeHelper<T>::RetType;
581 };
582 
583 template <typename T> struct TypeHelper<const volatile T> {
584  using RetType = const volatile typename TypeHelper<T>::RetType;
585 };
586 
587 template <typename T> using type_helper = typename TypeHelper<T>::RetType;
588 
589 template <typename T>
591  T,
592  typename std::enable_if_t<is_genptr<T>::value && !std::is_pointer_v<T>>> {
596 };
597 
598 template <typename T>
600  T,
601  typename std::enable_if_t<!is_genptr<T>::value || std::is_pointer_v<T>>> {
603 };
604 
605 // All types converting shortcut.
606 template <typename T>
609 
610 // Converts T to OpenCL friendly
611 //
612 template <typename T /* MatchingOpencCLTypeT */>
613 using ConvertToOpenCLTypeImpl_t = std::conditional_t<
615  std::conditional_t<TryToGetPointerT<T>::value,
617 template <typename T>
618 using ConvertToOpenCLType_t =
620 
621 // convertDataToType() function converts data from FROM type to TO type using
622 // 'as' method for vector type and copy otherwise.
623 template <typename FROM, typename TO>
624 typename std::enable_if_t<is_vgentype<FROM>::value && is_vgentype<TO>::value &&
625  sizeof(TO) == sizeof(FROM),
626  TO>
628  return t.template as<TO>();
629 }
630 
631 template <typename FROM, typename TO>
632 typename std::enable_if_t<!(is_vgentype<FROM>::value &&
633  is_vgentype<TO>::value) &&
634  sizeof(TO) == sizeof(FROM),
635  TO>
637  return ConvertNonVectorType<TO>(t);
638 }
639 
640 // Used for all, any and select relational built-in functions
641 template <typename T> inline constexpr T msbMask(T) {
642  using UT = make_unsigned_t<T>;
643  return T(UT(1) << (sizeof(T) * 8 - 1));
644 }
645 
646 template <typename T> inline constexpr bool msbIsSet(const T x) {
647  return (x & msbMask(x));
648 }
649 
650 // SYCL 2020 4.17.9 (Relation functions), e.g. table 178
651 //
652 // genbool isequal (genfloatf x, genfloatf y)
653 // genbool isequal (genfloatd x, genfloatd y)
654 //
655 // TODO: marray support isn't implemented yet.
656 template <typename T>
657 using common_rel_ret_t =
658  std::conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, bool>;
659 
660 // forward declaration
661 template <int N> struct Boolean;
662 
663 // Try to get vector element count or 1 otherwise
664 template <typename T, typename Enable = void> struct TryToGetNumElements;
665 
666 template <typename T>
668  T, typename std::enable_if_t<TryToGetVectorT<T>::value>> {
669  static constexpr int value = T::size();
670 };
671 template <typename T>
673  T, typename std::enable_if_t<!TryToGetVectorT<T>::value>> {
674  static constexpr int value = 1;
675 };
676 
677 // Used for relational comparison built-in functions
678 template <typename T> struct RelationalReturnType {
679 #ifdef __SYCL_DEVICE_ONLY__
681 #else
683 #endif
684 };
685 
686 // Type representing the internal return type of relational builtins.
687 template <typename T>
689 
690 // Used for any and all built-in functions
691 template <typename T> struct RelationalTestForSignBitType {
692 #ifdef __SYCL_DEVICE_ONLY__
695 #else
696  using return_type = int;
697  using argument_type = T;
698 #endif
699 };
700 
701 template <typename T>
704 
705 template <typename T>
708 
709 template <typename T, typename Enable = void> struct RelConverter;
710 
711 template <typename T>
712 struct RelConverter<T,
713  typename std::enable_if_t<TryToGetElementType<T>::value>> {
714  static const int N = T::size();
715 #ifdef __SYCL_DEVICE_ONLY__
716  using bool_t = typename Boolean<N>::vector_t;
717  using ret_t = common_rel_ret_t<T>;
718 #else
721 #endif
722 
723  static ret_t apply(bool_t value) {
724 #ifdef __SYCL_DEVICE_ONLY__
725  typename ret_t::vector_t result(0);
726  for (size_t I = 0; I < N; ++I) {
727  result[I] = value[I];
728  }
729  return result;
730 #else
731  return value;
732 #endif
733  }
734 };
735 
736 template <typename T>
737 struct RelConverter<T,
738  typename std::enable_if_t<!TryToGetElementType<T>::value>> {
740 #ifdef __SYCL_DEVICE_ONLY__
741  using value_t = bool;
742 #else
743  using value_t = R;
744 #endif
745 
746  static R apply(value_t value) { return value; }
747 };
748 
749 template <typename T> static constexpr T max_v() {
750  return (std::numeric_limits<T>::max)();
751 }
752 
753 template <typename T> static constexpr T min_v() {
754  return (std::numeric_limits<T>::min)();
755 }
756 
757 template <typename T> static constexpr T quiet_NaN() {
759 }
760 
761 // is_same_vector_size
762 template <int FirstSize, typename... Args> class is_same_vector_size_impl;
763 
764 template <int FirstSize, typename T, typename... Args>
765 class is_same_vector_size_impl<FirstSize, T, Args...> {
766  using CurrentT = detail::remove_pointer_t<T>;
767  static constexpr int Size = vector_size<CurrentT>::value;
768  static constexpr bool IsSizeEqual = (Size == FirstSize);
769 
770 public:
771  static constexpr bool value =
772  IsSizeEqual ? is_same_vector_size_impl<FirstSize, Args...>::value : false;
773 };
774 
775 template <int FirstSize>
776 class is_same_vector_size_impl<FirstSize> : public std::true_type {};
777 
778 template <typename T, typename... Args> class is_same_vector_size {
779  using CurrentT = remove_pointer_t<T>;
780  static constexpr int Size = vector_size<CurrentT>::value;
781 
782 public:
783  static constexpr bool value = is_same_vector_size_impl<Size, Args...>::value;
784 };
785 
786 // check_vector_size
787 template <typename... Args> inline void check_vector_size() {
789  "The built-in function arguments must [point to|have] types "
790  "with the same number of elements.");
791 }
792 
793 } // namespace detail
794 } // namespace _V1
795 } // namespace sycl
sycl::_V1::detail::convertDataToType
std::enable_if_t< is_vgentype< FROM >::value &&is_vgentype< TO >::value &&sizeof(TO)==sizeof(FROM), TO > convertDataToType(FROM t)
Definition: generic_type_traits.hpp:627
sycl::_V1::detail::PointerConverter::Convert
static To Convert(From &t)
Definition: generic_type_traits.hpp:392
sycl::_V1::detail::mptr_or_vec_elem_type
Definition: generic_type_traits.hpp:443
sycl::_V1::detail::nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_int_list >::value, T > >::arg_type
find_same_size_type_t< gtl::scalar_unsigned_int_list, float > arg_type
Definition: generic_type_traits.hpp:291
sycl::_V1::detail::is_pointer
Definition: type_traits.hpp:339
sycl::_V1::detail::check_vector_size
void check_vector_size()
Definition: generic_type_traits.hpp:787
sycl::_V1::opencl::cl_int
std::int32_t cl_int
Definition: aliases.hpp:134
sycl::_V1::multi_ptr::value_type
ElementType value_type
Definition: multi_ptr.hpp:93
sycl::_V1::detail::is_ugeninteger64bit
is_gen_based_on_type_sizeof< T, 8, is_ugeninteger > is_ugeninteger64bit
Definition: generic_type_traits.hpp:227
sycl::_V1::opencl::cl_uint
std::uint32_t cl_uint
Definition: aliases.hpp:135
sycl::_V1::detail::select_cl_scalar_integral_unsigned_t
select_apply_cl_scalar_t< T, sycl::opencl::cl_uchar, sycl::opencl::cl_ushort, sycl::opencl::cl_uint, sycl::opencl::cl_ulong > select_cl_scalar_integral_unsigned_t
Definition: generic_type_traits.hpp:479
sycl::_V1::detail::make_singed_integer_t
make_type_t< T, gtl::scalar_signed_integer_list > make_singed_integer_t
Definition: generic_type_traits.hpp:312
sycl::_V1::detail::PointerConverter
Definition: generic_type_traits.hpp:387
sycl::_V1::detail::nan_types
Definition: generic_type_traits.hpp:278
sycl::_V1::detail::is_same_vector_size_impl
Definition: generic_type_traits.hpp:762
sycl::_V1::detail::is_igeninteger64bit
is_gen_based_on_type_sizeof< T, 8, is_igeninteger > is_igeninteger64bit
Definition: generic_type_traits.hpp:215
sycl::_V1::detail::select_cl_mptr_or_vector_or_scalar_or_ptr
Definition: generic_type_traits.hpp:561
type_traits.hpp
sycl::_V1::detail::type_helper
typename TypeHelper< T >::RetType type_helper
Definition: generic_type_traits.hpp:587
sycl::_V1::detail::nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_short_list >::value, T > >::arg_type
find_same_size_type_t< gtl::scalar_unsigned_short_list, half > arg_type
Definition: generic_type_traits.hpp:284
sycl::_V1::detail::is_ugeninteger8bit
is_gen_based_on_type_sizeof< T, 1, is_ugeninteger > is_ugeninteger8bit
Definition: generic_type_traits.hpp:218
sycl::_V1::detail::is_genfloatptr
std::bool_constant< is_pointer< T >::value &&is_genfloat< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value > is_genfloatptr
Definition: generic_type_traits.hpp:259
sycl::_V1::detail::is_geninteger16bit
is_gen_based_on_type_sizeof< T, 2, is_geninteger > is_geninteger16bit
Definition: generic_type_traits.hpp:233
sycl::_V1::opencl::cl_ushort
std::uint16_t cl_ushort
Definition: aliases.hpp:133
sycl::_V1::detail::TypeHelper::RetType
T RetType
Definition: generic_type_traits.hpp:566
sycl::_V1::opencl::cl_uchar
std::uint8_t cl_uchar
Definition: aliases.hpp:131
sycl::_V1::opencl::cl_ulong
std::uint64_t cl_ulong
Definition: aliases.hpp:137
sycl::_V1::detail::msbIsSet
constexpr bool msbIsSet(const T x)
Definition: generic_type_traits.hpp:646
sycl::_V1::detail::RelationalReturnType::type
common_rel_ret_t< T > type
Definition: generic_type_traits.hpp:682
sycl::_V1::detail::select_cl_scalar_integral_signed_t
select_apply_cl_scalar_t< T, sycl::opencl::cl_char, sycl::opencl::cl_short, sycl::opencl::cl_int, sycl::opencl::cl_long > select_cl_scalar_integral_signed_t
Definition: generic_type_traits.hpp:474
sycl::_V1::detail::select_apply_cl_scalar_t
std::conditional_t< sizeof(T)==1, T8, std::conditional_t< sizeof(T)==2, T16, std::conditional_t< sizeof(T)==4, T32, T64 > >> select_apply_cl_scalar_t
Definition: generic_type_traits.hpp:468
sycl::_V1::detail::convert_data_type_impl< T, B, std::enable_if_t< is_vgentype< T >::value, T > >::operator()
vec< B, T::size()> operator()(T t)
Definition: generic_type_traits.hpp:330
sycl::_V1::detail::is_same_vector_size::value
static constexpr bool value
Definition: generic_type_traits.hpp:783
sycl::_V1::detail::quiet_NaN
static constexpr T quiet_NaN()
Definition: generic_type_traits.hpp:757
sycl::_V1::detail::select_cl_mptr_or_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_genptr< T >::value||std::is_pointer_v< T > > >::type
typename select_cl_vector_or_scalar_or_ptr< T >::type type
Definition: generic_type_traits.hpp:602
sycl::_V1::detail::ConvertNonVectorType
To ConvertNonVectorType(From &t)
Definition: generic_type_traits.hpp:429
detail
---— Error handling, matching OpenCL plugin semantics.
Definition: common.hpp:44
sycl::_V1::detail::TryToGetPointerVecT::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:384
sycl::_V1::detail::is_genintptr_marray
std::bool_constant< std::is_same_v< T, sycl::marray< marray_element_t< T >, T::size()> > &&is_genint< marray_element_t< remove_pointer_t< T > >>::value &&is_address_space_compliant< multi_ptr< T, AddressSpace, IsDecorated >, gvl::nonconst_address_space_list >::value &&(IsDecorated==access::decorated::yes||IsDecorated==access::decorated::no)> is_genintptr_marray
Definition: generic_type_traits.hpp:254
sycl::_V1::detail::nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_int_list >::value, T > >::ret_type
change_base_type_t< T, float > ret_type
Definition: generic_type_traits.hpp:290
sycl::_V1::detail::TryToGetVectorT::value
static constexpr bool value
Definition: generic_type_traits.hpp:368
sycl::_V1::byte
unsigned char byte
Definition: image.hpp:108
helpers.hpp
sycl
Definition: access.hpp:18
max
simd< _Tp, _Abi > max(const simd< _Tp, _Abi > &, const simd< _Tp, _Abi > &) noexcept
sycl::_V1::detail::TryToGetNumElements
Definition: generic_type_traits.hpp:664
access.hpp
sycl::_V1::detail::mptr_or_vec_elem_type< multi_ptr< ElementType, Space, IsDecorated >, std::enable_if_t< IsDecorated==access::decorated::no||IsDecorated==access::decorated::yes > >::type
typename multi_ptr< ElementType, Space, IsDecorated >::value_type type
Definition: generic_type_traits.hpp:452
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr
Definition: generic_type_traits.hpp:521
sycl::_V1::detail::min_v
static constexpr T min_v()
Definition: generic_type_traits.hpp:753
sycl::_V1::detail::RelConverter< T, typename std::enable_if_t< TryToGetElementType< T >::value > >::ret_t
internal_rel_ret_t< T > ret_t
Definition: generic_type_traits.hpp:720
sycl::_V1::detail::nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_long_integer_list >::value, T > >::arg_type
find_same_size_type_t< gtl::scalar_unsigned_long_integer_list, double > arg_type
Definition: generic_type_traits.hpp:300
sycl::_V1::detail::is_gen_based_on_type_sizeof
std::bool_constant< S< T >::value &&(sizeof(vector_element_t< T >)==N)> is_gen_based_on_type_sizeof
Definition: type_traits.hpp:264
sycl::_V1::detail::nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_short_list >::value, T > >::ret_type
change_base_type_t< T, half > ret_type
Definition: generic_type_traits.hpp:283
sycl::_V1::opencl::cl_short
std::int16_t cl_short
Definition: aliases.hpp:132
sycl::_V1::detail::PointerConverter< multi_ptr< ElementType, Space, DecorateAddress > >::Convert
static multi_ptr< ElementType, Space, DecorateAddress > Convert(multi_ptr< ElementType, Space, DecorateAddress > &t)
Definition: generic_type_traits.hpp:422
generic_type_lists.hpp
sycl::_V1::remove_decoration_t
typename remove_decoration< T >::type remove_decoration_t
Definition: access.hpp:320
sycl::_V1::detail::is_mgenfloat
std::bool_constant< std::is_same_v< T, sycl::marray< marray_element_t< T >, T::size()> > &&is_svgenfloat< marray_element_t< T > >::value > is_mgenfloat
Definition: generic_type_traits.hpp:67
sycl::_V1::detail::select_cl_scalar_complex_or_T::type
T type
Definition: generic_type_traits.hpp:490
bool
sycl::_V1::detail::make_type_t
typename make_type_impl< T, TL >::type make_type_t
Definition: type_traits.hpp:426
sycl::_V1::detail::rel_sign_bit_test_arg_t
typename RelationalTestForSignBitType< T >::argument_type rel_sign_bit_test_arg_t
Definition: generic_type_traits.hpp:707
sycl::_V1::detail::make_unsigned_t
typename make_unsigned< T >::type make_unsigned_t
Definition: type_traits.hpp:259
sycl::_V1::detail::remove_pointer_t
typename remove_pointer< T >::type remove_pointer_t
Definition: type_traits.hpp:396
sycl::_V1::detail::is_igeninteger16bit
is_gen_based_on_type_sizeof< T, 2, is_igeninteger > is_igeninteger16bit
Definition: generic_type_traits.hpp:209
sycl::_V1::detail::Boolean
Definition: boolean.hpp:48
sycl::_V1::multi_ptr
Provides constructors for address space qualified and non address space qualified pointers to allow i...
Definition: atomic.hpp:34
sycl::_V1::detail::RelConverter< T, typename std::enable_if_t<!TryToGetElementType< T >::value > >::value_t
R value_t
Definition: generic_type_traits.hpp:743
sycl::_V1::detail::internal_rel_ret_t
typename RelationalReturnType< T >::type internal_rel_ret_t
Definition: generic_type_traits.hpp:688
sycl::_V1::detail::make_floating_point_t
make_type_t< T, gtl::scalar_floating_list > make_floating_point_t
Definition: generic_type_traits.hpp:309
sycl::_V1::detail::change_base_type_t
typename change_base_type< T, B >::type change_base_type_t
Definition: type_traits.hpp:161
sycl::_V1::opencl::cl_char
std::int8_t cl_char
Definition: aliases.hpp:130
sycl::_V1::detail::mptr_or_vec_elem_type_t
typename mptr_or_vec_elem_type< T >::type mptr_or_vec_elem_type_t
Definition: generic_type_traits.hpp:460
sycl::_V1::detail::RelationalReturnType
Definition: generic_type_traits.hpp:678
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_vgentype< T >::value &&std::is_pointer_v< T > > >::type
elem_ptr_type type
Definition: generic_type_traits.hpp:552
sycl::_V1::opencl::cl_long
std::int64_t cl_long
Definition: aliases.hpp:136
sycl::_V1::detail::TypeHelper< volatile T >::RetType
volatile typename TypeHelper< T >::RetType RetType
Definition: generic_type_traits.hpp:580
multi_ptr.hpp
sycl::_V1::detail::RelConverter< T, typename std::enable_if_t<!TryToGetElementType< T >::value > >::R
internal_rel_ret_t< T > R
Definition: generic_type_traits.hpp:739
sycl::_V1::detail::TryToGetElementType
Definition: generic_type_traits.hpp:351
sycl::_V1::detail::convert_data_type_impl
Definition: generic_type_traits.hpp:319
sycl::_V1::detail::TryToGetPointerT::value
static constexpr bool value
Definition: generic_type_traits.hpp:345
sycl::_V1::detail::msbMask
constexpr T msbMask(T)
Definition: generic_type_traits.hpp:641
sycl::_V1::detail::find_same_size_type_t
find_type_t< TypeList, is_type_size_equal, T > find_same_size_type_t
Definition: type_list.hpp:117
sycl::_V1::detail::make_unsinged_integer_t
make_type_t< T, gtl::scalar_unsigned_integer_list > make_unsinged_integer_t
Definition: generic_type_traits.hpp:316
sycl::_V1::detail::TryToGetElementType::value
static constexpr bool value
Definition: generic_type_traits.hpp:358
sycl::_V1::detail::RelConverter< T, typename std::enable_if_t<!TryToGetElementType< T >::value > >::apply
static R apply(value_t value)
Definition: generic_type_traits.hpp:746
sycl::_V1::detail::RelationalTestForSignBitType::return_type
int return_type
Definition: generic_type_traits.hpp:696
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_vgentype< T >::value &&!std::is_pointer_v< T > > >::type
select_cl_scalar_t< T > type
Definition: generic_type_traits.hpp:540
sycl::_V1::detail::TypeHelper< const T >::RetType
const typename TypeHelper< T >::RetType RetType
Definition: generic_type_traits.hpp:576
sycl::_V1::opencl::cl_half
half cl_half
Definition: aliases.hpp:138
sycl::_V1::detail::rel_sign_bit_test_ret_t
typename RelationalTestForSignBitType< T >::return_type rel_sign_bit_test_ret_t
Definition: generic_type_traits.hpp:703
sycl::_V1::detail::RelationalTestForSignBitType::argument_type
T argument_type
Definition: generic_type_traits.hpp:697
sycl::_V1::detail::convert_data_type_impl< T, B, std::enable_if_t< is_sgentype< T >::value, T > >::operator()
B operator()(T t)
Definition: generic_type_traits.hpp:324
sycl::_V1::element_type
std::conditional_t< std::is_same_v< ElementType, half >, sycl::detail::half_impl::BIsRepresentationT, ElementType > element_type
Definition: multi_ptr.hpp:752
sycl::_V1::detail::TryToGetVectorT::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:367
sycl::_V1::detail::TypeHelper
Definition: generic_type_traits.hpp:565
sycl::_V1::access::decorated
decorated
Definition: access.hpp:63
sycl::_V1::detail::TryToGetPointerVecT
Definition: generic_type_traits.hpp:373
sycl::_V1::detail::Boolean< 1 >
Definition: boolean.hpp:105
sycl::_V1::detail::nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_long_integer_list >::value, T > >::ret_type
change_base_type_t< T, double > ret_type
Definition: generic_type_traits.hpp:298
sycl::_V1::detail::select_cl_scalar_integral_t
std::conditional_t< std::is_signed_v< T >, select_cl_scalar_integral_signed_t< T >, select_cl_scalar_integral_unsigned_t< T > > select_cl_scalar_integral_t
Definition: generic_type_traits.hpp:501
sycl::_V1::detail::mptr_or_vec_elem_type< multi_ptr< ElementType, Space, IsDecorated > >::type
typename multi_ptr< ElementType, Space, IsDecorated > ::element_type type
Definition: generic_type_traits.hpp:444
sycl::_V1::detail::TryToGetPointerT::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:344
sycl::_V1::detail::nan_return_t
typename nan_types< T, T >::ret_type nan_return_t
Definition: generic_type_traits.hpp:303
sycl::_V1::access::decorated::no
@ no
sycl::_V1::detail::is_geninteger64bit
is_gen_based_on_type_sizeof< T, 8, is_geninteger > is_geninteger64bit
Definition: generic_type_traits.hpp:239
sycl::_V1::detail::RelConverter< T, typename std::enable_if_t< TryToGetElementType< T >::value > >::apply
static ret_t apply(bool_t value)
Definition: generic_type_traits.hpp:723
sycl::_V1::detail::TryToGetElementType::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:357
sycl::_V1::detail::value_list
Definition: type_list.hpp:64
sycl::_V1::detail::RelConverter
Definition: generic_type_traits.hpp:709
sycl::_V1::detail::is_address_space_compliant
Definition: type_traits.hpp:412
sycl::_V1::vec
Provides a cross-patform vector class template that works efficiently on SYCL devices as well as in h...
Definition: aliases.hpp:18
sycl::_V1::detail::select_cl_scalar_float_t
select_apply_cl_scalar_t< T, std::false_type, sycl::opencl::cl_half, sycl::opencl::cl_float, sycl::opencl::cl_double > select_cl_scalar_float_t
Definition: generic_type_traits.hpp:484
sycl::_V1::detail::is_genptr
std::bool_constant< is_pointer< T >::value &&is_gentype< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value > is_genptr
Definition: generic_type_traits.hpp:273
std
Definition: accessor.hpp:4139
sycl::_V1::detail::TypeHelper< std::byte >::RetType
std::uint8_t RetType
Definition: generic_type_traits.hpp:571
sycl::_V1::detail::PointerConverter< multi_ptr< ElementType, Space, DecorateAddress > >::Convert
static multi_ptr< ElementType, Space, DecorateAddress > Convert(From *t)
Definition: generic_type_traits.hpp:409
sycl::_V1::detail::max_v
static constexpr T max_v()
Definition: generic_type_traits.hpp:749
sycl::_V1::detail::is_geninteger8bit
is_gen_based_on_type_sizeof< T, 1, is_geninteger > is_geninteger8bit
Definition: generic_type_traits.hpp:230
sycl::_V1::access::decorated::yes
@ yes
sycl::_V1::detail::is_contained
Definition: type_list.hpp:56
sycl::_V1::detail::is_same_vector_size
Definition: generic_type_traits.hpp:778
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_vgentype< T >::value &&std::is_pointer_v< T > > >::elem_ptr_type
typename select_cl_vector_or_scalar_or_ptr< std::remove_pointer_t< T > >::type * elem_ptr_type
Definition: generic_type_traits.hpp:548
sycl::_V1::detail::half_impl::BIsRepresentationT
half BIsRepresentationT
Definition: half_type.hpp:256
half_type.hpp
sycl::_V1::detail::is_ugeninteger32bit
is_gen_based_on_type_sizeof< T, 4, is_ugeninteger > is_ugeninteger32bit
Definition: generic_type_traits.hpp:224
aliases.hpp
sycl::_V1::detail::TypeHelper< const volatile T >::RetType
const volatile typename TypeHelper< T >::RetType RetType
Definition: generic_type_traits.hpp:584
sycl::_V1::detail::is_genintptr
std::bool_constant< is_pointer< T >::value &&is_genint< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value > is_genintptr
Definition: generic_type_traits.hpp:244
sycl::_V1::detail::DecoratedType
Definition: access.hpp:163
sycl::_V1::detail::ConvertToOpenCLType_t
ConvertToOpenCLTypeImpl_t< SelectMatchingOpenCLType_t< T > > ConvertToOpenCLType_t
Definition: generic_type_traits.hpp:619
sycl::_V1::detail::common_rel_ret_t
std::conditional_t< is_vgentype< T >::value, make_singed_integer_t< T >, bool > common_rel_ret_t
Definition: generic_type_traits.hpp:658
sycl::_V1::detail::is_igeninteger32bit
is_gen_based_on_type_sizeof< T, 4, is_igeninteger > is_igeninteger32bit
Definition: generic_type_traits.hpp:212
sycl::_V1::detail::PointerConverter::Convert
static To Convert(From *t)
Definition: generic_type_traits.hpp:388
sycl::_V1::detail::nan_argument_base_t
typename nan_types< T, T >::arg_type nan_argument_base_t
Definition: generic_type_traits.hpp:306
sycl::_V1::opencl::cl_double
double cl_double
Definition: aliases.hpp:140
sycl::_V1::detail::RelationalTestForSignBitType
Definition: generic_type_traits.hpp:691
sycl::_V1::detail::vector_size
Definition: type_traits.hpp:130
sycl::_V1::detail::is_geninteger32bit
is_gen_based_on_type_sizeof< T, 4, is_geninteger > is_geninteger32bit
Definition: generic_type_traits.hpp:236
sycl::_V1::detail::select_cl_scalar_t
std::conditional_t< std::is_integral_v< T >, select_cl_scalar_integral_t< T >, std::conditional_t< std::is_floating_point_v< T >, select_cl_scalar_float_t< T >, std::conditional_t< is_half< T >::value, sycl::detail::half_impl::BIsRepresentationT, select_cl_scalar_complex_or_T_t< T > >> > select_cl_scalar_t
Definition: generic_type_traits.hpp:515
sycl::_V1::detail::is_ugeninteger16bit
is_gen_based_on_type_sizeof< T, 2, is_ugeninteger > is_ugeninteger16bit
Definition: generic_type_traits.hpp:221
sycl::_V1::detail::PointerConverter< multi_ptr< ElementType, Space, DecorateAddress > >::Convert
static multi_ptr< ElementType, Space, DecorateAddress > Convert(From &t)
Definition: generic_type_traits.hpp:415
sycl::_V1::detail::select_cl_scalar_complex_or_T_t
typename select_cl_scalar_complex_or_T< T >::type select_cl_scalar_complex_or_T_t
Definition: generic_type_traits.hpp:495
sycl::_V1::detail::TryToGetVectorT
Definition: generic_type_traits.hpp:362
sycl::_V1::detail::get
Definition: tuple.hpp:58
sycl::_V1::detail::ConvertToOpenCLTypeImpl_t
std::conditional_t< TryToGetVectorT< T >::value, typename TryToGetVectorT< T >::type, std::conditional_t< TryToGetPointerT< T >::value, typename TryToGetPointerVecT< T >::type, T > > ConvertToOpenCLTypeImpl_t
Definition: generic_type_traits.hpp:616
sycl::_V1::opencl::cl_float
float cl_float
Definition: aliases.hpp:139
sycl::_V1::detail::select_cl_scalar_complex_or_T
Definition: generic_type_traits.hpp:489
sycl::_V1::detail::is_igeninteger8bit
is_gen_based_on_type_sizeof< T, 1, is_igeninteger > is_igeninteger8bit
Definition: generic_type_traits.hpp:206
sycl::_V1::detail::TryToGetPointerT
Definition: generic_type_traits.hpp:338
sycl::_V1::detail::is_genfloatptr_marray
std::bool_constant< is_mgenfloat< T >::value &&is_address_space_compliant< multi_ptr< T, AddressSpace, IsDecorated >, gvl::nonconst_address_space_list >::value &&(IsDecorated==access::decorated::yes||IsDecorated==access::decorated::no)> is_genfloatptr_marray
Definition: generic_type_traits.hpp:268
sycl::_V1::pointer_t
typename detail::LegacyPointerTypes< ElementType, Space >::pointer_t pointer_t
Definition: multi_ptr.hpp:758
min
simd< _Tp, _Abi > min(const simd< _Tp, _Abi > &, const simd< _Tp, _Abi > &) noexcept
sycl::_V1::detail::SelectMatchingOpenCLType_t
typename select_cl_mptr_or_vector_or_scalar_or_ptr< T >::type SelectMatchingOpenCLType_t
Definition: generic_type_traits.hpp:608
type_list.hpp
sycl::_V1::access::address_space
address_space
Definition: access.hpp:51