sycl::_V1::detail Namespace Reference

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

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

Typedefs
template<typename T >
using	IsPropertyListT = typename std::is_base_of< PropertyListBase, T >
template<typename T >
using	IsRunTimePropertyListT = typename std::is_same< ext::oneapi::accessor_property_list<>, T >
using	AccessorImplPtr = std::shared_ptr< AccessorImplHost >
using	LocalAccessorImplPtr = std::shared_ptr< LocalAccessorImplHost >
using	UnsampledImageAccessorImplPtr = std::shared_ptr< UnsampledImageAccessorImplHost >
using	SampledImageAccessorImplPtr = std::shared_ptr< SampledImageAccessorImplHost >
using	memory_order = sycl::memory_order
using	memory_scope = sycl::memory_scope
template<memory_order Order>
using	IsValidDefaultOrder = std::bool_constant< Order==memory_order::relaxed||Order==memory_order::acq_rel||Order==memory_order::seq_cst >
template<typename T >
using	get_elem_type_t = typename get_elem_type< T >::type
template<typename T >
using	get_select_opencl_builtin_c_arg_type = typename std::conditional_t< sizeof(T)==1, char, std::conditional_t< sizeof(T)==2, short, std::conditional_t<(detail::is_contained< T, detail::type_list< long, unsigned long > >::value &&(sizeof(T)==4||sizeof(T)==8)), long, std::conditional_t< sizeof(T)==4, int, std::conditional_t< sizeof(T)==8, long long, void > >> >>
template<size_t Size, typename T8 , typename T16 , typename T32 , typename T64 >
using	select_scalar_by_size_t = std::conditional_t< Size==1, T8, std::conditional_t< Size==2, T16, std::conditional_t< Size==4, T32, std::conditional_t< Size==8, T64, void > >> >
template<typename T >
using	same_size_signed_int_t = typename same_size_signed_int< T >::type
template<typename T >
using	upsampled_int_t = typename upsampled_int< T >::type
template<typename T >
using	simplify_if_swizzle_t = typename simplify_if_swizzle< T >::type
template<typename T >
using	nan_return_unswizzled_t = typename nan_return_unswizzled< T >::type
template<typename NewElemT , typename T >
using	change_elements_t = typename change_elements< NewElemT, T >::type
template<typename T >
using	int_elements_t = change_elements_t< int, T >
template<typename T >
using	bool_elements_t = change_elements_t< bool, T >
using	EventImplPtr = std::shared_ptr< event_impl >
template<typename DataT >
using	EnableIfOutputPointerT = std::enable_if_t< std::is_pointer_v< DataT > >
template<typename DataT >
using	EnableIfOutputIteratorT = std::enable_if_t< !std::is_pointer_v< DataT > >
template<typename T >
using	is_floatn = is_contained< T, gtl::vector_float_list >
template<typename T >
using	is_genfloatf = is_contained< T, gtl::float_list >
template<typename T >
using	is_svgenfloatf = is_contained< T, gtl::scalar_vector_float_list >
template<typename T >
using	is_doublen = is_contained< T, gtl::vector_double_list >
template<typename T >
using	is_genfloatd = is_contained< T, gtl::double_list >
template<typename T >
using	is_svgenfloatd = is_contained< T, gtl::scalar_vector_double_list >
template<typename T >
using	is_halfn = is_contained< T, gtl::vector_half_list >
template<typename T >
using	is_genfloath = is_contained< T, gtl::half_list >
template<typename T >
using	is_half = is_contained< T, gtl::scalar_half_list >
template<typename T >
using	is_svgenfloath = is_contained< T, gtl::scalar_vector_half_list >
template<typename T >
using	is_genfloat = is_contained< T, gtl::floating_list >
template<typename T >
using	is_sgenfloat = is_contained< T, gtl::scalar_floating_list >
template<typename T >
using	is_vgenfloat = is_contained< T, gtl::vector_floating_list >
template<typename T >
using	is_svgenfloat = is_contained< T, gtl::scalar_vector_floating_list >
template<typename T >
using	is_mgenfloat = std::bool_constant< std::is_same_v< T, sycl::marray< marray_element_t< T >, T::size()> > &&is_svgenfloat< marray_element_t< T > >::value >
template<typename T >
using	is_gengeofloat = is_contained< T, gtl::geo_float_list >
template<typename T >
using	is_gengeodouble = is_contained< T, gtl::geo_double_list >
template<typename T >
using	is_gengeomarrayfloat = is_contained< T, gtl::marray_geo_float_list >
template<typename T >
using	is_gengeomarray = is_contained< T, gtl::marray_geo_list >
template<typename T >
using	is_gengeohalf = is_contained< T, gtl::geo_half_list >
template<typename T >
using	is_vgengeofloat = is_contained< T, gtl::vector_geo_float_list >
template<typename T >
using	is_vgengeodouble = is_contained< T, gtl::vector_geo_double_list >
template<typename T >
using	is_vgengeohalf = is_contained< T, gtl::vector_geo_half_list >
template<typename T >
using	is_sgengeo = is_contained< T, gtl::scalar_geo_list >
template<typename T >
using	is_vgengeo = is_contained< T, gtl::vector_geo_list >
template<typename T >
using	is_gencrossfloat = is_contained< T, gtl::cross_float_list >
template<typename T >
using	is_gencrossdouble = is_contained< T, gtl::cross_double_list >
template<typename T >
using	is_gencrosshalf = is_contained< T, gtl::cross_half_list >
template<typename T >
using	is_gencross = is_contained< T, gtl::cross_floating_list >
template<typename T >
using	is_gencrossmarray = is_contained< T, gtl::cross_marray_list >
template<typename T >
using	is_charn = is_contained< T, gtl::vector_default_char_list >
template<typename T >
using	is_scharn = is_contained< T, gtl::vector_signed_char_list >
template<typename T >
using	is_ucharn = is_contained< T, gtl::vector_unsigned_char_list >
template<typename T >
using	is_igenchar = is_contained< T, gtl::signed_char_list >
template<typename T >
using	is_ugenchar = is_contained< T, gtl::unsigned_char_list >
template<typename T >
using	is_genchar = is_contained< T, gtl::char_list >
template<typename T >
using	is_shortn = is_contained< T, gtl::vector_signed_short_list >
template<typename T >
using	is_genshort = is_contained< T, gtl::signed_short_list >
template<typename T >
using	is_ushortn = is_contained< T, gtl::vector_unsigned_short_list >
template<typename T >
using	is_ugenshort = is_contained< T, gtl::unsigned_short_list >
template<typename T >
using	is_uintn = is_contained< T, gtl::vector_unsigned_int_list >
template<typename T >
using	is_ugenint = is_contained< T, gtl::unsigned_int_list >
template<typename T >
using	is_intn = is_contained< T, gtl::vector_signed_int_list >
template<typename T >
using	is_genint = is_contained< T, gtl::signed_int_list >
template<typename T >
using	is_ulonglongn = is_contained< T, gtl::vector_unsigned_longlong_list >
template<typename T >
using	is_ugenlonglong = is_contained< T, gtl::unsigned_longlong_list >
template<typename T >
using	is_longlongn = is_contained< T, gtl::vector_signed_longlong_list >
template<typename T >
using	is_genlonglong = is_contained< T, gtl::signed_longlong_list >
template<typename T >
using	is_igenlonginteger = is_contained< T, gtl::signed_long_integer_list >
template<typename T >
using	is_ugenlonginteger = is_contained< T, gtl::unsigned_long_integer_list >
template<typename T >
using	is_geninteger = is_contained< T, gtl::integer_list >
template<typename T >
using	is_igeninteger = is_contained< T, gtl::signed_integer_list >
template<typename T >
using	is_ugeninteger = is_contained< T, gtl::unsigned_integer_list >
template<typename T >
using	is_sgeninteger = is_contained< T, gtl::scalar_integer_list >
template<typename T >
using	is_vgeninteger = is_contained< T, gtl::vector_integer_list >
template<typename T >
using	is_sigeninteger = is_contained< T, gtl::scalar_signed_integer_list >
template<typename T >
using	is_sugeninteger = is_contained< T, gtl::scalar_unsigned_integer_list >
template<typename T >
using	is_vigeninteger = is_contained< T, gtl::vector_signed_integer_list >
template<typename T >
using	is_vugeninteger = is_contained< T, gtl::vector_unsigned_integer_list >
template<typename T >
using	is_genbool = is_contained< T, gtl::bool_list >
template<typename T >
using	is_gentype = is_contained< T, gtl::basic_list >
template<typename T >
using	is_vgentype = is_contained< T, gtl::vector_basic_list >
template<typename T >
using	is_sgentype = is_contained< T, gtl::scalar_basic_list >
template<typename T >
using	is_igeninteger8bit = is_gen_based_on_type_sizeof< T, 1, is_igeninteger >
template<typename T >
using	is_igeninteger16bit = is_gen_based_on_type_sizeof< T, 2, is_igeninteger >
template<typename T >
using	is_igeninteger32bit = is_gen_based_on_type_sizeof< T, 4, is_igeninteger >
template<typename T >
using	is_igeninteger64bit = is_gen_based_on_type_sizeof< T, 8, is_igeninteger >
template<typename T >
using	is_ugeninteger8bit = is_gen_based_on_type_sizeof< T, 1, is_ugeninteger >
template<typename T >
using	is_ugeninteger16bit = is_gen_based_on_type_sizeof< T, 2, is_ugeninteger >
template<typename T >
using	is_ugeninteger32bit = is_gen_based_on_type_sizeof< T, 4, is_ugeninteger >
template<typename T >
using	is_ugeninteger64bit = is_gen_based_on_type_sizeof< T, 8, is_ugeninteger >
template<typename T >
using	is_geninteger8bit = is_gen_based_on_type_sizeof< T, 1, is_geninteger >
template<typename T >
using	is_geninteger16bit = is_gen_based_on_type_sizeof< T, 2, is_geninteger >
template<typename T >
using	is_geninteger32bit = is_gen_based_on_type_sizeof< T, 4, is_geninteger >
template<typename T >
using	is_geninteger64bit = is_gen_based_on_type_sizeof< T, 8, is_geninteger >
template<typename T >
using	is_genintptr = std::bool_constant< is_pointer< T >::value &&is_genint< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
template<typename T , access::address_space AddressSpace, access::decorated IsDecorated>
using	is_genintptr_marray = std::bool_constant< std::is_same_v< T, sycl::marray< marray_element_t< T >, T::size()> > &&is_genint< marray_element_t< remove_pointer_t< T > >>::value &&is_address_space_compliant< multi_ptr< T, AddressSpace, IsDecorated >, gvl::nonconst_address_space_list >::value &&(IsDecorated==access::decorated::yes||IsDecorated==access::decorated::no)>
template<typename T >
using	is_genfloatptr = std::bool_constant< is_pointer< T >::value &&is_genfloat< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
template<typename T , access::address_space AddressSpace, access::decorated IsDecorated>
using	is_genfloatptr_marray = std::bool_constant< is_mgenfloat< T >::value &&is_address_space_compliant< multi_ptr< T, AddressSpace, IsDecorated >, gvl::nonconst_address_space_list >::value &&(IsDecorated==access::decorated::yes||IsDecorated==access::decorated::no)>
template<typename T >
using	is_genptr = std::bool_constant< is_pointer< T >::value &&is_gentype< remove_pointer_t< T > >::value &&is_address_space_compliant< T, gvl::nonconst_address_space_list >::value >
template<typename T >
using	is_nan_type = is_contained< T, gtl::nan_list >
template<typename T >
using	nan_return_t = typename nan_types< T, T >::ret_type
template<typename T >
using	nan_argument_base_t = typename nan_types< T, T >::arg_type
template<typename T >
using	make_floating_point_t = make_type_t< T, gtl::scalar_floating_list >
template<typename T >
using	make_singed_integer_t = make_type_t< T, gtl::scalar_signed_integer_list >
template<typename T >
using	make_unsinged_integer_t = make_type_t< T, gtl::scalar_unsigned_integer_list >
template<typename T , typename B >
using	convert_data_type = convert_data_type_impl< T, B, T >
template<typename T >
using	mptr_or_vec_elem_type_t = typename mptr_or_vec_elem_type< T >::type
template<typename T , typename T8 , typename T16 , typename T32 , typename T64 >
using	select_apply_cl_scalar_t = std::conditional_t< sizeof(T)==1, T8, std::conditional_t< sizeof(T)==2, T16, std::conditional_t< sizeof(T)==4, T32, T64 > >>
template<typename T >
using	select_cl_scalar_integral_signed_t = select_apply_cl_scalar_t< T, sycl::opencl::cl_char, sycl::opencl::cl_short, sycl::opencl::cl_int, sycl::opencl::cl_long >
template<typename T >
using	select_cl_scalar_integral_unsigned_t = select_apply_cl_scalar_t< T, sycl::opencl::cl_uchar, sycl::opencl::cl_ushort, sycl::opencl::cl_uint, sycl::opencl::cl_ulong >
template<typename T >
using	select_cl_scalar_float_t = select_apply_cl_scalar_t< T, std::false_type, sycl::opencl::cl_half, sycl::opencl::cl_float, sycl::opencl::cl_double >
template<typename T >
using	select_cl_scalar_complex_or_T_t = typename select_cl_scalar_complex_or_T< T >::type
template<typename T >
using	select_cl_scalar_integral_t = std::conditional_t< std::is_signed_v< T >, select_cl_scalar_integral_signed_t< T >, select_cl_scalar_integral_unsigned_t< T > >
template<typename T >
using	select_cl_scalar_t = std::conditional_t< std::is_integral_v< T >, select_cl_scalar_integral_t< T >, std::conditional_t< std::is_floating_point_v< T >, select_cl_scalar_float_t< T >, std::conditional_t< is_half< T >::value, sycl::detail::half_impl::BIsRepresentationT, select_cl_scalar_complex_or_T_t< T > >> >
template<typename T >
using	type_helper = typename TypeHelper< T >::RetType
template<typename T >
using	SelectMatchingOpenCLType_t = typename select_cl_mptr_or_vector_or_scalar_or_ptr< T >::type
template<typename T >
using	ConvertToOpenCLTypeImpl_t = std::conditional_t< TryToGetVectorT< T >::value, typename TryToGetVectorT< T >::type, std::conditional_t< TryToGetPointerT< T >::value, typename TryToGetPointerVecT< T >::type, T > >
template<typename T >
using	ConvertToOpenCLType_t = ConvertToOpenCLTypeImpl_t< SelectMatchingOpenCLType_t< T > >
template<typename T >
using	common_rel_ret_t = std::conditional_t< is_vgentype< T >::value, make_singed_integer_t< T >, bool >
template<typename T >
using	internal_rel_ret_t = typename RelationalReturnType< T >::type
template<typename T >
using	rel_sign_bit_test_ret_t = typename RelationalTestForSignBitType< T >::return_type
template<typename T >
using	rel_sign_bit_test_arg_t = typename RelationalTestForSignBitType< T >::argument_type
template<typename T >
using	IsValidCoordType = typename is_contained< T, type_list< opencl::cl_int, opencl::cl_float, std::int32_t, float > >::type
using	int64_t = conditional< sizeof(long)==8, long, long long >::type
using	PluginPtr = std::shared_ptr< plugin >
template<typename T >
using	iterator_category_t = typename std::iterator_traits< T >::iterator_category
template<typename T >
using	iterator_value_type_t = typename std::iterator_traits< T >::value_type
template<typename T >
using	iterator_pointer_t = typename std::iterator_traits< T >::pointer
template<typename T >
using	iterator_to_const_type_t = std::is_const< std::remove_pointer_t< iterator_pointer_t< T > >>
template<typename T >
using	output_iterator_requirements = std::void_t< iterator_category_t< T >, decltype(*std::declval< T >()=std::declval< iterator_value_type_t< T > >())>
template<typename DataT >
using	sycl_memory_object_allocator = aligned_allocator< DataT >
template<std::size_t I, class T >
using	tuple_element_t = typename tuple_element< I, T >::type
template<typename T >
using	head_t = typename T::head
template<typename T >
using	tail_t = typename T::tail
using	empty_type_list = type_list<>
template<access::address_space... Values>
using	address_space_list = value_list< access::address_space, Values... >
template<access::address_space AddressSpace, typename ValueList >
using	is_one_of_spaces = is_contained_value< access::address_space, AddressSpace, ValueList >
template<typename TypeList , template< typename, typename > class Comp, typename T >
using	find_type_t = typename find_type< TypeList, Comp, T >::type
template<typename TypeList , typename T >
using	find_same_size_type_t = find_type_t< TypeList, is_type_size_equal, T >
template<typename TypeList , typename T >
using	find_twice_as_large_type_t = find_type_t< TypeList, is_type_size_double_of, T >
using	uuid_type = std::array< unsigned char, 16 >
template<typename T , typename R >
using	copy_cv_qualifiers_t = typename copy_cv_qualifiers< T, R >::type
template<int V>
using	int_constant = std::integral_constant< int, V >
template<typename T >
using	vector_element_impl_t = typename vector_element_impl< T >::type
template<class T >
using	vector_element_t = typename vector_element< T >::type
template<class T >
using	marray_element_t = typename T::value_type
template<typename T , typename B >
using	change_base_type_t = typename change_base_type< T, B >::type
template<typename T >
using	make_signed_impl_t = typename make_signed_impl< T, T >::type
template<typename T >
using	make_signed_t = typename make_signed< T >::type
template<typename T >
using	make_unsigned_impl_t = typename make_unsigned_impl< T, T >::type
template<typename T >
using	make_unsigned_t = typename make_unsigned< T >::type
template<typename T , int N, template< typename > class S>
using	is_gen_based_on_type_sizeof = std::bool_constant< S< T >::value &&(sizeof(vector_element_t< T >)==N)>
template<typename T >
using	remove_pointer_t = typename remove_pointer< T >::type
template<typename T , typename TL >
using	make_type_t = typename make_type_impl< T, TL >::type
template<typename T >
using	make_larger_t = typename make_larger< T >::type
template<access::address_space AS, class DataT >
using	const_if_const_AS = DataT
using	SerializedObj = std::vector< unsigned char >
using	DSelectorInvocableType = std::function< int(const sycl::device &)>
template<typename DeviceSelector >
using	EnableIfSYCL2020DeviceSelectorInvocable = std::enable_if_t< std::is_invocable_r_v< int, DeviceSelector &, const device & > &&!std::is_base_of_v< ext::oneapi::filter_selector, DeviceSelector > &&!std::is_base_of_v< device_selector, DeviceSelector > >
template<typename T >
using	native_op_list = type_list< sycl::plus< T >, sycl::bit_or< T >, sycl::bit_xor< T >, sycl::bit_and< T >, sycl::maximum< T >, sycl::minimum< T >, sycl::multiplies< T >, sycl::logical_or< T >, sycl::logical_and< T > >
template<typename T , typename BinaryOperation >
using	is_plus = std::integral_constant< bool, std::is_same_v< BinaryOperation, sycl::plus< T > >||std::is_same_v< BinaryOperation, sycl::plus< void > >>
template<typename T , typename BinaryOperation >
using	is_multiplies = std::integral_constant< bool, std::is_same_v< BinaryOperation, sycl::multiplies< T > >||std::is_same_v< BinaryOperation, sycl::multiplies< void > >>
template<typename T >
using	is_arithmetic_or_complex = std::integral_constant< bool, sycl::detail::is_complex< typename std::remove_cv_t< T > >::value||sycl::detail::is_arithmetic< T >::value >
template<typename T , typename BinaryOperation >
using	is_plus_or_multiplies_if_complex = std::integral_constant< bool,(is_complex< T >::value ?(is_plus< T, BinaryOperation >::value||is_multiplies< T, BinaryOperation >::value) :std::true_type::value)>
template<typename F , typename SuggestedArgType >
using	lambda_arg_type = decltype(argument_helper< F, SuggestedArgType >(0))
template<typename T >
using	is_validImageDataT = typename detail::is_contained< T, type_list< vec< opencl::cl_int, 4 >, vec< opencl::cl_uint, 4 >, vec< opencl::cl_float, 4 >, vec< opencl::cl_half, 4 > >>::type
template<typename DataT >
using	EnableIfImgAccDataT = typename std::enable_if_t< is_validImageDataT< DataT >::value, DataT >
using	DeviceImageImplPtr = std::shared_ptr< device_image_impl >
using	KernelBundleImplPtr = std::shared_ptr< detail::kernel_bundle_impl >
using	DevImgSelectorImpl = std::function< bool(const detail::DeviceImageImplPtr &DevImgImpl)>
template<typename T , class BinaryOperation >
using	IsPlus = std::bool_constant< std::is_same_v< BinaryOperation, sycl::plus< T > >||std::is_same_v< BinaryOperation, sycl::plus< void > >>
template<typename T , class BinaryOperation >
using	IsMultiplies = std::bool_constant< std::is_same_v< BinaryOperation, sycl::multiplies< T > >||std::is_same_v< BinaryOperation, sycl::multiplies< void > >>
template<typename T , class BinaryOperation >
using	IsMinimum = std::bool_constant< std::is_same_v< BinaryOperation, sycl::minimum< T > >||std::is_same_v< BinaryOperation, sycl::minimum< void > >>
template<typename T , class BinaryOperation >
using	IsMaximum = std::bool_constant< std::is_same_v< BinaryOperation, sycl::maximum< T > >||std::is_same_v< BinaryOperation, sycl::maximum< void > >>
template<typename T , class BinaryOperation >
using	IsBitAND = std::bool_constant< std::is_same_v< BinaryOperation, sycl::bit_and< T > >||std::is_same_v< BinaryOperation, sycl::bit_and< void > >>
template<typename T , class BinaryOperation >
using	IsBitOR = std::bool_constant< std::is_same_v< BinaryOperation, sycl::bit_or< T > >||std::is_same_v< BinaryOperation, sycl::bit_or< void > >>
template<typename T , class BinaryOperation >
using	IsBitXOR = std::bool_constant< std::is_same_v< BinaryOperation, sycl::bit_xor< T > >||std::is_same_v< BinaryOperation, sycl::bit_xor< void > >>
template<typename T , class BinaryOperation >
using	IsLogicalAND = std::bool_constant< std::is_same_v< BinaryOperation, std::logical_and< T > >||std::is_same_v< BinaryOperation, std::logical_and< void > >||std::is_same_v< BinaryOperation, sycl::logical_and< T > >||std::is_same_v< BinaryOperation, sycl::logical_and< void > >>
template<typename T , class BinaryOperation >
using	IsLogicalOR = std::bool_constant< std::is_same_v< BinaryOperation, std::logical_or< T > >||std::is_same_v< BinaryOperation, std::logical_or< void > >||std::is_same_v< BinaryOperation, sycl::logical_or< T > >||std::is_same_v< BinaryOperation, sycl::logical_or< void > >>
template<typename T , class BinaryOperation >
using	IsZeroIdentityOp = std::bool_constant<((is_genbool< T >::value||is_geninteger< T >::value) &&(IsPlus< T, BinaryOperation >::value||IsBitOR< T, BinaryOperation >::value||IsBitXOR< T, BinaryOperation >::value))||(is_genfloat< T >::value &&IsPlus< T, BinaryOperation >::value)||(isComplex< T >::value &&IsPlus< T, BinaryOperation >::value)>
template<typename T , class BinaryOperation >
using	IsOneIdentityOp = std::bool_constant<(is_genbool< T >::value||is_geninteger< T >::value||is_genfloat< T >::value) &&IsMultiplies< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsOnesIdentityOp = std::bool_constant<(is_genbool< T >::value||is_geninteger< T >::value) &&IsBitAND< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsMinimumIdentityOp = std::bool_constant<(is_genbool< T >::value||is_geninteger< T >::value||is_genfloat< T >::value) &&IsMinimum< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsMaximumIdentityOp = std::bool_constant<(is_genbool< T >::value||is_geninteger< T >::value||is_genfloat< T >::value) &&IsMaximum< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsFalseIdentityOp = std::bool_constant< IsLogicalOR< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsTrueIdentityOp = std::bool_constant< IsLogicalAND< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsKnownIdentityOp = std::bool_constant< IsZeroIdentityOp< T, BinaryOperation >::value||IsOneIdentityOp< T, BinaryOperation >::value||IsOnesIdentityOp< T, BinaryOperation >::value||IsMinimumIdentityOp< T, BinaryOperation >::value||IsMaximumIdentityOp< T, BinaryOperation >::value||IsFalseIdentityOp< T, BinaryOperation >::value||IsTrueIdentityOp< T, BinaryOperation >::value >
template<typename T , class BinaryOperation >
using	IsReduOptForFastAtomicFetch = std::bool_constant<((is_sgenfloat< T >::value &&sizeof(T)==4)||is_sgeninteger< T >::value) &&IsValidAtomicType< T >::value &&(IsPlus< T, BinaryOperation >::value||IsMinimum< T, BinaryOperation >::value||IsMaximum< T, BinaryOperation >::value||IsBitOR< T, BinaryOperation >::value||IsBitXOR< T, BinaryOperation >::value||IsBitAND< T, BinaryOperation >::value)>
template<typename T , class BinaryOperation >
using	IsReduOptForAtomic64Op = std::bool_constant<(IsPlus< T, BinaryOperation >::value||IsMinimum< T, BinaryOperation >::value||IsMaximum< T, BinaryOperation >::value) &&is_sgenfloat< T >::value &&sizeof(T)==8 >
template<typename T , class BinaryOperation >
using	IsReduOptForFastReduce = std::bool_constant<((is_sgeninteger< T >::value &&(sizeof(T)==4||sizeof(T)==8))||is_sgenfloat< T >::value) &&(IsPlus< T, BinaryOperation >::value||IsMinimum< T, BinaryOperation >::value||IsMaximum< T, BinaryOperation >::value)>
template<typename... Ts>
using	ReduTupleT = sycl::detail::tuple< Ts... >
template<class KernelName >
using	__sycl_init_mem_for = std::conditional_t< std::is_same_v< KernelName, auto_name >, auto_name, reduction::InitMemKrn< KernelName > >
	A helper to pass undefined (sycl::detail::auto_name) names unmodified. More...
