DPC++ Runtime
Runtime libraries for oneAPI DPC++
annotated_arg.hpp
Go to the documentation of this file.
1 //==----------- annotated_arg.hpp - SYCL annotated_arg extension -----------==//
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/detail/defines.hpp>
16 
17 #include <cstddef>
18 #include <type_traits>
19 #include <utility>
20 #include <variant>
21 
22 namespace sycl {
23 
24 // device_copyable trait
25 template <typename T, typename PropertyList>
27  ext::oneapi::experimental::annotated_arg<T, PropertyList>>
28  : is_device_copyable<T> {};
29 
30 inline namespace _V1 {
31 namespace ext {
32 namespace oneapi {
33 namespace experimental {
34 
35 namespace detail {
36 
37 // Type-trait for checking if a type defines `operator[]`.
38 template <typename T>
40  : std::bool_constant<
41  !std::is_void_v<decltype(std::declval<T>().operator[](0))>> {};
42 
43 } // namespace detail
44 
45 // Deduction guide
46 template <typename T, typename... Args>
47 annotated_arg(T, Args...)
48  -> annotated_arg<T, typename detail::DeducedProperties<Args...>::type>;
49 
50 template <typename T, typename old, typename... ArgT>
51 annotated_arg(annotated_arg<T, old>, properties<std::tuple<ArgT...>>)
52  -> annotated_arg<
54 
55 template <typename T, typename PropertyListT = empty_properties_t>
56 class annotated_arg {
57  // This should always fail when instantiating the unspecialized version.
58  static constexpr bool is_valid_property_list =
60  static_assert(is_valid_property_list, "Property list is invalid.");
61 };
62 
63 // Partial specialization for pointer type
64 template <typename T, typename... Props>
67  using property_list_t = detail::properties_t<Props...>;
68 
69  T *obj;
70 
71  template <typename T2, typename PropertyListT> friend class annotated_arg;
72 
73 #ifdef __SYCL_DEVICE_ONLY__
74  void __init([[__sycl_detail__::add_ir_attributes_kernel_parameter(
77  typename decorated_global_ptr<T>::pointer _obj) {
78  obj = _obj;
79  }
80 #endif
81 
82 public:
83  annotated_arg() noexcept = default;
84  annotated_arg(const annotated_arg &) = default;
85  annotated_arg &operator=(annotated_arg &) = default;
86 
87  annotated_arg(T *_ptr,
88  const property_list_t &PropList = properties{}) noexcept
89  : obj(_ptr) {
90  (void)PropList;
91  }
92 
93  // Constructs an annotated_arg object from a raw pointer and variadic
94  // properties. The new property set contains all properties of the input
95  // variadic properties. The same property in `Props...` and
96  // `PropertyValueTs...` must have the same property value.
97  template <typename... PropertyValueTs>
98  annotated_arg(T *_ptr, const PropertyValueTs &...props) noexcept : obj(_ptr) {
99  static constexpr bool has_same_properties = std::is_same<
100  property_list_t,
101  detail::merged_properties_t<property_list_t,
102  decltype(properties{props...})>>::value;
103  static_assert(
104  has_same_properties,
105  "The property list must contain all properties of the input of the "
106  "constructor");
107  }
108 
109  // Constructs an annotated_arg object from another annotated_arg object.
110  // The new property set contains all properties of the input
111  // annotated_arg object. The same property in `Props...` and `PropertyList2`
112  // must have the same property value.
113  template <typename T2, typename PropertyList2>
115  : obj(other.obj) {
116  static constexpr bool is_input_convertible =
117  std::is_convertible<T2, T *>::value;
118  static_assert(is_input_convertible,
119  "The underlying data type of the input annotated_arg is not "
120  "compatible");
121 
122  static constexpr bool has_same_properties = std::is_same<
123  property_list_t,
125  static_assert(
126  has_same_properties,
127  "The constructed annotated_arg type must contain all the properties "
128  "of the input annotated_arg");
129  }
130 
131  // Constructs an annotated_arg object from another annotated_arg object and a
132  // property list. The new property set is the union of property lists
133  // `PropertyListU` and `PropertyListV`. The same property in `PropertyListU`
134  // and `PropertyListV` must have the same property value.
135  template <typename T2, typename PropertyListU, typename PropertyListV>
137  const PropertyListV &proplist) noexcept
138  : obj(other.obj) {
139  (void)proplist;
140  static constexpr bool is_input_convertible =
141  std::is_convertible<T2, T *>::value;
142  static_assert(is_input_convertible,
143  "The underlying data type of the input annotated_arg is not "
144  "compatible");
145 
146  static constexpr bool has_same_properties = std::is_same<
147  property_list_t,
149  static_assert(
150  has_same_properties,
151  "The property list of constructed annotated_arg type must be the union "
152  "of the input property lists");
153  }
154 
155  operator T *() noexcept { return obj; }
156  operator T *() const noexcept { return obj; }
157 
158  T &operator[](std::ptrdiff_t idx) const noexcept { return obj[idx]; }
159 
160  T *operator->() const noexcept { return obj; }
161 
162  template <typename PropertyT> static constexpr bool has_property() {
163  return property_list_t::template has_property<PropertyT>();
164  }
165 
166  template <typename PropertyT> static constexpr auto get_property() {
167  return property_list_t::template get_property<PropertyT>();
168  }
169 
170  // *************************************************************************
171  // All static error checking is added here instead of placing inside neat
172  // functions to minimize the number lines printed out when an assert
173  // is triggered.
174  // static constexprs are used to ensure that the triggered assert prints
175  // a message that is very readable. Without these, the assert will
176  // print out long templated names
177  // *************************************************************************
178  static constexpr bool is_valid_property_list =
180  static_assert(is_valid_property_list, "Property list is invalid.");
181  static constexpr bool contains_valid_properties =
182  check_property_list<T *, Props...>::value;
183  static_assert(contains_valid_properties,
184  "The property list contains invalid property.");
185  // check the set if FPGA specificed properties are used
186  static constexpr bool hasValidFPGAProperties =
187  detail::checkValidFPGAPropertySet<Props...>::value;
188  static_assert(hasValidFPGAProperties,
189  "FPGA Interface properties (i.e. awidth, dwidth, etc.) "
190  "can only be set with BufferLocation together.");
191  // check if conduit and register_map properties are specified together
192  static constexpr bool hasConduitAndRegisterMapProperties =
193  detail::checkHasConduitAndRegisterMap<Props...>::value;
195  "The properties conduit and register_map cannot be "
196  "specified at the same time.");
197 };
198 
199 // Partial specialization for non-pointer type
200 template <typename T, typename... Props>
202 __SYCL_TYPE(annotated_arg) annotated_arg<T, detail::properties_t<Props...>> {
203  using property_list_t = detail::properties_t<Props...>;
204 
205  template <typename T2, typename PropertyListT> friend class annotated_arg;
206 
207  T obj;
208 
209 #ifdef __SYCL_DEVICE_ONLY__
210  void __init([[__sycl_detail__::add_ir_attributes_kernel_parameter(
213  obj = _obj;
214  }
215 #endif
216 
217 public:
218  annotated_arg() noexcept = default;
219  annotated_arg(const annotated_arg &) = default;
220  annotated_arg &operator=(annotated_arg &) = default;
221 
222  annotated_arg(const T &_obj,
223  const property_list_t &PropList = properties{}) noexcept
224  : obj(_obj) {
225  (void)PropList;
226  }
227 
228  // Constructs an annotated_arg object from a raw pointer and variadic
229  // properties. The new property set contains all properties of the input
230  // variadic properties. The same property in `Props...` and
231  // `PropertyValueTs...` must have the same property value.
232  template <typename... PropertyValueTs>
233  annotated_arg(const T &_obj, PropertyValueTs... props) noexcept : obj(_obj) {
234  static constexpr bool has_same_properties = std::is_same<
235  property_list_t,
236  detail::merged_properties_t<property_list_t,
237  decltype(properties{props...})>>::value;
238  static_assert(
239  has_same_properties,
240  "The property list must contain all properties of the input of the "
241  "constructor");
242  }
243 
244  // Constructs an annotated_arg object from another annotated_arg object.
245  // The new property set contains all properties of the input
246  // annotated_arg object. The same property in `Props...` and `PropertyList2`
247  // must have the same property value.
248  template <typename T2, typename PropertyList2>
249  explicit annotated_arg(const annotated_arg<T2, PropertyList2> &other) noexcept
250  : obj(other.obj) {
251  static constexpr bool is_input_convertible =
252  std::is_convertible<T2, T>::value;
253  static_assert(is_input_convertible,
254  "The underlying data type of the input annotated_arg is not "
255  "compatible");
256 
257  static constexpr bool has_same_properties = std::is_same<
258  property_list_t,
259  detail::merged_properties_t<property_list_t, PropertyList2>>::value;
260  static_assert(
261  has_same_properties,
262  "The constructed annotated_arg type must contain all the properties "
263  "of the input annotated_arg");
264  }
265 
266  // Constructs an annotated_arg object from another annotated_arg object and a
267  // property list. The new property set is the union of property lists
268  // `PropertyListU` and `PropertyListV`. The same property in `PropertyListU`
269  // and `PropertyListV` must have the same property value.
270  template <typename T2, typename PropertyListU, typename PropertyListV>
271  explicit annotated_arg(const annotated_arg<T2, PropertyListU> &other,
272  const PropertyListV &proplist) noexcept
273  : obj(other.obj) {
274  (void)proplist;
275  static constexpr bool is_input_convertible =
276  std::is_convertible<T2, T>::value;
277  static_assert(is_input_convertible,
278  "The underlying data type of the input annotated_arg is not "
279  "compatible");
280 
281  static constexpr bool has_same_properties = std::is_same<
282  property_list_t,
283  detail::merged_properties_t<PropertyListU, PropertyListV>>::value;
284  static_assert(
285  has_same_properties,
286  "The property list of constructed annotated_arg type must be the union "
287  "of the input property lists");
288  }
289 
290  operator T() noexcept { return obj; }
291  operator T() const noexcept { return obj; }
292 
293  template <class RelayT = T>
294  std::enable_if_t<detail::HasSubscriptOperator<RelayT>::value,
295  decltype(std::declval<RelayT>().operator[](0))> &
296  operator[](std::ptrdiff_t idx) const noexcept {
297  return obj.operator[](idx);
298  }
299 
300  template <typename PropertyT> static constexpr bool has_property() {
301  return property_list_t::template has_property<PropertyT>();
302  }
303 
304  template <typename PropertyT> static constexpr auto get_property() {
305  return property_list_t::template get_property<PropertyT>();
306  }
307 
308  template <typename T2, typename PropertyList2,
309  typename R = decltype(std::declval<T>() + std::declval<T2>())>
311  return obj + other.obj;
312  }
313 
314  template <typename T2, typename PropertyList2,
315  typename R = decltype(std::declval<T>() - std::declval<T2>())>
317  return obj - other.obj;
318  }
319 
320  template <typename T2, typename PropertyList2,
321  typename R = decltype(std::declval<T>() * std::declval<T2>())>
323  return obj * other.obj;
324  }
325 
326  template <typename T2, typename PropertyList2,
327  typename R = decltype(std::declval<T>() / std::declval<T2>())>
329  return obj / other.obj;
330  }
331 
332  template <typename T2, typename PropertyList2,
333  typename R = decltype(std::declval<T>() % std::declval<T2>())>
335  return obj % other.obj;
336  }
337 
338  template <typename T2, typename PropertyList2,
339  typename R = decltype(std::declval<T>() & std::declval<T2>())>
341  return obj & other.obj;
342  }
343 
344  template <typename T2, typename PropertyList2,
345  typename R = decltype(std::declval<T>() | std::declval<T2>())>
347  return obj | other.obj;
348  }
349 
350  template <typename T2, typename PropertyList2,
351  typename R = decltype(std::declval<T>() ^ std::declval<T2>())>
353  return obj ^ other.obj;
354  }
355 
356  template <typename T2, typename PropertyList2,
357  typename R = decltype(std::declval<T>() >> std::declval<T2>())>
359  return obj >> other.obj;
360  }
361 
362  template <typename T2, typename PropertyList2,
363  typename R = decltype(std::declval<T>() << std::declval<T2>())>
365  return obj << other.obj;
366  }
367 
368  // *************************************************************************
369  // All static error checking is added here instead of placing inside neat
370  // functions to minimize the number lines printed out when an assert
371  // is triggered.
372  // static constexprs are used to ensure that the triggered assert prints
373  // a message that is very readable. Without these, the assert will
374  // print out long templated names
375  // *************************************************************************
376  static constexpr bool is_device_copyable = is_device_copyable_v<T>;
377  static_assert(is_device_copyable, "Type T must be device copyable.");
378 
379  // check if invalid properties are specified for non pointer type
380  static constexpr bool has_buffer_location =
381  has_property<buffer_location_key>();
382  static_assert(!has_buffer_location,
383  "Property buffer_location cannot be specified for "
384  "annotated_arg<T> when T is a non pointer type.");
385 
386  static constexpr bool has_awidth = has_property<awidth_key>();
387  static_assert(!has_awidth, "Property awidth cannot be specified for "
388  "annotated_arg<T> when T is a non pointer type.");
389 
390  static constexpr bool has_dwidth = has_property<dwidth_key>();
391  static_assert(!has_dwidth, "Property dwidth cannot be specified for "
392  "annotated_arg<T> when T is a non pointer type.");
393 
394  static constexpr bool has_latency = has_property<latency_key>();
395  static_assert(!has_latency, "Property latency cannot be specified for "
396  "annotated_arg<T> when T is a non pointer type.");
397 
398  static constexpr bool has_read_write_mode =
399  has_property<read_write_mode_key>();
400  static_assert(!has_read_write_mode,
401  "Property read_write_mode cannot be specified for "
402  "annotated_arg<T> when T is a non pointer type.");
403 
404  static constexpr bool has_maxburst = has_property<maxburst_key>();
405  static_assert(!has_maxburst,
406  "Property maxburst cannot be specified for "
407  "annotated_arg<T> when T is a non pointer type.");
408 
409  static constexpr bool has_wait_request = has_property<wait_request_key>();
410  static_assert(!has_wait_request,
411  "Property wait_request cannot be specified for "
412  "annotated_arg<T> when T is a non pointer type.");
413 
414  static constexpr bool has_alignment = has_property<alignment_key>();
415  static_assert(!has_alignment,
416  "Property alignment cannot be specified for "
417  "annotated_arg<T> when T is a non pointer type.");
418 
419  static constexpr bool has_usm_kind = has_property<usm_kind_key>();
420  static_assert(!has_usm_kind,
421  "Property usm_kind cannot be specified for "
422  "annotated_arg<T> when T is a non pointer type.");
423 
424  static constexpr bool is_valid_property_list =
426  static_assert(is_valid_property_list, "Property list is invalid.");
427  static constexpr bool contains_valid_properties =
428  check_property_list<T, Props...>::value;
429  static_assert(contains_valid_properties,
430  "The property list contains invalid property.");
431  // check the set if FPGA specificed properties are used
432  static constexpr bool hasValidFPGAProperties =
433  detail::checkValidFPGAPropertySet<Props...>::value;
434  static_assert(hasValidFPGAProperties,
435  "FPGA Interface properties (i.e. awidth, dwidth, etc.) "
436  "can only be set with BufferLocation together.");
437  // check if conduit and register_map properties are specified together
438  static constexpr bool hasConduitAndRegisterMapProperties =
439  detail::checkHasConduitAndRegisterMap<Props...>::value;
441  "The properties conduit and register_map cannot be "
442  "specified at the same time.");
443 };
444 
445 template <typename T, typename PropertyList, typename T2,
446  typename R = decltype(std::declval<T>() + std::declval<T2>())>
448  T a1 = a;
449  return a1 + b;
450 }
451 
452 template <typename T, typename PropertyList, typename T2,
453  typename R = decltype(std::declval<T>() - std::declval<T2>())>
455  T a1 = a;
456  return a1 - b;
457 }
458 
459 template <typename T, typename PropertyList, typename T2,
460  typename R = decltype(std::declval<T>() * std::declval<T2>())>
462  T a1 = a;
463  return a1 * b;
464 }
465 
466 template <typename T, typename PropertyList, typename T2,
467  typename R = decltype(std::declval<T>() / std::declval<T2>())>
469  T a1 = a;
470  return a1 / b;
471 }
472 
473 template <typename T, typename PropertyList, typename T2,
474  typename R = decltype(std::declval<T>() % std::declval<T2>())>
476  T a1 = a;
477  return a1 % b;
478 }
479 
480 template <typename T, typename PropertyList, typename T2,
481  typename R = decltype(std::declval<T>() & std::declval<T2>())>
483  T a1 = a;
484  return a1 & b;
485 }
486 
487 template <typename T, typename PropertyList, typename T2,
488  typename R = decltype(std::declval<T>() | std::declval<T2>())>
490  T a1 = a;
491  return a1 | b;
492 }
493 
494 template <typename T, typename PropertyList, typename T2,
495  typename R = decltype(std::declval<T>() ^ std::declval<T2>())>
497  T a1 = a;
498  return a1 ^ b;
499 }
500 
501 template <typename T, typename PropertyList, typename T2,
502  typename R = decltype(std::declval<T>() >> std::declval<T2>())>
504  T a1 = a;
505  return a1 >> b;
506 }
507 
508 template <typename T, typename PropertyList, typename T2,
509  typename R = decltype(std::declval<T>() << std::declval<T2>())>
511  T a1 = a;
512  return a1 << b;
513 }
514 
515 template <typename T, typename T2, typename PropertyList2,
516  typename R = decltype(std::declval<T>() + std::declval<T2>())>
518  T2 b1 = b;
519  return a + b1;
520 }
521 
522 template <typename T, typename T2, typename PropertyList2,
523  typename R = decltype(std::declval<T>() - std::declval<T2>())>
525  T2 b1 = b;
526  return a - b1;
527 }
528 
529 template <typename T, typename T2, typename PropertyList2,
530  typename R = decltype(std::declval<T>() * std::declval<T2>())>
532  T2 b1 = b;
533  return a * b1;
534 }
535 
536 template <typename T, typename T2, typename PropertyList2,
537  typename R = decltype(std::declval<T>() / std::declval<T2>())>
539  T2 b1 = b;
540  return a / b1;
541 }
542 
543 template <typename T, typename T2, typename PropertyList2,
544  typename R = decltype(std::declval<T>() % std::declval<T2>())>
546  T2 b1 = b;
547  return a % b1;
548 }
549 
550 template <typename T, typename T2, typename PropertyList2,
551  typename R = decltype(std::declval<T>() & std::declval<T2>())>
553  T2 b1 = b;
554  return a & b1;
555 }
556 
557 template <typename T, typename T2, typename PropertyList2,
558  typename R = decltype(std::declval<T>() | std::declval<T2>())>
560  T2 b1 = b;
561  return a | b1;
562 }
563 
564 template <typename T, typename T2, typename PropertyList2,
565  typename R = decltype(std::declval<T>() ^ std::declval<T2>())>
567  T2 b1 = b;
568  return a ^ b1;
569 }
570 
571 template <typename T, typename T2, typename PropertyList2,
572  typename R = decltype(std::declval<T>() >> std::declval<T2>())>
574  T2 b1 = b;
575  return a >> b1;
576 }
577 
578 template <typename T, typename T2, typename PropertyList2,
579  typename R = decltype(std::declval<T>() << std::declval<T2>())>
581  T2 b1 = b;
582  return a << b1;
583 }
584 
585 } // namespace experimental
586 } // namespace oneapi
587 } // namespace ext
588 } // namespace _V1
589 } // namespace sycl
sycl::_V1::ext::oneapi::experimental::has_read_write_mode
static constexpr bool has_read_write_mode
Definition: annotated_arg.hpp:398
fpga_annotated_properties.hpp
sycl::_V1::ext::oneapi::experimental::__SYCL_TYPE
class __SYCL_SPECIAL_CLASS __SYCL_TYPE(annotated_arg) annotated_arg< T *
sycl::_V1::ext::oneapi::experimental::operator|
R operator|(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:346
sycl::_V1::ext::oneapi::experimental::operator%
R operator%(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:334
sycl::_V1::ext::oneapi::experimental::hasConduitAndRegisterMapProperties
static constexpr bool hasConduitAndRegisterMapProperties
Definition: annotated_arg.hpp:192
sycl::_V1::ext::oneapi::experimental::detail::HasSubscriptOperator
Definition: annotated_arg.hpp:39
sycl::_V1::ext::oneapi::experimental::detail::PropertyMetaInfo::value
static constexpr std::nullptr_t value
Definition: property.hpp:249
sycl::_V1::ext::oneapi::experimental::annotated_arg
Definition: fpga_annotated_properties.hpp:118
sycl::_V1::ext::oneapi::experimental::obj
T * obj
Definition: annotated_arg.hpp:69
annotated_ptr_properties.hpp
sycl::_V1::ext::oneapi::experimental::has_buffer_location
static constexpr bool has_buffer_location
Definition: annotated_arg.hpp:380
sycl::_V1::ext::oneapi::experimental::properties
Definition: properties.hpp:125
sycl::_V1::ext::oneapi::experimental::has_usm_kind
static constexpr bool has_usm_kind
Definition: annotated_arg.hpp:419
sycl::_V1::ext::oneapi::experimental::operator[]
T & operator[](std::ptrdiff_t idx) const noexcept
Definition: annotated_arg.hpp:158
sycl::_V1::ext::oneapi::experimental::operator&
R operator&(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:340
sycl
Definition: access.hpp:18
sycl::_V1::ext::oneapi::experimental::hasValidFPGAProperties
static constexpr bool hasValidFPGAProperties
Definition: annotated_arg.hpp:186
noexcept
_Abi const simd< _Tp, _Abi > & noexcept
Definition: simd.hpp:1324
sycl::_V1::ext::oneapi::experimental::operator+
R operator+(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:310
__SYCL_SPECIAL_CLASS
#define __SYCL_SPECIAL_CLASS
Definition: defines.hpp:29
sycl::_V1::ext::oneapi::experimental::detail::checkHasConduitAndRegisterMap
Definition: fpga_annotated_properties.hpp:377
sycl::_V1::is_device_copyable
is_device_copyable is a user specializable class template to indicate that a type T is device copyabl...
Definition: types.hpp:2518
sycl::_V1::ext::oneapi::experimental::detail::checkValidFPGAPropertySet
Definition: fpga_annotated_properties.hpp:361
sycl::_V1::ext::oneapi::experimental::operator*
R operator*(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:322
sycl::_V1::ext::oneapi::experimental::annotated_arg
annotated_arg(const T &_obj, PropertyValueTs... props) noexcept
Definition: annotated_arg.hpp:233
sycl::_V1::ext::oneapi::experimental::has_property
static constexpr bool has_property()
Definition: annotated_arg.hpp:162
sycl::_V1::ext::oneapi::experimental::has_maxburst
static constexpr bool has_maxburst
Definition: annotated_arg.hpp:404
properties.hpp
sycl::_V1::ext::oneapi::experimental::has_awidth
static constexpr bool has_awidth
Definition: annotated_arg.hpp:386
sycl::_V1::a
T detail::marray_element_t< T > y T T T maxval[i] T T T a
Definition: builtins_legacy_marray_vec.hpp:542
properties.hpp
defines.hpp
sycl::_V1::ext::oneapi::experimental::detail::DeducedProperties
Definition: properties.hpp:34
sycl::_V1::ext::oneapi::experimental::is_valid_property_list
static constexpr bool is_valid_property_list
Definition: annotated_arg.hpp:178
sycl::_V1::ext::oneapi::experimental::detail::merged_properties_t
typename merged_properties< LHSPropertiesT, RHSPropertiesT >::type merged_properties_t
Definition: properties.hpp:225
sycl::_V1::ext::oneapi::experimental::is_property_list
Definition: properties.hpp:193
sycl::_V1::ext::oneapi::experimental::get_property
static constexpr auto get_property()
Definition: annotated_arg.hpp:166
sycl::_V1::ext::oneapi::experimental::detail::PropertyMetaInfo
Definition: property.hpp:245
sycl::_V1::multi_ptr::pointer
std::conditional_t< is_decorated, decorated_type *, std::add_pointer_t< value_type > > pointer
Definition: multi_ptr.hpp:95
sycl::_V1::ext::oneapi::experimental::operator>>
R operator>>(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:358
sycl::_V1::ext::oneapi::experimental::check_property_list
Definition: properties.hpp:47
sycl::_V1::ext::oneapi::experimental::operator/
R operator/(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:328
sycl::_V1::b
y y maxval[j] maxval b
Definition: builtins_legacy_marray_vec.hpp:768
sycl::_V1::ext::oneapi::experimental::has_dwidth
static constexpr bool has_dwidth
Definition: annotated_arg.hpp:390
sycl::_V1::ext::oneapi::experimental::contains_valid_properties
static constexpr bool contains_valid_properties
Definition: annotated_arg.hpp:181
sycl::_V1::ext::oneapi::experimental::detail::PropertyMetaInfo::name
static constexpr const char * name
Definition: property.hpp:248
sycl::_V1::ext::oneapi::experimental::operator<<
R operator<<(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:364
sycl::_V1::ext::oneapi::experimental::detail::properties_t
properties< std::tuple< PropertyValueTs... > > properties_t
Definition: properties.hpp:212
sycl::_V1::ext::oneapi::experimental::operator->
T * operator->() const noexcept
Definition: annotated_arg.hpp:160
sycl::_V1::ext::oneapi::experimental::operator^
R operator^(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:352
sycl::_V1::ext::oneapi::experimental::annotated_arg
friend class annotated_arg
Definition: annotated_arg.hpp:71
sycl::_V1::ext::oneapi::experimental::has_alignment
static constexpr bool has_alignment
Definition: annotated_arg.hpp:414
sycl::_V1::ext::oneapi::experimental::has_wait_request
static constexpr bool has_wait_request
Definition: annotated_arg.hpp:409
sycl::_V1::ext::oneapi::experimental::has_latency
static constexpr bool has_latency
Definition: annotated_arg.hpp:394
sycl::_V1::ext::oneapi::experimental::operator-
R operator-(const annotated_arg< T2, PropertyList2 > &other) const
Definition: annotated_arg.hpp:316