sycl::_V1::detail Namespace Reference

Namespaces
	__sycl_service_kernel__
	acc_properties
	device_global_map
	enqueue_kernel_launch
	gtl
	gvl
	half_impl
	host_half_impl
	host_pipe_map
	kernel_get_group_info
	pi
	reduction
	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 detail::enable_if_t< std::is_floating_point< T >::value > >
class	atomic_ref_impl< T, IsAspectAtomic64AttrUsed, DefaultOrder, DefaultScope, AddressSpace, typename detail::enable_if_t< std::is_integral< T >::value > >
class	atomic_ref_impl< T, true, DefaultOrder, DefaultScope, AddressSpace, typename detail::enable_if_t< std::is_floating_point< T >::value > >
class	atomic_ref_impl< T, true, DefaultOrder, DefaultScope, AddressSpace, typename detail::enable_if_t< std::is_integral< T >::value > >
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, 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, 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 detail::enable_if_t< std::is_integral< T >::value > >
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	CGCopyToDeviceGlobal
	"Copy to device_global" command group class. More...
class	CGCopyUSM
	"Copy USM" 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	CGInteropTask
class	CGMemset2DUSM
	"Memset 2D USM" command group class. More...
class	CGPrefetchUSM
	"Prefetch USM" 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	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, enable_if_t< is_sgentype< T >::value, T > >
struct	convert_data_type_impl< T, B, 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_intel_mem_channel >
struct	get_device_info_impl< bool, info::device::ext_oneapi_bfloat16_math_functions >
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< 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< id< Dimensions >, info::device::max_work_item_sizes< Dimensions > >
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< 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< 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_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_red_t
struct	get_red_t< accessor< T, AccessorDims, Mode, access::target::device, IsPH, PropList > >
struct	get_red_t< T * >
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
struct	group_barrier_scope
struct	group_barrier_scope< sycl::group< D > >
struct	group_barrier_scope< sycl::sub_group >
class	handler_impl
struct	has_known_identity_impl
struct	HashCStr
class	HostKernel
class	HostKernelBase
class	HostProfilingInfo
	Profiling info for the host execution. More...
class	HostTask
class	if_architecture_helper
class	image_accessor
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, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
struct	interop< backend::ext_oneapi_cuda, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
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, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
struct	interop< backend::ext_oneapi_hip, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
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, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
struct	interop< backend::ext_oneapi_level_zero, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
struct	interop< backend::ext_oneapi_level_zero, accessor< DataT, Dimensions, AccessMode, access::target::image, access::placeholder::false_t > >
struct	interop< backend::ext_oneapi_level_zero, 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, accessor< DataT, Dimensions, AccessMode, access::target::constant_buffer, access::placeholder::false_t > >
struct	interop< backend::opencl, accessor< DataT, Dimensions, AccessMode, access::target::device, access::placeholder::false_t > >
struct	interop< backend::opencl, accessor< DataT, Dimensions, AccessMode, access::target::image, access::placeholder::false_t > >
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_level_zero >
struct	InteropFeatureSupportMap< backend::opencl >
class	InteropTask
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_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_native_op
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
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_type_size_double_of
struct	is_type_size_equal
struct	is_type_size_greater
struct	is_type_size_half_of
struct	is_type_size_less
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	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	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
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< T, enable_if_t< is_contained< T, gtl::scalar_floating_list >::value, T > >
struct	make_larger_impl< T, enable_if_t< is_contained< T, gtl::scalar_signed_integer_list >::value, T > >
struct	make_larger_impl< T, 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, enable_if_t< is_contained< T, gtl::scalar_integer_list >::value, T > >
struct	make_signed_impl< T, enable_if_t< is_contained< T, gtl::vector_integer_list >::value, T > >
struct	make_signed_impl< T, 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_impl
struct	make_unsigned_impl< T, enable_if_t< is_contained< T, gtl::scalar_integer_list >::value, T > >
struct	make_unsigned_impl< T, enable_if_t< is_contained< T, gtl::vector_integer_list >::value, T > >
struct	make_unsigned_impl< T, 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_types
struct	nan_types< T, enable_if_t< is_contained< T, gtl::unsigned_int_list >::value, T > >
struct	nan_types< T, enable_if_t< is_contained< T, gtl::unsigned_long_integer_list >::value, T > >
struct	nan_types< T, enable_if_t< is_contained< T, gtl::unsigned_short_list >::value, T > >
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
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...
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	RelationalReturnType
struct	RelationalTestForSignBitType
struct	RelConverter
struct	RelConverter< T, typename detail::enable_if_t< TryToGetElementType< T >::value > >
struct	RelConverter< T, typename detail::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	RoundedRangeKernel
class	RoundedRangeKernelWithKH
struct	RShift
class	RTDeviceBinaryImage
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 detail::enable_if_t< is_genptr< T >::value &&!std::is_pointer< T >::value > >
struct	select_cl_mptr_or_vector_or_scalar_or_ptr< T, typename detail::enable_if_t<!is_genptr< T >::value||std::is_pointer< T >::value > >
struct	select_cl_vector_or_scalar_or_ptr
struct	select_cl_vector_or_scalar_or_ptr< T, typename detail::enable_if_t< is_vgentype< T >::value > >
struct	select_cl_vector_or_scalar_or_ptr< T, typename detail::enable_if_t<!is_vgentype< T >::value &&!std::is_pointer< T >::value > >
struct	select_cl_vector_or_scalar_or_ptr< T, typename detail::enable_if_t<!is_vgentype< T >::value &&std::is_pointer< T >::value > >
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 detail::enable_if_t< TryToGetVectorT< T >::value > >
struct	TryToGetNumElements< T, typename detail::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< std::byte >
class	UnMapMemObject
	The unmap command removes mapping of host memory onto device memory. More...
class	UpdateHostRequirementCommand
struct	value_list
struct	value_list< T >
struct	value_list< T, Head, Tail... >
struct	vec_helper
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	memory_order = sycl::memory_order
using	memory_scope = sycl::memory_scope
template<memory_order Order>
using	IsValidDefaultOrder = bool_constant< Order==memory_order::relaxed||Order==memory_order::acq_rel||Order==memory_order::seq_cst >
using	EventImplPtr = std::shared_ptr< event_impl >
template<typename DataT >
using	EnableIfOutputPointerT = detail::enable_if_t< std::is_pointer< DataT >::value >
template<typename DataT >
using	EnableIfOutputIteratorT = detail::enable_if_t< !std::is_pointer< DataT >::value >
using	KernelSetId = size_t
template<typename T >
using	is_floatn = is_contained< T, gtl::vector_float_list >
template<typename T >
using	is_genfloatf = is_contained< T, gtl::float_list >
template<typename T >
using	is_svgenfloatf = is_contained< T, gtl::scalar_vector_float_list >
template<typename T >
using	is_doublen = is_contained< T, gtl::vector_double_list >
template<typename T >
using	is_genfloatd = is_contained< T, gtl::double_list >
template<typename T >
using	is_svgenfloatd = is_contained< T, gtl::scalar_vector_double_list >
template<typename T >
using	is_halfn = is_contained< T, gtl::vector_half_list >
template<typename T >
using	is_genfloath = is_contained< T, gtl::half_list >
template<typename T >
using	is_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	marray_element_type = typename T::value_type
template<typename T >
using	is_mgenfloat = bool_constant< std::is_same< T, sycl::marray< marray_element_type< T >, T::size()> >::value &&is_svgenfloat< marray_element_type< 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_gengeohalf = is_contained< T, gtl::geo_half_list >
template<typename T >
using	is_vgengeofloat = is_contained< T, gtl::vector_geo_float_list >
template<typename T >
using	is_vgengeodouble = is_contained< T, gtl::vector_geo_double_list >
template<typename T >
using	is_vgengeohalf = is_contained< T, gtl::vector_geo_half_list >
template<typename T >
using	is_sgengeo = is_contained< T, gtl::scalar_geo_list >
template<typename T >
using	is_vgengeo = is_contained< T, gtl::vector_geo_list >
template<typename T >
using	is_gencrossfloat = is_contained< T, gtl::cross_float_list >
template<typename T >
using	is_gencrossdouble = is_contained< T, gtl::cross_double_list >
template<typename T >
using	is_gencrosshalf = is_contained< T, gtl::cross_half_list >
template<typename T >
using	is_gencross = is_contained< T, gtl::cross_floating_list >
template<typename T >
using	is_charn = is_contained< T, gtl::vector_default_char_list >
template<typename T >
using	is_scharn = is_contained< T, gtl::vector_signed_char_list >
template<typename T >
using	is_ucharn = is_contained< T, gtl::vector_unsigned_char_list >
template<typename T >
using	is_igenchar = is_contained< T, gtl::signed_char_list >
template<typename T >
using	is_ugenchar = is_contained< T, gtl::unsigned_char_list >
template<typename T >
using	is_genchar = is_contained< T, gtl::char_list >
template<typename T >
using	is_shortn = is_contained< T, gtl::vector_signed_short_list >
template<typename T >
using	is_genshort = is_contained< T, gtl::signed_short_list >
template<typename T >
using	is_ushortn = is_contained< T, gtl::vector_unsigned_short_list >
template<typename T >
using	is_ugenshort = is_contained< T, gtl::unsigned_short_list >
template<typename T >
using	is_uintn = is_contained< T, gtl::vector_unsigned_int_list >
template<typename T >
using	is_ugenint = is_contained< T, gtl::unsigned_int_list >
template<typename T >
using	is_intn = is_contained< T, gtl::vector_signed_int_list >
template<typename T >
using	is_genint = is_contained< T, gtl::signed_int_list >
template<typename T >
using	is_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 = bool_constant< is_pointer< T >::value &&is_genint< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
template<typename T >
using	is_genfloatptr = bool_constant< is_pointer< T >::value &&is_genfloat< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
template<typename T >
using	is_genptr = 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 = conditional_t< sizeof(T)==1, T8, conditional_t< sizeof(T)==2, T16, 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 = std::conditional_t< std::is_same< T, std::complex< float > >::value, __spv::complex_float, std::conditional_t< std::is_same< T, std::complex< double > >::value, __spv::complex_double, std::conditional_t< std::is_same< T, std::complex< half > >::value, __spv::complex_half, T > >>
template<typename T >
using	select_cl_scalar_integral_t = conditional_t< std::is_signed< T >::value, select_cl_scalar_integral_signed_t< T >, select_cl_scalar_integral_unsigned_t< T > >
template<typename T >
using	select_cl_scalar_t = conditional_t< std::is_integral< T >::value, select_cl_scalar_integral_t< T >, conditional_t< std::is_floating_point< T >::value, select_cl_scalar_float_t< T >, conditional_t< std::is_same< T, half >::value, sycl::detail::half_impl::BIsRepresentationT, select_cl_scalar_complex_or_T_t< T > >> >
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 = conditional_t< TryToGetVectorT< T >::value, typename TryToGetVectorT< T >::type, 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 = conditional_t< is_vgentype< T >::value, make_singed_integer_t< T >, int >
template<typename T >
using	internal_host_rel_ret_t = common_rel_ret_t< T >
template<typename T >
using	internal_rel_ret_t = typename RelationalReturnType< T >::type
template<typename T >
using	rel_sign_bit_test_ret_t = typename RelationalTestForSignBitType< T >::return_type
template<typename T >
using	rel_sign_bit_test_arg_t = typename RelationalTestForSignBitType< T >::argument_type
template<typename T >
using	IsValidCoordType = typename is_contained< T, type_list< opencl::cl_int, opencl::cl_float, std::int32_t, float > >::type
using	int64_t = conditional< sizeof(long)==8, long, long long >::type
using	OSModuleHandle = intptr_t
	Uniquely identifies an operating system module (executable or a dynamic library) More...
