sycl Namespace Reference

Namespaces
	_V1
	access
	detail
	ext
	half_precision
	info
	native
	opencl
	property
	property
	usm

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

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

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

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

Variables
constexpr mode_tag_t< access_mode::read >	read_only {}
constexpr mode_tag_t< access_mode::read_write >	read_write {}
constexpr mode_tag_t< access_mode::write >	write_only {}
constexpr mode_target_tag_t< access_mode::read, target::constant_buffer >	read_constant {}
constexpr mode_target_tag_t< access_mode::read, target::host_task >	read_only_host_task
constexpr mode_target_tag_t< access_mode::read_write, target::host_task >	read_write_host_task
constexpr mode_target_tag_t< access_mode::write, target::host_task >	write_only_host_task
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS	Dimensions
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS	AccessMode
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS	IsPlaceholder
	x
	iptr
x[j]	exp
T::element_type	y
T detail::marray_element_t< T > y T T	minval
T detail::marray_element_t< T > y T T T	maxval
T detail::marray_element_t< T > y T T T maxval[i] T T T	a
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T	edge0
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T T	edge1
y y maxval[j] maxval	b
y y maxval[j] maxval	c
y y maxval[j] maxval c[j] c[j]	z
template<class T >
constexpr bool	is_group_v = is_group<T>::value
template<aspect Aspect>
constexpr bool	all_devices_have_v = all_devices_have<Aspect>::value
template<aspect Aspect>
constexpr bool	any_device_has_v = any_device_has<Aspect>::value
template<typename BinaryOperation , typename AccumulatorT >
constexpr bool	has_known_identity_v
template<typename BinaryOperation , typename AccumulatorT >
constexpr AccumulatorT	known_identity_v
constexpr auto	memory_scope_work_item = memory_scope::work_item
constexpr auto	memory_scope_sub_group = memory_scope::sub_group
constexpr auto	memory_scope_work_group = memory_scope::work_group
constexpr auto	memory_scope_device = memory_scope::device
constexpr auto	memory_scope_system = memory_scope::system
constexpr auto	memory_order_relaxed = memory_order::relaxed
constexpr auto	memory_order_acquire = memory_order::acquire
constexpr auto	memory_order_release = memory_order::release
constexpr auto	memory_order_acq_rel = memory_order::acq_rel
constexpr auto	memory_order_seq_cst = memory_order::seq_cst
static constexpr access::address_space	address_space = Space
constexpr property::no_init	no_init
constexpr property::noinit	noinit
template<typename propertyT >
constexpr bool	is_property_v = is_property<propertyT>::value
template<typename propertyT , typename syclObjectT >
constexpr bool	is_property_of_v
constexpr stream_manipulator	dec = stream_manipulator::dec
constexpr stream_manipulator	hex = stream_manipulator::hex
constexpr stream_manipulator	oct = stream_manipulator::oct
constexpr stream_manipulator	noshowbase = stream_manipulator::noshowbase
constexpr stream_manipulator	showbase = stream_manipulator::showbase
constexpr stream_manipulator	noshowpos = stream_manipulator::noshowpos
constexpr stream_manipulator	showpos = stream_manipulator::showpos
constexpr stream_manipulator	endl = stream_manipulator::endl
constexpr stream_manipulator	flush = stream_manipulator::flush
constexpr stream_manipulator	fixed = stream_manipulator::fixed
constexpr stream_manipulator	scientific = stream_manipulator::scientific
constexpr stream_manipulator	hexfloat = stream_manipulator::hexfloat
constexpr stream_manipulator	defaultfloat = stream_manipulator::defaultfloat
constexpr size_t	dynamic_extent = SIZE_MAX
template<typename T >
constexpr bool	is_device_copyable_v = is_device_copyable<T>::value
constexpr size_t	MaxNumAdditionalArgs = 13
static constexpr size_t	MAX_STATEMENT_SIZE

Enumeration Type Documentation

rounding_mode

enum sycl::rounding_mode

strong

Enumerator
automatic
rte
rtz
rtp
rtn

Definition at line 74 of file vector_convert.hpp.

Variable Documentation

all_devices_have_v

template<aspect Aspect>

constexpr bool sycl::all_devices_have_v = all_devices_have<Aspect>::value

constexpr

Definition at line 71 of file device_aspect_traits.hpp.

any_device_has_v

template<aspect Aspect>

constexpr bool sycl::any_device_has_v = any_device_has<Aspect>::value

constexpr

Definition at line 73 of file device_aspect_traits.hpp.