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

Namespaces

 acc_properties
 
 device_global_map
 
 enqueue_kernel_launch
 
 gtl
 
 gvl
 
 half_impl
 
 host_half_impl
 
 host_pipe_map
 
 kernel_get_group_info
 
 pi
 
 reduction
 
 spirv
 
 sub_group
 
 usm
 

Classes

class  __image_array_slice__
 
class  __pf_kernel_wrapper
 
class  accessor_common
 
class  accessor_iterator
 
class  AccessorBaseHost
 
class  AccessorImplDevice
 
class  AccessorImplHost
 
struct  AccHostDataT
 
class  aligned_allocator
 
class  AllocaCommand
 The alloca command enqueues allocation of instance of memory object on Host or underlying framework. More...
 
class  AllocaCommandBase
 Base class for memory allocation commands. More...
 
class  AllocaSubBufCommand
 The AllocaSubBuf command enqueues creation of sub-buffer of memory object. 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...
 
class  ArgDesc
 
class  array
 
struct  array_fill_helper
 
struct  array_fill_helper< Kind, Idx, T >
 
struct  array_fill_helper< Kind, Idx, T, Args... >
 
struct  ArrayCreator
 
struct  ArrayCreator< DataT, FlattenF >
 
struct  ArrayCreator< DataT, FlattenF, ArgT, ArgTN... >
 
struct  AssertHappened
 
struct  Assigner
 
struct  Assigner< 0 >
 
class  atomic_ref_base
 
class  atomic_ref_impl
 
class  atomic_ref_impl< T *, IsAspectAtomic64AttrUsed, DefaultOrder, DefaultScope, AddressSpace >
 
class  atomic_ref_impl< T, IsAspectAtomic64AttrUsed, DefaultOrder, DefaultScope, AddressSpace, typename std::enable_if_t< std::is_floating_point_v< T > > >
 
class  atomic_ref_impl< T, IsAspectAtomic64AttrUsed, DefaultOrder, DefaultScope, AddressSpace, typename std::enable_if_t< std::is_integral_v< T > > >
 
class  atomic_ref_impl< T, true, DefaultOrder, DefaultScope, AddressSpace, typename std::enable_if_t< std::is_floating_point_v< T > > >
 
class  atomic_ref_impl< T, true, DefaultOrder, DefaultScope, AddressSpace, typename std::enable_if_t< std::is_integral_v< T > > >
 
class  auto_name
 This class is the default KernelName template parameter type for kernel invocation APIs such as single_task. More...
 
struct  BackendInput
 
struct  BackendInput< backend::ext_oneapi_cuda, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendInput< backend::ext_oneapi_cuda, context >
 
struct  BackendInput< backend::ext_oneapi_cuda, device >
 
struct  BackendInput< backend::ext_oneapi_cuda, event >
 
struct  BackendInput< backend::ext_oneapi_cuda, platform >
 
struct  BackendInput< backend::ext_oneapi_cuda, queue >
 
struct  BackendInput< backend::ext_oneapi_hip, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendInput< backend::ext_oneapi_hip, context >
 
struct  BackendInput< backend::ext_oneapi_hip, device >
 
struct  BackendInput< backend::ext_oneapi_hip, event >
 
struct  BackendInput< backend::ext_oneapi_hip, queue >
 
struct  BackendInput< backend::ext_oneapi_level_zero, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendInput< backend::ext_oneapi_level_zero, context >
 
struct  BackendInput< backend::ext_oneapi_level_zero, device >
 
struct  BackendInput< backend::ext_oneapi_level_zero, event >
 
struct  BackendInput< backend::ext_oneapi_level_zero, image< Dimensions, AllocatorT > >
 
struct  BackendInput< backend::ext_oneapi_level_zero, kernel >
 
struct  BackendInput< backend::ext_oneapi_level_zero, kernel_bundle< State > >
 
struct  BackendInput< backend::ext_oneapi_level_zero, platform >
 
struct  BackendInput< backend::ext_oneapi_level_zero, queue >
 
struct  BackendInput< backend::opencl, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendInput< backend::opencl, context >
 
struct  BackendInput< backend::opencl, device >
 
struct  BackendInput< backend::opencl, event >
 
struct  BackendInput< backend::opencl, kernel >
 
struct  BackendInput< backend::opencl, kernel_bundle< State > >
 
struct  BackendInput< backend::opencl, platform >
 
struct  BackendInput< backend::opencl, queue >
 
struct  BackendReturn
 
struct  BackendReturn< backend::ext_oneapi_cuda, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_cuda, context >
 
struct  BackendReturn< backend::ext_oneapi_cuda, device >
 
struct  BackendReturn< backend::ext_oneapi_cuda, event >
 
struct  BackendReturn< backend::ext_oneapi_cuda, platform >
 
struct  BackendReturn< backend::ext_oneapi_cuda, queue >
 
struct  BackendReturn< backend::ext_oneapi_hip, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_hip, context >
 
struct  BackendReturn< backend::ext_oneapi_hip, device >
 
struct  BackendReturn< backend::ext_oneapi_hip, event >
 
struct  BackendReturn< backend::ext_oneapi_hip, queue >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, context >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, device >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, event >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, image< Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, kernel >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, kernel_bundle< State > >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, platform >
 
struct  BackendReturn< backend::ext_oneapi_level_zero, queue >
 
struct  BackendReturn< backend::opencl, buffer< DataT, Dimensions, AllocatorT > >
 
struct  BackendReturn< backend::opencl, context >
 
struct  BackendReturn< backend::opencl, device >
 
struct  BackendReturn< backend::opencl, event >
 
struct  BackendReturn< backend::opencl, kernel >
 
struct  BackendReturn< backend::opencl, kernel_bundle< State > >
 
struct  BackendReturn< backend::opencl, platform >
 
struct  BackendReturn< backend::opencl, queue >
 
struct  bit_equal
 
struct  bit_equal< double >
 
struct  bit_equal< float >
 
struct  bit_equal< T, typename std::enable_if_t< std::is_integral_v< T > > >
 
struct  Boolean
 
struct  Boolean< 1 >
 
class  buffer_impl
 
class  buffer_plain
 
struct  BufferInterop
 
struct  BufferInterop< backend::opencl, DataT, Dimensions, AllocatorT >
 
class  Builder
 
class  ByteArray
 
class  CG
 Base class for all types of command groups. More...
 
class  CGAdviseUSM
 "Advise USM" command group class. More...
 
class  CGBarrier
 
class  CGCopy
 "Copy memory" command group class. More...
 
class  CGCopy2DUSM
 "Copy 2D USM" command group class. More...
 
class  CGCopyFromDeviceGlobal
 "Copy to device_global" command group class. More...
 
class  CGCopyImage
 "Copy Image" command group class. More...
 
class  CGCopyToDeviceGlobal
 "Copy to device_global" command group class. More...
 
class  CGCopyUSM
 "Copy USM" command group class. More...
 
class  CGExecCommandBuffer
 "Execute command-buffer" command group class. More...
 
class  CGExecKernel
 "Execute kernel" command group class. More...
 
class  CGFill
 "Fill memory" command group class. More...
 
class  CGFill2DUSM
 "Fill 2D USM" command group class. More...
 
class  CGFillUSM
 "Fill USM" command group class. More...
 
class  CGHostTask
 
class  CGMemset2DUSM
 "Memset 2D USM" command group class. More...
 
class  CGPrefetchUSM
 "Prefetch USM" command group class. More...
 
class  CGReadWriteHostPipe
 "ReadWriteHostPipe" command group class. More...
 
class  CGSemaphoreSignal
 "Semaphore Signal" command group class. More...
 
class  CGSemaphoreWait
 "Semaphore Wait" command group class. More...
 
class  CGUpdateHost
 "Update host" command group class. More...
 
struct  change_base_type
 
struct  change_base_type< vec< T, N >, B >
 
struct  change_elements
 
struct  change_elements< NewElemT, marray< T, N > >
 
struct  change_elements< NewElemT, SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  change_elements< NewElemT, vec< T, N > >
 
struct  check_fn_signature
 
struct  check_fn_signature< F, RetT(Args...)>
 
struct  check_fp_support
 
struct  check_fp_support< info::device::double_fp_config >
 
struct  check_fp_support< info::device::half_fp_config >
 
class  CircularBuffer
 
struct  CmpCStr
 
struct  code_location
 
class  combiner
 Use CRTP to avoid redefining shorthand operators in terms of combine. More...
 
class  Command
 The Command class represents some action that needs to be performed on one or more memory objects. More...
 
struct  conditional
 
struct  conditional< false, TrueT, FalseT >
 
class  context_impl
 
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 > >
 
struct  copy_cv_qualifiers
 
struct  copy_cv_qualifiers_impl
 
struct  copy_cv_qualifiers_impl< const T, R >
 
struct  copy_cv_qualifiers_impl< const volatile T, R >
 
struct  copy_cv_qualifiers_impl< volatile T, R >
 
struct  data_dim_t
 
struct  data_dim_t< accessor< T, AccessorDims, Mode, access::target::device, IsPH, PropList > >
 
class  DataLessProperty
 
class  DataLessPropertyBase
 
struct  DecoratedType
 
struct  DecoratedType< ElementType, access::address_space::constant_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::generic_space >
 
struct  DecoratedType< ElementType, access::address_space::global_space >
 
struct  DecoratedType< ElementType, access::address_space::local_space >
 
struct  DecoratedType< ElementType, access::address_space::private_space >
 
struct  DefaultContextReleaseHandler
 
struct  DepDesc
 Dependency between two commands. More...
 
struct  device_filter
 
class  device_filter_list
 
class  device_image_impl
 
class  device_image_plain
 
class  device_impl
 
class  DeviceBinariesCollection
 Representation of pi_device_binaries_struct for creation of JIT device binaries at runtime. More...
 
class  DeviceBinaryContainer
 Representation of pi_device_binary_struct for creation of JIT device binaries at runtime. More...
 
class  DeviceBinaryProperty
 
struct  DeviceGlobalMapEntry
 
struct  DeviceGlobalUSMMem
 
class  DispatchHostTask
 
class  DynRTDeviceBinaryImage
 
class  EmptyCommand
 The empty command does nothing during enqueue. More...
 
struct  EmptyReductionPredicate
 
struct  EnqueueResultT
 Result of command enqueueing. More...
 
struct  EqualByNameComp
 
struct  EqualTo
 
class  event_impl
 
class  ExecCGCommand
 The exec CG command enqueues execution of kernel or explicit memory operation. More...
 
struct  FilterElement
 
struct  find_type
 
struct  find_type< empty_type_list, Comp, T >
 
struct  function_traits
 
struct  function_traits< Ret(Args...)>
 
class  fusion_wrapper_impl
 
struct  get
 
struct  get< 0 >
 
struct  get_device_info_impl
 
struct  get_device_info_impl< bool, ext::codeplay::experimental::info::device::supports_fusion >
 
struct  get_device_info_impl< bool, info::device::ext_oneapi_bfloat16_math_functions >
 
struct  get_device_info_impl< bool, info::device::image_support >
 
struct  get_device_info_impl< bool, info::device::kernel_kernel_pipe_support >
 
struct  get_device_info_impl< bool, info::device::queue_profiling >
 
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_restricted_shared_allocations >
 
struct  get_device_info_impl< bool, info::device::usm_shared_allocations >
 
struct  get_device_info_impl< bool, info::device::usm_system_allocations >
 
struct  get_device_info_impl< device, info::device::parent_device >
 
struct  get_device_info_impl< ext::oneapi::experimental::architecture, ext::oneapi::experimental::info::device::architecture >
 
struct  get_device_info_impl< ext::oneapi::experimental::graph_support_level, ext::oneapi::experimental::info::device::graph_support >
 