template<bool B, class T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
template<bool B, class T , class F >
using	conditional_t = typename std::conditional< B, T, F >::type
template<typename T >
using	remove_const_t = typename std::remove_const< T >::type
template<typename T >
using	remove_cv_t = typename std::remove_cv< T >::type
template<typename T >
using	remove_reference_t = typename std::remove_reference< T >::type
template<typename T >
using	add_pointer_t = typename std::add_pointer< T >::type
template<bool V>
using	bool_constant = std::integral_constant< bool, V >
template<class... >
using	void_t = void
template<typename T >
using	allocator_value_type_t = typename std::allocator_traits< T >::value_type
template<typename T >
using	allocator_pointer_t = typename std::allocator_traits< T >::pointer
template<typename T >
using	iterator_category_t = typename std::iterator_traits< T >::iterator_category
template<typename T >
using	iterator_value_type_t = typename std::iterator_traits< T >::value_type
template<typename T >
using	iterator_pointer_t = typename std::iterator_traits< T >::pointer
template<typename T >
using	iterator_to_const_type_t = std::is_const< typename std::remove_pointer< iterator_pointer_t< T > >::type >
template<typename T >
using	output_iterator_requirements = void_t< iterator_category_t< T >, decltype(*std::declval< T >()=std::declval< iterator_value_type_t< T > >())>
template<typename DataT >
using	sycl_memory_object_allocator = aligned_allocator< DataT >
template<std::size_t I, class T >
using	tuple_element_t = typename tuple_element< I, T >::type
template<typename T >
using	head_t = typename T::head
template<typename T >
using	tail_t = typename T::tail
using	empty_type_list = type_list<>
template<access::address_space... Values>
using	address_space_list = value_list< access::address_space, Values... >
template<access::address_space AddressSpace, typename ValueList >
using	is_one_of_spaces = is_contained_value< access::address_space, AddressSpace, ValueList >
template<typename TypeList , template< typename, typename > class Comp, typename T >
using	find_type_t = typename find_type< TypeList, Comp, T >::type
template<typename TypeList , typename T >
using	find_same_size_type_t = find_type_t< TypeList, is_type_size_equal, T >
template<typename TypeList , typename T >
using	find_smaller_type_t = find_type_t< TypeList, is_type_size_less, T >
template<typename TypeList , typename T >
using	find_larger_type_t = find_type_t< TypeList, is_type_size_greater, T >
template<typename TypeList , typename T >
using	find_twice_as_small_type_t = find_type_t< TypeList, is_type_size_half_of, T >
template<typename TypeList , typename T >
using	find_twice_as_large_type_t = find_type_t< TypeList, is_type_size_double_of, T >
using	uuid_type = std::array< unsigned char, 16 >
template<typename T , typename R >
using	copy_cv_qualifiers_t = typename copy_cv_qualifiers< T, R >::type
template<int V>
using	int_constant = std::integral_constant< int, V >
template<typename T >
using	vector_element_impl_t = typename vector_element_impl< T >::type
template<class T >
using	vector_element_t = typename vector_element< T >::type
template<typename T , typename B >
using	change_base_type_t = typename change_base_type< T, B >::type
template<typename T >
using	make_signed_impl_t = typename make_signed_impl< T, T >::type
template<typename T >
using	make_signed_t = typename make_signed< T >::type
template<typename T >
using	make_unsigned_impl_t = typename make_unsigned_impl< T, T >::type
template<typename T >
using	make_unsigned_t = typename make_unsigned< T >::type
template<typename T , int N, template< typename > class S>
using	is_gen_based_on_type_sizeof = 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 > >
template<typename T , typename BinaryOperation >
using	is_plus = std::integral_constant< bool, std::is_same< BinaryOperation, sycl::plus< T > >::value||std::is_same< BinaryOperation, sycl::plus< void > >::value >
template<typename T , typename BinaryOperation >
using	is_multiplies = std::integral_constant< bool, std::is_same< BinaryOperation, sycl::multiplies< T > >::value||std::is_same< BinaryOperation, sycl::multiplies< void > >::value >
template<typename T >
using	is_arithmetic_or_complex = std::integral_constant< bool, sycl::detail::is_complex< T >::value||sycl::detail::is_arithmetic< T >::value >
template<typename T , typename BinaryOperation >
using	is_plus_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 detail::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 = bool_constant< std::is_same< BinaryOperation, sycl::plus< T > >::value||std::is_same< BinaryOperation, sycl::plus< void > >::value >
template<typename T , class BinaryOperation >
using	IsMultiplies = bool_constant< std::is_same< BinaryOperation, sycl::multiplies< T > >::value||std::is_same< BinaryOperation, sycl::multiplies< void > >::value >
template<typename T , class BinaryOperation >
using	IsMinimum = bool_constant< std::is_same< BinaryOperation, sycl::minimum< T > >::value||std::is_same< BinaryOperation, sycl::minimum< void > >::value >
template<typename T , class BinaryOperation >
using	IsMaximum = bool_constant< std::is_same< BinaryOperation, sycl::maximum< T > >::value||std::is_same< BinaryOperation, sycl::maximum< void > >::value >
template<typename T , class BinaryOperation >
using	IsBitAND = bool_constant< std::is_same< BinaryOperation, sycl::bit_and< T > >::value||std::is_same< BinaryOperation, sycl::bit_and< void > >::value >
template<typename T , class BinaryOperation >
using	IsBitOR = bool_constant< std::is_same< BinaryOperation, sycl::bit_or< T > >::value||std::is_same< BinaryOperation, sycl::bit_or< void > >::value >
template<typename T , class BinaryOperation >
using	IsBitXOR = bool_constant< std::is_same< BinaryOperation, sycl::bit_xor< T > >::value||std::is_same< BinaryOperation, sycl::bit_xor< void > >::value >
template<typename T , class BinaryOperation >
using	IsLogicalAND = bool_constant< std::is_same< BinaryOperation, sycl::logical_and< T > >::value||std::is_same< BinaryOperation, sycl::logical_and< void > >::value >
template<typename T , class BinaryOperation >
using	IsLogicalOR = bool_constant< std::is_same< BinaryOperation, sycl::logical_or< T > >::value||std::is_same< BinaryOperation, sycl::logical_or< void > >::value >
template<typename T >
using	isComplex = bool_constant< std::is_same< T, std::complex< float > >::value||std::is_same< T, std::complex< double > >::value >
template<typename T , class BinaryOperation >
using	IsZeroIdentityOp = 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 = 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 = bool_constant<(is_genbool< T >::value||is_geninteger< T >::value) &&IsBitAND< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsMinimumIdentityOp = 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 = 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 = bool_constant< IsLogicalOR< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsTrueIdentityOp = bool_constant< IsLogicalAND< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsKnownIdentityOp = 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 = 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 = 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 = 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< KernelName, auto_name >::value, 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< KernelName, auto_name >::value, auto_name, MainOrAux< KernelName, Strategy, Ts... > >
	A helper to pass undefined (sycl::detail::auto_name) names unmodified. More...
