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

Namespaces

 __sycl_service_kernel__
 
 acc_properties
 
 device_global_map
 
 enqueue_kernel_launch
 
 gtl
 
 gvl
 
 half_impl
 
 host_half_impl
 
 pi
 
 reduction
 
 sub_group
 
 usm
 

Classes

struct  NegateDecorated
 
struct  NegateDecorated< access::decorated::yes >
 
struct  NegateDecorated< access::decorated::no >
 
struct  TargetToAS
 
struct  TargetToAS< access::target::local >
 
struct  TargetToAS< access::target::constant_buffer >
 
struct  DecoratedType
 
struct  DecoratedType< ElementType, access::address_space::private_space >
 
struct  DecoratedType< ElementType, access::address_space::generic_space >
 
struct  DecoratedType< ElementType, access::address_space::global_space >
 
struct  DecoratedType< ElementType, access::address_space::ext_intel_global_device_space >
 
struct  DecoratedType< ElementType, access::address_space::ext_intel_global_host_space >
 
struct  DecoratedType< ElementType, access::address_space::constant_space >
 
struct  DecoratedType< ElementType, access::address_space::local_space >
 
struct  AccHostDataT
 
struct  IsCxPropertyList
 
struct  IsCxPropertyList< ext::oneapi::accessor_property_list< Props... > >
 
struct  IsCxPropertyList< ext::oneapi::accessor_property_list<> >
 
class  accessor_common
 
class  LocalAccessorBaseDevice
 
class  AccessorImplDevice
 
class  AccessorBaseHost
 
class  LocalAccessorBaseHost
 
struct  IsValidCoordDataT
 
struct  IsValidCoordDataT< 1, T >
 
struct  IsValidCoordDataT< 2, T >
 
struct  IsValidCoordDataT< 3, T >
 
class  __image_array_slice__
 
class  image_accessor
 
struct  IsValidAtomicType
 
struct  IsValidAtomicAddressSpace
 
struct  GetSpirvMemoryScope
 
struct  GetSpirvMemoryScope< access::address_space::global_space >
 
struct  GetSpirvMemoryScope< access::address_space::ext_intel_global_device_space >
 
struct  GetSpirvMemoryScope< access::address_space::local_space >
 
struct  IsValidAtomicRefType
 
struct  IsValidAtomicRefAddressSpace
 
struct  memory_order_traits
 
struct  memory_order_traits< memory_order::relaxed >
 
struct  memory_order_traits< memory_order::acq_rel >
 
struct  memory_order_traits< memory_order::seq_cst >
 
struct  bit_equal
 
struct  bit_equal< T, typename std::enable_if_t< std::is_integral< T >::value > >
 
struct  bit_equal< float >
 
struct  bit_equal< double >
 
class  atomic_ref_base
 
class  atomic_ref_impl
 
class  atomic_ref_impl< T, DefaultOrder, DefaultScope, AddressSpace, typename std::enable_if_t< std::is_integral< T >::value > >
 
class  atomic_ref_impl< T, DefaultOrder, DefaultScope, AddressSpace, typename std::enable_if_t< std::is_floating_point< T >::value > >
 
class  atomic_ref_impl< T *, DefaultOrder, DefaultScope, AddressSpace >
 
struct  BufferInterop
 
struct  BufferInterop< backend::opencl, DataT, Dimensions, AllocatorT >
 
class  buffer_plain
 
class  accessor_iterator
 
class  aligned_allocator
 
class  array
 
struct  AssertHappened
 
struct  interop
 
struct  BackendInput
 
struct  BackendReturn
 
struct  InteropFeatureSupportMap
 
struct  interop< backend::ext_oneapi_cuda, context >
 
struct  interop< backend::ext_oneapi_cuda, device >
 
struct  interop< backend::ext_oneapi_cuda, event >
 
struct  interop< backend::ext_oneapi_cuda, queue >
 
struct  interop< backend::ext_oneapi_cuda, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
 
struct  interop< backend::ext_oneapi_cuda, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
 
struct  BackendInput< backend::ext_oneapi_cuda, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_cuda, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendInput< backend::ext_oneapi_cuda, context >
 
struct  BackendReturn< backend::ext_oneapi_cuda, context >
 
struct  BackendInput< backend::ext_oneapi_cuda, device >
 
struct  BackendReturn< backend::ext_oneapi_cuda, device >
 
struct  BackendInput< backend::ext_oneapi_cuda, event >
 
struct  BackendReturn< backend::ext_oneapi_cuda, event >
 
struct  BackendInput< backend::ext_oneapi_cuda, queue >
 
struct  BackendReturn< backend::ext_oneapi_cuda, queue >
 
struct  interop< backend::ext_oneapi_hip, context >
 
struct  interop< backend::ext_oneapi_hip, device >
 
struct  interop< backend::ext_oneapi_hip, event >
 
struct  interop< backend::ext_oneapi_hip, queue >
 
struct  interop< backend::ext_oneapi_hip, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
 
struct  interop< backend::ext_oneapi_hip, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
 
struct  BackendInput< backend::ext_oneapi_hip, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_hip, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendInput< backend::ext_oneapi_hip, context >
 
struct  BackendReturn< backend::ext_oneapi_hip, context >
 
struct  BackendInput< backend::ext_oneapi_hip, device >
 
struct  BackendReturn< backend::ext_oneapi_hip, device >
 
struct  BackendInput< backend::ext_oneapi_hip, event >
 
struct  BackendReturn< backend::ext_oneapi_hip, event >
 
struct  BackendInput< backend::ext_oneapi_hip, queue >
 
struct  BackendReturn< backend::ext_oneapi_hip, queue >
 
struct  interop< backend::ext_oneapi_level_zero, context >
 
struct  interop< backend::ext_oneapi_level_zero, device >
 
struct  interop< backend::ext_oneapi_level_zero, event >
 
struct  interop< backend::ext_oneapi_level_zero, queue >
 
struct  interop< backend::ext_oneapi_level_zero, platform >
 
struct  interop< backend::ext_oneapi_level_zero, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
 
struct  interop< backend::ext_oneapi_level_zero, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
 
struct  interop< backend::ext_oneapi_level_zero, accessor< DataT, Dimensions, AccessMode, access::target::image, access::placeholder::false_t > >
 
struct  interop< backend::ext_oneapi_level_zero, kernel >
 
struct  BackendInput< backend::ext_oneapi_level_zero, context >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, context >
 
struct  BackendInput< backend::ext_oneapi_level_zero, device >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, device >
 
struct  BackendInput< backend::ext_oneapi_level_zero, event >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, event >
 
struct  BackendInput< backend::ext_oneapi_level_zero, queue >
 
struct  BackendInput< backend::ext_oneapi_level_zero, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, queue >
 
struct  BackendInput< backend::ext_oneapi_level_zero, platform >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, platform >
 
struct  BackendInput< backend::ext_oneapi_level_zero, kernel_bundle< State > >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, kernel_bundle< State > >
 
struct  BackendInput< backend::ext_oneapi_level_zero, kernel >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, kernel >
 
struct  InteropFeatureSupportMap< backend::ext_oneapi_level_zero >
 
struct  interop< backend::opencl, context >
 
struct  interop< backend::opencl, device >
 
struct  interop< backend::opencl, queue >
 
struct  interop< backend::opencl, platform >
 
struct  interop< backend::opencl, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
 
struct  interop< backend::opencl, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
 
struct  interop< backend::opencl, accessor< DataT, Dimensions, AccessMode, access::target::image, access::placeholder::false_t > >
 
struct  BackendInput< backend::opencl, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::opencl, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendInput< backend::opencl, context >
 
struct  BackendReturn< backend::opencl, context >
 
struct  BackendInput< backend::opencl, device >
 
struct  BackendReturn< backend::opencl, device >
 
struct  interop< backend::opencl, event >
 
struct  BackendInput< backend::opencl, event >
 
struct  BackendReturn< backend::opencl, event >
 
struct  BackendInput< backend::opencl, queue >
 
struct  BackendReturn< backend::opencl, queue >
 
struct  BackendInput< backend::opencl, platform >
 
struct  BackendReturn< backend::opencl, platform >
 
struct  BackendInput< backend::opencl, kernel_bundle< State > >
 
struct  BackendReturn< backend::opencl, kernel_bundle< State > >
 
struct  BackendInput< backend::opencl, kernel >
 
struct  BackendReturn< backend::opencl, kernel >
 
struct  InteropFeatureSupportMap< backend::opencl >
 
struct  Assigner
 
struct  Assigner< 0 >
 
struct  Boolean
 
struct  Boolean< 1 >
 
class  CG
 Base class for all types of command groups. More...
 
class  CGExecKernel
 "Execute kernel" command group class. More...
 
class  CGCopy
 "Copy memory" command group class. More...
 
class  CGFill
 "Fill memory" command group class. More...
 
class  CGUpdateHost
 "Update host" command group class. More...
 
class  CGCopyUSM
 "Copy USM" command group class. More...
 
class  CGFillUSM
 "Fill USM" command group class. More...
 
class  CGPrefetchUSM
 "Prefetch USM" command group class. More...
 
class  CGAdviseUSM
 "Advise USM" command group class. More...
 
class  CGInteropTask
 
class  CGHostTask
 
class  CGBarrier
 
class  ArgDesc
 
class  NDRDescT
 
struct  check_fn_signature
 
struct  check_fn_signature< F, RetT(Args...)>
 
struct  KernelLambdaHasKernelHandlerArgT
 
class  HostKernelBase
 
class  InteropTask
 
class  HostTask
 
class  HostKernel
 
struct  code_location
 
struct  InitializedVal
 
struct  InitializedVal< 1, T >
 
struct  InitializedVal< 2, T >
 
struct  InitializedVal< 3, T >
 
struct  NDLoopIterateImpl
 Helper class for the NDLoop. More...
 
struct  NDLoopIterateImpl< NDims, 0, LoopBoundTy, FuncTy, LoopIndexTy >
 
struct  NDLoop
 Generates an NDims-dimensional perfect loop nest. More...
 
struct  InlineVariableHelper
 
struct  ods_target
 
class  ods_target_list
 
struct  device_filter
 
class  device_filter_list
 
struct  nan_types
 
struct  nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_short_list >::value, T > >
 
struct  nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_int_list >::value, T > >
 
struct  nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_long_integer_list >::value, T > >
 
struct  convert_data_type_impl
 
struct  convert_data_type_impl< T, B, std::enable_if_t< is_sgentype< T >::value, T > >
 
struct  convert_data_type_impl< T, B, std::enable_if_t< is_vgentype< T >::value, T > >
 
class  TryToGetPointerT
 
class  TryToGetElementType
 
class  TryToGetVectorT
 
class  TryToGetPointerVecT
 
struct  PointerConverter
 
struct  PointerConverter< multi_ptr< ElementType, Space, DecorateAddress > >
 
struct  mptr_or_vec_elem_type
 
struct  mptr_or_vec_elem_type< multi_ptr< ElementType, Space, IsDecorated >, std::enable_if_t< IsDecorated==access::decorated::no||IsDecorated==access::decorated::yes > >
 
struct  mptr_or_vec_elem_type< const multi_ptr< ElementType, Space, IsDecorated > >
 
struct  select_cl_vector_or_scalar_or_ptr
 
struct  select_cl_vector_or_scalar_or_ptr< T, typename std::enable_if_t< is_vgentype< T >::value > >
 
struct  select_cl_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_vgentype< T >::value &&!std::is_pointer< T >::value > >
 
struct  select_cl_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_vgentype< T >::value &&std::is_pointer< T >::value > >
 
struct  select_cl_mptr_or_vector_or_scalar_or_ptr
 
struct  TypeHelper
 
struct  select_cl_mptr_or_vector_or_scalar_or_ptr< T, typename std::enable_if_t< is_genptr< T >::value &&!std::is_pointer< T >::value > >
 
struct  select_cl_mptr_or_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_genptr< T >::value||std::is_pointer< T >::value > >
 
struct  TryToGetNumElements
 
struct  TryToGetNumElements< T, typename std::enable_if_t< TryToGetVectorT< T >::value > >
 
struct  TryToGetNumElements< T, typename std::enable_if_t<!TryToGetVectorT< T >::value > >
 
struct  RelationalReturnType
 
struct  RelationalTestForSignBitType
 
struct  RelConverter
 
struct  RelConverter< T, typename std::enable_if_t< TryToGetElementType< T >::value > >
 
struct  RelConverter< T, typename std::enable_if_t<!TryToGetElementType< T >::value > >
 
class  is_same_vector_size_impl
 
class  is_same_vector_size_impl< FirstSize, T, Args... >
 
class  is_same_vector_size_impl< FirstSize >
 
class  is_same_vector_size
 
class  Builder
 
class  HostProfilingInfo
 Profiling info for the host execution. More...
 
struct  PiInfoCode
 
struct  is_platform_info_desc
 
struct  is_context_info_desc
 
struct  is_device_info_desc
 
struct  is_queue_info_desc
 
struct  is_kernel_info_desc
 
struct  is_kernel_device_specific_info_desc
 
struct  is_event_info_desc
 
struct  is_event_profiling_info_desc
 
struct  IsSubGroupInfo
 
struct  IsSubGroupInfo< info::kernel_device_specific::max_num_sub_groups >
 
struct  IsSubGroupInfo< info::kernel_device_specific::compile_num_sub_groups >
 
struct  IsSubGroupInfo< info::kernel_device_specific::max_sub_group_size >
 
struct  IsSubGroupInfo< info::kernel_device_specific::compile_sub_group_size >
 
struct  ItemBase
 
struct  ItemBase< Dims, true >
 
struct  ItemBase< Dims, false >
 
struct  conditional
 
struct  conditional< false, TrueT, FalseT >
 
struct  kernel_param_desc_t
 
struct  SpecConstantInfo
 
struct  KernelInfo
 
class  Locked
 Represents a reference to value with appropriate lock acquired. More...
 
class  OSUtil
 Groups the OS-dependent services. More...
 
class  OwnerLessBase
 
class  DataLessPropertyBase
 
class  DataLessProperty
 
class  PropertyWithDataBase
 
class  PropertyWithData
 
class  PropertyListBase
 
class  SpinLock
 SpinLock is a synchronization primitive, that uses atomic variable and causes thread trying acquire lock wait in loop while repeatedly check if the lock is available. More...
 
struct  is_output_iterator
 
struct  is_output_iterator< T, output_iterator_requirements< T > >
 
class  SYCLMemObjAllocator
 
class  SYCLMemObjAllocatorHolder
 
struct  tuple
 
struct  tuple_element
 
struct  tuple_element< N, tuple< T, Rest... > >
 
struct  tuple_element< 0, tuple< T, Rest... > >
 
struct  get
 
struct  get< 0 >
 
struct  TupleValueHolder
 
struct  TupleCopyAssignableValueHolder
 
struct  TupleCopyAssignableValueHolder< T, false >
 
struct  tuple< T, Ts... >
 
struct  tuple<>
 
struct  type_list
 
struct  is_empty_type_list
 
struct  type_list<>
 
struct  type_list< Head, Tail... >
 
struct  type_list< type_list< Head, Tail... >, Tail2... >
 
struct  is_contained
 
struct  is_contained< T, empty_type_list >
 
struct  value_list
 
struct  value_list< T, Head, Tail... >
 
struct  value_list< T >
 
struct  is_contained_value
 
struct  is_contained_value< T, Value, value_list< T > >
 
struct  is_type_size_equal
 
struct  is_type_size_greater
 
struct  is_type_size_double_of
 
struct  is_type_size_less
 
struct  is_type_size_half_of
 
struct  find_type
 
struct  find_type< empty_type_list, Comp, T >
 
struct  is_group
 
struct  is_group< group< Dimensions > >
 
struct  is_sub_group
 
struct  is_sub_group< ext::oneapi::sub_group >
 
struct  is_generic_group
 
struct  copy_cv_qualifiers
 
struct  vector_size_impl
 
struct  vector_size_impl< vec< T, N > >
 
struct  vector_size
 
struct  vector_alignment_impl
 
struct  vector_alignment
 
struct  vector_element_impl
 
struct  vector_element_impl< vec< T, N > >
 
struct  vector_element
 
struct  change_base_type
 
struct  change_base_type< vec< T, N >, B >
 
struct  copy_cv_qualifiers_impl
 
struct  copy_cv_qualifiers_impl< const T, R >
 
struct  copy_cv_qualifiers_impl< volatile T, R >
 
struct  copy_cv_qualifiers_impl< const volatile T, R >
 
struct  make_signed_impl
 
struct  make_signed_impl< T, std::enable_if_t< is_contained< T, gtl::scalar_integer_list >::value, T > >
 
struct  make_signed_impl< T, std::enable_if_t< is_contained< T, gtl::vector_integer_list >::value, T > >
 
struct  make_signed_impl< T, std::enable_if_t<!is_contained< T, gtl::integer_list >::value, T > >
 
struct  make_signed
 
struct  make_unsigned_impl
 
struct  make_unsigned_impl< T, std::enable_if_t< is_contained< T, gtl::scalar_integer_list >::value, T > >
 
struct  make_unsigned_impl< T, std::enable_if_t< is_contained< T, gtl::vector_integer_list >::value, T > >
 
struct  make_unsigned_impl< T, std::enable_if_t<!is_contained< T, gtl::integer_list >::value, T > >
 
struct  make_unsigned
 
struct  is_vec
 
struct  is_vec< sycl::vec< T, N > >
 
struct  is_integral
 
struct  is_floating_point_impl
 
struct  is_floating_point_impl< half >
 
struct  is_floating_point
 
struct  is_arithmetic
 
struct  is_scalar_arithmetic
 
struct  is_vector_arithmetic
 
struct  is_scalar_bool
 
struct  is_vector_bool
 
struct  is_bool
 
struct  is_pointer_impl
 
struct  is_pointer_impl< T * >
 
struct  is_pointer_impl< multi_ptr< T, Space, DecorateAddress > >
 
struct  is_pointer
 
struct  remove_pointer_impl
 
struct  remove_pointer_impl< T * >
 
struct  remove_pointer_impl< multi_ptr< T, Space, DecorateAddress > >
 
struct  remove_pointer
 
struct  is_address_space_compliant_impl
 
struct  is_address_space_compliant_impl< T *, SpaceList >
 
struct  is_address_space_compliant_impl< multi_ptr< T, Space, DecorateAddress >, SpaceList >
 
struct  is_address_space_compliant
 
struct  make_type_impl
 
struct  make_type_impl< vec< T, N >, TL >
 
struct  make_larger_impl
 
struct  make_larger_impl< T, std::enable_if_t< is_contained< T, gtl::scalar_floating_list >::value, T > >
 
struct  make_larger_impl< T, std::enable_if_t< is_contained< T, gtl::scalar_signed_integer_list >::value, T > >
 
struct  make_larger_impl< T, std::enable_if_t< is_contained< T, gtl::scalar_unsigned_integer_list >::value, T > >
 
struct  make_larger_impl< vec< T, N >, vec< T, N > >
 
struct  make_larger
 
struct  function_traits
 
struct  function_traits< Ret(Args...)>
 
class  Sync
 Groups and provides access to all the locks used the SYCL runtime. More...
 
struct  TempAssignGuard
 
struct  HashCStr
 
struct  CmpCStr
 
class  SYCLCategory
 
struct  IsAOTForArchitectureClass
 
class  if_architecture_helper
 
struct  IsCompileTimePropertyInstance
 
struct  interop< backend::ext_oneapi_cuda, platform >
 
struct  BackendInput< backend::ext_oneapi_cuda, platform >
 
struct  BackendReturn< backend::ext_oneapi_cuda, platform >
 
struct  InteropFeatureSupportMap< backend::ext_oneapi_cuda >
 
struct  is_native_op
 
struct  is_complex
 
struct  group_barrier_scope
 
struct  group_barrier_scope< sycl::sub_group >
 
struct  group_barrier_scope< sycl::group< D > >
 
class  __pf_kernel_wrapper
 
struct  get_kernel_wrapper_name_t
 
struct  GetMergedKernelProperties
 
struct  GetMergedKernelProperties< KernelType, PropertiesT, std::enable_if_t< ext::oneapi::experimental::detail::HasKernelPropertiesGetMethod< KernelType >::value > >
 
class  RoundedRangeKernel
 
class  RoundedRangeKernelWithKH
 
class  image_plain
 
class  auto_name
 This class is the default KernelName template parameter type for kernel invocation APIs such as single_task. More...
 
struct  get_kernel_name_t
 Helper struct to get a kernel name type based on given Name and Type types: if Name is undefined (is a auto_name) then Type becomes the Name. More...
 
class  device_image_plain
 
class  kernel_bundle_plain
 
struct  has_known_identity_impl
 
struct  known_identity_impl
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsZeroIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns zero as identity for ADD, OR, XOR operations. More...
 
struct  known_identity_impl< BinaryOperation, vec< sycl::half, NumElements >, std::enable_if_t< IsZeroIdentityOp< vec< sycl::half, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, half, std::enable_if_t< IsZeroIdentityOp< half, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsOneIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns one as identify for MULTIPLY operations. More...
 
struct  known_identity_impl< BinaryOperation, half, std::enable_if_t< IsOneIdentityOp< half, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsOnesIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns bit image consisting of all ones as identity for AND operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsMinimumIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns maximal possible value as identity for MIN operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsMaximumIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns minimal possible value as identity for MAX operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsFalseIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns false as identity for LOGICAL OR operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsTrueIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns true as identity for LOGICAL AND operations. More...
 