struct  get_device_info_impl< id< 1 >, ext::oneapi::experimental::info::device::max_work_groups< 1 > >
 
struct  get_device_info_impl< id< 1 >, info::device::ext_oneapi_max_work_groups_1d >
 
struct  get_device_info_impl< id< 2 >, ext::oneapi::experimental::info::device::max_work_groups< 2 > >
 
struct  get_device_info_impl< id< 2 >, info::device::ext_oneapi_max_work_groups_2d >
 
struct  get_device_info_impl< id< 3 >, ext::oneapi::experimental::info::device::max_work_groups< 3 > >
 
struct  get_device_info_impl< id< 3 >, info::device::ext_oneapi_max_work_groups_3d >
 
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< platform, Param >
 
struct  get_device_info_impl< range< Dimensions >, info::device::max_work_item_sizes< Dimensions > >
 
struct  get_device_info_impl< ReturnT, info::device::parent_device >
 
struct  get_device_info_impl< size_t, ext::oneapi::experimental::info::device::max_global_work_groups >
 
struct  get_device_info_impl< size_t, info::device::ext_oneapi_max_global_work_groups >
 
struct  get_device_info_impl< std::string, info::device::version >
 
struct  get_device_info_impl< std::string, Param >
 
struct  get_device_info_impl< std::vector< ext::oneapi::experimental::matrix::combination >, ext::oneapi::experimental::info::device::matrix_combinations >
 
struct  get_device_info_impl< std::vector< info::execution_capability >, info::device::execution_capabilities >
 
struct  get_device_info_impl< std::vector< info::fp_config >, info::device::single_fp_config >
 
struct  get_device_info_impl< std::vector< info::fp_config >, Param >
 
struct  get_device_info_impl< std::vector< info::partition_affinity_domain >, info::device::partition_affinity_domains >
 
struct  get_device_info_impl< std::vector< info::partition_property >, info::device::partition_properties >
 
struct  get_device_info_impl< std::vector< kernel_id >, info::device::built_in_kernel_ids >
 
struct  get_device_info_impl< std::vector< memory_order >, info::device::atomic_fence_order_capabilities >
 
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_fence_scope_capabilities >
 
struct  get_device_info_impl< std::vector< memory_scope >, info::device::atomic_memory_scope_capabilities >
 
struct  get_device_info_impl< std::vector< size_t >, info::device::sub_group_sizes >
 
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< uint32_t, ext::codeplay::experimental::info::device::max_registers_per_work_group >
 
struct  get_elem_type
 
struct  get_elem_type< marray< T, N > >
 
struct  get_elem_type< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  get_elem_type< vec< T, N > >
 
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...
 
struct  get_kernel_wrapper_name_t
 
struct  get_multi_ptr_decoration
 
struct  get_multi_ptr_decoration< multi_ptr< ElementType, Space, DecorateAddress > >
 
struct  get_red_t
 
struct  get_red_t< buffer< T, Dims, AllocatorT > >
 
struct  get_red_t< T * >
 
struct  get_scalar_binary_op
 
struct  get_scalar_binary_op< F< sycl::vec< T, n > > >
 
struct  get_scalar_binary_op< F< void > >
 
struct  get_signed_int_by_size
 
struct  get_unsigned_int_by_size
 
struct  get_vec_size
 
struct  get_vec_size< sycl::vec< T, N > >
 
struct  GetMArrayArgsSize
 
struct  GetMArrayArgsSize< marray< T, N >, Ts... >
 
struct  GetMArrayArgsSize< T, Ts... >
 
struct  GetMArrayArgsSize<>
 
struct  GetMergedKernelProperties
 
struct  GetMergedKernelProperties< KernelType, PropertiesT, std::enable_if_t< ext::oneapi::experimental::detail::HasKernelPropertiesGetMethod< KernelType >::value > >
 
class  GetOp
 
class  GetScalarOp
 
struct  GetSpirvMemoryScope
 
struct  GetSpirvMemoryScope< access::address_space::ext_intel_global_device_space >
 
struct  GetSpirvMemoryScope< access::address_space::global_space >
 
struct  GetSpirvMemoryScope< access::address_space::local_space >
 
class  GlobalHandler
 Wrapper class for global data structures with non-trivial destructors. More...
 
struct  GreaterEqualTo
 
struct  GreaterThan
 
class  handler_impl
 
struct  has_known_identity_impl
 
struct  has_writeable_addr_space
 
struct  has_writeable_addr_space< multi_ptr< ElementType, Space, DecorateAddress > >
 
struct  HashCStr
 
class  HostKernel
 
class  HostKernelBase
 
struct  HostPipeMapEntry
 
class  HostProfilingInfo
 Profiling info for the host execution. More...
 
class  HostTask
 
class  if_architecture_helper
 
class  image_accessor
 
class  image_common
 
class  image_impl
 
class  image_plain
 
struct  InitializedVal
 
struct  InitializedVal< 1, T >
 
struct  InitializedVal< 2, T >
 
struct  InitializedVal< 3, T >
 
struct  InlineVariableHelper
 
struct  interop
 
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, platform >
 
struct  interop< 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_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, kernel >
 
struct  interop< backend::ext_oneapi_level_zero, platform >
 
struct  interop< backend::ext_oneapi_level_zero, queue >
 
struct  interop< backend::opencl, context >
 
struct  interop< backend::opencl, device >
 
struct  interop< backend::opencl, event >
 
struct  interop< backend::opencl, platform >
 
struct  interop< backend::opencl, queue >
 
struct  InteropFeatureSupportMap
 
struct  InteropFeatureSupportMap< backend::ext_oneapi_cuda >
 
struct  InteropFeatureSupportMap< backend::ext_oneapi_hip >
 
struct  InteropFeatureSupportMap< backend::ext_oneapi_level_zero >
 
struct  InteropFeatureSupportMap< backend::opencl >
 
struct  is_address_space_compliant
 
struct  is_address_space_compliant_impl
 
struct  is_address_space_compliant_impl< multi_ptr< T, Space, DecorateAddress >, SpaceList >
 
struct  is_address_space_compliant_impl< T *, SpaceList >
 
struct  is_arithmetic
 
struct  is_bool
 
struct  is_complex
 
struct  is_contained
 
struct  is_contained< T, empty_type_list >
 
struct  is_contained_value
 
struct  is_contained_value< T, Value, value_list< T > >
 
struct  is_context_info_desc
 
struct  is_device_info_desc
 
struct  is_empty_type_list
 
struct  is_event_info_desc
 
struct  is_event_profiling_info_desc
 
struct  is_fixed_size_group
 
struct  is_fixed_size_group< ext::oneapi::experimental::fixed_size_group< PartitionSize, ParentGroup > >
 
struct  is_floating_point
 
struct  is_floating_point_impl
 
struct  is_floating_point_impl< half >
 
struct  is_generic_group
 
struct  is_group
 
struct  is_group< group< Dimensions > >
 
struct  is_integral
 
struct  is_kernel_device_specific_info_desc
 
struct  is_kernel_info_desc
 
struct  is_legacy_multi_ptr
 
struct  is_legacy_multi_ptr< multi_ptr< ElementType, Space, access::decorated::legacy > >
 
struct  is_marray
 
struct  is_marray< sycl::marray< T, N > >
 
struct  is_max_or_min
 
struct  is_max_or_min< sycl::maximum< T > >
 
struct  is_max_or_min< sycl::minimum< T > >
 
struct  is_multi_ptr
 
struct  is_multi_ptr< multi_ptr< ElementType, Space, IsDecorated > >
 
struct  is_native_op
 
struct  is_non_legacy_multi_ptr
 
struct  is_non_legacy_multi_ptr< multi_ptr< ElementType, Space, access::decorated::no > >
 
struct  is_non_legacy_multi_ptr< multi_ptr< ElementType, Space, access::decorated::yes > >
 
struct  is_output_iterator
 
struct  is_output_iterator< T, output_iterator_requirements< T > >
 
struct  is_platform_info_desc
 
struct  is_pointer
 
struct  is_pointer_impl
 
struct  is_pointer_impl< multi_ptr< T, Space, DecorateAddress > >
 
struct  is_pointer_impl< T * >
 
struct  is_queue_info_desc
 
struct  is_same_op
 
struct  is_same_op< T1, T2, std::enable_if_t< is_vec_or_swizzle_v< T1 > &&is_vec_or_swizzle_v< T2 > > >
 
class  is_same_vector_size
 
class  is_same_vector_size_impl
 
class  is_same_vector_size_impl< FirstSize >
 
class  is_same_vector_size_impl< FirstSize, T, Args... >
 
struct  is_scalar_arithmetic
 
struct  is_scalar_bool
 
struct  is_sub_group
 
struct  is_sub_group< ext::oneapi::sub_group >
 
struct  is_sub_group< sycl::sub_group >
 
struct  is_swizzle
 
struct  is_swizzle< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  is_type_size_double_of
 
struct  is_type_size_equal
 
struct  is_valid_elem_type
 
struct  is_valid_elem_type< marray< T, N >, Ts... >
 
struct  is_valid_elem_type< multi_ptr< ElementType, Space, DecorateAddress >, Ts... >
 
struct  is_valid_elem_type< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... >, Ts... >
 
struct  is_valid_elem_type< vec< T, N >, Ts... >
 
struct  is_valid_size
 
struct  is_vec
 
struct  is_vec< sycl::vec< T, N > >
 
struct  is_vector_arithmetic
 
struct  is_vector_arithmetic_or_complex
 
struct  is_vector_bool
 
struct  IsAOTForArchitectureClass
 
struct  IsArrayReduction
 
struct  IsCompileTimePropertyInstance
 
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<> >
 
struct  isComplex
 
struct  IsCxPropertyList
 
struct  IsCxPropertyList< ext::oneapi::accessor_property_list< Props... > >
 
struct  IsCxPropertyList< ext::oneapi::accessor_property_list<> >
 
struct  IsDeprecatedDeviceCopyable
 
struct  IsNonUsmReductionPredicate
 
struct  IsReduction
 Predicate returning true if a type is a reduction. More...
 
struct  IsScalarReduction
 
struct  IsSubGroupInfo
 
struct  IsSubGroupInfo< info::kernel_device_specific::compile_num_sub_groups >
 
struct  IsSubGroupInfo< info::kernel_device_specific::compile_sub_group_size >
 
struct  IsSubGroupInfo< info::kernel_device_specific::max_num_sub_groups >
 
struct  IsSubGroupInfo< info::kernel_device_specific::max_sub_group_size >
 
struct  IsSwizzleOp
 
struct  IsSwizzleOp< sycl::detail::SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  IsValidAtomicAddressSpace
 
struct  IsValidAtomicRefAddressSpace
 
struct  IsValidAtomicRefType
 
struct  IsValidAtomicType
 
struct  IsValidCoordDataT
 
struct  IsValidCoordDataT< 1, T >
 
struct  IsValidCoordDataT< 2, T >
 
struct  IsValidCoordDataT< 3, T >
 
struct  IsValidSampledCoord2020DataT
 
struct  IsValidSampledCoord2020DataT< 1, T >
 
struct  IsValidSampledCoord2020DataT< 2, T >
 
struct  IsValidSampledCoord2020DataT< 3, T >
 
struct  IsValidUnsampledCoord2020DataT
 
struct  IsValidUnsampledCoord2020DataT< 1, T >
 
struct  IsValidUnsampledCoord2020DataT< 2, T >
 
struct  IsValidUnsampledCoord2020DataT< 3, T >
 
struct  ItemBase
 
struct  ItemBase< Dims, false >
 
struct  ItemBase< Dims, true >
 
class  jit_compiler
 
