DPC++ Runtime
Runtime libraries for oneAPI DPC++
sycl::_V1 Namespace Reference

Namespaces

 access
 
 detail
 
 ext
 
 half_precision
 
 info
 
 native
 
 opencl
 
 property
 
 property
 
 usm
 

Classes

struct  mode_tag_t
 
struct  mode_target_tag_t
 
struct  remove_decoration
 
struct  remove_decoration< const T >
 
struct  remove_decoration< T * >
 
struct  remove_decoration< const T * >
 
struct  remove_decoration< T & >
 
struct  remove_decoration< const T & >
 
class  accessor
 
class  local_accessor_base
 Local accessor. More...
 
class  accessor< DataT, Dimensions, AccessMode, access::target::local, IsPlaceholder >
 
class  accessor< DataT, Dimensions, AccessMode, access::target::host_image, IsPlaceholder >
 Host image accessor. More...
 
class  host_accessor
 
class  unsampled_image_accessor
 
class  host_unsampled_image_accessor
 
class  sampled_image_accessor
 
class  host_sampled_image_accessor
 
class  vec
 defined(__INTEL_PREVIEW_BREAKING_CHANGES) More...
 
class  multi_ptr
 Provides constructors for address space qualified and non address space qualified pointers to allow interoperability between plain C++ and OpenCL C. More...
 
class  atomic_ref
 
class  backend_traits
 
class  range
 Defines the iteration domain of either a single work-group in a parallel dispatch, or the overall Dimensions of the dispatch. More...
 
class  buffer
 Defines a shared array that can be used by kernels in queues. More...
 
class  context
 The context class represents a SYCL context on which kernel functions may be executed. More...
 
class  id
 A unique identifier of an item in an index space. More...
 
class  marray
 Provides a cross-platform math array class template that works on SYCL devices as well as in host C++ code. More...
 
class  item
 Identifies an instance of the function object executing at each point in a range. More...
 
class  group
 
class  nd_item
 Identifies an instance of the function object executing at each point in an nd_range. More...
 
class  h_item
 Identifies an instance of a group::parallel_for_work_item function object executing at each point in a local range passed to a parallel_for_work_item call or to the corresponding parallel_for_work_group call. More...
 
struct  is_group
 
class  device
 The SYCL device class encapsulates a single SYCL device on which kernels may be executed. More...
 
class  device_event
 Encapsulates a single SYCL device event which is available only within SYCL kernel functions and can be used to wait for asynchronous operations within a kernel function to complete. More...
 
class  accelerator_selector
 The default selector chooses the first available SYCL device. More...
 
class  event
 An event object can be used to synchronize memory transfers, enqueues of kernels and signaling barriers. More...
 
class  exception
 
class  exception_list
 A list of asynchronous exceptions. More...
 
struct  is_property< ext::codeplay::experimental::property::promote_private >
 
struct  is_property< ext::codeplay::experimental::property::promote_local >
 
struct  is_property< ext::codeplay::experimental::property::no_barriers >
 
struct  is_property< ext::codeplay::experimental::property::force_fusion >
 
struct  is_property< ext::codeplay::experimental::property::queue::enable_fusion >
 
struct  is_property_of< ext::codeplay::experimental::property::promote_private, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< ext::codeplay::experimental::property::promote_local, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< ext::codeplay::experimental::property::promote_private, accessor< DataT, Dimensions, AccessMode, AccessTarget, IsPlaceholder, PropertyListT > >
 
struct  is_property_of< ext::codeplay::experimental::property::promote_local, accessor< DataT, Dimensions, AccessMode, AccessTarget, IsPlaceholder, PropertyListT > >
 
struct  is_property_of< ext::codeplay::experimental::property::queue::enable_fusion, queue >
 
struct  is_property< ext::oneapi::property::usm::device_read_only >
 
struct  is_property< ext::intel::experimental::property::usm::buffer_location >
 
struct  is_group< ext::oneapi::experimental::ballot_group< ParentGroup > >
 
struct  is_group< ext::oneapi::experimental::fixed_size_group< PartitionSize, ParentGroup > >
 
struct  is_property< ext::oneapi::experimental::property::graph::no_cycle_check >
 
struct  is_property< ext::oneapi::experimental::property::node::depends_on >
 
struct  is_property_of< ext::oneapi::experimental::property::graph::no_cycle_check, ext::oneapi::experimental::command_graph< ext::oneapi::experimental::graph_state::modifiable > >
 
struct  is_property_of< ext::oneapi::experimental::property::node::depends_on, ext::oneapi::experimental::node >
 
struct  is_group< ext::oneapi::experimental::opportunistic_group >
 
struct  is_group< ext::oneapi::experimental::tangle_group< ParentGroup > >
 
class  nd_range
 Defines the iteration domain of both the work-groups and the overall dispatch. More...
 
struct  is_device_copyable< ext::oneapi::experimental::properties< PropertiesT > >
 
struct  logical_and
 
struct  logical_and< void >
 
struct  logical_or
 
struct  logical_or< void >
 
struct  minimum
 
struct  minimum< void >
 
struct  maximum
 
struct  maximum< void >
 
class  handler
 Command group handler class. More...
 
class  image
 Defines a shared image data. More...
 
class  unsampled_image
 
class  sampled_image
 
class  interop_handle
 
class  kernel_bundle
 The kernel_bundle class represents collection of device images in a particular state. More...
 
class  kernel
 Provides an abstraction of a SYCL kernel. More...
 
class  kernel_id
 Objects of the class identify kernel is some kernel_bundle related APIs. More...
 
class  device_image
 Objects of the class represents an instance of an image in a specific state. More...
 
struct  has_known_identity
 
struct  known_identity
 
class  local_accessor
 
class  multi_ptr< const void, Space, DecorateAddress >
 Specialization of multi_ptr for const void. More...
 
class  multi_ptr< void, Space, DecorateAddress >
 
class  platform
 Encapsulates a SYCL platform on which kernels may be executed. More...
 
class  image_accessor
 
struct  is_property< ext::oneapi::property::no_offset >
 
struct  is_property< ext::oneapi::property::no_alias >
 
struct  is_property< ext::intel::property::buffer_location >
 
struct  is_property_of< property::noinit, T >
 
struct  is_property_of< property::no_init, T >
 
struct  is_property_of< ext::oneapi::property::no_offset, T >
 
struct  is_property_of< ext::oneapi::property::no_alias, T >
 
struct  is_property_of< ext::intel::property::buffer_location, T >
 
struct  is_property_of< property::buffer::use_host_ptr, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< property::buffer::use_mutex, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< property::buffer::detail::buffer_location, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< property::buffer::context_bound, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< property::buffer::mem_channel, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< ext::oneapi::property::buffer::use_pinned_host_memory, buffer< T, Dimensions, AllocatorT, void > >
 
struct  is_property_of< property::context::cuda::use_primary_context, context >
 
struct  is_property_of< ext::oneapi::cuda::property::context::use_primary_context, context >
 
struct  is_property_of< property::image::use_host_ptr, image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::use_mutex, image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::context_bound, image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::use_host_ptr, sampled_image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::use_mutex, sampled_image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::context_bound, sampled_image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::use_host_ptr, unsampled_image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::use_mutex, unsampled_image< Dimensions, AllocatorT > >
 
struct  is_property_of< property::image::context_bound, unsampled_image< Dimensions, AllocatorT > >
 
struct  is_property
 
struct  is_property_of
 
class  property_list
 Objects of the property_list class are containers for the SYCL properties. More...
 
class  queue
 Encapsulates a single SYCL queue which schedules kernels on a SYCL device. More...
 
class  reducer
 Class that is used to represent objects that are passed to user's lambda functions and representing users' reduction variable. More...
 
struct  is_device_copyable< detail::ReducerElement< T, BinaryOperation, IsOptional > >
 
class  reducer< T, BinaryOperation, Dims, Extent, IdentityContainerT, View, std::enable_if_t< Dims==0 &&Extent==1 &&View==false &&!detail::IsKnownIdentityOp< T, BinaryOperation >::value > >
 Specialization of the generic class 'reducer'. More...
 
class  reducer< T, BinaryOperation, Dims, Extent, IdentityContainerT, View, std::enable_if_t< Dims==0 &&Extent==1 &&View==false &&detail::IsKnownIdentityOp< T, BinaryOperation >::value > >
 Specialization of the generic class 'reducer'. More...
 
class  reducer< T, BinaryOperation, Dims, Extent, IdentityContainerT, View, std::enable_if_t< Dims==0 &&View==true > >
 Component of 'reducer' class for array reductions, representing a single element of the span (as returned by the subscript operator). More...
 
class  reducer< T, BinaryOperation, Dims, Extent, IdentityContainerT, View, std::enable_if_t< Dims==1 &&View==false &&!detail::IsKnownIdentityOp< T, BinaryOperation >::value > >
 Specialization of 'reducer' class for array reductions exposing the subscript operator. More...
 
class  reducer< T, BinaryOperation, Dims, Extent, IdentityContainerT, View, std::enable_if_t< Dims==1 &&View==false &&detail::IsKnownIdentityOp< T, BinaryOperation >::value > >
 Specialization of 'reducer' class for array reductions accepting a span in cases where the identity value is known. More...
 
struct  image_sampler
 
class  __precision_manipulator__
 
class  __width_manipulator__
 
struct  sub_group
 
class  span
 
struct  __is_span_impl
 
struct  __is_span_impl< span< _Tp, _Extent > >
 
struct  __is_span
 
struct  __is_std_array_impl
 
struct  __is_std_array_impl< std::array< _Tp, _Sz > >
 
struct  __is_std_array
 
struct  __is_span_compatible_container
 
struct  __is_span_compatible_container< _Tp, _ElementType, std::void_t< typename std::enable_if<!__is_span< _Tp >::value, std::nullptr_t >::type, typename std::enable_if<!__is_std_array< _Tp >::value, std::nullptr_t >::type, typename std::enable_if<!std::is_array_v< _Tp >, std::nullptr_t >::type, decltype(data(std::declval< _Tp >())), decltype(size(std::declval< _Tp >())), typename std::enable_if< std::is_convertible_v< std::remove_pointer_t< decltype(data(std::declval< _Tp & >()))>(*)[], _ElementType(*)[]>, std::nullptr_t >::type > >
 
class  span< _Tp, dynamic_extent >
 
struct  elem
 
struct  is_device_copyable
 is_device_copyable is a user specializable class template to indicate that a type T is device copyable, which means that SYCL implementation may copy objects of the type T between host and device or between two devices. More...
 
struct  is_device_copyable< std::array< T, 0 > >
 
struct  is_device_copyable< std::array< T, N > >
 
struct  is_device_copyable< std::optional< T > >
 
struct  is_device_copyable< std::pair< T1, T2 > >
 
struct  is_device_copyable< std::tuple< Ts... > >
 
struct  is_device_copyable< std::variant< Ts... > >
 
struct  is_device_copyable< sycl::marray< T, N > >
 
struct  is_device_copyable< T[N]>
 
class  usm_allocator
 

Typedefs

using access_mode = access::mode
 
template<typename T >
using remove_decoration_t = typename remove_decoration< T >::type
 
using instead = std::uint8_t
 
using __SYCL2020_DEPRECATED = signed char
 
using half = sycl::detail::half_impl::half
 
using async_handler = std::function< void(sycl::exception_list)>
 
template<backend Backend, typename SyclType >
using backend_input_t = typename backend_traits< Backend >::template input_type< SyclType >
 
template<backend Backend, typename SyclType >
using backend_return_t = typename backend_traits< Backend >::template return_type< SyclType >
 
template<typename DataT >
using buffer_allocator = detail::sycl_memory_object_allocator< DataT >
 
template<backend B>
using errc_for = typename backend_traits< B >::errc
 
template<typename T = void>
using plus = std::plus< T >
 
template<typename T = void>
using multiplies = std::multiplies< T >
 
template<typename T = void>
using bit_and = std::bit_and< T >
 
template<typename T = void>
using bit_or = std::bit_or< T >
 
template<typename T = void>
using bit_xor = std::bit_xor< T >
 
using byte = unsigned char
 
using image_allocator = detail::aligned_allocator< byte >
 
using element_type = std::conditional_t< std::is_same_v< ElementType, half >, sycl::detail::half_impl::BIsRepresentationT, ElementType >
 
using difference_type = std::ptrdiff_t
 
using pointer_t = typename detail::LegacyPointerTypes< ElementType, Space >::pointer_t
 
using const_pointer_t = typename detail::LegacyPointerTypes< ElementType, Space >::const_pointer_t
 
using reference_t = typename detail::LegacyReferenceTypes< ElementType, Space >::reference_t
 
using const_reference_t = typename detail::LegacyReferenceTypes< ElementType, Space >::const_reference_t
 
using ReturnPtr = detail::const_if_const_AS< Space, ElementType > *
 
using ReturnRef = detail::const_if_const_AS< Space, ElementType > &
 
using ReturnConstRef = const ElementType &
 
template<class name , class dataT , int32_t min_capacity = 0>
using pipe = ext::intel::pipe< name, dataT, min_capacity >
 
template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using generic_ptr = multi_ptr< ElementType, access::address_space::generic_space, IsDecorated >
 
template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using global_ptr = multi_ptr< ElementType, access::address_space::global_space, IsDecorated >
 
template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using local_ptr = multi_ptr< ElementType, access::address_space::local_space, IsDecorated >
 
template<typename ElementType >
using constant_ptr = multi_ptr< ElementType, access::address_space::constant_space, access::decorated::legacy >
 
template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using private_ptr = multi_ptr< ElementType, access::address_space::private_space, IsDecorated >
 
template<typename ElementType >
using raw_global_ptr = multi_ptr< ElementType, access::address_space::global_space, access::decorated::no >
 
template<typename ElementType >
using raw_local_ptr = multi_ptr< ElementType, access::address_space::local_space, access::decorated::no >
 
template<typename ElementType >
using raw_private_ptr = multi_ptr< ElementType, access::address_space::private_space, access::decorated::no >
 
template<typename ElementType >
using decorated_global_ptr = multi_ptr< ElementType, access::address_space::global_space, access::decorated::yes >
 
template<typename ElementType >
using decorated_local_ptr = multi_ptr< ElementType, access::address_space::local_space, access::decorated::yes >
 
template<typename ElementType >
using decorated_private_ptr = multi_ptr< ElementType, access::address_space::private_space, access::decorated::yes >
 
template<typename T >
using vec_data = detail::vec_helper< T >
 
template<typename T >
using vec_data_t = typename detail::vec_helper< T >::RetType
 
using ContextImplPtr = std::shared_ptr< sycl::detail::context_impl >
 
using alloc = sycl::usm::alloc
 

Enumerations

enum class  image_target : unsigned int { device = 0 , host_task = 1 }
 
enum class  backend : char {
  __SYCL2020_DEPRECATED =("'host' backend is no longer supported") = 0 , opencl = 1 , ext_oneapi_level_zero = 2 , ext_oneapi_cuda = 3 ,
  all = 4 , __SYCL_DEPRECATED , ext_oneapi_hip = 6 , ext_oneapi_native_cpu = 7
}
 
enum class  errc : unsigned int {
  success = 0 , runtime = 1 , kernel = 2 , accessor = 3 ,
  nd_range = 4 , event = 5 , kernel_argument = 6 , build = 7 ,
  invalid = 8 , memory_allocation = 9 , platform = 10 , profiling = 11 ,
  feature_not_supported = 12 , kernel_not_supported = 13 , backend_mismatch = 14
}
 
enum class  image_channel_order : unsigned int {
  a = 0 , r = 1 , rx = 2 , rg = 3 ,
  rgx = 4 , ra = 5 , rgb = 6 , rgbx = 7 ,
  rgba = 8 , argb = 9 , bgra = 10 , intensity = 11 ,
  luminance = 12 , abgr = 13 , ext_oneapi_srgba = 14
}
 
enum class  image_channel_type : unsigned int {
  snorm_int8 = 0 , snorm_int16 = 1 , unorm_int8 = 2 , unorm_int16 = 3 ,
  unorm_short_565 = 4 , unorm_short_555 = 5 , unorm_int_101010 = 6 , signed_int8 = 7 ,
  signed_int16 = 8 , signed_int32 = 9 , unsigned_int8 = 10 , unsigned_int16 = 11 ,
  unsigned_int32 = 12 , fp16 = 13 , fp32 = 14
}
 
enum class  image_format : unsigned int {
  r8g8b8a8_unorm = 0 , r16g16b16a16_unorm = 1 , r8g8b8a8_sint = 2 , r16g16b16a16_sint = 3 ,
  r32b32g32a32_sint = 4 , r8g8b8a8_uint = 5 , r16g16b16a16_uint = 6 , r32b32g32a32_uint = 7 ,
  r16b16g16a16_sfloat = 8 , r32g32b32a32_sfloat = 9 , b8g8r8a8_unorm = 10
}
 
enum class  bundle_state : char { input = 0 , object = 1 , executable = 2 , ext_oneapi_source = 3 }
 
enum class  memory_order : int {
  relaxed = 0 , acquire = 1 , __consume_unsupported , release = 3 ,
  acq_rel = 4 , seq_cst = 5
}
 