template<template< typename, reduction::strategy, typename... > class MainOrAux, class KernelName , reduction::strategy Strategy, class... Ts>
using	__sycl_reduction_kernel = std::conditional_t< std::is_same_v< KernelName, auto_name >, auto_name, MainOrAux< KernelName, Strategy, Ts... > >
	A helper to pass undefined (sycl::detail::auto_name) names unmodified. More...
using	FmtFlags = unsigned int
template<class F , class T = void>
using	EnableIfFP = typename std::enable_if_t< std::is_same_v< F, float >||std::is_same_v< F, double >||std::is_same_v< F, half >, T >
using	GlobalBufAccessorT = accessor< char, 1, sycl::access::mode::read_write, sycl::access::target::device >
using	GlobalBufPtrType = typename detail::DecoratedType< char, GlobalBufAS >::type *
using	GlobalOffsetAccessorT = accessor< unsigned, 1, sycl::access::mode::atomic, sycl::access::target::device >
using	GlobalOffsetPtrType = typename detail::DecoratedType< unsigned, GlobalBufAS >::type *
template<typename T >
using	EnableIfSwizzleVec = typename std::enable_if_t< IsSwizzleOp< T >::value, typename IsSwizzleOp< T >::Type >
template<typename _IN , typename T8 , typename T16 , typename T32 , typename T64 >
using	select_apply_cl_t = std::conditional_t< sizeof(_IN)==1, T8, std::conditional_t< sizeof(_IN)==2, T16, std::conditional_t< sizeof(_IN)==4, T32, T64 > >>
template<typename DataT >
using	rel_t = typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_char), opencl::cl_char, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_short), opencl::cl_short, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_int), opencl::cl_int, typename std::conditional_t< sizeof(DataT)==sizeof(opencl::cl_long), opencl::cl_long, bool > >> >
template<typename T , typename R >
using	is_int_to_int = std::integral_constant< bool, std::is_integral_v< T > &&std::is_integral_v< R > >
template<typename T , typename R >
using	is_sint_to_sint = std::integral_constant< bool, is_sigeninteger< T >::value &&is_sigeninteger< R >::value >
template<typename T , typename R >
using	is_uint_to_uint = std::integral_constant< bool, is_sugeninteger< T >::value &&is_sugeninteger< R >::value >
template<typename T , typename R >
using	is_sint_to_from_uint = std::integral_constant< bool,(is_sugeninteger< T >::value &&is_sigeninteger< R >::value)||(is_sigeninteger< T >::value &&is_sugeninteger< R >::value)>
template<typename T , typename R >
using	is_sint_to_float = std::integral_constant< bool, std::is_integral_v< T > &&!(std::is_unsigned_v< T >)&&detail::is_floating_point< R >::value >
template<typename T , typename R >
using	is_uint_to_float = std::integral_constant< bool, std::is_unsigned_v< T > &&detail::is_floating_point< R >::value >
template<typename T , typename R >
using	is_int_to_float = std::integral_constant< bool, std::is_integral_v< T > &&detail::is_floating_point< R >::value >
template<typename T , typename R >
using	is_float_to_int = std::integral_constant< bool, detail::is_floating_point< T >::value &&std::is_integral_v< R > >
template<typename T , typename R >
using	is_float_to_float = std::integral_constant< bool, detail::is_floating_point< T >::value &&detail::is_floating_point< R >::value >
template<typename T >
using	is_standard_type = std::integral_constant< bool, detail::is_sgentype< T >::value >
using	Requirement = AccessorImplHost
using	DeviceDescT = std::map< std::string, std::string >
using	AllowListParsedT = std::vector< DeviceDescT >
using	PlatformImplPtr = std::shared_ptr< detail::platform_impl >
using	ContextImplPtr = std::shared_ptr< sycl::detail::context_impl >
using	QueueImplPtr = std::shared_ptr< sycl::detail::queue_impl >
using	LockGuard = std::lock_guard< SpinLock >
using	image_allocator = aligned_allocator< byte >
using	KernelArgMask = std::vector< bool >
using	ProgramImplPtr = std::shared_ptr< program_impl >
using	DeviceImplPtr = std::shared_ptr< device_impl >
using	StreamImplPtr = std::shared_ptr< detail::stream_impl >
using	QueueIdT = std::hash< std::shared_ptr< detail::queue_impl > >::result_type
using	CommandPtr = std::unique_ptr< Command >
using	FusionList = std::unique_ptr< KernelFusionCommand >
using	FusionMap = std::unordered_map< QueueIdT, FusionList >
using	SpecConstRegistryT = std::map< std::string, spec_constant_impl >

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