struct  LegacyPointerTypes
 
struct  LegacyPointerTypes< ElementType, access::address_space::constant_space >
 
struct  LegacyReferenceTypes
 
struct  LegacyReferenceTypes< ElementType, access::address_space::constant_space >
 
struct  IsCompileTimePropertyInstance< ext::intel::property::buffer_location::instance< I > >
 
struct  IsCompileTimePropertyInstance< ext::oneapi::property::no_alias::instance<> >
 
struct  IsCompileTimePropertyInstance< ext::oneapi::property::no_offset::instance<> >
 
class  reduction_impl_base
 Base non-template class which is a base class for all reduction implementation classes. More...
 
struct  IsReduction
 Predicate returning true if a type is a reduction. More...
 
struct  AreAllButLastReductions
 Predicate returning true if all template type parameters except the last one are reductions. More...
 
struct  AreAllButLastReductions< T >
 Helper specialization of AreAllButLastReductions for one element only. More...
 
struct  ReducerTraits
 Helper class for accessing reducer-defined types in CRTP May prove to be useful for other things later. More...
 
struct  ReducerTraits< reducer< T, BinaryOperation, Dims, Extent, View, Subst > >
 
class  combiner
 Use CRTP to avoid redefining shorthand operators in terms of combine. More...
 
class  reduction_impl_common
 Templated class for common functionality of all reduction implementation classes. More...
 
struct  data_dim_t
 
struct  data_dim_t< accessor< T, AccessorDims, Mode, access::target::device, IsPH, PropList > >
 
struct  get_red_t
 
struct  get_red_t< T * >
 
struct  get_red_t< accessor< T, AccessorDims, Mode, access::target::device, IsPH, PropList > >
 
class  reduction_impl_algo
 
class  reduction_impl
 This class encapsulates the reduction variable/accessor, the reduction operator and an optional operator identity. More...
 
struct  NDRangeReduction
 
struct  NDRangeReduction< reduction::strategy::local_atomic_and_atomic_cross_wg >
 
struct  NDRangeReduction< reduction::strategy::group_reduce_and_last_wg_detection >
 
struct  NDRangeReduction< reduction::strategy::range_basic >
 
struct  NDRangeReduction< reduction::strategy::group_reduce_and_atomic_cross_wg >
 
struct  NDRangeReduction< reduction::strategy::local_mem_tree_and_atomic_cross_wg >
 
struct  NDRangeReduction< reduction::strategy::group_reduce_and_multiple_kernels >
 
struct  NDRangeReduction< reduction::strategy::basic >
 
struct  IsNonUsmReductionPredicate
 
struct  EmptyReductionPredicate
 
struct  FilterElement
 
struct  IsScalarReduction
 
struct  IsArrayReduction
 
struct  NDRangeReduction< reduction::strategy::multi >
 
struct  NDRangeReduction< reduction::strategy::auto_select >
 
struct  IsSwizzleOp
 
struct  IsSwizzleOp< sycl::detail::SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  vec_helper
 
class  SwizzleOp
 
class  BaseCLTypeConverter
 
class  GetOp
 
class  GetScalarOp
 
struct  EqualTo
 
struct  NotEqualTo
 
struct  GreaterEqualTo
 
struct  LessEqualTo
 
struct  GreaterThan
 
struct  LessThan
 
struct  LogicalAnd
 
struct  LogicalOr
 
struct  RShift
 
struct  LShift
 
struct  IsDeprecatedDeviceCopyable
 
class  AccessorImplHost
 
class  LocalAccessorImplHost
 
class  buffer_impl
 
class  CircularBuffer
 
class  SYCLConfigBase
 
class  SYCLConfig
 
class  SYCLConfig< SYCL_PI_TRACE >
 
class  SYCLConfig< SYCL_RT_WARNING_LEVEL >
 
class  SYCLConfig< SYCL_PARALLEL_FOR_RANGE_ROUNDING_TRACE >
 
class  SYCLConfig< SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING >
 
class  SYCLConfig< SYCL_PARALLEL_FOR_RANGE_ROUNDING_PARAMS >
 
class  SYCLConfig< ONEAPI_DEVICE_SELECTOR >
 
class  SYCLConfig< SYCL_ENABLE_DEFAULT_CONTEXTS >
 
class  SYCLConfig< SYCL_QUEUE_THREAD_POOL_SIZE >
 
class  SYCLConfig< SYCL_CACHE_PERSISTENT >
 
class  SYCLConfig< SYCL_CACHE_DIR >
 
class  SYCLConfig< SYCL_REDUCTION_PREFERRED_WORKGROUP_SIZE >
 
class  context_impl
 
class  ByteArray
 
class  DeviceBinaryProperty
 
class  RTDeviceBinaryImage
 
class  DynRTDeviceBinaryImage
 
struct  DeviceGlobalMapEntry
 
struct  LessByHash
 
class  device_image_impl
 
class  device_impl
 
struct  sycl_to_pi
 
struct  sycl_to_pi< bool >
 
struct  sycl_to_pi< device >
 
struct  sycl_to_pi< platform >
 
struct  check_fp_support
 
struct  check_fp_support< info::device::half_fp_config >
 
struct  check_fp_support< info::device::double_fp_config >
 
struct  get_device_info_impl
 
struct  get_device_info_impl< platform, Param >
 
struct  get_device_info_impl< std::string, Param >
 
struct  get_device_info_impl< ReturnT, info::device::parent_device >
 
struct  get_device_info_impl< std::vector< info::fp_config >, Param >
 
struct  get_device_info_impl< std::string, info::device::version >
 
struct  get_device_info_impl< std::vector< info::fp_config >, info::device::single_fp_config >
 
struct  get_device_info_impl< bool, info::device::queue_profiling >
 
struct  get_device_info_impl< std::vector< memory_order >, info::device::atomic_memory_order_capabilities >
 
struct  get_device_info_impl< std::vector< memory_scope >, info::device::atomic_memory_scope_capabilities >
 
struct  get_device_info_impl< bool, info::device::ext_oneapi_bfloat16_math_functions >
 
struct  get_device_info_impl< std::vector< info::execution_capability >, info::device::execution_capabilities >
 
struct  get_device_info_impl< std::vector< kernel_id >, info::device::built_in_kernel_ids >
 
struct  get_device_info_impl< std::vector< std::string >, info::device::built_in_kernels >
 
struct  get_device_info_impl< std::vector< std::string >, info::device::extensions >
 
struct  get_device_info_impl< std::vector< info::partition_property >, info::device::partition_properties >
 
struct  get_device_info_impl< std::vector< info::partition_affinity_domain >, info::device::partition_affinity_domains >
 
struct  get_device_info_impl< info::partition_affinity_domain, info::device::partition_type_affinity_domain >
 
struct  get_device_info_impl< info::partition_property, info::device::partition_type_property >
 
struct  get_device_info_impl< std::vector< size_t >, info::device::sub_group_sizes >
 
struct  get_device_info_impl< bool, info::device::kernel_kernel_pipe_support >
 
struct  get_device_info_impl< id< Dimensions >, info::device::max_work_item_sizes< Dimensions > >
 
struct  get_device_info_impl< size_t, ext::oneapi::experimental::info::device::max_global_work_groups >
 
struct  get_device_info_impl< id< 1 >, ext::oneapi::experimental::info::device::max_work_groups< 1 > >
 
struct  get_device_info_impl< id< 2 >, ext::oneapi::experimental::info::device::max_work_groups< 2 > >
 
struct  get_device_info_impl< id< 3 >, ext::oneapi::experimental::info::device::max_work_groups< 3 > >
 
struct  get_device_info_impl< size_t, info::device::ext_oneapi_max_global_work_groups >
 
struct  get_device_info_impl< id< 1 >, info::device::ext_oneapi_max_work_groups_1d >
 
struct  get_device_info_impl< id< 2 >, info::device::ext_oneapi_max_work_groups_2d >
 
struct  get_device_info_impl< id< 3 >, info::device::ext_oneapi_max_work_groups_3d >
 
struct  get_device_info_impl< device, info::device::parent_device >
 
struct  get_device_info_impl< bool, info::device::usm_device_allocations >
 
struct  get_device_info_impl< bool, info::device::usm_host_allocations >
 
struct  get_device_info_impl< bool, info::device::usm_shared_allocations >
 
struct  get_device_info_impl< bool, info::device::usm_restricted_shared_allocations >
 
struct  get_device_info_impl< bool, info::device::usm_system_allocations >
 
struct  get_device_info_impl< bool, info::device::ext_intel_mem_channel >
 
class  event_impl
 
class  fusion_wrapper_impl
 
struct  DefaultContextReleaseHandler
 
class  GlobalHandler
 Wrapper class for global data structures with non-trivial destructors. More...
 
class  handler_impl
 
class  image_impl
 
class  kernel_bundle_impl
 
struct  LessByNameComp
 
struct  EqualByNameComp
 
class  kernel_id_impl
 
class  kernel_impl
 
class  KernelProgramCache
 
struct  TermPositions
 
class  MemoryManager
 
class  LockCacheItem
 
class  PersistentDeviceCodeCache
 
class  platform_impl
 
struct  PlatformUtil
 
struct  array_fill_helper
 
struct  PiApiArgTuple
 
struct  array_fill_helper< Kind, Idx, T >
 
struct  array_fill_helper< Kind, Idx, T, Args... >
 
class  plugin
 The plugin class provides a unified interface to the underlying low-level runtimes for the device-agnostic SYCL runtime. More...
 
class  program_impl
 
class  ProgramManager
 
class  queue_impl
 
class  sampler_impl
 
class  DispatchHostTask
 
struct  EnqueueResultT
 Result of command enqueueing. More...
 
struct  DepDesc
 Dependency between two commands. More...
 
class  Command
 The Command class represents some action that needs to be performed on one or more memory objects. More...
 
class  EmptyCommand
 The empty command does nothing during enqueue. More...
 
class  ReleaseCommand
 The release command enqueues release of a memory object instance allocated on Host or underlying framework. More...
 
class  AllocaCommandBase
 Base class for memory allocation commands. More...
 
class  AllocaCommand
 The alloca command enqueues allocation of instance of memory object on Host or underlying framework. More...
 
class  AllocaSubBufCommand
 The AllocaSubBuf command enqueues creation of sub-buffer of memory object. More...
 
class  MapMemObject
 The map command enqueues mapping of device memory onto host memory. More...
 
class  UnMapMemObject
 The unmap command removes mapping of host memory onto device memory. More...
 
class  MemCpyCommand
 The mem copy command enqueues memory copy between two instances of memory object. More...
 
class  MemCpyCommandHost
 The mem copy host command enqueues memory copy between two instances of memory object. More...
 
class  ExecCGCommand
 The exec CG command enqueues execution of kernel or explicit memory operation. More...
 
class  UpdateHostRequirementCommand
 
class  LeavesCollection
 A wrapper for CircularBuffer class along with collection for host accessor's EmptyCommands. More...
 
struct  MemObjRecord
 Memory Object Record. More...
 
class  Scheduler
 DPC++ graph scheduler class. More...
 
class  spec_constant_impl
 
class  stream_impl
 
class  SYCLMemObjI
 
class  SYCLMemObjT
 
class  ThreadPool
 
class  XPTIRegistry
 

Typedefs

template<typename T >
using IsPropertyListT = typename std::is_base_of< PropertyListBase, T >
 
template<typename T >
using IsRunTimePropertyListT = typename std::is_same< ext::oneapi::accessor_property_list<>, T >
 
using AccessorImplPtr = std::shared_ptr< AccessorImplHost >
 
using LocalAccessorImplPtr = std::shared_ptr< LocalAccessorImplHost >
 
using memory_order = sycl::memory_order
 
using memory_scope = sycl::memory_scope
 
template<memory_order Order>
using IsValidDefaultOrder = std::bool_constant< Order==memory_order::relaxed||Order==memory_order::acq_rel||Order==memory_order::seq_cst >
 
using EventImplPtr = std::shared_ptr< event_impl >
 
template<typename DataT >
using EnableIfOutputPointerT = std::enable_if_t< std::is_pointer< DataT >::value >
 
template<typename DataT >
using EnableIfOutputIteratorT = std::enable_if_t< !std::is_pointer< DataT >::value >
 
using KernelSetId = size_t
 
template<typename T >
using is_floatn = is_contained< T, gtl::vector_float_list >
 
template<typename T >
using is_genfloatf = is_contained< T, gtl::float_list >
 
template<typename T >
using is_svgenfloatf = is_contained< T, gtl::scalar_vector_float_list >
 
template<typename T >
using is_doublen = is_contained< T, gtl::vector_double_list >
 
template<typename T >
using is_genfloatd = is_contained< T, gtl::double_list >
 
template<typename T >
using is_svgenfloatd = is_contained< T, gtl::scalar_vector_double_list >
 
template<typename T >
using is_halfn = is_contained< T, gtl::vector_half_list >
 
template<typename T >
using is_genfloath = is_contained< T, gtl::half_list >
 
template<typename T >
using is_svgenfloath = is_contained< T, gtl::scalar_vector_half_list >
 
template<typename T >
using is_genfloat = is_contained< T, gtl::floating_list >
 
template<typename T >
using is_sgenfloat = is_contained< T, gtl::scalar_floating_list >
 
template<typename T >
using is_vgenfloat = is_contained< T, gtl::vector_floating_list >
 
template<typename T >
using is_svgenfloat = is_contained< T, gtl::scalar_vector_floating_list >
 
template<typename T >
using is_gengeofloat = is_contained< T, gtl::geo_float_list >
 
template<typename T >
using is_gengeodouble = is_contained< T, gtl::geo_double_list >
 
template<typename T >
using is_gengeohalf = is_contained< T, gtl::geo_half_list >
 
template<typename T >
using is_vgengeofloat = is_contained< T, gtl::vector_geo_float_list >
 
template<typename T >
using is_vgengeodouble = is_contained< T, gtl::vector_geo_double_list >
 
template<typename T >
using is_vgengeohalf = is_contained< T, gtl::vector_geo_half_list >
 
template<typename T >
using is_sgengeo = is_contained< T, gtl::scalar_geo_list >
 
template<typename T >
using is_vgengeo = is_contained< T, gtl::vector_geo_list >
 
template<typename T >
using is_gencrossfloat = is_contained< T, gtl::cross_float_list >
 
template<typename T >
using is_gencrossdouble = is_contained< T, gtl::cross_double_list >
 
template<typename T >
using is_gencrosshalf = is_contained< T, gtl::cross_half_list >
 
template<typename T >
using is_gencross = is_contained< T, gtl::cross_floating_list >
 
template<typename T >
using is_charn = is_contained< T, gtl::vector_default_char_list >
 
template<typename T >
using is_scharn = is_contained< T, gtl::vector_signed_char_list >
 
template<typename T >
using is_ucharn = is_contained< T, gtl::vector_unsigned_char_list >
 
template<typename T >
using is_igenchar = is_contained< T, gtl::signed_char_list >
 
template<typename T >
using is_ugenchar = is_contained< T, gtl::unsigned_char_list >
 
template<typename T >
using is_genchar = is_contained< T, gtl::char_list >
 
template<typename T >
using is_shortn = is_contained< T, gtl::vector_signed_short_list >
 
template<typename T >
using is_genshort = is_contained< T, gtl::signed_short_list >
 
template<typename T >
using is_ushortn = is_contained< T, gtl::vector_unsigned_short_list >
 
template<typename T >
using is_ugenshort = is_contained< T, gtl::unsigned_short_list >
 
template<typename T >
using is_uintn = is_contained< T, gtl::vector_unsigned_int_list >
 
template<typename T >
using is_ugenint = is_contained< T, gtl::unsigned_int_list >
 
template<typename T >
using is_intn = is_contained< T, gtl::vector_signed_int_list >
 
template<typename T >
using is_genint = is_contained< T, gtl::signed_int_list >
 
template<typename T >
using is_ulongn = is_contained< T, gtl::vector_unsigned_long_list >
 
template<typename T >
using is_ugenlong = is_contained< T, gtl::unsigned_long_list >
 
template<typename T >
using is_longn = is_contained< T, gtl::vector_signed_long_list >
 
template<typename T >
using is_genlong = is_contained< T, gtl::signed_long_list >
 
template<typename T >
using is_ulonglongn = is_contained< T, gtl::vector_unsigned_longlong_list >
 
template<typename T >
using is_ugenlonglong = is_contained< T, gtl::unsigned_longlong_list >
 
template<typename T >
using is_longlongn = is_contained< T, gtl::vector_signed_longlong_list >
 
template<typename T >
using is_genlonglong = is_contained< T, gtl::signed_longlong_list >
 
template<typename T >
using is_igenlonginteger = is_contained< T, gtl::signed_long_integer_list >
 
template<typename T >
using is_ugenlonginteger = is_contained< T, gtl::unsigned_long_integer_list >
 
template<typename T >
using is_geninteger = is_contained< T, gtl::integer_list >
 
template<typename T >
using is_igeninteger = is_contained< T, gtl::signed_integer_list >
 
template<typename T >
using is_ugeninteger = is_contained< T, gtl::unsigned_integer_list >
 
template<typename T >
using is_sgeninteger = is_contained< T, gtl::scalar_integer_list >
 
template<typename T >
using is_vgeninteger = is_contained< T, gtl::vector_integer_list >
 
template<typename T >
using is_sigeninteger = is_contained< T, gtl::scalar_signed_integer_list >
 
template<typename T >
using is_sugeninteger = is_contained< T, gtl::scalar_unsigned_integer_list >
 
template<typename T >
using is_vigeninteger = is_contained< T, gtl::vector_signed_integer_list >
 
template<typename T >
using is_vugeninteger = is_contained< T, gtl::vector_unsigned_integer_list >
 
template<typename T >
using is_gentype = is_contained< T, gtl::basic_list >
 
template<typename T >
using is_vgentype = is_contained< T, gtl::vector_basic_list >
 
template<typename T >
using is_sgentype = is_contained< T, gtl::scalar_basic_list >
 
template<typename T >
using is_igeninteger8bit = is_gen_based_on_type_sizeof< T, 1, is_igeninteger >
 
template<typename T >
using is_igeninteger16bit = is_gen_based_on_type_sizeof< T, 2, is_igeninteger >
 
template<typename T >
using is_igeninteger32bit = is_gen_based_on_type_sizeof< T, 4, is_igeninteger >
 
template<typename T >
using is_igeninteger64bit = is_gen_based_on_type_sizeof< T, 8, is_igeninteger >
 
template<typename T >
using is_ugeninteger8bit = is_gen_based_on_type_sizeof< T, 1, is_ugeninteger >
 
template<typename T >
using is_ugeninteger16bit = is_gen_based_on_type_sizeof< T, 2, is_ugeninteger >
 
template<typename T >
using is_ugeninteger32bit = is_gen_based_on_type_sizeof< T, 4, is_ugeninteger >
 
template<typename T >
using is_ugeninteger64bit = is_gen_based_on_type_sizeof< T, 8, is_ugeninteger >
 
template<typename T >
using is_geninteger8bit = is_gen_based_on_type_sizeof< T, 1, is_geninteger >
 
template<typename T >
using is_geninteger16bit = is_gen_based_on_type_sizeof< T, 2, is_geninteger >
 
template<typename T >
using is_geninteger32bit = is_gen_based_on_type_sizeof< T, 4, is_geninteger >
 
template<typename T >
using is_geninteger64bit = is_gen_based_on_type_sizeof< T, 8, is_geninteger >
 
template<typename T >
using is_genintptr = std::bool_constant< is_pointer< T >::value &&is_genint< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
 
template<typename T >
using is_genfloatptr = std::bool_constant< is_pointer< T >::value &&is_genfloat< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
 
template<typename T >
using is_genptr = std::bool_constant< is_pointer< T >::value &&is_gentype< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
 
template<typename T >
using is_nan_type = is_contained< T, gtl::nan_list >
 
template<typename T >
using nan_return_t = typename nan_types< T, T >::ret_type
 
template<typename T >
using nan_argument_base_t = typename nan_types< T, T >::arg_type
 
template<typename T >
using make_floating_point_t = make_type_t< T, gtl::scalar_floating_list >
 
template<typename T >
using make_singed_integer_t = make_type_t< T, gtl::scalar_signed_integer_list >
 
template<typename T >
using make_unsinged_integer_t = make_type_t< T, gtl::scalar_unsigned_integer_list >
 
template<typename T , typename B >
using convert_data_type = convert_data_type_impl< T, B, T >
 
template<typename T >
using mptr_or_vec_elem_type_t = typename mptr_or_vec_elem_type< T >::type
 
template<typename T , typename T8 , typename T16 , typename T32 , typename T64 >
using select_apply_cl_scalar_t = std::conditional_t< sizeof(T)==1, T8, std::conditional_t< sizeof(T)==2, T16, std::conditional_t< sizeof(T)==4, T32, T64 > >>
 
template<typename T >
using select_cl_scalar_integral_signed_t = select_apply_cl_scalar_t< T, sycl::cl_char, sycl::cl_short, sycl::cl_int, sycl::cl_long >
 
template<typename T >
using select_cl_scalar_integral_unsigned_t = select_apply_cl_scalar_t< T, sycl::cl_uchar, sycl::cl_ushort, sycl::cl_uint, sycl::cl_ulong >
 
