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 
12 #include <sycl/access/access.hpp>
13 #include <sycl/aliases.hpp>
14 #include <sycl/detail/common.hpp>
17 #include <sycl/half_type.hpp>
18 #include <sycl/multi_ptr.hpp>
19 
20 #include <complex>
21 #include <limits>
22 
23 namespace sycl {
25 namespace detail {
26 
27 template <typename T> using is_floatn = is_contained<T, gtl::vector_float_list>;
28 
29 template <typename T> using is_genfloatf = is_contained<T, gtl::float_list>;
30 
31 template <typename T>
33 
34 template <typename T>
36 
37 template <typename T> using is_genfloatd = is_contained<T, gtl::double_list>;
38 
39 template <typename T>
41 
42 template <typename T> using is_halfn = is_contained<T, gtl::vector_half_list>;
43 
44 template <typename T> using is_genfloath = is_contained<T, gtl::half_list>;
45 
46 template <typename T> using is_half = is_contained<T, gtl::scalar_half_list>;
47 
48 template <typename T>
50 
51 template <typename T> using is_genfloat = is_contained<T, gtl::floating_list>;
52 
53 template <typename T>
55 
56 template <typename T>
58 
59 template <typename T>
61 
62 template <typename T> using marray_element_type = typename T::value_type;
63 
64 template <typename T>
66  std::is_same<T, sycl::marray<marray_element_type<T>, T::size()>>::value &&
68 
69 template <typename T>
71 
72 template <typename T>
74 
75 template <typename T> using is_gengeohalf = is_contained<T, gtl::geo_half_list>;
76 
77 template <typename T>
79 
80 template <typename T>
82 
83 template <typename T>
85 
86 template <typename T> using is_sgengeo = is_contained<T, gtl::scalar_geo_list>;
87 
88 template <typename T> using is_vgengeo = is_contained<T, gtl::vector_geo_list>;
89 
90 template <typename T>
92 
93 template <typename T>
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> using is_genchar = is_contained<T, gtl::char_list>;
118 
119 template <typename T>
121 
122 template <typename T>
124 
125 template <typename T>
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> using is_genint = is_contained<T, gtl::signed_int_list>;
141 
142 template <typename T>
144 
145 template <typename T>
147 
148 template <typename T>
150 
151 template <typename T>
153 
154 template <typename T>
156 
157 template <typename T>
159 
160 template <typename T> using is_geninteger = is_contained<T, gtl::integer_list>;
161 
162 template <typename T>
164 
165 template <typename T>
167 
168 template <typename T>
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> using is_genbool = is_contained<T, gtl::bool_list>;
187 
188 template <typename T> using is_gentype = is_contained<T, gtl::basic_list>;
189 
190 template <typename T>
192 
193 template <typename T>
195 
196 template <typename T>
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>
236 
237 template <typename T>
241 
242 template <typename T>
243 using is_genptr = bool_constant<
246 
247 template <typename T> using is_nan_type = is_contained<T, gtl::nan_list>;
248 
249 // nan_types
250 template <typename T, typename Enable = void> struct nan_types;
251 
252 template <typename T>
253 struct nan_types<
254  T, enable_if_t<is_contained<T, gtl::unsigned_short_list>::value, T>> {
257 };
258 
259 template <typename T>
260 struct nan_types<
261  T, enable_if_t<is_contained<T, gtl::unsigned_int_list>::value, T>> {
264 };
265 
266 template <typename T>
267 struct nan_types<
268  T,
271  using arg_type =
273 };
274 
275 template <typename T> using nan_return_t = typename nan_types<T, T>::ret_type;
276 
277 template <typename T>
279 
280 template <typename T>
282 
283 template <typename T>
285 
286 template <typename T>
289 
290 template <typename T, typename B, typename Enable = void>
292 
293 template <typename T, typename B>
294 struct convert_data_type_impl<T, B, enable_if_t<is_sgentype<T>::value, T>> {
295  B operator()(T t) { return static_cast<B>(t); }
296 };
297 
298 template <typename T, typename B>
299 struct convert_data_type_impl<T, B, enable_if_t<is_vgentype<T>::value, T>> {
300  vec<B, T::size()> operator()(T t) { return t.template convert<B>(); }
301 };
302 
303 template <typename T, typename B>
305 
306 // TryToGetPointerT<T>::type is T::pointer_t (legacy) or T::pointer if those
307 // exist, otherwise T.
308 template <typename T> class TryToGetPointerT {
309  static T check(...);
310  template <typename A> static typename A::pointer_t check(const A &);
311  template <typename A> static typename A::pointer check(const A &);
312 
313 public:
314  using type = decltype(check(T()));
315  static constexpr bool value =
316  std::is_pointer<T>::value || !std::is_same<T, type>::value;
317 };
318 
319 // TryToGetElementType<T>::type is T::element_type or T::value_type if those
320 // exist, otherwise T.
321 template <typename T> class TryToGetElementType {
322  static T check(...);
323  template <typename A> static typename A::element_type check(const A &);
324  template <typename A> static typename A::value_type check(const A &);
325 
326 public:
327  using type = decltype(check(T()));
328  static constexpr bool value = !std::is_same<T, type>::value;
329 };
330 
331 // TryToGetVectorT<T>::type is T::vector_t if that exists, otherwise T.
332 template <typename T> class TryToGetVectorT {
333  static T check(...);
334  template <typename A> static typename A::vector_t check(const A &);
335 
336 public:
337  using type = decltype(check(T()));
338  static constexpr bool value = !std::is_same<T, type>::value;
339 };
340 
341 // Try to get pointer_t (if pointer_t indicates on the type with_remainder
342 // vector_t creates a pointer type on vector_t), otherwise T
343 template <typename T> class TryToGetPointerVecT {
344  static T check(...);
345  template <typename A>
346  static typename DecoratedType<
349  check(const A &);
350  template <typename A>
351  static typename TryToGetVectorT<A>::type *check(const A *);
352 
353 public:
354  using type = decltype(check(T()));
355 };
356 
357 template <typename To> struct PointerConverter {
358  template <typename From> static To Convert(From *t) {
359  return reinterpret_cast<To>(t);
360  }
361 
362  template <typename From> static To Convert(From &t) {
363  // TODO find the better way to get the pointer to underlying data from vec
364  // class
365  return reinterpret_cast<To>(t.get());
366  }
367 };
368 
369 template <typename ElementType, access::address_space Space,
370  access::decorated DecorateAddress>
371 struct PointerConverter<multi_ptr<ElementType, Space, DecorateAddress>> {
372  template <typename From>
374  return address_space_cast<Space, DecorateAddress>(
375  reinterpret_cast<remove_decoration_t<From *>>(t));
376  }
377 
378  template <typename From>
380  return address_space_cast<Space, DecorateAddress>(
381  reinterpret_cast<remove_decoration_t<decltype(t.get())>>(t.get()));
382  }
383 
384  template <typename From>
387  return t;
388  }
389 };
390 
391 template <
392  typename To, typename From,
394 To ConvertNonVectorType(From &t) {
396 }
397 
398 template <typename To, typename From> To ConvertNonVectorType(From *t) {
400 }
401 
402 template <typename To, typename From>
405  return static_cast<To>(t);
406 }
407 
408 template <typename T, typename = void> struct mptr_or_vec_elem_type {
409  using type = typename T::element_type;
410 };
411 template <typename ElementType, access::address_space Space,
412  access::decorated IsDecorated>
414  multi_ptr<ElementType, Space, IsDecorated>,
415  std::enable_if_t<IsDecorated == access::decorated::no ||
416  IsDecorated == access::decorated::yes>> {
418 };
419 template <typename ElementType, access::address_space Space,
420  access::decorated IsDecorated>
421 struct mptr_or_vec_elem_type<const multi_ptr<ElementType, Space, IsDecorated>>
422  : mptr_or_vec_elem_type<multi_ptr<ElementType, Space, IsDecorated>> {};
423 
424 template <typename T>
426 
427 // select_apply_cl_scalar_t selects from T8/T16/T32/T64 basing on
428 // sizeof(IN). expected to handle scalar types.
429 template <typename T, typename T8, typename T16, typename T32, typename T64>
431  conditional_t<sizeof(T) == 1, T8,
432  conditional_t<sizeof(T) == 2, T16,
433  conditional_t<sizeof(T) == 4, T32, T64>>>;
434 
435 // Shortcuts for selecting scalar int/unsigned int/fp type.
436 template <typename T>
440 
441 template <typename T>
445 
446 template <typename T>
450 
451 template <typename T>
453  std::is_same<T, std::complex<float>>::value, __spv::complex_float,
455  std::is_same<T, std::complex<double>>::value, __spv::complex_double,
456  std::conditional_t<std::is_same<T, std::complex<half>>::value,
458 
459 template <typename T>
464 
465 // select_cl_scalar_t picks corresponding cl_* type for input
466 // scalar T or returns T if T is not scalar.
467 template <typename T>
469  std::is_integral<T>::value, select_cl_scalar_integral_t<T>,
471  // half is a special case: it is implemented differently on
472  // host and device and therefore, might lower to different
473  // types
477 
478 // select_cl_vector_or_scalar_or_ptr does cl_* type selection for element type
479 // of a vector type T, pointer type substitution, and scalar type substitution.
480 // If T is not vector, scalar, or pointer unmodified T is returned.
481 template <typename T, typename Enable = void>
483 
484 template <typename T>
486  T, typename detail::enable_if_t<is_vgentype<T>::value>> {
487  using type =
488  // select_cl_scalar_t returns _Float16, so, we try to instantiate vec
489  // class with _Float16 DataType, which is not expected there
490  // So, leave vector<half, N> as-is
494  T::size()>;
495 };
496 
497 template <typename T>
499  T, typename detail::enable_if_t<!is_vgentype<T>::value &&
500  !std::is_pointer<T>::value>> {
502 };
503 
504 template <typename T>
506  T, typename detail::enable_if_t<!is_vgentype<T>::value &&
507  std::is_pointer<T>::value>> {
509  std::remove_pointer_t<T>>::type *;
510 #ifdef __SYCL_DEVICE_ONLY__
512 #else
514 #endif
515 };
516 
517 // select_cl_mptr_or_vector_or_scalar_or_ptr does cl_* type selection for type
518 // pointed by multi_ptr, for raw pointers, for element type of a vector type T,
519 // and does scalar type substitution. If T is not mutlti_ptr or vector or
520 // scalar or pointer unmodified T is returned.
521 template <typename T, typename Enable = void>
523 
524 // this struct helps to use std::uint8_t instead of std::byte,
525 // which is not supported on device
526 template <typename T> struct TypeHelper {
527  using RetType = T;
528 };
529 
530 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
531 template <> struct TypeHelper<std::byte> {
532  using RetType = std::uint8_t;
533 };
534 #endif
535 
536 template <typename T> using type_helper = typename TypeHelper<T>::RetType;
537 
538 template <typename T>
540  T, typename detail::enable_if_t<is_genptr<T>::value &&
541  !std::is_pointer<T>::value>> {
544  T::address_space, access::decorated::yes>;
545 };
546 
547 template <typename T>
549  T, typename detail::enable_if_t<!is_genptr<T>::value ||
550  std::is_pointer<T>::value>> {
552 };
553 
554 // All types converting shortcut.
555 template <typename T>
558 
559 // Converts T to OpenCL friendly
560 //
561 template <typename T /* MatchingOpencCLTypeT */>
566 template <typename T>
567 using ConvertToOpenCLType_t =
569 
570 // convertDataToType() function converts data from FROM type to TO type using
571 // 'as' method for vector type and copy otherwise.
572 template <typename FROM, typename TO>
575  sizeof(TO) == sizeof(FROM),
576  TO>
578  return t.template as<TO>();
579 }
580 
581 template <typename FROM, typename TO>
582 typename detail::enable_if_t<!(is_vgentype<FROM>::value &&
583  is_vgentype<TO>::value) &&
584  sizeof(TO) == sizeof(FROM),
585  TO>
587  return ConvertNonVectorType<TO>(t);
588 }
589 
590 // Used for all, any and select relational built-in functions
591 template <typename T> inline constexpr T msbMask(T) {
592  using UT = make_unsigned_t<T>;
593  return T(UT(1) << (sizeof(T) * 8 - 1));
594 }
595 
596 template <typename T> inline constexpr bool msbIsSet(const T x) {
597  return (x & msbMask(x));
598 }
599 
600 #if defined(SYCL2020_CONFORMANT_APIS) && SYCL_LANGUAGE_VERSION >= 202001
601 // SYCL 2020 4.17.9 (Relation functions), e.g. table 178
602 //
603 // genbool isequal (genfloatf x, genfloatf y)
604 // genbool isequal (genfloatd x, genfloatd y)
605 //
606 // TODO: marray support isn't implemented yet.
607 template <typename T>
608 using common_rel_ret_t =
609  conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, bool>;
610 
611 // TODO: Remove this when common_rel_ret_t is promoted.
612 template <typename T>
614  conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, int>;
615 #else
616 // SYCL 1.2.1 4.13.7 (Relation functions), e.g.
617 //
618 // igeninteger32bit isequal (genfloatf x, genfloatf y)
619 // igeninteger64bit isequal (genfloatd x, genfloatd y)
620 //
621 // However, we have pre-existing bug so
622 //
623 // igeninteger32bit isequal (genfloatd x, genfloatd y)
624 //
625 // Fixing it would be an ABI-breaking change so isn't done.
626 template <typename T>
627 using common_rel_ret_t =
629 template <typename T> using internal_host_rel_ret_t = common_rel_ret_t<T>;
630 #endif
631 
632 // forward declaration
633 template <int N> struct Boolean;
634 
635 // Try to get vector element count or 1 otherwise
636 template <typename T, typename Enable = void> struct TryToGetNumElements;
637 
638 template <typename T>
640  T, typename detail::enable_if_t<TryToGetVectorT<T>::value>> {
641  static constexpr int value = T::size();
642 };
643 template <typename T>
645  T, typename detail::enable_if_t<!TryToGetVectorT<T>::value>> {
646  static constexpr int value = 1;
647 };
648 
649 // Used for relational comparison built-in functions
650 template <typename T> struct RelationalReturnType {
651 #ifdef __SYCL_DEVICE_ONLY__
653 #else
654  // After changing the return type of scalar relational operations to boolean
655  // we keep the old representation of the internal implementation of the
656  // host-side builtins to avoid ABI-breaks.
657  // TODO: Use common_rel_ret_t when ABI break is allowed and the boolean return
658  // type for relationals are promoted out of SYCL2020_CONFORMANT_APIS.
659  // The scalar relational builtins in
660  // sycl/source/detail/builtins_relational.cpp should likewise be updated
661  // to return boolean values.
663 #endif
664 };
665 
666 // Type representing the internal return type of relational builtins.
667 template <typename T>
669 
670 // Used for any and all built-in functions
671 template <typename T> struct RelationalTestForSignBitType {
672 #ifdef __SYCL_DEVICE_ONLY__
675 #else
676  using return_type = int;
677  using argument_type = T;
678 #endif
679 };
680 
681 template <typename T>
684 
685 template <typename T>
688 
689 template <typename T, typename Enable = void> struct RelConverter;
690 
691 template <typename T>
693  T, typename detail::enable_if_t<TryToGetElementType<T>::value>> {
694  static const int N = T::size();
695 #ifdef __SYCL_DEVICE_ONLY__
696  using bool_t = typename Boolean<N>::vector_t;
697  using ret_t = common_rel_ret_t<T>;
698 #else
701 #endif
702 
703  static ret_t apply(bool_t value) {
704 #ifdef __SYCL_DEVICE_ONLY__
705  typename ret_t::vector_t result(0);
706  for (size_t I = 0; I < N; ++I) {
707  result[I] = value[I];
708  }
709  return result;
710 #else
711  return value;
712 #endif
713  }
714 };
715 
716 template <typename T>
718  T, typename detail::enable_if_t<!TryToGetElementType<T>::value>> {
720 #ifdef __SYCL_DEVICE_ONLY__
721  using value_t = bool;
722 #else
723  using value_t = R;
724 #endif
725 
726  static R apply(value_t value) { return value; }
727 };
728 
729 template <typename T> static constexpr T max_v() {
730  return (std::numeric_limits<T>::max)();
731 }
732 
733 template <typename T> static constexpr T min_v() {
734  return (std::numeric_limits<T>::min)();
735 }
736 
737 template <typename T> static constexpr T quiet_NaN() {
739 }
740 
741 // is_same_vector_size
742 template <int FirstSize, typename... Args> class is_same_vector_size_impl;
743 
744 template <int FirstSize, typename T, typename... Args>
745 class is_same_vector_size_impl<FirstSize, T, Args...> {
746  using CurrentT = detail::remove_pointer_t<T>;
747  static constexpr int Size = vector_size<CurrentT>::value;
748  static constexpr bool IsSizeEqual = (Size == FirstSize);
749 
750 public:
751  static constexpr bool value =
752  IsSizeEqual ? is_same_vector_size_impl<FirstSize, Args...>::value : false;
753 };
754 
755 template <int FirstSize>
756 class is_same_vector_size_impl<FirstSize> : public std::true_type {};
757 
758 template <typename T, typename... Args> class is_same_vector_size {
759  using CurrentT = remove_pointer_t<T>;
760  static constexpr int Size = vector_size<CurrentT>::value;
761 
762 public:
763  static constexpr bool value = is_same_vector_size_impl<Size, Args...>::value;
764 };
765 
766 // check_vector_size
767 template <typename... Args> inline void check_vector_size() {
769  "The built-in function arguments must [point to|have] types "
770  "with the same number of elements.");
771 }
772 
773 } // namespace detail
774 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
775 } // namespace sycl
sycl::_V1::detail::nan_types< T, 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:270
sycl::_V1::detail::PointerConverter::Convert
static To Convert(From &t)
Definition: generic_type_traits.hpp:362
sycl::_V1::detail::mptr_or_vec_elem_type
Definition: generic_type_traits.hpp:408
sycl::_V1::detail::select_cl_mptr_or_vector_or_scalar_or_ptr< T, typename detail::enable_if_t<!is_genptr< T >::value||std::is_pointer< T >::value > >::type
typename select_cl_vector_or_scalar_or_ptr< T >::type type
Definition: generic_type_traits.hpp:551
sycl::_V1::detail::is_pointer
Definition: type_traits.hpp:284
sycl::_V1::detail::check_vector_size
void check_vector_size()
Definition: generic_type_traits.hpp:767
sycl::_V1::opencl::cl_int
std::int32_t cl_int
Definition: aliases.hpp:136
sycl::_V1::multi_ptr::value_type
ElementType value_type
Definition: multi_ptr.hpp:88
sycl::_V1::detail::is_ugeninteger64bit
is_gen_based_on_type_sizeof< T, 8, is_ugeninteger > is_ugeninteger64bit
Definition: generic_type_traits.hpp:218
sycl::_V1::opencl::cl_uint
std::uint32_t cl_uint
Definition: aliases.hpp:137
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:444
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:284
sycl::_V1::detail::PointerConverter
Definition: generic_type_traits.hpp:357
sycl::_V1::detail::nan_types< T, 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:256
sycl::_V1::detail::nan_types
Definition: generic_type_traits.hpp:250
sycl::_V1::detail::convertDataToType
detail::enable_if_t<!(is_vgentype< FROM >::value &&is_vgentype< TO >::value) &&sizeof(TO)==sizeof(FROM), TO > convertDataToType(FROM t)
Definition: generic_type_traits.hpp:586
sycl::_V1::detail::is_same_vector_size_impl
Definition: generic_type_traits.hpp:742
sycl::_V1::detail::is_igeninteger64bit
is_gen_based_on_type_sizeof< T, 8, is_igeninteger > is_igeninteger64bit
Definition: generic_type_traits.hpp:206
sycl::_V1::detail::select_cl_mptr_or_vector_or_scalar_or_ptr
Definition: generic_type_traits.hpp:522
sycl::_V1::detail::RelConverter< T, typename detail::enable_if_t< TryToGetElementType< T >::value > >::ret_t
internal_rel_ret_t< T > ret_t
Definition: generic_type_traits.hpp:700
type_traits.hpp
sycl::_V1::detail::gtl::unsigned_long_integer_list
type_list< scalar_unsigned_long_integer_list, vector_unsigned_long_integer_list, marray_unsigned_long_integer_list > unsigned_long_integer_list
Definition: generic_type_lists.hpp:394
sycl::_V1::detail::select_apply_cl_scalar_t
conditional_t< sizeof(T)==1, T8, conditional_t< sizeof(T)==2, T16, conditional_t< sizeof(T)==4, T32, T64 > >> select_apply_cl_scalar_t
Definition: generic_type_traits.hpp:433
sycl::_V1::detail::select_cl_scalar_integral_t
conditional_t< std::is_signed< T >::value, select_cl_scalar_integral_signed_t< T >, select_cl_scalar_integral_unsigned_t< T > > select_cl_scalar_integral_t
Definition: generic_type_traits.hpp:463
sycl::_V1::detail::RelConverter< T, typename detail::enable_if_t<!TryToGetElementType< T >::value > >::value_t
R value_t
Definition: generic_type_traits.hpp:723
sycl::_V1::detail::type_helper
typename TypeHelper< T >::RetType type_helper
Definition: generic_type_traits.hpp:536
sycl::_V1::detail::RelConverter< T, typename detail::enable_if_t< TryToGetElementType< T >::value > >::apply
static ret_t apply(bool_t value)
Definition: generic_type_traits.hpp:703
sycl::_V1::detail::is_ugeninteger8bit
is_gen_based_on_type_sizeof< T, 1, is_ugeninteger > is_ugeninteger8bit
Definition: generic_type_traits.hpp:209
sycl::_V1::detail::is_geninteger16bit
is_gen_based_on_type_sizeof< T, 2, is_geninteger > is_geninteger16bit
Definition: generic_type_traits.hpp:224
sycl::_V1::detail::marray_element_type
typename T::value_type marray_element_type
Definition: generic_type_traits.hpp:62
sycl::_V1::opencl::cl_ushort
std::uint16_t cl_ushort
Definition: aliases.hpp:135
__SYCL_INLINE_VER_NAMESPACE
#define __SYCL_INLINE_VER_NAMESPACE(X)
Definition: defines_elementary.hpp:11
sycl::_V1::detail::TypeHelper::RetType
T RetType
Definition: generic_type_traits.hpp:527
sycl::_V1::opencl::cl_uchar
std::uint8_t cl_uchar
Definition: aliases.hpp:133
sycl::_V1::opencl::cl_ulong
std::uint64_t cl_ulong
Definition: aliases.hpp:139
sycl::_V1::detail::msbIsSet
constexpr bool msbIsSet(const T x)
Definition: generic_type_traits.hpp:596
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:439
sycl::_V1::detail::is_gen_based_on_type_sizeof
bool_constant< S< T >::value &&(sizeof(vector_element_t< T >)==N)> is_gen_based_on_type_sizeof
Definition: type_traits.hpp:220
sycl::_V1::detail::nan_types< T, 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:263
sycl::_V1::detail::nan_types< T, 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:255
sycl::_V1::detail::quiet_NaN
static constexpr T quiet_NaN()
Definition: generic_type_traits.hpp:737
sycl::_V1::detail::TryToGetPointerVecT::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:354
sycl::_V1::byte
unsigned char byte
Definition: image.hpp:63
sycl
---— Error handling, matching OpenCL plugin semantics.
Definition: access.hpp:14
bool_constant
max
simd< _Tp, _Abi > max(const simd< _Tp, _Abi > &, const simd< _Tp, _Abi > &) noexcept
sycl::_V1::detail::TryToGetNumElements
Definition: generic_type_traits.hpp:636
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:417
sycl::_V1::detail::is_genfloatptr
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:240
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr
Definition: generic_type_traits.hpp:482
sycl::_V1::detail::min_v
static constexpr T min_v()
Definition: generic_type_traits.hpp:733
sycl::_V1::opencl::cl_short
std::int16_t cl_short
Definition: aliases.hpp:134
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:386
generic_type_lists.hpp
sycl::_V1::detail::RelConverter< T, typename detail::enable_if_t<!TryToGetElementType< T >::value > >::apply
static R apply(value_t value)
Definition: generic_type_traits.hpp:726
sycl::_V1::remove_decoration_t
typename remove_decoration< T >::type remove_decoration_t
Definition: access.hpp:309
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr< T, typename detail::enable_if_t<!is_vgentype< T >::value &&std::is_pointer< T >::value > >::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:509
sycl::_V1::detail::enable_if_t
typename std::enable_if< B, T >::type enable_if_t
Definition: stl_type_traits.hpp:24
sycl::_V1::detail::make_type_t
typename make_type_impl< T, TL >::type make_type_t
Definition: type_traits.hpp:334
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:687
sycl::_V1::detail::make_unsigned_t
typename make_unsigned< T >::type make_unsigned_t
Definition: type_traits.hpp:215
sycl::_V1::detail::remove_pointer_t
typename remove_pointer< T >::type remove_pointer_t
Definition: type_traits.hpp:304
sycl::_V1::detail::is_igeninteger16bit
is_gen_based_on_type_sizeof< T, 2, is_igeninteger > is_igeninteger16bit
Definition: generic_type_traits.hpp:200
sycl::_V1::detail::Boolean
Definition: boolean.hpp:46
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::internal_rel_ret_t
typename RelationalReturnType< T >::type internal_rel_ret_t
Definition: generic_type_traits.hpp:668
sycl::_V1::detail::make_floating_point_t
make_type_t< T, gtl::scalar_floating_list > make_floating_point_t
Definition: generic_type_traits.hpp:281
sycl::_V1::detail::change_base_type_t
typename change_base_type< T, B >::type change_base_type_t
Definition: type_traits.hpp:124
sycl::_V1::opencl::cl_char
std::int8_t cl_char
Definition: aliases.hpp:132
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr< T, typename detail::enable_if_t<!is_vgentype< T >::value &&!std::is_pointer< T >::value > >::type
select_cl_scalar_t< T > type
Definition: generic_type_traits.hpp:501
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:425
sycl::_V1::detail::RelationalReturnType
Definition: generic_type_traits.hpp:650
sycl::_V1::detail::internal_host_rel_ret_t
common_rel_ret_t< T > internal_host_rel_ret_t
Definition: generic_type_traits.hpp:629
sycl::_V1::opencl::cl_long
std::int64_t cl_long
Definition: aliases.hpp:138
sycl::_V1::detail::RelationalReturnType::type
internal_host_rel_ret_t< T > type
Definition: generic_type_traits.hpp:662
multi_ptr.hpp
sycl::_V1::detail::TryToGetElementType
Definition: generic_type_traits.hpp:321
sycl::_V1::detail::select_cl_vector_or_scalar_or_ptr< T, typename detail::enable_if_t<!is_vgentype< T >::value &&std::is_pointer< T >::value > >::type
elem_ptr_type type
Definition: generic_type_traits.hpp:513
common.hpp
sycl::_V1::detail::convert_data_type_impl
Definition: generic_type_traits.hpp:291
sycl::_V1::detail::nan_types< T, 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:262
sycl::_V1::detail::msbMask
constexpr T msbMask(T)
Definition: generic_type_traits.hpp:591
sycl::_V1::detail::is_genptr
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:245
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:125
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:288
sycl::_V1::detail::RelationalTestForSignBitType::return_type
int return_type
Definition: generic_type_traits.hpp:676
sycl::_V1::detail::RelConverter< T, typename detail::enable_if_t<!TryToGetElementType< T >::value > >::R
internal_rel_ret_t< T > R
Definition: generic_type_traits.hpp:719
sycl::_V1::half
sycl::detail::half_impl::half half
Definition: aliases.hpp:103
__spv::complex_float
Definition: spirv_types.hpp:134
sycl::_V1::detail::gtl::unsigned_int_list
type_list< scalar_unsigned_int_list, vector_unsigned_int_list, marray_unsigned_int_list > unsigned_int_list
Definition: generic_type_lists.hpp:267
sycl::_V1::opencl::cl_half
half cl_half
Definition: aliases.hpp:140
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:683
sycl::_V1::detail::RelationalTestForSignBitType::argument_type
T argument_type
Definition: generic_type_traits.hpp:677
sycl::_V1::detail::gtl::unsigned_short_list
type_list< scalar_unsigned_short_list, vector_unsigned_short_list, marray_unsigned_short_list > unsigned_short_list
Definition: generic_type_lists.hpp:226
sycl::_V1::detail::TryToGetVectorT::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:337
sycl::_V1::detail::TypeHelper
Definition: generic_type_traits.hpp:526
sycl::_V1::detail::ConvertNonVectorType
detail::enable_if_t<!TryToGetPointerT< From >::value, To > ConvertNonVectorType(From &t)
Definition: generic_type_traits.hpp:404
sycl::_V1::access::decorated
decorated
Definition: access.hpp:59
sycl::_V1::detail::TryToGetPointerVecT
Definition: generic_type_traits.hpp:343
sycl::_V1::detail::Boolean< 1 >
Definition: boolean.hpp:103
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:409
sycl::_V1::detail::TryToGetPointerT::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:314
sycl::_V1::detail::nan_return_t
typename nan_types< T, T >::ret_type nan_return_t
Definition: generic_type_traits.hpp:275
sycl::_V1::detail::common_rel_ret_t
conditional_t< is_vgentype< T >::value, make_singed_integer_t< T >, int > common_rel_ret_t
Definition: generic_type_traits.hpp:628
sycl::_V1::detail::is_geninteger64bit
is_gen_based_on_type_sizeof< T, 8, is_geninteger > is_geninteger64bit
Definition: generic_type_traits.hpp:230
sycl::_V1::detail::convert_data_type_impl< T, B, enable_if_t< is_sgentype< T >::value, T > >::operator()
B operator()(T t)
Definition: generic_type_traits.hpp:295
sycl::_V1::detail::TryToGetElementType::type
decltype(check(T())) type
Definition: generic_type_traits.hpp:327
sycl::_V1::detail::RelConverter
Definition: generic_type_traits.hpp:689
sycl::_V1::detail::is_address_space_compliant
Definition: type_traits.hpp:320
sycl::_V1::vec
Provides a cross-patform vector class template that works efficiently on SYCL devices as well as in h...
Definition: aliases.hpp:20
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:449
std
Definition: accessor.hpp:3230
sycl::_V1::detail::TypeHelper< std::byte >::RetType
std::uint8_t RetType
Definition: generic_type_traits.hpp:532
sycl::_V1::detail::PointerConverter< multi_ptr< ElementType, Space, DecorateAddress > >::Convert
static multi_ptr< ElementType, Space, DecorateAddress > Convert(From *t)
Definition: generic_type_traits.hpp:373
sycl::_V1::detail::max_v
static constexpr T max_v()
Definition: generic_type_traits.hpp:729
sycl::_V1::detail::is_geninteger8bit
is_gen_based_on_type_sizeof< T, 1, is_geninteger > is_geninteger8bit
Definition: generic_type_traits.hpp:221
sycl::_V1::detail::is_contained
Definition: type_list.hpp:54
sycl::_V1::detail::is_same_vector_size
Definition: generic_type_traits.hpp:758
sycl::_V1::detail::convert_data_type_impl< T, B, enable_if_t< is_vgentype< T >::value, T > >::operator()
vec< B, T::size()> operator()(T t)
Definition: generic_type_traits.hpp:300
sycl::_V1::detail::half_impl::BIsRepresentationT
half BIsRepresentationT
Definition: half_type.hpp:249
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:215
sycl::_V1::detail::select_cl_scalar_t
conditional_t< std::is_integral< T >::value, select_cl_scalar_integral_t< T >, conditional_t< std::is_floating_point< T >::value, select_cl_scalar_float_t< T >, conditional_t< std::is_same< T, half >::value, sycl::detail::half_impl::BIsRepresentationT, select_cl_scalar_complex_or_T_t< T > >> > select_cl_scalar_t
Definition: generic_type_traits.hpp:476
aliases.hpp
sycl::_V1::detail::is_genintptr
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:235
sycl::_V1::detail::DecoratedType
Definition: access.hpp:152
sycl::_V1::detail::ConvertToOpenCLType_t
ConvertToOpenCLTypeImpl_t< SelectMatchingOpenCLType_t< T > > ConvertToOpenCLType_t
Definition: generic_type_traits.hpp:568
sycl::_V1::detail::is_igeninteger32bit
is_gen_based_on_type_sizeof< T, 4, is_igeninteger > is_igeninteger32bit
Definition: generic_type_traits.hpp:203
sycl::_V1::detail::PointerConverter::Convert
static To Convert(From *t)
Definition: generic_type_traits.hpp:358
sycl::_V1::detail::nan_argument_base_t
typename nan_types< T, T >::arg_type nan_argument_base_t
Definition: generic_type_traits.hpp:278
sycl::_V1::opencl::cl_double
double cl_double
Definition: aliases.hpp:142
__spv::complex_double
Definition: spirv_types.hpp:141
sycl::_V1::detail::RelationalTestForSignBitType
Definition: generic_type_traits.hpp:671
sycl::_V1::detail::ConvertToOpenCLTypeImpl_t
conditional_t< TryToGetVectorT< T >::value, typename TryToGetVectorT< T >::type, conditional_t< TryToGetPointerT< T >::value, typename TryToGetPointerVecT< T >::type, T > > ConvertToOpenCLTypeImpl_t
Definition: generic_type_traits.hpp:565
sycl::_V1::detail::vector_size
Definition: type_traits.hpp:97
sycl::_V1::detail::is_geninteger32bit
is_gen_based_on_type_sizeof< T, 4, is_geninteger > is_geninteger32bit
Definition: generic_type_traits.hpp:227
sycl::_V1::detail::conditional_t
typename std::conditional< B, T, F >::type conditional_t
Definition: stl_type_traits.hpp:27
sycl::_V1::detail::is_ugeninteger16bit
is_gen_based_on_type_sizeof< T, 2, is_ugeninteger > is_ugeninteger16bit
Definition: generic_type_traits.hpp:212
sycl::_V1::detail::PointerConverter< multi_ptr< ElementType, Space, DecorateAddress > >::Convert
static multi_ptr< ElementType, Space, DecorateAddress > Convert(From &t)
Definition: generic_type_traits.hpp:379
sycl::_V1::detail::TryToGetVectorT
Definition: generic_type_traits.hpp:332
sycl::_V1::detail::get
Definition: tuple.hpp:59
sycl::_V1::opencl::cl_float
float cl_float
Definition: aliases.hpp:141
sycl::_V1::detail::is_mgenfloat
bool_constant< std::is_same< T, sycl::marray< marray_element_type< T >, T::size()> >::value &&is_svgenfloat< marray_element_type< T > >::value > is_mgenfloat
Definition: generic_type_traits.hpp:67
sycl::_V1::detail::is_igeninteger8bit
is_gen_based_on_type_sizeof< T, 1, is_igeninteger > is_igeninteger8bit
Definition: generic_type_traits.hpp:197
sycl::_V1::detail::nan_types< T, 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:272
sycl::_V1::detail::TryToGetPointerT
Definition: generic_type_traits.hpp:308
sycl::_V1::Space
Space
Definition: multi_ptr.hpp:1316
__spv::complex_half
Definition: spirv_types.hpp:148
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:557
spirv_types.hpp
sycl::_V1::detail::select_cl_scalar_complex_or_T_t
std::conditional_t< std::is_same< T, std::complex< float > >::value, __spv::complex_float, std::conditional_t< std::is_same< T, std::complex< double > >::value, __spv::complex_double, std::conditional_t< std::is_same< T, std::complex< half > >::value, __spv::complex_half, T > >> select_cl_scalar_complex_or_T_t
Definition: generic_type_traits.hpp:457
sycl::_V1::access::address_space
address_space
Definition: access.hpp:47