Functions
constexpr bool	isTargetHostAccess (access::target T)
constexpr bool	modeNeedsOldData (access::mode m)
constexpr bool	modeWritesNewData (access::mode m)
template<typename ToT , typename FromT >
ToT	cast_AS (FromT from)
void	constructorNotification (void *BufferObj, void *AccessorObj, access::target Target, access::mode Mode, const code_location &CodeLoc)
void	unsampledImageConstructorNotification (void *ImageObj, void *AccessorObj, const std::optional< image_target > &Target, access::mode Mode, const void *Type, uint32_t ElemSize, const code_location &CodeLoc)
void	sampledImageConstructorNotification (void *ImageObj, void *AccessorObj, const std::optional< image_target > &Target, const void *Type, uint32_t ElemSize, const code_location &CodeLoc)
template<typename BufferT >
sycl::range< 1 >	GetZeroDimAccessRange (BufferT Buffer)
device	getDeviceFromHandler (handler &CommandGroupHandlerRef)
template<typename DataT >
constexpr access::mode	accessModeFromConstness ()
template<typename MayBeTag1 , typename MayBeTag2 >
constexpr access::mode	deduceAccessMode ()
template<typename MayBeTag1 , typename MayBeTag2 >
constexpr access::target	deduceAccessTarget (access::target defaultTarget)
void	addHostAccessorAndWait (AccessorImplHost *Req)
void	addHostUnsampledImageAccessorAndWait (UnsampledImageAccessorImplHost *Req)
void	addHostSampledImageAccessorAndWait (SampledImageAccessorImplHost *Req)
std::memory_order	getStdMemoryOrder (__spv::MemorySemanticsMask::Flag)
constexpr memory_order	getLoadOrder (memory_order order)
backend	convertBackend (pi_platform_backend PiBackend)
platform	make_platform (pi_native_handle NativeHandle, backend Backend)
device	make_device (pi_native_handle NativeHandle, backend Backend)
context	make_context (pi_native_handle NativeHandle, const async_handler &Handler, backend Backend)
queue	make_queue (pi_native_handle NativeHandle, int32_t nativeHandleDesc, const context &TargetContext, const device *TargetDevice, bool KeepOwnership, const property_list &PropList, const async_handler &Handler, backend Backend)
event	make_event (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
event	make_event (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, backend Backend)
kernel	make_kernel (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
kernel	make_kernel (const context &TargetContext, const kernel_bundle< bundle_state::executable > &KernelBundle, pi_native_handle NativeKernelHandle, bool KeepOwnership, backend Backend)
std::shared_ptr< detail::kernel_bundle_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 T , int Dimensions, typename AllocatorT >
buffer< T, Dimensions, AllocatorT, void >	make_buffer_helper (pi_native_handle Handle, const context &Ctx, event Evt={}, bool OwnNativeHandle=true)
template<backend BackendName, typename DataT , int Dimensions, typename Allocator >
auto	get_native_buffer (const buffer< DataT, Dimensions, Allocator, void > &Obj) -> backend_return_t< BackendName, buffer< DataT, Dimensions, Allocator, void >>
template<typename T , typename... Ts>
constexpr bool	CheckTypeIn ()
template<size_t N, size_t... Ns>
constexpr bool	CheckSizeIn ()
template<typename T , typename... Ts>
constexpr bool	CheckAllSameOpType ()
template<class T , size_t N>
vec< T, 2 >	to_vec2 (marray< T, N > X, size_t Start)
template<class T , size_t N>
vec< T, N >	to_vec (marray< T, N > X)
template<class T , int N>
marray< T, N >	to_marray (vec< T, N > X)
template<typename F , typename... Args>
static constexpr bool	check_kernel_lambda_takes_args ()
template<typename KernelType , typename LambdaArgType , typename std::enable_if_t< std::is_same_v< LambdaArgType, void >> * = nullptr>
constexpr bool	isKernelLambdaCallableWithKernelHandlerImpl ()
template<typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType >::value >	runKernelWithoutArg (KernelType KernelName)
template<typename KernelType >
std::enable_if_t<!KernelLambdaHasKernelHandlerArgT< KernelType >::value >	runKernelWithoutArg (KernelType KernelName)
template<typename ArgType , typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value >	runKernelWithArg (KernelType KernelName, ArgType Arg)
template<typename ArgType , typename KernelType >
std::enable_if_t< !KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value >	runKernelWithArg (KernelType KernelName, ArgType Arg)
const char *	stringifyErrorCode (pi_int32 error)
std::string	codeToString (pi_int32 code)
constexpr size_t	getNextPowerOfTwoHelper (size_t Var, size_t Offset)
constexpr size_t	getNextPowerOfTwo (size_t Var)
template<int Dims, template< int > class T, template< int > class U>
size_t	getLinearIndex (const T< Dims > &Index, const U< Dims > &Range)
template<int NewDim, int DefaultValue, template< int > class T, int OldDim>
static T< NewDim >	convertToArrayOfN (T< OldDim > OldObj)
template<typename T , std::size_t... Is1, std::size_t... Is2>
constexpr std::array< T, sizeof...(Is1)+sizeof...(Is2)>	ConcatArrays (const std::array< T, sizeof...(Is1)> &A1, const std::array< T, sizeof...(Is2)> &A2, std::index_sequence< Is1... >, std::index_sequence< Is2... >)
template<typename T , std::size_t N1, std::size_t N2>
constexpr std::array< T, N1+N2 >	ConcatArrays (const std::array< T, N1 > &A1, const std::array< T, N2 > &A2)
template<typename T , size_t... Is>
static constexpr std::array< T, sizeof...(Is)>	RepeatValueHelper (const T &Arg, std::index_sequence< Is... >)
template<size_t N, typename T >
static constexpr std::array< T, N >	RepeatValue (const T &Arg)
std::vector< std::string >	split_string (const std::string &str, char delimeter)
template<typename T >
std::ostream &	operator<< (std::ostream &os, std::optional< T > const &opt)
std::ostream &	operator<< (std::ostream &Out, const ods_target &Target)
std::vector< ods_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 std::enable_if_t<TryToGetPointerT<From>::value>>
To	ConvertNonVectorType (From &t)
template<typename To , typename From >
To	ConvertNonVectorType (From *t)
template<typename To , typename From >
std::enable_if_t<!TryToGetPointerT< From >::value, To >	ConvertNonVectorType (From &t)
template<typename FROM , typename TO >
std::enable_if_t< is_vgentype< FROM >::value &&is_vgentype< TO >::value &&sizeof(TO)==sizeof(FROM), TO >	convertDataToType (FROM t)
template<typename FROM , typename TO >
std::enable_if_t<!(is_vgentype< FROM >::value &&is_vgentype< TO >::value) &&sizeof(TO)==sizeof(FROM), TO >	convertDataToType (FROM t)
template<typename T >
constexpr T	msbMask (T)
template<typename T >
constexpr bool	msbIsSet (const T x)
template<typename T >
static constexpr T	max_v ()
template<typename T >
static constexpr T	min_v ()
template<typename T >
static constexpr T	quiet_NaN ()
template<typename... Args>
void	check_vector_size ()
void	associateWithHandler (handler &, AccessorBaseHost *, access::target)
void	associateWithHandler (handler &, UnsampledImageAccessorBaseHost *, image_target)
void	associateWithHandler (handler &, SampledImageAccessorBaseHost *, image_target)
std::vector< sycl::detail::pi::PiEvent >	getOrWaitEvents (std::vector< sycl::event > DepEvents, std::shared_ptr< sycl::detail::context_impl > Context)
void	waitEvents (std::vector< sycl::event > DepEvents)
void	markBufferAsInternal (const std::shared_ptr< buffer_impl > &BufImpl)
template<typename T >
T *	declptr ()
template<typename T >
T	get_or_store (const T *obj)
constexpr __spv::MemorySemanticsMask::Flag	getSPIRVMemorySemanticsMask (memory_order)
constexpr uint32_t	getSPIRVMemorySemanticsMask (const access::fence_space AccessSpace, const __spv::MemorySemanticsMask LocalScopeMask=__spv::MemorySemanticsMask::WorkgroupMemory)
template<size_t... Inds, class F >
void	loop_impl (std::integer_sequence< size_t, Inds... >, F &&f)
template<size_t count, class F >
void	loop (F &&f)
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, T >	UnnormalizeCoordinates (const T &Coords, const range< 3 > &Range)
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, vec< T, 2 > >	UnnormalizeCoordinates (const vec< T, 2 > &Coords, const range< 3 > &Range)
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, vec< T, 4 > >	UnnormalizeCoordinates (const vec< T, 4 > &Coords, const range< 3 > &Range)
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, float4 >	convertToFloat4 (T Coords)
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, float4 >	convertToFloat4 (vec< T, 2 > Coords)
template<typename T >
std::enable_if_t< IsValidCoordType< T >::value, float4 >	convertToFloat4 (vec< T, 4 > Coords)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, size_t >	getImageOffset (const T &Coords, const id< 3 >, const uint8_t ElementSize)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, size_t >	getImageOffset (const vec< T, 2 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, size_t >	getImageOffset (const vec< T, 4 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
int4	getPixelCoordNearestFiltMode (float4, const addressing_mode, const range< 3 >)
int8	getPixelCoordLinearFiltMode (float4, const addressing_mode, const range< 3 >, float4 &)
bool	isOutOfRange (const int4 PixelCoord, const addressing_mode SmplAddrMode, const range< 3 > ImgRange)
float4	getBorderColor (const image_channel_order ImgChannelOrder)
template<typename T >
vec< T, 4 >	readPixel (T *Ptr, const image_channel_order ChannelOrder, const image_channel_type ChannelType)
template<typename T >
void	writePixel (const vec< T, 4 > Pixel, T *Ptr, const image_channel_order ChannelOrder, const image_channel_type ChannelType)
template<typename ChannelType >
void	convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, uint4 &RetData)
template<typename ChannelType >
void	convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, int4 &RetData)
template<typename ChannelType >
void	convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, float4 &RetData)
template<typename ChannelType >
void	convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, half4 &RetData)
template<typename ChannelType >
vec< ChannelType, 4 >	convertWriteData (const uint4 WriteData, const image_channel_type ImageChannelType)
template<typename ChannelType >
vec< ChannelType, 4 >	convertWriteData (const int4 WriteData, const image_channel_type ImageChannelType)
template<typename ChannelType >
vec< ChannelType, 4 >	processFloatDataToPixel (float4 WriteData, float MulFactor)
template<typename ChannelType >
vec< ChannelType, 4 >	convertWriteData (const float4 WriteData, const image_channel_type ImageChannelType)
template<typename ChannelType >
vec< ChannelType, 4 >	convertWriteData (const half4 WriteData, const image_channel_type ImageChannelType)
template<typename CoordT , typename WriteDataT >
void	imageWriteHostImpl (const CoordT &Coords, const WriteDataT &Color, id< 3 > ImgPitch, uint8_t ElementSize, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr)
template<typename DataT >
DataT	ReadPixelData (const int4 PixelCoord, const id< 3 > ImgPitch, const image_channel_type ImageChannelType, const image_channel_order ImageChannelOrder, void *BasePtr, const uint8_t ElementSize)
template<typename DataT >
DataT	getColor (const int4 PixelCoord, const addressing_mode SmplAddrMode, const range< 3 > ImgRange, const id< 3 > ImgPitch, const image_channel_type ImgChannelType, const image_channel_order ImgChannelOrder, void *BasePtr, const uint8_t ElementSize)
template<typename DataT >
DataT	ReadPixelDataLinearFiltMode (const int8 CoordValues, const float4 abc, const addressing_mode SmplAddrMode, const range< 3 > ImgRange, id< 3 > ImgPitch, const image_channel_type ImgChannelType, const image_channel_order ImgChannelOrder, void *BasePtr, const uint8_t ElementSize)
template<typename CoordT , typename DataT >
DataT	imageReadSamplerHostImpl (const CoordT &Coords, coordinate_normalization_mode SmplNormMode, addressing_mode SmplAddrMode, filtering_mode SmplFiltMode, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, uint8_t ElementSize)
template<typename CoordT , typename DataT >
DataT	imageReadSamplerHostImpl (const CoordT &Coords, const sampler &Smpl, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, uint8_t ElementSize)
template<typename CoordT , typename DataT >
DataT	imageReadSamplerHostImpl (const CoordT &Coords, const image_sampler &Smpl, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, uint8_t ElementSize)
template<class Obj >
decltype(Obj::impl)	getSyclObjImpl (const Obj &SyclObject)
template<class T >
std::add_pointer_t< typename decltype(T::impl)::element_type >	getRawSyclObjImpl (const T &SyclObject)
template<class T >
T	createSyclObjFromImpl (decltype(T::impl) ImplObj)
template<auto & SpecName>
const char *	get_spec_constant_symbolic_ID_impl ()
template<auto & SpecName>
const char *	get_spec_constant_symbolic_ID ()
template<register_alloc_mode_enum Mode>
constexpr register_alloc_mode_key::value_t< Mode > register_alloc_mode	__SYCL_DEPRECATED ("register_alloc_mode is deprecated, " "use sycl::ext::intel::experimental::grf_size or " "sycl::ext::intel::experimental::grf_size_automatic")
void	memcpy (void *Dst, const void *Src, size_t Size)
template<sycl::backend BE>
void *	getPluginOpaqueData (void *opaquedata_arg)
template<typename KernelName , reduction::strategy Strategy = reduction::strategy::auto_select, int Dims, typename PropertiesT , typename... RestT>
void	reduction_parallel_for (handler &CGH, range< Dims > NDRange, PropertiesT Properties, RestT... Rest)
template<typename KernelName , reduction::strategy Strategy = reduction::strategy::auto_select, int Dims, typename PropertiesT , typename... RestT>
void	reduction_parallel_for (handler &CGH, nd_range< Dims > NDRange, PropertiesT Properties, RestT... Rest)
template<typename T , typename... Ts, std::size_t... Is>
std::tuple< Ts... >	get_tuple_tail_impl (const std::tuple< T, Ts... > &Tuple, const std::index_sequence< Is... > &)
template<typename T , typename... Ts>
std::tuple< Ts... >	get_tuple_tail (const std::tuple< T, Ts... > &Tuple)
template<typename... Ts>
constexpr tuple< Ts... >	make_tuple (Ts... Args)
template<typename... Ts>
auto	tie (Ts &...Args)
auto	getDeviceComparisonLambda ()
template<typename LastT >
void	fill_aspect_vector (std::vector< aspect > &V, LastT L)
template<typename FirstT , typename... OtherTs>
void	fill_aspect_vector (std::vector< aspect > &V, FirstT F, OtherTs... O)
device	select_device (const DSelectorInvocableType &DeviceSelectorInvocable)
device	select_device (const DSelectorInvocableType &DeviceSelectorInvocable, const context &SyclContext)
void	defaultAsyncHandler (exception_list Exceptions)
template<ext::oneapi::experimental::architecture... Archs>
constexpr static bool	allowable_aot_mode ()
template<ext::oneapi::experimental::architecture... Archs>
constexpr static bool	device_architecture_is ()
sycl::vec< unsigned, 4 >	ExtractMask (ext::oneapi::sub_group_mask Mask)
template<typename NonUniformGroup >
ext::oneapi::sub_group_mask	GetMask (NonUniformGroup Group)
template<typename NonUniformGroup >
uint32_t	IdToMaskPosition (NonUniformGroup Group, uint32_t Id)
template<typename DecorT , typename T , access::address_space Space, access::decorated IsDecorated>
DecorT *	getDecorated (multi_ptr< T, Space, IsDecorated > ptr)
void	workGroupBarrier ()
template<int Dimensions>
id< 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< sycl::sub_group > (sycl::sub_group g)
template<typename Group >
Group::linear_id_type	get_local_linear_id (Group g)
template<>
sycl::sub_group::linear_id_type	get_local_linear_id< sycl::sub_group > (sycl::sub_group g)
template<typename T , class BinaryOperation >
constexpr std::enable_if_t<(is_complex< T >::value &&is_plus< T, BinaryOperation >::value), T >	identity_for_ga_op ()
template<typename T , class BinaryOperation >
constexpr std::enable_if_t<(is_complex< T >::value &&is_multiplies< T, BinaryOperation >::value), T >	identity_for_ga_op ()
template<typename T , class BinaryOperation >
constexpr std::enable_if_t<!is_complex< T >::value, T >	identity_for_ga_op ()
template<typename Group , typename Ptr , class Function >
Function	for_each (Group g, Ptr first, Ptr last, Function f)
__SYCL_CONSTEXPR_HALF uint16_t	float2Half (const float &Val)
__SYCL_CONSTEXPR_HALF float	half2Float (const uint16_t &Val)
template<typename T >
T	cast_if_host_half (T val)
float	cast_if_host_half (half_impl::half val)
template<typename RetType , typename Func , typename Arg >
static Arg	member_ptr_helper (RetType(Func::*)(Arg) const)
template<typename F , typename SuggestedArgType >
SuggestedArgType	argument_helper (...)
bool	isDeviceGlobalUsedInKernel (const void *DeviceGlobalPtr)
template<int Dims, typename T >
std::enable_if_t< std::is_same_v< T, range< Dims > >||std::is_same_v< T, id< Dims > > >	checkValueRange (const T &V)
template<int Dims>
void	checkValueRange (const range< Dims > &R, const id< Dims > &O)
template<int Dims, typename T >
std::enable_if_t< std::is_same_v< T, nd_range< Dims > > >	checkValueRange (const T &V)
template<typename T >
static std::enable_if_t< std::is_unsigned_v< T >, bool >	multiply_with_overflow_check (T &dst, T x, T y)
template<int Dims>
bool	range_size_fits_in_size_t (const range< Dims > &r)
template<int Dimensions>
size_t	getOffsetForId (range< Dimensions > Range, id< Dimensions > Id, id< Dimensions > Offset)
id< 1 >	getDelinearizedId (const range< 1 > &, size_t Index)
id< 2 >	getDelinearizedId (const range< 2 > &Range, size_t Index)
id< 3 >	getDelinearizedId (const range< 3 > &Range, size_t Index)
image_channel_type	FormatChannelType (image_format Format)
image_channel_order	FormatChannelOrder (image_format Format)
kernel_id	get_kernel_id_impl (std::string KernelName)
detail::KernelBundleImplPtr	get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State)
const std::vector< 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)
void	enable_ext_oneapi_default_context (bool Val)
	Allows to enable/disable "Default Context" extension. More...