using	FmtFlags = unsigned int
template<class F , class T = void>
using	EnableIfFP = typename detail::enable_if_t< std::is_same< F, float >::value||std::is_same< F, double >::value||std::is_same< F, half >::value, T >
using	GlobalBufAccessorT = accessor< char, 1, sycl::access::mode::read_write, sycl::access::target::global_buffer, sycl::access::placeholder::false_t >
using	GlobalBufPtrType = typename detail::DecoratedType< char, GlobalBufAS >::type *
using	GlobalOffsetAccessorT = accessor< unsigned, 1, sycl::access::mode::atomic, sycl::access::target::global_buffer, sycl::access::placeholder::false_t >
using	GlobalOffsetPtrType = typename detail::DecoratedType< unsigned, GlobalBufAS >::type *
template<typename T >
using	EnableIfSwizzleVec = typename detail::enable_if_t< IsSwizzleOp< T >::value, typename IsSwizzleOp< T >::Type >
template<typename DataT >
using	rel_t = typename detail::conditional_t< sizeof(DataT)==sizeof(opencl::cl_char), opencl::cl_char, typename detail::conditional_t< sizeof(DataT)==sizeof(opencl::cl_short), opencl::cl_short, typename detail::conditional_t< sizeof(DataT)==sizeof(opencl::cl_int), opencl::cl_int, typename detail::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< T >::value &&std::is_integral< R >::value >
template<typename T , typename R >
using	is_sint_to_sint = std::integral_constant< bool, is_sigeninteger< T >::value &&is_sigeninteger< R >::value >
template<typename T , typename R >
using	is_uint_to_uint = std::integral_constant< bool, is_sugeninteger< T >::value &&is_sugeninteger< R >::value >
template<typename T , typename R >
using	is_sint_to_from_uint = std::integral_constant< bool,(is_sugeninteger< T >::value &&is_sigeninteger< R >::value)||(is_sigeninteger< T >::value &&is_sugeninteger< R >::value)>
template<typename T , typename R >
using	is_sint_to_float = std::integral_constant< bool, std::is_integral< T >::value &&!(std::is_unsigned< T >::value) &&detail::is_floating_point< R >::value >
template<typename T , typename R >
using	is_uint_to_float = std::integral_constant< bool, std::is_unsigned< T >::value &&detail::is_floating_point< R >::value >
template<typename T , typename R >
using	is_int_to_float = std::integral_constant< bool, std::is_integral< T >::value &&detail::is_floating_point< R >::value >
template<typename T , typename R >
using	is_float_to_int = std::integral_constant< bool, detail::is_floating_point< T >::value &&std::is_integral< R >::value >
template<typename T , typename R >
using	is_float_to_float = std::integral_constant< bool, detail::is_floating_point< T >::value &&detail::is_floating_point< R >::value >
template<typename T >
using	is_standard_type = std::integral_constant< bool, detail::is_sgentype< T >::value >
template<typename _IN , typename T8 , typename T16 , typename T32 , typename T64 >
using	select_apply_cl_t = conditional_t< sizeof(_IN)==1, T8, conditional_t< sizeof(_IN)==2, T16, conditional_t< sizeof(_IN)==4, T32, T64 > >>
using	Requirement = AccessorImplHost
using	DeviceDescT = std::map< std::string, std::string >
using	AllowListParsedT = std::vector< DeviceDescT >
using	PlatformImplPtr = std::shared_ptr< detail::platform_impl >
using	ContextImplPtr = std::shared_ptr< sycl::detail::context_impl >
using	QueueImplPtr = std::shared_ptr< sycl::detail::queue_impl >
using	LockGuard = std::lock_guard< SpinLock >
using	image_allocator = aligned_allocator< byte >
using	ProgramImplPtr = std::shared_ptr< program_impl >
using	DeviceImplPtr = std::shared_ptr< device_impl >
using	StreamImplPtr = std::shared_ptr< detail::stream_impl >
using	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	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, LastKnownDataLessPropKind = 18,   DataLessPropKindSize = 32 }
enum	PropWithDataKind {   BufferUseMutex = 0, BufferContextBound = 1, ImageUseMutex = 2, ImageContextBound = 3,   BufferMemChannel = 4, AccPropBufferLocation = 5, QueueComputeIndex = 6, PropWithDataKindSize = 7 }
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)
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)
static std::memory_order	getStdMemoryOrder (__spv::MemorySemanticsMask::Flag)
constexpr memory_order	getLoadOrder (memory_order order)
platform	make_platform (pi_native_handle NativeHandle, backend Backend)
device	make_device (pi_native_handle NativeHandle, backend Backend)
context	make_context (pi_native_handle NativeHandle, const async_handler &Handler, backend Backend)
queue	make_queue (pi_native_handle NativeHandle, const context &TargetContext, const device *TargetDevice, bool KeepOwnership, const async_handler &Handler, backend Backend)
event	make_event (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
event	make_event (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, backend Backend)
kernel	make_kernel (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
kernel	make_kernel (const context &TargetContext, const kernel_bundle< bundle_state::executable > &KernelBundle, pi_native_handle NativeKernelHandle, bool KeepOwnership, backend Backend)
std::shared_ptr< detail::kernel_bundle_impl >	make_kernel_bundle (pi_native_handle NativeHandle, const context &TargetContext, bundle_state State, backend Backend)
std::shared_ptr< detail::kernel_bundle_impl >	make_kernel_bundle (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, bundle_state State, backend Backend)
template<typename To , typename From >
To	bit_cast (const From &from) noexcept
template<typename T , int Dimensions, typename AllocatorT >
buffer< T, Dimensions, AllocatorT, void >	make_buffer_helper (pi_native_handle Handle, const context &Ctx, event Evt={}, bool OwnNativeHandle=true)
template<backend BackendName, typename DataT , int Dimensions, typename Allocator >
auto	get_native_buffer (const buffer< DataT, Dimensions, Allocator, void > &Obj) -> backend_return_t< BackendName, buffer< DataT, Dimensions, Allocator, void >>
template<class T , size_t N>
vec< T, 2 >	to_vec2 (marray< T, N > x, size_t start)
template<typename F , typename... Args>
static constexpr bool	check_kernel_lambda_takes_args ()
template<typename KernelType , typename LambdaArgType , typename std::enable_if_t< std::is_same< LambdaArgType, void >::value > * = nullptr>
constexpr bool	isKernelLambdaCallableWithKernelHandlerImpl ()
template<typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType >::value >	runKernelWithoutArg (KernelType KernelName)
template<typename KernelType >
std::enable_if_t<!KernelLambdaHasKernelHandlerArgT< KernelType >::value >	runKernelWithoutArg (KernelType KernelName)
template<typename ArgType , typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value >	runKernelWithArg (KernelType KernelName, ArgType Arg)
template<typename ArgType , typename KernelType >
std::enable_if_t< !KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value >	runKernelWithArg (KernelType KernelName, ArgType Arg)
const char *	stringifyErrorCode (pi_int32 error)
static std::string	codeToString (pi_int32 code)
template<class Obj >
decltype(Obj::impl)	getSyclObjImpl (const Obj &SyclObject)
template<class T >
detail::add_pointer_t< typename decltype(T::impl)::element_type >	getRawSyclObjImpl (const T &SyclObject)
template<class T >
T	createSyclObjFromImpl (decltype(T::impl) ImplObj)
constexpr size_t	getNextPowerOfTwoHelper (size_t Var, size_t Offset)
constexpr size_t	getNextPowerOfTwo (size_t Var)
template<int Dims, template< int > class T, template< int > class U>
size_t	getLinearIndex (const T< Dims > &Index, const U< Dims > &Range)
template<int NewDim, int DefaultValue, template< int > class T, int OldDim>
static T< NewDim >	convertToArrayOfN (T< OldDim > OldObj)
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_target >	Parse_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 detail::enable_if_t<TryToGetPointerT<From>::value>>
To	ConvertNonVectorType (From &t)
template<typename To , typename From >
To	ConvertNonVectorType (From *t)
template<typename To , typename From >
detail::enable_if_t<!TryToGetPointerT< From >::value, To >	ConvertNonVectorType (From &t)
template<typename FROM , typename TO >
detail::enable_if_t< is_vgentype< FROM >::value &&is_vgentype< TO >::value &&sizeof(TO)==sizeof(FROM), TO >	convertDataToType (FROM t)
template<typename FROM , typename TO >
detail::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)
std::vector< RT::PiEvent >	getOrWaitEvents (std::vector< sycl::event > DepEvents, std::shared_ptr< sycl::detail::context_impl > Context)
void	waitEvents (std::vector< sycl::event > DepEvents)
template<typename T >
T *	declptr ()
template<typename T >
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	dim_loop_impl (std::integer_sequence< size_t, Inds... >, F &&f)
template<size_t count, class F >
void	dim_loop (F &&f)
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, T >	UnnormalizeCoordinates (const T &Coords, const range< 3 > &Range)
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, vec< T, 2 > >	UnnormalizeCoordinates (const vec< T, 2 > &Coords, const range< 3 > &Range)
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, vec< T, 4 > >	UnnormalizeCoordinates (const vec< T, 4 > &Coords, const range< 3 > &Range)
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, float4 >	convertToFloat4 (T Coords)
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, float4 >	convertToFloat4 (vec< T, 2 > Coords)
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, float4 >	convertToFloat4 (vec< T, 4 > Coords)
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, size_t >	getImageOffset (const T &Coords, const id< 3 >, const uint8_t ElementSize)
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, size_t >	getImageOffset (const vec< T, 2 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, 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, const sampler &Smpl, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, uint8_t ElementSize)
template<auto & SpecName>
const char *	get_spec_constant_symbolic_ID_impl ()
template<auto & SpecName>
const char *	get_spec_constant_symbolic_ID ()
void	memcpy (void *Dst, const void *Src, size_t Size)
template<sycl::backend BE>
void *	getPluginOpaqueData (void *opaquedata_arg)
template<typename T , typename... Ts, std::size_t... Is>
std::tuple< Ts... >	get_tuple_tail_impl (const std::tuple< T, Ts... > &Tuple, const std::index_sequence< Is... > &)
template<typename T , typename... Ts>
std::tuple< Ts... >	get_tuple_tail (const std::tuple< T, Ts... > &Tuple)
template<typename... Ts>
constexpr tuple< Ts... >	make_tuple (Ts... Args)
template<typename... Ts>
auto	tie (Ts &...Args)
auto	getDeviceComparisonLambda ()
template<typename LastT >
void	fill_aspect_vector (std::vector< aspect > &V, LastT L)
template<typename FirstT , typename... OtherTs>
void	fill_aspect_vector (std::vector< aspect > &V, FirstT F, OtherTs... O)
device	select_device (const DSelectorInvocableType &DeviceSelectorInvocable)
device	select_device (const DSelectorInvocableType &DeviceSelectorInvocable, const context &SyclContext)
void	defaultAsyncHandler (exception_list Exceptions)
template<ext::oneapi::experimental::architecture... Archs>
constexpr static bool	allowable_aot_mode ()
template<ext::oneapi::experimental::architecture... Archs>
constexpr static bool	device_architecture_is ()
template<typename CVT , access::address_space Space, access::decorated IsDecorated, typename T = std::remove_cv_t<CVT>>
multi_ptr< T, Space, IsDecorated >	GetUnqualMultiPtr (const multi_ptr< CVT, Space, IsDecorated > &Mptr)
static void	workGroupBarrier ()
template<int Dimensions>
id< Dimensions >	linear_id_to_id (range< Dimensions >, size_t linear_id)
template<>
id< 1 >	linear_id_to_id (range< 1 >, size_t linear_id)
template<>
id< 2 >	linear_id_to_id (range< 2 > r, size_t linear_id)
template<>
id< 3 >	linear_id_to_id (range< 3 > r, size_t linear_id)
template<typename Group >
size_t	get_local_linear_range (Group g)
template<>
size_t	get_local_linear_range< group< 1 > > (group< 1 > g)
template<>
size_t	get_local_linear_range< group< 2 > > (group< 2 > g)
template<>
size_t	get_local_linear_range< group< 3 > > (group< 3 > g)
template<>
size_t	get_local_linear_range< ext::oneapi::sub_group > (ext::oneapi::sub_group g)
template<typename Group >
Group::linear_id_type	get_local_linear_id (Group g)
template<>
ext::oneapi::sub_group::linear_id_type	get_local_linear_id< ext::oneapi::sub_group > (ext::oneapi::sub_group g)
template<typename T , class BinaryOperation >
constexpr detail::enable_if_t<(is_complex< T >::value &&is_plus< T, BinaryOperation >::value), T >	identity_for_ga_op ()
template<typename T , class BinaryOperation >
constexpr detail::enable_if_t<(is_complex< T >::value &&is_multiplies< T, BinaryOperation >::value), T >	identity_for_ga_op ()
template<typename T , class BinaryOperation >
constexpr detail::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 >
T	cast_if_host_half (T val)
float	cast_if_host_half (half_impl::half val)
template<typename RetType , typename Func , typename Arg >
static Arg	member_ptr_helper (RetType(Func::*)(Arg) const)
template<typename F , typename SuggestedArgType >
SuggestedArgType	argument_helper (...)
template<int Dims, typename T >
detail::enable_if_t< std::is_same< T, range< Dims > >::value||std::is_same< T, id< Dims > >::value >	checkValueRange (const T &V)
template<int Dims>
void	checkValueRange (const range< Dims > &R, const id< Dims > &O)
template<int Dims, typename T >
detail::enable_if_t< std::is_same< T, nd_range< Dims > >::value >	checkValueRange (const T &V)
template<int dimensions>
size_t	getOffsetForId (range< dimensions > Range, id< dimensions > Id, id< dimensions > Offset)
id< 1 >	getDelinearizedId (const range< 1 > &, size_t Index)
id< 2 >	getDelinearizedId (const range< 2 > &Range, size_t Index)
id< 3 >	getDelinearizedId (const range< 3 > &Range, size_t Index)
kernel_id	get_kernel_id_impl (std::string KernelName)
detail::KernelBundleImplPtr	get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State)
const std::vector< device >	removeDuplicateDevices (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_impl >	join_impl (const std::vector< detail::KernelBundleImplPtr > &Bundles, bundle_state State)
std::shared_ptr< detail::kernel_bundle_impl >	compile_impl (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList)
std::vector< sycl::device >	find_device_intersection (const std::vector< kernel_bundle< bundle_state::object >> &ObjectBundles)
std::shared_ptr< detail::kernel_bundle_impl >	link_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_impl >	build_impl (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList)
std::vector< memory_order >	readMemoryOrderBitfield (pi_memory_order_capabilities bits)
std::vector< memory_scope >	readMemoryScopeBitfield (pi_memory_scope_capabilities bits)
static constexpr std::memory_order	getStdMemoryOrder (sycl::memory_order order)
template<typename... Ts>
ReduTupleT< Ts... >	makeReduTupleT (Ts... Elements)
size_t	reduGetMaxWGSize (std::shared_ptr< queue_impl > Queue, size_t LocalMemBytesPerWorkItem)
size_t	reduComputeWGSize (size_t NWorkItems, size_t MaxWGSize, size_t &NWorkGroups)
size_t	reduGetPreferredWGSize (std::shared_ptr< queue_impl > &Queue, size_t LocalMemBytesPerWorkItem)
template<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...
static 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<typename... Reductions, typename... OutAccT, typename... LocalAccT, typename... BOPsT, typename... Ts, size_t... Is>
void	writeReduSumsToOutAccs (bool IsOneWG, 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... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... Ts, typename... BOPsT, size_t... Is>
void	reduCGFuncImplScalar (bool IsOneWG, nd_item< Dims > NDIt, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, std::tuple< ReducerT... > &ReducersTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... > ReduIndices)
	All scalar reductions are processed together; there is one loop of log2(N) steps, and each reduction uses its own storage. More...
template<typename Reduction , int Dims, typename LocalAccT , typename OutAccT , typename ReducerT , typename BOPT >
void	reduCGFuncImplArrayHelper (bool IsOneWG, nd_item< Dims > NDIt, LocalAccT LocalReds, OutAccT Out, ReducerT &Reducer, BOPT BOp, bool IsInitializeToIdentity)
	Each array reduction is processed separately. More...
template<typename... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... BOPsT, size_t... Is>
void	reduCGFuncImplArray (bool IsOneWG, 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<typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void	reduAuxCGFuncImplScalar (bool IsOneWG, 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<typename Reduction , int Dims, typename LocalAccT , typename InAccT , typename OutAccT , typename T , typename BOPT >
void	reduAuxCGFuncImplArrayHelper (bool IsOneWG, 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<typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void	reduAuxCGFuncImplArray (bool IsOneWG, 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...
template<typename KernelName , reduction::strategy Strategy, int Dims, typename PropertiesT , typename... RestT>
void	reduction_parallel_for (handler &CGH, nd_range< Dims > NDRange, PropertiesT Properties, RestT... Rest)
uint32_t	reduGetMaxNumConcurrentWorkGroups (std::shared_ptr< queue_impl > Queue)
template<typename KernelName , reduction::strategy Strategy, int Dims, typename PropertiesT , typename... RestT>
void	reduction_parallel_for (handler &CGH, range< Dims > Range, PropertiesT Properties, RestT... Rest)
unsigned	GetFlushBufOffset (const GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
void	SetFlushBufOffset (GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset, unsigned Offset)
void	write (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const char *Str, unsigned Len, unsigned Padding=0)
void	reverseBuf (char *Buf, unsigned Len)
template<typename T >
std::make_unsigned< T >::type	getAbsVal (const T Val, const int Base)
char	digitToChar (const int Digit)
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, unsigned >	integralToBase (T Val, int Base, char *Digits)
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, unsigned >	ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
unsigned	append (char *Dst, const char *Src)
template<typename T >
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 >
detail::enable_if_t< std::is_same< T, half >::value, unsigned >	checkForInfNan (char *Buf, T Val)
template<typename T >
EnableIfFP< T, unsigned >	floatingPointToDecStr (T AbsVal, char *Digits, int Precision, bool IsSci)
template<typename T >
EnableIfFP< T, unsigned >	ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
template<typename T >
detail::enable_if_t< std::is_integral< T >::value >	writeIntegral (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, const T &Val)
template<typename T >
EnableIfFP< T >	writeFloatingPoint (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const T &Val)
bool	updateOffset (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, unsigned Size, unsigned &Cur)
void	flushBuffer (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
template<typename T , int VecLength>
detail::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>
detail::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>
detail::enable_if_t<(VecLength==3), unsigned >	VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
template<typename T , int VecLength>
void	writeVec (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const vec< T, VecLength > &Vec)
template<int ArrayLength>
unsigned	ArrayToStr (char *Buf, const array< ArrayLength > &Arr)
template<int ArrayLength>
void	writeArray (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const array< ArrayLength > &Arr)
template<int Dimensions>
void	writeItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const item< Dimensions > &Item)
template<int Dimensions>
void	writeNDRange (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_range< Dimensions > &ND_Range)
template<int Dimensions>
void	writeNDItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_item< Dimensions > &ND_Item)
template<int Dimensions>
void	writeGroup (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const group< Dimensions > &Group)
template<int Dimensions>
unsigned	ItemToStr (char *Buf, const item< Dimensions, false > &Item)
template<int Dimensions>
void	writeHItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const h_item< Dimensions > &HItem)
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t< std::is_same< T, R >::value, R >	convertImpl (T Value)
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t<!std::is_same< T, R >::value &&(is_int_to_int< T, R >::value||is_int_to_float< T, R >::value||is_float_to_float< T, R >::value), R >	convertImpl (T Value)
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::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 plugin &	getPlugin (backend Backend)
queue	make_queue_impl (pi_native_handle NativeHandle, const context &Context, RT::PiDevice Device, bool KeepOwnership, const async_handler &Handler, backend Backend)
void	constructorNotification (void *BufferObj, void *AccessorObj, sycl::access::target Target, sycl::access::mode Mode, const detail::code_location &CodeLoc)
AllowListParsedT	parseAllowList (const std::string &AllowListRaw)
bool	deviceIsAllowed (const DeviceDescT &DeviceDesc, const AllowListParsedT &AllowListParsed)
void	applyAllowList (std::vector< RT::PiDevice > &PiDevices, RT::PiPlatform PiPlatform, const plugin &Plugin)
template<class T >
backend	getImplBackend (const T &Impl)
static void	initValue (const char *Key, const char *Value)
void	readConfig (bool ForceInitialization)
void	dumpConfig ()
const std::array< std::pair< std::string, info::device_type >, 6 > &	getSyclDeviceTypeMap ()
const std::array< std::pair< std::string, backend >, 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::device >	context_impl::get_info< info::context::devices > () const
template<>
std::vector< sycl::memory_order >	context_impl::get_info< info::context::atomic_memory_order_capabilities > () const
template<>
std::vector< sycl::memory_scope >	context_impl::get_info< info::context::atomic_memory_scope_capabilities > () const
template<>
std::vector< sycl::memory_order >	context_impl::get_info< info::context::atomic_fence_order_capabilities > () const
template<>
std::vector< sycl::memory_scope >	context_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 (RT::PiContext Ctx, const plugin &Plugin)
std::ostream &	operator<< (std::ostream &Out, const DeviceBinaryProperty &P)
std::vector< std::string_view >	tokenize (const std::string_view &Filter, const std::string &Delim)
static backend	Parse_ODS_Backend (const std::string_view &BackendStr, const std::string_view &FullEntry)
static void	Parse_ODS_Device (ods_target &Target, const std::string_view &DeviceStr)
std::vector< info::fp_config >	read_fp_bitfield (pi_device_fp_config bits)
std::vector< info::partition_affinity_domain >	read_domain_bitfield (pi_device_affinity_domain bits)
std::vector< info::execution_capability >	read_execution_bitfield (pi_device_exec_capabilities bits)
std::string	affinityDomainToString (info::partition_affinity_domain AffinityDomain)
std::string	get_device_info_string (RT::PiDevice dev, RT::PiDeviceInfo InfoCode, const plugin &Plugin)
static bool	is_sycl_partition_property (info::partition_property PP)
template<int Dimensions>
id< Dimensions >	construct_id (size_t *values)=delete
template<>
id< 1 >	construct_id< 1 > (size_t *values)
template<>
id< 2 >	construct_id< 2 > (size_t *values)
template<>
id< 3 >	construct_id< 3 > (size_t *values)
template<typename Param >
Param::return_type	get_device_info (RT::PiDevice dev, const plugin &Plugin)
template<typename Param >
Param::return_type	get_device_info_host ()=delete
template<>
info::device_type	get_device_info_host< info::device::device_type > ()
template<>
uint32_t	get_device_info_host< info::device::vendor_id > ()
template<>
uint32_t	get_device_info_host< info::device::max_compute_units > ()
template<>
uint32_t	get_device_info_host< info::device::max_work_item_dimensions > ()
template<>
id< 1 >	get_device_info_host< info::device::max_work_item_sizes< 1 > > ()
template<>
id< 2 >	get_device_info_host< info::device::max_work_item_sizes< 2 > > ()
template<>
id< 3 >	get_device_info_host< info::device::max_work_item_sizes< 3 > > ()
template<>
constexpr size_t	get_device_info_host< ext::oneapi::experimental::info::device::max_global_work_groups > ()
template<>
id< 1 >	get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 1 > > ()
template<>
id< 2 >	get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 2 > > ()
template<>
id< 3 >	get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 3 > > ()
template<>
constexpr size_t	get_device_info_host< info::device::ext_oneapi_max_global_work_groups > ()
template<>
id< 1 >	get_device_info_host< info::device::ext_oneapi_max_work_groups_1d > ()
template<>
id< 2 >	get_device_info_host< info::device::ext_oneapi_max_work_groups_2d > ()
template<>
id< 3 >	get_device_info_host< info::device::ext_oneapi_max_work_groups_3d > ()
template<>
size_t	get_device_info_host< info::device::max_work_group_size > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_char > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_short > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_int > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_long > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_float > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_double > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_half > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_char > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_short > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_int > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_long > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_float > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_double > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_half > ()
template<>
uint32_t	get_device_info_host< info::device::max_clock_frequency > ()
template<>
uint32_t	get_device_info_host< info::device::address_bits > ()
template<>
uint64_t	get_device_info_host< info::device::global_mem_size > ()
template<>
uint64_t	get_device_info_host< info::device::max_mem_alloc_size > ()
template<>
bool	get_device_info_host< info::device::image_support > ()
template<>
bool	get_device_info_host< info::device::atomic64 > ()
template<>
std::vector< memory_order >	get_device_info_host< info::device::atomic_memory_order_capabilities > ()
template<>
std::vector< memory_order >	get_device_info_host< info::device::atomic_fence_order_capabilities > ()
template<>
std::vector< memory_scope >	get_device_info_host< info::device::atomic_memory_scope_capabilities > ()
template<>
std::vector< memory_scope >	get_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_config >	get_device_info_host< info::device::half_fp_config > ()
template<>
std::vector< info::fp_config >	get_device_info_host< info::device::single_fp_config > ()
template<>
std::vector< info::fp_config >	get_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_capability >	get_device_info_host< info::device::execution_capabilities > ()
template<>
bool	get_device_info_host< info::device::queue_profiling > ()
template<>
std::vector< kernel_id >	get_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_property >	get_device_info_host< info::device::partition_properties > ()
template<>
std::vector< info::partition_affinity_domain >	get_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<>
uint64_t	event_impl::get_profiling_info< info::event_profiling::command_submit > ()
template<>
uint64_t	event_impl::get_profiling_info< info::event_profiling::command_start > ()
template<>
uint64_t	event_impl::get_profiling_info< info::event_profiling::command_end > ()
template<>
uint32_t	event_impl::get_info< info::event::reference_count > ()
template<>
info::event_command_status	event_impl::get_info< info::event::command_execution_status > ()
static uint64_t	getTimestamp ()
template<typename Param >
Param::return_type	get_event_profiling_info (RT::PiEvent Event, const plugin &Plugin)
template<typename Param >
Param::return_type	get_event_info (RT::PiEvent Event, const plugin &Plugin)
static void	enableOnCrashStackPrinting ()
void	shutdown ()
	__attribute__ ((destructor(110))) static void syclUnload()
std::vector< RT::PiEvent >	getOrWaitEvents (std::vector< sycl::event > DepEvents, ContextImplPtr Context)
template<typename Param >
static bool	checkImageValueRange (const std::vector< device > &Devices, const size_t Value)
template<typename T , typename... Args>
static bool	checkAnyImpl (T)
template<typename ValT , typename VarT , typename... Args>
static bool	checkAnyImpl (ValT Value, VarT Variant, Args... Arguments)
template<typename T , typename... Args>
static bool	checkAny (const T Value, Args... Arguments)
uint8_t	getImageNumberChannels (image_channel_order Order)
uint8_t	getImageElementSize (uint8_t NumChannels, image_channel_type Type)
RT::PiMemImageChannelOrder	convertChannelOrder (image_channel_order Order)
image_channel_order	convertChannelOrder (RT::PiMemImageChannelOrder Order)
RT::PiMemImageChannelType	convertChannelType (image_channel_type Type)
image_channel_type	convertChannelType (RT::PiMemImageChannelType Type)
template<typename T >
static void	getImageInfo (const ContextImplPtr Context, RT::PiMemImageInfo Info, T &Dest, RT::PiMem InteropMemObject)
static bool	checkAllDevicesAreInContext (const std::vector< device > &Devices, const context &Context)
static bool	checkAllDevicesHaveAspect (const std::vector< device > &Devices, aspect Aspect)
template<>
context	kernel_impl::get_info< info::kernel::context > () const
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, std::string >::value, std::string >::type	get_kernel_info (RT::PiKernel Kernel, const plugin &Plugin)
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, uint32_t >::value, uint32_t >::type	get_kernel_info (RT::PiKernel Kernel, const plugin &Plugin)
template<typename Param >
std::enable_if< IsSubGroupInfo< Param >::value >::type	get_kernel_device_specific_info_helper (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin, void *Result, size_t Size)
template<typename Param >
std::enable_if<!IsSubGroupInfo< Param >::value >::type	get_kernel_device_specific_info_helper (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin, void *Result, size_t Size)
template<typename Param >
std::enable_if< !std::is_same< typename Param::return_type, sycl::range< 3 > >::value, typename Param::return_type >::type	get_kernel_device_specific_info (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin)
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, sycl::range< 3 > >::value, sycl::range< 3 > >::type	get_kernel_device_specific_info (RT::PiKernel Kernel, RT::PiDevice Device, const plugin &Plugin)
template<typename Param >
uint32_t	get_kernel_device_specific_info_with_input (RT::PiKernel Kernel, RT::PiDevice Device, sycl::range< 3 > In, const plugin &Plugin)
template<typename Param >
Param::return_type	get_kernel_device_specific_info_host (const sycl::device &Device)=delete
template<>
sycl::range< 3 >	get_kernel_device_specific_info_host< info::kernel_device_specific::global_work_size > (const sycl::device &)
template<>
size_t	get_kernel_device_specific_info_host< info::kernel_device_specific::work_group_size > (const sycl::device &Dev)
template<>
sycl::range< 3 >	get_kernel_device_specific_info_host< info::kernel_device_specific::compile_work_group_size > (const sycl::device &)
template<>
size_t	get_kernel_device_specific_info_host< info::kernel_device_specific::preferred_work_group_size_multiple > (const sycl::device &Dev)
template<>
size_t	get_kernel_device_specific_info_host< info::kernel_device_specific::private_mem_size > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::ext_codeplay_num_regs > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::max_num_sub_groups > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::max_sub_group_size > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::compile_num_sub_groups > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::compile_sub_group_size > (const sycl::device &)
void	memBufferCreateHelper (const plugin &Plugin, pi_context Ctx, pi_mem_flags Flags, size_t Size, void *HostPtr, pi_mem *RetMem, const pi_mem_properties *Props=nullptr)
void	memReleaseHelper (const plugin &Plugin, pi_mem Mem)
void	memBufferMapHelper (const plugin &Plugin, pi_queue command_queue, pi_mem buffer, pi_bool blocking_map, pi_map_flags map_flags, size_t offset, size_t size, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event, void **ret_map)
void	memUnmapHelper (const plugin &Plugin, pi_queue command_queue, pi_mem memobj, void *mapped_ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event)
uint64_t	emitMemAllocBeginTrace (uintptr_t ObjHandle, size_t AllocSize, size_t GuardZone)
void	emitMemAllocEndTrace (uintptr_t ObjHandle, uintptr_t AllocPtr, size_t AllocSize, size_t GuardZone, uint64_t CorrelationID)
uint64_t	emitMemReleaseBeginTrace (uintptr_t ObjHandle, uintptr_t AllocPtr)
void	emitMemReleaseEndTrace (uintptr_t ObjHandle, uintptr_t AllocPtr, uint64_t CorrelationID)
static void	waitForEvents (const std::vector< EventImplPtr > &Events)
static RT::PiMemFlags	getMemObjCreationFlags (void *UserPtr, bool HostPtrReadOnly)
void	prepTermPositions (TermPositions &pos, int Dimensions, detail::SYCLMemObjI::MemObjType Type)
void	copyH2D (SYCLMemObjI *SYCLMemObj, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, RT::PiMem DstMem, QueueImplPtr TgtQueue, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
void	copyD2H (SYCLMemObjI *SYCLMemObj, RT::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
void	copyD2D (SYCLMemObjI *SYCLMemObj, RT::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, RT::PiMem DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 >, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
static void	copyH2H (SYCLMemObjI *, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent >, RT::PiEvent &)
static void	memcpyToDeviceGlobalUSM (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, const void *Src, const std::vector< RT::PiEvent > &DepEvents, RT::PiEvent *OutEvent)
static void	memcpyFromDeviceGlobalUSM (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, void *Dest, const std::vector< RT::PiEvent > &DepEvents, RT::PiEvent *OutEvent)
static RT::PiProgram	getOrBuildProgramForDeviceGlobal (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, OSModuleHandle M)
static void	memcpyToDeviceGlobalDirect (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, const void *Src, OSModuleHandle M, const std::vector< RT::PiEvent > &DepEvents, RT::PiEvent *OutEvent)
static void	memcpyFromDeviceGlobalDirect (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, void *Dest, OSModuleHandle M, const std::vector< RT::PiEvent > &DepEvents, RT::PiEvent *OutEvent)
static bool	IsSupportedImageFormat (RT::PiDeviceBinaryType Format)
std::string	getDirName (const char *Path)
template void *	getPluginOpaqueData< sycl::backend::ext_intel_esimd_emulator > (void *)
static bool	IsBannedPlatform (platform Platform)
template<typename ListT , typename FilterT >
static std::vector< int >	filterDeviceFilter (std::vector< RT::PiDevice > &PiDevices, RT::PiPlatform Platform, ListT *FilterList)
static bool	supportsAffinityDomain (const device &dev, info::partition_property partitionProp, info::partition_affinity_domain domain)
static bool	supportsPartitionProperty (const device &dev, info::partition_property partitionProp)
static std::vector< device >	amendDeviceAndSubDevices (backend PlatformBackend, std::vector< device > &DeviceList, ods_target_list *OdsTargetList, const std::vector< int > &original_indices, PlatformImplPtr PlatformImpl)
std::string	get_platform_info_string_impl (RT::PiPlatform Plt, const plugin &Plugin, pi_platform_info PiCode)
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, std::string >::value, std::string >::type	get_platform_info (RT::PiPlatform Plt, const plugin &Plugin)
template<typename Param >
std::enable_if< std::is_same< Param, info::platform::extensions >::value, std::vector< std::string > >::type	get_platform_info (RT::PiPlatform Plt, const plugin &Plugin)
template<typename Param >
Param::return_type	get_platform_info_host ()=delete
template<>
std::string	get_platform_info_host< info::platform::profile > ()
template<>
std::string	get_platform_info_host< info::platform::version > ()
template<>
std::string	get_platform_info_host< info::platform::name > ()
template<>
std::string	get_platform_info_host< info::platform::vendor > ()
template<>
std::vector< std::string >	get_platform_info_host< info::platform::extensions > ()
template<typename... Ts>
constexpr size_t	totalSize (const std::tuple< Ts... > &)
template<PiApiKind Kind, typename... ArgsT>
auto	packCallArguments (ArgsT &&...Args)
static constexpr char	UseSpvEnv ("SYCL_USE_KERNEL_SPV")
static void	enableITTAnnotationsIfNeeded (const RT::PiProgram &Prog, const plugin &Plugin)
	This function enables ITT annotations in SPIR-V module by setting a specialization constant if INTEL_LIBITTNOTIFY64 env variable is set. More...
static RT::PiProgram	createBinaryProgram (const ContextImplPtr Context, const device &Device, const unsigned char *Data, size_t DataLen, const std::vector< pi_device_binary_property > Metadata)
static RT::PiProgram	createSpirvProgram (const ContextImplPtr Context, const unsigned char *Data, size_t DataLen)
template<typename 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, RT::PiDeviceBinaryType Format)
static const char *	getFormatStr (RT::PiDeviceBinaryType Format)
static void	appendLinkOptionsFromImage (std::string &LinkOpts, const RTDeviceBinaryImage &Img)
static bool	getUint32PropAsBool (const RTDeviceBinaryImage &Img, const char *PropName)
static void	appendCompileOptionsFromImage (std::string &CompileOpts, const RTDeviceBinaryImage &Img, const std::vector< device > &Devs, const detail::plugin &Plugin)
static void	applyOptionsFromImage (std::string &CompileOpts, std::string &LinkOpts, const RTDeviceBinaryImage &Img, const std::vector< device > &Devices, const detail::plugin &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, RT::PiProgram &Prog)
static const char *	getDeviceLibFilename (DeviceLibExt Extension, bool Native)
static const char *	getDeviceLibExtensionStr (DeviceLibExt Extension)
static RT::PiProgram	loadDeviceLibFallback (const ContextImplPtr Context, DeviceLibExt Extension, const RT::PiDevice &Device, bool UseNativeLib)
static bool	isDeviceLibRequired (DeviceLibExt Ext, uint32_t DeviceLibReqMask)
static std::vector< RT::PiProgram >	getDeviceLibPrograms (const ContextImplPtr Context, const RT::PiDevice &Device, uint32_t DeviceLibReqMask)
static ProgramManager::KernelArgMask	createKernelArgMask (const ByteArray &Bytes)
static bundle_state	getBinImageState (const RTDeviceBinaryImage *BinImage)
static bool	compatibleWithDevice (RTDeviceBinaryImage *BinImage, const device &Dev)
static void	setSpecializationConstants (const std::shared_ptr< device_image_impl > &InputImpl, RT::PiProgram Prog, const plugin &Plugin)
bool	doesDevSupportDeviceRequirements (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	prepareUSMEvent (const std::shared_ptr< detail::queue_impl > &QueueImpl, RT::PiEvent NativeEvent)
static event	createDiscardedEvent ()
uint32_t	reduGetMaxNumConcurrentWorkGroups (std::shared_ptr< sycl::detail::queue_impl > Queue)
size_t	reduGetMaxWGSize (std::shared_ptr< sycl::detail::queue_impl > Queue, size_t LocalMemBytesPerWorkItem)
static std::string	demangleKernelName (std::string Name)
static std::string	deviceToString (device Device)
static void	applyFuncOnFilteredArgs (const ProgramManager::KernelArgMask &EliminatedArgMask, std::vector< ArgDesc > &Args, std::function< void(detail::ArgDesc &Arg, int NextTrueIndex)> Func)
static std::string	accessModeToString (access::mode Mode)
static void	flushCrossQueueDeps (const std::vector< EventImplPtr > &EventImpls, const QueueImplPtr &Queue)
static std::string	cgTypeToString (detail::CG::CGTYPE Type)
static void	adjustNDRangePerKernel (NDRDescT &NDR, RT::PiKernel Kernel, const device_impl &DeviceImpl)
static void	ReverseRangeDimensionsForKernel (NDRDescT &NDR)
static pi_result	SetKernelParamsAndLaunch (const QueueImplPtr &Queue, std::vector< ArgDesc > &Args, const std::shared_ptr< device_image_impl > &DeviceImageImpl, RT::PiKernel Kernel, NDRDescT &NDRDesc, std::vector< RT::PiEvent > &RawEvents, RT::PiEvent *OutEvent, const ProgramManager::KernelArgMask &EliminatedArgMask, const std::function< void *(Requirement *Req)> &getMemAllocationFunc)
void	DispatchNativeKernel (void *Blob)
pi_int32	enqueueImpKernel (const QueueImplPtr &Queue, NDRDescT &NDRDesc, std::vector< ArgDesc > &Args, const std::shared_ptr< detail::kernel_bundle_impl > &KernelBundleImplPtr, const std::shared_ptr< detail::kernel_impl > &MSyclKernel, const std::string &KernelName, const detail::OSModuleHandle &OSModuleHandle, std::vector< RT::PiEvent > &RawEvents, RT::PiEvent *OutEvent, const std::function< void *(Requirement *Req)> &getMemAllocationFunc, RT::PiKernelCacheConfig KernelCacheConfig)
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 Command *	insertMapUnmapForLinkedCmds (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 Command *	getCommand (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)
void	force_type (info::device_type &t, const info::device_type &ft)
static int	getDevicePreference (const device &Device)
static void	traceDeviceSelection (const device &Device, int Score, bool Chosen)
device	select_device (DSelectorInvocableType DeviceSelectorInvocable, std::vector< device > &Devices)
ESIMDDeviceInterface *	getESIMDDeviceInterface ()

Variables
constexpr KernelSetId	SpvFileKSId = 0
constexpr KernelSetId	LastKSId = SpvFileKSId
static constexpr int	REJECT_DEVICE_SCORE = -1
static constexpr ext::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

Typedef Documentation

__sycl_init_mem_for

template<class KernelName >

using sycl::_V1::detail::__sycl_init_mem_for = typedef std::conditional_t<std::is_same<KernelName, auto_name>::value, 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 760 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<KernelName, auto_name>::value, auto_name, MainOrAux<KernelName, Strategy, Ts...> >

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

We must do that to avoid name collisions.

Definition at line 1130 of file reduction.hpp.

AccessorImplPtr

typedef std::shared_ptr< AccessorImplHost > sycl::_V1::detail::AccessorImplPtr

Definition at line 464 of file accessor.hpp.

add_pointer_t

template<typename T >

using sycl::_V1::detail::add_pointer_t = typedef typename std::add_pointer<T>::type

Definition at line 37 of file stl_type_traits.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 82 of file type_list.hpp.

allocator_pointer_t

template<typename T >

using sycl::_V1::detail::allocator_pointer_t = typedef typename std::allocator_traits<T>::pointer

Definition at line 49 of file stl_type_traits.hpp.

allocator_value_type_t

template<typename T >

using sycl::_V1::detail::allocator_value_type_t = typedef typename std::allocator_traits<T>::value_type

Definition at line 46 of file stl_type_traits.hpp.

AllowListParsedT

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

Definition at line 23 of file allowlist.hpp.

bool_constant

template<bool V>

using sycl::_V1::detail::bool_constant = typedef std::integral_constant<bool, V>

Definition at line 40 of file stl_type_traits.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 124 of file type_traits.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 conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, int>

Definition at line 628 of file generic_type_traits.hpp.

conditional_t

template<bool B, class T , class F >

using sycl::_V1::detail::conditional_t = typedef typename std::conditional<B, T, F>::type

Definition at line 27 of file stl_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 379 of file type_traits.hpp.

ContextImplPtr

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

Definition at line 30 of file event_impl.hpp.

convert_data_type

template<typename T , typename B >

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

Definition at line 304 of file generic_type_traits.hpp.

ConvertToOpenCLType_t

template<typename T >

using sycl::_V1::detail::ConvertToOpenCLType_t = typedef ConvertToOpenCLTypeImpl_t<SelectMatchingOpenCLType_t<T> >

Definition at line 568 of file generic_type_traits.hpp.

ConvertToOpenCLTypeImpl_t

template<typename T >

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

Definition at line 565 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 88 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 72 of file kernel_bundle.hpp.

DeviceImplPtr

typedef std::shared_ptr< detail::device_impl > sycl::_V1::detail::DeviceImplPtr

Definition at line 59 of file program_manager.hpp.

DevImgSelectorImpl

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

Definition at line 479 of file kernel_bundle.hpp.

DSelectorInvocableType

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

Definition at line 118 of file device_selector.hpp.

empty_type_list

using sycl::_V1::detail::empty_type_list = typedef type_list<>

Definition at line 25 of file type_list.hpp.

enable_if_t

template<bool B, class T = void>

using sycl::_V1::detail::enable_if_t = typedef typename std::enable_if<B, T>::type

Definition at line 24 of file stl_type_traits.hpp.

EnableIfFP

template<class F , class T = void>

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

Definition at line 67 of file stream.hpp.

EnableIfImgAccDataT

template<typename DataT >

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

Definition at line 79 of file image.hpp.

EnableIfOutputIteratorT

template<typename DataT >

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

Definition at line 38 of file common.hpp.

EnableIfOutputPointerT

template<typename DataT >

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

Definition at line 34 of file common.hpp.

EnableIfSwizzleVec

template<typename T >

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

Definition at line 660 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 139 of file device_selector.hpp.

EventImplPtr

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

Definition at line 42 of file cg.hpp.

find_larger_type_t

template<typename TypeList , typename T >

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

Definition at line 131 of file type_list.hpp.

find_same_size_type_t

template<typename TypeList , typename T >

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

Definition at line 125 of file type_list.hpp.

find_smaller_type_t

template<typename TypeList , typename T >

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

Definition at line 128 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 139 of file type_list.hpp.

find_twice_as_small_type_t

template<typename TypeList , typename T >

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

Definition at line 135 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 122 of file type_list.hpp.

FmtFlags

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

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

GlobalBufAccessorT

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

Definition at line 71 of file stream.hpp.

GlobalBufPtrType

using sycl::_V1::detail::GlobalBufPtrType = typedef typename detail::DecoratedType<char, GlobalBufAS>::type *

Definition at line 76 of file stream.hpp.

GlobalOffsetAccessorT

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

Definition at line 81 of file stream.hpp.

GlobalOffsetPtrType

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

Definition at line 86 of file stream.hpp.

head_t

template<typename T >

using sycl::_V1::detail::head_t = typedef typename T::head

Definition at line 18 of file type_list.hpp.

image_allocator

using sycl::_V1::detail::image_allocator = typedef aligned_allocator<byte>

Definition at line 40 of file image_impl.hpp.

int64_t

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

Definition at line 34 of file kernel_desc.hpp.

int_constant

template<int V>

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

Definition at line 90 of file type_traits.hpp.

internal_host_rel_ret_t

template<typename T >

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

Definition at line 629 of file generic_type_traits.hpp.

internal_rel_ret_t

template<typename T >

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

Definition at line 668 of file generic_type_traits.hpp.

is_arithmetic_or_complex

template<typename T >

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

Definition at line 129 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 103 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 35 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 266 of file types.hpp.

is_float_to_int

template<typename T , typename R >

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

Definition at line 261 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 27 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 bool_constant<S<T>::value && (sizeof(vector_element_t<T>) == N)>

Definition at line 220 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 186 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 117 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 100 of file generic_type_traits.hpp.

is_gencrossdouble

template<typename T >

using sycl::_V1::detail::is_gencrossdouble = typedef is_contained<T, gtl::cross_double_list>

Definition at line 94 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 91 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 97 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 51 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 37 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 29 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 44 of file generic_type_traits.hpp.

is_genfloatptr

template<typename T >

using sycl::_V1::detail::is_genfloatptr = typedef 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 240 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 75 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 140 of file generic_type_traits.hpp.

is_geninteger

template<typename T >

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

Definition at line 160 of file generic_type_traits.hpp.

is_geninteger16bit

template<typename T >

using sycl::_V1::detail::is_geninteger16bit = typedef is_gen_based_on_type_sizeof<T, 2, is_geninteger>

Definition at line 224 of file generic_type_traits.hpp.

is_geninteger32bit

template<typename T >

using sycl::_V1::detail::is_geninteger32bit = typedef is_gen_based_on_type_sizeof<T, 4, is_geninteger>

Definition at line 227 of file generic_type_traits.hpp.

is_geninteger64bit

template<typename T >

using sycl::_V1::detail::is_geninteger64bit = typedef is_gen_based_on_type_sizeof<T, 8, is_geninteger>

Definition at line 230 of file generic_type_traits.hpp.

is_geninteger8bit

template<typename T >

using sycl::_V1::detail::is_geninteger8bit = typedef is_gen_based_on_type_sizeof<T, 1, is_geninteger>

Definition at line 221 of file generic_type_traits.hpp.

is_genintptr

template<typename T >

using sycl::_V1::detail::is_genintptr = typedef 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 235 of file generic_type_traits.hpp.

is_genlonglong

template<typename T >

using sycl::_V1::detail::is_genlonglong = typedef is_contained<T, gtl::signed_longlong_list>

Definition at line 152 of file generic_type_traits.hpp.

is_genptr

template<typename T >

using sycl::_V1::detail::is_genptr = typedef 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 245 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 123 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 188 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 46 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 42 of file generic_type_traits.hpp.

is_igenchar

template<typename T >

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

Definition at line 112 of file generic_type_traits.hpp.

is_igeninteger

template<typename T >

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

Definition at line 163 of file generic_type_traits.hpp.

is_igeninteger16bit

template<typename T >

using sycl::_V1::detail::is_igeninteger16bit = typedef is_gen_based_on_type_sizeof<T, 2, is_igeninteger>

Definition at line 200 of file generic_type_traits.hpp.

is_igeninteger32bit

template<typename T >

using sycl::_V1::detail::is_igeninteger32bit = typedef is_gen_based_on_type_sizeof<T, 4, is_igeninteger>

Definition at line 203 of file generic_type_traits.hpp.

is_igeninteger64bit

template<typename T >

using sycl::_V1::detail::is_igeninteger64bit = typedef is_gen_based_on_type_sizeof<T, 8, is_igeninteger>

Definition at line 206 of file generic_type_traits.hpp.

is_igeninteger8bit

template<typename T >

using sycl::_V1::detail::is_igeninteger8bit = typedef is_gen_based_on_type_sizeof<T, 1, is_igeninteger>

Definition at line 197 of file generic_type_traits.hpp.

is_igenlonginteger

template<typename T >

using sycl::_V1::detail::is_igenlonginteger = typedef is_contained<T, gtl::signed_long_integer_list>

Definition at line 155 of file generic_type_traits.hpp.

is_int_to_float

template<typename T , typename R >

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

Definition at line 256 of file types.hpp.

is_int_to_int

template<typename T , typename R >

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

Definition at line 225 of file types.hpp.

is_intn

template<typename T >

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

Definition at line 138 of file generic_type_traits.hpp.

is_longlongn

template<typename T >

using sycl::_V1::detail::is_longlongn = typedef is_contained<T, gtl::vector_signed_longlong_list>

Definition at line 149 of file generic_type_traits.hpp.

is_mgenfloat

template<typename T >

using sycl::_V1::detail::is_mgenfloat = typedef bool_constant< std::is_same<T, sycl::marray<marray_element_type<T>, T::size()> >::value && is_svgenfloat<marray_element_type<T> >::value>

Definition at line 67 of file generic_type_traits.hpp.

is_multiplies

template<typename T , typename BinaryOperation >

using sycl::_V1::detail::is_multiplies = typedef std::integral_constant< bool, std::is_same<BinaryOperation, sycl::multiplies<T> >::value || std::is_same<BinaryOperation, sycl::multiplies<void> >::value>

Definition at line 113 of file group_algorithm.hpp.

is_nan_type

template<typename T >

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

Definition at line 247 of file generic_type_traits.hpp.

is_one_of_spaces

template<access::address_space AddressSpace, typename ValueList >

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

Definition at line 86 of file type_list.hpp.

is_plus

template<typename T , typename BinaryOperation >

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

Definition at line 107 of file group_algorithm.hpp.

is_plus_or_multiplies_if_complex

template<typename T , typename BinaryOperation >

using sycl::_V1::detail::is_plus_or_multiplies_if_complex = typedef std::integral_constant< bool, (is_complex<T>::value ? (is_plus<T, BinaryOperation>::value || is_multiplies<T, BinaryOperation>::value) : std::true_type::value)>

Definition at line 142 of file group_algorithm.hpp.

is_scharn

template<typename T >

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

Definition at line 106 of file generic_type_traits.hpp.

is_sgenfloat

template<typename T >

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

Definition at line 54 of file generic_type_traits.hpp.

is_sgengeo

template<typename T >

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

Definition at line 86 of file generic_type_traits.hpp.

is_sgeninteger

template<typename T >

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

Definition at line 169 of file generic_type_traits.hpp.

is_sgentype

template<typename T >

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

Definition at line 194 of file generic_type_traits.hpp.

is_shortn

template<typename T >

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

Definition at line 120 of file generic_type_traits.hpp.

is_sigeninteger

template<typename T >

using sycl::_V1::detail::is_sigeninteger = typedef is_contained<T, gtl::scalar_signed_integer_list>

Definition at line 175 of file generic_type_traits.hpp.

is_sint_to_float

template<typename T , typename R >

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

Definition at line 246 of file types.hpp.

is_sint_to_from_uint

template<typename T , typename R >

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

Definition at line 240 of file types.hpp.

is_sint_to_sint

template<typename T , typename R >

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

Definition at line 230 of file types.hpp.

is_standard_type

template<typename T >

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

Definition at line 269 of file types.hpp.

is_sugeninteger

template<typename T >

using sycl::_V1::detail::is_sugeninteger = typedef is_contained<T, gtl::scalar_unsigned_integer_list>

Definition at line 178 of file generic_type_traits.hpp.

is_svgenfloat

template<typename T >

using sycl::_V1::detail::is_svgenfloat = typedef is_contained<T, gtl::scalar_vector_floating_list>

Definition at line 60 of file generic_type_traits.hpp.

is_svgenfloatd

template<typename T >

using sycl::_V1::detail::is_svgenfloatd = typedef is_contained<T, gtl::scalar_vector_double_list>

Definition at line 40 of file generic_type_traits.hpp.

is_svgenfloatf

template<typename T >

using sycl::_V1::detail::is_svgenfloatf = typedef is_contained<T, gtl::scalar_vector_float_list>

Definition at line 32 of file generic_type_traits.hpp.

is_svgenfloath

template<typename T >

using sycl::_V1::detail::is_svgenfloath = typedef is_contained<T, gtl::scalar_vector_half_list>

Definition at line 49 of file generic_type_traits.hpp.

is_ucharn

template<typename T >

using sycl::_V1::detail::is_ucharn = typedef is_contained<T, gtl::vector_unsigned_char_list>

Definition at line 109 of file generic_type_traits.hpp.

is_ugenchar

template<typename T >

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

Definition at line 115 of file generic_type_traits.hpp.

is_ugenint

template<typename T >

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

Definition at line 135 of file generic_type_traits.hpp.

is_ugeninteger

template<typename T >

using sycl::_V1::detail::is_ugeninteger = typedef is_contained<T, gtl::unsigned_integer_list>

Definition at line 166 of file generic_type_traits.hpp.

is_ugeninteger16bit

template<typename T >

using sycl::_V1::detail::is_ugeninteger16bit = typedef is_gen_based_on_type_sizeof<T, 2, is_ugeninteger>

Definition at line 212 of file generic_type_traits.hpp.

is_ugeninteger32bit

template<typename T >

using sycl::_V1::detail::is_ugeninteger32bit = typedef is_gen_based_on_type_sizeof<T, 4, is_ugeninteger>

Definition at line 215 of file generic_type_traits.hpp.

is_ugeninteger64bit

template<typename T >

using sycl::_V1::detail::is_ugeninteger64bit = typedef is_gen_based_on_type_sizeof<T, 8, is_ugeninteger>

Definition at line 218 of file generic_type_traits.hpp.

is_ugeninteger8bit

template<typename T >

using sycl::_V1::detail::is_ugeninteger8bit = typedef is_gen_based_on_type_sizeof<T, 1, is_ugeninteger>

Definition at line 209 of file generic_type_traits.hpp.

is_ugenlonginteger

template<typename T >

using sycl::_V1::detail::is_ugenlonginteger = typedef is_contained<T, gtl::unsigned_long_integer_list>

Definition at line 158 of file generic_type_traits.hpp.

is_ugenlonglong

template<typename T >

using sycl::_V1::detail::is_ugenlonglong = typedef is_contained<T, gtl::unsigned_longlong_list>

Definition at line 146 of file generic_type_traits.hpp.

is_ugenshort

template<typename T >

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

Definition at line 129 of file generic_type_traits.hpp.

is_uint_to_float

template<typename T , typename R >

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

Definition at line 251 of file types.hpp.

is_uint_to_uint

template<typename T , typename R >

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

Definition at line 235 of file types.hpp.

is_uintn

template<typename T >

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

Definition at line 132 of file generic_type_traits.hpp.

is_ulonglongn

template<typename T >

using sycl::_V1::detail::is_ulonglongn = typedef is_contained<T, gtl::vector_unsigned_longlong_list>

Definition at line 143 of file generic_type_traits.hpp.

is_ushortn

template<typename T >

using sycl::_V1::detail::is_ushortn = typedef is_contained<T, gtl::vector_unsigned_short_list>

Definition at line 126 of file generic_type_traits.hpp.

is_validImageDataT

template<typename T >

using sycl::_V1::detail::is_validImageDataT = typedef typename detail::is_contained< T, type_list<vec<opencl::cl_int, 4>, vec<opencl::cl_uint, 4>, vec<opencl::cl_float, 4>, vec<opencl::cl_half, 4> >>::type

Definition at line 75 of file image.hpp.

is_vgenfloat

template<typename T >

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

Definition at line 57 of file generic_type_traits.hpp.

is_vgengeo

template<typename T >

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

Definition at line 88 of file generic_type_traits.hpp.

is_vgengeodouble

template<typename T >

using sycl::_V1::detail::is_vgengeodouble = typedef is_contained<T, gtl::vector_geo_double_list>

Definition at line 81 of file generic_type_traits.hpp.

is_vgengeofloat

template<typename T >

using sycl::_V1::detail::is_vgengeofloat = typedef is_contained<T, gtl::vector_geo_float_list>

Definition at line 78 of file generic_type_traits.hpp.

is_vgengeohalf

template<typename T >

using sycl::_V1::detail::is_vgengeohalf = typedef is_contained<T, gtl::vector_geo_half_list>

Definition at line 84 of file generic_type_traits.hpp.

is_vgeninteger

template<typename T >

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

Definition at line 172 of file generic_type_traits.hpp.

is_vgentype

template<typename T >

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

Definition at line 191 of file generic_type_traits.hpp.

is_vigeninteger

template<typename T >

using sycl::_V1::detail::is_vigeninteger = typedef is_contained<T, gtl::vector_signed_integer_list>

Definition at line 181 of file generic_type_traits.hpp.

is_vugeninteger

template<typename T >

using sycl::_V1::detail::is_vugeninteger = typedef is_contained<T, gtl::vector_unsigned_integer_list>

Definition at line 184 of file generic_type_traits.hpp.

IsBitAND

template<typename T , class BinaryOperation >

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

Definition at line 44 of file known_identity.hpp.

IsBitOR

template<typename T , class BinaryOperation >

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

Definition at line 49 of file known_identity.hpp.

IsBitXOR

template<typename T , class BinaryOperation >

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

Definition at line 54 of file known_identity.hpp.

isComplex

template<typename T >

using sycl::_V1::detail::isComplex = typedef bool_constant<std::is_same<T, std::complex<float> >::value || std::is_same<T, std::complex<double> >::value>

Definition at line 68 of file known_identity.hpp.

IsFalseIdentityOp

template<typename T , class BinaryOperation >

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

Definition at line 108 of file known_identity.hpp.

IsKnownIdentityOp

template<typename T , class BinaryOperation >

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

Definition at line 122 of file known_identity.hpp.

IsLogicalAND

template<typename T , class BinaryOperation >

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

Definition at line 59 of file known_identity.hpp.

IsLogicalOR

template<typename T , class BinaryOperation >

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

Definition at line 64 of file known_identity.hpp.

IsMaximum

template<typename T , class BinaryOperation >

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

Definition at line 39 of file known_identity.hpp.

IsMaximumIdentityOp

template<typename T , class BinaryOperation >

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

Definition at line 104 of file known_identity.hpp.

IsMinimum

template<typename T , class BinaryOperation >

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

Definition at line 34 of file known_identity.hpp.

IsMinimumIdentityOp

template<typename T , class BinaryOperation >

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

Definition at line 97 of file known_identity.hpp.

IsMultiplies

template<typename T , class BinaryOperation >

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

Definition at line 29 of file known_identity.hpp.

IsOneIdentityOp

template<typename T , class BinaryOperation >

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

Definition at line 84 of file known_identity.hpp.

IsOnesIdentityOp

template<typename T , class BinaryOperation >

using sycl::_V1::detail::IsOnesIdentityOp = typedef bool_constant<(is_genbool<T>::value || is_geninteger<T>::value) && IsBitAND<T, BinaryOperation>::value>

Definition at line 90 of file known_identity.hpp.

IsPlus

template<typename T , class BinaryOperation >

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

Definition at line 24 of file known_identity.hpp.

IsPropertyListT

template<typename T >

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

Definition at line 250 of file accessor.hpp.

IsReduOptForAtomic64Op

template<typename T , class BinaryOperation >

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

Definition at line 113 of file reduction.hpp.

IsReduOptForFastAtomicFetch

template<typename T , class BinaryOperation >

using sycl::_V1::detail::IsReduOptForFastAtomicFetch = typedef 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)>