class  kernel_bundle_impl
 
class  kernel_bundle_plain
 
class  kernel_id_impl
 
class  kernel_impl
 
struct  kernel_param_desc_t
 
class  KernelFusionCommand
 The KernelFusionCommand is placed in the execution graph together with the individual kernels of the fusion list to control kernel fusion. More...
 
struct  KernelInfo
 
struct  KernelLambdaHasKernelHandlerArgT
 
struct  KernelMultipleWGTag
 
struct  KernelOneWGTag
 
class  KernelProgramCache
 
struct  known_identity_impl
 
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< IsMaximumIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns minimal possible value as identity for MAX 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< IsOneIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns one as identify for MULTIPLY operations. More...
 
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< IsTrueIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns true as identity for LOGICAL AND operations. More...
 
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, half, std::enable_if_t< IsOneIdentityOp< half, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, half, std::enable_if_t< IsZeroIdentityOp< half, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, marray< std::byte, NumElements >, std::enable_if_t< IsFalseIdentityOp< marray< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, marray< std::byte, NumElements >, std::enable_if_t< IsMaximumIdentityOp< marray< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, marray< std::byte, NumElements >, std::enable_if_t< IsMinimumIdentityOp< marray< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, marray< std::byte, NumElements >, std::enable_if_t< IsOneIdentityOp< marray< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, marray< std::byte, NumElements >, std::enable_if_t< IsOnesIdentityOp< marray< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, marray< std::byte, NumElements >, std::enable_if_t< IsTrueIdentityOp< marray< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, marray< std::byte, NumElements >, std::enable_if_t< IsZeroIdentityOp< marray< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< std::byte, NumElements >, std::enable_if_t< IsFalseIdentityOp< vec< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< std::byte, NumElements >, std::enable_if_t< IsMaximumIdentityOp< vec< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< std::byte, NumElements >, std::enable_if_t< IsMinimumIdentityOp< vec< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< std::byte, NumElements >, std::enable_if_t< IsOneIdentityOp< vec< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< std::byte, NumElements >, std::enable_if_t< IsOnesIdentityOp< vec< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< std::byte, NumElements >, std::enable_if_t< IsTrueIdentityOp< vec< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< std::byte, NumElements >, std::enable_if_t< IsZeroIdentityOp< vec< std::byte, NumElements >, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, vec< sycl::half, NumElements >, std::enable_if_t< IsZeroIdentityOp< vec< sycl::half, NumElements >, BinaryOperation >::value > >
 
class  LeavesCollection
 A wrapper for CircularBuffer class along with collection for host accessor's EmptyCommands. More...
 
struct  LegacyPointerTypes
 
struct  LegacyPointerTypes< ElementType, access::address_space::constant_space >
 
struct  LegacyReferenceTypes
 
struct  LegacyReferenceTypes< ElementType, access::address_space::constant_space >
 
struct  LessByHash
 
struct  LessByNameComp
 
struct  LessEqualTo
 
struct  LessThan
 
class  LocalAccessorBaseDevice
 
class  LocalAccessorBaseHost
 
class  LocalAccessorImplHost
 
class  LockCacheItem
 
class  Locked
 Represents a reference to value with appropriate lock acquired. More...
 
struct  LogicalAnd
 
struct  LogicalOr
 
struct  LShift
 
struct  make_larger
 
struct  make_larger_impl
 
struct  make_larger_impl< marray< T, N >, marray< T, N > >
 
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_signed
 
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_type_impl
 
struct  make_type_impl< vec< T, N >, TL >
 
struct  make_unsigned
 
struct  make_unsigned< marray< T, N > >
 
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 > >
 
class  MapMemObject
 The map command enqueues mapping of device memory onto host 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...
 
struct  MemObjRecord
 Memory Object Record. More...
 
struct  memory_order_traits
 
struct  memory_order_traits< memory_order::acq_rel >
 
struct  memory_order_traits< memory_order::relaxed >
 
struct  memory_order_traits< memory_order::seq_cst >
 
class  MemoryManager
 
struct  mptr_or_vec_elem_type
 
struct  mptr_or_vec_elem_type< const multi_ptr< ElementType, Space, IsDecorated > >
 
struct  mptr_or_vec_elem_type< multi_ptr< ElementType, Space, IsDecorated >, std::enable_if_t< IsDecorated==access::decorated::no||IsDecorated==access::decorated::yes > >
 
struct  nan_return_unswizzled
 
struct  nan_return_unswizzled< marray< T, N > >
 
struct  nan_return_unswizzled< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  nan_types
 
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  nan_types< T, std::enable_if_t< is_contained< T, gtl::unsigned_short_list >::value, T > >
 
struct  NativeCPUArgDesc
 
struct  NDLoop
 Generates an NDims-dimensional perfect loop nest. More...
 
struct  NDLoopIterateImpl
 Helper class for the NDLoop. More...
 
struct  NDLoopIterateImpl< NDims, 0, LoopBoundTy, FuncTy, LoopIndexTy >
 
struct  NDRangeReduction
 
struct  NDRangeReduction< reduction::strategy::auto_select >
 
struct  NDRangeReduction< reduction::strategy::basic >
 
struct  NDRangeReduction< reduction::strategy::group_reduce_and_atomic_cross_wg >
 
struct  NDRangeReduction< reduction::strategy::group_reduce_and_last_wg_detection >
 
struct  NDRangeReduction< reduction::strategy::group_reduce_and_multiple_kernels >
 
struct  NDRangeReduction< reduction::strategy::local_atomic_and_atomic_cross_wg >
 
struct  NDRangeReduction< reduction::strategy::local_mem_tree_and_atomic_cross_wg >
 
struct  NDRangeReduction< reduction::strategy::multi >
 
struct  NDRangeReduction< reduction::strategy::range_basic >
 
class  NDRDescT
 
struct  NegateDecorated
 
struct  NegateDecorated< access::decorated::no >
 
struct  NegateDecorated< access::decorated::yes >
 
struct  NotEqualTo
 
struct  num_elements
 
struct  num_elements< marray< T, N > >
 
struct  num_elements< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  num_elements< vec< T, N > >
 
class  ObjectUsageCounter
 
struct  ods_target
 
class  ods_target_list
 
class  OffloadEntryContainer
 Representation of _pi_offload_entry for creation of JIT device binaries at runtime. More...
 
class  OSUtil
 Groups the OS-dependent services. More...
 
struct  OwnedPiEvent
 
class  OwnerLessBase
 
class  PersistentDeviceCodeCache
 
struct  PiApiArgTuple
 
struct  PiInfoCode
 
class  platform_impl
 
struct  PlatformUtil
 
class  plugin
 The plugin class provides a unified interface to the underlying low-level runtimes for the device-agnostic SYCL runtime. More...
 
struct  PointerConverter
 
struct  PointerConverter< multi_ptr< ElementType, Space, DecorateAddress > >
 
class  program_impl
 
class  ProgramManager
 
class  PropertyContainer
 Representation of _pi_device_binary_property_struct for creation of JIT device binaries at runtime. More...
 
class  PropertyListBase
 
class  PropertySetContainer
 Representation of _pi_device_binary_property_set_struct for creation of JIT device binaries at runtime. More...
 
class  PropertyWithData
 
class  PropertyWithDataBase
 
class  queue_impl
 
class  reducer_common
 
class  ReducerAccess
 Helper class for accessing internal reducer member functions. More...
 
class  ReducerElement
 
struct  ReducerToken
 
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, IdentityContainerT, View, Subst > >
 
class  reduction_impl
 This class encapsulates the reduction variable/accessor, the reduction operator and an optional operator identity. More...
 
class  reduction_impl_algo
 
class  reduction_impl_base
 Base non-template class which is a base class for all reduction implementation classes. More...
 
class  ReductionIdentityContainer
 Templated class for common functionality of all reduction implementation classes. More...
 
class  ReductionIdentityContainer< T, BinaryOperation, ExplicitIdentity, enable_if_t< IsKnownIdentityOp< T, BinaryOperation >::value > >
 
class  ReductionIdentityContainer< T, BinaryOperation, false, std::enable_if_t<!IsKnownIdentityOp< T, BinaryOperation >::value > >
 
class  ReductionIdentityContainer< T, BinaryOperation, true, enable_if_t<!IsKnownIdentityOp< T, BinaryOperation >::value > >
 
struct  register_alloc_mode_key
 
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  ReleaseCommand
 The release command enqueues release of a memory object instance allocated on Host or underlying framework. More...
 
struct  remove_pointer
 
struct  remove_pointer_impl
 
struct  remove_pointer_impl< multi_ptr< T, Space, DecorateAddress > >
 
struct  remove_pointer_impl< T * >
 
class  RoundedRangeIDGenerator
 
class  RoundedRangeKernel
 
class  RoundedRangeKernelWithKH
 
struct  RShift
 
class  RTDeviceBinaryImage
 
struct  same_size_signed_int
 
struct  same_size_signed_int< marray< T, N > >
 
struct  same_size_signed_int< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  same_size_signed_int< vec< T, N > >
 
struct  same_size_unsigned_int
 
struct  same_size_unsigned_int< marray< T, N > >
 
struct  same_size_unsigned_int< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  same_size_unsigned_int< vec< T, N > >
 
class  SampledImageAccessorBaseHost
 
class  SampledImageAccessorImplHost
 
class  sampler_impl
 
class  Scheduler
 DPC++ graph scheduler class. More...
 
struct  select_cl_mptr_or_vector_or_scalar_or_ptr
 
struct  select_cl_mptr_or_vector_or_scalar_or_ptr< T, typename std::enable_if_t< is_genptr< T >::value &&!std::is_pointer_v< T > > >
 
struct  select_cl_mptr_or_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_genptr< T >::value||std::is_pointer_v< T > > >
 
struct  select_cl_scalar_complex_or_T
 
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_v< T > > >
 
struct  select_cl_vector_or_scalar_or_ptr< T, typename std::enable_if_t<!is_vgentype< T >::value &&std::is_pointer_v< T > > >
 
struct  simplify_if_swizzle
 
struct  simplify_if_swizzle< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
class  spec_constant_impl
 
struct  SpecConstantInfo
 
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...
 
class  stream_impl
 
class  SwizzleOp
 
struct  sycl_to_pi
 
struct  sycl_to_pi< bool >
 
struct  sycl_to_pi< device >
 
struct  sycl_to_pi< platform >
 
class  SYCLCategory
 
class  SYCLConfig
 
class  SYCLConfig< ONEAPI_DEVICE_SELECTOR >
 
class  SYCLConfig< SYCL_CACHE_DIR >
 
class  SYCLConfig< SYCL_CACHE_PERSISTENT >
 
class  SYCLConfig< SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING >
 
class  SYCLConfig< SYCL_ENABLE_DEFAULT_CONTEXTS >
 
class  SYCLConfig< SYCL_ENABLE_FUSION_CACHING >
 
class  SYCLConfig< SYCL_PARALLEL_FOR_RANGE_ROUNDING_PARAMS >
 
class  SYCLConfig< SYCL_PARALLEL_FOR_RANGE_ROUNDING_TRACE >
 
class  SYCLConfig< SYCL_PI_TRACE >
 
class  SYCLConfig< SYCL_QUEUE_THREAD_POOL_SIZE >
 
class  SYCLConfig< SYCL_REDUCTION_PREFERRED_WORKGROUP_SIZE >
 
class  SYCLConfig< SYCL_RT_WARNING_LEVEL >
 
class  SYCLConfigBase
 
class  SYCLMemObjAllocator
 
class  SYCLMemObjAllocatorHolder
 
class  SYCLMemObjI
 
class  SYCLMemObjT
 
class  Sync
 Groups and provides access to all the locks used the SYCL runtime. More...
 