std::array< size_t, 3 >	rangeToArray (const range< 3 > &r)
std::array< size_t, 3 >	rangeToArray (const range< 2 > &r)
std::array< size_t, 3 >	rangeToArray (const range< 1 > &r)
template<typename... Ts>
ReduTupleT< Ts... >	makeReduTupleT (Ts... Elements)
size_t	reduGetMaxWGSize (std::shared_ptr< queue_impl > Queue, size_t LocalMemBytesPerWorkItem)
size_t	reduComputeWGSize (size_t NWorkItems, size_t MaxWGSize, size_t &NWorkGroups)
size_t	reduGetPreferredWGSize (std::shared_ptr< queue_impl > &Queue, size_t LocalMemBytesPerWorkItem)
template<typename ReducerT >
auto	getReducerAccess (ReducerT &Reducer)
template<class BinaryOp , int Dims, size_t Extent, bool ExplicitIdentity, typename RedOutVar , typename... RestTy>
auto	make_reduction (RedOutVar RedVar, RestTy &&...Rest)
template<typename KernelName , class Reduction >
void	reduSaveFinalResultToUserMem (handler &CGH, Reduction &Redu)
	Copies the final reduction result kept in read-write accessor to user's USM memory. More...
size_t	GreatestPowerOfTwo (size_t N)
	Computes the greatest power-of-two less than or equal to N. More...