template<typename T >
using select_cl_scalar_float_t = select_apply_cl_scalar_t< T, std::false_type, sycl::cl_half, sycl::cl_float, sycl::cl_double >
 
template<typename T >
using select_cl_scalar_integral_t = std::conditional_t< std::is_signed< T >::value, select_cl_scalar_integral_signed_t< T >, select_cl_scalar_integral_unsigned_t< T > >
 
template<typename T >
using select_cl_scalar_t = std::conditional_t< std::is_integral< T >::value, select_cl_scalar_integral_t< T >, std::conditional_t< std::is_floating_point< T >::value, select_cl_scalar_float_t< T >, std::conditional_t< std::is_same< T, half >::value, sycl::detail::half_impl::BIsRepresentationT, T > >>
 
template<typename T >
using type_helper = typename TypeHelper< T >::RetType
 
template<typename T >
using SelectMatchingOpenCLType_t = typename select_cl_mptr_or_vector_or_scalar_or_ptr< T >::type
 
template<typename T >
using ConvertToOpenCLType_t = std::conditional_t< TryToGetVectorT< SelectMatchingOpenCLType_t< T > >::value, typename TryToGetVectorT< SelectMatchingOpenCLType_t< T > >::type, std::conditional_t< TryToGetPointerT< SelectMatchingOpenCLType_t< T > >::value, typename TryToGetPointerVecT< SelectMatchingOpenCLType_t< T > >::type, SelectMatchingOpenCLType_t< T > >>
 
template<typename T >
using common_rel_ret_t = std::conditional_t< is_vgentype< T >::value, make_singed_integer_t< T >, int >
 
template<typename T >
using internal_host_rel_ret_t = common_rel_ret_t< T >
 
template<typename T >
using internal_rel_ret_t = typename RelationalReturnType< T >::type
 
template<typename T >
using rel_sign_bit_test_ret_t = typename RelationalTestForSignBitType< T >::return_type
 
template<typename T >
using rel_sign_bit_test_arg_t = typename RelationalTestForSignBitType< T >::argument_type
 
template<typename T >
using IsValidCoordType = typename is_contained< T, type_list< cl_int, cl_float > >::type
 
using int64_t = conditional< sizeof(long)==8, long, long long >::type
 
using OSModuleHandle = intptr_t
 Uniquely identifies an operating system module (executable or a dynamic library) More...
 
template<typename T >
using iterator_category_t = typename std::iterator_traits< T >::iterator_category
 
template<typename T >
using iterator_value_type_t = typename std::iterator_traits< T >::value_type
 
template<typename T >
using iterator_pointer_t = typename std::iterator_traits< T >::pointer
 
template<typename T >
using iterator_to_const_type_t = std::is_const< typename std::remove_pointer< iterator_pointer_t< T > >::type >
 
template<typename T >
using output_iterator_requirements = std::void_t< iterator_category_t< T >, decltype(*std::declval< T >()=std::declval< iterator_value_type_t< T > >())>
 
template<typename DataT >
using sycl_memory_object_allocator = aligned_allocator< DataT >
 
template<std::size_t I, class T >
using tuple_element_t = typename tuple_element< I, T >::type
 
template<typename T >
using head_t = typename T::head
 
template<typename T >
using tail_t = typename T::tail
 
using empty_type_list = type_list<>
 
template<access::address_space... Values>
using address_space_list = value_list< access::address_space, Values... >
 
template<access::address_space AddressSpace, typename ValueList >
using is_one_of_spaces = is_contained_value< access::address_space, AddressSpace, ValueList >
 
template<typename TypeList , template< typename, typename > class Comp, typename T >
using find_type_t = typename find_type< TypeList, Comp, T >::type
 
template<typename TypeList , typename T >
using find_same_size_type_t = find_type_t< TypeList, is_type_size_equal, T >
 
template<typename TypeList , typename T >
using find_smaller_type_t = find_type_t< TypeList, is_type_size_less, T >
 
template<typename TypeList , typename T >
using find_larger_type_t = find_type_t< TypeList, is_type_size_greater, T >
 
template<typename TypeList , typename T >
using find_twice_as_small_type_t = find_type_t< TypeList, is_type_size_half_of, T >
 
template<typename TypeList , typename T >
using find_twice_as_large_type_t = find_type_t< TypeList, is_type_size_double_of, T >
 
using uuid_type = std::array< unsigned char, 16 >
 
template<typename T , typename R >
using copy_cv_qualifiers_t = typename copy_cv_qualifiers< T, R >::type
 
template<int V>
using int_constant = std::integral_constant< int, V >
 
template<typename T >
using vector_element_impl_t = typename vector_element_impl< T >::type
 
template<class T >
using vector_element_t = typename vector_element< T >::type
 
template<typename T , typename B >
using change_base_type_t = typename change_base_type< T, B >::type
 
template<typename T >
using make_signed_impl_t = typename make_signed_impl< T, T >::type
 
template<typename T >
using make_signed_t = typename make_signed< T >::type
 
template<typename T >
using make_unsigned_impl_t = typename make_unsigned_impl< T, T >::type
 
template<typename T >
using make_unsigned_t = typename make_unsigned< T >::type
 
template<typename T , int N, template< typename > class S>
using is_gen_based_on_type_sizeof = std::bool_constant< S< T >::value &&(sizeof(vector_element_t< T >)==N)>
 
template<typename T >
using remove_pointer_t = typename remove_pointer< T >::type
 
template<typename T , typename TL >
using make_type_t = typename make_type_impl< T, TL >::type
 
template<typename T >
using make_larger_t = typename make_larger< T >::type
 
template<access::address_space AS, class DataT >
using const_if_const_AS = DataT
 
using SerializedObj = std::vector< unsigned char >
 
using DSelectorInvocableType = std::function< int(const sycl::device &)>
 
template<typename T >
using native_op_list = type_list< sycl::plus< T >, sycl::bit_or< T >, sycl::bit_xor< T >, sycl::bit_and< T >, sycl::maximum< T >, sycl::minimum< T >, sycl::multiplies< T > >
 
template<typename T , typename BinaryOperation >
using is_plus = std::integral_constant< bool, std::is_same< BinaryOperation, sycl::plus< T > >::value||std::is_same< BinaryOperation, sycl::plus< void > >::value >
 
template<typename T >
using is_arithmetic_or_complex = std::integral_constant< bool, sycl::detail::is_complex< T >::value||sycl::detail::is_arithmetic< T >::value >
 
template<typename T , typename BinaryOperation >
using is_plus_if_complex = std::integral_constant< bool,(is_complex< T >::value ? is_plus< T, BinaryOperation >::value :std::true_type::value)>
 
template<typename F , typename SuggestedArgType >
using lambda_arg_type = decltype(argument_helper< F, SuggestedArgType >(0))
 
template<typename T >
using is_validImageDataT = typename detail::is_contained< T, type_list< cl_int4, cl_uint4, cl_float4, cl_half4 > >::type
 
template<typename DataT >
using EnableIfImgAccDataT = typename std::enable_if_t< is_validImageDataT< DataT >::value, DataT >
 
using DeviceImageImplPtr = std::shared_ptr< device_image_impl >
 
using KernelBundleImplPtr = std::shared_ptr< detail::kernel_bundle_impl >
 
using DevImgSelectorImpl = std::function< bool(const detail::DeviceImageImplPtr &DevImgImpl)>
 
template<typename T , class BinaryOperation >
using IsPlus = std::bool_constant< std::is_same< BinaryOperation, sycl::plus< T > >::value||std::is_same< BinaryOperation, sycl::plus< void > >::value >
 
template<typename T , class BinaryOperation >
using IsMultiplies = std::bool_constant< std::is_same< BinaryOperation, sycl::multiplies< T > >::value||std::is_same< BinaryOperation, sycl::multiplies< void > >::value >
 
template<typename T , class BinaryOperation >
using IsMinimum = std::bool_constant< std::is_same< BinaryOperation, sycl::minimum< T > >::value||std::is_same< BinaryOperation, sycl::minimum< void > >::value >
 
template<typename T , class BinaryOperation >
using IsMaximum = std::bool_constant< std::is_same< BinaryOperation, sycl::maximum< T > >::value||std::is_same< BinaryOperation, sycl::maximum< void > >::value >
 
template<typename T , class BinaryOperation >
using IsBitAND = std::bool_constant< std::is_same< BinaryOperation, sycl::bit_and< T > >::value||std::is_same< BinaryOperation, sycl::bit_and< void > >::value >
 
template<typename T , class BinaryOperation >
using IsBitOR = std::bool_constant< std::is_same< BinaryOperation, sycl::bit_or< T > >::value||std::is_same< BinaryOperation, sycl::bit_or< void > >::value >
 
template<typename T , class BinaryOperation >
using IsBitXOR = std::bool_constant< std::is_same< BinaryOperation, sycl::bit_xor< T > >::value||std::is_same< BinaryOperation, sycl::bit_xor< void > >::value >
 
template<typename T , class BinaryOperation >
using IsLogicalAND = std::bool_constant< std::is_same< BinaryOperation, sycl::logical_and< T > >::value||std::is_same< BinaryOperation, sycl::logical_and< void > >::value >
 
template<typename T , class BinaryOperation >
using IsLogicalOR = std::bool_constant< std::is_same< BinaryOperation, sycl::logical_or< T > >::value||std::is_same< BinaryOperation, sycl::logical_or< void > >::value >
 
template<typename T , class BinaryOperation >
using IsZeroIdentityOp = std::bool_constant<(is_geninteger< T >::value &&(IsPlus< T, BinaryOperation >::value||IsBitOR< T, BinaryOperation >::value||IsBitXOR< T, BinaryOperation >::value))||(is_genfloat< T >::value &&IsPlus< T, BinaryOperation >::value)>
 
template<typename T , class BinaryOperation >
using IsOneIdentityOp = std::bool_constant<(is_geninteger< T >::value||is_genfloat< T >::value) &&IsMultiplies< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsOnesIdentityOp = std::bool_constant< is_geninteger< T >::value &&IsBitAND< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsMinimumIdentityOp = std::bool_constant<(is_geninteger< T >::value||is_genfloat< T >::value) &&IsMinimum< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsMaximumIdentityOp = std::bool_constant<(is_geninteger< T >::value||is_genfloat< T >::value) &&IsMaximum< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsFalseIdentityOp = std::bool_constant< IsLogicalOR< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsTrueIdentityOp = std::bool_constant< IsLogicalAND< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsKnownIdentityOp = std::bool_constant< IsZeroIdentityOp< T, BinaryOperation >::value||IsOneIdentityOp< T, BinaryOperation >::value||IsOnesIdentityOp< T, BinaryOperation >::value||IsMinimumIdentityOp< T, BinaryOperation >::value||IsMaximumIdentityOp< T, BinaryOperation >::value||IsFalseIdentityOp< T, BinaryOperation >::value||IsTrueIdentityOp< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsReduOptForFastAtomicFetch = std::bool_constant<((is_sgenfloat< T >::value &&sizeof(T)==4)||is_sgeninteger< T >::value) &&IsValidAtomicType< T >::value &&(IsPlus< T, BinaryOperation >::value||IsMinimum< T, BinaryOperation >::value||IsMaximum< T, BinaryOperation >::value||IsBitOR< T, BinaryOperation >::value||IsBitXOR< T, BinaryOperation >::value||IsBitAND< T, BinaryOperation >::value)>
 
template<typename T , class BinaryOperation >
using IsReduOptForAtomic64Op = std::bool_constant<(IsPlus< T, BinaryOperation >::value||IsMinimum< T, BinaryOperation >::value||IsMaximum< T, BinaryOperation >::value) &&is_sgenfloat< T >::value &&sizeof(T)==8 >
 
template<typename T , class BinaryOperation >
using IsReduOptForFastReduce = std::bool_constant<((is_sgeninteger< T >::value &&(sizeof(T)==4||sizeof(T)==8))||is_sgenfloat< T >::value) &&(IsPlus< T, BinaryOperation >::value||IsMinimum< T, BinaryOperation >::value||IsMaximum< T, BinaryOperation >::value)>
 
template<typename... Ts>
using ReduTupleT = sycl::detail::tuple< Ts... >
 
template<template< typename, reduction::strategy, typename... > class MainOrAux, class KernelName , reduction::strategy Strategy, class... Ts>
using __sycl_reduction_kernel = std::conditional_t< std::is_same< KernelName, auto_name >::value, auto_name, MainOrAux< KernelName, Strategy, Ts... > >
 A helper to pass undefined (sycl::detail::auto_name) names unmodified. More...
 
using FmtFlags = unsigned int
 
template<class F , class T = void>
using EnableIfFP = typename std::enable_if_t< std::is_same< F, float >::value||std::is_same< F, double >::value||std::is_same< F, half >::value, T >
 
using GlobalBufAccessorT = accessor< char, 1, sycl::access::mode::read_write, sycl::access::target::global_buffer, sycl::access::placeholder::false_t >
 
using GlobalBufPtrType = typename detail::DecoratedType< char, GlobalBufAS >::type *
 
using GlobalOffsetAccessorT = accessor< unsigned, 1, sycl::access::mode::atomic, sycl::access::target::global_buffer, sycl::access::placeholder::false_t >
 
using GlobalOffsetPtrType = typename detail::DecoratedType< unsigned, GlobalBufAS >::type *
 
template<typename T >
using EnableIfSwizzleVec = typename std::enable_if_t< IsSwizzleOp< T >::value, typename IsSwizzleOp< T >::Type >
 
template<typename DataT >
using rel_t = typename std::conditional_t< sizeof(DataT)==sizeof(cl_char), cl_char, typename std::conditional_t< sizeof(DataT)==sizeof(cl_short), cl_short, typename std::conditional_t< sizeof(DataT)==sizeof(cl_int), cl_int, typename std::conditional_t< sizeof(DataT)==sizeof(cl_long), cl_long, bool > >> >
 
template<typename T , typename R >
using is_int_to_int = std::integral_constant< bool, std::is_integral< T >::value &&std::is_integral< R >::value >
 
template<typename T , typename R >
using is_sint_to_sint = std::integral_constant< bool, is_sigeninteger< T >::value &&is_sigeninteger< R >::value >
 
template<typename T , typename R >
using is_uint_to_uint = std::integral_constant< bool, is_sugeninteger< T >::value &&is_sugeninteger< R >::value >
 
template<typename T , typename R >
using is_sint_to_from_uint = std::integral_constant< bool,(is_sugeninteger< T >::value &&is_sigeninteger< R >::value)||(is_sigeninteger< T >::value &&is_sugeninteger< R >::value)>
 
template<typename T , typename R >
using is_sint_to_float = std::integral_constant< bool, std::is_integral< T >::value &&!(std::is_unsigned< T >::value) &&detail::is_floating_point< R >::value >
 
template<typename T , typename R >
using is_uint_to_float = std::integral_constant< bool, std::is_unsigned< T >::value &&detail::is_floating_point< R >::value >
 
template<typename T , typename R >
using is_int_to_float = std::integral_constant< bool, std::is_integral< T >::value &&detail::is_floating_point< R >::value >
 
template<typename T , typename R >
using is_float_to_int = std::integral_constant< bool, detail::is_floating_point< T >::value &&std::is_integral< R >::value >
 
template<typename T , typename R >
using is_float_to_float = std::integral_constant< bool, detail::is_floating_point< T >::value &&detail::is_floating_point< R >::value >
 
template<typename T >
using is_standard_type = std::integral_constant< bool, detail::is_sgentype< T >::value >
 
template<typename T , typename T8 , typename T16 , typename T32 , typename T64 >
using select_apply_cl_t = std::conditional_t< sizeof(T)==1, T8, std::conditional_t< sizeof(T)==2, T16, std::conditional_t< sizeof(T)==4, T32, T64 > >>
 
using Requirement = AccessorImplHost
 
using DeviceDescT = std::map< std::string, std::string >
 
using AllowListParsedT = std::vector< DeviceDescT >
 
using PlatformImplPtr = std::shared_ptr< detail::platform_impl >
 
using ContextImplPtr = std::shared_ptr< sycl::detail::context_impl >
 
using QueueImplPtr = std::shared_ptr< sycl::detail::queue_impl >
 
using LockGuard = std::lock_guard< SpinLock >
 
using image_allocator = aligned_allocator< byte >
 
using ProgramImplPtr = std::shared_ptr< program_impl >
 
using DeviceImplPtr = std::shared_ptr< device_impl >
 
using StreamImplPtr = std::shared_ptr< detail::stream_impl >
 
using SpecConstRegistryT = std::map< std::string, spec_constant_impl >
 

Enumerations

enum class  backend_errc : unsigned int
 
enum class  kernel_param_kind_t {
  kind_accessor = 0 , kind_std_layout = 1 , kind_sampler = 2 , kind_pointer = 3 ,
  kind_specialization_constants_buffer = 4 , kind_stream = 5 , kind_invalid = 0xf
}
 
enum class  PiApiKind { _PI_API }
 
enum  DataLessPropKind {
  BufferUseHostPtr = 0 , ImageUseHostPtr = 1 , QueueEnableProfiling = 2 , InOrder = 3 ,
  NoInit = 4 , BufferUsePinnedHostMemory = 5 , UsePrimaryContext = 6 , InitializeToIdentity = 7 ,
  UseDefaultStream = 8 , DiscardEvents = 9 , DeviceReadOnly = 10 , FusionPromotePrivate = 11 ,
  FusionPromoteLocal = 12 , FusionNoBarrier = 13 , FusionEnable = 14 , FusionForce = 15 ,
  QueuePriorityNormal = 16 , QueuePriorityLow = 17 , QueuePriorityHigh = 18 , LastKnownDataLessPropKind = 18 ,
  DataLessPropKindSize = 32
}
 
enum  PropWithDataKind {
  BufferUseMutex = 0 , BufferContextBound = 1 , ImageUseMutex = 2 , ImageContextBound = 3 ,
  BufferMemChannel = 4 , AccPropBufferLocation = 5 , PropWithDataKindSize = 6
}
 
enum  ConfigID { START = 0 , END }
 
enum class  HandlerSubmissionState : std::uint8_t { NO_STATE = 0 , EXPLICIT_KERNEL_BUNDLE_STATE , SPEC_CONST_SET_STATE }
 
enum class  program_state { none = 0 , compiled = 1 , linked = 2 }
 
enum  BuildState { BS_InProgress , BS_Done , BS_Failed }
 
enum class  DeviceLibExt : std::uint32_t {
  cl_intel_devicelib_assert , cl_intel_devicelib_math , cl_intel_devicelib_math_fp64 , cl_intel_devicelib_complex ,
  cl_intel_devicelib_complex_fp64 , cl_intel_devicelib_cstring , cl_intel_devicelib_imf , cl_intel_devicelib_imf_fp64 ,
  cl_intel_devicelib_imf_bf16 , cl_intel_devicelib_bfloat16
}
 
enum class  CUDAContextT : char { primary , custom }
 Possible CUDA context types supported by PI CUDA backend TODO: Implement this as a property once there is an extension document. More...
 
enum  QueueOrder { Ordered , OOO }
 
enum  BlockingT { NON_BLOCKING = 0 , BLOCKING }
 

Functions

constexpr bool isTargetHostAccess (access::target T)
 
constexpr bool modeNeedsOldData (access::mode m)
 
constexpr bool modeWritesNewData (access::mode m)
 
template<typename ToT , typename FromT >
ToT cast_AS (FromT from)
 
template<size_t... Inds, class F >
void dim_loop_impl (std::integer_sequence< size_t, Inds... >, F &&f)
 
template<size_t count, class F >
void dim_loop (F &&f)
 
void constructorNotification (void *BufferObj, void *AccessorObj, access::target Target, access::mode Mode, const code_location &CodeLoc)
 
device getDeviceFromHandler (handler &CommandGroupHandlerRef)
 
void addHostAccessorAndWait (AccessorImplHost *Req)
 
static std::memory_order getStdMemoryOrder (__spv::MemorySemanticsMask::Flag)
 
constexpr memory_order getLoadOrder (memory_order order)
 
template<backend BackendName, typename DataT , int Dimensions, typename AllocatorT >
auto get_native_buffer (const buffer< DataT, Dimensions, AllocatorT, void > &Obj) -> backend_return_t< BackendName, buffer< DataT, Dimensions, AllocatorT, void >>
 
platform make_platform (pi_native_handle NativeHandle, backend Backend)
 
device make_device (pi_native_handle NativeHandle, backend Backend)
 
context make_context (pi_native_handle NativeHandle, const async_handler &Handler, backend Backend)
 
queue make_queue (pi_native_handle NativeHandle, const context &TargetContext, const device *TargetDevice, bool KeepOwnership, const async_handler &Handler, backend Backend)
 