struct  TargetToAS
 
struct  TargetToAS< access::target::constant_buffer >
 
struct  TargetToAS< access::target::local >
 
struct  TempAssignGuard
 
struct  TermPositions
 
class  ThreadPool
 
class  tls_code_loc_t
 Data type that manages the code_location information in TLS. More...
 
class  TryToGetElementType
 
struct  TryToGetNumElements
 
struct  TryToGetNumElements< T, typename std::enable_if_t< TryToGetVectorT< T >::value > >
 
struct  TryToGetNumElements< T, typename std::enable_if_t<!TryToGetVectorT< T >::value > >
 
class  TryToGetPointerT
 
class  TryToGetPointerVecT
 
class  TryToGetVectorT
 
struct  tuple
 
struct  tuple< T, Ts... >
 
struct  tuple<>
 
struct  tuple_element
 
struct  tuple_element< 0, tuple< T, Rest... > >
 
struct  tuple_element< N, tuple< T, Rest... > >
 
struct  TupleCopyAssignableValueHolder
 
struct  TupleCopyAssignableValueHolder< T, false >
 
struct  TupleValueHolder
 
struct  type_list
 
struct  type_list< Head, Tail... >
 
struct  type_list< type_list< Head, Tail... >, Tail2... >
 
struct  type_list<>
 
struct  TypeHelper
 
struct  TypeHelper< const T >
 
struct  TypeHelper< const volatile T >
 
struct  TypeHelper< std::byte >
 
struct  TypeHelper< volatile T >
 
class  UnMapMemObject
 The unmap command removes mapping of host memory onto device memory. More...
 
class  unsampled_image_common
 
class  UnsampledImageAccessorBaseHost
 
class  UnsampledImageAccessorImplHost
 
class  UpdateHostRequirementCommand
 
struct  upsampled_int
 
struct  upsampled_int< marray< T, N > >
 
struct  upsampled_int< SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  upsampled_int< vec< T, N > >
 
struct  use_fast_math
 
struct  value_list
 
struct  value_list< T >
 
struct  value_list< T, Head, Tail... >
 
struct  vec_helper
 
struct  vec_helper< bool >
 
struct  vec_helper< std::byte >
 
struct  VecStorage
 
struct  VecStorage< bool, 1, void >
 
struct  VecStorage< bool, N, typename std::enable_if_t< isValidVectorSize(N)> >
 
struct  VecStorage< half, 1, void >
 
struct  VecStorage< T, 1, typename std::enable_if_t< is_sigeninteger< T >::value > >
 
struct  VecStorage< T, 1, typename std::enable_if_t< is_sugeninteger< T >::value > >
 
struct  VecStorage< T, 1, typename std::enable_if_t<!is_half< T >::value &&is_sgenfloat< T >::value > >
 
struct  VecStorage< T, N, typename std::enable_if_t< isValidVectorSize(N) &&(is_sgeninteger< T >::value||(is_sgenfloat< T >::value &&!is_half< T >::value))> >
 
struct  VecStorageImpl
 
struct  vector_alignment
 
struct  vector_alignment_impl
 
struct  vector_element
 
struct  vector_element_impl
 
struct  vector_element_impl< vec< T, N > >
 
struct  vector_size
 
struct  vector_size_impl
 
struct  vector_size_impl< vec< T, N > >
 
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 UnsampledImageAccessorImplPtr = std::shared_ptr< UnsampledImageAccessorImplHost >
 
using SampledImageAccessorImplPtr = std::shared_ptr< SampledImageAccessorImplHost >
 
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 >
 
template<typename T >
using get_elem_type_t = typename get_elem_type< T >::type
 
template<typename T >
using get_select_opencl_builtin_c_arg_type = typename std::conditional_t< sizeof(T)==1, char, std::conditional_t< sizeof(T)==2, short, std::conditional_t<(detail::is_contained< T, detail::type_list< long, unsigned long > >::value &&(sizeof(T)==4||sizeof(T)==8)), long, std::conditional_t< sizeof(T)==4, int, std::conditional_t< sizeof(T)==8, long long, void > >> >>
 
template<size_t Size, typename T8 , typename T16 , typename T32 , typename T64 >
using select_scalar_by_size_t = std::conditional_t< Size==1, T8, std::conditional_t< Size==2, T16, std::conditional_t< Size==4, T32, std::conditional_t< Size==8, T64, void > >> >
 
template<typename T >
using same_size_signed_int_t = typename same_size_signed_int< T >::type
 
template<typename T >
using upsampled_int_t = typename upsampled_int< T >::type
 
template<typename T >
using simplify_if_swizzle_t = typename simplify_if_swizzle< T >::type
 
template<typename T >
using nan_return_unswizzled_t = typename nan_return_unswizzled< T >::type
 
template<typename NewElemT , typename T >
using change_elements_t = typename change_elements< NewElemT, T >::type
 
template<typename T >
using int_elements_t = change_elements_t< int, T >
 
template<typename T >
using bool_elements_t = change_elements_t< bool, T >
 
using EventImplPtr = std::shared_ptr< event_impl >
 
template<typename DataT >
using EnableIfOutputPointerT = std::enable_if_t< std::is_pointer_v< DataT > >
 
template<typename DataT >
using EnableIfOutputIteratorT = std::enable_if_t< !std::is_pointer_v< DataT > >
 
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_half = is_contained< T, gtl::scalar_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_mgenfloat = std::bool_constant< std::is_same_v< T, sycl::marray< marray_element_t< T >, T::size()> > &&is_svgenfloat< marray_element_t< T > >::value >
 
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_gengeomarrayfloat = is_contained< T, gtl::marray_geo_float_list >
 
template<typename T >
using is_gengeomarray = is_contained< T, gtl::marray_geo_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_gencrossmarray = is_contained< T, gtl::cross_marray_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_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_genbool = is_contained< T, gtl::bool_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 , access::address_space AddressSpace, access::decorated IsDecorated>
using is_genintptr_marray = std::bool_constant< std::is_same_v< T, sycl::marray< marray_element_t< T >, T::size()> > &&is_genint< marray_element_t< remove_pointer_t< T > >>::value &&is_address_space_compliant< multi_ptr< T, AddressSpace, IsDecorated >, gvl::nonconst_address_space_list >::value &&(IsDecorated==access::decorated::yes||IsDecorated==access::decorated::no)>
 
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 , access::address_space AddressSpace, access::decorated IsDecorated>
using is_genfloatptr_marray = std::bool_constant< is_mgenfloat< T >::value &&is_address_space_compliant< multi_ptr< T, AddressSpace, IsDecorated >, gvl::nonconst_address_space_list >::value &&(IsDecorated==access::decorated::yes||IsDecorated==access::decorated::no)>
 
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::opencl::cl_char, sycl::opencl::cl_short, sycl::opencl::cl_int, sycl::opencl::cl_long >
 
template<typename T >
using select_cl_scalar_integral_unsigned_t = select_apply_cl_scalar_t< T, sycl::opencl::cl_uchar, sycl::opencl::cl_ushort, sycl::opencl::cl_uint, sycl::opencl::cl_ulong >
 
template<typename T >
using select_cl_scalar_float_t = select_apply_cl_scalar_t< T, std::false_type, sycl::opencl::cl_half, sycl::opencl::cl_float, sycl::opencl::cl_double >
 
template<typename T >
using select_cl_scalar_complex_or_T_t = typename select_cl_scalar_complex_or_T< T >::type
 
template<typename T >
using select_cl_scalar_integral_t = std::conditional_t< std::is_signed_v< T >, select_cl_scalar_integral_signed_t< T >, select_cl_scalar_integral_unsigned_t< T > >
 
template<typename T >
using select_cl_scalar_t = std::conditional_t< std::is_integral_v< T >, select_cl_scalar_integral_t< T >, std::conditional_t< std::is_floating_point_v< T >, select_cl_scalar_float_t< T >, std::conditional_t< is_half< T >::value, sycl::detail::half_impl::BIsRepresentationT, select_cl_scalar_complex_or_T_t< T > >> >
 
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 ConvertToOpenCLTypeImpl_t = std::conditional_t< TryToGetVectorT< T >::value, typename TryToGetVectorT< T >::type, std::conditional_t< TryToGetPointerT< T >::value, typename TryToGetPointerVecT< T >::type, T > >
 
template<typename T >
using ConvertToOpenCLType_t = ConvertToOpenCLTypeImpl_t< SelectMatchingOpenCLType_t< T > >
 
template<typename T >
using common_rel_ret_t = std::conditional_t< is_vgentype< T >::value, make_singed_integer_t< T >, bool >
 
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< opencl::cl_int, opencl::cl_float, std::int32_t, float > >::type
 
using int64_t = conditional< sizeof(long)==8, long, long long >::type
 
using PluginPtr = std::shared_ptr< plugin >
 
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< std::remove_pointer_t< iterator_pointer_t< T > >>
 
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_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<class T >
using marray_element_t = typename T::value_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 DeviceSelector >
using EnableIfSYCL2020DeviceSelectorInvocable = std::enable_if_t< std::is_invocable_r_v< int, DeviceSelector &, const device & > &&!std::is_base_of_v< ext::oneapi::filter_selector, DeviceSelector > &&!std::is_base_of_v< device_selector, DeviceSelector > >
 
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 >, sycl::logical_or< T >, sycl::logical_and< T > >
 
template<typename T , typename BinaryOperation >
using is_plus = std::integral_constant< bool, std::is_same_v< BinaryOperation, sycl::plus< T > >||std::is_same_v< BinaryOperation, sycl::plus< void > >>
 
template<typename T , typename BinaryOperation >
using is_multiplies = std::integral_constant< bool, std::is_same_v< BinaryOperation, sycl::multiplies< T > >||std::is_same_v< BinaryOperation, sycl::multiplies< void > >>
 
template<typename T >
using is_arithmetic_or_complex = std::integral_constant< bool, sycl::detail::is_complex< typename std::remove_cv_t< T > >::value||sycl::detail::is_arithmetic< T >::value >
 