template<typename FuncTy >
void	doTreeReductionHelper (size_t WorkSize, size_t LID, FuncTy Func)
template<WorkSizeGuarantees WSGuarantee, int Dim, typename LocalRedsTy , typename BinOpTy , typename AccessFuncTy >
void	doTreeReduction (size_t WorkSize, nd_item< Dim > NDIt, LocalRedsTy &LocalReds, BinOpTy &BOp, AccessFuncTy AccessFunc)
template<typename... LocalAccT, typename... BOPsT, size_t... Is>
void	doTreeReductionOnTuple (size_t WorkSize, size_t LID, ReduTupleT< LocalAccT... > &LocalAccs, ReduTupleT< BOPsT... > &BOPs, std::index_sequence< Is... >)
template<bool IsOneWG, typename... Reductions, size_t... Is>
auto	createReduOutAccs (size_t NWorkGroups, handler &CGH, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... >)
	For the given 'Reductions' types pack and indices enumerating them this function either creates new temporary accessors for partial sums (if IsOneWG is false) or returns user's accessor/USM-pointer if (IsOneWG is true). More...
template<typename OutAccT , typename LocalAccT , typename BOPT , typename IdentityContainerT >
auto	getLastCombine (OutAccT OutAcc, LocalAccT LocalAcc, BOPT BOP, IdentityContainerT IdentityContainer, bool IsInitializeToIdentity)
template<bool IsOneWG, typename... Reductions, typename... OutAccT, typename... LocalAccT, typename... BOPsT, typename... Ts, size_t... Is>
void	writeReduSumsToOutAccs (size_t OutAccIndex, ReduTupleT< OutAccT... > OutAccs, ReduTupleT< LocalAccT... > LocalAccs, ReduTupleT< BOPsT... > BOPs, ReduTupleT< Ts... > IdentityVals, std::array< bool, sizeof...(Reductions)> IsInitializeToIdentity, std::index_sequence< Is... >)
constexpr std::index_sequence	concat_sequences (std::index_sequence<>)
template<size_t I>
constexpr std::index_sequence< I >	concat_sequences (std::index_sequence< I >)
template<size_t... Is, size_t... Js>
constexpr std::index_sequence< Is..., Js... >	concat_sequences (std::index_sequence< Is... >, std::index_sequence< Js... >)
template<size_t... Is, size_t... Js, class... Rs>
constexpr auto	concat_sequences (std::index_sequence< Is... >, std::index_sequence< Js... >, Rs...)
template<typename... T, typename FunctorT , size_t... Is, std::enable_if_t<(sizeof...(Is) > 0), int > Z = 0>
constexpr auto	filterSequenceHelper (FunctorT, std::index_sequence< Is... >)
	For each index 'I' from the given indices pack 'Is' this function initially creates a number of short index_sequences, where each of such short index sequences is either empty (if the given Functor returns false for the type T[I]) or 1 element 'I' (otherwise). More...
template<typename... T, typename FunctorT , size_t... Is>
constexpr auto	filterSequence (FunctorT F, std::index_sequence< Is... > Indices)
	For each index 'I' from the given indices pack 'Is' this function returns an index sequence consisting of only those 'I's for which the 'FunctorT' applied to 'T[I]' returns true. More...
template<typename ElementType , typename BOPT >
constexpr auto	makeAdjustedBOP (BOPT &BOP)
template<typename... Reductions, typename... BOPsT, size_t... Is>
constexpr auto	makeAdjustedBOPs (ReduTupleT< BOPsT... > &BOPsTuple, std::index_sequence< Is... >)
template<typename... Reductions, typename... BOPsT>
constexpr auto	makeAdjustedBOPs (ReduTupleT< BOPsT... > &BOPsTuple)
template<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... Ts, typename... BOPsT, size_t... Is>
void	reduCGFuncImplScalar (nd_item< Dims > NDIt, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, std::tuple< ReducerT... > &ReducersTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... > ReduIndices)
	All scalar reductions are processed together; there is one loop of log2(N) steps, and each reduction uses its own storage. More...
template<bool IsOneWG, typename Reduction , int Dims, typename LocalAccT , typename OutAccT , typename ReducerT , typename BOPT >
void	reduCGFuncImplArrayHelper (nd_item< Dims > NDIt, LocalAccT LocalReds, OutAccT Out, ReducerT &Reducer, BOPT BOp, bool IsInitializeToIdentity)
	Each array reduction is processed separately. More...
template<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... OutAccT, typename... ReducerT, typename... BOPsT, size_t... Is>
void	reduCGFuncImplArray (nd_item< Dims > NDIt, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, std::tuple< ReducerT... > &ReducersTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... >)
template<typename KernelName , typename KernelType , int Dims, typename PropertiesT , typename... Reductions, size_t... Is>
void	reduCGFuncMulti (handler &CGH, KernelType KernelFunc, const nd_range< Dims > &Range, PropertiesT Properties, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... > ReduIndices)
template<typename... Reductions, size_t... Is>
void	associateReduAccsWithHandler (handler &CGH, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... >)
template<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void	reduAuxCGFuncImplScalar (nd_item< Dims > NDIt, size_t LID, size_t GID, size_t RemainingWorkSize, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< InAccT... > InAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... > ReduIndices)
	All scalar reductions are processed together; there is one loop of log2(N) steps, and each reduction uses its own storage. More...
template<bool IsOneWG, typename Reduction , int Dims, typename LocalAccT , typename InAccT , typename OutAccT , typename T , typename BOPT >
void	reduAuxCGFuncImplArrayHelper (nd_item< Dims > NDIt, size_t LID, size_t GID, size_t RemainingWorkSize, LocalAccT LocalReds, InAccT In, OutAccT Out, T IdentityContainer, BOPT BOp, bool IsInitializeToIdentity)
template<bool IsOneWG, typename... Reductions, int Dims, typename... LocalAccT, typename... InAccT, typename... OutAccT, typename... Ts, typename... BOPsT, size_t... Is>
void	reduAuxCGFuncImplArray (nd_item< Dims > NDIt, size_t LID, size_t GID, size_t RemainingWorkSize, ReduTupleT< LocalAccT... > LocalAccsTuple, ReduTupleT< InAccT... > InAccsTuple, ReduTupleT< OutAccT... > OutAccsTuple, ReduTupleT< Ts... > IdentitiesTuple, ReduTupleT< BOPsT... > BOPsTuple, std::array< bool, sizeof...(Reductions)> InitToIdentityProps, std::index_sequence< Is... >)
template<typename KernelName , typename KernelType , typename... Reductions, size_t... Is>
size_t	reduAuxCGFunc (handler &CGH, size_t NWorkItems, size_t MaxWGSize, std::tuple< Reductions... > &ReduTuple, std::index_sequence< Is... > ReduIndices)
template<typename Reduction >
size_t	reduGetMemPerWorkItemHelper (Reduction &)
template<typename Reduction , typename... RestT>
size_t	reduGetMemPerWorkItemHelper (Reduction &, RestT... Rest)
template<typename... ReductionT, size_t... Is>
size_t	reduGetMemPerWorkItem (std::tuple< ReductionT... > &ReduTuple, std::index_sequence< Is... >)
template<typename TupleT , std::size_t... Is>
std::tuple< std::tuple_element_t< Is, TupleT >... >	tuple_select_elements (TupleT Tuple, std::index_sequence< Is... >)
	Utility function: for the given tuple. More...
uint32_t	reduGetMaxNumConcurrentWorkGroups (std::shared_ptr< queue_impl > Queue)
unsigned	GetFlushBufOffset (const GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
void	SetFlushBufOffset (GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset, unsigned Offset)
void	write (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const char *Str, unsigned Len, unsigned Padding=0)
void	reverseBuf (char *Buf, unsigned Len)
template<typename T >
std::make_unsigned_t< T >	getAbsVal (const T Val, const int Base)
char	digitToChar (const int Digit)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, unsigned >	integralToBase (T Val, int Base, char *Digits)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, unsigned >	ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
unsigned	append (char *Dst, const char *Src)
unsigned	F2I32 (float Val)
unsigned long long	D2I64 (double Val)
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, bool >	isFastMathInf (T Val)
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, bool >	isFastMathNan (T Val)
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, bool >	isFastMathSignBit (T Val)
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, unsigned >	checkForInfNan (char *Buf, T Val)
template<typename T >
std::enable_if_t< std::is_same_v< T, half >, unsigned >	checkForInfNan (char *Buf, T Val)
template<typename T >
EnableIfFP< T, unsigned >	floatingPointToDecStr (T AbsVal, char *Digits, int Precision, bool IsSci)
template<typename T >
EnableIfFP< T, unsigned >	ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
template<typename T >
std::enable_if_t< std::is_integral_v< T > >	writeIntegral (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, const T &Val)
template<typename T >
EnableIfFP< T >	writeFloatingPoint (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const T &Val)
bool	updateOffset (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, unsigned Size, unsigned &Cur)
void	flushBuffer (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
template<typename T , int VecLength>
std::enable_if_t<(VecLength==1), unsigned >	VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
template<typename T , int VecLength>
std::enable_if_t<(VecLength==2||VecLength==4||VecLength==8||VecLength==16), unsigned >	VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
template<typename T , int VecLength>
std::enable_if_t<(VecLength==3), unsigned >	VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
template<typename T , int VecLength>
void	writeVec (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const vec< T, VecLength > &Vec)
template<int ArrayLength>
unsigned	ArrayToStr (char *Buf, const array< ArrayLength > &Arr)
template<int ArrayLength>
void	writeArray (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const array< ArrayLength > &Arr)
template<int Dimensions>
void	writeItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const item< Dimensions > &Item)
template<int Dimensions>
void	writeNDRange (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_range< Dimensions > &ND_Range)
template<int Dimensions>
void	writeNDItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_item< Dimensions > &ND_Item)
template<int Dimensions>
void	writeGroup (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const group< Dimensions > &Group)
template<int Dimensions>
unsigned	ItemToStr (char *Buf, const item< Dimensions, false > &Item)
template<int Dimensions>
void	writeHItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const h_item< Dimensions > &HItem)
template<typename CVT , access::address_space Space, access::decorated IsDecorated, typename T = std::remove_cv_t<CVT>>
multi_ptr< T, Space, IsDecorated >	GetUnqualMultiPtr (const multi_ptr< CVT, Space, IsDecorated > &Mptr)
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t< std::is_same_v< T, R >, R >	convertImpl (T Value)
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t<!std::is_same_v< T, R > &&(is_int_to_int< T, R >::value||is_int_to_float< T, R >::value||is_float_to_float< T, R >::value), R >	convertImpl (T Value)
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
std::enable_if_t< is_float_to_int< T, R >::value, R >	convertImpl (T Value)
constexpr bool	isValidVectorSize (int N)
template<typename T >
struct	__SYCL2020_DEPRECATED ("This type isn't device copyable in SYCL 2020") IsDeprecatedDeviceCopyable< T
static const PluginPtr &	getPlugin (backend Backend)
void	constructorNotification (void *BufferObj, void *AccessorObj, sycl::access::target Target, sycl::access::mode Mode, const detail::code_location &CodeLoc)
AllowListParsedT	parseAllowList (const std::string &AllowListRaw)
bool	deviceIsAllowed (const DeviceDescT &DeviceDesc, const AllowListParsedT &AllowListParsed)
void	applyAllowList (std::vector< sycl::detail::pi::PiDevice > &PiDevices, sycl::detail::pi::PiPlatform PiPlatform, const PluginPtr &Plugin)
template<class T >
backend	getImplBackend (const T &Impl)
static void	initValue (const char *Key, const char *Value)
void	readConfig (bool ForceInitialization)
void	dumpConfig ()
const std::array< std::pair< std::string, info::device_type >, 6 > &	getSyclDeviceTypeMap ()
const std::array< std::pair< std::string, backend >, 8 > &	getSyclBeMap ()
constexpr const char *	getStrOrNullptr (const char *Str)
template<>
class	__SYCL2020_DEPRECATED ("Use SYCLConfig<ONEAPI_DEVICE_SELECTOR> instead") SYCLConfig< SYCL_DEVICE_FILTER >
template<>
uint32_t	context_impl::get_info< info::context::reference_count > () const
template<>
platform	context_impl::get_info< info::context::platform > () const
template<>
std::vector< sycl::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 (sycl::detail::pi::PiContext Ctx, const PluginPtr &Plugin)
std::ostream &	operator<< (std::ostream &Out, const DeviceBinaryProperty &P)
std::vector< std::string_view >	tokenize (const std::string_view &Filter, const std::string &Delim)
static backend	Parse_ODS_Backend (const std::string_view &BackendStr, const std::string_view &FullEntry)
static void	Parse_ODS_Device (ods_target &Target, const std::string_view &DeviceStr)
std::vector< info::fp_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)
static bool	is_sycl_partition_property (info::partition_property PP)
template<int Dimensions>
range< Dimensions >	construct_range (size_t *values)=delete
template<>
range< 1 >	construct_range< 1 > (size_t *values)
template<>
range< 2 >	construct_range< 2 > (size_t *values)
template<>
range< 3 >	construct_range< 3 > (size_t *values)
template<typename Param >
Param::return_type	get_device_info (const DeviceImplPtr &Dev)
template<typename Param >
Param::return_type	get_device_info_host ()=delete
template<>
std::vector< sycl::aspect >	get_device_info_host< info::device::aspects > ()
template<>
ext::oneapi::experimental::architecture	get_device_info_host< ext::oneapi::experimental::info::device::architecture > ()
template<>
info::device_type	get_device_info_host< info::device::device_type > ()
template<>
uint32_t	get_device_info_host< info::device::vendor_id > ()
template<>
uint32_t	get_device_info_host< info::device::max_compute_units > ()
template<>
uint32_t	get_device_info_host< info::device::max_work_item_dimensions > ()
template<>
range< 1 >	get_device_info_host< info::device::max_work_item_sizes< 1 > > ()
template<>
range< 2 >	get_device_info_host< info::device::max_work_item_sizes< 2 > > ()
template<>
range< 3 >	get_device_info_host< info::device::max_work_item_sizes< 3 > > ()
template<>
constexpr size_t	get_device_info_host< ext::oneapi::experimental::info::device::max_global_work_groups > ()
template<>
id< 1 >	get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 1 > > ()
template<>
id< 2 >	get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 2 > > ()
template<>
id< 3 >	get_device_info_host< ext::oneapi::experimental::info::device::max_work_groups< 3 > > ()
template<>
constexpr size_t	get_device_info_host< info::device::ext_oneapi_max_global_work_groups > ()
template<>
id< 1 >	get_device_info_host< info::device::ext_oneapi_max_work_groups_1d > ()
template<>
id< 2 >	get_device_info_host< info::device::ext_oneapi_max_work_groups_2d > ()
template<>
id< 3 >	get_device_info_host< info::device::ext_oneapi_max_work_groups_3d > ()
template<>
size_t	get_device_info_host< info::device::max_work_group_size > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_char > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_short > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_int > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_long > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_float > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_double > ()
template<>
uint32_t	get_device_info_host< info::device::preferred_vector_width_half > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_char > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_short > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_int > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_long > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_float > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_double > ()
template<>
uint32_t	get_device_info_host< info::device::native_vector_width_half > ()
template<>
uint32_t	get_device_info_host< info::device::max_clock_frequency > ()
template<>
uint32_t	get_device_info_host< info::device::address_bits > ()
template<>
uint64_t	get_device_info_host< info::device::global_mem_size > ()
template<>
uint64_t	get_device_info_host< info::device::max_mem_alloc_size > ()
template<>
bool	get_device_info_host< info::device::image_support > ()
template<>
bool	get_device_info_host< info::device::atomic64 > ()
template<>
std::vector< memory_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<>
uint32_t	get_device_info_host< ext::codeplay::experimental::info::device::max_registers_per_work_group > ()
template<>
ext::oneapi::experimental::graph_support_level	get_device_info_host< ext::oneapi::experimental::info::device::graph_support > ()
template<>
uint32_t	get_device_info_host< ext::oneapi::experimental::info::device::image_row_pitch_align > ()
template<>
uint32_t	get_device_info_host< ext::oneapi::experimental::info::device::max_image_linear_row_pitch > ()
template<>
std::vector< ext::oneapi::experimental::matrix::combination >	get_device_info_host< ext::oneapi::experimental::info::device::matrix_combinations > ()
template<>
uint32_t	get_device_info_host< ext::oneapi::experimental::info::device::max_image_linear_width > ()
template<>
uint32_t	get_device_info_host< ext::oneapi::experimental::info::device::max_image_linear_height > ()
template<>
float	get_device_info_host< ext::oneapi::experimental::info::device::mipmap_max_anisotropy > ()
static uint64_t	getTimestamp ()
template<>
uint64_t	event_impl::get_profiling_info< info::event_profiling::command_submit > ()
template<>
uint64_t	event_impl::get_profiling_info< info::event_profiling::command_start > ()
template<>
uint64_t	event_impl::get_profiling_info< info::event_profiling::command_end > ()
template<>
uint32_t	event_impl::get_info< info::event::reference_count > ()
template<>
info::event_command_status	event_impl::get_info< info::event::command_execution_status > ()
template<typename Param >
Param::return_type	get_event_profiling_info (sycl::detail::pi::PiEvent Event, const PluginPtr &Plugin)
template<typename Param >
Param::return_type	get_event_info (sycl::detail::pi::PiEvent Event, const PluginPtr &Plugin)
static void	enableOnCrashStackPrinting ()
void	shutdown ()
	__attribute__ ((destructor(110))) static void syclUnload()