event make_event (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
 
event make_event (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, backend Backend)
 
kernel make_kernel (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
 
kernel make_kernel (const context &TargetContext, const kernel_bundle< bundle_state::executable > &KernelBundle, pi_native_handle NativeKernelHandle, bool KeepOwnership, backend Backend)
 
std::shared_ptr< detail::kernel_bundle_implmake_kernel_bundle (pi_native_handle NativeHandle, const context &TargetContext, bundle_state State, backend Backend)
 
std::shared_ptr< detail::kernel_bundle_implmake_kernel_bundle (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, bundle_state State, backend Backend)
 
void memcpy (void *Dst, const void *Src, std::size_t Size)
 
template<typename To , typename From >
To bit_cast (const From &from) noexcept
 
template<typename T , int Dimensions, typename AllocatorT >
buffer< T, Dimensions, AllocatorT, void > make_buffer_helper (pi_native_handle Handle, const context &Ctx, event Evt={}, bool OwnNativeHandle=true)
 
template<backend BackendName, typename DataT , int Dimensions, typename Allocator >
auto get_native_buffer (const buffer< DataT, Dimensions, Allocator, void > &Obj) -> backend_return_t< BackendName, buffer< DataT, Dimensions, Allocator, void >>
 
template<class T , size_t N>
vec< T, 2 > to_vec2 (marray< T, N > x, size_t start)
 
template<typename F , typename... Args>
static constexpr bool check_kernel_lambda_takes_args ()
 
template<typename KernelType , typename LambdaArgType , typename std::enable_if_t< std::is_same< LambdaArgType, void >::value > * = nullptr>
constexpr bool isKernelLambdaCallableWithKernelHandlerImpl ()
 
template<typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType >::value > runKernelWithoutArg (KernelType KernelName)
 
template<typename KernelType >
std::enable_if_t<!KernelLambdaHasKernelHandlerArgT< KernelType >::value > runKernelWithoutArg (KernelType KernelName)
 
template<typename ArgType , typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value > runKernelWithArg (KernelType KernelName, ArgType Arg)
 
template<typename ArgType , typename KernelType >
std::enable_if_t< !KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value > runKernelWithArg (KernelType KernelName, ArgType Arg)
 
const char * stringifyErrorCode (pi_int32 error)
 
static std::string codeToString (pi_int32 code)
 
template<class Obj >
decltype(Obj::impl) getSyclObjImpl (const Obj &SyclObject)
 
template<class T >
std::add_pointer_t< typename decltype(T::impl)::element_type > getRawSyclObjImpl (const T &SyclObject)
 
template<class T >
createSyclObjFromImpl (decltype(T::impl) ImplObj)
 
constexpr size_t getNextPowerOfTwoHelper (size_t Var, size_t Offset)
 
constexpr size_t getNextPowerOfTwo (size_t Var)
 
template<int Dims, template< int > class T, template< int > class U>
size_t getLinearIndex (const T< Dims > &Index, const U< Dims > &Range)
 
template<int NewDim, int DefaultValue, template< int > class T, int OldDim>
static T< NewDim > convertToArrayOfN (T< OldDim > OldObj)
 
std::vector< std::string > split_string (const std::string &str, char delimeter)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, std::optional< T > const &opt)
 
std::ostream & operator<< (std::ostream &Out, const ods_target &Target)
 
std::vector< ods_targetParse_ONEAPI_DEVICE_SELECTOR (const std::string &envStr)
 
std::ostream & operator<< (std::ostream &Out, const device_filter &Filter)
 
std::ostream & operator<< (std::ostream &Out, const device_filter_list &List)
 
template<typename To , typename From , typename = typename std::enable_if_t<TryToGetPointerT<From>::value>>
To ConvertNonVectorType (From &t)
 
template<typename To , typename From >
To ConvertNonVectorType (From *t)
 
template<typename To , typename From >
std::enable_if_t<!TryToGetPointerT< From >::value, To > ConvertNonVectorType (From &t)
 
template<typename FROM , typename TO >
std::enable_if_t< is_vgentype< FROM >::value &&is_vgentype< TO >::value &&sizeof(TO)==sizeof(FROM), TO > convertDataToType (FROM t)
 
template<typename FROM , typename TO >
std::enable_if_t<!(is_vgentype< FROM >::value &&is_vgentype< TO >::value) &&sizeof(TO)==sizeof(FROM), TO > convertDataToType (FROM t)
 
template<typename T >
constexpr T msbMask (T)
 
template<typename T >
constexpr bool msbIsSet (const T x)
 
template<typename T >
static constexpr T max_v ()
 
template<typename T >
static constexpr T min_v ()
 
template<typename T >
static constexpr T quiet_NaN ()
 
template<typename... Args>
void check_vector_size ()
 
void associateWithHandler (handler &, AccessorBaseHost *, access::target)
 
void memcpy (void *Dst, const void *Src, size_t Size)
 
std::vector< RT::PiEvent > getOrWaitEvents (std::vector< sycl::event > DepEvents, std::shared_ptr< sycl::detail::context_impl > Context)
 
void waitEvents (std::vector< sycl::event > DepEvents)
 
template<typename T >
T * declptr ()
 
template<typename T >
get_or_store (const T *obj)
 
constexpr __spv::MemorySemanticsMask::Flag getSPIRVMemorySemanticsMask (memory_order)
 
constexpr uint32_t getSPIRVMemorySemanticsMask (const access::fence_space AccessSpace, const __spv::MemorySemanticsMask LocalScopeMask=__spv::MemorySemanticsMask::WorkgroupMemory)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, T > UnnormalizeCoordinates (const T &Coords, const range< 3 > &Range)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, vec< T, 2 > > UnnormalizeCoordinates (const vec< T, 2 > &Coords, const range< 3 > &Range)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, vec< T, 4 > > UnnormalizeCoordinates (const vec< T, 4 > &Coords, const range< 3 > &Range)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, cl_float4 > convertToFloat4 (T Coords)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, cl_float4 > convertToFloat4 (vec< T, 2 > Coords)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, cl_float4 > convertToFloat4 (vec< T, 4 > Coords)
 
template<typename T >
std::enable_if_t< std::is_integral< T >::value, size_t > getImageOffset (const T &Coords, const id< 3 >, const uint8_t ElementSize)
 
template<typename T >
std::enable_if_t< std::is_integral< T >::value, size_t > getImageOffset (const vec< T, 2 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
 
template<typename T >
std::enable_if_t< std::is_integral< T >::value, size_t > getImageOffset (const vec< T, 4 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
 
cl_int4 getPixelCoordNearestFiltMode (cl_float4, const addressing_mode, const range< 3 >)
 
cl_int8 getPixelCoordLinearFiltMode (cl_float4, const addressing_mode, const range< 3 >, cl_float4 &)
 
bool isOutOfRange (const cl_int4 PixelCoord, const addressing_mode SmplAddrMode, const range< 3 > ImgRange)
 
cl_float4 getBorderColor (const image_channel_order ImgChannelOrder)
 
template<typename T >
vec< T, 4 > readPixel (T *Ptr, const image_channel_order ChannelOrder, const image_channel_type ChannelType)
 
template<typename T >
void writePixel (const vec< T, 4 > Pixel, T *Ptr, const image_channel_order ChannelOrder, const image_channel_type ChannelType)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_uint, 4 > &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_int, 4 > &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_float, 4 > &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_half, 4 > &RetData)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_uint, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_int, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > processFloatDataToPixel (vec< cl_float, 4 > WriteData, float MulFactor)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_float, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_half, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename CoordT , typename WriteDataT >
void imageWriteHostImpl (const CoordT &Coords, const WriteDataT &Color, id< 3 > ImgPitch, uint8_t ElementSize, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr)
 
template<typename DataT >
DataT ReadPixelData (const cl_int4 PixelCoord, const id< 3 > ImgPitch, const image_channel_type ImageChannelType, const image_channel_order ImageChannelOrder, void *BasePtr, const uint8_t ElementSize)
 
template<typename DataT >
DataT getColor (const cl_int4 PixelCoord, const addressing_mode SmplAddrMode, const range< 3 > ImgRange, const id< 3 > ImgPitch, const image_channel_type ImgChannelType, const image_channel_order ImgChannelOrder, void *BasePtr, const uint8_t ElementSize)
 
template<typename DataT >
DataT ReadPixelDataLinearFiltMode (const cl_int8 CoordValues, const cl_float4 abc, const addressing_mode SmplAddrMode, const range< 3 > ImgRange, id< 3 > ImgPitch, const image_channel_type ImgChannelType, const image_channel_order ImgChannelOrder, void *BasePtr, const uint8_t ElementSize)
 
template<typename CoordT , typename DataT >
DataT imageReadSamplerHostImpl (const CoordT &Coords, const sampler &Smpl, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, uint8_t ElementSize)
 
template<sycl::backend BE>
void * getPluginOpaqueData (void *opaquedata_arg)
 
template<typename T , typename... Ts, std::size_t... Is>
std::tuple< Ts... > get_tuple_tail_impl (const std::tuple< T, Ts... > &Tuple, const std::index_sequence< Is... > &)
 
template<typename T , typename... Ts>
std::tuple< Ts... > get_tuple_tail (const std::tuple< T, Ts... > &Tuple)
 
template<typename... Ts>
constexpr tuple< Ts... > make_tuple (Ts... Args)
 
template<typename... Ts>
auto tie (Ts &...Args)
 
auto getDeviceComparisonLambda ()
 
template<typename LastT >
void fill_aspect_vector (std::vector< aspect > &V, LastT L)
 
template<typename FirstT , typename... OtherTs>
void fill_aspect_vector (std::vector< aspect > &V, FirstT F, OtherTs... O)
 
device select_device (const DSelectorInvocableType &DeviceSelectorInvocable)
 
device select_device (const DSelectorInvocableType &DeviceSelectorInvocable, const context &SyclContext)
 
void defaultAsyncHandler (exception_list Exceptions)
 
template<ext::intel::experimental::architecture... Archs>
constexpr static bool allowable_aot_mode ()
 
template<ext::intel::experimental::architecture... Archs>
constexpr static bool device_architecture_is ()
 
template<typename CVT , access::address_space Space, access::decorated IsDecorated, typename T = std::remove_cv_t<CVT>>
multi_ptr< T, Space, IsDecorated > GetUnqualMultiPtr (const multi_ptr< CVT, Space, IsDecorated > &Mptr)
 
static void workGroupBarrier ()
 
template<int Dimensions>
id< Dimensionslinear_id_to_id (range< Dimensions >, size_t linear_id)
 
template<>
id< 1 > linear_id_to_id (range< 1 >, size_t linear_id)
 
template<>
id< 2 > linear_id_to_id (range< 2 > r, size_t linear_id)
 
template<>
id< 3 > linear_id_to_id (range< 3 > r, size_t linear_id)
 
template<typename Group >
size_t get_local_linear_range (Group g)
 
template<>
size_t get_local_linear_range< group< 1 > > (group< 1 > g)
 
template<>
size_t get_local_linear_range< group< 2 > > (group< 2 > g)
 
template<>
size_t get_local_linear_range< group< 3 > > (group< 3 > g)
 
template<>
size_t get_local_linear_range< ext::oneapi::sub_group > (ext::oneapi::sub_group g)
 
template<typename Group >
Group::linear_id_type get_local_linear_id (Group g)
 
template<>
ext::oneapi::sub_group::linear_id_type get_local_linear_id< ext::oneapi::sub_group > (ext::oneapi::sub_group g)
 
template<typename T , class BinaryOperation >
constexpr std::enable_if_t<(is_complex< T >::value &&is_plus< T, BinaryOperation >::value), T > identity_for_ga_op ()
 
template<typename T , class BinaryOperation >
constexpr std::enable_if_t<!is_complex< T >::value, T > identity_for_ga_op ()
 
template<typename Group , typename Ptr , class Function >
Function for_each (Group g, Ptr first, Ptr last, Function f)
 
__SYCL_CONSTEXPR_HALF uint16_t float2Half (const float &Val)
 
__SYCL_CONSTEXPR_HALF float half2Float (const uint16_t &Val)
 
template<typename T >
cast_if_host_half (T val)
 
float cast_if_host_half (half_impl::half val)
 
template<typename RetType , typename Func , typename Arg >
static Arg member_ptr_helper (RetType(Func::*)(Arg) const)
 
template<typename F , typename SuggestedArgType >
SuggestedArgType argument_helper (...)
 
template<int Dims, typename T >
std::enable_if_t< std::is_same< T, range< Dims > >::value||std::is_same< T, id< Dims > >::value > checkValueRange (const T &V)
 
template<int Dims>
void checkValueRange (const range< Dims > &R, const id< Dims > &O)
 
template<int Dims, typename T >
std::enable_if_t< std::is_same< T, nd_range< Dims > >::value > checkValueRange (const T &V)
 
template<int dimensions>
size_t getOffsetForId (range< dimensions > Range, id< dimensions > Id, id< dimensions > Offset)
 
id< 1 > getDelinearizedId (const range< 1 > &, size_t Index)
 
id< 2 > getDelinearizedId (const range< 2 > &Range, size_t Index)
 
id< 3 > getDelinearizedId (const range< 3 > &Range, size_t Index)
 
kernel_id get_kernel_id_impl (std::string KernelName)
 
detail::KernelBundleImplPtr get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State)
 
const std::vector< deviceremoveDuplicateDevices (const std::vector< device > &Devs)
 
detail::KernelBundleImplPtr get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, const std::vector< kernel_id > &KernelIDs, bundle_state State)
 
detail::KernelBundleImplPtr get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State, const DevImgSelectorImpl &Selector)
 
detail::KernelBundleImplPtr get_empty_interop_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs)
 
template<bundle_state State>
kernel_bundle< State > get_empty_interop_kernel_bundle (const context &Ctx)
 make_kernel may need an empty interop kernel bundle. More...
 
bool has_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State)
 
bool has_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, const std::vector< kernel_id > &kernelIds, bundle_state State)
 
std::shared_ptr< detail::kernel_bundle_impljoin_impl (const std::vector< detail::KernelBundleImplPtr > &Bundles, bundle_state State)
 
std::shared_ptr< detail::kernel_bundle_implcompile_impl (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList)
 
std::vector< sycl::device > find_device_intersection (const std::vector< kernel_bundle< bundle_state::object >> &ObjectBundles)
 
std::shared_ptr< detail::kernel_bundle_impllink_impl (const std::vector< kernel_bundle< bundle_state::object >> &ObjectBundles, const std::vector< device > &Devs, const property_list &PropList)
 
std::shared_ptr< detail::kernel_bundle_implbuild_impl (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList)
 
std::vector< memory_orderreadMemoryOrderBitfield (pi_memory_order_capabilities bits)
 
std::vector< memory_scopereadMemoryScopeBitfield (pi_memory_scope_capabilities bits)
 
static constexpr std::memory_order getStdMemoryOrder (sycl::memory_order order)
 
template<typename... Ts>
ReduTupleT< Ts... > makeReduTupleT (Ts... Elements)
 
size_t reduGetMaxWGSize (std::shared_ptr< queue_impl > Queue, size_t LocalMemBytesPerWorkItem)
 
size_t reduComputeWGSize (size_t NWorkItems, size_t MaxWGSize, size_t &NWorkGroups)
 
size_t reduGetPreferredWGSize (std::shared_ptr< queue_impl > &Queue, size_t LocalMemBytesPerWorkItem)
 
template<class BinaryOp , int Dims, size_t Extent, typename RedOutVar , typename... RestTy>
auto make_reduction (RedOutVar RedVar, RestTy &&...Rest)
 
template<typename KernelName , class Reduction >
void reduSaveFinalResultToUserMem (handler &CGH, Reduction &Redu)
 Copies the final reduction result kept in read-write accessor to user's USM memory. More...
 
template<bool IsOneWG, typename... Reductions, size_t... Is>
auto createReduOutAccs (size_t NWorkGroups, handler &CGH, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... >)
 For the given 'Reductions' types pack and indices enumerating them this function either creates new temporary accessors for partial sums (if IsOneWG is false) or returns user's accessor/USM-pointer if (IsOneWG is true). More...
 
template<typename... LocalAccT, typename... BOPsT, size_t... Is>
void reduceReduLocalAccs (size_t IndexA, size_t IndexB, ReduTupleT< LocalAccT... > LocalAccs, ReduTupleT< BOPsT... > BOPs, std::index_sequence< Is... >)
 
template<typename... Reductions, typename... OutAccT, typename... LocalAccT, typename... BOPsT, typename... Ts, size_t... Is>
void writeReduSumsToOutAccs (bool Pow2WG, bool IsOneWG, size_t OutAccIndex, size_t WGSize, ReduTupleT< OutAccT... > OutAccs, ReduTupleT< LocalAccT... > LocalAccs, ReduTupleT< BOPsT... > BOPs, ReduTupleT< Ts... > IdentityVals, std::array< bool, sizeof...(Reductions)> IsInitializeToIdentity, std::index_sequence< Is... >)
 
constexpr std::index_sequence concat_sequences (std::index_sequence<>)
 
template<size_t I>
constexpr std::index_sequence< I > concat_sequences (std::index_sequence< I >)
 
template<size_t... Is, size_t... Js>
constexpr std::index_sequence< Is..., Js... > concat_sequences (std::index_sequence< Is... >, std::index_sequence< Js... >)
 
template<size_t... Is, size_t... Js, class... Rs>
constexpr auto concat_sequences (std::index_sequence< Is... >, std::index_sequence< Js... >, Rs...)
 
template<typename... T, typename FunctorT , size_t... Is, std::enable_if_t<(sizeof...(Is) > 0), int > Z = 0>
constexpr auto filterSequenceHelper (FunctorT, std::index_sequence< Is... >)
 For each index 'I' from the given indices pack 'Is' this function initially creates a number of short index_sequences, where each of such short index sequences is either empty (if the given Functor returns false for the type T[I]) or 1 element 'I' (otherwise). More...
 
template<typename... T, typename FunctorT , size_t... Is>
constexpr auto filterSequence (FunctorT F, std::index_sequence< Is... > Indices)
 For each index 'I' from the given indices pack 'Is' this function returns an index sequence consisting of only those 'I's for which the 'FunctorT' applied to 'T[I]' returns true. More...
 
template<typename... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... Ts, typename... BOPsT, size_t... Is>
void reduCGFuncImplScalar (bool Pow2WG, bool IsOneWG, nd_item< Dims > NDIt, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, std::tuple< ReducerT... > &ReducersTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... > ReduIndices)
 All scalar reductions are processed together; there is one loop of log2(N) steps, and each reduction uses its own storage. More...
 
template<typename Reduction , int Dims, typename LocalAccT , typename OutAccT , typename ReducerT , typename T , typename BOPT >
void reduCGFuncImplArrayHelper (bool Pow2WG, bool IsOneWG, nd_item< Dims > NDIt, LocalAccT LocalReds, OutAccT Out, ReducerT &Reducer, T Identity, BOPT BOp, bool IsInitializeToIdentity)
 Each array reduction is processed separately. More...
 
template<typename... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... Ts, typename... BOPsT, size_t... Is>
void reduCGFuncImplArray (bool Pow2WG, bool IsOneWG, nd_item< Dims > NDIt, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, std::tuple< ReducerT... > &ReducersTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... >)
 
template<typename KernelName , typename KernelType , int Dims, typename PropertiesT , typename... Reductions, size_t... Is>
void reduCGFuncMulti (handler &CGH, KernelType KernelFunc, const nd_range< Dims > &Range, PropertiesT Properties, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... > ReduIndices)
 
template<typename... Reductions, size_t... Is>
void associateReduAccsWithHandler (handler &CGH, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... >)
 
template<typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void reduAuxCGFuncImplScalar (bool UniformPow2WG, bool IsOneWG, nd_item< Dims > NDIt, size_t LID, size_t GID, size_t NWorkItems, size_t WGSize, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< InAccT... > InAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... > ReduIndices)
 All scalar reductions are processed together; there is one loop of log2(N) steps, and each reduction uses its own storage. More...
 
template<typename Reduction , int Dims, typename LocalAccT , typename InAccT , typename OutAccT , typename T , typename BOPT >
void reduAuxCGFuncImplArrayHelper (bool UniformPow2WG, bool IsOneWG, nd_item< Dims > NDIt, size_t LID, size_t GID, size_t NWorkItems, size_t WGSize, LocalAccT LocalReds, InAccT In, OutAccT Out, T Identity, BOPT BOp, bool IsInitializeToIdentity)
 
template<typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void reduAuxCGFuncImplArray (bool UniformPow2WG, bool IsOneWG, nd_item< Dims > NDIt, size_t LID, size_t GID, size_t NWorkItems, size_t WGSize, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< InAccT... > InAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... >)
 
template<typename KernelName , typename KernelType , typename... Reductions, size_t... Is>
size_t reduAuxCGFunc (handler &CGH, size_t NWorkItems, size_t MaxWGSize, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... > ReduIndices)
 
template<typename Reduction >
size_t reduGetMemPerWorkItemHelper (Reduction &)
 
template<typename Reduction , typename... RestT>
size_t reduGetMemPerWorkItemHelper (Reduction &, RestT... Rest)
 
template<typename... ReductionT, size_t... Is>
size_t reduGetMemPerWorkItem (std::tuple< ReductionT... > &ReduTuple, std::index_sequence< Is... >)
 
template<typename TupleT , std::size_t... Is>
std::tuple< std::tuple_element_t< Is, TupleT >... > tuple_select_elements (TupleT Tuple, std::index_sequence< Is... >)
 Utility function: for the given tuple. More...
 
template<typename KernelName , reduction::strategy Strategy, int Dims, typename PropertiesT , typename... RestT>
void reduction_parallel_for (handler &CGH, nd_range< Dims > NDRange, PropertiesT Properties, RestT... Rest)
 
uint32_t reduGetMaxNumConcurrentWorkGroups (std::shared_ptr< queue_impl > Queue)
 
template<typename KernelName , reduction::strategy Strategy, int Dims, typename PropertiesT , typename... RestT>
void reduction_parallel_for (handler &CGH, range< Dims > Range, PropertiesT Properties, RestT... Rest)
 