template<typename T , typename BinaryOperation >
using is_plus_or_multiplies_if_complex = std::integral_constant< bool,(is_complex< T >::value ?(is_plus< T, BinaryOperation >::value||is_multiplies< 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< vec< opencl::cl_int, 4 >, vec< opencl::cl_uint, 4 >, vec< opencl::cl_float, 4 >, vec< opencl::cl_half, 4 > >>::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_v< BinaryOperation, sycl::plus< T > >||std::is_same_v< BinaryOperation, sycl::plus< void > >>
 
template<typename T , class BinaryOperation >
using IsMultiplies = std::bool_constant< std::is_same_v< BinaryOperation, sycl::multiplies< T > >||std::is_same_v< BinaryOperation, sycl::multiplies< void > >>
 
template<typename T , class BinaryOperation >
using IsMinimum = std::bool_constant< std::is_same_v< BinaryOperation, sycl::minimum< T > >||std::is_same_v< BinaryOperation, sycl::minimum< void > >>
 
template<typename T , class BinaryOperation >
using IsMaximum = std::bool_constant< std::is_same_v< BinaryOperation, sycl::maximum< T > >||std::is_same_v< BinaryOperation, sycl::maximum< void > >>
 
template<typename T , class BinaryOperation >
using IsBitAND = std::bool_constant< std::is_same_v< BinaryOperation, sycl::bit_and< T > >||std::is_same_v< BinaryOperation, sycl::bit_and< void > >>
 
template<typename T , class BinaryOperation >
using IsBitOR = std::bool_constant< std::is_same_v< BinaryOperation, sycl::bit_or< T > >||std::is_same_v< BinaryOperation, sycl::bit_or< void > >>
 
template<typename T , class BinaryOperation >
using IsBitXOR = std::bool_constant< std::is_same_v< BinaryOperation, sycl::bit_xor< T > >||std::is_same_v< BinaryOperation, sycl::bit_xor< void > >>
 
template<typename T , class BinaryOperation >
using IsLogicalAND = std::bool_constant< std::is_same_v< BinaryOperation, std::logical_and< T > >||std::is_same_v< BinaryOperation, std::logical_and< void > >||std::is_same_v< BinaryOperation, sycl::logical_and< T > >||std::is_same_v< BinaryOperation, sycl::logical_and< void > >>
 
template<typename T , class BinaryOperation >
using IsLogicalOR = std::bool_constant< std::is_same_v< BinaryOperation, std::logical_or< T > >||std::is_same_v< BinaryOperation, std::logical_or< void > >||std::is_same_v< BinaryOperation, sycl::logical_or< T > >||std::is_same_v< BinaryOperation, sycl::logical_or< void > >>
 
template<typename T , class BinaryOperation >
using IsZeroIdentityOp = std::bool_constant<((is_genbool< T >::value||is_geninteger< T >::value) &&(IsPlus< T, BinaryOperation >::value||IsBitOR< T, BinaryOperation >::value||IsBitXOR< T, BinaryOperation >::value))||(is_genfloat< T >::value &&IsPlus< T, BinaryOperation >::value)||(isComplex< T >::value &&IsPlus< T, BinaryOperation >::value)>
 
template<typename T , class BinaryOperation >
using IsOneIdentityOp = std::bool_constant<(is_genbool< T >::value||is_geninteger< T >::value||is_genfloat< T >::value) &&IsMultiplies< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsOnesIdentityOp = std::bool_constant<(is_genbool< T >::value||is_geninteger< T >::value) &&IsBitAND< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsMinimumIdentityOp = std::bool_constant<(is_genbool< T >::value||is_geninteger< T >::value||is_genfloat< T >::value) &&IsMinimum< T, BinaryOperation >::value >
 
template<typename T , class BinaryOperation >
using IsMaximumIdentityOp = std::bool_constant<(is_genbool< T >::value||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<class KernelName >
using __sycl_init_mem_for = std::conditional_t< std::is_same_v< KernelName, auto_name >, auto_name, reduction::InitMemKrn< KernelName > >
 A helper to pass undefined (sycl::detail::auto_name) names unmodified. More...
 
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_v< KernelName, auto_name >, 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_v< F, float >||std::is_same_v< F, double >||std::is_same_v< F, half >, T >
 
using GlobalBufAccessorT = accessor< char, 1, sycl::access::mode::read_write, sycl::access::target::device >
 
using GlobalBufPtrType = typename detail::DecoratedType< char, GlobalBufAS >::type *
 
using GlobalOffsetAccessorT = accessor< unsigned, 1, sycl::access::mode::atomic, sycl::access::target::device >
 
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 _IN , typename T8 , typename T16 , typename T32 , typename T64 >
using select_apply_cl_t = std::conditional_t< sizeof(_IN)==1, T8, std::conditional_t< sizeof(_IN)==2, T16, std::conditional_t< sizeof(_IN)==4, T32, T64 > >>
 
template<typename DataT >
using rel_t = typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_char), opencl::cl_char, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_short), opencl::cl_short, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_int), opencl::cl_int, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_long), opencl::cl_long, bool > >> >
 
template<typename T , typename R >
using is_int_to_int = std::integral_constant< bool, std::is_integral_v< T > &&std::is_integral_v< R > >
 
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_v< T > &&!(std::is_unsigned_v< T >)&&detail::is_floating_point< R >::value >
 
template<typename T , typename R >
using is_uint_to_float = std::integral_constant< bool, std::is_unsigned_v< T > &&detail::is_floating_point< R >::value >
 
template<typename T , typename R >
using is_int_to_float = std::integral_constant< bool, std::is_integral_v< T > &&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_v< R > >
 
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 >
 
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 KernelArgMask = std::vector< bool >
 
using ProgramImplPtr = std::shared_ptr< program_impl >
 
using DeviceImplPtr = std::shared_ptr< device_impl >
 
using StreamImplPtr = std::shared_ptr< detail::stream_impl >
 
using QueueIdT = std::hash< std::shared_ptr< detail::queue_impl > >::result_type
 
using CommandPtr = std::unique_ptr< Command >
 
using FusionList = std::unique_ptr< KernelFusionCommand >
 
using FusionMap = std::unordered_map< QueueIdT, FusionList >
 
using SpecConstRegistryT = std::map< std::string, spec_constant_impl >
 

Enumerations

enum  backend_errc : unsigned int
 
enum  kernel_param_kind_t {
  kernel_param_kind_t::kind_accessor = 0, kernel_param_kind_t::kind_std_layout = 1, kernel_param_kind_t::kind_sampler = 2, kernel_param_kind_t::kind_pointer = 3,
  kernel_param_kind_t::kind_specialization_constants_buffer = 4, kernel_param_kind_t::kind_stream = 5, kernel_param_kind_t::kind_invalid = 0xf
}
 
enum  register_alloc_mode_enum : uint32_t { register_alloc_mode_enum::automatic = 0, register_alloc_mode_enum::large = 2 }
 
enum  PiApiKind { 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, GraphNoCycleCheck = 19,
  QueueSubmissionBatched = 20, QueueSubmissionImmediate = 21, GraphAssumeDataOutlivesBuffer = 22, GraphAssumeBufferOutlivesGraph = 23,
  LastKnownDataLessPropKind = 23, DataLessPropKindSize = 32
}
 
enum  PropWithDataKind {
  BufferUseMutex = 0, BufferContextBound = 1, ImageUseMutex = 2, ImageContextBound = 3,
  BufferMemChannel = 4, AccPropBufferLocation = 5, QueueComputeIndex = 6, GraphNodeDependencies = 7,
  PropWithDataKindSize = 8
}
 
enum  WorkSizeGuarantees { WorkSizeGuarantees::None, WorkSizeGuarantees::Equal, WorkSizeGuarantees::LessOrEqual }
 
enum  ConfigID { START = 0, END }
 
enum  HandlerSubmissionState : std::uint8_t { HandlerSubmissionState::NO_STATE = 0, HandlerSubmissionState::EXPLICIT_KERNEL_BUNDLE_STATE, HandlerSubmissionState::SPEC_CONST_SET_STATE }
 
enum  program_state { program_state::none = 0, program_state::compiled = 1, program_state::linked = 2 }
 
enum  DeviceLibExt : std::uint32_t {
  DeviceLibExt::cl_intel_devicelib_assert, DeviceLibExt::cl_intel_devicelib_math, DeviceLibExt::cl_intel_devicelib_math_fp64, DeviceLibExt::cl_intel_devicelib_complex,
  DeviceLibExt::cl_intel_devicelib_complex_fp64, DeviceLibExt::cl_intel_devicelib_cstring, DeviceLibExt::cl_intel_devicelib_imf, DeviceLibExt::cl_intel_devicelib_imf_fp64,
  DeviceLibExt::cl_intel_devicelib_imf_bf16, DeviceLibExt::cl_intel_devicelib_bfloat16
}
 
enum  CUDAContextT : char { CUDAContextT::primary, CUDAContextT::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)
 
void constructorNotification (void *BufferObj, void *AccessorObj, access::target Target, access::mode Mode, const code_location &CodeLoc)
 
void unsampledImageConstructorNotification (void *ImageObj, void *AccessorObj, const std::optional< image_target > &Target, access::mode Mode, const void *Type, uint32_t ElemSize, const code_location &CodeLoc)
 
void sampledImageConstructorNotification (void *ImageObj, void *AccessorObj, const std::optional< image_target > &Target, const void *Type, uint32_t ElemSize, const code_location &CodeLoc)
 
template<typename BufferT >
sycl::range< 1 > GetZeroDimAccessRange (BufferT Buffer)
 
device getDeviceFromHandler (handler &CommandGroupHandlerRef)
 
template<typename DataT >
constexpr access::mode accessModeFromConstness ()
 
template<typename MayBeTag1 , typename MayBeTag2 >
constexpr access::mode deduceAccessMode ()
 
template<typename MayBeTag1 , typename MayBeTag2 >
constexpr access::target deduceAccessTarget (access::target defaultTarget)
 
void addHostAccessorAndWait (AccessorImplHost *Req)
 
void addHostUnsampledImageAccessorAndWait (UnsampledImageAccessorImplHost *Req)
 
void addHostSampledImageAccessorAndWait (SampledImageAccessorImplHost *Req)
 
std::memory_order getStdMemoryOrder (__spv::MemorySemanticsMask::Flag)
 
constexpr memory_order getLoadOrder (memory_order order)
 
backend convertBackend (pi_platform_backend PiBackend)
 
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, int32_t nativeHandleDesc, const context &TargetContext, const device *TargetDevice, bool KeepOwnership, const property_list &PropList, 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)
 
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<typename T , typename... Ts>
constexpr bool CheckTypeIn ()
 
template<size_t N, size_t... Ns>
constexpr bool CheckSizeIn ()
 
template<typename T , typename... Ts>
constexpr bool CheckAllSameOpType ()
 
template<class T , size_t N>
vec< T, 2 > to_vec2 (marray< T, N > X, size_t Start)
 
template<class T , size_t N>
vec< T, N > to_vec (marray< T, N > X)
 
template<class T , int N>
marray< T, N > to_marray (vec< T, N > X)
 
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_v< LambdaArgType, void >> * = 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)
 
std::string codeToString (pi_int32 code)
 
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)
 
template<typename T , std::size_t... Is1, std::size_t... Is2>
constexpr std::array< T, sizeof...(Is1)+sizeof...(Is2)> ConcatArrays (const std::array< T, sizeof...(Is1)> &A1, const std::array< T, sizeof...(Is2)> &A2, std::index_sequence< Is1... >, std::index_sequence< Is2... >)
 
template<typename T , std::size_t N1, std::size_t N2>
constexpr std::array< T, N1+N2 > ConcatArrays (const std::array< T, N1 > &A1, const std::array< T, N2 > &A2)
 
template<typename T , size_t... Is>
static constexpr std::array< T, sizeof...(Is)> RepeatValueHelper (const T &Arg, std::index_sequence< Is... >)
 
template<size_t N, typename T >
static constexpr std::array< T, N > RepeatValue (const T &Arg)
 
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 associateWithHandler (handler &, UnsampledImageAccessorBaseHost *, image_target)
 
void associateWithHandler (handler &, SampledImageAccessorBaseHost *, image_target)
 
std::vector< sycl::detail::pi::PiEventgetOrWaitEvents (std::vector< sycl::event > DepEvents, std::shared_ptr< sycl::detail::context_impl > Context)
 
void waitEvents (std::vector< sycl::event > DepEvents)
 
void markBufferAsInternal (const std::shared_ptr< buffer_impl > &BufImpl)
 
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<size_t... Inds, class F >
void loop_impl (std::integer_sequence< size_t, Inds... >, F &&f)
 
template<size_t count, class F >
void loop (F &&f)
 
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, float4 > convertToFloat4 (T Coords)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, float4 > convertToFloat4 (vec< T, 2 > Coords)
 
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, float4 > convertToFloat4 (vec< T, 4 > Coords)
 
template<typename T >
std::enable_if_t< std::is_integral_v< T >, size_t > getImageOffset (const T &Coords, const id< 3 >, const uint8_t ElementSize)
 