enum class  memory_scope : int {
  work_item = 0 , sub_group = 1 , work_group = 2 , device = 3 ,
  system = 4
}
 
enum class  addressing_mode : unsigned int {
  mirrored_repeat = PI_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT , repeat = PI_SAMPLER_ADDRESSING_MODE_REPEAT , clamp_to_edge = PI_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE , clamp = PI_SAMPLER_ADDRESSING_MODE_CLAMP ,
  none = PI_SAMPLER_ADDRESSING_MODE_NONE
}
 
enum class  filtering_mode : unsigned int { nearest = PI_SAMPLER_FILTER_MODE_NEAREST , linear = PI_SAMPLER_FILTER_MODE_LINEAR }
 
enum class  coordinate_normalization_mode : unsigned int { normalized = 1 , unnormalized = 0 }
 
enum class  stream_manipulator {
  dec = 0 , hex = 1 , oct = 2 , noshowbase = 3 ,
  showbase = 4 , noshowpos = 5 , showpos = 6 , endl = 7 ,
  flush = 8 , fixed = 9 , scientific = 10 , hexfloat = 11 ,
  defaultfloat = 12
}
 

Functions

template<typename DataT , int Dimensions, typename AllocatorT >
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor accessor (buffer< DataT, Dimensions, AllocatorT >) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::true_t >
 Buffer accessor. More...
 
template<typename DataT , int Dimensions, typename AllocatorT , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::true_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::true_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, Type3) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::true_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, Type3, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, Type3, Type4) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::true_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, Type3, Type4, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT >
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::false_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::false_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1, Type2) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::false_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1, Type2, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1, Type2, Type3) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::false_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1, Type2, Type3, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 >
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1, Type2, Type3, Type4) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::false_t >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 , typename... PropsT>
 accessor (buffer< DataT, Dimensions, AllocatorT >, handler &, Type1, Type2, Type3, Type4, const ext::oneapi::accessor_property_list< PropsT... > &) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>
 
template<typename DataT , int Dimensions, access::mode AccessMode, access::placeholder IsPlaceholder>
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE (accessor) accessor< DataT
 Image accessors. More...
 
template<typename DataT , int Dimensions, access::mode AccessMode, access::placeholder IsPlaceholder>
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE (accessor) accessor< DataT
 Image array accessor. More...
 
template<typename DataT , int Dimensions, typename AllocatorT >
 host_accessor (buffer< DataT, Dimensions, AllocatorT >) -> host_accessor< DataT, Dimensions, access::mode::read_write >
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 >
 host_accessor (buffer< DataT, Dimensions, AllocatorT >, Type1) -> host_accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >()>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 >
 host_accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2) -> host_accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >()>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 >
 host_accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, Type3) -> host_accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >()>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 >
 host_accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, Type3, Type4) -> host_accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >()>
 
template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 , typename Type5 >
 host_accessor (buffer< DataT, Dimensions, AllocatorT >, Type1, Type2, Type3, Type4, Type5) -> host_accessor< DataT, Dimensions, detail::deduceAccessMode< Type4, Type5 >()>
 
enum __SYCL_TYPE (aspect) aspect
 
template<typename T , access::address_space addressSpace = access::address_space::global_space>
class __SYCL2020_DEPRECATED ("sycl::atomic is deprecated since SYCL 2020") atomic
 