std::vector< sycl::detail::pi::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)
sycl::detail::pi::PiMemImageChannelOrder	convertChannelOrder (image_channel_order Order)
image_channel_order	convertChannelOrder (sycl::detail::pi::PiMemImageChannelOrder Order)
sycl::detail::pi::PiMemImageChannelType	convertChannelType (image_channel_type Type)
image_channel_type	convertChannelType (sycl::detail::pi::PiMemImageChannelType Type)
template<typename T >
static void	getImageInfo (const ContextImplPtr Context, sycl::detail::pi::PiMemImageInfo Info, T &Dest, sycl::detail::pi::PiMem InteropMemObject)
KernelArgMask	createKernelArgMask (const ByteArray &Bytes)
static bool	checkAllDevicesAreInContext (const std::vector< device > &Devices, const context &Context)
static bool	checkAllDevicesHaveAspect (const std::vector< device > &Devices, aspect Aspect)
template<>
context	kernel_impl::get_info< info::kernel::context > () const
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, std::string >::value, std::string >::type	get_kernel_info (sycl::detail::pi::PiKernel Kernel, const PluginPtr &Plugin)
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, uint32_t >::value, uint32_t >::type	get_kernel_info (sycl::detail::pi::PiKernel Kernel, const PluginPtr &Plugin)
template<typename Param >
std::enable_if< IsSubGroupInfo< Param >::value >::type	get_kernel_device_specific_info_helper (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &Plugin, void *Result, size_t Size)
template<typename Param >
std::enable_if<!IsSubGroupInfo< Param >::value >::type	get_kernel_device_specific_info_helper (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &Plugin, void *Result, size_t Size)
template<typename Param >
std::enable_if< !std::is_same< typename Param::return_type, sycl::range< 3 > >::value, typename Param::return_type >::type	get_kernel_device_specific_info (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &Plugin)
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, sycl::range< 3 > >::value, sycl::range< 3 > >::type	get_kernel_device_specific_info (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, const PluginPtr &Plugin)
template<typename Param >
uint32_t	get_kernel_device_specific_info_with_input (sycl::detail::pi::PiKernel Kernel, sycl::detail::pi::PiDevice Device, sycl::range< 3 > In, const PluginPtr &Plugin)
template<typename Param >
Param::return_type	get_kernel_device_specific_info_host (const sycl::device &Device)=delete
template<>
sycl::range< 3 >	get_kernel_device_specific_info_host< info::kernel_device_specific::global_work_size > (const sycl::device &)
template<>
size_t	get_kernel_device_specific_info_host< info::kernel_device_specific::work_group_size > (const sycl::device &Dev)
template<>
sycl::range< 3 >	get_kernel_device_specific_info_host< info::kernel_device_specific::compile_work_group_size > (const sycl::device &)
template<>
size_t	get_kernel_device_specific_info_host< info::kernel_device_specific::preferred_work_group_size_multiple > (const sycl::device &Dev)
template<>
size_t	get_kernel_device_specific_info_host< info::kernel_device_specific::private_mem_size > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::ext_codeplay_num_regs > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::max_num_sub_groups > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::max_sub_group_size > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::compile_num_sub_groups > (const sycl::device &)
template<>
uint32_t	get_kernel_device_specific_info_host< info::kernel_device_specific::compile_sub_group_size > (const sycl::device &)
void	memBufferCreateHelper (const PluginPtr &Plugin, pi_context Ctx, pi_mem_flags Flags, size_t Size, void *HostPtr, pi_mem *RetMem, const pi_mem_properties *Props=nullptr)
void	memReleaseHelper (const PluginPtr &Plugin, pi_mem Mem)
void	memBufferMapHelper (const PluginPtr &Plugin, pi_queue command_queue, pi_mem buffer, pi_bool blocking_map, pi_map_flags map_flags, size_t offset, size_t size, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event, void **ret_map)
void	memUnmapHelper (const PluginPtr &Plugin, pi_queue command_queue, pi_mem memobj, void *mapped_ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event)
uint64_t	emitMemAllocBeginTrace (uintptr_t ObjHandle, size_t AllocSize, size_t GuardZone)
void	emitMemAllocEndTrace (uintptr_t ObjHandle, uintptr_t AllocPtr, size_t AllocSize, size_t GuardZone, uint64_t CorrelationID)
uint64_t	emitMemReleaseBeginTrace (uintptr_t ObjHandle, uintptr_t AllocPtr)
void	emitMemReleaseEndTrace (uintptr_t ObjHandle, uintptr_t AllocPtr, uint64_t CorrelationID)
static void	waitForEvents (const std::vector< EventImplPtr > &Events)
static sycl::detail::pi::PiMemFlags	getMemObjCreationFlags (void *UserPtr, bool HostPtrReadOnly)
void	prepTermPositions (TermPositions &pos, int Dimensions, detail::SYCLMemObjI::MemObjType Type)
void	copyH2D (SYCLMemObjI *SYCLMemObj, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, sycl::detail::pi::PiMem DstMem, QueueImplPtr TgtQueue, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< sycl::detail::pi::PiEvent > DepEvents, sycl::detail::pi::PiEvent &OutEvent, const detail::EventImplPtr &OutEventImpl)
void	copyD2H (SYCLMemObjI *SYCLMemObj, sycl::detail::pi::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< sycl::detail::pi::PiEvent > DepEvents, sycl::detail::pi::PiEvent &OutEvent, const detail::EventImplPtr &OutEventImpl)
void	copyD2D (SYCLMemObjI *SYCLMemObj, sycl::detail::pi::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, sycl::detail::pi::PiMem DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 >, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< sycl::detail::pi::PiEvent > DepEvents, sycl::detail::pi::PiEvent &OutEvent, const detail::EventImplPtr &OutEventImpl)
static void	copyH2H (SYCLMemObjI *, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< sycl::detail::pi::PiEvent >, sycl::detail::pi::PiEvent &, const detail::EventImplPtr &)
static void	memcpyToDeviceGlobalUSM (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, const void *Src, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent, const detail::EventImplPtr &OutEventImpl)
static void	memcpyFromDeviceGlobalUSM (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, void *Dest, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent, const detail::EventImplPtr &OutEventImpl)
static sycl::detail::pi::PiProgram	getOrBuildProgramForDeviceGlobal (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry)
static void	memcpyToDeviceGlobalDirect (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, const void *Src, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent)
static void	memcpyFromDeviceGlobalDirect (QueueImplPtr Queue, DeviceGlobalMapEntry *DeviceGlobalEntry, size_t NumBytes, size_t Offset, void *Dest, const std::vector< sycl::detail::pi::PiEvent > &DepEvents, sycl::detail::pi::PiEvent *OutEvent)
static bool	IsSupportedImageFormat (sycl::detail::pi::PiDeviceBinaryType Format)
std::string	getDirName (const char *Path)
template void *	getPluginOpaqueData< sycl::backend::ext_intel_esimd_emulator > (void *)
static bool	IsBannedPlatform (platform Platform)
static bool	supportsAffinityDomain (const device &dev, info::partition_property partitionProp, info::partition_affinity_domain domain)
static bool	supportsPartitionProperty (const device &dev, info::partition_property partitionProp)
static std::vector< 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 (sycl::detail::pi::PiPlatform Plt, const PluginPtr &Plugin, pi_platform_info PiCode)
template<typename Param >
std::enable_if< std::is_same< typename Param::return_type, std::string >::value, std::string >::type	get_platform_info (sycl::detail::pi::PiPlatform Plt, const PluginPtr &Plugin)
template<typename Param >
std::enable_if< std::is_same< Param, info::platform::extensions >::value, std::vector< std::string > >::type	get_platform_info (sycl::detail::pi::PiPlatform Plt, const PluginPtr &Plugin)
template<typename Param >
Param::return_type	get_platform_info_host ()=delete
template<>
std::string	get_platform_info_host< info::platform::profile > ()
template<>
std::string	get_platform_info_host< info::platform::version > ()
template<>
std::string	get_platform_info_host< info::platform::name > ()
template<>
std::string	get_platform_info_host< info::platform::vendor > ()
template<>
std::vector< std::string >	get_platform_info_host< info::platform::extensions > ()
template<typename... Ts>
constexpr size_t	totalSize (const std::tuple< Ts... > &)
template<PiApiKind Kind, typename... ArgsT>
auto	packCallArguments (ArgsT &&...Args)
static constexpr char	UseSpvEnv ("SYCL_USE_KERNEL_SPV")
static void	enableITTAnnotationsIfNeeded (const sycl::detail::pi::PiProgram &Prog, const PluginPtr &Plugin)
	This function enables ITT annotations in SPIR-V module by setting a specialization constant if INTEL_LIBITTNOTIFY64 env variable is set. More...