template<typename T >
std::enable_if_t< std::is_integral_v< T >, 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_v< T >, size_t > getImageOffset (const vec< T, 4 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
 
int4 getPixelCoordNearestFiltMode (float4, const addressing_mode, const range< 3 >)
 
int8 getPixelCoordLinearFiltMode (float4, const addressing_mode, const range< 3 >, float4 &)
 
bool isOutOfRange (const int4 PixelCoord, const addressing_mode SmplAddrMode, const range< 3 > ImgRange)
 
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, uint4 &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, int4 &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, float4 &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, half4 &RetData)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const uint4 WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const int4 WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > processFloatDataToPixel (float4 WriteData, float MulFactor)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const float4 WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const half4 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 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 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 int8 CoordValues, const 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, coordinate_normalization_mode SmplNormMode, addressing_mode SmplAddrMode, filtering_mode SmplFiltMode, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, 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<typename CoordT , typename DataT >
DataT imageReadSamplerHostImpl (const CoordT &Coords, const image_sampler &Smpl, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, uint8_t ElementSize)
 
template<class Obj >
decltype(Obj::impl) getSyclObjImpl (const Obj &SyclObject)
 
template<class T >
std::add_pointer_t< typename decltype(T::impl)::element_typegetRawSyclObjImpl (const T &SyclObject)
 
template<class T >
createSyclObjFromImpl (decltype(T::impl) ImplObj)
 
template<auto & SpecName>
const char * get_spec_constant_symbolic_ID_impl ()
 
template<auto & SpecName>
const char * get_spec_constant_symbolic_ID ()
 
template<register_alloc_mode_enum Mode>
constexpr register_alloc_mode_key::value_t< Mode > register_alloc_mode __SYCL_DEPRECATED ("register_alloc_mode is deprecated, " "use sycl::ext::intel::experimental::grf_size or " "sycl::ext::intel::experimental::grf_size_automatic")
 
void memcpy (void *Dst, const void *Src, size_t Size)
 
template<sycl::backend BE>
void * getPluginOpaqueData (void *opaquedata_arg)
 
template<typename KernelName , reduction::strategy Strategy = reduction::strategy::auto_select, int Dims, typename PropertiesT , typename... RestT>
void reduction_parallel_for (handler &CGH, range< Dims > NDRange, PropertiesT Properties, RestT... Rest)
 
template<typename KernelName , reduction::strategy Strategy = reduction::strategy::auto_select, int Dims, typename PropertiesT , typename... RestT>
void reduction_parallel_for (handler &CGH, nd_range< Dims > NDRange, PropertiesT Properties, RestT... Rest)
 
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::oneapi::experimental::architecture... Archs>
constexpr static bool allowable_aot_mode ()
 
template<ext::oneapi::experimental::architecture... Archs>
constexpr static bool device_architecture_is ()
 
sycl::vec< unsigned, 4 > ExtractMask (ext::oneapi::sub_group_mask Mask)
 
template<typename NonUniformGroup >
ext::oneapi::sub_group_mask GetMask (NonUniformGroup Group)
 
template<typename NonUniformGroup >
uint32_t IdToMaskPosition (NonUniformGroup Group, uint32_t Id)
 
template<typename DecorT , typename T , access::address_space Space, access::decorated IsDecorated>
DecorT * getDecorated (multi_ptr< T, Space, IsDecorated > ptr)
 
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< sycl::sub_group > (sycl::sub_group g)
 
template<typename Group >
Group::linear_id_type get_local_linear_id (Group g)
 
template<>
sycl::sub_group::linear_id_type get_local_linear_id< sycl::sub_group > (sycl::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 &&is_multiplies< 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 (...)
 
bool isDeviceGlobalUsedInKernel (const void *DeviceGlobalPtr)
 
template<int Dims, typename T >
std::enable_if_t< std::is_same_v< T, range< Dims > >||std::is_same_v< T, id< Dims > > > 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_v< T, nd_range< Dims > > > checkValueRange (const T &V)
 
template<typename T >
static std::enable_if_t< std::is_unsigned_v< T >, boolmultiply_with_overflow_check (T &dst, T x, T y)
 
template<int Dims>
bool range_size_fits_in_size_t (const range< Dims > &r)
 
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)
 
image_channel_type FormatChannelType (image_format Format)
 
image_channel_order FormatChannelOrder (image_format Format)
 
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::devicefind_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)
 
void enable_ext_oneapi_default_context (bool Val)
 Allows to enable/disable "Default Context" extension. More...
 
std::array< size_t, 3 > rangeToArray (const range< 3 > &r)
 
std::array< size_t, 3 > rangeToArray (const range< 2 > &r)
 
std::array< size_t, 3 > rangeToArray (const range< 1 > &r)
 
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<typename ReducerT >
auto getReducerAccess (ReducerT &Reducer)
 
template<class BinaryOp , int Dims, size_t Extent, bool ExplicitIdentity, 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...
 
size_t GreatestPowerOfTwo (size_t N)
 Computes the greatest power-of-two less than or equal to N. More...
 
template<typename FuncTy >
void doTreeReductionHelper (size_t WorkSize, size_t LID, FuncTy Func)
 
template<WorkSizeGuarantees WSGuarantee, int Dim, typename LocalRedsTy , typename BinOpTy , typename AccessFuncTy >
void doTreeReduction (size_t WorkSize, nd_item< Dim > NDIt, LocalRedsTy &LocalReds, BinOpTy &BOp, AccessFuncTy AccessFunc)
 
template<typename... LocalAccT, typename... BOPsT, size_t... Is>
void doTreeReductionOnTuple (size_t WorkSize, size_t LID, ReduTupleT< LocalAccT... > &LocalAccs, ReduTupleT< BOPsT... > &BOPs, std::index_sequence< Is... >)
 
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 OutAccT , typename LocalAccT , typename BOPT , typename IdentityContainerT >
auto getLastCombine (OutAccT OutAcc, LocalAccT LocalAcc, BOPT BOP, IdentityContainerT IdentityContainer, bool IsInitializeToIdentity)
 