template<typename T , access::address_space addressSpace>
void atomic_store (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_load (atomic< T, addressSpace > Object, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_exchange (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
bool atomic_compare_exchange_strong (atomic< T, addressSpace > Object, T &Expected, T Desired, memory_order SuccessOrder=memory_order::relaxed, memory_order FailOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_fetch_add (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_fetch_sub (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_fetch_and (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_fetch_or (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_fetch_xor (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_fetch_min (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
template<typename T , access::address_space addressSpace>
atomic_fetch_max (atomic< T, addressSpace > Object, T Operand, memory_order MemoryOrder=memory_order::relaxed)
 
void atomic_fence (memory_order order, memory_scope scope)
 
template<backend BackendName, class SyclObjectT >
auto get_native (const SyclObjectT &Obj) -> backend_return_t< BackendName, SyclObjectT >
 
template<backend BackendName>
auto get_native (const queue &Obj) -> backend_return_t< BackendName, queue >
 
template<backend BackendName, bundle_state State>
auto get_native (const kernel_bundle< State > &Obj) -> backend_return_t< BackendName, kernel_bundle< State >>
 
template<backend BackendName, typename DataT , int Dimensions, typename AllocatorT >
auto get_native (const buffer< DataT, Dimensions, AllocatorT > &Obj) -> backend_return_t< BackendName, buffer< DataT, Dimensions, AllocatorT >>
 
template<backend BackendName, typename DataT , int Dimensions, access::mode AccessMode, access::target AccessTarget, access::placeholder IsPlaceholder>
auto get_native (const accessor< DataT, Dimensions, AccessMode, AccessTarget, IsPlaceholder > &Obj) -> typename detail::interop< BackendName, accessor< DataT, Dimensions, AccessMode, AccessTarget, IsPlaceholder >>::type=delete
 
template<backend Backend>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakePlatform==true, platformmake_platform (const typename backend_traits< Backend >::template input_type< platform > &BackendObject)
 
template<backend Backend>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeDevice==true, devicemake_device (const typename backend_traits< Backend >::template input_type< device > &BackendObject)
 
template<backend Backend>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeContext==true, contextmake_context (const typename backend_traits< Backend >::template input_type< context > &BackendObject, const async_handler &Handler={})
 
template<backend Backend>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeQueue==true, queuemake_queue (const typename backend_traits< Backend >::template input_type< queue > &BackendObject, const context &TargetContext, const async_handler Handler={})
 
template<backend Backend>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeEvent==true, eventmake_event (const typename backend_traits< Backend >::template input_type< event > &BackendObject, const context &TargetContext)
 
template<backend Backend>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeEvent==true, eventmake_event (const typename backend_traits< Backend >::template input_type< event > &BackendObject, const context &TargetContext, bool KeepOwnership)
 
template<backend Backend, typename T , int Dimensions = 1, typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeBuffer==true &&Backend !=backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT > > make_buffer (const typename backend_traits< Backend >::template input_type< buffer< T, Dimensions, AllocatorT >> &BackendObject, const context &TargetContext, event AvailableEvent={})
 
template<backend Backend, int Dimensions = 1, typename AllocatorT = image_allocator>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeImage==true &&Backend !=backend::ext_oneapi_level_zero, image< Dimensions, AllocatorT > > make_image (const typename backend_traits< Backend >::template input_type< image< Dimensions, AllocatorT >> &BackendObject, const context &TargetContext, event AvailableEvent={})
 
template<backend Backend>
kernel make_kernel (const typename backend_traits< Backend >::template input_type< kernel > &BackendObject, const context &TargetContext)
 
template<backend Backend, bundle_state State>
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeKernelBundle==true, kernel_bundle< State > > make_kernel_bundle (const typename backend_traits< Backend >::template input_type< kernel_bundle< State >> &BackendObject, const context &TargetContext)
 
std::ostream & operator<< (std::ostream &Out, backend be)
 
template<typename To , typename From >
std::enable_if_t< sizeof(To)==sizeof(From) &&std::is_trivially_copyable< From >::value &&std::is_trivially_copyable< To >::value, To > bit_cast (const From &from) noexcept
 
template<int SZ>
ESIMD_NODEBUG ESIMD_INLINE sycl::ext::intel::esimd::simd< float, SZ > cos (sycl::ext::intel::esimd::simd< float, SZ > x) __NOEXC
 
template<int SZ>
ESIMD_NODEBUG ESIMD_INLINE sycl::ext::intel::esimd::simd< float, SZ > sin (sycl::ext::intel::esimd::simd< float, SZ > x) __NOEXC
 
template<int SZ>
ESIMD_NODEBUG ESIMD_INLINE sycl::ext::intel::esimd::simd< float, SZ > exp (sycl::ext::intel::esimd::simd< float, SZ > x) __NOEXC
 
template<int SZ>
ESIMD_NODEBUG ESIMD_INLINE sycl::ext::intel::esimd::simd< float, SZ > log (sycl::ext::intel::esimd::simd< float, SZ > x) __NOEXC
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< int, N > > ilogb (marray< T, N > x)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< __FAST_MATH_SGENFLOAT(T), marray< T, N > > powr (marray< T, N > x, marray< T, N > y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > ldexp (marray< T, N > x, marray< int, N > k)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > ldexp (marray< T, N > x, int k)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > pown (marray< T, N > x, marray< int, N > y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > rootn (marray< T, N > x, marray< int, N > y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > pown (marray< T, N > x, int y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > rootn (marray< T, N > x, int y)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > fmax (T x, typename T::element_type y)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > fmin (T x, typename T::element_type y)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > ldexp (T x, int k)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_vgenfloat_v< T > &&detail::is_intn_v< T2 >, T > ldexp (T x, T2 k)
 
 __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD (fract, x, iptr, x[j]) __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD(modf
 
x[j] __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD (sincos, x, cosval, x[j]) __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD(frexp
 
x[j] x[j] __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD (lgamma_r, x, signp, x[j]) template< typename T
 
x[j] x[j] size_t N std::enable_if_t< detail::is_nan_type_v< T > &&detail::is_non_deprecated_nan_type_v< T >, marray< detail::nan_return_t< T >, N > > nan (marray< T, N > nancode)
 
template<typename T , size_t N>
 __SYCL_DEPRECATED ("This is a deprecated argument type for SYCL nan built-in function.") std
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > clamp (T x, typename T::element_type minval, typename T::element_type maxval)
 
template<typename T >
 std::enable_if_t< detail::is_vgenfloat_v< T >, T > (max)(T x
 
template<typename T >
 std::enable_if_t< detail::is_vgenfloat_v< T >, T > (min)(T x
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > mix (T x, T y, typename T::element_type a)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > step (typename T::element_type edge, T x)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > smoothstep (typename T::element_type edge0, typename T::element_type edge1, T x)
 
 __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD ((min), T x, detail::marray_element_t< T > y, x[i], y) __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD((max)
 
T detail::marray_element_t< T > y __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD (step, detail::marray_element_t< T > edge, T x, edge, x[i]) __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(clamp
 
T detail::marray_element_t< T > y T T T maxval[i] __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (clamp, T x, detail::marray_element_t< T > minval, detail::marray_element_t< T > maxval, x[i], minval, maxval) __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(mix
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (mix, T x, T y, detail::marray_element_t< T > a, x[i], y[i], a) __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(smoothstep
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T T T x[i] __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (smoothstep, detail::marray_element_t< T > edge0, detail::marray_element_t< T > edge1, T x, edge0, edge1, x[i]) template< typename T > std
 
template<typename T >
std::enable_if_t< detail::is_vigeninteger_v< T >, T > clamp (T x, typename T::element_type minval, typename T::element_type maxval)
 
template<typename T >
std::enable_if_t< detail::is_vugeninteger_v< T >, T > clamp (T x, typename T::element_type minval, typename T::element_type maxval)
 
template<typename T >
 std::enable_if_t< detail::is_vigeninteger_v< T >, T > (max)(T x
 
template<typename T >
 std::enable_if_t< detail::is_vugeninteger_v< T >, T > (max)(T x
 
template<typename T >
 std::enable_if_t< detail::is_vigeninteger_v< T >, T > (min)(T x
 
template<typename T >
 std::enable_if_t< detail::is_vugeninteger_v< T >, T > (min)(T x
 
 __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_RET_U_OVERLOAD (abs_diff, x, y, x[j], y[j]) __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_2ND_ARG_SCALAR_OVERLOAD((max)
 
y __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD ((max), x, y, x[j], y) __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_2ND_ARG_SCALAR_OVERLOAD((min)
 
y y __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD ((min), x, y, x[j], y) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD(clamp
 
y y maxval[j] __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD (clamp, x, minval, maxval, x[j], minval[j], maxval[j]) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_2ND_3RD_ARGS_SCALAR_OVERLOAD(clamp
 
y y maxval[j] maxval __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_2ND_3RD_ARGS_SCALAR_OVERLOAD (clamp, x, minval, maxval, x[j], minval, maxval) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD(mad_hi
 
y y maxval[j] maxval c[j] __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD (mad_hi, a, b, c, a[j], b[j], c[j]) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD(mad_sat
 
y y maxval[j] maxval c[j] c[j] __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD (mad_sat, a, b, c, a[j], b[j], c[j]) __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_U_OVERLOAD(mad24
 
y y maxval[j] maxval c[j] c[j] z[j] __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_I_OVERLOAD (mad24, x, y, z, x[j], y[j], z[j]) template< typename T > std
 
template<typename T >
std::enable_if_t< detail::is_vgengeofloat_v< T >, float > dot (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_vgengeodouble_v< T >, double > dot (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_vgengeohalf_v< T >, halfdot (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
double distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeohalf_v<T>, T>>
half distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float length (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
double length (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeohalf_v<T>, T>>
half length (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeofloat_v< T >, T > normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeodouble_v< T >, T > normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeohalf_v< T >, T > normalize (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float fast_distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
 __SYCL_DEPRECATED ("fast_distance for double precision types is non-standard " "and has been deprecated") double fast_distance(T p0
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float fast_length (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
 __SYCL_DEPRECATED ("fast_length for double precision types is non-standard " "and has been deprecated") double fast_length(T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeofloat_v< T >, T > fast_normalize (T p)
 
template<typename T >
 __SYCL_DEPRECATED ("fast_normalize for double precision types is non-standard " "and has been deprecated") std
 
template<typename T >
std::enable_if_t< detail::is_gencrossmarray_v< T >, T > cross (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarray_v< T >, T > normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarrayfloat_v< T >, T > fast_normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarray_v< T >, detail::marray_element_t< T > > length (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarrayfloat_v< T >, detail::marray_element_t< T > > fast_distance (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarrayfloat_v< T >, detail::marray_element_t< T > > fast_length (T p)
 
template<typename T >
std::enable_if_t< detail::is_vigeninteger_v< T >, int > any (T x)
 
template<typename T >
std::enable_if_t< detail::is_vigeninteger_v< T >, int > all (T x)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_sigeninteger_v< T >, bool > any (marray< T, N > x)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_sigeninteger_v< T >, bool > all (marray< T, N > x)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_gentype_v< T >, marray< T, N > > bitselect (marray< T, N > a, marray< T, N > b, marray< T, N > c)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_gentype_v< T >, marray< T, N > > select (marray< T, N > a, marray< T, N > b, marray< bool, N > c)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > acos (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > acosh (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > acospi (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > asin (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > asinh (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > asinpi (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > atan (T y_over_x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > atan2 (T y, T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > atanh (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > atanpi (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > atan2pi (T y, T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > cbrt (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > ceil (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > copysign (T x, T y)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > cos (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > cosh (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > cospi (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > erfc (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > erf (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > exp (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > exp2 (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > exp10 (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > expm1 (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > fabs (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > fdim (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > floor (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > fma (T a, T b, T c)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > fmax (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > fmin (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > fmod (T x, T y)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloat_v< T > &&detail::is_genfloatptr_v< T2 >, T > fract (T x, T2 iptr)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloat_v< T > &&detail::is_genintptr_v< T2 >, T > frexp (T x, T2 exp)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > hypot (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::change_base_type_t< T, int > ilogb (T x)
 
template<typename T >
std::enable_if_t< detail::is_sgenfloat_v< T >, T > ldexp (T x, int k)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > lgamma (T x)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloat_v< T > &&detail::is_genintptr_v< T2 >, T > lgamma_r (T x, T2 signp)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > log (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > log2 (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > log10 (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > log1p (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > logb (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > mad (T a, T b, T c)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > maxmag (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > minmag (T x, T y)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloat_v< T > &&detail::is_genfloatptr_v< T2 >, T > modf (T x, T2 iptr)
 
template<typename T >
std::enable_if_t< detail::is_nan_type_v< T > &&detail::is_non_deprecated_nan_type_v< T >, detail::nan_return_t< T > > nan (T nancode)
 
template<typename T >
 __SYCL_DEPRECATED ("This is a deprecated argument type for SYCL nan built-in function.") std
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > nextafter (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > pow (T x, T y)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloat_v< T > &&detail::is_genint_v< T2 >, T > pown (T x, T2 y)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > powr (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > remainder (T x, T y)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloat_v< T > &&detail::is_genintptr_v< T2 >, T > remquo (T x, T y, T2 quo)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > rint (T x)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloat_v< T > &&detail::is_genint_v< T2 >, T > rootn (T x, T2 y)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > round (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > rsqrt (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > sin (T x)
 
template<typename T , typename T2 >
std::enable_if_t< __FAST_MATH_GENFLOAT(T) &&detail::is_genfloatptr_v< T2 >, T > sincos (T x, T2 cosval)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > sinh (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > sinpi (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > sqrt (T x)
 
template<typename T >
std::enable_if_t< __FAST_MATH_GENFLOAT(T), T > tan (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > tanh (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > tanpi (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > tgamma (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > trunc (T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > clamp (T x, T minval, T maxval)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > degrees (T radians)
 
template<typename T >
 __SYCL_DEPRECATED ("abs for floating point types is non-standard and has been " "deprecated. Please use fabs instead.") std
 
template<typename T >
 std::enable_if_t< detail::is_svgenfloat_v< T >, T > (max)(T x
 
template<typename T >
 std::enable_if_t< detail::is_svgenfloat_v< T >, T > (min)(T x
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > mix (T x, T y, T a)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > radians (T degrees)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > step (T edge, T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > smoothstep (T edge0, T edge1, T x)
 
template<typename T >
std::enable_if_t< detail::is_svgenfloat_v< T >, T > sign (T x)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > abs (T x)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > abs_diff (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, detail::make_unsigned_t< T > > abs_diff (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > add_sat (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > add_sat (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > hadd (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > hadd (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > rhadd (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > rhadd (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > clamp (T x, T minval, T maxval)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > clamp (T x, T minval, T maxval)
 
template<typename T >
std::enable_if_t< detail::is_geninteger_v< T >, T > clz (T x)
 
template<typename T >
std::enable_if_t< detail::is_geninteger_v< T >, T > ctz (T x)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > mad_hi (T x, T y, T z)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > mad_hi (T x, T y, T z)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > mad_sat (T a, T b, T c)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > mad_sat (T a, T b, T c)
 
template<typename T >
 std::enable_if_t< detail::is_igeninteger_v< T >, T > (max)(T x
 
template<typename T >
 std::enable_if_t< detail::is_ugeninteger_v< T >, T > (max)(T x
 
template<typename T >
 std::enable_if_t< detail::is_igeninteger_v< T >, T > (min)(T x
 
template<typename T >
 std::enable_if_t< detail::is_ugeninteger_v< T >, T > (min)(T x
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > mul_hi (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > mul_hi (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_geninteger_v< T >, T > rotate (T v, T i)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger_v< T >, T > sub_sat (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger_v< T >, T > sub_sat (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger8bit_v< T >, detail::make_larger_t< T > > upsample (T hi, T lo)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_igeninteger8bit_v< T > &&detail::is_ugeninteger8bit_v< T2 >, detail::make_larger_t< T > > upsample (T hi, T2 lo)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger16bit_v< T >, detail::make_larger_t< T > > upsample (T hi, T lo)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_igeninteger16bit_v< T > &&detail::is_ugeninteger16bit_v< T2 >, detail::make_larger_t< T > > upsample (T hi, T2 lo)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger32bit_v< T >, detail::make_larger_t< T > > upsample (T hi, T lo)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_igeninteger32bit_v< T > &&detail::is_ugeninteger32bit_v< T2 >, detail::make_larger_t< T > > upsample (T hi, T2 lo)
 
template<typename T >
std::enable_if_t< detail::is_geninteger_v< T >, T > popcount (T x)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger32bit_v< T >, T > mad24 (T x, T y, T z)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger32bit_v< T >, T > mad24 (T x, T y, T z)
 
template<typename T >
std::enable_if_t< detail::is_igeninteger32bit_v< T >, T > mul24 (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_ugeninteger32bit_v< T >, T > mul24 (T x, T y)
 
template<typename T >
std::enable_if_t< detail::is_sgenfloat_v< T >, T > dot (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isequal (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isnotequal (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isgreater (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isgreaterequal (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isless (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > islessequal (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > islessgreater (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isfinite (T x)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isinf (T x)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isnan (T x)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isnormal (T x)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isordered (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > isunordered (T x, T y)
 
template<typename T , typename = std::enable_if_t<detail::is_svgenfloat_v<T>, T>>
detail::common_rel_ret_t< T > signbit (T x)
 
template<typename T >
std::enable_if_t< detail::is_sigeninteger_v< T >, bool > any (T x)
 
template<typename T >
std::enable_if_t< detail::is_sigeninteger_v< T >, bool > all (T x)
 
template<typename T >
std::enable_if_t< detail::is_gentype_v< T >, T > bitselect (T a, T b, T c)
 
template<typename T >
std::enable_if_t< detail::is_sgentype_v< T >, T > select (T a, T b, bool c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_geninteger_v< T > &&detail::is_igeninteger_v< T2 >, T > select (T a, T b, T2 c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_geninteger_v< T > &&detail::is_ugeninteger_v< T2 >, T > select (T a, T b, T2 c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloatf_v< T > &&detail::is_genint_v< T2 >, T > select (T a, T b, T2 c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloatf_v< T > &&detail::is_ugenint_v< T2 >, T > select (T a, T b, T2 c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloatd_v< T > &&detail::is_igeninteger64bit_v< T2 >, T > select (T a, T b, T2 c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloatd_v< T > &&detail::is_ugeninteger64bit_v< T2 >, T > select (T a, T b, T2 c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloath_v< T > &&detail::is_igeninteger16bit_v< T2 >, T > select (T a, T b, T2 c)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_svgenfloath_v< T > &&detail::is_ugeninteger16bit_v< T2 >, T > select (T a, T b, T2 c)
 
template<backend Backend, class SyclT >
auto get_native (const SyclT &Obj) -> backend_return_t< Backend, SyclT >
 
class __SYCL2020_DEPRECATED ("Use SYCL 2020 callable device selectors instead.") device_selector
 The SYCL 1.2.1 device_selector class provides ability to choose the best SYCL device based on heuristics specified by the user. More...
 
class __SYCL2020_DEPRECATED("Host device is no longer supported.") host_selector int default_selector_v (const device &dev)
 Selects SYCL host device. More...
 
int gpu_selector_v (const device &dev)
 
int cpu_selector_v (const device &dev)
 
int accelerator_selector_v (const device &dev)
 
detail::DSelectorInvocableType aspect_selector (const std::vector< aspect > &RequireList, const std::vector< aspect > &DenyList={})
 
template<typename... AspectListT>
detail::DSelectorInvocableType aspect_selector (AspectListT... AspectList)
 
template<aspect... AspectList>
detail::DSelectorInvocableType aspect_selector ()
 
std::error_code make_error_code (sycl::errc E) noexcept
 Constructs an error code using e and sycl_category() More...
 
const std::error_category & sycl_category () noexcept
 
template<>
backend_return_t< backend::ext_oneapi_hip, deviceget_native< backend::ext_oneapi_hip, device > (const device &Obj)
 
template<>
device make_device< backend::ext_oneapi_hip > (const backend_input_t< backend::ext_oneapi_hip, device > &BackendObject)
 
template<>
context make_context< backend::ext_oneapi_level_zero > (const backend_input_t< backend::ext_oneapi_level_zero, context > &BackendObject, const async_handler &Handler)
 
template<>
queue make_queue< backend::ext_oneapi_level_zero > (const backend_input_t< backend::ext_oneapi_level_zero, queue > &BackendObject, const context &TargetContext, const async_handler Handler)
 
template<>
auto get_native< backend::ext_oneapi_level_zero, queue > (const queue &Obj) -> backend_return_t< backend::ext_oneapi_level_zero, queue >
 
template<>
event make_event< backend::ext_oneapi_level_zero > (const backend_input_t< backend::ext_oneapi_level_zero, event > &BackendObject, const context &TargetContext)
 
template<>
kernel_bundle< bundle_state::executablemake_kernel_bundle< backend::ext_oneapi_level_zero, bundle_state::executable > (const backend_input_t< backend::ext_oneapi_level_zero, kernel_bundle< bundle_state::executable >> &BackendObject, const context &TargetContext)
 
template<>
kernel make_kernel< backend::ext_oneapi_level_zero > (const backend_input_t< backend::ext_oneapi_level_zero, kernel > &BackendObject, const context &TargetContext)
 
template<backend Backend, typename T , int Dimensions = 1, typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
std::enable_if_t< Backend==backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT > > make_buffer (const backend_input_t< backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT >> &BackendObject, const context &TargetContext, event AvailableEvent)
 
template<backend Backend, typename T , int Dimensions = 1, typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
std::enable_if_t< Backend==backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT > > make_buffer (const backend_input_t< backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT >> &BackendObject, const context &TargetContext)
 
template<backend Backend, int Dimensions = 1, typename AllocatorT = image_allocator>
std::enable_if_t< Backend==backend::ext_oneapi_level_zero, image< Dimensions, AllocatorT > > make_image (const backend_input_t< Backend, image< Dimensions, AllocatorT >> &BackendObject, const context &TargetContext, event AvailableEvent)
 
namespace __SYCL2020_DEPRECATED ("use 'ext::oneapi::level_zero' instead") level_zero
 
template<>
auto get_native< backend::ext_oneapi_cuda, context > (const context &C) -> backend_return_t< backend::ext_oneapi_cuda, context >
 
template<>
backend_return_t< backend::ext_oneapi_cuda, contextinterop_handle::get_native_context< backend::ext_oneapi_cuda > () const
 
template<>
device make_device< backend::ext_oneapi_cuda > (const backend_input_t< backend::ext_oneapi_cuda, device > &BackendObject)
 
template<>
event make_event< backend::ext_oneapi_cuda > (const backend_input_t< backend::ext_oneapi_cuda, event > &BackendObject, const context &TargetContext)
 
template<>
queue make_queue< backend::ext_oneapi_cuda > (const backend_input_t< backend::ext_oneapi_cuda, queue > &BackendObject, const context &TargetContext, const async_handler Handler)
 
template<>
ext::oneapi::experimental::info::kernel_queue_specific::max_num_work_group_sync::return_type kernel::ext_oneapi_get_info< ext::oneapi::experimental::info::kernel_queue_specific::max_num_work_group_sync > (const queue &q) const
 
template<int dimensions>
void group_barrier (ext::oneapi::experimental::root_group< dimensions > G, memory_scope FenceScope=decltype(G)::fence_scope)
 
template<typename T , int Dimensions = 1>
class __SYCL_TYPE (private_memory) private_memory
 
template<int Dimensions = 1>
class __SYCL_TYPE (group) group
 Encapsulates all functionality required to represent a particular work-group within a parallel execution. More...
 
template<int Dims>
group< Dims > this_group ()
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(detail::is_scalar_arithmetic< T >::value||(detail::is_complex< T >::value &&detail::is_multiplies< T, BinaryOperation >::value)) &&detail::is_native_op< T, BinaryOperation >::value), T > reduce_over_group (Group g, T x, BinaryOperation binary_op)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_complex< T >::value &&detail::is_native_op< T, sycl::plus< T >>::value &&detail::is_plus< T, BinaryOperation >::value), T > reduce_over_group (Group g, T x, BinaryOperation)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_vector_arithmetic_or_complex< T >::value &&detail::is_native_op< T, BinaryOperation >::value), T > reduce_over_group (Group g, T x, BinaryOperation binary_op)
 
template<typename Group , typename V , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(detail::is_scalar_arithmetic< V >::value||detail::is_complex< V >::value) &&(detail::is_scalar_arithmetic< T >::value||detail::is_complex< T >::value) &&detail::is_native_op< T, BinaryOperation >::value &&detail::is_plus_or_multiplies_if_complex< T, BinaryOperation >::value &&std::is_convertible_v< V, T >), T > reduce_over_group (Group g, V x, T init, BinaryOperation binary_op)
 
template<typename Group , typename V , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_vector_arithmetic_or_complex< V >::value &&detail::is_vector_arithmetic_or_complex< T >::value &&detail::is_native_op< V, BinaryOperation >::value &&detail::is_native_op< T, BinaryOperation >::value), T > reduce_over_group (Group g, V x, T init, BinaryOperation binary_op)
 
template<typename Group , typename Ptr , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< Ptr > &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< Ptr >::type >::value &&detail::is_arithmetic_or_complex< T >::value &&detail::is_plus_or_multiplies_if_complex< T, BinaryOperation >::value &&detail::is_native_op< T, BinaryOperation >::value), T > joint_reduce (Group g, Ptr first, Ptr last, T init, BinaryOperation binary_op)
 
template<typename Group , typename Ptr , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< Ptr > &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< Ptr >::type >::value &&detail::is_plus_or_multiplies_if_complex< typename detail::remove_pointer< Ptr >::type, BinaryOperation >::value), typename detail::remove_pointer< Ptr >::type > joint_reduce (Group g, Ptr first, Ptr last, BinaryOperation binary_op)
 
template<typename Group >
std::enable_if_t< is_group_v< std::decay_t< Group > >, bool > any_of_group (Group g, bool pred)
 
template<typename Group , typename T , class Predicate >
std::enable_if_t< is_group_v< Group >, bool > any_of_group (Group g, T x, Predicate pred)
 
template<typename Group , typename Ptr , class Predicate >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< Ptr >), bool > joint_any_of (Group g, Ptr first, Ptr last, Predicate pred)
 
template<typename Group >
std::enable_if_t< is_group_v< std::decay_t< Group > >, bool > all_of_group (Group g, bool pred)
 
template<typename Group , typename T , class Predicate >
std::enable_if_t< is_group_v< std::decay_t< Group > >, bool > all_of_group (Group g, T x, Predicate pred)
 
template<typename Group , typename Ptr , class Predicate >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< Ptr >), bool > joint_all_of (Group g, Ptr first, Ptr last, Predicate pred)
 
template<typename Group >
std::enable_if_t< is_group_v< std::decay_t< Group > >, bool > none_of_group (Group g, bool pred)
 
template<typename Group , typename T , class Predicate >
std::enable_if_t< is_group_v< std::decay_t< Group > >, bool > none_of_group (Group g, T x, Predicate pred)
 
template<typename Group , typename Ptr , class Predicate >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< Ptr >), bool > joint_none_of (Group g, Ptr first, Ptr last, Predicate pred)
 
template<typename Group , typename T >
std::enable_if_t<(std::is_same_v< std::decay_t< Group >, sub_group > &&(std::is_trivially_copyable_v< T >||detail::is_vec< T >::value)), T > shift_group_left (Group, T x, typename Group::linear_id_type delta=1)
 
template<typename Group , typename T >
std::enable_if_t<(std::is_same_v< std::decay_t< Group >, sub_group > &&(std::is_trivially_copyable_v< T >||detail::is_vec< T >::value)), T > shift_group_right (Group, T x, typename Group::linear_id_type delta=1)
 
template<typename Group , typename T >
std::enable_if_t<(std::is_same_v< std::decay_t< Group >, sub_group > &&(std::is_trivially_copyable_v< T >||detail::is_vec< T >::value)), T > permute_group_by_xor (Group, T x, typename Group::linear_id_type mask)
 
template<typename Group , typename T >
std::enable_if_t<(std::is_same_v< std::decay_t< Group >, sub_group > &&(std::is_trivially_copyable_v< T >||detail::is_vec< T >::value)), T > select_from_group (Group, T x, typename Group::id_type local_id)
 
template<typename Group , typename T >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(std::is_trivially_copyable_v< T >||detail::is_vec< T >::value)), T > group_broadcast (Group g, T x, typename Group::id_type local_id)
 
template<typename Group , typename T >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(std::is_trivially_copyable_v< T >||detail::is_vec< T >::value)), T > group_broadcast (Group g, T x, typename Group::linear_id_type linear_local_id)
 
template<typename Group , typename T >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(std::is_trivially_copyable_v< T >||detail::is_vec< T >::value)), T > group_broadcast (Group g, T x)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(detail::is_scalar_arithmetic< T >::value||(detail::is_complex< T >::value &&detail::is_multiplies< T, BinaryOperation >::value)) &&detail::is_native_op< T, BinaryOperation >::value), T > exclusive_scan_over_group (Group g, T x, BinaryOperation binary_op)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_complex< T >::value &&detail::is_native_op< T, sycl::plus< T >>::value &&detail::is_plus< T, BinaryOperation >::value), T > exclusive_scan_over_group (Group g, T x, BinaryOperation)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_vector_arithmetic_or_complex< T >::value &&detail::is_native_op< T, BinaryOperation >::value), T > exclusive_scan_over_group (Group g, T x, BinaryOperation binary_op)
 
template<typename Group , typename V , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_vector_arithmetic_or_complex< V >::value &&detail::is_vector_arithmetic_or_complex< T >::value &&detail::is_native_op< V, BinaryOperation >::value &&detail::is_native_op< T, BinaryOperation >::value), T > exclusive_scan_over_group (Group g, V x, T init, BinaryOperation binary_op)
 
template<typename Group , typename V , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(detail::is_scalar_arithmetic< V >::value||detail::is_complex< V >::value) &&(detail::is_scalar_arithmetic< T >::value||detail::is_complex< T >::value) &&detail::is_native_op< T, BinaryOperation >::value &&detail::is_plus_or_multiplies_if_complex< T, BinaryOperation >::value &&std::is_convertible_v< V, T >), T > exclusive_scan_over_group (Group g, V x, T init, BinaryOperation binary_op)
 
template<typename Group , typename InPtr , typename OutPtr , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< InPtr > &&detail::is_pointer_v< OutPtr > &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< InPtr >::type >::value &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< OutPtr >::type >::value &&detail::is_arithmetic_or_complex< T >::value &&detail::is_native_op< T, BinaryOperation >::value &&detail::is_plus_or_multiplies_if_complex< T, BinaryOperation >::value), OutPtr > joint_exclusive_scan (Group g, InPtr first, InPtr last, OutPtr result, T init, BinaryOperation binary_op)
 
template<typename Group , typename InPtr , typename OutPtr , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< InPtr > &&detail::is_pointer_v< OutPtr > &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< InPtr >::type >::value &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< OutPtr >::type >::value &&detail::is_native_op< typename detail::remove_pointer< OutPtr >::type, BinaryOperation >::value &&detail::is_plus_or_multiplies_if_complex< typename detail::remove_pointer< OutPtr >::type, BinaryOperation >::value), OutPtr > joint_exclusive_scan (Group g, InPtr first, InPtr last, OutPtr result, BinaryOperation binary_op)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_vector_arithmetic_or_complex< T >::value &&detail::is_native_op< T, BinaryOperation >::value), T > inclusive_scan_over_group (Group g, T x, BinaryOperation binary_op)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(detail::is_scalar_arithmetic< T >::value||(detail::is_complex< T >::value &&detail::is_multiplies< T, BinaryOperation >::value)) &&detail::is_native_op< T, BinaryOperation >::value), T > inclusive_scan_over_group (Group g, T x, BinaryOperation binary_op)
 
template<typename Group , typename T , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_complex< T >::value &&detail::is_native_op< T, sycl::plus< T >>::value &&detail::is_plus< T, BinaryOperation >::value), T > inclusive_scan_over_group (Group g, T x, BinaryOperation)
 
template<typename Group , typename V , class BinaryOperation , typename T >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&(detail::is_scalar_arithmetic< V >::value||detail::is_complex< V >::value) &&(detail::is_scalar_arithmetic< T >::value||detail::is_complex< T >::value) &&detail::is_native_op< T, BinaryOperation >::value &&detail::is_plus_or_multiplies_if_complex< T, BinaryOperation >::value &&std::is_convertible_v< V, T >), T > inclusive_scan_over_group (Group g, V x, BinaryOperation binary_op, T init)
 
template<typename Group , typename V , class BinaryOperation , typename T >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_vector_arithmetic_or_complex< V >::value &&detail::is_vector_arithmetic_or_complex< T >::value &&detail::is_native_op< V, BinaryOperation >::value &&detail::is_native_op< T, BinaryOperation >::value), T > inclusive_scan_over_group (Group g, V x, BinaryOperation binary_op, T init)
 
template<typename Group , typename InPtr , typename OutPtr , class BinaryOperation , typename T >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< InPtr > &&detail::is_pointer_v< OutPtr > &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< InPtr >::type >::value &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< OutPtr >::type >::value &&detail::is_arithmetic_or_complex< T >::value &&detail::is_native_op< T, BinaryOperation >::value &&detail::is_plus_or_multiplies_if_complex< T, BinaryOperation >::value), OutPtr > joint_inclusive_scan (Group g, InPtr first, InPtr last, OutPtr result, BinaryOperation binary_op, T init)
 
template<typename Group , typename InPtr , typename OutPtr , class BinaryOperation >
std::enable_if_t<(is_group_v< std::decay_t< Group >> &&detail::is_pointer_v< InPtr > &&detail::is_pointer_v< OutPtr > &&detail::is_arithmetic_or_complex< typename detail::remove_pointer< InPtr >::type >::value &&detail::is_native_op< typename detail::remove_pointer< OutPtr >::type, BinaryOperation >::value &&detail::is_plus_or_multiplies_if_complex< typename detail::remove_pointer< OutPtr >::type, BinaryOperation >::value), OutPtr > joint_inclusive_scan (Group g, InPtr first, InPtr last, OutPtr result, BinaryOperation binary_op)
 
template<typename Group >
std::enable_if_t< is_group_v< Group > > group_barrier (Group G, memory_scope FenceScope=Group::fence_scope)
 
template<int Dims>
id< Dims > this_id ()
 
template<backend Backend, int D, typename A >
std::enable_if_t< Backend==backend::ext_oneapi_level_zero, image< D, A > > make_image (const backend_input_t< Backend, image< D, A >> &BackendObject, const context &TargetContext, event AvailableEvent={})
 
template<int Dims>
item< Dims > this_item ()
 
template<typename KernelName >
kernel_id get_kernel_id ()
 
template<bundle_state State>
 kernel_bundle (kernel_bundle< State > &&) -> kernel_bundle< State >
 
std::vector< kernel_idget_kernel_ids ()
 
template<bundle_state State>
kernel_bundle< State > get_kernel_bundle (const context &Ctx, const std::vector< device > &Devs)
 A kernel bundle in state State which contains all of the kernels in the application which are compatible with at least one of the devices in Devs. More...
 
template<bundle_state State>
kernel_bundle< State > get_kernel_bundle (const context &Ctx)
 
template<bundle_state State>
kernel_bundle< State > get_kernel_bundle (const context &Ctx, const std::vector< device > &Devs, const std::vector< kernel_id > &KernelIDs)
 
template<bundle_state State>
kernel_bundle< State > get_kernel_bundle (const context &Ctx, const std::vector< kernel_id > &KernelIDs)
 
template<typename KernelName , bundle_state State>
kernel_bundle< State > get_kernel_bundle (const context &Ctx)
 
template<typename KernelName , bundle_state State>
kernel_bundle< State > get_kernel_bundle (const context &Ctx, const std::vector< device > &Devs)
 
template<bundle_state State, typename SelectorT >
kernel_bundle< State > get_kernel_bundle (const context &Ctx, const std::vector< device > &Devs, SelectorT Selector)
 A kernel bundle in state State which contains all of the device images for which the selector returns true. More...
 
template<bundle_state State, typename SelectorT >
kernel_bundle< State > get_kernel_bundle (const context &Ctx, SelectorT Selector)
 
template<bundle_state State>
bool has_kernel_bundle (const context &Ctx, const std::vector< device > &Devs)
 
template<bundle_state State>
bool has_kernel_bundle (const context &Ctx, const std::vector< device > &Devs, const std::vector< kernel_id > &KernelIDs)
 
template<bundle_state State>
bool has_kernel_bundle (const context &Ctx)
 
template<bundle_state State>
bool has_kernel_bundle (const context &Ctx, const std::vector< kernel_id > &KernelIDs)
 
template<typename KernelName , bundle_state State>
bool has_kernel_bundle (const context &Ctx)
 
template<typename KernelName , bundle_state State>
bool has_kernel_bundle (const context &Ctx, const std::vector< device > &Devs)
 
bool is_compatible (const std::vector< kernel_id > &KernelIDs, const device &Dev)
 
template<typename KernelName >
bool is_compatible (const device &Dev)
 
template<sycl::bundle_state State>
sycl::kernel_bundle< State > join (const std::vector< sycl::kernel_bundle< State >> &Bundles)
 
kernel_bundle< bundle_state::objectcompile (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList={})
 
kernel_bundle< bundle_state::objectcompile (const kernel_bundle< bundle_state::input > &InputBundle, const property_list &PropList={})
 
kernel_bundle< bundle_state::executablelink (const std::vector< kernel_bundle< bundle_state::object >> &ObjectBundles, const std::vector< device > &Devs, const property_list &PropList={})
 
kernel_bundle< bundle_state::executablelink (const kernel_bundle< bundle_state::object > &ObjectBundle, const property_list &PropList={})
 
kernel_bundle< bundle_state::executablelink (const std::vector< kernel_bundle< bundle_state::object >> &ObjectBundles, const property_list &PropList={})
 
kernel_bundle< bundle_state::executablelink (const kernel_bundle< bundle_state::object > &ObjectBundle, const std::vector< device > &Devs, const property_list &PropList={})
 
kernel_bundle< bundle_state::executablebuild (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList={})
 
kernel_bundle< bundle_state::executablebuild (const kernel_bundle< bundle_state::input > &InputBundle, const property_list &PropList={})
 
class __SYCL_TYPE (kernel_handler) kernel_handler
 Reading the value of a specialization constant. More...
 
template<typename ElementType , access::address_space Space>
class __SYCL2020_DEPRECATED ("decorated::legacy multi_ptr specialization is deprecated since SYCL 2020.") multi_ptr< ElementType
 
 multi_ptr ()
 
 multi_ptr (const multi_ptr &rhs)=default
 
 multi_ptr (multi_ptr &&)=default
 
 multi_ptr (ElementType *pointer)
 
 multi_ptr (std::nullptr_t)
 
 ~multi_ptr ()=default
 
multi_ptroperator= (const multi_ptr &)=default
 
multi_ptroperator= (multi_ptr &&)=default
 
multi_ptroperator= (ElementType *pointer)
 
multi_ptroperator= (std::nullptr_t)
 
ReturnRef operator* () const
 
ReturnPtr operator-> () const
 
ReturnRef operator[] (difference_type index)
 
template<int dimensions, access::mode Mode, access::placeholder isPlaceholder, typename PropertyListT , access::address_space _Space = Space, typename = typename std::enable_if_t< _Space == Space && (Space == access::address_space::generic_space || Space == access::address_space::global_space || Space == access::address_space::ext_intel_global_device_space)>>
 multi_ptr (accessor< ElementType, dimensions, Mode, target::device, isPlaceholder, PropertyListT > Accessor)
 
template<int dimensions, access::mode Mode, access::placeholder isPlaceholder, typename PropertyListT , access::address_space _Space = Space, typename = typename std::enable_if_t< _Space == Space && (Space == access::address_space::generic_space || Space == access::address_space::local_space)>>
 multi_ptr (accessor< ElementType, dimensions, Mode, target::local, isPlaceholder, PropertyListT > Accessor)
 
template<int dimensions>
 multi_ptr (local_accessor< ElementType, dimensions > Accessor)
 
template<int dimensions, access::mode Mode, access::placeholder isPlaceholder, typename PropertyListT , access::address_space _Space = Space, typename = typename std::enable_if_t< _Space == Space && Space == access::address_space::constant_space>>
 multi_ptr (accessor< ElementType, dimensions, Mode, target::constant_buffer, isPlaceholder, PropertyListT > Accessor)
 
template<int dimensions, access::mode Mode, access::placeholder isPlaceholder, typename PropertyListT , access::address_space _Space = Space, typename ET = ElementType, typename = typename std::enable_if_t< _Space == Space && (Space == access::address_space::generic_space || Space == access::address_space::global_space || Space == access::address_space::ext_intel_global_device_space) && std::is_const_v<ET> && std::is_same_v<ET, ElementType>>>
 multi_ptr (accessor< typename std::remove_const_t< ET >, dimensions, Mode, target::device, isPlaceholder, PropertyListT > Accessor)
 
template<int dimensions, access::mode Mode, access::placeholder isPlaceholder, typename PropertyListT , access::address_space _Space = Space, typename ET = ElementType, typename = typename std::enable_if_t< _Space == Space && (Space == access::address_space::generic_space || Space == access::address_space::local_space) && std::is_const_v<ET> && std::is_same_v<ET, ElementType>>>
 multi_ptr (accessor< typename std::remove_const_t< ET >, dimensions, Mode, target::local, isPlaceholder, PropertyListT > Accessor)
 
template<int dimensions, access::address_space _Space = Space, typename ET = ElementType, typename = typename std::enable_if_t< _Space == Space && (Space == access::address_space::generic_space || Space == access::address_space::local_space) && std::is_const_v<ET> && std::is_same_v<ET, ElementType>>>
 multi_ptr (local_accessor< typename std::remove_const_t< ET >, dimensions > Accessor)
 
template<int dimensions, access::mode Mode, access::placeholder isPlaceholder, typename PropertyListT , access::address_space _Space = Space, typename ET = ElementType, typename = typename std::enable_if_t< _Space == Space && Space == access::address_space::constant_space && std::is_const_v<ET> && std::is_same_v<ET, ElementType>>>
 multi_ptr (accessor< typename std::remove_const_t< ET >, dimensions, Mode, target::constant_buffer, isPlaceholder, PropertyListT > Accessor)
 
template<typename ET = ElementType>
 multi_ptr (typename std::enable_if_t< std::is_const_v< ET > &&std::is_same_v< ET, ElementType >, const multi_ptr< typename std::remove_const_t< ET >, Space, access::decorated::legacy >> &ETP)
 
pointer_t get () const
 
pointer_t get_decorated () const
 
std::add_pointer_t< element_typeget_raw () const
 
 operator ReturnPtr () const
 
 operator multi_ptr< const ElementType, Space, access::decorated::legacy > () const
 
multi_ptroperator++ ()
 
multi_ptr operator++ (int)
 
multi_ptroperator-- ()
 
multi_ptr operator-- (int)
 
multi_ptroperator+= (difference_type r)
 
multi_ptroperator-= (difference_type r)
 
multi_ptr operator+ (difference_type r) const
 
multi_ptr operator- (difference_type r) const
 
template<access::address_space _Space = Space, typename = typename std::enable_if_t< _Space == Space && Space == access::address_space::global_space>>
void prefetch (size_t NumElements) const
 
template<int Dims>
nd_item< Dims > this_nd_item ()
 
template<typename DataT , int Dimensions>
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE (local_accessor) local_accessor
 
template<typename T , typename AllocatorT , typename BinaryOperation >
auto reduction (buffer< T, 1, AllocatorT > Var, handler &CGH, BinaryOperation Combiner, const property_list &PropList={})
 Constructs a reduction object using the given buffer Var, handler CGH, reduction operation Combiner, and optional reduction properties. More...
 
template<typename T , typename BinaryOperation >
auto reduction (T *Var, BinaryOperation Combiner, const property_list &PropList={})
 Constructs a reduction object using the reduction variable referenced by the given USM pointer Var, handler CGH, reduction operation Combiner, and optional reduction properties. More...
 
template<typename T , typename AllocatorT , typename BinaryOperation >
auto reduction (buffer< T, 1, AllocatorT > Var, handler &CGH, const T &Identity, BinaryOperation Combiner, const property_list &PropList={})
 Constructs a reduction object using the given buffer Var, handler CGH, reduction identity value Identity, reduction operation Combiner, and optional reduction properties. More...
 
template<typename T , typename BinaryOperation >
auto reduction (T *Var, const T &Identity, BinaryOperation Combiner, const property_list &PropList={})
 Constructs a reduction object using the reduction variable referenced by the given USM pointer Var, reduction identity value Identity, binary operation Combiner, and optional reduction properties. More...
 
template<typename T , size_t Extent, typename BinaryOperation , typename = std::enable_if_t<Extent != dynamic_extent>>
auto reduction (span< T, Extent > Span, BinaryOperation Combiner, const property_list &PropList={})
 Constructs a reduction object using the reduction variable referenced by the given sycl::span Span, reduction operation Combiner, and optional reduction properties. More...
 
template<typename T , size_t Extent, typename BinaryOperation , typename = std::enable_if_t<Extent != dynamic_extent>>
auto reduction (span< T, Extent > Span, const T &Identity, BinaryOperation Combiner, const property_list &PropList={})
 Constructs a reduction object using the reduction variable referenced by the given sycl::span Span, reduction identity value Identity, reduction operation Combiner, and optional reduction properties. More...
 
class __SYCL_SPECIAL_CLASS __SYCL_TYPE (sampler) sampler
 Encapsulates a configuration for sampling an image accessor. More...
 
template<typename T >
class __SYCL_TYPE (specialization_id) specialization_id
 Declaring a specialization constant. More...
 
template<typename T , typename... ArgsT>
std::unique_ptr< T > make_unique_ptr (ArgsT &&...Args)
 
__precision_manipulator__ setprecision (int Precision)
 
__width_manipulator__ setw (int Width)
 
template<typename T >
class __SYCL_SPECIAL_CLASS __SYCL_TYPE(stream) stream std::enable_if_t< std::is_same_v< T, std::byte >, const stream & > operator<< (const stream &, const T &)
 A buffered output stream that allows outputting the values of built-in, vector and SYCL types to the console. More...
 
const stream & operator<< (const stream &Out, const char C)
 
const stream & operator<< (const stream &Out, const char *Str)
 
const stream & operator<< (const stream &Out, const bool &RHS)
 
template<typename ValueType >
std::enable_if_t< std::is_integral_v< ValueType >, const stream & > operator<< (const stream &Out, const ValueType &RHS)
 
const stream & operator<< (const stream &Out, const float &RHS)
 
const stream & operator<< (const stream &Out, const double &RHS)
 
const stream & operator<< (const stream &Out, const half &RHS)
 
const stream & operator<< (const stream &Out, const ext::oneapi::bfloat16 &RHS)
 
template<typename ElementType , access::address_space Space, access::decorated IsDecorated>
const stream & operator<< (const stream &Out, const multi_ptr< ElementType, Space, IsDecorated > &RHS)
 
template<typename T >
const stream & operator<< (const stream &Out, const T *RHS)
 
const stream & operator<< (const stream &Out, const __precision_manipulator__ &RHS)
 
const stream & operator<< (const stream &Out, const __width_manipulator__ &RHS)
 
const stream & operator<< (const stream &Out, const stream_manipulator RHS)
 
template<typename T , int VectorLength>
const stream & operator<< (const stream &Out, const vec< T, VectorLength > &RHS)
 
template<int Dimensions>
const stream & operator<< (const stream &Out, const id< Dimensions > &RHS)
 
template<int Dimensions>
const stream & operator<< (const stream &Out, const range< Dimensions > &RHS)
 
template<int Dimensions>
const stream & operator<< (const stream &Out, const item< Dimensions > &RHS)
 
template<int Dimensions>
const stream & operator<< (const stream &Out, const nd_range< Dimensions > &RHS)
 
template<int Dimensions>
const stream & operator<< (const stream &Out, const nd_item< Dimensions > &RHS)
 
template<int Dimensions>
const stream & operator<< (const stream &Out, const group< Dimensions > &RHS)
 
template<int Dimensions>
const stream & operator<< (const stream &Out, const h_item< Dimensions > &RHS)
 
template<typename T , typename RT = detail::EnableIfSwizzleVec<T>>
const stream & operator<< (const stream &Out, const T &RHS)
 
template<class _Tp , size_t _Extent>
_SYCL_SPAN_INLINE_VISIBILITY auto as_bytes (span< _Tp, _Extent > __s) noexcept -> decltype(__s.__as_bytes())
 
template<class _Tp , size_t _Extent>
_SYCL_SPAN_INLINE_VISIBILITY auto as_writable_bytes (span< _Tp, _Extent > __s) noexcept -> std::enable_if_t<!std::is_const_v< _Tp >, decltype(__s.__as_writable_bytes())>
 
template<class _Tp , size_t _Sz>
 span (_Tp(&)[_Sz]) -> span< _Tp, _Sz >
 
template<class _Tp , size_t _Sz>
 span (std::array< _Tp, _Sz > &) -> span< _Tp, _Sz >
 
template<class _Tp , size_t _Sz>
 span (const std::array< _Tp, _Sz > &) -> span< const _Tp, _Sz >
 
template<class _Container >
 span (_Container &) -> span< typename _Container::value_type >
 
template<class _Container >
 span (const _Container &) -> span< const typename _Container::value_type >
 
usm::alloc get_pointer_type (const void *ptr, const context &ctxt)
 Query the allocation type from a USM pointer. More...
 
device get_pointer_device (const void *ptr, const context &ctxt)
 Queries the device against which the pointer was allocated Throws an invalid_object_error if ptr is a host allocation. More...
 
void * malloc_device (size_t size, const device &dev, const context &ctxt, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_device (size_t size, const device &dev, const context &ctxt, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_device (size_t size, const queue &q, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_device (size_t size, const queue &q, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_device (size_t alignment, size_t size, const device &dev, const context &ctxt, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_device (size_t alignment, size_t size, const device &dev, const context &ctxt, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_device (size_t alignment, size_t size, const queue &q, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_device (size_t alignment, size_t size, const queue &q, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void free (void *ptr, const context &ctxt, const detail::code_location &CodeLoc=detail::code_location::current())
 
void free (void *ptr, const queue &q, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_host (size_t size, const context &ctxt, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_host (size_t size, const context &ctxt, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_host (size_t size, const queue &q, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_host (size_t size, const queue &q, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_shared (size_t size, const device &dev, const context &ctxt, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_shared (size_t size, const device &dev, const context &ctxt, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_shared (size_t size, const queue &q, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc_shared (size_t size, const queue &q, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_host (size_t alignment, size_t size, const context &ctxt, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_host (size_t alignment, size_t size, const context &ctxt, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_host (size_t alignment, size_t size, const queue &q, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_host (size_t alignment, size_t size, const queue &q, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_shared (size_t alignment, size_t size, const device &dev, const context &ctxt, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_shared (size_t alignment, size_t size, const device &dev, const context &ctxt, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_shared (size_t alignment, size_t size, const queue &q, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc_shared (size_t alignment, size_t size, const queue &q, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc (size_t size, const device &dev, const context &ctxt, usm::alloc kind, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc (size_t size, const device &dev, const context &ctxt, usm::alloc kind, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc (size_t size, const queue &q, usm::alloc kind, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * malloc (size_t size, const queue &q, usm::alloc kind, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc (size_t alignment, size_t size, const device &dev, const context &ctxt, usm::alloc kind, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc (size_t alignment, size_t size, const device &dev, const context &ctxt, usm::alloc kind, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc (size_t alignment, size_t size, const queue &q, usm::alloc kind, const detail::code_location &CodeLoc=detail::code_location::current())
 
void * aligned_alloc (size_t alignment, size_t size, const queue &q, usm::alloc kind, const property_list &propList, const detail::code_location &CodeLoc=detail::code_location::current())
 
size_t is_not_power_of_two (size_t Alignment)
 
 BUILTIN_COMMON (ONE_ARG, degrees, [](auto x) -> decltype(x) { return(180/M_PI) *x;}) BUILTIN_COMMON(ONE_ARG
 
 BUILTIN_COMMON (ONE_ARG, sign, [](auto x) -> decltype(x) { using T=decltype(x);if(std::isnan(x)) return T(0.0);if(x > 0) return T(1.0);if(x< 0) return T(-1.0);return x;}) BUILTIN_COMMON(THREE_ARGS
 
 BUILTIN_COMMON (TWO_ARGS, step, [](auto x, auto y) -> decltype(x) { return y< x ? 0.0 :1.0;}) BUILTIN_COMMON(THREE_ARGS
 
 BUILTIN_COMMON (TWO_ARGS, max, [](auto x, auto y) -> decltype(x) { return(x< y ? y :x);}) BUILTIN_COMMON(TWO_ARGS
 
template<typename T >
static T cross_host_impl (T p0, T p1)
 
template<typename T0 , typename T1 >
static auto dot_host_impl (T0 x, T1 y)
 
template<typename T >
static auto length_host_impl (T x)
 
template<typename T >
static auto fast_length_host_impl (T x)
 
template<typename T0 , typename T1 >
static auto distance_host_impl (T0 x, T1 y)
 
template<typename T0 , typename T1 >
static auto fast_distance_host_impl (T0 x, T1 y)
 
template<typename T >
static auto normalize_host_impl (T x)
 
template<typename T >
static auto fast_normalize_host_impl (T x)
 
 BUILTIN_GENINT (ONE_ARG, abs, [](auto x) -> decltype(x) { if constexpr(std::is_signed_v< decltype(x)>) { return std::abs(x);} else { return x;} }) BUILTIN_GENINT_SU(TWO_ARGS
 
 BUILTIN_GENINT_SU (TWO_ARGS, add_sat, [](auto x, auto y) -> decltype(x) { using T=decltype(x);if constexpr(std::is_signed_v< T >) { if(x > 0 &&y > 0) return(x<(std::numeric_limits< T >::max() - y) ?(x+y) :std::numeric_limits< T >::max());if(x< 0 &&y< 0) return(x >(std::numeric_limits< T >::min() - y) ?(x+y) :std::numeric_limits< T >::min());return x+y;} else { return(x<(std::numeric_limits< T >::max() - y) ? x+y :std::numeric_limits< T >::max());} }) BUILTIN_GENINT_SU(TWO_ARGS
 
 return (x >> one)+(y >> one)+((y &x) &one)
 
 BUILTIN_GENINT_SU (TWO_ARGS, rhadd, [](auto x, auto y) -> decltype(x) { const decltype(x) one=1;return(x >> one)+(y >> one)+((y|x) &one);}) BUILTIN_GENINT_SU(THREE_ARGS
 
 BUILTIN_GENINT_SU (THREE_ARGS, mad_sat, [](auto a, auto b, auto c) -> decltype(a) { using T=decltype(a);if constexpr(std::is_signed_v< T >) { if constexpr(sizeof(T)==8) { bool neg_prod=(a< 0) ^(b< 0);T mulhi=__s_long_mul_hi(a, b);if(!neg_prod &&mulhi !=0) return std::numeric_limits< T >::max();if(neg_prod &&mulhi !=-1) return std::numeric_limits< T >::min();return sycl::add_sat(T(a *b), c);} else { using UPT=sycl::detail::make_larger_t< T >;UPT mul=UPT(a) *UPT(b);UPT res=mul+UPT(c);const UPT max=std::numeric_limits< T >::max();const UPT min=std::numeric_limits< T >::min();res=std::min(std::max(res, min), max);return T(res);} } else { if constexpr(sizeof(T)==8) { T mulhi=__u_long_mul_hi(a, b);if(mulhi !=0) return std::numeric_limits< T >::max();return sycl::add_sat(T(a *b), c);} else { using UPT=sycl::detail::make_larger_t< T >;UPT mul=UPT(a) *UPT(b);const UPT min=std::numeric_limits< T >::min();const UPT max=std::numeric_limits< T >::max();mul=std::min(std::max(mul, min), max);return sycl::add_sat(T(mul), c);} } }) BUILTIN_GENINT_SU(TWO_ARGS
 
constexpr if (sizeof(T)==8)
 
 return (mul >>(sizeof(T) *8))
 
 BUILTIN_GENINT_SU (TWO_ARGS, sub_sat, [](auto x, auto y) -> decltype(x) { using T=decltype(x);if constexpr(std::is_signed_v< T >) { using UT=std::make_unsigned_t< T >;T result=UT(x) - UT(y);if(((x< 0) ^(y< 0)) &&((x< 0) ^(result< 0))) result=result< 0 ? std::numeric_limits< T >::max() :std::numeric_limits< T >::min();return result;} else { return(y<(x - std::numeric_limits< T >::min())) ?(x - y) :std::numeric_limits< T >::min();} }) BUILTIN_GENINT_SU(TWO_ARGS
 
 BUILTIN_GENINT_SU (TWO_ARGS, min, [](auto x, auto y) -> decltype(x) { return y< x ? y :x;}) BUILTIN_GENINT_SU(THREE_ARGS
 
template<typename T >
static constexpr T __clz_impl (T x, T m, T n=0)
 
template<typename T >
static constexpr T __clz (T x)
 
template<typename T >
static constexpr T __ctz_impl (T x, T m, T n=0)
 
template<typename T >
static constexpr T __ctz (T x)
 
 BUILTIN_GENINT (TWO_ARGS, rotate, [](auto x, auto n) -> decltype(x) { using T=decltype(x);using UT=std::make_unsigned_t< T >;constexpr UT size=sizeof(x) *8;UT xu=UT(x);UT nu=UT(n) &(size - 1);return(xu<< nu)|(xu >>(size - nu));}) template< typename T > static inline const expr T __popcount_impl(T x
 
 BUILTIN_GENF_CUSTOM (ONE_ARG, acospi, [](auto x) -> decltype(x) { return std::acos(x)/M_PI;}) BUILTIN_GENF_CUSTOM(ONE_ARG
 
 BUILTIN_GENF_CUSTOM (ONE_ARG, atanpi, [](auto x) -> decltype(x) { return std::atan(x)/M_PI;}) BUILTIN_GENF_CUSTOM(TWO_ARGS
 
 BUILTIN_GENF_CUSTOM (ONE_ARG, cospi, [](auto x) -> decltype(x) { return std::sin(M_PI *(0.5 - x));}) BUILTIN_GENF_CUSTOM(ONE_ARG
 
 BUILTIN_GENF_CUSTOM (THREE_ARGS, mad, [](auto x, auto y, auto z) -> decltype(x) { return(x *y)+z;}) BUILTIN_GENF_CUSTOM(TWO_ARGS
 
 if (std::fabs(y) > std::fabs(x)) return y
 
 BUILTIN_GENF_CUSTOM (TWO_ARGS, minmag, [](auto x, auto y) -> decltype(x) { if(std::fabs(x)< std::fabs(y)) return x;if(std::fabs(y)< std::fabs(x)) return y;return std::fmin(x, y);}) BUILTIN_GENF_CUSTOM(TWO_ARGS
 
return(x >=T(0)) ? T(std BUILTIN_GENF_CUSTOM (ONE_ARG, rsqrt, [](auto x) -> decltype(x) { return decltype(x){1.0}/std::sqrt(x);}) BUILTIN_GENF_CUSTOM(ONE_ARG
 
 BUILTIN_GENF_CUSTOM (ONE_ARG, tanpi, [](auto x) -> decltype(x) { double y=x - std::floor(x);return 1.0/std::tan((0.5 - y) *M_PI);}) BUILTIN_GENF_CUSTOM(TWO_ARGS
 
template<typename T >
static auto process_arg_for_macos (T x)
 
 REL_BUILTIN_CUSTOM (TWO_ARGS, isequal,([](auto x, auto y) { return x==y;})) REL_BUILTIN_CUSTOM(TWO_ARGS
 
 REL_BUILTIN_CUSTOM (TWO_ARGS, isgreater,([](auto x, auto y) { return x > y;})) REL_BUILTIN_CUSTOM(TWO_ARGS
 
 REL_BUILTIN_CUSTOM (TWO_ARGS, isless,([](auto x, auto y) { return x< y;})) REL_BUILTIN_CUSTOM(TWO_ARGS
 
 REL_BUILTIN_CUSTOM (TWO_ARGS, islessgreater,([](auto x, auto y) { return x< y||x > y;})) REL_BUILTIN_CUSTOM(TWO_ARGS
 
namespace __SYCL2020_DEPRECATED ("use 'ext::oneapi' instead") ONEAPI
 
namespace __SYCL2020_DEPRECATED ("use 'ext::intel::experimental' instead") INTEL
 
void * malloc (size_t Size, const device &Dev, const context &Ctxt, alloc Kind, const property_list &PropList, const detail::code_location &CodeLoc)
 
void * malloc (size_t Size, const device &Dev, const context &Ctxt, alloc Kind, const detail::code_location &CodeLoc)
 
void * malloc (size_t Size, const queue &Q, alloc Kind, const detail::code_location &CodeLoc)
 
void * malloc (size_t Size, const queue &Q, alloc Kind, const property_list &PropList, const detail::code_location &CodeLoc)
 
void * aligned_alloc (size_t Alignment, size_t Size, const device &Dev, const context &Ctxt, alloc Kind, const detail::code_location &CodeLoc)
 
void * aligned_alloc (size_t Alignment, size_t Size, const device &Dev, const context &Ctxt, alloc Kind, const property_list &PropList, const detail::code_location &CodeLoc)
 
void * aligned_alloc (size_t Alignment, size_t Size, const queue &Q, alloc Kind, const detail::code_location &CodeLoc)
 
void * aligned_alloc (size_t Alignment, size_t Size, const queue &Q, alloc Kind, const property_list &PropList, const detail::code_location &CodeLoc)
 
static void prepare_for_usm_device_copy (const void *Ptr, size_t Size, const context &Ctxt)
 
static void release_from_usm_device_copy (const void *Ptr, const context &Ctxt)
 
template std::vector< devicedevice::create_sub_devices< info::partition_property::partition_equally > (size_t ComputeUnits) const
 
template std::vector< devicedevice::create_sub_devices< info::partition_property::partition_by_counts > (const std::vector< size_t > &Counts) const
 
template std::vector< devicedevice::create_sub_devices< info::partition_property::partition_by_affinity_domain > (info::partition_affinity_domain AffinityDomain) const
 
template std::vector< devicedevice::create_sub_devices< info::partition_property::ext_intel_partition_by_cslice > () const
 
template<>
device device::get_info< info::device::parent_device > () const
 
template<>
std::vector< sycl::aspect > device::get_info< info::device::aspects > () const
 
template<>
bool device::get_info< info::device::image_support > () const
 
static void traceDeviceSelector (const std::string &DeviceType)
 default_selector_v Devices of different kinds are prioritized in the following order: More...
 
static void addArgsForGlobalAccessor (detail::Requirement *AccImpl, size_t Index, size_t &IndexShift, int Size, bool IsKernelCreatedFromSource, size_t GlobalSize, std::vector< detail::ArgDesc > &Args, bool isESIMD)
 
static bool checkContextSupports (const std::shared_ptr< detail::context_impl > &ContextImpl, sycl::detail::pi::PiContextInfo InfoQuery)
 
template uint32_t kernel::get_info< info::kernel_device_specific::max_sub_group_size > (const device &, const sycl::range< 3 > &) const
 
static size_t CheckMaxStatementSize (const size_t &MaxStatementSize)
 

Variables

constexpr mode_tag_t< access_mode::readread_only {}
 
constexpr mode_tag_t< access_mode::read_write > read_write {}
 
constexpr mode_tag_t< access_mode::writewrite_only {}
 
constexpr mode_target_tag_t< access_mode::read, target::constant_buffer > read_constant {}
 
constexpr mode_target_tag_t< access_mode::read, target::host_task > read_only_host_task
 
constexpr mode_target_tag_t< access_mode::read_write, target::host_task > read_write_host_task
 
constexpr mode_target_tag_t< access_mode::write, target::host_task > write_only_host_task
 
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS Dimensions
 
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS AccessMode
 
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS IsPlaceholder
 
 x { return (M_PI / 180) * x
 
 iptr
 
x[j] exp
 
T::element_type y
 
T detail::marray_element_t< T > y T T minval
 
T detail::marray_element_t< T > y T T T maxval
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T edge0
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T T edge1
 
y y maxval[j] maxval b
 
y y maxval[j] maxval c
 
y y maxval[j] maxval c[j] c[j] z
 
p1
 
template<class T >
constexpr bool is_group_v = is_group<T>::value
 
template<typename BinaryOperation , typename AccumulatorT >
constexpr bool has_known_identity_v
 
template<typename BinaryOperation , typename AccumulatorT >
constexpr AccumulatorT known_identity_v
 
constexpr auto memory_scope_work_item = memory_scope::work_item
 
constexpr auto memory_scope_sub_group = memory_scope::sub_group
 
constexpr auto memory_scope_work_group = memory_scope::work_group
 
constexpr auto memory_scope_device = memory_scope::device
 
constexpr auto memory_scope_system = memory_scope::system
 
constexpr auto memory_order_relaxed = memory_order::relaxed
 
constexpr auto memory_order_acquire = memory_order::acquire
 
constexpr auto memory_order_release = memory_order::release
 
constexpr auto memory_order_acq_rel = memory_order::acq_rel
 
constexpr auto memory_order_seq_cst = memory_order::seq_cst
 
static constexpr access::address_space address_space = Space
 
constexpr property::no_init no_init
 
constexpr property::noinit noinit
 
template<typename propertyT >
constexpr bool is_property_v = is_property<propertyT>::value
 
template<typename propertyT , typename syclObjectT >
constexpr bool is_property_of_v
 
constexpr stream_manipulator dec = stream_manipulator::dec
 
constexpr stream_manipulator hex = stream_manipulator::hex
 
constexpr stream_manipulator oct = stream_manipulator::oct
 
constexpr stream_manipulator noshowbase = stream_manipulator::noshowbase
 
constexpr stream_manipulator showbase = stream_manipulator::showbase
 
constexpr stream_manipulator noshowpos = stream_manipulator::noshowpos
 
constexpr stream_manipulator showpos = stream_manipulator::showpos
 
constexpr stream_manipulator endl = stream_manipulator::endl
 
constexpr stream_manipulator flush = stream_manipulator::flush
 
constexpr stream_manipulator fixed = stream_manipulator::fixed
 
constexpr stream_manipulator scientific = stream_manipulator::scientific
 
constexpr stream_manipulator hexfloat = stream_manipulator::hexfloat
 
constexpr stream_manipulator defaultfloat = stream_manipulator::defaultfloat
 
constexpr size_t dynamic_extent = SIZE_MAX
 
template<typename T >
constexpr bool is_device_copyable_v = is_device_copyable<T>::value
 
 radians
 
 mix
 
 smoothstep
 
auto t = sycl::clamp((z - x) / (y - x), T{0}, T{1})
 
 min
 
 abs_diff
 
 hadd
 
 mad_hi
 
 mul_hi
 
 else
 
UPT a_s = a
 
UPT b_s = b
 
UPT mul = a_s * b_s
 
 max
 
 clamp
 
 asinpi
 
 atan2pi
 
 exp10
 
 maxmag
 
 powr
 
return(x >=T(0)) ? T(std sinpi
 
 nextafter
 
 isnotequal
 
 isgreaterequal
 
 islessequal
 
 isordered
 
constexpr size_t MaxNumAdditionalArgs = 13
 
static constexpr size_t MAX_STATEMENT_SIZE
 

Typedef Documentation

◆ __SYCL2020_DEPRECATED

Definition at line 94 of file aliases.hpp.

◆ access_mode

Definition at line 72 of file access.hpp.

◆ alloc

using sycl::_V1::alloc = typedef sycl::usm::alloc

Definition at line 34 of file usm_impl.cpp.

◆ async_handler

using sycl::_V1::async_handler = typedef std::function<void(sycl::exception_list)>

Definition at line 19 of file async_handler.hpp.

◆ backend_input_t

template<backend Backend, typename SyclType >
using sycl::_V1::backend_input_t = typedef typename backend_traits<Backend>::template input_type<SYCLObjectT>

Definition at line 82 of file backend.hpp.

◆ backend_return_t

template<backend Backend, typename SyclType >
using sycl::_V1::backend_return_t = typedef typename backend_traits<Backend>::template return_type<SYCLObjectT>

Definition at line 86 of file backend.hpp.

◆ bit_and

template<typename T = void>
using sycl::_V1::bit_and = typedef std::bit_and<T>

Definition at line 20 of file functional.hpp.

◆ bit_or

template<typename T = void>
using sycl::_V1::bit_or = typedef std::bit_or<T>

Definition at line 21 of file functional.hpp.

◆ bit_xor

template<typename T = void>
using sycl::_V1::bit_xor = typedef std::bit_xor<T>

Definition at line 22 of file functional.hpp.

◆ buffer_allocator

template<typename DataT >
using sycl::_V1::buffer_allocator = typedef detail::sycl_memory_object_allocator<DataT>

Definition at line 55 of file buffer.hpp.

◆ byte

typedef unsigned char sycl::_V1::byte

Definition at line 108 of file image.hpp.

◆ const_pointer_t

typedef typename detail::LegacyPointerTypes< const void, Space >::pointer_t sycl::_V1::const_pointer_t

Definition at line 759 of file multi_ptr.hpp.

◆ const_reference_t

using sycl::_V1::const_reference_t = typedef typename detail::LegacyReferenceTypes<ElementType, Space>::const_reference_t

Definition at line 763 of file multi_ptr.hpp.

◆ constant_ptr

template<typename ElementType >
using sycl::_V1::constant_ptr = typedef multi_ptr<ElementType, access::address_space::constant_space, access::decorated::legacy>

Definition at line 55 of file pointers.hpp.

◆ ContextImplPtr

using sycl::_V1::ContextImplPtr = typedef std::shared_ptr<sycl::detail::context_impl>

Definition at line 22 of file helpers.cpp.

◆ decorated_global_ptr

template<typename ElementType >
using sycl::_V1::decorated_global_ptr = typedef multi_ptr<ElementType, access::address_space::global_space, access::decorated::yes>

Definition at line 86 of file pointers.hpp.

◆ decorated_local_ptr

template<typename ElementType >
using sycl::_V1::decorated_local_ptr = typedef multi_ptr<ElementType, access::address_space::local_space, access::decorated::yes>

Definition at line 91 of file pointers.hpp.

◆ decorated_private_ptr

template<typename ElementType >
using sycl::_V1::decorated_private_ptr = typedef multi_ptr<ElementType, access::address_space::private_space, access::decorated::yes>

Definition at line 96 of file pointers.hpp.

◆ difference_type

typedef std::ptrdiff_t sycl::_V1::difference_type

Definition at line 753 of file multi_ptr.hpp.

◆ element_type

typedef const void sycl::_V1::element_type

Definition at line 749 of file multi_ptr.hpp.

◆ errc_for

template<backend B>
using sycl::_V1::errc_for = typedef typename backend_traits<B>::errc

Definition at line 50 of file exception.hpp.

◆ generic_ptr

template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using sycl::_V1::generic_ptr = typedef multi_ptr<ElementType, access::address_space::generic_space, IsDecorated>

Definition at line 24 of file pointers.hpp.

◆ global_ptr

template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using sycl::_V1::global_ptr = typedef multi_ptr<ElementType, access::address_space::global_space, IsDecorated>

Definition at line 29 of file pointers.hpp.

◆ half

Definition at line 101 of file aliases.hpp.

◆ image_allocator

Definition at line 110 of file image.hpp.

◆ instead

Definition at line 93 of file aliases.hpp.

◆ local_ptr

template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using sycl::_V1::local_ptr = typedef multi_ptr<ElementType, access::address_space::local_space, IsDecorated>

Definition at line 51 of file pointers.hpp.

◆ multiplies

template<typename T = void>
using sycl::_V1::multiplies = typedef std::multiplies<T>

Definition at line 19 of file functional.hpp.

◆ pipe

template<class name , class dataT , int32_t min_capacity = 0>
using sycl::_V1::pipe = typedef ext::intel::pipe<name, dataT, min_capacity>

Definition at line 18 of file pipes.hpp.

◆ plus

template<typename T = void>
using sycl::_V1::plus = typedef std::plus<T>

Definition at line 18 of file functional.hpp.

◆ pointer_t

typedef typename detail::LegacyPointerTypes< const void, Space >::pointer_t sycl::_V1::pointer_t

Definition at line 757 of file multi_ptr.hpp.

◆ private_ptr

template<typename ElementType , access::decorated IsDecorated = access::decorated::legacy>
using sycl::_V1::private_ptr = typedef multi_ptr<ElementType, access::address_space::private_space, IsDecorated>

Definition at line 61 of file pointers.hpp.

◆ raw_global_ptr

template<typename ElementType >
using sycl::_V1::raw_global_ptr = typedef multi_ptr<ElementType, access::address_space::global_space, access::decorated::no>

Definition at line 69 of file pointers.hpp.

◆ raw_local_ptr

template<typename ElementType >
using sycl::_V1::raw_local_ptr = typedef multi_ptr<ElementType, access::address_space::local_space, access::decorated::no>

Definition at line 74 of file pointers.hpp.

◆ raw_private_ptr

template<typename ElementType >
using sycl::_V1::raw_private_ptr = typedef multi_ptr<ElementType, access::address_space::private_space, access::decorated::no>

Definition at line 78 of file pointers.hpp.

◆ reference_t

using sycl::_V1::reference_t = typedef typename detail::LegacyReferenceTypes<ElementType, Space>::reference_t

Definition at line 761 of file multi_ptr.hpp.

◆ remove_decoration_t

template<typename T >
using sycl::_V1::remove_decoration_t = typedef typename remove_decoration<T>::type

Definition at line 325 of file access.hpp.

◆ ReturnConstRef

using sycl::_V1::ReturnConstRef = typedef const ElementType &

Definition at line 830 of file multi_ptr.hpp.

◆ ReturnPtr

Definition at line 828 of file multi_ptr.hpp.

◆ ReturnRef

using sycl::_V1::ReturnRef = typedef detail::const_if_const_AS<Space, ElementType> &

Definition at line 829 of file multi_ptr.hpp.

◆ vec_data

template<typename T >
using sycl::_V1::vec_data = typedef detail::vec_helper<T>

Definition at line 313 of file types.hpp.

◆ vec_data_t

template<typename T >
using sycl::_V1::vec_data_t = typedef typename detail::vec_helper<T>::RetType

Definition at line 316 of file types.hpp.

Enumeration Type Documentation

◆ addressing_mode

enum sycl::_V1::addressing_mode : unsigned int
strong
Enumerator
mirrored_repeat 
repeat 
clamp_to_edge 
clamp 
none 

Definition at line 23 of file sampler.hpp.

◆ backend

enum sycl::_V1::backend : char
strong
Enumerator
__SYCL2020_DEPRECATED 
opencl 
ext_oneapi_level_zero 
ext_oneapi_cuda 
all 
__SYCL_DEPRECATED 
ext_oneapi_hip 
ext_oneapi_native_cpu 

Definition at line 18 of file backend_types.hpp.

◆ bundle_state

enum sycl::_V1::bundle_state : char
strong
Enumerator
input 
object 
executable 
ext_oneapi_source 

Definition at line 14 of file kernel_bundle_enums.hpp.

◆ coordinate_normalization_mode

enum sycl::_V1::coordinate_normalization_mode : unsigned int
strong
Enumerator
normalized 
unnormalized 

Definition at line 36 of file sampler.hpp.

◆ errc

enum sycl::_V1::errc : unsigned int
strong
Enumerator
success 
runtime 
kernel 
accessor 
nd_range 
event 
kernel_argument 
build 
invalid 
memory_allocation 
platform 
profiling 
feature_not_supported 
kernel_not_supported 
backend_mismatch 

Definition at line 32 of file exception.hpp.

◆ filtering_mode

enum sycl::_V1::filtering_mode : unsigned int
strong
Enumerator
nearest 
linear 

Definition at line 31 of file sampler.hpp.

◆ image_channel_order

enum sycl::_V1::image_channel_order : unsigned int
strong
Enumerator
rx 
rg 
rgx 
ra 
rgb 
rgbx 
rgba 
argb 
bgra 
intensity 
luminance 
abgr 
ext_oneapi_srgba 

Definition at line 57 of file image.hpp.

◆ image_channel_type

enum sycl::_V1::image_channel_type : unsigned int
strong
Enumerator
snorm_int8 
snorm_int16 
unorm_int8 
unorm_int16 
unorm_short_565 
unorm_short_555 
unorm_int_101010 
signed_int8 
signed_int16 
signed_int32 
unsigned_int8 
unsigned_int16 
unsigned_int32 
fp16 
fp32 

Definition at line 75 of file image.hpp.

◆ image_format

enum sycl::_V1::image_format : unsigned int
strong
Enumerator
r8g8b8a8_unorm 
r16g16b16a16_unorm 
r8g8b8a8_sint 
r16g16b16a16_sint 
r32b32g32a32_sint 
r8g8b8a8_uint 
r16g16b16a16_uint 
r32b32g32a32_uint 
r16b16g16a16_sfloat 
r32g32b32a32_sfloat 
b8g8r8a8_unorm 

Definition at line 94 of file image.hpp.

◆ image_target

enum sycl::_V1::image_target : unsigned int
strong
Enumerator
device 
host_task 

Definition at line 74 of file access.hpp.

◆ memory_order

enum sycl::_V1::memory_order : int
strong
Enumerator
relaxed 
acquire 
__consume_unsupported 
release 
acq_rel 
seq_cst 

Definition at line 19 of file memory_enums.hpp.

◆ memory_scope

enum sycl::_V1::memory_scope : int
strong
Enumerator
work_item 
sub_group 
work_group 
device 
system 

Definition at line 29 of file memory_enums.hpp.

◆ stream_manipulator

Enumerator
dec 
hex 
oct 
noshowbase 
showbase 
noshowpos 
showpos 
endl 
flush 
fixed 
scientific 
hexfloat 
defaultfloat 

Definition at line 768 of file stream.hpp.

Function Documentation

◆ __clz()

template<typename T >
static constexpr T sycl::_V1::__clz ( x)
inlinestaticconstexpr

Definition at line 225 of file integer_functions.cpp.

◆ __clz_impl()

template<typename T >
static constexpr T sycl::_V1::__clz_impl ( x,
m,
n = 0 
)
inlinestaticconstexpr

Definition at line 222 of file integer_functions.cpp.

◆ __ctz()

template<typename T >
static constexpr T sycl::_V1::__ctz ( x)
inlinestaticconstexpr

Definition at line 236 of file integer_functions.cpp.

◆ __ctz_impl()

template<typename T >
static constexpr T sycl::_V1::__ctz_impl ( x,
m,
n = 0 
)
inlinestaticconstexpr

Definition at line 232 of file integer_functions.cpp.

◆ __SYCL2020_DEPRECATED() [1/5]

template<typename ElementType , access::address_space Space>
class sycl::_V1::__SYCL2020_DEPRECATED ( "decorated::legacy multi_ptr specialization is deprecated since SYCL 2020."  )

◆ __SYCL2020_DEPRECATED() [2/5]

template<typename T , access::address_space addressSpace = access::address_space::global_space>
class sycl::_V1::__SYCL2020_DEPRECATED ( "sycl::atomic is deprecated since SYCL 2020"  )

Definition at line 82 of file atomic.hpp.

◆ __SYCL2020_DEPRECATED() [3/5]

namespace sycl::_V1::__SYCL2020_DEPRECATED ( "use 'ext::intel::experimental' instead )

Definition at line 1 of file online_compiler.cpp.

◆ __SYCL2020_DEPRECATED() [4/5]

namespace sycl::_V1::__SYCL2020_DEPRECATED ( "use 'ext::oneapi' instead )

Definition at line 1 of file filter_selector_impl.cpp.

◆ __SYCL2020_DEPRECATED() [5/5]

namespace sycl::_V1::__SYCL2020_DEPRECATED ( "use 'ext::oneapi::level_zero' instead )

Definition at line 241 of file level_zero.hpp.

◆ __SYCL_DEPRECATED() [1/6]

template<typename T >
sycl::_V1::__SYCL_DEPRECATED ( "abs for floating point types is non-standard and has been " "deprecated. Please use fabs instead."  )

Definition at line 508 of file builtins_legacy_scalar.hpp.

◆ __SYCL_DEPRECATED() [2/6]

template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
sycl::_V1::__SYCL_DEPRECATED ( "fast_distance for double precision types is non-standard " "and has been deprecated"  )

◆ __SYCL_DEPRECATED() [3/6]

template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
sycl::_V1::__SYCL_DEPRECATED ( "fast_length for double precision types is non-standard " "and has been deprecated"  )

Definition at line 997 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_DEPRECATED() [4/6]

template<typename T >
sycl::_V1::__SYCL_DEPRECATED ( "fast_normalize for double precision types is non-standard " "and has been deprecated"  )

Definition at line 1011 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_DEPRECATED() [5/6]

template<typename T , size_t N>
sycl::_V1::__SYCL_DEPRECATED ( "This is a deprecated argument type for SYCL nan built-in function."  )

Definition at line 426 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_DEPRECATED() [6/6]

template<typename T >
sycl::_V1::__SYCL_DEPRECATED ( "This is a deprecated argument type for SYCL nan built-in function."  )

Definition at line 360 of file builtins_legacy_scalar.hpp.

◆ __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD() [1/2]

sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD ( (min ,
x,
detail::marray_element_t< T >  y,
x  [i],
y   
)

◆ __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD() [2/2]

T detail::marray_element_t<T> y sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD ( step  ,
detail::marray_element_t< T >  edge,
x,
edge  ,
x  [i] 
)

◆ __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD() [1/3]

T detail::marray_element_t<T> y T T T maxval [i] sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD ( clamp  ,
x,
detail::marray_element_t< T >  minval,
detail::marray_element_t< T >  maxval,
x  [i],
minval  ,
maxval   
)

◆ __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD() [2/3]

T detail::marray_element_t<T> y T T T maxval [i] T T T a [i] sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD ( mix  ,
x,
y,
detail::marray_element_t< T >  a,
x  [i],
y  [i],
a   
)

◆ __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD() [3/3]

T detail::marray_element_t<T> y T T T maxval [i] T T T a [i] T T T x [i] sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD ( smoothstep  ,
detail::marray_element_t< T >  edge0,
detail::marray_element_t< T >  edge1,
x,
edge0  ,
edge1  ,
x  [i] 
)

Definition at line 563 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD() [1/2]

y sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD ( (max ,
x  ,
y  ,
x  [j],
y   
)

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD() [2/2]

y y sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD ( (min ,
x  ,
y  ,
x  [j],
y   
)

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_RET_U_OVERLOAD()

sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_RET_U_OVERLOAD ( abs_diff  ,
x  ,
y  ,
x  [j],
y  [j] 
)

◆ __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_I_OVERLOAD()

y y maxval [j] maxval c [j] c [j] z [j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_MAD24_I_OVERLOAD ( mad24  ,
x  ,
y  ,
z  ,
x  [j],
y  [j],
z  [j] 
)

Definition at line 815 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_2ND_3RD_ARGS_SCALAR_OVERLOAD()

y y maxval [j] maxval sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_2ND_3RD_ARGS_SCALAR_OVERLOAD ( clamp  ,
x  ,
minval  ,
maxval  ,
x  [j],
minval  ,
maxval   
)

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD() [1/3]

y y maxval [j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD ( clamp  ,
x  ,
minval  ,
maxval  ,
x  [j],
minval  [j],
maxval  [j] 
)

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD() [2/3]

y y maxval [j] maxval c [j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD ( mad_hi  ,
a  ,
b  ,
c  ,
a  [j],
b  [j],
c  [j] 
)

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD() [3/3]

y y maxval [j] maxval c [j] c [j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD ( mad_sat  ,
a  ,
b  ,
c  ,
a  [j],
b  [j],
c  [j] 
)

◆ __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD() [1/2]

sycl::_V1::__SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD ( fract  ,
x  ,
iptr  ,
x  [j] 
)

◆ __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD() [2/2]

x [j] sycl::_V1::__SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD ( sincos  ,
x  ,
cosval  ,
x  [j] 
)

◆ __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD()

x [j] x [j] sycl::_V1::__SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD ( lgamma_r  ,
x  ,
signp  ,
x  [j] 
)

◆ __SYCL_TYPE() [1/4]

template<typename DataT , int Dimensions, access::mode AccessMode, access::placeholder IsPlaceholder>
class __SYCL_EBO __SYCL_SPECIAL_CLASS sycl::_V1::__SYCL_TYPE ( accessor  )

Image array accessor.

Available only when accessTarget == access::target::image_array and dimensions < 3.

See also
image

◆ __SYCL_TYPE() [2/4]

enum sycl::_V1::__SYCL_TYPE ( aspect  )
strong

Definition at line 1 of file aspects.hpp.

◆ __SYCL_TYPE() [3/4]

template<typename DataT , int Dimensions>
class __SYCL_EBO __SYCL_SPECIAL_CLASS sycl::_V1::__SYCL_TYPE ( local_accessor  )

◆ __SYCL_TYPE() [4/4]

template<typename T , int Dimensions = 1>
class sycl::_V1::__SYCL_TYPE ( private_memory  )

Definition at line 1 of file group.hpp.

◆ abs()

template<typename T >
std::enable_if_t<detail::is_ugeninteger_v<T>, T> sycl::_V1::abs ( x)

Definition at line 560 of file builtins_legacy_scalar.hpp.

◆ abs_diff() [1/2]

template<typename T >
std::enable_if_t<detail::is_ugeninteger_v<T>, T> sycl::_V1::abs_diff ( x,
y 
)

Definition at line 566 of file builtins_legacy_scalar.hpp.

◆ abs_diff() [2/2]

template<typename T >
std::enable_if_t<detail::is_igeninteger_v<T>, detail::make_unsigned_t<T> > sycl::_V1::abs_diff ( x,
y 
)

Definition at line 573 of file builtins_legacy_scalar.hpp.

◆ accelerator_selector_v()

int sycl::_V1::accelerator_selector_v ( const device dev)

◆ accessor() [1/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [2/19]

template<typename DataT , int Dimensions, typename AllocatorT >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler  
) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::false_t >

◆ accessor() [3/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [4/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::false_t >

◆ accessor() [5/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [6/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1  ,
Type2   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::false_t >

◆ accessor() [7/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1  ,
Type2  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [8/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1  ,
Type2  ,
Type3   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::false_t >

◆ accessor() [9/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1  ,
Type2  ,
Type3  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [10/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1  ,
Type2  ,
Type3  ,
Type4   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::false_t >

◆ accessor() [11/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
handler ,
Type1  ,
Type2  ,
Type3  ,
Type4  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::false_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [12/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::true_t >

◆ accessor() [13/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type1 >(), detail::deduceAccessTarget< Type1, Type1 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [14/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1  ,
Type2   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::true_t >

◆ accessor() [15/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1  ,
Type2  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type1, Type2 >(), detail::deduceAccessTarget< Type1, Type2 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [16/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1  ,
Type2  ,
Type3   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::true_t >

◆ accessor() [17/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1  ,
Type2  ,
Type3  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type2, Type3 >(), detail::deduceAccessTarget< Type2, Type3 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ accessor() [18/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 >
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1  ,
Type2  ,
Type3  ,
Type4   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::true_t >

◆ accessor() [19/19]

template<typename DataT , int Dimensions, typename AllocatorT , typename Type1 , typename Type2 , typename Type3 , typename Type4 , typename... PropsT>
sycl::_V1::accessor ( buffer< DataT, Dimensions, AllocatorT >  ,
Type1  ,
Type2  ,
Type3  ,
Type4  ,
const ext::oneapi::accessor_property_list< PropsT... > &   
) -> accessor< DataT, Dimensions, detail::deduceAccessMode< Type3, Type4 >(), detail::deduceAccessTarget< Type3, Type4 >(target::device), access::placeholder::true_t, ext::oneapi::accessor_property_list< PropsT... >>

◆ acos()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::acos ( x)

Definition at line 48 of file builtins_legacy_scalar.hpp.

◆ acosh()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::acosh ( x)

Definition at line 54 of file builtins_legacy_scalar.hpp.

◆ acospi()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::acospi ( x)

Definition at line 60 of file builtins_legacy_scalar.hpp.

◆ add_sat() [1/2]

template<typename T >
std::enable_if_t<detail::is_igeninteger_v<T>, T> sycl::_V1::add_sat ( x,
y 
)

Definition at line 579 of file builtins_legacy_scalar.hpp.

◆ add_sat() [2/2]

template<typename T >
std::enable_if_t<detail::is_ugeninteger_v<T>, T> sycl::_V1::add_sat ( x,
y 
)

Definition at line 585 of file builtins_legacy_scalar.hpp.

◆ addArgsForGlobalAccessor()

static void sycl::_V1::addArgsForGlobalAccessor ( detail::Requirement AccImpl,
size_t  Index,
size_t &  IndexShift,
int  Size,
bool  IsKernelCreatedFromSource,
size_t  GlobalSize,
std::vector< detail::ArgDesc > &  Args,
bool  isESIMD 
)
static

Definition at line 607 of file handler.cpp.

◆ aligned_alloc() [1/8]

void* sycl::_V1::aligned_alloc ( size_t  Alignment,
size_t  Size,
const device Dev,
const context Ctxt,
alloc  Kind,
const detail::code_location CodeLoc 
)

Definition at line 526 of file usm_impl.cpp.

◆ aligned_alloc() [2/8]

void* sycl::_V1::aligned_alloc ( size_t  Alignment,
size_t  Size,
const device Dev,
const context Ctxt,
alloc  Kind,
const property_list PropList,
const detail::code_location CodeLoc 
)

Definition at line 537 of file usm_impl.cpp.

◆ aligned_alloc() [3/8]

void* sycl::_V1::aligned_alloc ( size_t  alignment,
size_t  size,
const device dev,
const context ctxt,
usm::alloc  kind,
const detail::code_location CodeLoc = detail::code_location::current() 
)

◆ aligned_alloc() [4/8]

void* sycl::_V1::aligned_alloc ( size_t  alignment,
size_t  size,
const device dev,
const context ctxt,
usm::alloc  kind,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 310 of file usm.hpp.

◆ aligned_alloc() [5/8]

void* sycl::_V1::aligned_alloc ( size_t  Alignment,
size_t  Size,
const queue Q,
alloc  Kind,
const detail::code_location CodeLoc 
)

Definition at line 548 of file usm_impl.cpp.

◆ aligned_alloc() [6/8]

void* sycl::_V1::aligned_alloc ( size_t  Alignment,
size_t  Size,
const queue Q,
alloc  Kind,
const property_list PropList,
const detail::code_location CodeLoc 
)

Definition at line 558 of file usm_impl.cpp.

◆ aligned_alloc() [7/8]

void* sycl::_V1::aligned_alloc ( size_t  alignment,
size_t  size,
const queue q,
usm::alloc  kind,
const detail::code_location CodeLoc = detail::code_location::current() 
)

◆ aligned_alloc() [8/8]

void* sycl::_V1::aligned_alloc ( size_t  alignment,
size_t  size,
const queue q,
usm::alloc  kind,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 323 of file usm.hpp.

◆ aligned_alloc_device() [1/4]

void * sycl::_V1::aligned_alloc_device ( size_t  alignment,
size_t  size,
const device dev,
const context ctxt,
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 344 of file usm_impl.cpp.

◆ aligned_alloc_device() [2/4]

void * sycl::_V1::aligned_alloc_device ( size_t  alignment,
size_t  size,
const device dev,
const context ctxt,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 185 of file usm.hpp.

◆ aligned_alloc_device() [3/4]

void * sycl::_V1::aligned_alloc_device ( size_t  alignment,
size_t  size,
const queue q,
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 358 of file usm_impl.cpp.

◆ aligned_alloc_device() [4/4]

void * sycl::_V1::aligned_alloc_device ( size_t  alignment,
size_t  size,
const queue q,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 198 of file usm.hpp.

◆ aligned_alloc_host() [1/4]

void * sycl::_V1::aligned_alloc_host ( size_t  alignment,
size_t  size,
const context ctxt,
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 432 of file usm_impl.cpp.

◆ aligned_alloc_host() [2/4]

void * sycl::_V1::aligned_alloc_host ( size_t  alignment,
size_t  size,
const context ctxt,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 242 of file usm.hpp.

◆ aligned_alloc_host() [3/4]

void * sycl::_V1::aligned_alloc_host ( size_t  alignment,
size_t  size,
const queue q,
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 445 of file usm_impl.cpp.

◆ aligned_alloc_host() [4/4]

void * sycl::_V1::aligned_alloc_host ( size_t  alignment,
size_t  size,
const queue q,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 255 of file usm.hpp.

◆ aligned_alloc_shared() [1/4]

void * sycl::_V1::aligned_alloc_shared ( size_t  alignment,
size_t  size,
const device dev,
const context ctxt,
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 458 of file usm_impl.cpp.

◆ aligned_alloc_shared() [2/4]

void * sycl::_V1::aligned_alloc_shared ( size_t  alignment,
size_t  size,
const device dev,
const context ctxt,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 267 of file usm.hpp.

◆ aligned_alloc_shared() [3/4]

void * sycl::_V1::aligned_alloc_shared ( size_t  alignment,
size_t  size,
const queue q,
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 472 of file usm_impl.cpp.

◆ aligned_alloc_shared() [4/4]

void * sycl::_V1::aligned_alloc_shared ( size_t  alignment,
size_t  size,
const queue q,
const property_list propList = {},
const detail::code_location CodeLoc = detail::code_location::current() 
)

Definition at line 280 of file usm.hpp.

◆ all() [1/3]

template<typename T , size_t N>
std::enable_if_t<detail::is_sigeninteger_v<T>, bool> sycl::_V1::all ( marray< T, N >  x)

Definition at line 1142 of file builtins_legacy_marray_vec.hpp.

◆ all() [2/3]

template<typename T >
std::enable_if_t<detail::is_vigeninteger_v<T>, int> sycl::_V1::all ( x)

Definition at line 1128 of file builtins_legacy_marray_vec.hpp.

◆ all() [3/3]

template<typename T >
std::enable_if_t<detail::is_sigeninteger_v<T>, bool> sycl::_V1::all ( x)

Definition at line 919 of file builtins_legacy_scalar.hpp.

◆ all_of_group() [1/2]

template<typename Group >
std::enable_if_t<is_group_v<std::decay_t<Group> >, bool> sycl::_V1::all_of_group ( Group  g,
bool  pred 
)

Definition at line 452 of file group_algorithm.hpp.

◆ all_of_group() [2/2]

template<typename Group , typename T , class Predicate >
std::enable_if_t<is_group_v<std::decay_t<Group> >, bool> sycl::_V1::all_of_group ( Group  g,
x,
Predicate  pred 
)

Definition at line 471 of file group_algorithm.hpp.

◆ any() [1/3]

template<typename T , size_t N>
std::enable_if_t<detail::is_sigeninteger_v<T>, bool> sycl::_V1::any ( marray< T, N >  x)

Definition at line 1137 of file builtins_legacy_marray_vec.hpp.

◆ any() [2/3]

template<typename T >
std::enable_if_t<detail::is_vigeninteger_v<T>, int> sycl::_V1::any ( x)

Definition at line 1120 of file builtins_legacy_marray_vec.hpp.

◆ any() [3/3]

template<typename T >
std::enable_if_t<detail::is_sigeninteger_v<T>, bool> sycl::_V1::any ( x)

Definition at line 913 of file builtins_legacy_scalar.hpp.

◆ any_of_group() [1/2]

template<typename Group >
std::enable_if_t<is_group_v<std::decay_t<Group> >, bool> sycl::_V1::any_of_group ( Group  g,
bool  pred 
)

Definition at line 406 of file group_algorithm.hpp.

◆ any_of_group() [2/2]

template<typename Group , typename T , class Predicate >
std::enable_if_t<is_group_v<Group>, bool> sycl::_V1::any_of_group ( Group  g,
x,
Predicate  pred 
)

Definition at line 424 of file group_algorithm.hpp.

◆ as_bytes()

template<class _Tp , size_t _Extent>
_SYCL_SPAN_INLINE_VISIBILITY auto sycl::_V1::as_bytes ( span< _Tp, _Extent >  __s) -> decltype(__s.__as_bytes())
noexcept

Definition at line 606 of file sycl_span.hpp.

◆ as_writable_bytes()

template<class _Tp , size_t _Extent>
_SYCL_SPAN_INLINE_VISIBILITY auto sycl::_V1::as_writable_bytes ( span< _Tp, _Extent >  __s) -> std::enable_if_t<!std::is_const_v<_Tp>, decltype(__s.__as_writable_bytes())>
noexcept

Definition at line 613 of file sycl_span.hpp.

◆ asin()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::asin ( x)

Definition at line 66 of file builtins_legacy_scalar.hpp.

◆ asinh()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::asinh ( x)

Definition at line 72 of file builtins_legacy_scalar.hpp.

◆ asinpi()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::asinpi ( x)

Definition at line 78 of file builtins_legacy_scalar.hpp.

◆ aspect_selector() [1/3]

template<aspect... AspectList>
detail::DSelectorInvocableType sycl::_V1::aspect_selector ( )

Definition at line 169 of file device_selector.hpp.

◆ aspect_selector() [2/3]

template<typename... AspectListT>
detail::DSelectorInvocableType sycl::_V1::aspect_selector ( AspectListT...  AspectList)

Definition at line 159 of file device_selector.hpp.

◆ aspect_selector() [3/3]

detail::DSelectorInvocableType sycl::_V1::aspect_selector ( const std::vector< aspect > &  RequireList,
const std::vector< aspect > &  DenyList = {} 
)

Definition at line 256 of file device_selector.cpp.

◆ atan()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::atan ( y_over_x)

Definition at line 84 of file builtins_legacy_scalar.hpp.

◆ atan2()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::atan2 ( y,
x 
)

Definition at line 90 of file builtins_legacy_scalar.hpp.

◆ atan2pi()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::atan2pi ( y,
x 
)

Definition at line 108 of file builtins_legacy_scalar.hpp.

◆ atanh()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::atanh ( x)

Definition at line 96 of file builtins_legacy_scalar.hpp.

◆ atanpi()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::atanpi ( x)

Definition at line 102 of file builtins_legacy_scalar.hpp.

◆ atomic_compare_exchange_strong()

template<typename T , access::address_space addressSpace>
bool sycl::_V1::atomic_compare_exchange_strong ( atomic< T, addressSpace >  Object,
T &  Expected,
Desired,
memory_order  SuccessOrder = memory_order::relaxed,
memory_order  FailOrder = memory_order::relaxed 
)

Definition at line 354 of file atomic.hpp.

◆ atomic_exchange()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_exchange ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 348 of file atomic.hpp.

◆ atomic_fence()

void sycl::_V1::atomic_fence ( memory_order  order,
memory_scope  scope 
)
inline

Definition at line 22 of file atomic_fence.hpp.

◆ atomic_fetch_add()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_fetch_add ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 363 of file atomic.hpp.

◆ atomic_fetch_and()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_fetch_and ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 375 of file atomic.hpp.

◆ atomic_fetch_max()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_fetch_max ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 399 of file atomic.hpp.

◆ atomic_fetch_min()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_fetch_min ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 393 of file atomic.hpp.

◆ atomic_fetch_or()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_fetch_or ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 381 of file atomic.hpp.

◆ atomic_fetch_sub()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_fetch_sub ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 369 of file atomic.hpp.

◆ atomic_fetch_xor()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_fetch_xor ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 387 of file atomic.hpp.

◆ atomic_load()

template<typename T , access::address_space addressSpace>
T sycl::_V1::atomic_load ( atomic< T, addressSpace >  Object,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 342 of file atomic.hpp.

◆ atomic_store()

template<typename T , access::address_space addressSpace>
void sycl::_V1::atomic_store ( atomic< T, addressSpace >  Object,
Operand,
memory_order  MemoryOrder = memory_order::relaxed 
)

Definition at line 336 of file atomic.hpp.

◆ bit_cast()

template<typename To , typename From >
std::enable_if_t<sizeof(To) == sizeof(From) && std::is_trivially_copyable<From>::value && std::is_trivially_copyable<To>::value, To> sycl::_V1::bit_cast ( const From &  from)
noexcept

Definition at line 52 of file bit_cast.hpp.

◆ bitselect() [1/2]

template<typename T , size_t N>
std::enable_if_t<detail::is_gentype_v<T>, marray<T, N> > sycl::_V1::bitselect ( marray< T, N >  a,
marray< T, N >  b,
marray< T, N >  c 
)

Definition at line 1148 of file builtins_legacy_marray_vec.hpp.

◆ bitselect() [2/2]

template<typename T >
std::enable_if_t<detail::is_gentype_v<T>, T> sycl::_V1::bitselect ( a,
b,
c 
)

Definition at line 925 of file builtins_legacy_scalar.hpp.

◆ build() [1/2]

kernel_bundle<bundle_state::executable> sycl::_V1::build ( const kernel_bundle< bundle_state::input > &  InputBundle,
const property_list PropList = {} 
)
inline

Definition at line 809 of file kernel_bundle.hpp.

◆ build() [2/2]

kernel_bundle<bundle_state::executable> sycl::_V1::build ( const kernel_bundle< bundle_state::input > &  InputBundle,
const std::vector< device > &  Devs,
const property_list PropList = {} 
)
inline
Returns
a new kernel_bundle which contains device images that are translated into one ore more new device images of state bundle_state::executable. The new bundle represents all of the kernels in InputBundle that are compatible with at least one of the devices in Devs.

Definition at line 798 of file kernel_bundle.hpp.

Referenced by sycl::_V1::detail::ProgramManager::bringSYCLDeviceImagesToState(), and sycl::_V1::detail::ProgramManager::build().

◆ BUILTIN_COMMON() [1/4]

sycl::_V1::BUILTIN_COMMON ( ONE_ARG  ,
degrees  ,
[] (auto x) -> decltype(x) { return(180/M_PI) *x;}   
)

◆ BUILTIN_COMMON() [2/4]

sycl::_V1::BUILTIN_COMMON ( ONE_ARG  ,
sign  ,
[] (auto x) -> decltype(x) { using T=decltype(x);if(std::isnan(x)) return T(0.0);if(x > 0) return T(1.0);if(x< 0) return T(-1.0);return x;}   
)

◆ BUILTIN_COMMON() [3/4]

sycl::_V1::BUILTIN_COMMON ( TWO_ARGS  ,
max  ,
[] (auto x, auto y) -> decltype(x) { return(x< y ? y :x);}   
)

◆ BUILTIN_COMMON() [4/4]

sycl::_V1::BUILTIN_COMMON ( TWO_ARGS  ,
step  ,
[] (auto x, auto y) -> decltype(x) { return y< x ? 0.0 :1.0;}   
)

◆ BUILTIN_GENF_CUSTOM() [1/7]

sycl::_V1::BUILTIN_GENF_CUSTOM ( ONE_ARG  ,
acospi  ,
[] (auto x) -> decltype(x) { return std::acos(x)/M_PI;}   
)

◆ BUILTIN_GENF_CUSTOM() [2/7]

sycl::_V1::BUILTIN_GENF_CUSTOM ( ONE_ARG  ,
atanpi  ,
[] (auto x) -> decltype(x) { return std::atan(x)/M_PI;}   
)

◆ BUILTIN_GENF_CUSTOM() [3/7]

sycl::_V1::BUILTIN_GENF_CUSTOM ( ONE_ARG  ,
cospi  ,
[] (auto x) -> decltype(x) { return std::sin(M_PI *(0.5 - x));}   
)

◆ BUILTIN_GENF_CUSTOM() [4/7]

return (x >= T(0)) ? T(std sycl::_V1::BUILTIN_GENF_CUSTOM ( ONE_ARG  ,
rsqrt  ,
[] (auto x) -> decltype(x) { return decltype(x){1.0}/std::sqrt(x);}   
)

◆ BUILTIN_GENF_CUSTOM() [5/7]

sycl::_V1::BUILTIN_GENF_CUSTOM ( ONE_ARG  ,
tanpi  ,
[] (auto x) -> decltype(x) { double y=x - std::floor(x);return 1.0/std::tan((0.5 - y) *M_PI);}   
)

◆ BUILTIN_GENF_CUSTOM() [6/7]

sycl::_V1::BUILTIN_GENF_CUSTOM ( THREE_ARGS  ,
mad  ,
[] (auto x, auto y, auto z) -> decltype(x) { return(x *y)+z;}   
)

◆ BUILTIN_GENF_CUSTOM() [7/7]

sycl::_V1::BUILTIN_GENF_CUSTOM ( TWO_ARGS  ,
minmag  ,
[] (auto x, auto y) -> decltype(x) { if(std::fabs(x)< std::fabs(y)) return x;if(std::fabs(y)< std::fabs(x)) return y;return std::fmin(x, y);}   
)

◆ BUILTIN_GENINT() [1/2]

sycl::_V1::BUILTIN_GENINT ( ONE_ARG  ,
abs  ,
[] (auto x) -> decltype(x) { if constexpr(std::is_signed_v< decltype(x)>) { return std::abs(x);} else { return x;} }   
)

◆ BUILTIN_GENINT() [2/2]

sycl::_V1::BUILTIN_GENINT ( TWO_ARGS  ,
rotate  ,
[] (auto x, auto n) -> decltype(x) { using T=decltype(x);using UT=std::make_unsigned_t< T >;constexpr UT size=sizeof(x) *8;UT xu=UT(x);UT nu=UT(n) &(size - 1);return(xu<< nu)|(xu >>(size - nu));}   
) const

◆ BUILTIN_GENINT_SU() [1/5]

sycl::_V1::BUILTIN_GENINT_SU ( THREE_ARGS  ,
mad_sat  ,
[] (auto a, auto b, auto c) -> decltype(a) { using T=decltype(a);if constexpr(std::is_signed_v< T >) { if constexpr(sizeof(T)==8) { bool neg_prod=(a< 0) ^(b< 0);T mulhi=__s_long_mul_hi(a, b);if(!neg_prod &&mulhi !=0) return std::numeric_limits< T >::max();if(neg_prod &&mulhi !=-1) return std::numeric_limits< T >::min();return sycl::add_sat(T(a *b), c);} else { using UPT=sycl::detail::make_larger_t< T >;UPT mul=UPT(a) *UPT(b);UPT res=mul+UPT(c);const UPT max=std::numeric_limits< T >::max();const UPT min=std::numeric_limits< T >::min();res=std::min(std::max(res, min), max);return T(res);} } else { if constexpr(sizeof(T)==8) { T mulhi=__u_long_mul_hi(a, b);if(mulhi !=0) return std::numeric_limits< T >::max();return sycl::add_sat(T(a *b), c);} else { using UPT=sycl::detail::make_larger_t< T >;UPT mul=UPT(a) *UPT(b);const UPT min=std::numeric_limits< T >::min();const UPT max=std::numeric_limits< T >::max();mul=std::min(std::max(mul, min), max);return sycl::add_sat(T(mul), c);} } }   
)

◆ BUILTIN_GENINT_SU() [2/5]

sycl::_V1::BUILTIN_GENINT_SU ( TWO_ARGS  ,
add_sat  ,
[] (auto x, auto y) -> decltype(x) { using T=decltype(x);if constexpr(std::is_signed_v< T >) { if(x > 0 &&y > 0) return(x<(std::numeric_limits< T >::max() - y) ?(x+y) :std::numeric_limits< T >::max());if(x< 0 &&y< 0) return(x >(std::numeric_limits< T >::min() - y) ?(x+y) :std::numeric_limits< T >::min());return x+y;} else { return(x<(std::numeric_limits< T >::max() - y) ? x+y :std::numeric_limits< T >::max());} }   
)

◆ BUILTIN_GENINT_SU() [3/5]

sycl::_V1::BUILTIN_GENINT_SU ( TWO_ARGS  ,
min  ,
[] (auto x, auto y) -> decltype(x) { return y< x ? y :x;}   
)

◆ BUILTIN_GENINT_SU() [4/5]

sycl::_V1::BUILTIN_GENINT_SU ( TWO_ARGS  ,
rhadd  ,
[] (auto x, auto y) -> decltype(x) { const decltype(x) one=1;return(x >> one)+(y >> one)+((y|x) &one);}   
)

◆ BUILTIN_GENINT_SU() [5/5]

sycl::_V1::BUILTIN_GENINT_SU ( TWO_ARGS  ,
sub_sat  ,
[] (auto x, auto y) -> decltype(x) { using T=decltype(x);if constexpr(std::is_signed_v< T >) { using UT=std::make_unsigned_t< T >;T result=UT(x) - UT(y);if(((x< 0) ^(y< 0)) &&((x< 0) ^(result< 0))) result=result< 0 ? std::numeric_limits< T >::max() :std::numeric_limits< T >::min();return result;} else { return(y<(x - std::numeric_limits< T >::min())) ?(x - y) :std::numeric_limits< T >::min();} }   
)

◆ cbrt()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::cbrt ( x)

Definition at line 114 of file builtins_legacy_scalar.hpp.

◆ ceil()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::ceil ( x)

Definition at line 120 of file builtins_legacy_scalar.hpp.

◆ checkContextSupports()

static bool sycl::_V1::checkContextSupports ( const std::shared_ptr< detail::context_impl > &  ContextImpl,
sycl::detail::pi::PiContextInfo  InfoQuery 
)
static

Definition at line 1258 of file handler.cpp.

◆ CheckMaxStatementSize()

static size_t sycl::_V1::CheckMaxStatementSize ( const size_t &  MaxStatementSize)
static

Definition at line 27 of file stream.cpp.

◆ clamp() [1/6]

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::clamp ( x,
minval,
maxval 
)

Definition at line 496 of file builtins_legacy_scalar.hpp.

◆ clamp() [2/6]

template<typename T >
std::enable_if_t<detail::is_igeninteger_v<T>, T> sycl::_V1::clamp ( x,
minval,
maxval 
)

Definition at line 615 of file builtins_legacy_scalar.hpp.

◆ clamp() [3/6]

template<typename T >
std::enable_if_t<detail::is_ugeninteger_v<T>, T> sycl::_V1::clamp ( x,
minval,
maxval 
)

Definition at line 622 of file builtins_legacy_scalar.hpp.

◆ clamp() [4/6]

template<typename T >
std::enable_if_t<detail::is_vgenfloat_v<T>, T> sycl::_V1::clamp ( x,
typename T::element_type  minval,
typename T::element_type  maxval 
)

Definition at line 444 of file builtins_legacy_marray_vec.hpp.

◆ clamp() [5/6]

template<typename T >
std::enable_if_t<detail::is_vigeninteger_v<T>, T> sycl::_V1::clamp ( x,
typename T::element_type  minval,
typename T::element_type  maxval 
)

Definition at line 585 of file builtins_legacy_marray_vec.hpp.

◆ clamp() [6/6]

template<typename T >
std::enable_if_t<detail::is_vugeninteger_v<T>, T> sycl::_V1::clamp ( x,
typename T::element_type  minval,
typename T::element_type  maxval 
)

Definition at line 592 of file builtins_legacy_marray_vec.hpp.

◆ clz()

template<typename T >
std::enable_if_t<detail::is_geninteger_v<T>, T> sycl::_V1::clz ( x)

Definition at line 628 of file builtins_legacy_scalar.hpp.

◆ compile() [1/2]

kernel_bundle<bundle_state::object> sycl::_V1::compile ( const kernel_bundle< bundle_state::input > &  InputBundle,
const property_list PropList = {} 
)
inline

Definition at line 727 of file kernel_bundle.hpp.

◆ compile() [2/2]

kernel_bundle<bundle_state::object> sycl::_V1::compile ( const kernel_bundle< bundle_state::input > &  InputBundle,
const std::vector< device > &  Devs,
const property_list PropList = {} 
)
inline
Returns
a new kernel_bundle which contains the device images from InputBundle that are translated into one or more new device images of state bundle_state::object. The new bundle represents all of the kernels in InputBundles that are compatible with at least one of the devices in Devs.

Definition at line 716 of file kernel_bundle.hpp.

Referenced by sycl::_V1::detail::ProgramManager::bringSYCLDeviceImagesToState(), and sycl::_V1::detail::kernel_bundle_impl::kernel_bundle_impl().

◆ copysign()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::copysign ( x,
y 
)

Definition at line 126 of file builtins_legacy_scalar.hpp.

◆ cos() [1/2]

template<int SZ>
ESIMD_NODEBUG ESIMD_INLINE sycl::ext::intel::esimd::simd<float, SZ> sycl::_V1::cos ( sycl::ext::intel::esimd::simd< float, SZ >  x)

Definition at line 27 of file builtins_esimd.hpp.

◆ cos() [2/2]

template<typename T >
std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> sycl::_V1::cos ( x)

Definition at line 131 of file builtins_legacy_scalar.hpp.

◆ cosh()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::cosh ( x)

Definition at line 137 of file builtins_legacy_scalar.hpp.

◆ cospi()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::cospi ( x)

Definition at line 143 of file builtins_legacy_scalar.hpp.

◆ cpu_selector_v()

int sycl::_V1::cpu_selector_v ( const device dev)

Definition at line 225 of file device_selector.cpp.

Referenced by sycl::_V1::detail::select_device().

◆ cross()

template<typename T >
std::enable_if_t<detail::is_gencrossmarray_v<T>, T> sycl::_V1::cross ( p0,
p1 
)

Definition at line 1025 of file builtins_legacy_marray_vec.hpp.

◆ cross_host_impl()

template<typename T >
static T sycl::_V1::cross_host_impl ( p0,
p1 
)
inlinestatic

Definition at line 17 of file geometric_functions.cpp.

◆ ctz()

template<typename T >
std::enable_if_t<detail::is_geninteger_v<T>, T> sycl::_V1::ctz ( x)

Definition at line 633 of file builtins_legacy_scalar.hpp.

◆ degrees()

template<typename T >
std::enable_if_t<detail::is_svgenfloat_v<T>, T> sycl::_V1::degrees ( radians)

Definition at line 502 of file builtins_legacy_scalar.hpp.

◆ device::create_sub_devices< info::partition_property::ext_intel_partition_by_cslice >()

◆ device::create_sub_devices< info::partition_property::partition_by_affinity_domain >()

◆ device::create_sub_devices< info::partition_property::partition_by_counts >()

template std::vector<device> sycl::_V1::device::create_sub_devices< info::partition_property::partition_by_counts > ( const std::vector< size_t > &  Counts) const

◆ device::create_sub_devices< info::partition_property::partition_equally >()

template std::vector<device> sycl::_V1::device::create_sub_devices< info::partition_property::partition_equally > ( size_t  ComputeUnits) const

◆ device::get_info< info::device::aspects >()

template<>
std::vector<sycl::aspect> sycl::_V1::device::get_info< info::device::aspects > ( ) const

Definition at line 145 of file device.cpp.

◆ device::get_info< info::device::image_support >()

template<>
bool sycl::_V1::device::get_info< info::device::image_support > ( ) const

Definition at line 184 of file device.cpp.

◆ device::get_info< info::device::parent_device >()

template<>
device sycl::_V1::device::get_info< info::device::parent_device > ( ) const

Definition at line 145 of file device.cpp.

◆ distance() [1/3]

template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float sycl::_V1::distance ( p0,
p1 
)

Definition at line 914 of file builtins_legacy_marray_vec.hpp.

◆ distance() [2/3]

template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
double sycl::_V1::distance ( p0,
p1 
)

Definition at line 921 of file builtins_legacy_marray_vec.hpp.

◆ distance() [3/3]

template<typename T , typename = std::enable_if_t<detail::is_gengeohalf_v<T>, T>>
half sycl::_V1::distance (