static sycl::detail::pi::PiProgram	createBinaryProgram (const ContextImplPtr Context, const device &Device, const unsigned char *Data, size_t DataLen, const std::vector< pi_device_binary_property > Metadata)
static sycl::detail::pi::PiProgram	createSpirvProgram (const ContextImplPtr Context, const unsigned char *Data, size_t DataLen)
template<typename RetT , typename ExceptionT , typename GetCachedBuildFT , typename BuildFT >
KernelProgramCache::BuildResult< RetT > *	getOrBuild (KernelProgramCache &KPCache, GetCachedBuildFT &&GetCachedBuild, BuildFT &&Build)
	Try to fetch entity (kernel or program) from cache. More...
static bool	isDeviceBinaryTypeSupported (const context &C, sycl::detail::pi::PiDeviceBinaryType Format)
static const char *	getFormatStr (sycl::detail::pi::PiDeviceBinaryType Format)
static void	appendLinkOptionsFromImage (std::string &LinkOpts, const RTDeviceBinaryImage &Img)
static bool	getUint32PropAsBool (const RTDeviceBinaryImage &Img, const char *PropName)
static std::string	getUint32PropAsOptStr (const RTDeviceBinaryImage &Img, const char *PropName)
static void	appendCompileOptionsForGRFSizeProperties (std::string &CompileOpts, const RTDeviceBinaryImage &Img, bool IsEsimdImage)
static void	appendCompileOptionsFromImage (std::string &CompileOpts, const RTDeviceBinaryImage &Img, const std::vector< device > &Devs, const PluginPtr &)
static void	applyOptionsFromImage (std::string &CompileOpts, std::string &LinkOpts, const RTDeviceBinaryImage &Img, const std::vector< device > &Devices, const PluginPtr &Plugin)
static void	applyCompileOptionsFromEnvironment (std::string &CompileOpts)
static void	applyLinkOptionsFromEnvironment (std::string &LinkOpts)
static void	applyOptionsFromEnvironment (std::string &CompileOpts, std::string &LinkOpts)
static void	emitBuiltProgramInfo (const pi_program &Prog, const ContextImplPtr &Context)
	Emits information about built programs if the appropriate contitions are met, namely when SYCL_RT_WARNING_LEVEL is greater than or equal to 2. More...
static bool	loadDeviceLib (const ContextImplPtr Context, const char *Name, sycl::detail::pi::PiProgram &Prog)
static const char *	getDeviceLibFilename (DeviceLibExt Extension, bool Native)
static const char *	getDeviceLibExtensionStr (DeviceLibExt Extension)
static sycl::detail::pi::PiProgram	loadDeviceLibFallback (const ContextImplPtr Context, DeviceLibExt Extension, const sycl::detail::pi::PiDevice &Device, bool UseNativeLib)
void	CheckJITCompilationForImage (const RTDeviceBinaryImage *const &Image, bool JITCompilationIsRequired)
template<typename StorageKey >
RTDeviceBinaryImage *	getBinImageFromMultiMap (const std::unordered_multimap< StorageKey, RTDeviceBinaryImage * > &ImagesSet, const StorageKey &Key, const context &Context, const device &Device)
static bool	isDeviceLibRequired (DeviceLibExt Ext, uint32_t DeviceLibReqMask)
static std::vector< sycl::detail::pi::PiProgram >	getDeviceLibPrograms (const ContextImplPtr Context, const sycl::detail::pi::PiDevice &Device, uint32_t DeviceLibReqMask)
static bundle_state	getBinImageState (const RTDeviceBinaryImage *BinImage)
static bool	compatibleWithDevice (RTDeviceBinaryImage *BinImage, const device &Dev)
static void	setSpecializationConstants (const std::shared_ptr< device_image_impl > &InputImpl, sycl::detail::pi::PiProgram Prog, const PluginPtr &Plugin)
bool	doesDevSupportDeviceRequirements (const device &Dev, const RTDeviceBinaryImage &Img)
static std::string	getAspectNameStr (sycl::aspect AspectNum)
template<typename T >
static std::enable_if_t< std::is_unsigned_v< T >, std::optional< T > >	multiply_with_overflow_check (T x, T y)
std::optional< sycl::exception >	checkDevSupportDeviceRequirements (const device &Dev, const RTDeviceBinaryImage &Img)
template<>
uint32_t	queue_impl::get_info< info::queue::reference_count > () const
template<>
context	queue_impl::get_info< info::queue::context > () const
template<>
device	queue_impl::get_info< info::queue::device > () const
static event	prepareSYCLEventAssociatedWithQueue (const std::shared_ptr< detail::queue_impl > &QueueImpl)
static event	createDiscardedEvent ()
void	report (const code_location &CodeLoc)
uint32_t	reduGetMaxNumConcurrentWorkGroups (std::shared_ptr< sycl::detail::queue_impl > Queue)
size_t	reduGetMaxWGSize (std::shared_ptr< sycl::detail::queue_impl > Queue, size_t LocalMemBytesPerWorkItem)
static std::string	demangleKernelName (std::string Name)
static std::string	deviceToString (device Device)
void	applyFuncOnFilteredArgs (const KernelArgMask *EliminatedArgMask, std::vector< ArgDesc > &Args, std::function< void(detail::ArgDesc &Arg, int NextTrueIndex)> Func)
static std::string	accessModeToString (access::mode Mode)
static void	flushCrossQueueDeps (const std::vector< EventImplPtr > &EventImpls, const QueueImplPtr &Queue)
static std::string	cgTypeToString (detail::CG::CGTYPE Type)
void	emitKernelInstrumentationData (const std::shared_ptr< detail::kernel_impl > &SyclKernel, const detail::code_location &CodeLoc, const std::string &SyclKernelName, const QueueImplPtr &Queue, const NDRDescT &NDRDesc, const std::shared_ptr< detail::kernel_bundle_impl > &KernelBundleImplPtr, std::vector< ArgDesc > &CGArgs)
static void	adjustNDRangePerKernel (NDRDescT &NDR, sycl::detail::pi::PiKernel Kernel, const device_impl &DeviceImpl)
void	ReverseRangeDimensionsForKernel (NDRDescT &NDR)
pi_mem_obj_access	AccessModeToPi (access::mode AccessorMode)
void	SetArgBasedOnType (const PluginPtr &Plugin, sycl::detail::pi::PiKernel Kernel, const std::shared_ptr< device_image_impl > &DeviceImageImpl, const std::function< void *(Requirement *Req)> &getMemAllocationFunc, const sycl::context &Context, bool IsHost, detail::ArgDesc &Arg, size_t NextTrueIndex)
static pi_result	SetKernelParamsAndLaunch (const QueueImplPtr &Queue, std::vector< ArgDesc > &Args, const std::shared_ptr< device_image_impl > &DeviceImageImpl, sycl::detail::pi::PiKernel Kernel, NDRDescT &NDRDesc, std::vector< sycl::detail::pi::PiEvent > &RawEvents, const detail::EventImplPtr &OutEventImpl, const KernelArgMask *EliminatedArgMask, const std::function< void *(Requirement *Req)> &getMemAllocationFunc)
void	DispatchNativeKernel (void *Blob)
pi_int32	enqueueImpCommandBufferKernel (context Ctx, DeviceImplPtr DeviceImpl, sycl::detail::pi::PiExtCommandBuffer CommandBuffer, const CGExecKernel &CommandGroup, std::vector< sycl::detail::pi::PiExtSyncPoint > &SyncPoints, sycl::detail::pi::PiExtSyncPoint *OutSyncPoint, const std::function< void *(Requirement *Req)> &getMemAllocationFunc)
pi_int32	enqueueImpKernel (const QueueImplPtr &Queue, NDRDescT &NDRDesc, std::vector< ArgDesc > &Args, const std::shared_ptr< detail::kernel_bundle_impl > &KernelBundleImplPtr, const std::shared_ptr< detail::kernel_impl > &MSyclKernel, const std::string &KernelName, std::vector< sycl::detail::pi::PiEvent > &RawEvents, const detail::EventImplPtr &OutEventImpl, const std::function< void *(Requirement *Req)> &getMemAllocationFunc, sycl::detail::pi::PiKernelCacheConfig KernelCacheConfig)
pi_int32	enqueueReadWriteHostPipe (const QueueImplPtr &Queue, const std::string &PipeName, bool blocking, void *ptr, size_t size, std::vector< sycl::detail::pi::PiEvent > &RawEvents, const detail::EventImplPtr &OutEventImpl, bool read)
void	SetArgBasedOnType (const detail::plugin &Plugin, sycl::detail::pi::PiKernel Kernel, const std::shared_ptr< device_image_impl > &DeviceImageImpl, const std::function< void *(Requirement *Req)> &getMemAllocationFunc, const sycl::context &Context, bool IsHost, detail::ArgDesc &Arg, size_t NextTrueIndex)
static bool	doOverlap (const Requirement *LHS, const Requirement *RHS)
	Checks whether two requirements overlap or not. More...
static bool	sameCtx (const ContextImplPtr &LHS, const ContextImplPtr &RHS)
static bool	IsSuitableSubReq (const Requirement *Req)
	Checks if current requirement is requirement for sub buffer. More...
static bool	isAccessModeAllowed (access::mode Required, access::mode Current)
	Checks if the required access mode is allowed under the current one. More...
static access::mode	combineAccessModes (access::mode A, access::mode B)
	Combines two access modes into a single one that allows both. More...
static bool	markNodeAsVisited (Command *Cmd, std::vector< Command * > &Visited)
static void	unmarkVisitedNodes (std::vector< Command * > &Visited)
static void	handleVisitedNodes (std::vector< Command * > &Visited)
static void	printDotRecursive (std::fstream &Stream, std::vector< Command * > &Visited, Command *Cmd)
static 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)
sycl::detail::pi::PiMemObjectType	getImageType (int Dimensions)
void	force_type (info::device_type &t, const info::device_type &ft)
static int	getDevicePreference (const device &Device)
static void	traceDeviceSelection (const device &Device, int Score, bool Chosen)
device	select_device (DSelectorInvocableType DeviceSelectorInvocable, std::vector< device > &Devices)
ESIMDDeviceInterface *	getESIMDDeviceInterface ()
sycl::detail::pi::PiImageCopyFlags	getPiImageCopyFlags (sycl::usm::alloc SrcPtrType, sycl::usm::alloc DstPtrType)