template<bool IsOneWG, typename... Reductions, typename... OutAccT, typename... LocalAccT, typename... BOPsT, typename... Ts, size_t... Is>
void writeReduSumsToOutAccs (size_t OutAccIndex, 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 ElementType , typename BOPT >
constexpr auto makeAdjustedBOP (BOPT &BOP)
 
template<typename... Reductions, typename... BOPsT, size_t... Is>
constexpr auto makeAdjustedBOPs (ReduTupleT< BOPsT... > &BOPsTuple, std::index_sequence< Is... >)
 
template<typename... Reductions, typename... BOPsT>
constexpr auto makeAdjustedBOPs (ReduTupleT< BOPsT... > &BOPsTuple)
 
template<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... Ts, typename... BOPsT, size_t... Is>
void reduCGFuncImplScalar (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<bool IsOneWG, typename Reduction , int Dims, typename LocalAccT , typename OutAccT , typename ReducerT , typename BOPT >
void reduCGFuncImplArrayHelper (nd_item< Dims > NDIt, LocalAccT LocalReds, OutAccT Out, ReducerT &Reducer, BOPT BOp, bool IsInitializeToIdentity)
 Each array reduction is processed separately. More...
 
template<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... BOPsT, size_t... Is>
void reduCGFuncImplArray (nd_item< Dims > NDIt, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, std::tuple< ReducerT... > &ReducersTuple, 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<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void reduAuxCGFuncImplScalar (nd_item< Dims > NDIt, size_t LID, size_t GID, size_t RemainingWorkSize, 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<bool IsOneWG, typename Reduction , int Dims, typename LocalAccT , typename InAccT , typename OutAccT , typename T , typename BOPT >
void reduAuxCGFuncImplArrayHelper (nd_item< Dims > NDIt, size_t LID, size_t GID, size_t RemainingWorkSize, LocalAccT LocalReds, InAccT In, OutAccT Out, T IdentityContainer, BOPT BOp, bool IsInitializeToIdentity)
 
template<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void reduAuxCGFuncImplArray (nd_item< Dims > NDIt, size_t LID, size_t GID, size_t RemainingWorkSize, 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...
 
uint32_t reduGetMaxNumConcurrentWorkGroups (std::shared_ptr< queue_impl > Queue)
 
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< T > getAbsVal (const T Val, const int Base)
 
char digitToChar (const int Digit)
 
template<typename T >
std::enable_if_t< std::is_integral_v< T >, unsigned > integralToBase (T Val, int Base, char *Digits)
 
template<typename T >
std::enable_if_t< std::is_integral_v< T >, unsigned > ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
 
unsigned append (char *Dst, const char *Src)
 
unsigned F2I32 (float Val)
 
unsigned long long D2I64 (double Val)
 
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, boolisFastMathInf (T Val)
 
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, boolisFastMathNan (T Val)
 
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, boolisFastMathSignBit (T Val)
 
template<typename T >
detail::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_v< T, half >, 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_v< T > > 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 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)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t< std::is_same_v< T, R >, R > convertImpl (T Value)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t<!std::is_same_v< T, R > &&(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)
 
constexpr bool isValidVectorSize (int N)
 
template<typename T >
struct __SYCL2020_DEPRECATED ("This type isn't device copyable in SYCL 2020") IsDeprecatedDeviceCopyable< T
 
static const PluginPtrgetPlugin (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< sycl::detail::pi::PiDevice > &PiDevices, sycl::detail::pi::PiPlatform PiPlatform, const PluginPtr &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 >, 8 > & 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::devicecontext_impl::get_info< info::context::devices > () const
 
template<>
std::vector< sycl::memory_ordercontext_impl::get_info< info::context::atomic_memory_order_capabilities > () const
 
template<>
std::vector< sycl::memory_scopecontext_impl::get_info< info::context::atomic_memory_scope_capabilities > () const
 
template<>
std::vector< sycl::memory_ordercontext_impl::get_info< info::context::atomic_fence_order_capabilities > () const
 
template<>
std::vector< sycl::memory_scopecontext_impl::get_info< info::context::atomic_fence_scope_capabilities > () const
 
template<typename T , typename Capabilities >
void GetCapabilitiesIntersectionSet (const std::vector< sycl::device > &Devices, std::vector< T > &CapabilityList)
 
template<typename Param >
Param::return_type get_context_info (sycl::detail::pi::PiContext Ctx, const PluginPtr &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)
 
static bool is_sycl_partition_property (info::partition_property PP)
 
template<int Dimensions>
range< Dimensionsconstruct_range (size_t *values)=delete
 
template<>
range< 1 > construct_range< 1 > (size_t *values)
 
template<>
range< 2 > construct_range< 2 > (size_t *values)
 
template<>
range< 3 > construct_range< 3 > (size_t *values)
 
template<typename Param >
Param::return_type get_device_info (const DeviceImplPtr &Dev)
 
template<typename Param >
Param::return_type get_device_info_host ()=delete
 
template<>
std::vector< sycl::aspect > get_device_info_host< info::device::aspects > ()
 
template<>
ext::oneapi::experimental::architecture get_device_info_host< ext::oneapi::experimental::info::device::architecture > ()
 
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<>
range< 1 > get_device_info_host< info::device::max_work_item_sizes< 1 > > ()
 
template<>
range< 2 > get_device_info_host< info::device::max_work_item_sizes< 2 > > ()
 
template<>
range< 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_orderget_device_info_host< info::device::atomic_fence_order_capabilities > ()
 
template<>
std::vector< memory_scopeget_device_info_host< info::device::atomic_memory_scope_capabilities > ()
 
template<>
std::vector< memory_scopeget_device_info_host< info::device::atomic_fence_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<>
int32_t get_device_info_host< ext::intel::info::device::max_compute_queue_indices > ()
 
template<>
bool get_device_info_host< ext::codeplay::experimental::info::device::supports_fusion > ()
 
template<>
uint32_t get_device_info_host< ext::codeplay::experimental::info::device::max_registers_per_work_group > ()
 
template<>
ext::oneapi::experimental::graph_support_level get_device_info_host< ext::oneapi::experimental::info::device::graph_support > ()
 
template<>
uint32_t get_device_info_host< ext::oneapi::experimental::info::device::image_row_pitch_align > ()
 
template<>
uint32_t get_device_info_host< ext::oneapi::experimental::info::device::max_image_linear_row_pitch > ()
 
template<>
std::vector< ext::oneapi::experimental::matrix::combinationget_device_info_host< ext::oneapi::experimental::info::device::matrix_combinations > ()
 
template<>
uint32_t get_device_info_host< ext::oneapi::experimental::info::device::max_image_linear_width > ()
 
template<>
uint32_t get_device_info_host< ext::oneapi::experimental::info::device::max_image_linear_height > ()
 
template<>
float get_device_info_host< ext::oneapi::experimental::info::device::mipmap_max_anisotropy > ()
 
static uint64_t getTimestamp ()
 
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 > ()
 
template<typename Param >
Param::return_type get_event_profiling_info (sycl::detail::pi::PiEvent Event, const PluginPtr &Plugin)
 
template<typename Param >
Param::return_type get_event_info (sycl::detail::pi::PiEvent Event, const PluginPtr &Plugin)
 
static void enableOnCrashStackPrinting ()
 
void shutdown ()
 
 __attribute__ ((destructor(110))) static void syclUnload()
 
std::vector< sycl::detail::pi::PiEventgetOrWaitEvents (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)
 
sycl::detail::pi::PiMemImageChannelOrder convertChannelOrder (image_channel_order Order)
 
image_channel_order convertChannelOrder (sycl::detail::pi::PiMemImageChannelOrder Order)
 
sycl::detail::pi::PiMemImageChannelType convertChannelType (image_channel_type Type)
 
image_channel_type convertChannelType (sycl::detail::pi::PiMemImageChannelType Type)
 
template<typename T >
static void getImageInfo (const ContextImplPtr Context, sycl::detail::pi::PiMemImageInfo Info, T &Dest, sycl::detail::pi::PiMem InteropMemObject)
 
KernelArgMask createKernelArgMask (const ByteArray &Bytes)
 
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 (sycl::detail::pi::PiKernel Kernel, const PluginPtr &Plugin)
 
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, uint32_t >::value, uint32_t >::type get_kernel_info (sycl::detail::pi::PiKernel Kernel, const PluginPtr &Plugin)
 
template<typename Param >
std::enable_if< IsSubGroupInfo< Param >::value >::type get_kernel_device_specific_info_helper (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &Plugin, void *Result, size_t Size)
 
template<typename Param >
std::enable_if<!IsSubGroupInfo< Param >::value >::type get_kernel_device_specific_info_helper (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &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 (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &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 (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &Plugin)
 
template<typename Param >
uint32_t get_kernel_device_specific_info_with_input (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, sycl::range< 3 > In, const PluginPtr &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 PluginPtr &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 PluginPtr &Plugin, pi_mem Mem)
 
void memBufferMapHelper (const PluginPtr &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 PluginPtr &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 sycl::detail::pi::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, sycl::detail::pi::PiMem DstMem, QueueImplPtr TgtQueue, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< sycl::detail::pi::PiEvent > DepEvents, sycl::detail::pi::PiEvent &OutEvent, const detail::EventImplPtr &OutEventImpl)
 
void copyD2H (SYCLMemObjI *SYCLMemObj, sycl::detail::pi::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< sycl::detail::pi::PiEvent > DepEvents, sycl::detail::pi::PiEvent &OutEvent, const detail::EventImplPtr &OutEventImpl)
 
void copyD2D (SYCLMemObjI *SYCLMemObj, sycl::detail::pi::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, sycl::detail::pi::PiMem DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 >, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< sycl::detail::pi::PiEvent > DepEvents, sycl::detail::pi::PiEvent &OutEvent, const detail::EventImplPtr &OutEventImpl)
 
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< sycl::detail::pi::PiEvent >, sycl::detail::pi::PiEvent &, const detail::EventImplPtr &)
 
static void memcpyToDeviceGlobalUSM (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, const void *Src, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent, const detail::EventImplPtr &OutEventImpl)
 
static void memcpyFromDeviceGlobalUSM (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, void *Dest, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent, const detail::EventImplPtr &OutEventImpl)
 
static sycl::detail::pi::PiProgram getOrBuildProgramForDeviceGlobal (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry)
 
static void memcpyToDeviceGlobalDirect (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, const void *Src, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent)
 
static void memcpyFromDeviceGlobalDirect (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, void *Dest, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent)
 
static bool IsSupportedImageFormat (sycl::detail::pi::PiDeviceBinaryType Format)
 
std::string getDirName (const char *Path)
 
template void * getPluginOpaqueData< sycl::backend::ext_intel_esimd_emulator > (void *)
 
static bool IsBannedPlatform (platform Platform)
 
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 (sycl::detail::pi::PiPlatform Plt, const PluginPtr &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 (sycl::detail::pi::PiPlatform Plt, const PluginPtr &Plugin)
 
template<typename Param >
std::enable_if< std::is_same< Param, info::platform::extensions >::value, std::vector< std::string > >::type get_platform_info (sycl::detail::pi::PiPlatform Plt, const PluginPtr &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 sycl::detail::pi::PiProgram &Prog, const PluginPtr &Plugin)
 This function enables ITT annotations in SPIR-V module by setting a specialization constant if INTEL_LIBITTNOTIFY64 env variable is set. More...
 
static sycl::detail::pi::PiProgram createBinaryProgram (const ContextImplPtr Context, const device &Device, const unsigned char *Data, size_t DataLen, const std::vector< pi_device_binary_property > Metadata)
 
static sycl::detail::pi::PiProgram createSpirvProgram (const ContextImplPtr Context, const unsigned char *Data, size_t DataLen)
 
template<typename RetT , typename ExceptionT , typename GetCachedBuildFT , typename BuildFT >
KernelProgramCache::BuildResult< RetT > * getOrBuild (KernelProgramCache &KPCache, GetCachedBuildFT &&GetCachedBuild, BuildFT &&Build)
 Try to fetch entity (kernel or program) from cache. More...
 
static bool isDeviceBinaryTypeSupported (const context &C, sycl::detail::pi::PiDeviceBinaryType Format)
 
static const char * getFormatStr (sycl::detail::pi::PiDeviceBinaryType Format)
 
static void appendLinkOptionsFromImage (std::string &LinkOpts, const RTDeviceBinaryImage &Img)
 
static bool getUint32PropAsBool (const RTDeviceBinaryImage &Img, const char *PropName)
 
static std::string getUint32PropAsOptStr (const RTDeviceBinaryImage &Img, const char *PropName)
 
static void appendCompileOptionsForGRFSizeProperties (std::string &CompileOpts, const RTDeviceBinaryImage &Img, bool IsEsimdImage)
 
static void appendCompileOptionsFromImage (std::string &CompileOpts, const RTDeviceBinaryImage &Img, const std::vector< device > &Devs, const PluginPtr &)
 
static void applyOptionsFromImage (std::string &CompileOpts, std::string &LinkOpts, const RTDeviceBinaryImage &Img, const std::vector< device > &Devices, const PluginPtr &Plugin)
 
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, sycl::detail::pi::PiProgram &Prog)
 
static const char * getDeviceLibFilename (DeviceLibExt Extension, bool Native)
 
static const char * getDeviceLibExtensionStr (DeviceLibExt Extension)
 
static sycl::detail::pi::PiProgram loadDeviceLibFallback (const ContextImplPtr Context, DeviceLibExt Extension, const sycl::detail::pi::PiDevice &Device, bool UseNativeLib)
 
void CheckJITCompilationForImage (const RTDeviceBinaryImage *const &Image, bool JITCompilationIsRequired)
 
template<typename StorageKey >
RTDeviceBinaryImagegetBinImageFromMultiMap (const std::unordered_multimap< StorageKey, RTDeviceBinaryImage * > &ImagesSet, const StorageKey &Key, const context &Context, const device &Device)
 
static bool isDeviceLibRequired (DeviceLibExt Ext, uint32_t DeviceLibReqMask)
 
static std::vector< sycl::detail::pi::PiProgramgetDeviceLibPrograms (const ContextImplPtr Context, const sycl::detail::pi::PiDevice &Device, uint32_t DeviceLibReqMask)
 
static bundle_state getBinImageState (const RTDeviceBinaryImage *BinImage)
 
static bool compatibleWithDevice (RTDeviceBinaryImage *BinImage, const device &Dev)
 
static void setSpecializationConstants (const std::shared_ptr< device_image_impl > &InputImpl, sycl::detail::pi::PiProgram Prog, const PluginPtr &Plugin)
 
bool doesDevSupportDeviceRequirements (const device &Dev, const RTDeviceBinaryImage &Img)
 
static std::string getAspectNameStr (sycl::aspect AspectNum)
 
template<typename T >
static std::enable_if_t< std::is_unsigned_v< T >, std::optional< T > > multiply_with_overflow_check (T x, T y)
 
std::optional< sycl::exceptioncheckDevSupportDeviceRequirements (const device &Dev, const RTDeviceBinaryImage &Img)
 
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 prepareSYCLEventAssociatedWithQueue (const std::shared_ptr< detail::queue_impl > &QueueImpl)
 
static event createDiscardedEvent ()
 
void report (const code_location &CodeLoc)
 
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)
 
void applyFuncOnFilteredArgs (const 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)
 
void emitKernelInstrumentationData (const std::shared_ptr< detail::kernel_impl > &SyclKernel, const detail::code_location &CodeLoc, const std::string &SyclKernelName, const QueueImplPtr &Queue, const NDRDescT &NDRDesc, const std::shared_ptr< detail::kernel_bundle_impl > &KernelBundleImplPtr, std::vector< ArgDesc > &CGArgs)
 
static void adjustNDRangePerKernel (NDRDescT &NDR, sycl::detail::pi::PiKernel Kernel, const device_impl &DeviceImpl)
 
void ReverseRangeDimensionsForKernel (NDRDescT &NDR)
 
pi_mem_obj_access AccessModeToPi (access::mode AccessorMode)
 
void SetArgBasedOnType (const PluginPtr &Plugin, sycl::detail::pi::PiKernel Kernel, const std::shared_ptr< device_image_impl > &DeviceImageImpl, const std::function< void *(Requirement *Req)> &getMemAllocationFunc, const sycl::context &Context, bool IsHost, detail::ArgDesc &Arg, size_t NextTrueIndex)
 
static pi_result SetKernelParamsAndLaunch (const QueueImplPtr &Queue, std::vector< ArgDesc > &Args, const std::shared_ptr< device_image_impl > &DeviceImageImpl, sycl::detail::pi::PiKernel Kernel, NDRDescT &NDRDesc, std::vector< sycl::detail::pi::PiEvent > &RawEvents, const detail::EventImplPtr &OutEventImpl, const KernelArgMask *EliminatedArgMask, const std::function< void *(Requirement *Req)> &getMemAllocationFunc)
 
void DispatchNativeKernel (void *Blob)
 
pi_int32 enqueueImpCommandBufferKernel (context Ctx, DeviceImplPtr DeviceImpl, sycl::detail::pi::PiExtCommandBuffer CommandBuffer, const CGExecKernel &CommandGroup, std::vector< sycl::detail::pi::PiExtSyncPoint > &SyncPoints, sycl::detail::pi::PiExtSyncPoint *OutSyncPoint, const std::function< void *(Requirement *Req)> &getMemAllocationFunc)
 
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, std::vector< sycl::detail::pi::PiEvent > &RawEvents, const detail::EventImplPtr &OutEventImpl, const std::function< void *(Requirement *Req)> &getMemAllocationFunc, sycl::detail::pi::PiKernelCacheConfig KernelCacheConfig)
 
pi_int32 enqueueReadWriteHostPipe (const QueueImplPtr &Queue, const std::string &PipeName, bool blocking, void *ptr, size_t size, std::vector< sycl::detail::pi::PiEvent > &RawEvents, const detail::EventImplPtr &OutEventImpl, bool read)
 
void SetArgBasedOnType (const detail::plugin &Plugin, sycl::detail::pi::PiKernel Kernel, const std::shared_ptr< device_image_impl > &DeviceImageImpl, const std::function< void *(Requirement *Req)> &getMemAllocationFunc, const sycl::context &Context, bool IsHost, detail::ArgDesc &Arg, size_t NextTrueIndex)
 
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 (ExecCGCommand *Cmd)
 
static void combineAccessModesOfReqs (std::vector< Requirement * > &Reqs)
 
static bool isPartOfFusion (Command *Cmd, KernelFusionCommand *Fusion)
 
static bool checkForCircularDependency (Command *, bool, KernelFusionCommand *)
 
static bool createsCircularDependency (Command *Cmd, bool PredPartOfFusion, KernelFusionCommand *Fusion)
 
static CommandgetCommand (const EventImplPtr &Event)
 
static bool doOverlap (const Requirement *LHS, const Requirement *RHS)
 
static bool isHostAccessorCmd (Command *Cmd)
 
void stableSerializeSpecConstRegistry (const SpecConstRegistryT &Reg, SerializedObj &Dst)
 
std::ostream & operator<< (std::ostream &Out, const spec_constant_impl &V)
 
sycl::detail::pi::PiMemObjectType getImageType (int Dimensions)
 
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 ()
 
sycl::detail::pi::PiImageCopyFlags getPiImageCopyFlags (sycl::usm::alloc SrcPtrType, sycl::usm::alloc DstPtrType)
 

Variables

template<typename T >
constexpr bool use_fast_math_v = use_fast_math<T>::value
 
template<typename... Ts>
constexpr bool check_type_in_v = CheckTypeIn<Ts...>()
 
template<typename T1 , typename T2 >
constexpr bool is_same_op_v = is_same_op<T1, T2>::value
 
template<typename... Ts>
constexpr bool check_all_same_op_type_v = CheckAllSameOpType<Ts...>()
 
template<size_t... Ns>
constexpr bool check_size_in_v = CheckSizeIn<Ns...>()
 
template<typename T , typename... Ts>
constexpr bool is_valid_elem_type_v = is_valid_elem_type<T, Ts...>::value
 
template<typename T >
constexpr access::decorated get_multi_ptr_decoration_v
 
template<typename T >
constexpr bool has_writeable_addr_space_v = has_writeable_addr_space<T>::value
 
template<typename T >
constexpr bool is_swizzle_v = is_swizzle<T>::value
 
template<typename T >
constexpr bool is_vec_or_swizzle_v = is_vec_v<T> || is_swizzle_v<T>
 
template<typename T , int... Ns>
constexpr bool is_valid_size_v = is_valid_size<T, Ns...>::value
 
template<class T >
constexpr bool is_fixed_size_group_v = is_fixed_size_group<T>::value
 
template<typename T >
constexpr bool is_vec_v = is_vec<T>::value
 
template<typename T >
constexpr bool is_marray_v = is_marray<T>::value
 
template<class T >
constexpr bool is_multi_ptr_v = is_multi_ptr<T>::value
 
template<class T >
constexpr bool is_non_legacy_multi_ptr_v
 
template<class T >
constexpr bool is_legacy_multi_ptr_v = is_legacy_multi_ptr<T>::value
 
constexpr size_t MaxVecAlignment = 64
 
static constexpr int REJECT_DEVICE_SCORE = -1
 
static constexpr ext::oneapi::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
 
static thread_local detail::code_location GCodeLocTLS = {}
 CodeLocation information slot in thread local storage. More...
 
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
 
constexpr const char * SYCL_IMAGE_STREAM_NAME = "sycl.experimental.image"
 

Typedef Documentation

◆ __sycl_init_mem_for

template<class KernelName >
using sycl::_V1::detail::__sycl_init_mem_for = typedef std::conditional_t<std::is_same_v<KernelName, auto_name>, auto_name, reduction::InitMemKrn<KernelName> >

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

We must do that to avoid name collisions.

Definition at line 843 of file reduction.hpp.

◆ __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_v<KernelName, auto_name>, 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 1233 of file reduction.hpp.

◆ AccessorImplPtr

Definition at line 532 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.

◆ bool_elements_t

template<typename T >
using sycl::_V1::detail::bool_elements_t = typedef change_elements_t<bool, T>

Definition at line 162 of file builtins_utils_vec.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 161 of file type_traits.hpp.

◆ change_elements_t

template<typename NewElemT , typename T >
using sycl::_V1::detail::change_elements_t = typedef typename change_elements<NewElemT, T>::type

Definition at line 159 of file builtins_utils_vec.hpp.

◆ CommandPtr

using sycl::_V1::detail::CommandPtr = typedef std::unique_ptr<Command>

Definition at line 188 of file scheduler.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>, bool>

Definition at line 658 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 480 of file type_traits.hpp.

◆ ContextImplPtr

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

Definition at line 33 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 334 of file generic_type_traits.hpp.

◆ ConvertToOpenCLType_t

◆ ConvertToOpenCLTypeImpl_t

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

Definition at line 616 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 121 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 79 of file kernel_bundle.hpp.

◆ DeviceImplPtr

Definition at line 65 of file program_manager.hpp.

◆ DevImgSelectorImpl

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

Definition at line 486 of file kernel_bundle.hpp.

◆ DSelectorInvocableType

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

Definition at line 122 of file device_selector.hpp.

◆ empty_type_list

Definition at line 26 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_v<F, float> || std::is_same_v<F, double> || std::is_same_v<F, half>, T>

Definition at line 89 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 124 of file image.hpp.

◆ EnableIfOutputIteratorT

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

Definition at line 38 of file common.hpp.

◆ EnableIfOutputPointerT

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

Definition at line 34 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 745 of file stream.hpp.

◆ EnableIfSYCL2020DeviceSelectorInvocable

template<typename DeviceSelector >
using sycl::_V1::detail::EnableIfSYCL2020DeviceSelectorInvocable = typedef std::enable_if_t< std::is_invocable_r_v<int, DeviceSelector &, const device &> && !std::is_base_of_v<ext::oneapi::filter_selector, DeviceSelector> && !std::is_base_of_v<device_selector, DeviceSelector> >

Definition at line 143 of file device_selector.hpp.

◆ EventImplPtr

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

Definition at line 39 of file cg.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 117 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 121 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 114 of file type_list.hpp.

◆ FmtFlags

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

Definition at line 46 of file stream.hpp.

◆ FusionList

using sycl::_V1::detail::FusionList = typedef std::unique_ptr<KernelFusionCommand>

Definition at line 189 of file scheduler.hpp.

◆ FusionMap

using sycl::_V1::detail::FusionMap = typedef std::unordered_map<QueueIdT, FusionList>

Definition at line 190 of file scheduler.hpp.

◆ get_elem_type_t

template<typename T >
using sycl::_V1::detail::get_elem_type_t = typedef typename get_elem_type<T>::type

Definition at line 41 of file builtins_utils_scalar.hpp.

◆ get_select_opencl_builtin_c_arg_type

template<typename T >
using sycl::_V1::detail::get_select_opencl_builtin_c_arg_type = typedef typename std::conditional_t< sizeof(T) == 1, char, std::conditional_t< sizeof(T) == 2, short, std::conditional_t< (detail::is_contained< T, detail::type_list<long, unsigned long> >::value && (sizeof(T) == 4 || sizeof(T) == 8)), long, std::conditional_t< sizeof(T) == 4, int, std::conditional_t<sizeof(T) == 8, long long, void> >> >>

Definition at line 69 of file builtins_utils_scalar.hpp.

◆ GlobalBufAccessorT

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

Definition at line 92 of file stream.hpp.

◆ GlobalBufPtrType

Definition at line 97 of file stream.hpp.

◆ GlobalOffsetAccessorT

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

Definition at line 101 of file stream.hpp.

◆ GlobalOffsetPtrType

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

Definition at line 106 of file stream.hpp.

◆ head_t

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

Definition at line 19 of file type_list.hpp.

◆ image_allocator

Definition at line 41 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 35 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 123 of file type_traits.hpp.

◆ int_elements_t

template<typename T >
using sycl::_V1::detail::int_elements_t = typedef change_elements_t<int, T>

Definition at line 161 of file builtins_utils_vec.hpp.

◆ internal_rel_ret_t

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

Definition at line 688 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<typename std::remove_cv_t<T> >::value || sycl::detail::is_arithmetic<T>::value>

Definition at line 139 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 112 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 37 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 272 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_v<R> >

Definition at line 267 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 29 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 264 of file type_traits.hpp.

◆ is_genbool

template<typename T >
using sycl::_V1::detail::is_genbool = typedef is_contained<T, gtl::bool_list>

Definition at line 195 of file generic_type_traits.hpp.

◆ is_genchar

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

Definition at line 126 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 106 of file generic_type_traits.hpp.

◆ is_gencrossdouble

Definition at line 100 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 97 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 103 of file generic_type_traits.hpp.

◆ is_gencrossmarray

Definition at line 109 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 53 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 39 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 31 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 46 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 259 of file generic_type_traits.hpp.

◆ is_genfloatptr_marray

template<typename T , access::address_space AddressSpace, access::decorated IsDecorated>
using sycl::_V1::detail::is_genfloatptr_marray = typedef std::bool_constant< is_mgenfloat<T>::value && is_address_space_compliant<multi_ptr<T, AddressSpace, IsDecorated>, gvl::nonconst_address_space_list>::value && (IsDecorated == access::decorated::yes || IsDecorated == access::decorated::no)>

Definition at line 268 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 73 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 70 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 81 of file generic_type_traits.hpp.

◆ is_gengeomarray

template<typename T >
using sycl::_V1::detail::is_gengeomarray = typedef is_contained<T, gtl::marray_geo_list>

Definition at line 79 of file generic_type_traits.hpp.

◆ is_gengeomarrayfloat

Definition at line 76 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 149 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 169 of file generic_type_traits.hpp.

◆ is_geninteger16bit

Definition at line 233 of file generic_type_traits.hpp.

◆ is_geninteger32bit

Definition at line 236 of file generic_type_traits.hpp.

◆ is_geninteger64bit

Definition at line 239 of file generic_type_traits.hpp.

◆ is_geninteger8bit

Definition at line 230 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 244 of file generic_type_traits.hpp.

◆ is_genintptr_marray

template<typename T , access::address_space AddressSpace, access::decorated IsDecorated>
using sycl::_V1::detail::is_genintptr_marray = typedef std::bool_constant< std::is_same_v<T, sycl::marray<marray_element_t<T>, T::size()> > && is_genint<marray_element_t<remove_pointer_t<T> >>::value && is_address_space_compliant<multi_ptr<T, AddressSpace, IsDecorated>, gvl::nonconst_address_space_list>::value && (IsDecorated == access::decorated::yes || IsDecorated == access::decorated::no)>

Definition at line 254 of file generic_type_traits.hpp.

◆ is_genlonglong

Definition at line 161 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 273 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 132 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 197 of file generic_type_traits.hpp.

◆ is_half

template<typename T >
using sycl::_V1::detail::is_half = typedef is_contained<T, gtl::scalar_half_list>

Definition at line 48 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 44 of file generic_type_traits.hpp.

◆ is_igenchar

template<typename T >
using