unsigned GetFlushBufOffset (const GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
 
void SetFlushBufOffset (GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset, unsigned Offset)
 
void write (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const char *Str, unsigned Len, unsigned Padding=0)
 
void reverseBuf (char *Buf, unsigned Len)
 
template<typename T >
std::make_unsigned< T >::type getAbsVal (const T Val, const int Base)
 
char digitToChar (const int Digit)
 
template<typename T >
std::enable_if_t< std::is_integral< T >::value, unsigned > integralToBase (T Val, int Base, char *Digits)
 
template<typename T >
std::enable_if_t< std::is_integral< T >::value, unsigned > ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
 
unsigned append (char *Dst, const char *Src)
 
template<typename T >
std::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, unsigned > checkForInfNan (char *Buf, T Val)
 
template<typename T >
std::enable_if_t< std::is_same< T, half >::value, unsigned > checkForInfNan (char *Buf, T Val)
 
template<typename T >
EnableIfFP< T, unsigned > floatingPointToDecStr (T AbsVal, char *Digits, int Precision, bool IsSci)
 
template<typename T >
EnableIfFP< T, unsigned > ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
 
template<typename T >
std::enable_if_t< std::is_integral< T >::value > writeIntegral (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, const T &Val)
 
template<typename T >
EnableIfFP< T > writeFloatingPoint (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const T &Val)
 
bool updateOffset (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, unsigned Size, unsigned &Cur)
 
void flushBuffer (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
 
template<typename T , int VecLength>
std::enable_if_t<(VecLength==1), unsigned > VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
 
template<typename T , int VecLength>
std::enable_if_t<(VecLength==2||VecLength==4||VecLength==8||VecLength==16), unsigned > VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
 
template<typename T , int VecLength>
std::enable_if_t<(VecLength==3), unsigned > VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
 
template<typename T , int VecLength>
void writeVec (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const vec< T, VecLength > &Vec)
 
template<int ArrayLength>
unsigned ArrayToStr (char *Buf, const array< ArrayLength > &Arr)
 
template<int ArrayLength>
void writeArray (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const array< ArrayLength > &Arr)
 
template<int Dimensions>
void writeItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const item< Dimensions > &Item)
 
template<int Dimensions>
void writeNDRange (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_range< Dimensions > &ND_Range)
 
template<int Dimensions>
void writeNDItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_item< Dimensions > &ND_Item)
 
template<int Dimensions>
void writeGroup (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const group< Dimensions > &Group)
 
template<int Dimensions>
unsigned ItemToStr (char *Buf, const item< Dimensions, false > &Item)
 
template<int Dimensions>
void writeHItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const h_item< Dimensions > &HItem)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t< std::is_same< T, R >::value, R > convertImpl (T Value)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t<!std::is_same< T, R >::value &&(is_int_to_int< T, R >::value||is_int_to_float< T, R >::value||is_float_to_float< T, R >::value), R > convertImpl (T Value)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t< is_float_to_int< T, R >::value, R > convertImpl (T Value)
 
template<typename T >
struct __SYCL2020_DEPRECATED ("This type isn't device copyable in SYCL 2020") IsDeprecatedDeviceCopyable< T
 
static const plugingetPlugin (backend Backend)
 
queue make_queue_impl (pi_native_handle NativeHandle, const context &Context, RT::PiDevice Device, bool KeepOwnership, const async_handler &Handler, backend Backend)
 
void constructorNotification (void *BufferObj, void *AccessorObj, sycl::access::target Target, sycl::access::mode Mode, const detail::code_location &CodeLoc)
 
AllowListParsedT parseAllowList (const std::string &AllowListRaw)
 
bool deviceIsAllowed (const DeviceDescT &DeviceDesc, const AllowListParsedT &AllowListParsed)
 
void applyAllowList (std::vector< RT::PiDevice > &PiDevices, RT::PiPlatform PiPlatform, const plugin &Plugin)
 
template<class T >
backend getImplBackend (const T &Impl)
 
static void initValue (const char *Key, const char *Value)
 
void readConfig (bool ForceInitialization)
 
void dumpConfig ()
 
const std::array< std::pair< std::string, info::device_type >, 6 > & getSyclDeviceTypeMap ()
 
const std::array< std::pair< std::string, backend >, 7 > & getSyclBeMap ()
 
constexpr const char * getStrOrNullptr (const char *Str)
 
template<>
class __SYCL2020_DEPRECATED ("Use SYCLConfig<ONEAPI_DEVICE_SELECTOR> instead") SYCLConfig< SYCL_DEVICE_FILTER >
 
template<>
uint32_t context_impl::get_info< info::context::reference_count > () const
 
template<>
platform context_impl::get_info< info::context::platform > () const
 
template<>
std::vector< sycl::device > context_impl::get_info< info::context::devices > () const
 
template<>
std::vector< sycl::memory_order > context_impl::get_info< info::context::atomic_memory_order_capabilities > () const
 
template<>
std::vector< sycl::memory_scope > context_impl::get_info< info::context::atomic_memory_scope_capabilities > () const
 
template<typename Param >
Param::return_type get_context_info (RT::PiContext Ctx, const plugin &Plugin)
 
template<>
std::vector< sycl::memory_order > get_context_info< info::context::atomic_memory_order_capabilities > (RT::PiContext Ctx, const plugin &Plugin)
 
std::ostream & operator<< (std::ostream &Out, const DeviceBinaryProperty &P)
 
std::vector< std::string_view > tokenize (const std::string_view &Filter, const std::string &Delim)
 
static backend Parse_ODS_Backend (const std::string_view &BackendStr, const std::string_view &FullEntry)
 
static void Parse_ODS_Device (ods_target &Target, const std::string_view &DeviceStr)
 
std::vector< info::fp_configread_fp_bitfield (pi_device_fp_config bits)
 
std::vector< info::partition_affinity_domainread_domain_bitfield (pi_device_affinity_domain bits)
 
std::vector< info::execution_capabilityread_execution_bitfield (pi_device_exec_capabilities bits)
 
std::string affinityDomainToString (info::partition_affinity_domain AffinityDomain)
 
std::string get_device_info_string (RT::PiDevice dev, RT::PiDeviceInfo InfoCode, const plugin &Plugin)
 
static bool is_sycl_partition_property (info::partition_property PP)
 
template<int Dimensions>
id< Dimensionsconstruct_id (size_t *values)=delete
 
template<>
id< 1 > construct_id< 1 > (size_t *values)
 
template<>
id< 2 > construct_id< 2 > (size_t *values)
 
template<>
id< 3 > construct_id< 3 > (size_t *values)
 
template<typename Param >
Param::return_type get_device_info (RT::PiDevice dev, const plugin &Plugin)
 
template<typename Param >
Param::return_type get_device_info_host ()=delete
 
template<>
info::device_type get_device_info_host< info::device::device_type > ()
 
template<>
uint32_t get_device_info_host< info::device::vendor_id > ()
 
template<>
uint32_t get_device_info_host< info::device::max_compute_units > ()
 
template<>
uint32_t get_device_info_host< info::device::max_work_item_dimensions > ()
 
template<>
id< 1 > get_device_info_host< info::device::max_work_item_sizes< 1 > > ()
 
template<>
id< 2 > get_device_info_host< info::device::max_work_item_sizes< 2 > > ()
 
template<>
id< 3 > get_device_info_host< info::device::max_work_item_sizes< 3 > > ()
 
template<>
constexpr size_t get_device_info_host< ext::oneapi::experimental::info::device::max_global_work_groups > ()
 
template<>
id< 1 > get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 1 > > ()
 
template<>
id< 2 > get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 2 > > ()
 
template<>
id< 3 > get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 3 > > ()
 
template<>
constexpr size_t get_device_info_host< info::device::ext_oneapi_max_global_work_groups > ()
 
template<>
id< 1 > get_device_info_host< info::device::ext_oneapi_max_work_groups_1d > ()
 
template<>
id< 2 > get_device_info_host< info::device::ext_oneapi_max_work_groups_2d > ()
 
template<>
id< 3 > get_device_info_host< info::device::ext_oneapi_max_work_groups_3d > ()
 
template<>
size_t get_device_info_host< info::device::max_work_group_size > ()
 
template<>
uint32_t get_device_info_host< info::device::preferred_vector_width_char > ()
 
template<>
uint32_t get_device_info_host< info::device::preferred_vector_width_short > ()
 
template<>
uint32_t get_device_info_host< info::device::preferred_vector_width_int > ()
 
template<>
uint32_t get_device_info_host< info::device::preferred_vector_width_long > ()
 
template<>
uint32_t get_device_info_host< info::device::preferred_vector_width_float > ()
 
template<>
uint32_t get_device_info_host< info::device::preferred_vector_width_double > ()
 
template<>
uint32_t get_device_info_host< info::device::preferred_vector_width_half > ()
 
template<>
uint32_t get_device_info_host< info::device::native_vector_width_char > ()
 
template<>
uint32_t get_device_info_host< info::device::native_vector_width_short > ()
 
template<>
uint32_t get_device_info_host< info::device::native_vector_width_int > ()
 
template<>
uint32_t get_device_info_host< info::device::native_vector_width_long > ()
 
template<>
uint32_t get_device_info_host< info::device::native_vector_width_float > ()
 
template<>
uint32_t get_device_info_host< info::device::native_vector_width_double > ()
 
template<>
uint32_t get_device_info_host< info::device::native_vector_width_half > ()
 
template<>
uint32_t get_device_info_host< info::device::max_clock_frequency > ()
 
template<>
uint32_t get_device_info_host< info::device::address_bits > ()
 
template<>
uint64_t get_device_info_host< info::device::global_mem_size > ()
 
template<>
uint64_t get_device_info_host< info::device::max_mem_alloc_size > ()
 
template<>
bool get_device_info_host< info::device::image_support > ()
 
template<>
bool get_device_info_host< info::device::atomic64 > ()
 
template<>
std::vector< memory_orderget_device_info_host< info::device::atomic_memory_order_capabilities > ()
 
template<>
std::vector< memory_scopeget_device_info_host< info::device::atomic_memory_scope_capabilities > ()
 
template<>
bool get_device_info_host< info::device::ext_oneapi_bfloat16_math_functions > ()
 
template<>
uint32_t get_device_info_host< info::device::max_read_image_args > ()
 
template<>
uint32_t get_device_info_host< info::device::max_write_image_args > ()
 
template<>
size_t get_device_info_host< info::device::image2d_max_width > ()
 
template<>
size_t get_device_info_host< info::device::image2d_max_height > ()
 
template<>
size_t get_device_info_host< info::device::image3d_max_width > ()
 
template<>
size_t get_device_info_host< info::device::image3d_max_height > ()
 
template<>
size_t get_device_info_host< info::device::image3d_max_depth > ()
 
template<>
size_t get_device_info_host< info::device::image_max_buffer_size > ()
 
template<>
size_t get_device_info_host< info::device::image_max_array_size > ()
 
template<>
uint32_t get_device_info_host< info::device::max_samplers > ()
 
template<>
size_t get_device_info_host< info::device::max_parameter_size > ()
 
template<>
uint32_t get_device_info_host< info::device::mem_base_addr_align > ()
 
template<>
std::vector< info::fp_configget_device_info_host< info::device::half_fp_config > ()
 
template<>
std::vector< info::fp_configget_device_info_host< info::device::single_fp_config > ()
 
template<>
std::vector< info::fp_configget_device_info_host< info::device::double_fp_config > ()
 
template<>
info::global_mem_cache_type get_device_info_host< info::device::global_mem_cache_type > ()
 
template<>
uint32_t get_device_info_host< info::device::global_mem_cache_line_size > ()
 
template<>
uint64_t get_device_info_host< info::device::global_mem_cache_size > ()
 
template<>
uint64_t get_device_info_host< info::device::max_constant_buffer_size > ()
 
template<>
uint32_t get_device_info_host< info::device::max_constant_args > ()
 
template<>
info::local_mem_type get_device_info_host< info::device::local_mem_type > ()
 
template<>
uint64_t get_device_info_host< info::device::local_mem_size > ()
 
template<>
bool get_device_info_host< info::device::error_correction_support > ()
 
template<>
bool get_device_info_host< info::device::host_unified_memory > ()
 
template<>
size_t get_device_info_host< info::device::profiling_timer_resolution > ()
 
template<>
bool get_device_info_host< info::device::is_endian_little > ()
 
template<>
bool get_device_info_host< info::device::is_available > ()
 
template<>
bool get_device_info_host< info::device::is_compiler_available > ()
 
template<>
bool get_device_info_host< info::device::is_linker_available > ()
 
template<>
std::vector< info::execution_capabilityget_device_info_host< info::device::execution_capabilities > ()
 
template<>
bool get_device_info_host< info::device::queue_profiling > ()
 
template<>
std::vector< kernel_idget_device_info_host< info::device::built_in_kernel_ids > ()
 
template<>
std::vector< std::string > get_device_info_host< info::device::built_in_kernels > ()
 
template<>
platform get_device_info_host< info::device::platform > ()
 
template<>
std::string get_device_info_host< info::device::name > ()
 
template<>
std::string get_device_info_host< info::device::vendor > ()
 
template<>
std::string get_device_info_host< info::device::driver_version > ()
 
template<>
std::string get_device_info_host< info::device::profile > ()
 
template<>
std::string get_device_info_host< info::device::version > ()
 
template<>
std::string get_device_info_host< info::device::opencl_c_version > ()
 
template<>
std::vector< std::string > get_device_info_host< info::device::extensions > ()
 
template<>
size_t get_device_info_host< info::device::printf_buffer_size > ()
 
template<>
bool get_device_info_host< info::device::preferred_interop_user_sync > ()
 
template<>
device get_device_info_host< info::device::parent_device > ()
 
template<>
uint32_t get_device_info_host< info::device::partition_max_sub_devices > ()
 
template<>
std::vector< info::partition_propertyget_device_info_host< info::device::partition_properties > ()
 
template<>
std::vector< info::partition_affinity_domainget_device_info_host< info::device::partition_affinity_domains > ()
 
template<>
info::partition_property get_device_info_host< info::device::partition_type_property > ()
 
template<>
info::partition_affinity_domain get_device_info_host< info::device::partition_type_affinity_domain > ()
 
template<>
uint32_t get_device_info_host< info::device::reference_count > ()
 
template<>
uint32_t get_device_info_host< info::device::max_num_sub_groups > ()
 
template<>
std::vector< size_t > get_device_info_host< info::device::sub_group_sizes > ()
 
template<>
bool get_device_info_host< info::device::sub_group_independent_forward_progress > ()
 
template<>
bool get_device_info_host< info::device::kernel_kernel_pipe_support > ()
 
template<>
std::string get_device_info_host< info::device::backend_version > ()
 
template<>
bool get_device_info_host< info::device::usm_device_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_host_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_shared_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_restricted_shared_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_system_allocations > ()
 
template<>
bool get_device_info_host< info::device::ext_intel_mem_channel > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::device_id > ()
 
template<>
std::string get_device_info_host< ext::intel::info::device::pci_address > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::gpu_eu_count > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::gpu_eu_simd_width > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::gpu_slices > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::gpu_subslices_per_slice > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::gpu_eu_count_per_subslice > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::gpu_hw_threads_per_eu > ()
 
template<>
uint64_t get_device_info_host< ext::intel::info::device::max_mem_bandwidth > ()
 
template<>
detail::uuid_type get_device_info_host< ext::intel::info::device::uuid > ()
 
template<>
std::string get_device_info_host< info::device::ext_intel_pci_address > ()
 
template<>
uint32_t get_device_info_host< info::device::ext_intel_gpu_eu_count > ()
 
template<>
uint32_t get_device_info_host< info::device::ext_intel_gpu_eu_simd_width > ()
 
template<>
uint32_t get_device_info_host< info::device::ext_intel_gpu_slices > ()
 
template<>
uint32_t get_device_info_host< info::device::ext_intel_gpu_subslices_per_slice > ()
 
template<>
uint32_t get_device_info_host< info::device::ext_intel_gpu_eu_count_per_subslice > ()
 
template<>
uint32_t get_device_info_host< info::device::ext_intel_gpu_hw_threads_per_eu > ()
 
template<>
uint64_t get_device_info_host< info::device::ext_intel_max_mem_bandwidth > ()
 
template<>
bool get_device_info_host< info::device::ext_oneapi_srgb > ()
 
template<>
detail::uuid_type get_device_info_host< info::device::ext_intel_device_info_uuid > ()
 
template<>
uint64_t get_device_info_host< ext::intel::info::device::free_memory > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::memory_clock_rate > ()
 
template<>
uint32_t get_device_info_host< ext::intel::info::device::memory_bus_width > ()
 
template<>
uint64_t event_impl::get_profiling_info< info::event_profiling::command_submit > ()
 
template<>
uint64_t event_impl::get_profiling_info< info::event_profiling::command_start > ()
 
template<>
uint64_t event_impl::get_profiling_info< info::event_profiling::command_end > ()
 
template<>
uint32_t event_impl::get_info< info::event::reference_count > ()
 
template<>
info::event_command_status event_impl::get_info< info::event::command_execution_status > ()
 
static uint64_t getTimestamp ()
 
template<typename Param >
Param::return_type get_event_profiling_info (RT::PiEvent Event, const plugin &Plugin)
 
template<typename Param >
Param::return_type get_event_info (RT::PiEvent Event, const plugin &Plugin)
 
void releaseDefaultContexts ()
 
void shutdown ()
 
 __attribute__ ((destructor(110))) static void syclUnload()
 
std::vector< RT::PiEvent > getOrWaitEvents (std::vector< sycl::event > DepEvents, ContextImplPtr Context)
 
template<typename Param >
static bool checkImageValueRange (const std::vector< device > &Devices, const size_t Value)
 
template<typename T , typename... Args>
static bool checkAnyImpl (T)
 
template<typename ValT , typename VarT , typename... Args>
static bool checkAnyImpl (ValT Value, VarT Variant, Args... Arguments)
 
template<typename T , typename... Args>
static bool checkAny (const T Value, Args... Arguments)
 
uint8_t getImageNumberChannels (image_channel_order Order)
 
uint8_t getImageElementSize (uint8_t NumChannels, image_channel_type Type)
 
RT::PiMemImageChannelOrder convertChannelOrder (image_channel_order Order)
 
image_channel_order convertChannelOrder (RT::PiMemImageChannelOrder Order)
 
RT::PiMemImageChannelType convertChannelType (image_channel_type Type)
 
image_channel_type convertChannelType (RT::PiMemImageChannelType Type)
 
template<typename T >
static void getImageInfo (const ContextImplPtr Context, RT::PiMemImageInfo Info, T &Dest, RT::PiMem InteropMemObject)
 
static bool checkAllDevicesAreInContext (const std::vector< device > &Devices, const context &Context)
 
static bool checkAllDevicesHaveAspect (const std::vector< device > &Devices, aspect Aspect)
 
template<>
context kernel_impl::get_info< info::kernel::context > () const
 
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, std::string >::value, std::string >::type get_kernel_info (RT::PiKernel Kernel, const plugin &Plugin)
 
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, uint32_t >::value, uint32_t >::type get_kernel_info (RT::PiKernel Kernel, const plugin &Plugin)
 
template<typename Param >
std::enable_if< IsSubGroupInfo< Param >::value >::type get_kernel_device_specific_info_helper (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin, void *Result, size_t Size)
 
template<typename Param >
std::enable_if<!IsSubGroupInfo< Param >::value >::type get_kernel_device_specific_info_helper (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin, void *Result, size_t Size)
 
template<typename Param >
std::enable_if< !std::is_same< typename Param::return_type, sycl::range< 3 > >::value, typename Param::return_type >::type get_kernel_device_specific_info (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin)
 
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, sycl::range< 3 > >::value, sycl::range< 3 > >::type get_kernel_device_specific_info (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin)
 
template<typename Param >
uint32_t get_kernel_device_specific_info_with_input (RT::PiKernel Kernel, RT::PiDevice Device, sycl::range< 3 > In, const plugin &Plugin)
 
template<typename Param >
Param::return_type get_kernel_device_specific_info_host (const sycl::device &Device)=delete
 
template<>
sycl::range< 3 > get_kernel_device_specific_info_host< info::kernel_device_specific::global_work_size > (const sycl::device &)
 
template<>
size_t get_kernel_device_specific_info_host< info::kernel_device_specific::work_group_size > (const sycl::device &Dev)
 
template<>
sycl::range< 3 > get_kernel_device_specific_info_host< info::kernel_device_specific::compile_work_group_size > (const sycl::device &)
 
template<>
size_t get_kernel_device_specific_info_host< info::kernel_device_specific::preferred_work_group_size_multiple > (const sycl::device &Dev)
 