Variables
template<typename T >
constexpr bool	use_fast_math_v = use_fast_math<T>::value
template<typename... Ts>
constexpr bool	check_type_in_v = CheckTypeIn<Ts...>()
template<typename T1 , typename T2 >
constexpr bool	is_same_op_v = is_same_op<T1, T2>::value
template<typename... Ts>
constexpr bool	check_all_same_op_type_v = CheckAllSameOpType<Ts...>()
template<size_t... Ns>
constexpr bool	check_size_in_v = CheckSizeIn<Ns...>()
template<typename T , typename... Ts>
constexpr bool	is_valid_elem_type_v = is_valid_elem_type<T, Ts...>::value
template<typename T >
constexpr access::decorated	get_multi_ptr_decoration_v
template<typename T >
constexpr bool	has_writeable_addr_space_v = has_writeable_addr_space<T>::value
template<typename T >
constexpr bool	is_swizzle_v = is_swizzle<T>::value
template<typename T >
constexpr bool	is_vec_or_swizzle_v = is_vec_v<T> || is_swizzle_v<T>
template<typename T , int... Ns>
constexpr bool	is_valid_size_v = is_valid_size<T, Ns...>::value
template<class T >
constexpr bool	is_fixed_size_group_v = is_fixed_size_group<T>::value
template<typename T >
constexpr bool	is_vec_v = is_vec<T>::value
template<typename T >
constexpr bool	is_marray_v = is_marray<T>::value
template<class T >
constexpr bool	is_multi_ptr_v = is_multi_ptr<T>::value
template<class T >
constexpr bool	is_non_legacy_multi_ptr_v
template<class T >
constexpr bool	is_legacy_multi_ptr_v = is_legacy_multi_ptr<T>::value
constexpr size_t	MaxVecAlignment = 64
static constexpr int	REJECT_DEVICE_SCORE = -1
static constexpr ext::oneapi::experimental::architecture	max_architecture
static constexpr bool	is_allowable_aot_mode
static constexpr IsAOTForArchitectureClass	is_aot_for_architecture
template<typename F , typename SuggestedArgType >
decltype(member_ptr_helper(&F::operator()))	argument_helper (int)
static constexpr FmtFlags	Dec = 0x0001
static constexpr FmtFlags	Hex = 0x0002
static constexpr FmtFlags	Oct = 0x0004
static constexpr FmtFlags	ShowBase = 0x0008
static constexpr FmtFlags	ShowPos = 0x0010
static constexpr FmtFlags	Fixed = 0x0020
static constexpr FmtFlags	Scientific = 0x0040
static constexpr FmtFlags	BaseField = Dec | Hex | Oct
static constexpr FmtFlags	FloatField = Scientific | Fixed
constexpr size_t	MAX_FLOATING_POINT_DIGITS = 24
constexpr size_t	MAX_INTEGRAL_DIGITS = 23
constexpr const char *	VEC_ELEMENT_DELIMITER = ", "
constexpr char	VEC_OPEN_BRACE = '{'
constexpr char	VEC_CLOSE_BRACE = '}'
constexpr size_t	MAX_DIMENSIONS = 3
constexpr size_t	MAX_ARRAY_SIZE
constexpr unsigned	FLUSH_BUF_OFFSET_SIZE = 2
constexpr static access::address_space	GlobalBufAS
constexpr static int	GlobalBufDim = 1
constexpr static access::address_space	GlobalOffsetAS
constexpr static int	GlobalOffsetDim = 1
constexpr size_t	MAX_ITEM_SIZE = 2 * MAX_ARRAY_SIZE + 20
constexpr char	BackendNameKeyName [] = "BackendName"
constexpr char	DeviceTypeKeyName [] = "DeviceType"
constexpr char	DeviceVendorIdKeyName [] = "DeviceVendorId"
constexpr char	DriverVersionKeyName [] = "DriverVersion"
constexpr char	PlatformVersionKeyName [] = "PlatformVersion"
constexpr char	DeviceNameKeyName [] = "DeviceName"
constexpr char	PlatformNameKeyName [] = "PlatformName"
constexpr std::array< const char *, 7 >	SupportedAllowListKeyNames
static thread_local detail::code_location	GCodeLocTLS = {}
	CodeLocation information slot in thread local storage. More...
constexpr bool	ConfigFromEnvEnabled = true
constexpr bool	ConfigFromFileEnabled = true
constexpr bool	ConfigFromCompileDefEnabled = true
constexpr int	MAX_CONFIG_NAME = 256
constexpr int	MAX_CONFIG_VALUE = 1024
static constexpr int	DbgProgMgr = 0
static const std::map< DeviceLibExt, std::pair< const char *, const char * > >	DeviceLibNames
static const std::map< DeviceLibExt, const char * >	DeviceLibExtensionStrs
static constexpr uint32_t	ITTSpecConstId = 0xFF747469
static constexpr size_t	MaxNumQueues = 256
	Sets max number of queues supported by FPGA RT. More...
constexpr CUDAContextT	DefaultContextType = CUDAContextT::custom
	Default context type created for CUDA backend. More...
constexpr const char *	SYCL_STREAM_NAME = "sycl"
constexpr const char *	SYCL_PICALL_STREAM_NAME = "sycl.pi"
constexpr const char *	SYCL_PIDEBUGCALL_STREAM_NAME = "sycl.pi.debug"
constexpr auto	SYCL_MEM_ALLOC_STREAM_NAME
constexpr const char *	SYCL_BUFFER_STREAM_NAME
constexpr const char *	SYCL_IMAGE_STREAM_NAME = "sycl.experimental.image"

Typedef Documentation

__sycl_init_mem_for

template<class KernelName >

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

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

We must do that to avoid name collisions.

Definition at line 843 of file reduction.hpp.

__sycl_reduction_kernel

template<template< typename, reduction::strategy, typename... > class MainOrAux, class KernelName , reduction::strategy Strategy, class... Ts>

using sycl::_V1::detail::__sycl_reduction_kernel = typedef std::conditional_t<std::is_same_v<KernelName, auto_name>, auto_name, MainOrAux<KernelName, Strategy, Ts...> >

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

We must do that to avoid name collisions.

Definition at line 1233 of file reduction.hpp.

AccessorImplPtr

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

Definition at line 532 of file accessor.hpp.

address_space_list

template<access::address_space... Values>

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

Definition at line 84 of file type_list.hpp.

AllowListParsedT

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

Definition at line 23 of file allowlist.hpp.

bool_elements_t

template<typename T >

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

Definition at line 162 of file builtins_utils_vec.hpp.

change_base_type_t

template<typename T , typename B >

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

Definition at line 161 of file type_traits.hpp.

change_elements_t

template<typename NewElemT , typename T >

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

Definition at line 159 of file builtins_utils_vec.hpp.

CommandPtr

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

Definition at line 188 of file scheduler.hpp.

common_rel_ret_t

template<typename T >

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

Definition at line 658 of file generic_type_traits.hpp.

const_if_const_AS

template<access::address_space AS, class DataT >

using sycl::_V1::detail::const_if_const_AS = typedef DataT

Definition at line 480 of file type_traits.hpp.

ContextImplPtr

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

Definition at line 33 of file event_impl.hpp.

convert_data_type

template<typename T , typename B >

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

Definition at line 334 of file generic_type_traits.hpp.

ConvertToOpenCLType_t

template<typename T >

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

Definition at line 619 of file generic_type_traits.hpp.

ConvertToOpenCLTypeImpl_t

template<typename T >

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

Definition at line 616 of file generic_type_traits.hpp.

copy_cv_qualifiers_t

template<typename T , typename R >

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

Definition at line 121 of file type_traits.hpp.

DeviceDescT

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

Definition at line 22 of file allowlist.hpp.

DeviceImageImplPtr

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

Definition at line 79 of file kernel_bundle.hpp.

DeviceImplPtr

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

Definition at line 65 of file program_manager.hpp.

DevImgSelectorImpl

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

Definition at line 486 of file kernel_bundle.hpp.

DSelectorInvocableType

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

Definition at line 122 of file device_selector.hpp.

empty_type_list

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

Definition at line 26 of file type_list.hpp.

EnableIfFP

template<class F , class T = void>

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

Definition at line 89 of file stream.hpp.

EnableIfImgAccDataT

template<typename DataT >

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

Definition at line 124 of file image.hpp.

EnableIfOutputIteratorT

template<typename DataT >

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

Definition at line 38 of file common.hpp.

EnableIfOutputPointerT

template<typename DataT >

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

Definition at line 34 of file common.hpp.

EnableIfSwizzleVec

template<typename T >

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

Definition at line 745 of file stream.hpp.

EnableIfSYCL2020DeviceSelectorInvocable

template<typename DeviceSelector >

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

Definition at line 143 of file device_selector.hpp.

EventImplPtr

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

Definition at line 39 of file cg.hpp.

find_same_size_type_t

template<typename TypeList , typename T >

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

Definition at line 117 of file type_list.hpp.

find_twice_as_large_type_t

template<typename TypeList , typename T >

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

Definition at line 121 of file type_list.hpp.

find_type_t

template<typename TypeList , template< typename, typename > class Comp, typename T >

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

Definition at line 114 of file type_list.hpp.

FmtFlags

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

Definition at line 46 of file stream.hpp.

FusionList

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

Definition at line 189 of file scheduler.hpp.

FusionMap

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

Definition at line 190 of file scheduler.hpp.

get_elem_type_t

template<typename T >

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

Definition at line 41 of file builtins_utils_scalar.hpp.

get_select_opencl_builtin_c_arg_type

template<typename T >

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

Definition at line 69 of file builtins_utils_scalar.hpp.

GlobalBufAccessorT

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

Definition at line 92 of file stream.hpp.

GlobalBufPtrType

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

Definition at line 97 of file stream.hpp.

GlobalOffsetAccessorT

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

Definition at line 101 of file stream.hpp.

GlobalOffsetPtrType

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

Definition at line 106 of file stream.hpp.

head_t

template<typename T >

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

Definition at line 19 of file type_list.hpp.

image_allocator

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

Definition at line 41 of file image_impl.hpp.

int64_t

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

Definition at line 35 of file kernel_desc.hpp.

int_constant

template<int V>

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

Definition at line 123 of file type_traits.hpp.

int_elements_t

template<typename T >

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

Definition at line 161 of file builtins_utils_vec.hpp.

internal_rel_ret_t

template<typename T >

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

Definition at line 688 of file generic_type_traits.hpp.

is_arithmetic_or_complex

template<typename T >

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

Definition at line 139 of file group_algorithm.hpp.

is_charn

template<typename T >

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

Definition at line 112 of file generic_type_traits.hpp.

is_doublen

template<typename T >

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

Definition at line 37 of file generic_type_traits.hpp.

is_float_to_float

template<typename T , typename R >

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

Definition at line 272 of file types.hpp.

is_float_to_int

template<typename T , typename R >

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

Definition at line 267 of file types.hpp.

is_floatn

template<typename T >

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

Definition at line 29 of file generic_type_traits.hpp.

is_gen_based_on_type_sizeof

template<typename T , int N, template< typename > class S>

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

Definition at line 264 of file type_traits.hpp.

is_genbool

template<typename T >

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

Definition at line 195 of file generic_type_traits.hpp.

is_genchar

template<typename T >

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

Definition at line 126 of file generic_type_traits.hpp.

is_gencross

template<typename T >

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

Definition at line 106 of file generic_type_traits.hpp.

is_gencrossdouble

template<typename T >

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

Definition at line 100 of file generic_type_traits.hpp.

is_gencrossfloat

template<typename T >

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

Definition at line 97 of file generic_type_traits.hpp.

is_gencrosshalf

template<typename T >

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

Definition at line 103 of file generic_type_traits.hpp.

is_gencrossmarray

template<typename T >

using sycl::_V1::detail::is_gencrossmarray = typedef is_contained<T, gtl::cross_marray_list>

Definition at line 109 of file generic_type_traits.hpp.

is_genfloat

template<typename T >

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

Definition at line 53 of file generic_type_traits.hpp.

is_genfloatd

template<typename T >

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

Definition at line 39 of file generic_type_traits.hpp.

is_genfloatf

template<typename T >

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

Definition at line 31 of file generic_type_traits.hpp.

is_genfloath

template<typename T >

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

Definition at line 46 of file generic_type_traits.hpp.

is_genfloatptr

template<typename T >

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

Definition at line 259 of file generic_type_traits.hpp.

is_genfloatptr_marray

template<typename T , access::address_space AddressSpace, access::decorated IsDecorated>

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

Definition at line 268 of file generic_type_traits.hpp.

is_gengeodouble

template<typename T >

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

Definition at line 73 of file generic_type_traits.hpp.

is_gengeofloat

template<typename T >

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

Definition at line 70 of file generic_type_traits.hpp.

is_gengeohalf

template<typename T >

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

Definition at line 81 of file generic_type_traits.hpp.

is_gengeomarray

template<typename T >

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

Definition at line 79 of file generic_type_traits.hpp.

is_gengeomarrayfloat

template<typename T >

using sycl::_V1::detail::is_gengeomarrayfloat = typedef is_contained<T, gtl::marray_geo_float_list>

Definition at line 76 of file generic_type_traits.hpp.

is_genint

template<typename T >

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

Definition at line 149 of file generic_type_traits.hpp.

is_geninteger

template<typename T >

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

Definition at line 169 of file generic_type_traits.hpp.

is_geninteger16bit

template<typename T >

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

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

is_genintptr

template<typename T >

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

Definition at line 244 of file generic_type_traits.hpp.

is_genintptr_marray

template<typename T , access::address_space AddressSpace, access::decorated IsDecorated>

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

Definition at line 254 of file generic_type_traits.hpp.

is_genlonglong

template<typename T >

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

Definition at line 161 of file generic_type_traits.hpp.

is_genptr

template<typename T >

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

Definition at line 273 of file generic_type_traits.hpp.

is_genshort

template<typename T >

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

Definition at line 132 of file generic_type_traits.hpp.

is_gentype

template<typename T >

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

Definition at line 197 of file generic_type_traits.hpp.

is_half

template<typename T >

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

Definition at line 48 of file generic_type_traits.hpp.

is_halfn

template<typename T >

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

Definition at line 44 of file generic_type_traits.hpp.

is_igenchar

template<typename T >

using