template<>
size_t get_kernel_device_specific_info_host< info::kernel_device_specific::private_mem_size > (const sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::ext_codeplay_num_regs > (const sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::max_num_sub_groups > (const sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::max_sub_group_size > (const sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::compile_num_sub_groups > (const sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::compile_sub_group_size > (const sycl::device &)
 
void memBufferCreateHelper (const plugin &Plugin, pi_context Ctx, pi_mem_flags Flags, size_t Size, void *HostPtr, pi_mem *RetMem, const pi_mem_properties *Props=nullptr)
 
void memReleaseHelper (const plugin &Plugin, pi_mem Mem)
 
void memBufferMapHelper (const plugin &Plugin, pi_queue command_queue, pi_mem buffer, pi_bool blocking_map, pi_map_flags map_flags, size_t offset, size_t size, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event, void **ret_map)
 
void memUnmapHelper (const plugin &Plugin, pi_queue command_queue, pi_mem memobj, void *mapped_ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event)
 
uint64_t emitMemAllocBeginTrace (uintptr_t ObjHandle, size_t AllocSize, size_t GuardZone)
 
void emitMemAllocEndTrace (uintptr_t ObjHandle, uintptr_t AllocPtr, size_t AllocSize, size_t GuardZone, uint64_t CorrelationID)
 
uint64_t emitMemReleaseBeginTrace (uintptr_t ObjHandle, uintptr_t AllocPtr)
 
void emitMemReleaseEndTrace (uintptr_t ObjHandle, uintptr_t AllocPtr, uint64_t CorrelationID)
 
static void waitForEvents (const std::vector< EventImplPtr > &Events)
 
static RT::PiMemFlags getMemObjCreationFlags (void *UserPtr, bool HostPtrReadOnly)
 
void prepTermPositions (TermPositions &pos, int Dimensions, detail::SYCLMemObjI::MemObjType Type)
 
void copyH2D (SYCLMemObjI *SYCLMemObj, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, RT::PiMem DstMem, QueueImplPtr TgtQueue, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
 
void copyD2H (SYCLMemObjI *SYCLMemObj, RT::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
 
void copyD2D (SYCLMemObjI *SYCLMemObj, RT::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, RT::PiMem DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 >, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
 
static void copyH2H (SYCLMemObjI *, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent >, RT::PiEvent &)
 
static bool IsSupportedImageFormat (RT::PiDeviceBinaryType Format)
 
std::string getDirName (const char *Path)
 
template void * getPluginOpaqueData< sycl::backend::ext_intel_esimd_emulator > (void *)
 
static bool IsBannedPlatform (platform Platform)
 
template<typename ListT , typename FilterT >
static std::vector< int > filterDeviceFilter (std::vector< RT::PiDevice > &PiDevices, RT::PiPlatform Platform, ListT *FilterList)
 
static bool supportsAffinityDomain (const device &dev, info::partition_property partitionProp, info::partition_affinity_domain domain)
 
static bool supportsPartitionProperty (const device &dev, info::partition_property partitionProp)
 
static std::vector< deviceamendDeviceAndSubDevices (backend PlatformBackend, std::vector< device > &DeviceList, ods_target_list *OdsTargetList, const std::vector< int > &original_indices, PlatformImplPtr PlatformImpl)
 
std::string get_platform_info_string_impl (RT::PiPlatform Plt, const plugin &Plugin, pi_platform_info PiCode)
 
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, std::string >::value, std::string >::type get_platform_info (RT::PiPlatform Plt, const plugin &Plugin)
 
template<typename Param >
std::enable_if< std::is_same< Param, info::platform::extensions >::value, std::vector< std::string > >::type get_platform_info (RT::PiPlatform Plt, const plugin &Plugin)
 
template<typename Param >
Param::return_type get_platform_info_host ()=delete
 
template<>
std::string get_platform_info_host< info::platform::profile > ()
 
template<>
std::string get_platform_info_host< info::platform::version > ()
 
template<>
std::string get_platform_info_host< info::platform::name > ()
 
template<>
std::string get_platform_info_host< info::platform::vendor > ()
 
template<>
std::vector< std::string > get_platform_info_host< info::platform::extensions > ()
 
template<typename... Ts>
constexpr size_t totalSize (const std::tuple< Ts... > &)
 
template<PiApiKind Kind, typename... ArgsT>
auto packCallArguments (ArgsT &&...Args)
 
static constexpr char UseSpvEnv ("SYCL_USE_KERNEL_SPV")
 
static void enableITTAnnotationsIfNeeded (const RT::PiProgram &Prog, const plugin &Plugin)
 This function enables ITT annotations in SPIR-V module by setting a specialization constant if INTEL_LIBITTNOTIFY64 env variable is set. More...
 
static RT::PiProgram createBinaryProgram (const ContextImplPtr Context, const device &Device, const unsigned char *Data, size_t DataLen, const std::vector< pi_device_binary_property > Metadata)
 
static RT::PiProgram createSpirvProgram (const ContextImplPtr Context, const unsigned char *Data, size_t DataLen)
 
template<typename ExceptionT , typename RetT >
RetT * waitUntilBuilt (KernelProgramCache &Cache, KernelProgramCache::BuildResult< RetT > *BuildResult)
 
template<typename RetT , typename ExceptionT , typename KeyT , typename AcquireFT , typename GetCacheFT , typename BuildFT >
KernelProgramCache::BuildResult< RetT > * getOrBuild (KernelProgramCache &KPCache, KeyT &&CacheKey, AcquireFT &&Acquire, GetCacheFT &&GetCache, BuildFT &&Build)
 Try to fetch entity (kernel or program) from cache. More...
 
static bool isDeviceBinaryTypeSupported (const context &C, RT::PiDeviceBinaryType Format)
 
static const char * getFormatStr (RT::PiDeviceBinaryType Format)
 
static void appendLinkOptionsFromImage (std::string &LinkOpts, const RTDeviceBinaryImage &Img)
 
static bool getUint32PropAsBool (const RTDeviceBinaryImage &Img, const char *PropName)
 
static void appendCompileOptionsFromImage (std::string &CompileOpts, const RTDeviceBinaryImage &Img)
 
static void applyOptionsFromImage (std::string &CompileOpts, std::string &LinkOpts, const RTDeviceBinaryImage &Img)
 
static void applyCompileOptionsFromEnvironment (std::string &CompileOpts)
 
static void applyLinkOptionsFromEnvironment (std::string &LinkOpts)
 
static void applyOptionsFromEnvironment (std::string &CompileOpts, std::string &LinkOpts)
 
static void emitBuiltProgramInfo (const pi_program &Prog, const ContextImplPtr &Context)
 Emits information about built programs if the appropriate contitions are met, namely when SYCL_RT_WARNING_LEVEL is greater than or equal to 2. More...
 
static bool loadDeviceLib (const ContextImplPtr Context, const char *Name, RT::PiProgram &Prog)
 
static const char * getDeviceLibFilename (DeviceLibExt Extension, bool Native)
 
static const char * getDeviceLibExtensionStr (DeviceLibExt Extension)
 
static RT::PiProgram loadDeviceLibFallback (const ContextImplPtr Context, DeviceLibExt Extension, const RT::PiDevice &Device, bool UseNativeLib)
 
static bool isDeviceLibRequired (DeviceLibExt Ext, uint32_t DeviceLibReqMask)
 
static std::vector< RT::PiProgram > getDeviceLibPrograms (const ContextImplPtr Context, const RT::PiDevice &Device, uint32_t DeviceLibReqMask)
 
static ProgramManager::KernelArgMask createKernelArgMask (const ByteArray &Bytes)
 
static bundle_state getBinImageState (const RTDeviceBinaryImage *BinImage)
 
static bool compatibleWithDevice (RTDeviceBinaryImage *BinImage, const device &Dev)
 
template<>
uint32_t queue_impl::get_info< info::queue::reference_count > () const
 
template<>
context queue_impl::get_info< info::queue::context > () const
 
template<>
device queue_impl::get_info< info::queue::device > () const
 
static event prepareUSMEvent (const std::shared_ptr< detail::queue_impl > &QueueImpl, RT::PiEvent NativeEvent)
 
static event createDiscardedEvent ()
 
uint32_t reduGetMaxNumConcurrentWorkGroups (std::shared_ptr< sycl::detail::queue_impl > Queue)
 
size_t reduGetMaxWGSize (std::shared_ptr< sycl::detail::queue_impl > Queue, size_t LocalMemBytesPerWorkItem)
 
static std::string demangleKernelName (std::string Name)
 
static std::string deviceToString (device Device)
 
static void applyFuncOnFilteredArgs (const ProgramManager::KernelArgMask &EliminatedArgMask, std::vector< ArgDesc > &Args, std::function< void(detail::ArgDesc &Arg, int NextTrueIndex)> Func)
 
static std::string accessModeToString (access::mode Mode)
 
static void flushCrossQueueDeps (const std::vector< EventImplPtr > &EventImpls, const QueueImplPtr &Queue)
 
static std::string cgTypeToString (detail::CG::CGTYPE Type)
 
static void adjustNDRangePerKernel (NDRDescT &NDR, RT::PiKernel Kernel, const device_impl &DeviceImpl)
 
static void ReverseRangeDimensionsForKernel (NDRDescT &NDR)
 
static pi_result SetKernelParamsAndLaunch (const QueueImplPtr &Queue, std::vector< ArgDesc > &Args, const std::shared_ptr< device_image_impl > &DeviceImageImpl, RT::PiKernel Kernel, NDRDescT &NDRDesc, std::vector< RT::PiEvent > &RawEvents, RT::PiEvent *OutEvent, const ProgramManager::KernelArgMask &EliminatedArgMask, const std::function< void *(Requirement *Req)> &getMemAllocationFunc)
 
void DispatchNativeKernel (void *Blob)
 
pi_int32 enqueueImpKernel (const QueueImplPtr &Queue, NDRDescT &NDRDesc, std::vector< ArgDesc > &Args, const std::shared_ptr< detail::kernel_bundle_impl > &KernelBundleImplPtr, const std::shared_ptr< detail::kernel_impl > &MSyclKernel, const std::string &KernelName, const detail::OSModuleHandle &OSModuleHandle, std::vector< RT::PiEvent > &RawEvents, RT::PiEvent *OutEvent, const std::function< void *(Requirement *Req)> &getMemAllocationFunc)
 
static bool doOverlap (const Requirement *LHS, const Requirement *RHS)
 Checks whether two requirements overlap or not. More...
 
static bool sameCtx (const ContextImplPtr &LHS, const ContextImplPtr &RHS)
 
static bool IsSuitableSubReq (const Requirement *Req)
 Checks if current requirement is requirement for sub buffer. More...
 
static bool isAccessModeAllowed (access::mode Required, access::mode Current)
 Checks if the required access mode is allowed under the current one. More...
 
static access::mode combineAccessModes (access::mode A, access::mode B)
 Combines two access modes into a single one that allows both. More...
 
static bool markNodeAsVisited (Command *Cmd, std::vector< Command * > &Visited)
 
static void unmarkVisitedNodes (std::vector< Command * > &Visited)
 
static void handleVisitedNodes (std::vector< Command * > &Visited)
 
static void printDotRecursive (std::fstream &Stream, std::vector< Command * > &Visited, Command *Cmd)
 
static CommandinsertMapUnmapForLinkedCmds (AllocaCommandBase *AllocaCmdSrc, AllocaCommandBase *AllocaCmdDst, access::mode MapMode)
 
static bool checkHostUnifiedMemory (const ContextImplPtr &Ctx)
 
static bool isInteropHostTask (const std::unique_ptr< ExecCGCommand > &Cmd)
 
static void combineAccessModesOfReqs (std::vector< Requirement * > &Reqs)
 
static CommandgetCommand (const EventImplPtr &Event)
 
static bool doOverlap (const Requirement *LHS, const Requirement *RHS)
 
static bool isHostAccessorCmd (Command *Cmd)
 
static void deallocateStreams (std::vector< std::shared_ptr< stream_impl >> &StreamsToDeallocate)
 
void initStream (StreamImplPtr Stream, QueueImplPtr Queue)
 
void stableSerializeSpecConstRegistry (const SpecConstRegistryT &Reg, SerializedObj &Dst)
 
std::ostream & operator<< (std::ostream &Out, const spec_constant_impl &V)
 
void force_type (info::device_type &t, const info::device_type &ft)
 
static int getDevicePreference (const device &Device)
 
static void traceDeviceSelection (const device &Device, int Score, bool Chosen)
 
device select_device (DSelectorInvocableType DeviceSelectorInvocable, std::vector< device > &Devices)
 
ESIMDDeviceInterface * getESIMDDeviceInterface ()
 

Variables

constexpr KernelSetId SpvFileKSId = 0
 
constexpr KernelSetId LastKSId = SpvFileKSId
 
static constexpr int REJECT_DEVICE_SCORE = -1
 
static constexpr ext::intel::experimental::architecture max_architecture
 
static constexpr bool is_allowable_aot_mode
 
static constexpr IsAOTForArchitectureClass is_aot_for_architecture
 
template<typename F , typename SuggestedArgType >
decltype(member_ptr_helper(&F::operator())) argument_helper (int)
 
static constexpr FmtFlags Dec = 0x0001
 
static constexpr FmtFlags Hex = 0x0002
 
static constexpr FmtFlags Oct = 0x0004
 
static constexpr FmtFlags ShowBase = 0x0008
 
static constexpr FmtFlags ShowPos = 0x0010
 
static constexpr FmtFlags Fixed = 0x0020
 
static constexpr FmtFlags Scientific = 0x0040
 
static constexpr FmtFlags BaseField = Dec | Hex | Oct
 
static constexpr FmtFlags FloatField = Scientific | Fixed
 
constexpr size_t MAX_FLOATING_POINT_DIGITS = 24
 
constexpr size_t MAX_INTEGRAL_DIGITS = 23
 
constexpr const char * VEC_ELEMENT_DELIMITER = ", "
 
constexpr char VEC_OPEN_BRACE = '{'
 
constexpr char VEC_CLOSE_BRACE = '}'
 
constexpr size_t MAX_DIMENSIONS = 3
 
constexpr size_t MAX_ARRAY_SIZE
 
constexpr unsigned FLUSH_BUF_OFFSET_SIZE = 2
 
constexpr static access::address_space GlobalBufAS
 
constexpr static int GlobalBufDim = 1
 
constexpr static access::address_space GlobalOffsetAS
 
constexpr static int GlobalOffsetDim = 1
 
constexpr size_t MAX_ITEM_SIZE = 2 * MAX_ARRAY_SIZE + 20
 
constexpr char BackendNameKeyName [] = "BackendName"
 
constexpr char DeviceTypeKeyName [] = "DeviceType"
 
constexpr char DeviceVendorIdKeyName [] = "DeviceVendorId"
 
constexpr char DriverVersionKeyName [] = "DriverVersion"
 
constexpr char PlatformVersionKeyName [] = "PlatformVersion"
 
constexpr char DeviceNameKeyName [] = "DeviceName"
 
constexpr char PlatformNameKeyName [] = "PlatformName"
 
constexpr std::array< const char *, 7 > SupportedAllowListKeyNames
 
constexpr bool ConfigFromEnvEnabled = true
 
constexpr bool ConfigFromFileEnabled = true
 
constexpr bool ConfigFromCompileDefEnabled = true
 
constexpr int MAX_CONFIG_NAME = 256
 
constexpr int MAX_CONFIG_VALUE = 1024
 
static constexpr int DbgProgMgr = 0
 
static const std::map< DeviceLibExt, std::pair< const char *, const char * > > DeviceLibNames
 
static const std::map< DeviceLibExt, const char * > DeviceLibExtensionStrs
 
static constexpr uint32_t ITTSpecConstId = 0xFF747469
 
static constexpr size_t MaxNumQueues = 256
 Sets max number of queues supported by FPGA RT. More...
 
constexpr CUDAContextT DefaultContextType = CUDAContextT::custom
 Default context type created for CUDA backend. More...
 
constexpr const char * SYCL_STREAM_NAME = "sycl"
 
constexpr const char * SYCL_PICALL_STREAM_NAME = "sycl.pi"
 
constexpr const char * SYCL_PIDEBUGCALL_STREAM_NAME = "sycl.pi.debug"
 
constexpr auto SYCL_MEM_ALLOC_STREAM_NAME
 
constexpr const char * SYCL_BUFFER_STREAM_NAME
 

Typedef Documentation

◆ __sycl_reduction_kernel

template<template< typename, reduction::strategy, typename... > class MainOrAux, class KernelName , reduction::strategy Strategy, class... Ts>
using sycl::_V1::detail::__sycl_reduction_kernel = typedef std::conditional_t<std::is_same<KernelName, auto_name>::value, auto_name, MainOrAux<KernelName, Strategy, Ts...> >

A helper to pass undefined (sycl::detail::auto_name) names unmodified.

We must do that to avoid name collisions.

Definition at line 868 of file reduction.hpp.

◆ AccessorImplPtr

Definition at line 473 of file accessor.hpp.

◆ address_space_list

template<access::address_space... Values>
using sycl::_V1::detail::address_space_list = typedef value_list<access::address_space, Values...>

Definition at line 84 of file type_list.hpp.

◆ AllowListParsedT

using sycl::_V1::detail::AllowListParsedT = typedef std::vector<DeviceDescT>

Definition at line 23 of file allowlist.hpp.

◆ change_base_type_t

template<typename T , typename B >
using sycl::_V1::detail::change_base_type_t = typedef typename change_base_type<T, B>::type

Definition at line 136 of file type_traits.hpp.

◆ common_rel_ret_t

template<typename T >
using sycl::_V1::detail::common_rel_ret_t = typedef std::conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, int>

Definition at line 615 of file generic_type_traits.hpp.

◆ const_if_const_AS

template<access::address_space AS, class DataT >
using sycl::_V1::detail::const_if_const_AS = typedef DataT

Definition at line 386 of file type_traits.hpp.

◆ ContextImplPtr

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

Definition at line 30 of file event_impl.hpp.

◆ convert_data_type

template<typename T , typename B >
using sycl::_V1::detail::convert_data_type = typedef convert_data_type_impl<T, B, T>

Definition at line 304 of file generic_type_traits.hpp.

◆ ConvertToOpenCLType_t

template<typename T >
using sycl::_V1::detail::ConvertToOpenCLType_t = typedef std::conditional_t< TryToGetVectorT<SelectMatchingOpenCLType_t<T> >::value, typename TryToGetVectorT<SelectMatchingOpenCLType_t<T> >::type, std::conditional_t< TryToGetPointerT<SelectMatchingOpenCLType_t<T> >::value, typename TryToGetPointerVecT<SelectMatchingOpenCLType_t<T> >::type, SelectMatchingOpenCLType_t<T> >>

Definition at line 551 of file generic_type_traits.hpp.

◆ copy_cv_qualifiers_t

template<typename T , typename R >
using sycl::_V1::detail::copy_cv_qualifiers_t = typedef typename copy_cv_qualifiers<T, R>::type

Definition at line 87 of file type_traits.hpp.

◆ DeviceDescT

using sycl::_V1::detail::DeviceDescT = typedef std::map<std::string, std::string>

Definition at line 22 of file allowlist.hpp.

◆ DeviceImageImplPtr

using sycl::_V1::detail::DeviceImageImplPtr = typedef std::shared_ptr<device_image_impl>

Definition at line 70 of file kernel_bundle.hpp.

◆ DeviceImplPtr

Definition at line 55 of file program_manager.hpp.

◆ DevImgSelectorImpl

using sycl::_V1::detail::DevImgSelectorImpl = typedef std::function<bool(const detail::DeviceImageImplPtr &DevImgImpl)>

Definition at line 458 of file kernel_bundle.hpp.

◆ DSelectorInvocableType

using sycl::_V1::detail::DSelectorInvocableType = typedef std::function<int(const sycl::device &)>

Definition at line 120 of file device_selector.hpp.

◆ empty_type_list

Definition at line 25 of file type_list.hpp.

◆ EnableIfFP

template<class F , class T = void>
using sycl::_V1::detail::EnableIfFP = typedef typename std::enable_if_t<std::is_same<F, float>::value || std::is_same<F, double>::value || std::is_same<F, half>::value, T>

Definition at line 63 of file stream.hpp.

◆ EnableIfImgAccDataT

template<typename DataT >
using sycl::_V1::detail::EnableIfImgAccDataT = typedef typename std::enable_if_t<is_validImageDataT<DataT>::value, DataT>

Definition at line 77 of file image.hpp.

◆ EnableIfOutputIteratorT

template<typename DataT >
using sycl::_V1::detail::EnableIfOutputIteratorT = typedef std::enable_if_t< !std::is_pointer<DataT>::value>

Definition at line 37 of file common.hpp.

◆ EnableIfOutputPointerT

template<typename DataT >
using sycl::_V1::detail::EnableIfOutputPointerT = typedef std::enable_if_t< std::is_pointer<DataT>::value>

Definition at line 33 of file common.hpp.

◆ EnableIfSwizzleVec

template<typename T >
using sycl::_V1::detail::EnableIfSwizzleVec = typedef typename std::enable_if_t<IsSwizzleOp<T>::value, typename IsSwizzleOp<T>::Type>

Definition at line 658 of file stream.hpp.

◆ EventImplPtr

typedef std::shared_ptr< event_impl > sycl::_V1::detail::EventImplPtr

Definition at line 42 of file cg.hpp.

◆ find_larger_type_t

template<typename TypeList , typename T >
using sycl::_V1::detail::find_larger_type_t = typedef find_type_t<TypeList, is_type_size_greater, T>

Definition at line 133 of file type_list.hpp.

◆ find_same_size_type_t

template<typename TypeList , typename T >
using sycl::_V1::detail::find_same_size_type_t = typedef find_type_t<TypeList, is_type_size_equal, T>

Definition at line 127 of file type_list.hpp.

◆ find_smaller_type_t

template<typename TypeList , typename T >
using sycl::_V1::detail::find_smaller_type_t = typedef find_type_t<TypeList, is_type_size_less, T>

Definition at line 130 of file type_list.hpp.

◆ find_twice_as_large_type_t

template<typename TypeList , typename T >
using sycl::_V1::detail::find_twice_as_large_type_t = typedef find_type_t<TypeList, is_type_size_double_of, T>

Definition at line 140 of file type_list.hpp.

◆ find_twice_as_small_type_t

template<typename TypeList , typename T >
using sycl::_V1::detail::find_twice_as_small_type_t = typedef find_type_t<TypeList, is_type_size_half_of, T>

Definition at line 136 of file type_list.hpp.

◆ find_type_t

template<typename TypeList , template< typename, typename > class Comp, typename T >
using sycl::_V1::detail::find_type_t = typedef typename find_type<TypeList, Comp, T>::type

Definition at line 124 of file type_list.hpp.

◆ FmtFlags

using sycl::_V1::detail::FmtFlags = typedef unsigned int

Definition at line 23 of file stream.hpp.

◆ GlobalBufAccessorT

using sycl::_V1::detail::GlobalBufAccessorT = typedef accessor<char, 1, sycl::access::mode::read_write, sycl::access::target::global_buffer, sycl::access::placeholder::false_t>

Definition at line 69 of file stream.hpp.

◆ GlobalBufPtrType

Definition at line 75 of file stream.hpp.

◆ GlobalOffsetAccessorT

using sycl::_V1::detail::GlobalOffsetAccessorT = typedef accessor<unsigned, 1, sycl::access::mode::atomic, sycl::access::target::global_buffer, sycl::access::placeholder::false_t>

Definition at line 79 of file stream.hpp.

◆ GlobalOffsetPtrType

using sycl::_V1::detail::GlobalOffsetPtrType = typedef typename detail::DecoratedType<unsigned, GlobalBufAS>::type *

Definition at line 85 of file stream.hpp.

◆ head_t

template<typename T >
using sycl::_V1::detail::head_t = typedef typename T::head

Definition at line 18 of file type_list.hpp.

◆ image_allocator

Definition at line 40 of file image_impl.hpp.

◆ int64_t

using sycl::_V1::detail::int64_t = typedef conditional<sizeof(long) == 8, long, long long>::type

Definition at line 34 of file kernel_desc.hpp.

◆ int_constant

template<int V>
using sycl::_V1::detail::int_constant = typedef std::integral_constant<int, V>

Definition at line 89 of file type_traits.hpp.

◆ internal_host_rel_ret_t

template<typename T >
using sycl::_V1::detail::internal_host_rel_ret_t = typedef common_rel_ret_t<T>

Definition at line 617 of file generic_type_traits.hpp.

◆ internal_rel_ret_t

template<typename T >
using sycl::_V1::detail::internal_rel_ret_t = typedef typename RelationalReturnType<T>::type

Definition at line 656 of file generic_type_traits.hpp.

◆ is_arithmetic_or_complex

template<typename T >
using sycl::_V1::detail::is_arithmetic_or_complex = typedef std::integral_constant<bool, sycl::detail::is_complex<T>::value || sycl::detail::is_arithmetic<T>::value>

Definition at line 121 of file group_algorithm.hpp.

◆ is_charn

template<typename T >
using sycl::_V1::detail::is_charn = typedef is_contained<T, gtl::vector_default_char_list>

Definition at line 92 of file generic_type_traits.hpp.

◆ is_doublen

template<typename T >
using sycl::_V1::detail::is_doublen = typedef is_contained<T, gtl::vector_double_list>

Definition at line 33 of file generic_type_traits.hpp.

◆ is_float_to_float

template<typename T , typename R >
using sycl::_V1::detail::is_float_to_float = typedef std::integral_constant<bool, detail::is_floating_point<T>::value && detail::is_floating_point<R>::value>

Definition at line 257 of file types.hpp.

◆ is_float_to_int

template<typename T , typename R >
using sycl::_V1::detail::is_float_to_int = typedef std::integral_constant<bool, detail::is_floating_point<T>::value && std::is_integral<R>::value>

Definition at line 252 of file types.hpp.

◆ is_floatn

template<typename T >
using sycl::_V1::detail::is_floatn = typedef is_contained<T, gtl::vector_float_list>

Definition at line 25 of file generic_type_traits.hpp.

◆ is_gen_based_on_type_sizeof

template<typename T , int N, template< typename > class S>
using sycl::_V1::detail::is_gen_based_on_type_sizeof = typedef std::bool_constant<S<T>::value && (sizeof(vector_element_t<T>) == N)>

Definition at line 231 of file type_traits.hpp.

◆ is_genchar

template<typename T >
using sycl::_V1::detail::is_genchar = typedef is_contained<T, gtl::char_list>

Definition at line 106 of file generic_type_traits.hpp.

◆ is_gencross

template<typename T >
using sycl::_V1::detail::is_gencross = typedef is_contained<T, gtl::cross_floating_list>

Definition at line 89 of file generic_type_traits.hpp.

◆ is_gencrossdouble

Definition at line 83 of file generic_type_traits.hpp.

◆ is_gencrossfloat

template<typename T >
using sycl::_V1::detail::is_gencrossfloat = typedef is_contained<T, gtl::cross_float_list>

Definition at line 80 of file generic_type_traits.hpp.

◆ is_gencrosshalf

template<typename T >
using sycl::_V1::detail::is_gencrosshalf = typedef is_contained<T, gtl::cross_half_list>

Definition at line 86 of file generic_type_traits.hpp.

◆ is_genfloat

template<typename T >
using sycl::_V1::detail::is_genfloat = typedef is_contained<T, gtl::floating_list>

Definition at line 47 of file generic_type_traits.hpp.

◆ is_genfloatd

template<typename T >
using sycl::_V1::detail::is_genfloatd = typedef is_contained<T, gtl::double_list>

Definition at line 35 of file generic_type_traits.hpp.

◆ is_genfloatf

template<typename T >
using sycl::_V1::detail::is_genfloatf = typedef is_contained<T, gtl::float_list>

Definition at line 27 of file generic_type_traits.hpp.

◆ is_genfloath

template<typename T >
using sycl::_V1::detail::is_genfloath = typedef is_contained<T, gtl::half_list>

Definition at line 42 of file generic_type_traits.hpp.

◆ is_genfloatptr

template<typename T >
using sycl::_V1::detail::is_genfloatptr = typedef std::bool_constant< is_pointer<T>::value && is_genfloat<remove_pointer_t<T> >::value && is_address_space_compliant<T, gvl::nonconst_address_space_list>::value>

Definition at line 236 of file generic_type_traits.hpp.

◆ is_gengeodouble

template<typename T >
using sycl::_V1::detail::is_gengeodouble = typedef is_contained<T, gtl::geo_double_list>

Definition at line 62 of file generic_type_traits.hpp.

◆ is_gengeofloat

template<typename T >
using sycl::_V1::detail::is_gengeofloat = typedef is_contained<T, gtl::geo_float_list>

Definition at line 59 of file generic_type_traits.hpp.

◆ is_gengeohalf

template<typename T >
using sycl::_V1::detail::is_gengeohalf = typedef is_contained<T, gtl::geo_half_list>

Definition at line 64 of file generic_type_traits.hpp.

◆ is_genint

template<typename T >
using sycl::_V1::detail::is_genint = typedef is_contained<T, gtl::signed_int_list>

Definition at line 129 of file generic_type_traits.hpp.

◆ is_geninteger

template<typename T >
using sycl::_V1::detail::is_geninteger = typedef is_contained<T, gtl::integer_list>

Definition at line 160 of file generic_type_traits.hpp.

◆ is_geninteger16bit

Definition at line 222 of file generic_type_traits.hpp.

◆ is_geninteger32bit

Definition at line 225 of file generic_type_traits.hpp.

◆ is_geninteger64bit

Definition at line 228 of file generic_type_traits.hpp.

◆ is_geninteger8bit

Definition at line 219 of file generic_type_traits.hpp.

◆ is_genintptr

template<typename T >
using sycl::_V1::detail::is_genintptr = typedef std::bool_constant< is_pointer<T>::value && is_genint<remove_pointer_t<T> >::value && is_address_space_compliant<T, gvl::nonconst_address_space_list>::value>

Definition at line 231 of file generic_type_traits.hpp.

◆ is_genlong

template<typename T >
using sycl::_V1::detail::is_genlong = typedef is_contained<T, gtl::signed_long_list>

Definition at line 140 of file generic_type_traits.hpp.

◆ is_genlonglong

Definition at line 152 of file generic_type_traits.hpp.

◆ is_genptr

template<typename T >
using sycl::_V1::detail::is_genptr = typedef std::bool_constant< is_pointer<T>::value && is_gentype<remove_pointer_t<T> >::value && is_address_space_compliant<T, gvl::nonconst_address_space_list>::value>

Definition at line 241 of file generic_type_traits.hpp.

◆ is_genshort

template<typename T >
using sycl::_V1::detail::is_genshort = typedef is_contained<T, gtl::signed_short_list>

Definition at line 112 of file generic_type_traits.hpp.

◆ is_gentype

template<typename T >
using sycl::_V1::detail::is_gentype = typedef is_contained<T, gtl::basic_list>

Definition at line 186 of file generic_type_traits.hpp.

◆ is_halfn

template<typename T >
using sycl::_V1::detail::is_halfn = typedef is_contained<T, gtl::vector_half_list>

Definition at line 40 of file generic_type_traits.hpp.

◆ is_igenchar

template<typename T >
using sycl::_V1::detail::is_igenchar = typedef is_contained<T, gtl::signed_char_list>

Definition at line 101 of file generic_type_traits.hpp.

◆ is_igeninteger

template<typename T >
using sycl::_V1::detail::is_igeninteger = typedef is_contained<T, gtl::signed_integer_list>

Definition at line 163 of file generic_type_traits.hpp.

◆ is_igeninteger16bit

Definition at line 198 of file generic_type_traits.hpp.

◆ is_igeninteger32bit

Definition at line 201 of file generic_type_traits.hpp.

◆ is_igeninteger64bit

Definition at line 204 of file generic_type_traits.hpp.

◆ is_igeninteger8bit

Definition at line 195 of file generic_type_traits.hpp.

◆ is_igenlonginteger

Definition at line 155 of file generic_type_traits.hpp.

◆ is_int_to_float

template<typename T , typename R >
using sycl::_V1::detail::is_int_to_float = typedef std::integral_constant<bool, std::is_integral<T>::value && detail::is_floating_point<R>::value>

Definition at line 247 of file types.hpp.

◆ is_int_to_int

template<typename T , typename R >
using sycl::_V1::detail::is_int_to_int = typedef std::integral_constant<bool, std::is_integral<T>::value && std::is_integral<R>::value>

Definition at line 216 of file types.hpp.

◆ is_intn

template<typename T >
using sycl::_V1::detail::is_intn = typedef is_contained<T, gtl::vector_signed_int_list>

Definition at line 127 of file generic_type_traits.hpp.

◆ is_longlongn

Definition at line 149 of file generic_type_traits.hpp.

◆ is_longn

template<typename T >
using sycl::_V1::detail::is_longn = typedef is_contained<T, gtl::vector_signed_long_list>

Definition at line 138 of file generic_type_traits.hpp.

◆ is_nan_type

template<typename T >
using sycl::_V1::detail::is_nan_type = typedef is_contained<T, gtl::nan_list>

Definition at line 245 of file generic_type_traits.hpp.

◆ is_one_of_spaces

template<access::address_space AddressSpace, typename ValueList >
using sycl::_V1::detail::is_one_of_spaces = typedef is_contained_value<access::address_space, AddressSpace, ValueList>

Definition at line 87 of file type_list.hpp.

◆ is_plus

template<typename T , typename BinaryOperation >
using sycl::_V1::detail::is_plus = typedef std::integral_constant< bool, std::is_same<BinaryOperation, sycl::plus<T> >::value || std::is_same<BinaryOperation, sycl::plus<void> >::value>

Definition at line 106 of file group_algorithm.hpp.

◆ is_plus_if_complex

template<typename T , typename BinaryOperation >
using sycl::_V1::detail::is_plus_if_complex = typedef std::integral_constant<bool, (is_complex<T>::value ? is_plus<T, BinaryOperation>::value : std::true_type::value)>

Definition at line 126 of file group_algorithm.hpp.

◆ is_scharn

template<typename T >
using sycl::_V1::detail::is_scharn = typedef is_contained<T, gtl::vector_signed_char_list>

Definition at line 95 of file generic_type_traits.hpp.

◆ is_sgenfloat

template<typename T >
using sycl::_V1::detail::is_sgenfloat = typedef is_contained<T, gtl::scalar_floating_list>

Definition at line 50 of file generic_type_traits.hpp.

◆ is_sgengeo

template<typename T >
using sycl::_V1::detail::is_sgengeo = typedef is_contained<T, gtl::scalar_geo_list>

Definition at line 75 of file generic_type_traits.hpp.

◆ is_sgeninteger

template<typename T >
using sycl::_V1::detail::is_sgeninteger = typedef is_contained<T, gtl::scalar_integer_list>

Definition at line 169 of file generic_type_traits.hpp.

◆ is_sgentype

template<typename T >
using sycl::_V1::detail::is_sgentype = typedef is_contained<T, gtl::scalar_basic_list>

Definition at line 192 of file generic_type_traits.hpp.

◆ is_shortn

template<typename T >
using sycl::_V1::detail::is_shortn = typedef is_contained<T, gtl::vector_signed_short_list>

Definition at line 109 of file generic_type_traits.hpp.

◆ is_sigeninteger

Definition at line 175 of file generic_type_traits.hpp.

◆ is_sint_to_float

template<typename T , typename R >
using sycl::_V1::detail::is_sint_to_float = typedef std::integral_constant<bool, std::is_integral<T>::value && !(std::is_unsigned<T>::value) && detail::is_floating_point<R>::value>

Definition at line 236 of file types.hpp.

◆ is_sint_to_from_uint

template<typename T , typename R >
using sycl::_V1::detail::is_sint_to_from_uint = typedef std::integral_constant< bool, (is_sugeninteger<T>::value && is_sigeninteger<R>::value) || (is_sigeninteger<T>::value && is_sugeninteger<R>::value)>

Definition at line 231 of file types.hpp.

◆ is_sint_to_sint

template<typename T , typename R >
using sycl::_V1::detail::is_sint_to_sint = typedef std::integral_constant<bool, is_sigeninteger<T>::value && is_sigeninteger<R>::value>

Definition at line 221 of file types.hpp.

◆ is_standard_type

template<typename T >
using sycl::_V1::detail::is_standard_type = typedef std::integral_constant<bool, detail::is_sgentype<T>::value>

Definition at line 261 of file types.hpp.

◆ is_sugeninteger

Definition at line 178 of file generic_type_traits.hpp.

◆ is_svgenfloat

Definition at line 56 of file generic_type_traits.hpp.

◆ is_svgenfloatd

Definition at line 38 of file generic_type_traits.hpp.

◆ is_svgenfloatf

Definition at line 30 of file generic_type_traits.hpp.

◆ is_svgenfloath

Definition at line 45 of file generic_type_traits.hpp.

◆ is_ucharn

Definition at line 98 of file generic_type_traits.hpp.

◆ is_ugenchar

template<typename T >
using sycl::_V1::detail::is_ugenchar = typedef is_contained<T, gtl::unsigned_char_list>

Definition at line 104 of file generic_type_traits.hpp.

◆ is_ugenint

template<typename T >
using sycl::_V1::detail::is_ugenint = typedef is_contained<T, gtl::unsigned_int_list>

Definition at line 124 of file generic_type_traits.hpp.

◆ is_ugeninteger

Definition at line 166 of file generic_type_traits.hpp.

◆ is_ugeninteger16bit

Definition at line 210 of file generic_type_traits.hpp.

◆ is_ugeninteger32bit

Definition at line 213 of file generic_type_traits.hpp.

◆ is_ugeninteger64bit

Definition at line 216 of file generic_type_traits.hpp.

◆ is_ugeninteger8bit

Definition at line 207 of file generic_type_traits.hpp.

◆ is_ugenlong

template<typename T >
using sycl::_V1::detail::is_ugenlong = typedef is_contained<T, gtl::unsigned_long_list>

Definition at line 135 of file generic_type_traits.hpp.

◆ is_ugenlonginteger

Definition at line 158 of file generic_type_traits.hpp.

◆ is_ugenlonglong

Definition at line 146 of file generic_type_traits.hpp.

◆ is_ugenshort

template<typename T >
using sycl::_V1::detail::is_ugenshort = typedef is_contained<T, gtl::unsigned_short_list>

Definition at line 118 of file generic_type_traits.hpp.

◆ is_uint_to_float

template<typename T , typename R >
using sycl::_V1::detail::is_uint_to_float = typedef std::integral_constant<bool, std::is_unsigned<T>::value && detail::is_floating_point<R>::value>

Definition at line 242 of file types.hpp.

◆ is_uint_to_uint

template<typename T , typename R >
using sycl::_V1::detail::is_uint_to_uint = typedef std::integral_constant<bool, is_sugeninteger<T>::value && is_sugeninteger<R>::value>

Definition at line 226 of file types.hpp.

◆ is_uintn

template<typename T >
using sycl::_V1::detail::is_uintn = typedef is_contained<T, gtl::vector_unsigned_int_list>

Definition at line 121 of file generic_type_traits.hpp.

◆ is_ulonglongn

Definition at line 143 of file generic_type_traits.hpp.

◆ is_ulongn

Definition at line 132 of file generic_type_traits.hpp.

◆ is_ushortn

Definition at line 115 of file generic_type_traits.hpp.

◆ is_validImageDataT

template<typename T >
using sycl::_V1::detail::is_validImageDataT = typedef typename detail::is_contained< T, type_list<cl_int4, cl_uint4, cl_float4, cl_half4> >::type

Definition at line 73 of file image.hpp.

◆ is_vgenfloat

template<typename T >
using sycl::_V1::detail::is_vgenfloat = typedef is_contained<T, gtl::vector_floating_list>

Definition at line 53 of file generic_type_traits.hpp.

◆ is_vgengeo

template<typename T >
using sycl::_V1::detail::is_vgengeo = typedef is_contained<T, gtl::vector_geo_list>

Definition at line 77 of file generic_type_traits.hpp.

◆ is_vgengeodouble

Definition at line 70 of file generic_type_traits.hpp.

◆ is_vgengeofloat

Definition at line 67 of file generic_type_traits.hpp.

◆ is_vgengeohalf

Definition at line 73 of file generic_type_traits.hpp.

◆ is_vgeninteger

template<typename T >
using sycl::_V1::detail::is_vgeninteger = typedef is_contained<T, gtl::vector_integer_list>

Definition at line 172 of file generic_type_traits.hpp.

◆ is_vgentype

template<typename T >
using sycl::_V1::detail::is_vgentype = typedef is_contained<T, gtl::vector_basic_list>

Definition at line 189 of file generic_type_traits.hpp.

◆ is_vigeninteger

Definition at line 181 of file generic_type_traits.hpp.

◆ is_vugeninteger

Definition at line 184 of file generic_type_traits.hpp.

◆ IsBitAND

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsBitAND = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::bit_and<T> >::value || std::is_same<BinaryOperation, sycl::bit_and<void> >::value>

Definition at line 42 of file known_identity.hpp.

◆ IsBitOR

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsBitOR = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::bit_or<T> >::value || std::is_same<BinaryOperation, sycl::bit_or<void> >::value>

Definition at line 47 of file known_identity.hpp.

◆ IsBitXOR

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsBitXOR = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::bit_xor<T> >::value || std::is_same<BinaryOperation, sycl::bit_xor<void> >::value>

Definition at line 52 of file known_identity.hpp.

◆ IsFalseIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsFalseIdentityOp = typedef std::bool_constant<IsLogicalOR<T, BinaryOperation>::value>

Definition at line 100 of file known_identity.hpp.

◆ IsKnownIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsKnownIdentityOp = typedef std::bool_constant<IsZeroIdentityOp<T, BinaryOperation>::value || IsOneIdentityOp<T, BinaryOperation>::value || IsOnesIdentityOp<T, BinaryOperation>::value || IsMinimumIdentityOp<T, BinaryOperation>::value || IsMaximumIdentityOp<T, BinaryOperation>::value || IsFalseIdentityOp<T, BinaryOperation>::value || IsTrueIdentityOp<T, BinaryOperation>::value>

Definition at line 109 of file known_identity.hpp.

◆ IsLogicalAND

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsLogicalAND = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::logical_and<T> >::value || std::is_same<BinaryOperation, sycl::logical_and<void> >::value>

Definition at line 57 of file known_identity.hpp.

◆ IsLogicalOR

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsLogicalOR = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::logical_or<T> >::value || std::is_same<BinaryOperation, sycl::logical_or<void> >::value>

Definition at line 62 of file known_identity.hpp.

◆ IsMaximum

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsMaximum = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::maximum<T> >::value || std::is_same<BinaryOperation, sycl::maximum<void> >::value>

Definition at line 37 of file known_identity.hpp.

◆ IsMaximumIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsMaximumIdentityOp = typedef std::bool_constant<(is_geninteger<T>::value || is_genfloat<T>::value) && IsMaximum<T, BinaryOperation>::value>

Definition at line 94 of file known_identity.hpp.

◆ IsMinimum

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsMinimum = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::minimum<T> >::value || std::is_same<BinaryOperation, sycl::minimum<void> >::value>

Definition at line 32 of file known_identity.hpp.

◆ IsMinimumIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsMinimumIdentityOp = typedef std::bool_constant<(is_geninteger<T>::value || is_genfloat<T>::value) && IsMinimum<T, BinaryOperation>::value>

Definition at line 88 of file known_identity.hpp.

◆ IsMultiplies

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsMultiplies = typedef std::bool_constant< std::is_same<BinaryOperation, sycl::multiplies<T> >::value || std::is_same<BinaryOperation, sycl::multiplies<void> >::value>

Definition at line 27 of file known_identity.hpp.

◆ IsOneIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsOneIdentityOp = typedef std::bool_constant<(is_geninteger<T>::value || is_genfloat<T>::value) && IsMultiplies<T, BinaryOperation>::value>

Definition at line 76 of file known_identity.hpp.

◆ IsOnesIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsOnesIdentityOp = typedef std::bool_constant<is_geninteger<T>::value && IsBitAND<T, BinaryOperation>::value>

Definition at line 82 of file known_identity.hpp.

◆ IsPlus

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsPlus = typedef std::bool_constant<std::is_same<BinaryOperation, sycl::plus<T> >::value || std::is_same<BinaryOperation, sycl::plus<void> >::value>

Definition at line 22 of file known_identity.hpp.

◆ IsPropertyListT

template<typename T >
using sycl::_V1::detail::IsPropertyListT = typedef typename std::is_base_of<PropertyListBase, T>

Definition at line 270 of file accessor.hpp.

◆ IsReduOptForAtomic64Op

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsReduOptForAtomic64Op = typedef std::bool_constant<(IsPlus<T, BinaryOperation>::value || IsMinimum<T, BinaryOperation>::value || IsMaximum<T, BinaryOperation>::value) && is_sgenfloat<T>::value && sizeof(T) == 8>

Definition at line 105 of file reduction.hpp.

◆ IsReduOptForFastAtomicFetch

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsReduOptForFastAtomicFetch = typedef std::bool_constant<((is_sgenfloat<T>::value && sizeof(T) == 4) || is_sgeninteger<T>::value) && IsValidAtomicType<T>::value && (IsPlus<T, BinaryOperation>::value || IsMinimum<T, BinaryOperation>::value || IsMaximum<T, BinaryOperation>::value || IsBitOR<T, BinaryOperation>::value || IsBitXOR<T, BinaryOperation>::value || IsBitAND<T, BinaryOperation>::value)>

Definition at line 81 of file reduction.hpp.

◆ IsReduOptForFastReduce

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsReduOptForFastReduce = typedef std::bool_constant<((is_sgeninteger<T>::value && (sizeof(T) == 4 || sizeof(T) == 8)) || is_sgenfloat<T>::value) && (IsPlus<T, BinaryOperation>::value || IsMinimum<T, BinaryOperation>::value || IsMaximum<T, BinaryOperation>::value)>

Definition at line 121 of file reduction.hpp.

◆ IsRunTimePropertyListT

template<typename T >
using sycl::_V1::detail::IsRunTimePropertyListT = typedef typename std::is_same<ext::oneapi::accessor_property_list<>, T>

Definition at line 273 of file accessor.hpp.

◆ IsTrueIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsTrueIdentityOp = typedef std::bool_constant<IsLogicalAND<T, BinaryOperation>::value>

Definition at line 105 of file known_identity.hpp.

◆ IsValidCoordType

template<typename T >
using sycl::_V1::detail::IsValidCoordType = typedef typename is_contained<T, type_list<cl_int, cl_float> >::type

Definition at line 30 of file image_accessor_util.hpp.

◆ IsValidDefaultOrder

template<memory_order Order>
using sycl::_V1::detail::IsValidDefaultOrder = typedef std::bool_constant<Order == memory_order::relaxed || Order == memory_order::acq_rel || Order == memory_order::seq_cst>

Definition at line 52 of file atomic_ref.hpp.

◆ IsZeroIdentityOp

template<typename T , class BinaryOperation >
using sycl::_V1::detail::IsZeroIdentityOp = typedef std::bool_constant< (is_geninteger<T>::value && (IsPlus<T, BinaryOperation>::value || IsBitOR<T, BinaryOperation>::value || IsBitXOR<T, BinaryOperation>::value)) || (is_genfloat<T>::value && IsPlus<T, BinaryOperation>::value)>

Definition at line 68 of file known_identity.hpp.

◆ iterator_category_t

template<typename T >
using sycl::_V1::detail::iterator_category_t = typedef typename std::iterator_traits<T>::iterator_category

Definition at line 24 of file stl_type_traits.hpp.

◆ iterator_pointer_t

template<typename T >
using sycl::_V1::detail::iterator_pointer_t = typedef typename std::iterator_traits<T>::pointer

Definition at line 30 of file stl_type_traits.hpp.

◆ iterator_to_const_type_t

template<typename T >
using sycl::_V1::detail::iterator_to_const_type_t = typedef std::is_const<typename std::remove_pointer<iterator_pointer_t<T> >::type>

Definition at line 33 of file stl_type_traits.hpp.

◆ iterator_value_type_t

template<typename T >
using sycl::_V1::detail::iterator_value_type_t = typedef typename std::iterator_traits<T>::value_type

Definition at line 27 of file stl_type_traits.hpp.

◆ KernelBundleImplPtr

Definition at line 136 of file kernel_bundle.hpp.

◆ KernelSetId

using sycl::_V1::detail::KernelSetId = typedef size_t

Definition at line 391 of file common.hpp.

◆ lambda_arg_type

template<typename F , typename SuggestedArgType >
using sycl::_V1::detail::lambda_arg_type = typedef decltype(argument_helper<F, SuggestedArgType>(0))

Definition at line 123 of file handler.hpp.

◆ LocalAccessorImplPtr

Definition at line 521 of file accessor.hpp.

◆ LockGuard

using sycl::_V1::detail::LockGuard = typedef std::lock_guard<SpinLock>

Definition at line 30 of file global_handler.cpp.

◆ make_floating_point_t

Definition at line 279 of file generic_type_traits.hpp.

◆ make_larger_t

template<typename T >
using sycl::_V1::detail::make_larger_t = typedef typename make_larger<T>::type

Definition at line 377 of file type_traits.hpp.

◆ make_signed_impl_t

template<typename T >
using sycl::_V1::detail::make_signed_impl_t = typedef typename make_signed_impl<T, T>::type

Definition at line 165 of file type_traits.hpp.

◆ make_signed_t

template<typename T >
using sycl::_V1::detail::make_signed_t = typedef typename make_signed<T>::type

Definition at line 193 of file type_traits.hpp.

◆ make_singed_integer_t

Definition at line 282 of file generic_type_traits.hpp.

◆ make_type_t

template<typename T , typename TL >
using sycl::_V1::detail::make_type_t = typedef typename make_type_impl<T, TL>::type

Definition at line 341 of file type_traits.hpp.

◆ make_unsigned_impl_t

template<typename T >
using sycl::_V1::detail::make_unsigned_impl_t = typedef typename make_unsigned_impl<T, T>::type

Definition at line 199 of file type_traits.hpp.

◆ make_unsigned_t

template<typename T >
using sycl::_V1::detail::make_unsigned_t = typedef typename make_unsigned<T>::type

Definition at line 227 of file type_traits.hpp.

◆ make_unsinged_integer_t

Definition at line 285 of file generic_type_traits.hpp.

◆ memory_order

typedef sycl::memory_order sycl::_V1::detail::memory_order

Definition at line 38 of file atomic.hpp.

◆ memory_scope

using sycl::_V1::detail::memory_scope = typedef sycl::memory_scope

Definition at line 30 of file atomic_ref.hpp.

◆ mptr_or_vec_elem_type_t

template<typename T >
using sycl::_V1::detail::mptr_or_vec_elem_type_t = typedef typename mptr_or_vec_elem_type<T>::type

Definition at line 422 of file generic_type_traits.hpp.

◆ nan_argument_base_t

template<typename T >
using sycl::_V1::detail::nan_argument_base_t = typedef typename nan_types<T, T>::arg_type

Definition at line 276 of file generic_type_traits.hpp.

◆ nan_return_t

template<typename T >
using sycl::_V1::detail::nan_return_t = typedef typename nan_types<T, T>::ret_type

Definition at line 273 of file generic_type_traits.hpp.

◆ native_op_list

template<typename T >
using sycl::_V1::detail::native_op_list = typedef type_list<sycl::plus<T>, sycl::bit_or<T>, sycl::bit_xor<T>, sycl::bit_and<T>, sycl::maximum<T>, sycl::minimum<T>, sycl::multiplies<T> >

Definition at line 93 of file group_algorithm.hpp.

◆ OSModuleHandle

using sycl::_V1::detail::OSModuleHandle = typedef intptr_t

Uniquely identifies an operating system module (executable or a dynamic library)

Definition at line 48 of file os_util.hpp.

◆ output_iterator_requirements

template<typename T >
using sycl::_V1::detail::output_iterator_requirements = typedef std::void_t<iterator_category_t<T>, decltype(*std::declval<T>() = std::declval<iterator_value_type_t<T> >())>

Definition at line 39 of file stl_type_traits.hpp.

◆ PlatformImplPtr

Definition at line 30 of file context_impl.hpp.

◆ ProgramImplPtr

using sycl::_V1::detail::ProgramImplPtr = typedef std::shared_ptr<program_impl>

Definition at line 31 of file kernel_impl.hpp.

◆ QueueImplPtr

Definition at line 32 of file event_impl.hpp.

◆ ReduTupleT

template<typename... Ts>
using sycl::_V1::detail::ReduTupleT = typedef sycl::detail::tuple<Ts...>

Definition at line 137 of file reduction.hpp.

◆ rel_sign_bit_test_arg_t

template<typename T >
using sycl::_V1::detail::rel_sign_bit_test_arg_t = typedef typename RelationalTestForSignBitType<T>::argument_type

Definition at line 674 of file generic_type_traits.hpp.

◆ rel_sign_bit_test_ret_t

template<typename T >
using sycl::_V1::detail::rel_sign_bit_test_ret_t = typedef typename RelationalTestForSignBitType<T>::return_type

Definition at line 670 of file generic_type_traits.hpp.

◆ rel_t

template<typename DataT >
using sycl::_V1::detail::rel_t = typedef typename std::conditional_t< sizeof(DataT) == sizeof(cl_char), cl_char, typename std::conditional_t< sizeof(DataT) == sizeof(cl_short), cl_short, typename std::conditional_t< sizeof(DataT) == sizeof(cl_int), cl_int, typename std::conditional_t<sizeof(DataT) == sizeof(cl_long), cl_long, bool> >> >

Definition at line 124 of file types.hpp.

◆ remove_pointer_t

template<typename T >
using sycl::_V1::detail::remove_pointer_t = typedef typename remove_pointer<T>::type

Definition at line 311 of file type_traits.hpp.

◆ Requirement

Definition at line 132 of file accessor_impl.hpp.

◆ select_apply_cl_scalar_t

template<typename T , typename T8 , typename T16 , typename T32 , typename T64 >
using sycl::_V1::detail::select_apply_cl_scalar_t = typedef std::conditional_t< sizeof(T) == 1, T8, std::conditional_t<sizeof(T) == 2, T16, std::conditional_t<sizeof(T) == 4, T32, T64> >>

Definition at line 427 of file generic_type_traits.hpp.

◆ select_apply_cl_t

template<typename T , typename T8 , typename T16 , typename T32 , typename T64 >
using sycl::_V1::detail::select_apply_cl_t = typedef std::conditional_t< sizeof(T) == 1, T8, std::conditional_t<sizeof(T) == 2, T16, std::conditional_t<sizeof(T) == 4, T32, T64> >>

Definition at line 2146 of file types.hpp.

◆ select_cl_scalar_float_t

template<typename T >
using sycl::_V1::detail::select_cl_scalar_float_t = typedef select_apply_cl_scalar_t<T, std::false_type, sycl::cl_half, sycl::cl_float, sycl::cl_double>

Definition at line 444 of file generic_type_traits.hpp.

◆ select_cl_scalar_integral_signed_t

template<typename T >
using sycl::_V1::detail::select_cl_scalar_integral_signed_t = typedef select_apply_cl_scalar_t<T, sycl::cl_char, sycl::cl_short, sycl::cl_int, sycl::cl_long>

Definition at line 434 of file generic_type_traits.hpp.

◆ select_cl_scalar_integral_t

template<typename T >
using sycl::_V1::detail::select_cl_scalar_integral_t = typedef std::conditional_t<std::is_signed<T>::value, select_cl_scalar_integral_signed_t<T>, select_cl_scalar_integral_unsigned_t<T> >

Definition at line 449 of file generic_type_traits.hpp.

◆ select_cl_scalar_integral_unsigned_t

template<typename T >
using sycl::_V1::detail::select_cl_scalar_integral_unsigned_t = typedef select_apply_cl_scalar_t<T, sycl::cl_uchar, sycl::cl_ushort, sycl::cl_uint, sycl::cl_ulong>

Definition at line 439 of file generic_type_traits.hpp.

◆ select_cl_scalar_t

template<typename T >
using sycl::_V1::detail::select_cl_scalar_t = typedef std::conditional_t< std::is_integral<T>::value, select_cl_scalar_integral_t<T>, std::conditional_t< std::is_floating_point<T>::value, select_cl_scalar_float_t<T>, std::conditional_t<std::is_same<T, half>::value, sycl::detail::half_impl::BIsRepresentationT, T> >>

Definition at line 457 of file generic_type_traits.hpp.

◆ SelectMatchingOpenCLType_t

template<typename T >
using sycl::_V1::detail::SelectMatchingOpenCLType_t = typedef typename select_cl_mptr_or_vector_or_scalar_or_ptr<T>::type

Definition at line 545 of file generic_type_traits.hpp.

◆ SerializedObj

using sycl::_V1::detail::SerializedObj = typedef std::vector<unsigned char>

Definition at line 68 of file util.hpp.

◆ SpecConstRegistryT

using sycl::_V1::detail::SpecConstRegistryT = typedef std::map<std::string, spec_constant_impl>

Definition at line 44 of file spec_constant_impl.hpp.

◆ StreamImplPtr

Definition at line 38 of file commands.hpp.

◆ sycl_memory_object_allocator

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

Definition at line 18 of file sycl_mem_obj_allocator.hpp.

◆ tail_t

template<typename T >
using sycl::_V1::detail::tail_t = typedef typename T::tail

Definition at line 20 of file type_list.hpp.

◆ tuple_element_t

template<std::size_t I, class T >
using sycl::_V1::detail::tuple_element_t = typedef typename tuple_element<I, T>::type

Definition at line 56 of file tuple.hpp.

◆ type_helper

template<typename T >
using sycl::_V1::detail::type_helper = typedef typename TypeHelper<T>::RetType

Definition at line 525 of file generic_type_traits.hpp.

◆ uuid_type

using sycl::_V1::detail::uuid_type = typedef std::array<unsigned char, 16>

Definition at line 82 of file type_traits.hpp.

◆ vector_element_impl_t

template<typename T >
using sycl::_V1::detail::vector_element_impl_t = typedef typename vector_element_impl<T>::type

Definition at line 113 of file type_traits.hpp.

◆ vector_element_t

template<class T >
using sycl::_V1::detail::vector_element_t = typedef typename vector_element<T>::type

Definition at line 124 of file type_traits.hpp.

Enumeration Type Documentation

◆ backend_errc

enum sycl::_V1::detail::backend_errc : unsigned int
strong

Definition at line 52 of file backend.hpp.

◆ BlockingT

Enumerator
NON_BLOCKING 
BLOCKING 

Definition at line 47 of file commands.hpp.

◆ BuildState

Enumerator
BS_InProgress 
BS_Done 
BS_Failed 

Definition at line 49 of file program_manager.cpp.

◆ ConfigID

Enumerator
START 
END 

Definition at line 51 of file config.hpp.

◆ CUDAContextT

enum sycl::_V1::detail::CUDAContextT : char
strong

Possible CUDA context types supported by PI CUDA backend TODO: Implement this as a property once there is an extension document.

Enumerator
primary 
custom 

Definition at line 47 of file queue_impl.hpp.

◆ DataLessPropKind

Enumerator
BufferUseHostPtr 
ImageUseHostPtr 
QueueEnableProfiling 
InOrder 
NoInit 
BufferUsePinnedHostMemory 
UsePrimaryContext 
InitializeToIdentity 
UseDefaultStream 
DiscardEvents 
DeviceReadOnly 
FusionPromotePrivate 
FusionPromoteLocal 
FusionNoBarrier 
FusionEnable 
FusionForce 
QueuePriorityNormal 
QueuePriorityLow 
QueuePriorityHigh 
LastKnownDataLessPropKind 
DataLessPropKindSize 

Definition at line 26 of file property_helper.hpp.

◆ DeviceLibExt

enum sycl::_V1::detail::DeviceLibExt : std::uint32_t
strong
Enumerator
cl_intel_devicelib_assert 
cl_intel_devicelib_math 
cl_intel_devicelib_math_fp64 
cl_intel_devicelib_complex 
cl_intel_devicelib_complex_fp64 
cl_intel_devicelib_cstring 
cl_intel_devicelib_imf 
cl_intel_devicelib_imf_fp64 
cl_intel_devicelib_imf_bf16 
cl_intel_devicelib_bfloat16 

Definition at line 60 of file program_manager.hpp.

◆ HandlerSubmissionState

enum sycl::_V1::detail::HandlerSubmissionState : std::uint8_t
strong
Enumerator
NO_STATE 
EXPLICIT_KERNEL_BUNDLE_STATE 
SPEC_CONST_SET_STATE 

Definition at line 19 of file handler_impl.hpp.

◆ kernel_param_kind_t

Enumerator
kind_accessor 
kind_std_layout 
kind_sampler 
kind_pointer 
kind_specialization_constants_buffer 
kind_stream 
kind_invalid 

Definition at line 37 of file kernel_desc.hpp.

◆ PiApiKind

Enumerator
_PI_API 

Definition at line 42 of file pi.hpp.

◆ program_state

Enumerator
none 
compiled 
linked 

Definition at line 36 of file program_impl.hpp.

◆ PropWithDataKind

Enumerator
BufferUseMutex 
BufferContextBound 
ImageUseMutex 
ImageContextBound 
BufferMemChannel 
AccPropBufferLocation 
PropWithDataKindSize 

Definition at line 53 of file property_helper.hpp.

◆ QueueOrder

Enumerator
Ordered 
OOO 

Definition at line 52 of file queue_impl.hpp.

Function Documentation

◆ __attribute__()

sycl::_V1::detail::__attribute__ ( (destructor(110))  )

Definition at line 193 of file global_handler.cpp.

References shutdown().

◆ __SYCL2020_DEPRECATED() [1/2]

template<typename T >
struct sycl::_V1::detail::__SYCL2020_DEPRECATED ( "This type isn't device copyable in SYCL 2020"  )

◆ __SYCL2020_DEPRECATED() [2/2]

template<>
class sycl::_V1::detail::__SYCL2020_DEPRECATED ( "Use SYCLConfig<ONEAPI_DEVICE_SELECTOR> instead )

Definition at line 240 of file config.hpp.

◆ accessModeToString()

◆ addHostAccessorAndWait()

void sycl::_V1::detail::addHostAccessorAndWait ( AccessorImplHost Req)

Definition at line 36 of file accessor_impl.cpp.

◆ adjustNDRangePerKernel()

◆ affinityDomainToString()

std::string sycl::_V1::detail::affinityDomainToString ( info::partition_affinity_domain  AffinityDomain)
inline

◆ allowable_aot_mode()

template<ext::intel::experimental::architecture... Archs>
constexpr static bool sycl::_V1::detail::allowable_aot_mode ( )
staticconstexpr

Definition at line 219 of file device_architecture.hpp.

References is_allowable_aot_mode.

◆ amendDeviceAndSubDevices()

static std::vector<device> sycl::_V1::detail::amendDeviceAndSubDevices ( backend  PlatformBackend,
std::vector< device > &  DeviceList,
ods_target_list OdsTargetList,
const std::vector< int > &  original_indices,
PlatformImplPtr  PlatformImpl 
)
static

◆ append()

unsigned sycl::_V1::detail::append ( char *  Dst,
const char *  Src 
)
inline

◆ appendCompileOptionsFromImage()

static void sycl::_V1::detail::appendCompileOptionsFromImage ( std::string &  CompileOpts,
const RTDeviceBinaryImage Img 
)
static

◆ appendLinkOptionsFromImage()

static void sycl::_V1::detail::appendLinkOptionsFromImage ( std::string &  LinkOpts,
const RTDeviceBinaryImage Img 
)
static

◆ applyAllowList()

◆ applyCompileOptionsFromEnvironment()

static void sycl::_V1::detail::applyCompileOptionsFromEnvironment ( std::string &  CompileOpts)
static

◆ applyFuncOnFilteredArgs()

static void sycl::_V1::detail::applyFuncOnFilteredArgs ( const ProgramManager::KernelArgMask EliminatedArgMask,
std::vector< ArgDesc > &  Args,
std::function< void(detail::ArgDesc &Arg, int NextTrueIndex)>  Func 
)
static

◆ applyLinkOptionsFromEnvironment()

static void sycl::_V1::detail::applyLinkOptionsFromEnvironment ( std::string &  LinkOpts)
static

◆&n