DPC++ Runtime
Runtime libraries for oneAPI Data Parallel C++
cl::sycl::detail Namespace Reference

Namespaces

 __sycl_service_kernel__
 
 enqueue_kernel_launch
 
 gtl
 
 gvl
 
 half_impl
 
 host_half_impl
 
 pi
 
 sub_group
 
 usm
 

Classes

class  __image_array_slice__
 
class  __pf_kernel_wrapper
 
class  accessor_common
 
class  AccessorBaseHost
 
class  AccessorImplDevice
 
class  AccessorImplHost
 
class  aligned_allocator
 
class  AllocaCommand
 The alloca command enqueues allocation of instance of memory object on Host or underlying framework. More...
 
class  AllocaCommandBase
 Base class for memory allocation commands. More...
 
class  AllocaSubBufCommand
 The AllocaSubBuf command enqueues creation of sub-buffer of memory object. More...
 
class  ArgDesc
 
class  array
 
struct  array_fill_helper
 
struct  array_fill_helper< Kind, Idx, T >
 
struct  array_fill_helper< Kind, Idx, T, Args... >
 
struct  AssertHappened
 
struct  Assigner
 
struct  Assigner< 0 >
 
class  auto_name
 This class is the default KernelName template parameter type for kernel invocation APIs such as single_task. More...
 
struct  BackendInput
 
struct  BackendInput< backend::level_zero, context >
 
struct  BackendInput< backend::level_zero, event >
 
struct  BackendInput< backend::level_zero, kernel >
 
struct  BackendInput< backend::level_zero, kernel_bundle< State > >
 
struct  BackendInput< backend::level_zero, queue >
 
struct  BackendInput< backend::opencl, kernel >
 
struct  BackendInput< backend::opencl, kernel_bundle< State > >
 
struct  BackendReturn
 
struct  BackendReturn< backend::level_zero, kernel >
 
struct  BackendReturn< backend::level_zero, kernel_bundle< State > >
 
struct  BackendReturn< backend::opencl, kernel >
 
struct  BackendReturn< backend::opencl, kernel_bundle< State > >
 
class  BaseCLTypeConverter
 
struct  Boolean
 
struct  Boolean< 1 >
 
class  buffer_impl
 
class  Builder
 
class  CG
 Base class for all types of command groups. More...
 
class  CGAdviseUSM
 "Advise USM" command group class. More...
 
class  CGBarrier
 
class  CGCopy
 "Copy memory" command group class. More...
 
class  CGCopyUSM
 "Copy USM" command group class. More...
 
class  CGExecKernel
 "Execute kernel" command group class. More...
 
class  CGFill
 "Fill memory" command group class. More...
 
class  CGFillUSM
 "Fill USM" command group class. More...
 
class  CGHostTask
 
class  CGInteropTask
 
class  CGPrefetchUSM
 "Prefetch USM" command group class. More...
 
class  CGUpdateHost
 "Update host" command group class. More...
 
struct  change_base_type
 
struct  change_base_type< vec< T, N >, B >
 
struct  check_fn_signature
 
struct  check_fn_signature< F, RetT(Args...)>
 
struct  check_fp_support
 
struct  check_fp_support< info::device::double_fp_config >
 
struct  check_fp_support< info::device::half_fp_config >
 
class  CircularBuffer
 
struct  CmpCStr
 
struct  code_location
 
class  Command
 The Command class represents some action that needs to be performed on one or more memory objects. More...
 
class  context_impl
 
struct  convert_data_type_impl
 
struct  convert_data_type_impl< T, B, enable_if_t< is_sgentype< T >::value, T > >
 
struct  convert_data_type_impl< T, B, enable_if_t< is_vgentype< T >::value, T > >
 
struct  copy_cv_qualifiers
 
struct  copy_cv_qualifiers_impl
 
struct  copy_cv_qualifiers_impl< const T, R >
 
struct  copy_cv_qualifiers_impl< const volatile T, R >
 
struct  copy_cv_qualifiers_impl< volatile T, R >
 
class  DataLessProperty
 
class  DataLessPropertyBase
 
struct  DecoratedType
 
struct  DecoratedType< ElementType, access::address_space::constant_space >
 
struct  DecoratedType< ElementType, access::address_space::global_device_space >
 
struct  DecoratedType< ElementType, access::address_space::global_host_space >
 
struct  DecoratedType< ElementType, access::address_space::global_space >
 
struct  DecoratedType< ElementType, access::address_space::local_space >
 
struct  DecoratedType< ElementType, access::address_space::private_space >
 
struct  DepDesc
 Dependency between two commands. More...
 
struct  device_filter
 
class  device_filter_list
 
class  device_image_impl
 
class  device_image_plain
 
class  device_impl
 
class  DispatchHostTask
 
class  DynRTDeviceBinaryImage
 
class  EmptyCommand
 The empty command does nothing during enqueue. More...
 
struct  EnqueueResultT
 Result of command enqueueing. More...
 
struct  EqualByNameComp
 
struct  EqualTo
 
struct  ESIMDDeviceInterface
 
struct  ESIMDEmuPluginOpaqueData
 This structure denotes a ESIMD EMU plugin-specific data returned via the piextPluginGetOpaqueData PI call. More...
 
class  event_impl
 
class  ExecCGCommand
 The exec CG command enqueues execution of kernel or explicit memory operation. More...
 
struct  ExtendedMemberT
 
struct  find_type
 
struct  find_type< empty_type_list, C, T >
 
struct  function_traits
 
struct  function_traits< Ret(Args...)>
 
struct  get
 
struct  get< 0 >
 
struct  get_context_info
 
struct  get_context_info< info::context::atomic_memory_order_capabilities >
 
struct  get_device_info
 
struct  get_device_info< bool, info::device::atomic64 >
 
struct  get_device_info< bool, info::device::ext_intel_mem_channel >
 
struct  get_device_info< bool, info::device::kernel_kernel_pipe_support >
 
struct  get_device_info< bool, info::device::queue_profiling >
 
struct  get_device_info< bool, info::device::usm_device_allocations >
 
struct  get_device_info< bool, info::device::usm_host_allocations >
 
struct  get_device_info< bool, info::device::usm_restricted_shared_allocations >
 
struct  get_device_info< bool, info::device::usm_shared_allocations >
 
struct  get_device_info< bool, info::device::usm_system_allocations >
 
struct  get_device_info< device, info::device::parent_device >
 
struct  get_device_info< id< 1 >, info::device::ext_oneapi_max_work_groups_1d >
 
struct  get_device_info< id< 2 >, info::device::ext_oneapi_max_work_groups_2d >
 
struct  get_device_info< id< 3 >, info::device::ext_oneapi_max_work_groups_3d >
 
struct  get_device_info< id< 3 >, info::device::max_work_item_sizes >
 
struct  get_device_info< id< 3 >, param >
 
struct  get_device_info< info::partition_affinity_domain, info::device::partition_type_affinity_domain >
 
struct  get_device_info< info::partition_property, info::device::partition_type_property >
 
struct  get_device_info< platform, param >
 
struct  get_device_info< size_t, info::device::ext_oneapi_max_global_work_groups >
 
struct  get_device_info< std::string, info::device::version >
 
struct  get_device_info< std::string, param >
 
struct  get_device_info< std::vector< info::execution_capability >, info::device::execution_capabilities >
 
struct  get_device_info< std::vector< info::fp_config >, info::device::single_fp_config >
 
struct  get_device_info< std::vector< info::fp_config >, param >
 
struct  get_device_info< std::vector< info::partition_affinity_domain >, info::device::partition_affinity_domains >
 
struct  get_device_info< std::vector< info::partition_property >, info::device::partition_properties >
 
struct  get_device_info< std::vector< memory_order >, info::device::atomic_memory_order_capabilities >
 
struct  get_device_info< std::vector< size_t >, info::device::sub_group_sizes >
 
struct  get_device_info< std::vector< std::string >, info::device::built_in_kernels >
 
struct  get_device_info< std::vector< std::string >, info::device::extensions >
 
struct  get_device_info< T, info::device::parent_device >
 
struct  get_device_info_string
 
struct  get_event_info
 
struct  get_event_profiling_info
 
struct  get_kernel_device_specific_info
 
struct  get_kernel_device_specific_info< cl::sycl::range< 3 >, Param >
 
struct  get_kernel_device_specific_info_with_input
 
struct  get_kernel_info
 
struct  get_kernel_info< cl_uint, Param >
 
struct  get_kernel_info< std::string, Param >
 
struct  get_kernel_name_t
 Helper struct to get a kernel name type based on given Name and Type types: if Name is undefined (is a auto_name) then Type becomes the Name. More...
 
struct  get_kernel_wrapper_name_t
 
struct  get_platform_info
 
struct  get_platform_info< std::string, param >
 
struct  get_platform_info< std::vector< std::string >, info::platform::extensions >
 
class  GetOp
 
class  GetScalarOp
 
struct  GetSpirvMemoryScope
 
struct  GetSpirvMemoryScope< access::address_space::global_device_space >
 
struct  GetSpirvMemoryScope< access::address_space::global_space >
 
struct  GetSpirvMemoryScope< access::address_space::local_space >
 
class  GlobalHandler
 Wrapper class for global data structures with non-trivial destructors. More...
 
struct  GreaterEqualTo
 
struct  GreaterThan
 
struct  group_barrier_scope
 
struct  group_barrier_scope< sycl::group< D > >
 
struct  group_barrier_scope< sycl::sub_group >
 
class  handler_impl
 
struct  has_known_identity_impl
 
struct  HashCStr
 
class  HostKernel
 
class  HostKernelBase
 
class  HostProfilingInfo
 Profiling info for the host execution. More...
 
class  HostTask
 
class  image_accessor
 
class  image_impl
 
struct  InitializedVal
 
struct  InitializedVal< 1, T >
 
struct  InitializedVal< 2, T >
 
struct  InitializedVal< 3, T >
 
struct  InlineVariableHelper
 
struct  InteropFeatureSupportMap
 
struct  InteropFeatureSupportMap< backend::level_zero >
 
struct  InteropFeatureSupportMap< backend::opencl >
 
class  InteropTask
 
struct  is_address_space_compliant
 
struct  is_address_space_compliant_impl
 
struct  is_address_space_compliant_impl< multi_ptr< T, Space >, SpaceList >
 
struct  is_address_space_compliant_impl< T *, SpaceList >
 
struct  is_arithmetic
 
struct  is_bool
 
struct  is_contained
 
struct  is_contained< T, empty_type_list >
 
struct  is_contained_value
 
struct  is_contained_value< T, V, value_list< T > >
 
struct  is_empty_type_list
 
struct  is_floating_point
 
struct  is_floating_point_impl
 
struct  is_floating_point_impl< half >
 
struct  is_generic_group
 
struct  is_group
 
struct  is_group< group< Dimensions > >
 
struct  is_integral
 
struct  is_native_op
 
struct  is_output_iterator
 
struct  is_output_iterator< T, output_iterator_requirements< T > >
 
struct  is_pointer
 
struct  is_pointer_impl
 
struct  is_pointer_impl< multi_ptr< T, Space > >
 
struct  is_pointer_impl< T * >
 
class  is_same_vector_size
 
class  is_same_vector_size_impl
 
class  is_same_vector_size_impl< FirstSize >
 
class  is_same_vector_size_impl< FirstSize, T, Args... >
 
struct  is_scalar_arithmetic
 
struct  is_scalar_bool
 
struct  is_sub_group
 
struct  is_sub_group< ext::oneapi::sub_group >
 
struct  is_type_size_double_of
 
struct  is_type_size_equal
 
struct  is_type_size_greater
 
struct  is_type_size_half_of
 
struct  is_type_size_less
 
struct  is_vec
 
struct  is_vec< cl::sycl::vec< T, N > >
 
struct  is_vector_arithmetic
 
struct  is_vector_bool
 
struct  IsCompileTimePropertyInstance
 
struct  IsCompileTimePropertyInstance< ext::intel::property::buffer_location::instance< I > >
 
struct  IsCompileTimePropertyInstance< ext::oneapi::property::no_alias::instance<> >
 
struct  IsCompileTimePropertyInstance< ext::oneapi::property::no_offset::instance<> >
 
struct  IsCxPropertyList
 
struct  IsCxPropertyList< ext::oneapi::accessor_property_list< Props... > >
 
struct  IsCxPropertyList< ext::oneapi::accessor_property_list<> >
 
struct  IsDeprecatedDeviceCopyable
 
struct  IsSwizzleOp
 
struct  IsSwizzleOp< cl::sycl::detail::SwizzleOp< VecT, OperationLeftT, OperationRightT, OperationCurrentT, Indexes... > >
 
struct  IsValidAtomicAddressSpace
 
struct  IsValidAtomicType
 
struct  IsValidCoordDataT
 
struct  IsValidCoordDataT< 1, T >
 
struct  IsValidCoordDataT< 2, T >
 
struct  IsValidCoordDataT< 3, T >
 
struct  IsWorkGroupInfo
 
struct  IsWorkGroupInfo< info::kernel_device_specific::compile_work_group_size >
 
struct  IsWorkGroupInfo< info::kernel_device_specific::ext_codeplay_num_regs >
 
struct  IsWorkGroupInfo< info::kernel_device_specific::global_work_size >
 
struct  IsWorkGroupInfo< info::kernel_device_specific::preferred_work_group_size_multiple >
 
struct  IsWorkGroupInfo< info::kernel_device_specific::private_mem_size >
 
struct  IsWorkGroupInfo< info::kernel_device_specific::work_group_size >
 
struct  ItemBase
 
struct  ItemBase< Dims, false >
 
struct  ItemBase< Dims, true >
 
class  kernel_bundle_impl
 
class  kernel_bundle_plain
 
class  kernel_id_impl
 
class  kernel_impl
 
struct  kernel_param_desc_t
 
struct  KernelInfo
 
struct  KernelLambdaHasKernelHandlerArgT
 
class  KernelProgramCache
 
struct  known_identity_impl
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsFalseIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns false as identity for LOGICAL OR operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsMaximumIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns minimal possible value as identity for MAX operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsMinimumIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns maximal possible value as identity for MIN operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsOneIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns one as identify for MULTIPLY operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsOnesIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns bit image consisting of all ones as identity for AND operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsTrueIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns true as identity for LOGICAL AND operations. More...
 
struct  known_identity_impl< BinaryOperation, AccumulatorT, std::enable_if_t< IsZeroIdentityOp< AccumulatorT, BinaryOperation >::value > >
 Returns zero as identity for ADD, OR, XOR operations. More...
 
struct  known_identity_impl< BinaryOperation, half, std::enable_if_t< IsOneIdentityOp< half, BinaryOperation >::value > >
 
struct  known_identity_impl< BinaryOperation, half, std::enable_if_t< IsZeroIdentityOp< half, BinaryOperation >::value > >
 
class  LeavesCollection
 A wrapper for CircularBuffer class along with collection for host accessor's EmptyCommands. More...
 
struct  LessByHash
 
struct  LessByNameComp
 
struct  LessEqualTo
 
struct  LessThan
 
class  LocalAccessorBaseDevice
 
class  LocalAccessorBaseHost
 
class  LocalAccessorImplHost
 
class  LockCacheItem
 
class  Locked
 Represents a reference to value with appropriate lock acquired. More...
 
struct  LogicalAnd
 
struct  LogicalOr
 
struct  LShift
 
struct  make_larger
 
struct  make_larger_impl
 
struct  make_larger_impl< T, enable_if_t< is_contained< T, gtl::scalar_floating_list >::value, T > >
 
struct  make_larger_impl< T, enable_if_t< is_contained< T, gtl::scalar_signed_integer_list >::value, T > >
 
struct  make_larger_impl< T, enable_if_t< is_contained< T, gtl::scalar_unsigned_integer_list >::value, T > >
 
struct  make_larger_impl< vec< T, N >, vec< T, N > >
 
struct  make_signed
 
struct  make_signed_impl
 
struct  make_signed_impl< T, enable_if_t< is_contained< T, gtl::scalar_integer_list >::value, T > >
 
struct  make_signed_impl< T, enable_if_t< is_contained< T, gtl::vector_integer_list >::value, T > >
 
struct  make_signed_impl< T, enable_if_t<!is_contained< T, gtl::integer_list >::value, T > >
 
struct  make_type_impl
 
struct  make_type_impl< vec< T, N >, TL >
 
struct  make_unsigned
 
struct  make_unsigned_impl
 
struct  make_unsigned_impl< T, enable_if_t< is_contained< T, gtl::scalar_integer_list >::value, T > >
 
struct  make_unsigned_impl< T, enable_if_t< is_contained< T, gtl::vector_integer_list >::value, T > >
 
struct  make_unsigned_impl< T, enable_if_t<!is_contained< T, gtl::integer_list >::value, T > >
 
class  MapMemObject
 The map command enqueues mapping of device memory onto host memory. More...
 
class  MemCpyCommand
 The mem copy command enqueues memory copy between two instances of memory object. More...
 
class  MemCpyCommandHost
 The mem copy host command enqueues memory copy between two instances of memory object. More...
 
struct  MemObjRecord
 Memory Object Record. More...
 
class  MemoryManager
 
struct  nan_types
 
struct  nan_types< T, enable_if_t< is_contained< T, gtl::unsigned_int_list >::value, T > >
 
struct  nan_types< T, enable_if_t< is_contained< T, gtl::unsigned_long_integer_list >::value, T > >
 
struct  nan_types< T, enable_if_t< is_contained< T, gtl::unsigned_short_list >::value, T > >
 
struct  NDLoop
 Generates an NDIMS-dimensional perfect loop nest. More...
 
struct  NDLoopIterateImpl
 Helper class for the NDLoop. More...
 
struct  NDLoopIterateImpl< NDIMS, 0, LoopBoundTy, FuncTy, LoopIndexTy >
 
class  NDRDescT
 
struct  NotEqualTo
 
class  OSUtil
 Groups the OS-dependent services. More...
 
class  PersistentDeviceCodeCache
 
struct  PiApiArgTuple
 
class  platform_impl
 
struct  PlatformUtil
 
class  plugin
 The plugin class provides a unified interface to the underlying low-level runtimes for the device-agnostic SYCL runtime. More...
 
class  program_impl
 
class  ProgramManager
 
class  PropertyListBase
 
class  PropertyWithData
 
class  PropertyWithDataBase
 
class  queue_impl
 
struct  RelationalReturnType
 
struct  RelationalTestForSignBitType
 
struct  RelConverter
 
struct  RelConverter< T, typename detail::enable_if_t< TryToGetElementType< T >::value > >
 
struct  RelConverter< T, typename detail::enable_if_t<!TryToGetElementType< T >::value > >
 
class  ReleaseCommand
 The release command enqueues release of a memory object instance allocated on Host or underlying framework. More...
 
struct  remove_AS
 
struct  remove_pointer
 
struct  remove_pointer_impl
 
struct  remove_pointer_impl< multi_ptr< T, Space > >
 
struct  remove_pointer_impl< T * >
 
class  RoundedRangeKernel
 
class  RoundedRangeKernelWithKH
 
struct  RShift
 
class  RTDeviceBinaryImage
 
class  sampler_impl
 
class  Scheduler
 DPC++ graph scheduler class. More...
 
struct  select_cl_mptr_or_vector_or_scalar
 
struct  select_cl_mptr_or_vector_or_scalar< T, typename detail::enable_if_t< is_genptr< T >::value &&!std::is_pointer< T >::value > >
 
struct  select_cl_mptr_or_vector_or_scalar< T, typename detail::enable_if_t<!is_genptr< T >::value||std::is_pointer< T >::value > >
 
struct  select_cl_vector_or_scalar
 
struct  select_cl_vector_or_scalar< T, typename detail::enable_if_t< is_vgentype< T >::value > >
 
struct  select_cl_vector_or_scalar< T, typename detail::enable_if_t<!is_vgentype< T >::value > >
 
class  spec_constant_impl
 
struct  SpecConstantInfo
 
class  SpinLock
 SpinLock is a synchronization primitive, that uses atomic variable and causes thread trying acquire lock wait in loop while repeatedly check if the lock is available. More...
 
class  stream_impl
 
class  SwizzleOp
 
struct  sycl_to_pi
 
struct  sycl_to_pi< bool >
 
struct  sycl_to_pi< device >
 
struct  sycl_to_pi< platform >
 
class  SYCLCategory
 
class  SYCLConfig
 
class  SYCLConfig< SYCL_BE >
 
class  SYCLConfig< SYCL_DEVICE_FILTER >
 
class  SYCLConfig< SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING >
 
class  SYCLConfig< SYCL_ENABLE_DEFAULT_CONTEXTS >
 
class  SYCLConfig< SYCL_PARALLEL_FOR_RANGE_ROUNDING_PARAMS >
 
class  SYCLConfig< SYCL_PARALLEL_FOR_RANGE_ROUNDING_TRACE >
 
class  SYCLConfig< SYCL_PI_TRACE >
 
class  SYCLConfigBase
 
class  SYCLMemObjAllocator
 
class  SYCLMemObjAllocatorHolder
 
class  SYCLMemObjI
 
class  SYCLMemObjT
 
class  Sync
 Groups and provides access to all the locks used the SYCL runtime. More...
 
struct  TargetToAS
 
struct  TargetToAS< access::target::constant_buffer >
 
struct  TargetToAS< access::target::local >
 
struct  TermPositions
 
class  ThreadPool
 
class  TryToGetElementType
 
struct  TryToGetNumElements
 
struct  TryToGetNumElements< T, typename detail::enable_if_t< TryToGetVectorT< T >::value > >
 
struct  TryToGetNumElements< T, typename detail::enable_if_t<!TryToGetVectorT< T >::value > >
 
class  TryToGetPointerT
 
class  TryToGetPointerVecT
 
class  TryToGetVectorT
 
struct  tuple
 
struct  tuple< T, Ts... >
 
struct  tuple<>
 
struct  tuple_element
 
struct  tuple_element< 0, tuple< T, Rest... > >
 
struct  tuple_element< N, tuple< T, Rest... > >
 
struct  TupleCopyAssignableValueHolder
 
struct  TupleCopyAssignableValueHolder< T, false >
 
struct  TupleValueHolder
 
struct  type_list
 
struct  type_list< H, T... >
 
struct  type_list< type_list< H, T... >, T2... >
 
struct  type_list<>
 
struct  TypeHelper
 
class  UnMapMemObject
 The unmap command removes mapping of host memory onto device memory. More...
 
class  UpdateHostRequirementCommand
 
struct  value_list
 
struct  value_list< T >
 
struct  value_list< T, H, V... >
 
struct  vec_helper
 
struct  vector_alignment
 
struct  vector_alignment_impl
 
struct  vector_element
 
struct  vector_element_impl
 
struct  vector_element_impl< vec< T, N > >
 
struct  vector_size
 
struct  vector_size_impl
 
struct  vector_size_impl< vec< T, N > >
 
class  XPTIRegistry
 

Typedefs

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

Enumerations

enum  backend_errc : unsigned int
 
enum  ExtendedMembersType : unsigned int { ExtendedMembersType::HANDLER_KERNEL_BUNDLE = 0, ExtendedMembersType::HANDLER_MEM_ADVICE, ExtendedMembersType::HANDLER_IMPL }
 
enum  kernel_param_kind_t {
  kernel_param_kind_t::kind_accessor = 0, kernel_param_kind_t::kind_std_layout = 1, kernel_param_kind_t::kind_sampler = 2, kernel_param_kind_t::kind_pointer = 3,
  kernel_param_kind_t::kind_specialization_constants_buffer = 4, kernel_param_kind_t::kind_stream = 5, kernel_param_kind_t::kind_invalid = 0xf
}
 
enum  PiApiKind { PiApiKind::_PI_API }
 
enum  DataLessPropKind {
  BufferUseHostPtr = 0, ImageUseHostPtr = 1, QueueEnableProfiling = 2, InOrder = 3,
  NoInit = 4, BufferUsePinnedHostMemory = 5, UsePrimaryContext = 6, InitializeToIdentity = 7,
  UseDefaultStream = 8, LastKnownDataLessPropKind = 8, DataLessPropKindSize = 32
}
 
enum  PropWithDataKind {
  BufferUseMutex = 0, BufferContextBound = 1, ImageUseMutex = 2, ImageContextBound = 3,
  BufferMemChannel = 4, PropWithDataKindSize = 5
}
 
enum  ConfigID { START = 0, END }
 
enum  HandlerSubmissionState : std::uint8_t { HandlerSubmissionState::NO_STATE = 0, HandlerSubmissionState::EXPLICIT_KERNEL_BUNDLE_STATE, HandlerSubmissionState::SPEC_CONST_SET_STATE }
 
enum  BuildState { BS_InProgress, BS_Done, BS_Failed }
 
enum  DeviceLibExt : std::uint32_t {
  DeviceLibExt::cl_intel_devicelib_assert, DeviceLibExt::cl_intel_devicelib_math, DeviceLibExt::cl_intel_devicelib_math_fp64, DeviceLibExt::cl_intel_devicelib_complex,
  DeviceLibExt::cl_intel_devicelib_complex_fp64, DeviceLibExt::cl_intel_devicelib_cstring
}
 
enum  CUDAContextT : char { CUDAContextT::primary, CUDAContextT::custom }
 Possible CUDA context types supported by PI CUDA backend TODO: Implement this as a property once there is an extension document. More...
 
enum  QueueOrder { Ordered, OOO }
 
enum  BlockingT { NON_BLOCKING = 0, BLOCKING }
 

Functions

constexpr bool isTargetHostAccess (access::target T)
 
constexpr bool modeNeedsOldData (access::mode m)
 
constexpr bool modeWritesNewData (access::mode m)
 
template<int NewDim, int DefaultValue, template< int > class T, int OldDim>
static T< NewDim > convertToArrayOfN (T< OldDim > OldObj)
 
device getDeviceFromHandler (handler &CommandGroupHandlerRef)
 
static std::memory_order getStdMemoryOrder (__spv::MemorySemanticsMask::Flag)
 
platform make_platform (pi_native_handle NativeHandle, backend Backend)
 
device make_device (pi_native_handle NativeHandle, backend Backend)
 
context make_context (pi_native_handle NativeHandle, const async_handler &Handler, backend Backend)
 
queue make_queue (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, const async_handler &Handler, backend Backend)
 
queue make_queue (pi_native_handle NativeHandle, const context &TargetContext, const async_handler &Handler, backend Backend)
 
event make_event (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
 
event make_event (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, backend Backend)
 
kernel make_kernel (pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
 
kernel make_kernel (const context &TargetContext, const kernel_bundle< bundle_state::executable > &KernelBundle, pi_native_handle NativeKernelHandle, bool KeepOwnership, backend Backend)
 
std::shared_ptr< detail::kernel_bundle_implmake_kernel_bundle (pi_native_handle NativeHandle, const context &TargetContext, bundle_state State, backend Backend)
 
std::shared_ptr< detail::kernel_bundle_implmake_kernel_bundle (pi_native_handle NativeHandle, const context &TargetContext, bool KeepOwnership, bundle_state State, backend Backend)
 
void memcpy (void *Dst, const void *Src, std::size_t Size)
 
template<typename To , typename From >
To bit_cast (const From &from) noexcept
 
template<typename T , int Dimensions, typename AllocatorT >
buffer< T, Dimensions, AllocatorT, void > make_buffer_helper (pi_native_handle Handle, const context &Ctx, event Evt)
 
void addHostAccessorAndWait (Requirement *Req)
 
static std::shared_ptr< std::vector< ExtendedMemberT > > convertToExtendedMembers (const std::shared_ptr< const void > &SPtr)
 
constexpr unsigned int getVersionedCGType (unsigned int Type, unsigned char Version)
 
constexpr unsigned char getUnversionedCGType (unsigned int Type)
 
constexpr unsigned char getCGTypeVersion (unsigned int Type)
 
template<typename F , typename... Args>
static constexpr bool check_kernel_lambda_takes_args ()
 
template<typename KernelType , typename LambdaArgType , typename std::enable_if_t< std::is_same< LambdaArgType, void >::value > * = nullptr>
constexpr bool isKernelLambdaCallableWithKernelHandlerImpl ()
 
template<typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType >::value > runKernelWithoutArg (KernelType KernelName)
 
template<typename KernelType >
std::enable_if_t<!KernelLambdaHasKernelHandlerArgT< KernelType >::value > runKernelWithoutArg (KernelType KernelName)
 
template<typename ArgType , typename KernelType >
std::enable_if_t< KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value > runKernelWithArg (KernelType KernelName, ArgType Arg)
 
template<typename ArgType , typename KernelType >
std::enable_if_t< !KernelLambdaHasKernelHandlerArgT< KernelType, ArgType >::value > runKernelWithArg (KernelType KernelName, ArgType Arg)
 
const charstringifyErrorCode (cl_int error)
 
static std::string codeToString (cl_int code)
 
template<class Obj >
decltype(Obj::impl) getSyclObjImpl (const Obj &SyclObject)
 
template<class T >
detail::add_pointer_t< typename decltype(T::impl)::element_type > getRawSyclObjImpl (const T &SyclObject)
 
template<class T >
T createSyclObjFromImpl (decltype(T::impl) ImplObj)
 
constexpr size_t getNextPowerOfTwoHelper (size_t Var, size_t Offset)
 
constexpr size_t getNextPowerOfTwo (size_t Var)
 
template<int Dims, template< int > class T, template< int > class U>
size_t getLinearIndex (const T< Dims > &Index, const U< Dims > &Range)
 
std::vector< std::string > split_string (const std::string &str, char delimeter)
 
std::ostream & operator<< (std::ostream &Out, const device_filter &Filter)
 
std::ostream & operator<< (std::ostream &Out, const device_filter_list &List)
 
template<typename T , typename = typename detail::enable_if_t< TryToGetPointerT<T>::value, std::true_type>>
TryToGetPointerVecT< T >::type TryToGetPointer (T &t)
 
template<typename T >
TryToGetPointerVecT< T * >::type TryToGetPointer (T *t)
 
template<typename T , typename = typename detail::enable_if_t< !TryToGetPointerT<T>::value, std::false_type>>
T TryToGetPointer (T &t)
 
template<typename FROM , typename TO >
detail::enable_if_t< is_vgentype< FROM >::value &&is_vgentype< TO >::value &&sizeof(TO)==sizeof(FROM), TO > convertDataToType (FROM t)
 
template<typename FROM , typename TO >
detail::enable_if_t<!(is_vgentype< FROM >::value &&is_vgentype< TO >::value) &&sizeof(TO)==sizeof(FROM), TO > convertDataToType (FROM t)
 
template<typename T >
constexpr T msbMask (T)
 
template<typename T >
constexpr bool msbIsSet (const T x)
 
template<typename T >
static constexpr T max_v ()
 
template<typename T >
static constexpr T min_v ()
 
template<typename T >
static constexpr T quiet_NaN ()
 
template<typename... Args>
void check_vector_size ()
 
void associateWithHandler (handler &, AccessorBaseHost *, access::target)
 
void memcpy (void *Dst, const void *Src, size_t Size)
 
std::vector< RT::PiEventgetOrWaitEvents (std::vector< cl::sycl::event > DepEvents, std::shared_ptr< cl::sycl::detail::context_impl > Context)
 
void waitEvents (std::vector< cl::sycl::event > DepEvents)
 
template<typename T >
Tdeclptr ()
 
template<typename T >
T get_or_store (const T *obj)
 
constexpr __spv::MemorySemanticsMask::Flag getSPIRVMemorySemanticsMask (memory_order)
 
constexpr uint32_t getSPIRVMemorySemanticsMask (const access::fence_space AccessSpace, const __spv::MemorySemanticsMask LocalScopeMask=__spv::MemorySemanticsMask::WorkgroupMemory)
 
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, TUnnormalizeCoordinates (const T &Coords, const range< 3 > &Range)
 
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, vec< T, 2 > > UnnormalizeCoordinates (const vec< T, 2 > &Coords, const range< 3 > &Range)
 
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, vec< T, 4 > > UnnormalizeCoordinates (const vec< T, 4 > &Coords, const range< 3 > &Range)
 
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, cl_float4 > convertToFloat4 (T Coords)
 
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, cl_float4 > convertToFloat4 (vec< T, 2 > Coords)
 
template<typename T >
detail::enable_if_t< IsValidCoordType< T >::value, cl_float4 > convertToFloat4 (vec< T, 4 > Coords)
 
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, size_t > getImageOffset (const T &Coords, const id< 3 >, const uint8_t ElementSize)
 
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, size_t > getImageOffset (const vec< T, 2 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
 
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, size_t > getImageOffset (const vec< T, 4 > &Coords, const id< 3 > ImgPitch, const uint8_t ElementSize)
 
cl_int4 getPixelCoordNearestFiltMode (cl_float4, const addressing_mode, const range< 3 >)
 
cl_int8 getPixelCoordLinearFiltMode (cl_float4, const addressing_mode, const range< 3 >, cl_float4 &)
 
bool isOutOfRange (const cl_int4 PixelCoord, const addressing_mode SmplAddrMode, const range< 3 > ImgRange)
 
cl_float4 getBorderColor (const image_channel_order ImgChannelOrder)
 
template<typename T >
vec< T, 4 > readPixel (T *Ptr, const image_channel_order ChannelOrder, const image_channel_type ChannelType)
 
template<typename T >
void writePixel (const vec< T, 4 > Pixel, T *Ptr, const image_channel_order ChannelOrder, const image_channel_type ChannelType)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_uint, 4 > &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_int, 4 > &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_float, 4 > &RetData)
 
template<typename ChannelType >
void convertReadData (const vec< ChannelType, 4 > PixelData, const image_channel_type ImageChannelType, vec< cl_half, 4 > &RetData)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_uint, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_int, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > processFloatDataToPixel (vec< cl_float, 4 > WriteData, float MulFactor)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_float, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename ChannelType >
vec< ChannelType, 4 > convertWriteData (const vec< cl_half, 4 > WriteData, const image_channel_type ImageChannelType)
 
template<typename CoordT , typename WriteDataT >
void imageWriteHostImpl (const CoordT &Coords, const WriteDataT &Color, id< 3 > ImgPitch, uint8_t ElementSize, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr)
 
template<typename DataT >
DataT ReadPixelData (const cl_int4 PixelCoord, const id< 3 > ImgPitch, const image_channel_type ImageChannelType, const image_channel_order ImageChannelOrder, void *BasePtr, const uint8_t ElementSize)
 
template<typename DataT >
DataT getColor (const cl_int4 PixelCoord, const addressing_mode SmplAddrMode, const range< 3 > ImgRange, const id< 3 > ImgPitch, const image_channel_type ImgChannelType, const image_channel_order ImgChannelOrder, void *BasePtr, const uint8_t ElementSize)
 
template<typename DataT >
DataT ReadPixelDataLinearFiltMode (const cl_int8 CoordValues, const cl_float4 abc, const addressing_mode SmplAddrMode, const range< 3 > ImgRange, id< 3 > ImgPitch, const image_channel_type ImgChannelType, const image_channel_order ImgChannelOrder, void *BasePtr, const uint8_t ElementSize)
 
template<typename CoordT , typename DataT >
DataT imageReadSamplerHostImpl (const CoordT &Coords, const sampler &Smpl, range< 3 > ImgRange, id< 3 > ImgPitch, image_channel_type ImgChannelType, image_channel_order ImgChannelOrder, void *BasePtr, uint8_t ElementSize)
 
uint8_t getImageNumberChannels (image_channel_order Order)
 
uint8_t getImageElementSize (uint8_t NumChannels, image_channel_type Type)
 
RT::PiMemImageChannelOrder convertChannelOrder (image_channel_order Order)
 
image_channel_order convertChannelOrder (RT::PiMemImageChannelOrder Order)
 
RT::PiMemImageChannelType convertChannelType (image_channel_type Type)
 
image_channel_type convertChannelType (RT::PiMemImageChannelType Type)
 
template<cl::sycl::backend BE>
void * getPluginOpaqueData (void *opaquedata_arg)
 
template<typename T , typename... Ts, std::size_t... Is>
std::tuple< Ts... > get_tuple_tail_impl (const std::tuple< T, Ts... > &Tuple, const std::index_sequence< Is... > &)
 
template<typename T , typename... Ts>
std::tuple< Ts... > get_tuple_tail (const std::tuple< T, Ts... > &Tuple)
 
template<typename... Ts>
constexpr tuple< Ts... > make_tuple (Ts... Args)
 
template<typename... Ts>
auto tie (Ts &... Args)
 
static void workGroupBarrier ()
 
template<int Dims>
group< Dims > store_group (const group< Dims > *g)
 
template<int Dimensions>
id< Dimensions > linear_id_to_id (range< Dimensions >, size_t linear_id)
 
template<>
id< 1 > linear_id_to_id (range< 1 >, size_t linear_id)
 
template<>
id< 2 > linear_id_to_id (range< 2 > r, size_t linear_id)
 
template<>
id< 3 > linear_id_to_id (range< 3 > r, size_t linear_id)
 
template<typename Group >
size_t get_local_linear_range (Group g)
 
template<>
size_t get_local_linear_range< group< 1 > > (group< 1 > g)
 
template<>
size_t get_local_linear_range< group< 2 > > (group< 2 > g)
 
template<>
size_t get_local_linear_range< group< 3 > > (group< 3 > g)
 
template<>
size_t get_local_linear_range< ext::oneapi::sub_group > (ext::oneapi::sub_group g)
 
template<typename Group >
Group::linear_id_type get_local_linear_id (Group g)
 
template<>
ext::oneapi::sub_group::linear_id_type get_local_linear_id< ext::oneapi::sub_group > (ext::oneapi::sub_group g)
 
template<typename Group , typename Ptr , class Function >
Function for_each (Group g, Ptr first, Ptr last, Function f)
 
__SYCL_CONSTEXPR_HALF uint16_t float2Half (const float &Val)
 
__SYCL_CONSTEXPR_HALF float half2Float (const uint16_t &Val)
 
template<typename T >
T cast_if_host_half (T val)
 
float cast_if_host_half (half_impl::half val)
 
template<typename RetType , typename Func , typename Arg >
static Arg member_ptr_helper (RetType(Func::*)(Arg) const)
 
template<typename F , typename SuggestedArgType >
SuggestedArgType argument_helper (...)
 
template<int Dims, typename T >
detail::enable_if_t< std::is_same< T, range< Dims > >::value||std::is_same< T, id< Dims > >::value > checkValueRange (const T &V)
 
template<int Dims>
void checkValueRange (const range< Dims > &R, const id< Dims > &O)
 
template<int Dims, typename T >
detail::enable_if_t< std::is_same< T, nd_range< Dims > >::value > checkValueRange (const T &V)
 
template<int dimensions>
size_t getOffsetForId (range< dimensions > Range, id< dimensions > Id, id< dimensions > Offset)
 
id< 1 > getDelinearizedId (const range< 1 > &, size_t Index)
 
id< 2 > getDelinearizedId (const range< 2 > &Range, size_t Index)
 
id< 3 > getDelinearizedId (const range< 3 > &Range, size_t Index)
 
template<int Dims>
id< Dims > store_id (const id< Dims > *i)
 
template<int Dims>
item< Dims > store_item (const item< Dims > *i)
 
kernel_id get_kernel_id_impl (std::string KernelName)
 
detail::KernelBundleImplPtr get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State)
 
detail::KernelBundleImplPtr get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, const std::vector< kernel_id > &KernelIDs, bundle_state State)
 
detail::KernelBundleImplPtr get_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State, const DevImgSelectorImpl &Selector)
 
bool has_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, bundle_state State)
 
bool has_kernel_bundle_impl (const context &Ctx, const std::vector< device > &Devs, const std::vector< kernel_id > &kernelIds, bundle_state State)
 
std::shared_ptr< detail::kernel_bundle_impljoin_impl (const std::vector< detail::KernelBundleImplPtr > &Bundles)
 
std::shared_ptr< detail::kernel_bundle_implcompile_impl (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList)
 
std::vector< sycl::devicefind_device_intersection (const std::vector< kernel_bundle< bundle_state::object >> &ObjectBundles)
 
std::shared_ptr< detail::kernel_bundle_impllink_impl (const std::vector< kernel_bundle< bundle_state::object >> &ObjectBundles, const std::vector< device > &Devs, const property_list &PropList)
 
std::shared_ptr< detail::kernel_bundle_implbuild_impl (const kernel_bundle< bundle_state::input > &InputBundle, const std::vector< device > &Devs, const property_list &PropList)
 
std::vector< memory_orderreadMemoryOrderBitfield (pi_memory_order_capabilities bits)
 
static constexpr std::memory_order getStdMemoryOrder (sycl::memory_order order)
 
template<int Dims>
nd_item< Dims > store_nd_item (const nd_item< Dims > *nd_i)
 
static event submitAssertCapture (queue &Self, event &Event, queue *SecondaryQueue, const detail::code_location &CodeLoc)
 Submit copy task for assert failure flag and host-task to check the flag. More...
 
unsigned GetFlushBufOffset (const GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
 
void SetFlushBufOffset (GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset, unsigned Offset)
 
void write (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const char *Str, unsigned Len, unsigned Padding=0)
 
void reverseBuf (char *Buf, unsigned Len)
 
template<typename T >
std::make_unsigned< T >::type getAbsVal (const T Val, const int Base)
 
char digitToChar (const int Digit)
 
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, unsigned > integralToBase (T Val, int Base, char *Digits)
 
template<typename T >
detail::enable_if_t< std::is_integral< T >::value, unsigned > ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
 
unsigned append (char *Dst, const char *Src)
 
template<typename T >
detail::enable_if_t< std::is_same< T, float >::value||std::is_same< T, double >::value, unsigned > checkForInfNan (char *Buf, T Val)
 
template<typename T >
detail::enable_if_t< std::is_same< T, half >::value, unsigned > checkForInfNan (char *Buf, T Val)
 
template<typename T >
EnableIfFP< T, unsigned > floatingPointToDecStr (T AbsVal, char *Digits, int Precision, bool IsSci)
 
template<typename T >
EnableIfFP< T, unsigned > ScalarToStr (const T &Val, char *Buf, unsigned Flags, int, int Precision=-1)
 
template<typename T >
detail::enable_if_t< std::is_integral< T >::value > writeIntegral (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, const T &Val)
 
template<typename T >
EnableIfFP< TwriteFloatingPoint (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const T &Val)
 
bool updateOffset (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, unsigned Size, unsigned &Cur)
 
void flushBuffer (GlobalOffsetAccessorT &GlobalOffset, GlobalBufAccessorT &GlobalBuf, GlobalBufAccessorT &GlobalFlushBuf, unsigned WIOffset)
 
template<typename T , int VecLength>
detail::enable_if_t<(VecLength==1), unsigned > VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
 
template<typename T , int VecLength>
detail::enable_if_t<(VecLength==2||VecLength==4||VecLength==8||VecLength==16), unsigned > VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
 
template<typename T , int VecLength>
detail::enable_if_t<(VecLength==3), unsigned > VecToStr (const vec< T, VecLength > &Vec, char *VecStr, unsigned Flags, int Width, int Precision)
 
template<typename T , int VecLength>
void writeVec (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, unsigned Flags, int Width, int Precision, const vec< T, VecLength > &Vec)
 
template<int ArrayLength>
unsigned ArrayToStr (char *Buf, const array< ArrayLength > &Arr)
 
template<int ArrayLength>
void writeArray (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const array< ArrayLength > &Arr)
 
template<int Dimensions>
void writeItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const item< Dimensions > &Item)
 
template<int Dimensions>
void writeNDRange (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_range< Dimensions > &ND_Range)
 
template<int Dimensions>
void writeNDItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const nd_item< Dimensions > &ND_Item)
 
template<int Dimensions>
void writeGroup (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const group< Dimensions > &Group)
 
template<int Dimensions>
unsigned ItemToStr (char *Buf, const item< Dimensions, false > &Item)
 
template<int Dimensions>
void writeHItem (GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize, unsigned WIOffset, const h_item< Dimensions > &HItem)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t< std::is_same< T, R >::value, R > convertImpl (T Value)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t<!std::is_same< T, R >::value &&(is_int_to_int< T, R >::value||is_int_to_float< T, R >::value||is_float_to_float< T, R >::value), R > convertImpl (T Value)
 
template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t< is_float_to_int< T, R >::value, R > convertImpl (T Value)
 
template<typename T >
struct __SYCL2020_DEPRECATED ("This type isn't device copyable in SYCL 2020") IsDeprecatedDeviceCopyable< T
 
ESIMDDeviceInterfacegetESIMDDeviceInterface ()
 
static const plugingetPlugin (backend Backend)
 
AllowListParsedT parseAllowList (const std::string &AllowListRaw)
 
bool deviceIsAllowed (const DeviceDescT &DeviceDesc, const AllowListParsedT &AllowListParsed)
 
void applyAllowList (std::vector< RT::PiDevice > &PiDevices, RT::PiPlatform PiPlatform, const plugin &Plugin)
 
template<class T >
backend getImplBackend (const T &Impl)
 
static void initValue (const char *Key, const char *Value)
 
void readConfig (bool ForceInitialization)
 
void dumpConfig ()
 
const std::array< std::pair< std::string, info::device_type >, 5 > & getSyclDeviceTypeMap ()
 
const std::array< std::pair< std::string, backend >, 6 > & getSyclBeMap ()
 
constexpr const chargetStrOrNullptr (const char *Str)
 
template<>
cl_uint context_impl::get_info< info::context::reference_count > () const
 
template<>
platform context_impl::get_info< info::context::platform > () const
 
template<>
std::vector< cl::sycl::devicecontext_impl::get_info< info::context::devices > () const
 
template<>
std::vector< cl::sycl::memory_ordercontext_impl::get_info< info::context::atomic_memory_order_capabilities > () const
 
std::vector< std::string_view > tokenize (const std::string &Filter, const std::string &Delim)
 
std::vector< info::fp_configread_fp_bitfield (cl_device_fp_config bits)
 
std::vector< info::partition_affinity_domainread_domain_bitfield (cl_device_affinity_domain bits)
 
std::vector< info::execution_capabilityread_execution_bitfield (cl_device_exec_capabilities bits)
 
static bool is_sycl_partition_property (info::partition_property PP)
 
template<info::device param>
info::param_traits< info::device, param >::return_type get_device_info_host ()=delete
 
template<>
info::device_type get_device_info_host< info::device::device_type > ()
 
template<>
cl_uint get_device_info_host< info::device::vendor_id > ()
 
template<>
cl_uint get_device_info_host< info::device::max_compute_units > ()
 
template<>
cl_uint get_device_info_host< info::device::max_work_item_dimensions > ()
 
template<>
id< 3 > get_device_info_host< info::device::max_work_item_sizes > ()
 
template<>
constexpr size_t get_device_info_host< info::device::ext_oneapi_max_global_work_groups > ()
 
template<>
id< 1 > get_device_info_host< info::device::ext_oneapi_max_work_groups_1d > ()
 
template<>
id< 2 > get_device_info_host< info::device::ext_oneapi_max_work_groups_2d > ()
 
template<>
id< 3 > get_device_info_host< info::device::ext_oneapi_max_work_groups_3d > ()
 
template<>
size_t get_device_info_host< info::device::max_work_group_size > ()
 
template<>
cl_uint get_device_info_host< info::device::preferred_vector_width_char > ()
 
template<>
cl_uint get_device_info_host< info::device::preferred_vector_width_short > ()
 
template<>
cl_uint get_device_info_host< info::device::preferred_vector_width_int > ()
 
template<>
cl_uint get_device_info_host< info::device::preferred_vector_width_long > ()
 
template<>
cl_uint get_device_info_host< info::device::preferred_vector_width_float > ()
 
template<>
cl_uint get_device_info_host< info::device::preferred_vector_width_double > ()
 
template<>
cl_uint get_device_info_host< info::device::preferred_vector_width_half > ()
 
template<>
cl_uint get_device_info_host< info::device::native_vector_width_char > ()
 
template<>
cl_uint get_device_info_host< info::device::native_vector_width_short > ()
 
template<>
cl_uint get_device_info_host< info::device::native_vector_width_int > ()
 
template<>
cl_uint get_device_info_host< info::device::native_vector_width_long > ()
 
template<>
cl_uint get_device_info_host< info::device::native_vector_width_float > ()
 
template<>
cl_uint get_device_info_host< info::device::native_vector_width_double > ()
 
template<>
cl_uint get_device_info_host< info::device::native_vector_width_half > ()
 
template<>
cl_uint get_device_info_host< info::device::max_clock_frequency > ()
 
template<>
cl_uint get_device_info_host< info::device::address_bits > ()
 
template<>
cl_ulong get_device_info_host< info::device::global_mem_size > ()
 
template<>
cl_ulong get_device_info_host< info::device::max_mem_alloc_size > ()
 
template<>
bool get_device_info_host< info::device::image_support > ()
 
template<>
bool get_device_info_host< info::device::atomic64 > ()
 
template<>
std::vector< memory_orderget_device_info_host< info::device::atomic_memory_order_capabilities > ()
 
template<>
cl_uint get_device_info_host< info::device::max_read_image_args > ()
 
template<>
cl_uint get_device_info_host< info::device::max_write_image_args > ()
 
template<>
size_t get_device_info_host< info::device::image2d_max_width > ()
 
template<>
size_t get_device_info_host< info::device::image2d_max_height > ()
 
template<>
size_t get_device_info_host< info::device::image3d_max_width > ()
 
template<>
size_t get_device_info_host< info::device::image3d_max_height > ()
 
template<>
size_t get_device_info_host< info::device::image3d_max_depth > ()
 
template<>
size_t get_device_info_host< info::device::image_max_buffer_size > ()
 
template<>
size_t get_device_info_host< info::device::image_max_array_size > ()
 
template<>
cl_uint get_device_info_host< info::device::max_samplers > ()
 
template<>
size_t get_device_info_host< info::device::max_parameter_size > ()
 
template<>
cl_uint get_device_info_host< info::device::mem_base_addr_align > ()
 
template<>
std::vector< info::fp_configget_device_info_host< info::device::half_fp_config > ()
 
template<>
std::vector< info::fp_configget_device_info_host< info::device::single_fp_config > ()
 
template<>
std::vector< info::fp_configget_device_info_host< info::device::double_fp_config > ()
 
template<>
info::global_mem_cache_type get_device_info_host< info::device::global_mem_cache_type > ()
 
template<>
cl_uint get_device_info_host< info::device::global_mem_cache_line_size > ()
 
template<>
cl_ulong get_device_info_host< info::device::global_mem_cache_size > ()
 
template<>
cl_ulong get_device_info_host< info::device::max_constant_buffer_size > ()
 
template<>
cl_uint get_device_info_host< info::device::max_constant_args > ()
 
template<>
info::local_mem_type get_device_info_host< info::device::local_mem_type > ()
 
template<>
cl_ulong get_device_info_host< info::device::local_mem_size > ()
 
template<>
bool get_device_info_host< info::device::error_correction_support > ()
 
template<>
bool get_device_info_host< info::device::host_unified_memory > ()
 
template<>
size_t get_device_info_host< info::device::profiling_timer_resolution > ()
 
template<>
bool get_device_info_host< info::device::is_endian_little > ()
 
template<>
bool get_device_info_host< info::device::is_available > ()
 
template<>
bool get_device_info_host< info::device::is_compiler_available > ()
 
template<>
bool get_device_info_host< info::device::is_linker_available > ()
 
template<>
std::vector< info::execution_capabilityget_device_info_host< info::device::execution_capabilities > ()
 
template<>
bool get_device_info_host< info::device::queue_profiling > ()
 
template<>
std::vector< std::string > get_device_info_host< info::device::built_in_kernels > ()
 
template<>
platform get_device_info_host< info::device::platform > ()
 
template<>
std::string get_device_info_host< info::device::name > ()
 
template<>
std::string get_device_info_host< info::device::vendor > ()
 
template<>
std::string get_device_info_host< info::device::driver_version > ()
 
template<>
std::string get_device_info_host< info::device::profile > ()
 
template<>
std::string get_device_info_host< info::device::version > ()
 
template<>
std::string get_device_info_host< info::device::opencl_c_version > ()
 
template<>
std::vector< std::string > get_device_info_host< info::device::extensions > ()
 
template<>
size_t get_device_info_host< info::device::printf_buffer_size > ()
 
template<>
bool get_device_info_host< info::device::preferred_interop_user_sync > ()
 
template<>
device get_device_info_host< info::device::parent_device > ()
 
template<>
cl_uint get_device_info_host< info::device::partition_max_sub_devices > ()
 
template<>
std::vector< info::partition_propertyget_device_info_host< info::device::partition_properties > ()
 
template<>
std::vector< info::partition_affinity_domainget_device_info_host< info::device::partition_affinity_domains > ()
 
template<>
info::partition_property get_device_info_host< info::device::partition_type_property > ()
 
template<>
info::partition_affinity_domain get_device_info_host< info::device::partition_type_affinity_domain > ()
 
template<>
cl_uint get_device_info_host< info::device::reference_count > ()
 
template<>
cl_uint get_device_info_host< info::device::max_num_sub_groups > ()
 
template<>
std::vector< size_t > get_device_info_host< info::device::sub_group_sizes > ()
 
template<>
bool get_device_info_host< info::device::sub_group_independent_forward_progress > ()
 
template<>
bool get_device_info_host< info::device::kernel_kernel_pipe_support > ()
 
template<>
bool get_device_info_host< info::device::usm_device_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_host_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_shared_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_restricted_shared_allocations > ()
 
template<>
bool get_device_info_host< info::device::usm_system_allocations > ()
 
template<>
bool get_device_info_host< info::device::ext_intel_mem_channel > ()
 
cl_uint get_native_vector_width (size_t idx)
 
template<>
std::string get_device_info_host< info::device::ext_intel_pci_address > ()
 
template<>
cl_uint get_device_info_host< info::device::ext_intel_gpu_eu_count > ()
 
template<>
cl_uint get_device_info_host< info::device::ext_intel_gpu_eu_simd_width > ()
 
template<>
cl_uint get_device_info_host< info::device::ext_intel_gpu_slices > ()
 
template<>
cl_uint get_device_info_host< info::device::ext_intel_gpu_subslices_per_slice > ()
 
template<>
cl_uint get_device_info_host< info::device::ext_intel_gpu_eu_count_per_subslice > ()
 
template<>
cl_ulong get_device_info_host< info::device::ext_intel_max_mem_bandwidth > ()
 
template<>
bool get_device_info_host< info::device::ext_oneapi_srgb > ()
 
template<>
detail::uuid_type get_device_info_host< info::device::ext_intel_device_info_uuid > ()
 
template<>
cl_ulong event_impl::get_profiling_info< info::event_profiling::command_submit > () const
 
template<>
cl_ulong event_impl::get_profiling_info< info::event_profiling::command_start > () const
 
template<>
cl_ulong event_impl::get_profiling_info< info::event_profiling::command_end > () const
 
template<>
cl_uint event_impl::get_info< info::event::reference_count > () const
 
template<>
info::event_command_status event_impl::get_info< info::event::command_execution_status > () const
 
static uint64_t getTimestamp ()
 
bool match_types (const info::device_type &l, const info::device_type &r)
 
info::device_type get_forced_type ()
 
void releaseSharedGlobalHandles ()
 
void shutdown ()
 
 __attribute__ ((destructor)) static void syclPreunload()
 
 __attribute__ ((destructor(110))) static void syclUnload()
 
std::vector< RT::PiEventgetOrWaitEvents (std::vector< cl::sycl::event > DepEvents, ContextImplPtr Context)
 
template<info::device Param>
static bool checkImageValueRange (const std::vector< device > &Devices, const size_t Value)
 
template<typename T , typename... Args>
static bool checkAnyImpl (T)
 
template<typename ValT , typename VarT , typename... Args>
static bool checkAnyImpl (ValT Value, VarT Variant, Args... Arguments)
 
template<typename T , typename... Args>
static bool checkAny (const T Value, Args... Arguments)
 
template<typename T >
static void getImageInfo (const ContextImplPtr Context, RT::PiMemImageInfo Info, T &Dest, RT::PiMem InteropMemObject)
 
static bool checkAllDevicesAreInContext (const std::vector< device > &Devices, const context &Context)
 
static bool checkAllDevicesHaveAspect (const std::vector< device > &Devices, aspect Aspect)
 
template<>
context kernel_impl::get_info< info::kernel::context > () const
 
template<info::kernel_device_specific Param>
info::param_traits< info::kernel_device_specific, Param >::return_type get_kernel_device_specific_info_host (const cl::sycl::device &Device)
 
template<>
cl::sycl::range< 3 > get_kernel_device_specific_info_host< info::kernel_device_specific::global_work_size > (const cl::sycl::device &)
 
template<>
size_t get_kernel_device_specific_info_host< info::kernel_device_specific::work_group_size > (const cl::sycl::device &Dev)
 
template<>
cl::sycl::range< 3 > get_kernel_device_specific_info_host< info::kernel_device_specific::compile_work_group_size > (const cl::sycl::device &)
 
template<>
size_t get_kernel_device_specific_info_host< info::kernel_device_specific::preferred_work_group_size_multiple > (const cl::sycl::device &Dev)
 
template<>
cl_ulong get_kernel_device_specific_info_host< info::kernel_device_specific::private_mem_size > (const cl::sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::ext_codeplay_num_regs > (const cl::sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::max_num_sub_groups > (const cl::sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::compile_num_sub_groups > (const cl::sycl::device &)
 
template<>
uint32_t get_kernel_device_specific_info_host< info::kernel_device_specific::compile_sub_group_size > (const cl::sycl::device &)
 
static void waitForEvents (const std::vector< EventImplPtr > &Events)
 
static RT::PiMemFlags getMemObjCreationFlags (void *UserPtr, bool HostPtrReadOnly)
 
void prepTermPositions (TermPositions &pos, int Dimensions, detail::SYCLMemObjI::MemObjType Type)
 
void copyH2D (SYCLMemObjI *SYCLMemObj, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, RT::PiMem DstMem, QueueImplPtr TgtQueue, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
 
void copyD2H (SYCLMemObjI *SYCLMemObj, RT::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
 
void copyD2D (SYCLMemObjI *SYCLMemObj, RT::PiMem SrcMem, QueueImplPtr SrcQueue, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, RT::PiMem DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 >, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent > DepEvents, RT::PiEvent &OutEvent)
 
static void copyH2H (SYCLMemObjI *, char *SrcMem, QueueImplPtr, unsigned int DimSrc, sycl::range< 3 > SrcSize, sycl::range< 3 > SrcAccessRange, sycl::id< 3 > SrcOffset, unsigned int SrcElemSize, char *DstMem, QueueImplPtr, unsigned int DimDst, sycl::range< 3 > DstSize, sycl::range< 3 > DstAccessRange, sycl::id< 3 > DstOffset, unsigned int DstElemSize, std::vector< RT::PiEvent >, RT::PiEvent &)
 
static bool parsePersistentCacheConfig ()
 
std::string getDirName (const char *Path)
 
template void * getPluginOpaqueData< cl::sycl::backend::ext_intel_esimd_emulator > (void *)
 
static bool IsBannedPlatform (platform Platform)
 
static void filterDeviceFilter (std::vector< RT::PiDevice > &PiDevices, RT::PiPlatform Platform)
 
template<info::platform param>
info::param_traits< info::platform, param >::return_type get_platform_info_host ()=delete
 
template<>
std::string get_platform_info_host< info::platform::profile > ()
 
template<>
std::string get_platform_info_host< info::platform::version > ()
 
template<>
std::string get_platform_info_host< info::platform::name > ()
 
template<>
std::string get_platform_info_host< info::platform::vendor > ()
 
template<>
std::vector< std::string > get_platform_info_host< info::platform::extensions > ()
 
template<typename... Ts>
constexpr size_t totalSize (const std::tuple< Ts... > &)
 
template<PiApiKind Kind, typename... ArgsT>
auto packCallArguments (ArgsT &&... Args)
 
template<>
cl_uint program_impl::get_info< info::program::reference_count > () const
 
template<>
context program_impl::get_info< info::program::context > () const
 
template<>
std::vector< deviceprogram_impl::get_info< info::program::devices > () const
 
static constexpr char UseSpvEnv ("SYCL_USE_KERNEL_SPV")
 
static void enableITTAnnotationsIfNeeded (const RT::PiProgram &Prog, const plugin &Plugin)
 This function enables ITT annotations in SPIR-V module by setting a specialization constant if INTEL_LIBITTNOTIFY64 env variable is set. More...
 
static RT::PiProgram createBinaryProgram (const ContextImplPtr Context, const device &Device, const unsigned char *Data, size_t DataLen, const std::vector< pi_device_binary_property > Metadata)
 
static RT::PiProgram createSpirvProgram (const ContextImplPtr Context, const unsigned char *Data, size_t DataLen)
 
template<typename ExceptionT , typename RetT >
RetT * waitUntilBuilt (KernelProgramCache &Cache, KernelProgramCache::BuildResult< RetT > *BuildResult)
 
template<typename RetT , typename ExceptionT , typename KeyT , typename AcquireFT , typename GetCacheFT , typename BuildFT >
KernelProgramCache::BuildResult< RetT > * getOrBuild (KernelProgramCache &KPCache, KeyT &&CacheKey, AcquireFT &&Acquire, GetCacheFT &&GetCache, BuildFT &&Build)
 Try to fetch entity (kernel or program) from cache. More...
 
static bool isDeviceBinaryTypeSupported (const context &C, RT::PiDeviceBinaryType Format)
 
static const chargetFormatStr (RT::PiDeviceBinaryType Format)
 
static void applyOptionsFromImage (std::string &CompileOpts, std::string &LinkOpts, const RTDeviceBinaryImage &Img)
 
static void applyOptionsFromEnvironment (std::string &CompileOpts, std::string &LinkOpts)
 
static bool loadDeviceLib (const ContextImplPtr Context, const char *Name, RT::PiProgram &Prog)
 
static const chargetDeviceLibFilename (DeviceLibExt Extension)
 
static const chargetDeviceLibExtensionStr (DeviceLibExt Extension)
 
static RT::PiProgram loadDeviceLibFallback (const ContextImplPtr Context, DeviceLibExt Extension, const RT::PiDevice &Device, std::map< std::pair< DeviceLibExt, RT::PiDevice >, RT::PiProgram > &CachedLibPrograms)
 
static bool isDeviceLibRequired (DeviceLibExt Ext, uint32_t DeviceLibReqMask)
 
static std::vector< RT::PiProgramgetDeviceLibPrograms (const ContextImplPtr Context, const RT::PiDevice &Device, std::map< std::pair< DeviceLibExt, RT::PiDevice >, RT::PiProgram > &CachedLibPrograms, uint32_t DeviceLibReqMask)
 
static ProgramManager::KernelArgMask createKernelArgMask (const pi::ByteArray &Bytes)
 
static bundle_state getBinImageState (const RTDeviceBinaryImage *BinImage)
 
static bool compatibleWithDevice (RTDeviceBinaryImage *BinImage, const device &Dev)
 
template<>
cl_uint queue_impl::get_info< info::queue::reference_count > () const
 
template<>
context queue_impl::get_info< info::queue::context > () const
 
template<>
device queue_impl::get_info< info::queue::device > () const
 
static event prepareUSMEvent (const std::shared_ptr< detail::queue_impl > &QueueImpl, RT::PiEvent NativeEvent)
 
static std::string demangleKernelName (std::string Name)
 
static std::string deviceToString (device Device)
 
static std::string accessModeToString (access::mode Mode)
 
static std::vector< RT::PiEventgetPiEvents (const std::vector< EventImplPtr > &EventImpls)
 
static std::string cgTypeToString (detail::CG::CGTYPE Type)
 
static void adjustNDRangePerKernel (NDRDescT &NDR, RT::PiKernel Kernel, const device_impl &DeviceImpl)
 
static void ReverseRangeDimensionsForKernel (NDRDescT &NDR)
 
void DispatchNativeKernel (void *Blob)
 
static bool doOverlap (const Requirement *LHS, const Requirement *RHS)
 Checks whether two requirements overlap or not. More...
 
static bool sameCtx (const ContextImplPtr &LHS, const ContextImplPtr &RHS)
 
static bool IsSuitableSubReq (const Requirement *Req)
 Checks if current requirement is requirement for sub buffer. More...
 
static bool isAccessModeAllowed (access::mode Required, access::mode Current)
 Checks if the required access mode is allowed under the current one. More...
 
static access::mode combineAccessModes (access::mode A, access::mode B)
 Combines two access modes into a single one that allows both. More...
 
static bool markNodeAsVisited (Command *Cmd, std::vector< Command * > &Visited)
 
static void unmarkVisitedNodes (std::vector< Command * > &Visited)
 
static void handleVisitedNodes (std::vector< Command * > &Visited)
 
static void printDotRecursive (std::fstream &Stream, std::vector< Command * > &Visited, Command *Cmd)
 
static CommandinsertMapUnmapForLinkedCmds (AllocaCommandBase *AllocaCmdSrc, AllocaCommandBase *AllocaCmdDst, access::mode MapMode)
 
static bool checkHostUnifiedMemory (const ContextImplPtr &Ctx)
 
static bool isInteropHostTask (const std::unique_ptr< ExecCGCommand > &Cmd)
 
static void combineAccessModesOfReqs (std::vector< Requirement * > &Reqs)
 
static CommandgetCommand (const EventImplPtr &Event)
 
static bool doOverlap (const Requirement *LHS, const Requirement *RHS)
 
static bool isHostAccessorCmd (Command *Cmd)
 
static void deallocateStreams (std::vector< std::shared_ptr< stream_impl >> &StreamsToDeallocate)
 
void initStream (StreamImplPtr Stream, QueueImplPtr Queue)
 
void stableSerializeSpecConstRegistry (const SpecConstRegistryT &Reg, SerializedObj &Dst)
 
std::ostream & operator<< (std::ostream &Out, const spec_constant_impl &V)
 
void force_type (info::device_type &t, const info::device_type &ft)
 
ext::oneapi::device_func_ptr_holder_t getDeviceFunctionPointerImpl (device &D, program &P, const char *FuncName)
 

Variables

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

Typedef Documentation

◆ AccessorImplPtr

using cl::sycl::detail::AccessorImplPtr = typedef std::shared_ptr<AccessorImplHost>

Definition at line 132 of file accessor_impl.hpp.

◆ add_pointer_t

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

Definition at line 37 of file stl_type_traits.hpp.

◆ address_space_list

template<access::address_space... V>
using cl::sycl::detail::address_space_list = typedef value_list<access::address_space, V...>

Definition at line 82 of file type_list.hpp.

◆ allocator_pointer_t

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

Definition at line 49 of file stl_type_traits.hpp.

◆ allocator_value_type_t

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

Definition at line 46 of file stl_type_traits.hpp.

◆ AllowListParsedT

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

Definition at line 23 of file allowlist.hpp.

◆ bool_constant

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

Definition at line 40 of file stl_type_traits.hpp.

◆ change_base_type_t

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

Definition at line 110 of file type_traits.hpp.

◆ common_rel_ret_t

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

Definition at line 506 of file generic_type_traits.hpp.

◆ conditional_t

template<bool B, class T , class F >
using cl::sycl::detail::conditional_t = typedef typename std::conditional<B, T, F>::type

Definition at line 27 of file stl_type_traits.hpp.

◆ const_if_const_AS

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

Definition at line 348 of file type_traits.hpp.

◆ ContextImplPtr

Definition at line 31 of file memory_manager.hpp.

◆ convert_data_type

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

Definition at line 289 of file generic_type_traits.hpp.

◆ ConvertToOpenCLType_t

◆ copy_cv_qualifiers_t

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

Definition at line 67 of file type_traits.hpp.

◆ DeviceDescT

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

Definition at line 22 of file allowlist.hpp.

◆ DeviceImageImplPtr

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

Definition at line 66 of file kernel_bundle.hpp.

◆ DeviceImplPtr

Definition at line 54 of file program_manager.hpp.

◆ DevImgSelectorImpl

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

Definition at line 447 of file kernel_bundle.hpp.

◆ empty_type_list

Definition at line 25 of file type_list.hpp.

◆ enable_if_t

template<bool B, class T = void>
using cl::sycl::detail::enable_if_t = typedef typename std::enable_if<B, T>::type

Definition at line 24 of file stl_type_traits.hpp.

◆ EnableIfFP

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

Definition at line 65 of file stream.hpp.

◆ EnableIfImgAccDataT

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

Definition at line 67 of file image_impl.hpp.

◆ EnableIfSwizzleVec

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

Definition at line 658 of file stream.hpp.

◆ EventImplPtr

Definition at line 30 of file memory_manager.hpp.

◆ find_larger_type_t

template<typename TL , typename T >
using cl::sycl::detail::find_larger_type_t = typedef find_type_t<TL, is_type_size_greater, T>

Definition at line 128 of file type_list.hpp.

◆ find_same_size_type_t

template<typename TL , typename T >
using cl::sycl::detail::find_same_size_type_t = typedef find_type_t<TL, is_type_size_equal, T>

Definition at line 122 of file type_list.hpp.

◆ find_smaller_type_t

template<typename TL , typename T >
using cl::sycl::detail::find_smaller_type_t = typedef find_type_t<TL, is_type_size_less, T>

Definition at line 125 of file type_list.hpp.

◆ find_twice_as_large_type_t

template<typename TL , typename T >
using cl::sycl::detail::find_twice_as_large_type_t = typedef find_type_t<TL, is_type_size_double_of, T>

Definition at line 134 of file type_list.hpp.

◆ find_twice_as_small_type_t

template<typename TL , typename T >
using cl::sycl::detail::find_twice_as_small_type_t = typedef find_type_t<TL, is_type_size_half_of, T>

Definition at line 131 of file type_list.hpp.

◆ find_type_t

template<typename TL , template< typename, typename > class C, typename T >
using cl::sycl::detail::find_type_t = typedef typename find_type<TL, C, T>::type

Definition at line 119 of file type_list.hpp.

◆ FmtFlags

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

Definition at line 21 of file stream.hpp.

◆ GlobalBufAccessorT

Definition at line 69 of file stream.hpp.

◆ GlobalBufPtrType

Definition at line 74 of file stream.hpp.

◆ GlobalOffsetAccessorT

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

Definition at line 80 of file stream.hpp.

◆ GlobalOffsetPtrType

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

Definition at line 85 of file stream.hpp.

◆ head_t

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

Definition at line 18 of file type_list.hpp.

◆ image_allocator

Definition at line 39 of file image_impl.hpp.

◆ int_constant

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

Definition at line 69 of file type_traits.hpp.

◆ is_charn

Definition at line 79 of file generic_type_traits.hpp.

◆ is_doublen

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

Definition at line 29 of file generic_type_traits.hpp.

◆ is_float_to_float

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

Definition at line 259 of file types.hpp.

◆ is_float_to_int

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

Definition at line 254 of file types.hpp.

◆ is_floatn

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

Definition at line 24 of file generic_type_traits.hpp.

◆ is_gen_based_on_type_sizeof

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

Definition at line 206 of file type_traits.hpp.

◆ is_genchar

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

Definition at line 93 of file generic_type_traits.hpp.

◆ is_gencross

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

Definition at line 76 of file generic_type_traits.hpp.

◆ is_gencrossdouble

Definition at line 70 of file generic_type_traits.hpp.

◆ is_gencrossfloat

Definition at line 67 of file generic_type_traits.hpp.

◆ is_gencrosshalf

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

Definition at line 73 of file generic_type_traits.hpp.

◆ is_genfloat

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

Definition at line 37 of file generic_type_traits.hpp.

◆ is_genfloatd

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

Definition at line 31 of file generic_type_traits.hpp.

◆ is_genfloatf

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

Definition at line 26 of file generic_type_traits.hpp.

◆ is_genfloath

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

Definition at line 35 of file generic_type_traits.hpp.

◆ is_genfloatptr

Definition at line 225 of file generic_type_traits.hpp.

◆ is_gengeodouble

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

Definition at line 49 of file generic_type_traits.hpp.

◆ is_gengeofloat

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

Definition at line 46 of file generic_type_traits.hpp.

◆ is_gengeohalf

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

Definition at line 51 of file generic_type_traits.hpp.

◆ is_genint

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

Definition at line 116 of file generic_type_traits.hpp.

◆ is_geninteger

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

Definition at line 147 of file generic_type_traits.hpp.

◆ is_geninteger16bit

Definition at line 209 of file generic_type_traits.hpp.

◆ is_geninteger32bit

Definition at line 212 of file generic_type_traits.hpp.

◆ is_geninteger64bit

Definition at line 215 of file generic_type_traits.hpp.

◆ is_geninteger8bit

Definition at line 206 of file generic_type_traits.hpp.

◆ is_genintptr

Definition at line 220 of file generic_type_traits.hpp.

◆ is_genlong

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

Definition at line 127 of file generic_type_traits.hpp.

◆ is_genlonglong

Definition at line 139 of file generic_type_traits.hpp.

◆ is_genptr

Definition at line 230 of file generic_type_traits.hpp.

◆ is_genshort

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

Definition at line 99 of file generic_type_traits.hpp.

◆ is_gentype

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

Definition at line 173 of file generic_type_traits.hpp.

◆ is_halfn

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

Definition at line 33 of file generic_type_traits.hpp.

◆ is_igenchar

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

Definition at line 88 of file generic_type_traits.hpp.

◆ is_igeninteger

Definition at line 150 of file generic_type_traits.hpp.

◆ is_igeninteger16bit

Definition at line 185 of file generic_type_traits.hpp.

◆ is_igeninteger32bit

Definition at line 188 of file generic_type_traits.hpp.

◆ is_igeninteger64bit

Definition at line 191 of file generic_type_traits.hpp.

◆ is_igeninteger8bit

Definition at line 182 of file generic_type_traits.hpp.

◆ is_igenlonginteger

Definition at line 142 of file generic_type_traits.hpp.

◆ is_int_to_float

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

Definition at line 249 of file types.hpp.

◆ is_int_to_int

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

Definition at line 218 of file types.hpp.

◆ is_intn

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

Definition at line 114 of file generic_type_traits.hpp.

◆ is_longlongn

Definition at line 136 of file generic_type_traits.hpp.

◆ is_longn

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

Definition at line 125 of file generic_type_traits.hpp.

◆ is_nan_type

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

Definition at line 232 of file generic_type_traits.hpp.

◆ is_one_of_spaces

template<access::address_space AS, typename VL >
using cl::sycl::detail::is_one_of_spaces = typedef is_contained_value<access::address_space, AS, VL>

Definition at line 85 of file type_list.hpp.

◆ is_scharn

Definition at line 82 of file generic_type_traits.hpp.

◆ is_sgenfloat

Definition at line 40 of file generic_type_traits.hpp.

◆ is_sgengeo

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

Definition at line 62 of file generic_type_traits.hpp.

◆ is_sgeninteger

Definition at line 156 of file generic_type_traits.hpp.

◆ is_sgentype

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

Definition at line 179 of file generic_type_traits.hpp.

◆ is_shortn

Definition at line 96 of file generic_type_traits.hpp.

◆ is_sigeninteger

Definition at line 162 of file generic_type_traits.hpp.

◆ is_sint_to_float

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

Definition at line 239 of file types.hpp.

◆ is_sint_to_from_uint

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

Definition at line 233 of file types.hpp.

◆ is_sint_to_sint

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

Definition at line 223 of file types.hpp.

◆ is_standard_type

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

Definition at line 262 of file types.hpp.

◆ is_sugeninteger

Definition at line 165 of file generic_type_traits.hpp.

◆ is_ucharn

Definition at line 85 of file generic_type_traits.hpp.

◆ is_ugenchar

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

Definition at line 91 of file generic_type_traits.hpp.

◆ is_ugenint

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

Definition at line 111 of file generic_type_traits.hpp.

◆ is_ugeninteger

Definition at line 153 of file generic_type_traits.hpp.

◆ is_ugeninteger16bit

Definition at line 197 of file generic_type_traits.hpp.

◆ is_ugeninteger32bit

Definition at line 200 of file generic_type_traits.hpp.

◆ is_ugeninteger64bit

Definition at line 203 of file generic_type_traits.hpp.

◆ is_ugeninteger8bit

Definition at line 194 of file generic_type_traits.hpp.

◆ is_ugenlong

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

Definition at line 122 of file generic_type_traits.hpp.

◆ is_ugenlonginteger

Definition at line 145 of file generic_type_traits.hpp.

◆ is_ugenlonglong

Definition at line 133 of file generic_type_traits.hpp.

◆ is_ugenshort

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

Definition at line 105 of file generic_type_traits.hpp.

◆ is_uint_to_float

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

Definition at line 244 of file types.hpp.

◆ is_uint_to_uint

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

Definition at line 228 of file types.hpp.

◆ is_uintn

Definition at line 108 of file generic_type_traits.hpp.

◆ is_ulonglongn

Definition at line 130 of file generic_type_traits.hpp.

◆ is_ulongn

Definition at line 119 of file generic_type_traits.hpp.

◆ is_ushortn

Definition at line 102 of file generic_type_traits.hpp.

◆ is_validImageDataT

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

Definition at line 63 of file image_impl.hpp.

◆ is_vgenfloat

Definition at line 43 of file generic_type_traits.hpp.

◆ is_vgengeo

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

Definition at line 64 of file generic_type_traits.hpp.

◆ is_vgengeodouble

Definition at line 57 of file generic_type_traits.hpp.

◆ is_vgengeofloat

Definition at line 54 of file generic_type_traits.hpp.

◆ is_vgengeohalf

Definition at line 60 of file generic_type_traits.hpp.

◆ is_vgeninteger

Definition at line 159 of file generic_type_traits.hpp.

◆ is_vgentype

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

Definition at line 176 of file generic_type_traits.hpp.

◆ is_vigeninteger

Definition at line 168 of file generic_type_traits.hpp.

◆ is_vugeninteger

Definition at line 171 of file generic_type_traits.hpp.

◆ IsBitAND

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

Definition at line 43 of file known_identity.hpp.

◆ IsBitOR

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

Definition at line 48 of file known_identity.hpp.

◆ IsBitXOR

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

Definition at line 53 of file known_identity.hpp.

◆ IsFalseIdentityOp

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

Definition at line 98 of file known_identity.hpp.

◆ IsKnownIdentityOp

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

Definition at line 112 of file known_identity.hpp.

◆ IsLogicalAND

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

Definition at line 58 of file known_identity.hpp.

◆ IsLogicalOR

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

Definition at line 63 of file known_identity.hpp.

◆ IsMaximum

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

Definition at line 38 of file known_identity.hpp.

◆ IsMaximumIdentityOp

template<typename T , class BinaryOperation >
using cl::sycl::detail::IsMaximumIdentityOp = typedef bool_constant<(is_sgeninteger<T>::value || is_sgenfloat<T>::value) && IsMaximum<T, BinaryOperation>::value>

Definition at line 94 of file known_identity.hpp.

◆ IsMinimum

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

Definition at line 33 of file known_identity.hpp.

◆ IsMinimumIdentityOp

template<typename T , class BinaryOperation >
using cl::sycl::detail::IsMinimumIdentityOp = typedef bool_constant<(is_sgeninteger<T>::value || is_sgenfloat<T>::value) && IsMinimum<T, BinaryOperation>::value>

Definition at line 88 of file known_identity.hpp.

◆ IsMultiplies

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

Definition at line 28 of file known_identity.hpp.

◆ IsOneIdentityOp

template<typename T , class BinaryOperation >
using cl::sycl::detail::IsOneIdentityOp = typedef bool_constant<(is_sgeninteger<T>::value || is_sgenfloat<T>::value) && IsMultiplies<T, BinaryOperation>::value>

Definition at line 77 of file known_identity.hpp.

◆ IsOnesIdentityOp

template<typename T , class BinaryOperation >
using cl::sycl::detail::IsOnesIdentityOp = typedef bool_constant<is_sgeninteger<T>::value && IsBitAND<T, BinaryOperation>::value>

Definition at line 82 of file known_identity.hpp.

◆ IsPlus

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

Definition at line 23 of file known_identity.hpp.

◆ IsPropertyListT

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

Definition at line 229 of file accessor.hpp.

◆ IsRunTimePropertyListT

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

Definition at line 233 of file accessor.hpp.

◆ IsTrueIdentityOp

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

Definition at line 102 of file known_identity.hpp.

◆ IsValidCoordType

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

Definition at line 31 of file image_accessor_util.hpp.

◆ IsZeroIdentityOp

template<typename T , class BinaryOperation >
using cl::sycl::detail::IsZeroIdentityOp = typedef bool_constant< (is_sgeninteger<T>::value && (IsPlus<T, BinaryOperation>::value || IsBitOR<T, BinaryOperation>::value || IsBitXOR<T, BinaryOperation>::value)) || (is_sgenfloat<T>::value && IsPlus<T, BinaryOperation>::value)>

Definition at line 71 of file known_identity.hpp.

◆ iterator_category_t

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

Definition at line 52 of file stl_type_traits.hpp.

◆ iterator_pointer_t

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

Definition at line 58 of file stl_type_traits.hpp.

◆ iterator_to_const_type_t

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

Definition at line 62 of file stl_type_traits.hpp.

◆ iterator_value_type_t

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

Definition at line 55 of file stl_type_traits.hpp.

◆ KernelBundleImplPtr

Definition at line 131 of file kernel_bundle.hpp.

◆ KernelSetId

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

Definition at line 324 of file common.hpp.

◆ lambda_arg_type

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

Definition at line 111 of file handler.hpp.

◆ LocalAccessorImplPtr

Definition at line 183 of file accessor_impl.hpp.

◆ LockGuard

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

Definition at line 28 of file global_handler.cpp.

◆ make_floating_point_t

Definition at line 266 of file generic_type_traits.hpp.

◆ make_larger_t

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

Definition at line 339 of file type_traits.hpp.

◆ make_signed_impl_t

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

Definition at line 139 of file type_traits.hpp.

◆ make_signed_t

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

Definition at line 167 of file type_traits.hpp.

◆ make_singed_integer_t

Definition at line 269 of file generic_type_traits.hpp.

◆ make_type_t

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

Definition at line 303 of file type_traits.hpp.

◆ make_unsigned_impl_t

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

Definition at line 173 of file type_traits.hpp.

◆ make_unsigned_t

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

Definition at line 201 of file type_traits.hpp.

◆ make_unsinged_integer_t

Definition at line 273 of file generic_type_traits.hpp.

◆ memory_order

Definition at line 36 of file atomic.hpp.

◆ nan_argument_base_t

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

Definition at line 263 of file generic_type_traits.hpp.

◆ nan_return_t

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

Definition at line 260 of file generic_type_traits.hpp.

◆ native_op_list

◆ OSModuleHandle

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

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

Definition at line 48 of file os_util.hpp.

◆ output_iterator_requirements

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

Definition at line 70 of file stl_type_traits.hpp.

◆ PlatformImplPtr

Definition at line 30 of file context_impl.hpp.

◆ ProgramImplPtr

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

Definition at line 32 of file kernel_impl.hpp.

◆ QueueImplPtr

Definition at line 29 of file memory_manager.hpp.

◆ rel_ret_t

template<typename T >
using cl::sycl::detail::rel_ret_t = typedef typename RelationalReturnType<T>::type

Definition at line 534 of file generic_type_traits.hpp.

◆ rel_sign_bit_test_arg_t

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

Definition at line 553 of file generic_type_traits.hpp.

◆ rel_sign_bit_test_ret_t

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

Definition at line 549 of file generic_type_traits.hpp.

◆ rel_t

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

Definition at line 131 of file types.hpp.

◆ remove_const_t

template<typename T >
using cl::sycl::detail::remove_const_t = typedef typename std::remove_const<T>::type

Definition at line 30 of file stl_type_traits.hpp.

◆ remove_cv_t

template<typename T >
using cl::sycl::detail::remove_cv_t = typedef typename std::remove_cv<T>::type

Definition at line 32 of file stl_type_traits.hpp.

◆ remove_pointer_t

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

Definition at line 275 of file type_traits.hpp.

◆ remove_reference_t

template<typename T >
using cl::sycl::detail::remove_reference_t = typedef typename std::remove_reference<T>::type

Definition at line 35 of file stl_type_traits.hpp.

◆ Requirement

Definition at line 208 of file accessor_impl.hpp.

◆ select_apply_cl_scalar_t

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

Definition at line 365 of file generic_type_traits.hpp.

◆ select_apply_cl_t

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

Definition at line 2154 of file types.hpp.

◆ select_cl_scalar_float_t

Definition at line 381 of file generic_type_traits.hpp.

◆ select_cl_scalar_integral_signed_t

◆ select_cl_scalar_integral_t

Definition at line 387 of file generic_type_traits.hpp.

◆ select_cl_scalar_integral_unsigned_t

◆ select_cl_scalar_t

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

Definition at line 399 of file generic_type_traits.hpp.

◆ SelectMatchingOpenCLType_t

template<typename T >
using cl::sycl::detail::SelectMatchingOpenCLType_t = typedef typename select_cl_mptr_or_vector_or_scalar<T>::type

Definition at line 461 of file generic_type_traits.hpp.

◆ SerializedObj

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

Definition at line 56 of file util.hpp.

◆ SpecConstRegistryT

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

Definition at line 44 of file spec_constant_impl.hpp.

◆ StreamImplPtr

Definition at line 36 of file commands.hpp.

◆ sycl_memory_object_allocator

◆ tail_t

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

Definition at line 20 of file type_list.hpp.

◆ tuple_element_t

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

Definition at line 56 of file tuple.hpp.

◆ type_helper

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

Definition at line 440 of file generic_type_traits.hpp.

◆ uuid_type

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

Definition at line 62 of file type_traits.hpp.

◆ vector_element_impl_t

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

Definition at line 92 of file type_traits.hpp.

◆ vector_element_t

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

Definition at line 100 of file type_traits.hpp.

◆ void_t

template<class... >
using cl::sycl::detail::void_t = typedef void

Definition at line 42 of file stl_type_traits.hpp.

Enumeration Type Documentation

◆ backend_errc

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

Definition at line 46 of file backend.hpp.

◆ BlockingT

Enumerator
NON_BLOCKING 
BLOCKING 

Definition at line 45 of file commands.hpp.

◆ BuildState

Enumerator
BS_InProgress 
BS_Done 
BS_Failed 

Definition at line 48 of file program_manager.cpp.

◆ ConfigID

Enumerator
START 
END 

Definition at line 50 of file config.hpp.

◆ CUDAContextT

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

Enumerator
primary 
custom 

Definition at line 46 of file queue_impl.hpp.

◆ DataLessPropKind

Enumerator
BufferUseHostPtr 
ImageUseHostPtr 
QueueEnableProfiling 
InOrder 
NoInit 
BufferUsePinnedHostMemory 
UsePrimaryContext 
InitializeToIdentity 
UseDefaultStream 
LastKnownDataLessPropKind 
DataLessPropKindSize 

Definition at line 26 of file property_helper.hpp.

◆ DeviceLibExt

enum cl::sycl::detail::DeviceLibExt : std::uint32_t
strong
Enumerator
cl_intel_devicelib_assert 
cl_intel_devicelib_math 
cl_intel_devicelib_math_fp64 
cl_intel_devicelib_complex 
cl_intel_devicelib_complex_fp64 
cl_intel_devicelib_cstring 

Definition at line 59 of file program_manager.hpp.

◆ ExtendedMembersType

enum cl::sycl::detail::ExtendedMembersType : unsigned int
strong
Enumerator
HANDLER_KERNEL_BUNDLE 
HANDLER_MEM_ADVICE 
HANDLER_IMPL 

Definition at line 94 of file cg.hpp.

◆ HandlerSubmissionState

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

Definition at line 19 of file handler_impl.hpp.

◆ kernel_param_kind_t

Enumerator
kind_accessor 
kind_std_layout 
kind_sampler 
kind_pointer 
kind_specialization_constants_buffer 
kind_stream 
kind_invalid 

Definition at line 25 of file kernel_desc.hpp.

◆ PiApiKind

Enumerator
_PI_API 

Definition at line 42 of file pi.hpp.

◆ PropWithDataKind

Enumerator
BufferUseMutex 
BufferContextBound 
ImageUseMutex 
ImageContextBound 
BufferMemChannel 
PropWithDataKindSize 

Definition at line 43 of file property_helper.hpp.

◆ QueueOrder

Enumerator
Ordered 
OOO 

Definition at line 51 of file queue_impl.hpp.

Function Documentation

◆ __attribute__() [1/2]

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

Definition at line 161 of file global_handler.cpp.

References shutdown().

◆ __attribute__() [2/2]

cl::sycl::detail::__attribute__ ( (destructor)  )

◆ __SYCL2020_DEPRECATED()

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

◆ accessModeToString()

◆ addHostAccessorAndWait()

void cl::sycl::detail::addHostAccessorAndWait ( Requirement Req)

◆ adjustNDRangePerKernel()

◆ append()

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

◆ applyAllowList()

◆ applyOptionsFromEnvironment()

static void cl::sycl::detail::applyOptionsFromEnvironment ( std::string &  CompileOpts,
std::string &  LinkOpts 
)
static

◆ applyOptionsFromImage()

◆ argument_helper()

template<typename F , typename SuggestedArgType >
SuggestedArgType cl::sycl::detail::argument_helper (   ...)

◆ ArrayToStr()

template<int ArrayLength>
unsigned cl::sycl::detail::ArrayToStr ( char Buf,
const array< ArrayLength > &  Arr 
)
inline

◆ associateWithHandler()

◆ bit_cast()

template<typename To , typename From >
To cl::sycl::detail::bit_cast ( const From &  from)
noexcept

Definition at line 60 of file bit_cast.hpp.

◆ build_impl()

std::shared_ptr< detail::kernel_bundle_impl > cl::sycl::detail::build_impl ( const kernel_bundle< bundle_state::input > &  InputBundle,
const std::vector< device > &  Devs,
const property_list PropList 
)

Definition at line 239 of file kernel_bundle.cpp.

◆ cast_if_host_half() [1/2]

float cl::sycl::detail::cast_if_host_half ( half_impl::half  val)
inline

Definition at line 407 of file half_type.hpp.

◆ cast_if_host_half() [2/2]

template<typename T >
T cl::sycl::detail::cast_if_host_half ( T  val)
inline

Definition at line 405 of file half_type.hpp.

◆ cgTypeToString()

◆ check_kernel_lambda_takes_args()

template<typename F , typename... Args>
static constexpr bool cl::sycl::detail::check_kernel_lambda_takes_args ( )
staticconstexpr

Definition at line 148 of file cg_types.hpp.

◆ check_vector_size()

template<typename... Args>
void cl::sycl::detail::check_vector_size ( )
inline

Definition at line 633 of file generic_type_traits.hpp.

◆ checkAllDevicesAreInContext()

static bool cl::sycl::detail::checkAllDevicesAreInContext ( const std::vector< device > &  Devices,
const context Context 
)
static

◆ checkAllDevicesHaveAspect()

static bool cl::sycl::detail::checkAllDevicesHaveAspect ( const std::vector< device > &  Devices,
aspect  Aspect 
)
static

Definition at line 47 of file kernel_bundle_impl.hpp.

Referenced by has_kernel_bundle_impl().

◆ checkAny()

template<typename T , typename... Args>
static bool cl::sycl::detail::checkAny ( const T  Value,
Args...  Arguments 
)
static

Definition at line 40 of file image_impl.cpp.

References checkAnyImpl().

◆ checkAnyImpl() [1/2]

template<typename T , typename... Args>
static bool cl::sycl::detail::checkAnyImpl ( T  )
static

Definition at line 30 of file image_impl.cpp.

◆ checkAnyImpl() [2/2]

template<typename ValT , typename VarT , typename... Args>
static bool cl::sycl::detail::checkAnyImpl ( ValT  Value,
VarT  Variant,
Args...  Arguments 
)
static

Definition at line 35 of file image_impl.cpp.

Referenced by checkAny().

◆ checkForInfNan() [1/2]

template<typename T >
detail::enable_if_t< std::is_same<T, float>::value || std::is_same<T, double>::value, unsigned> cl::sycl::detail::checkForInfNan ( char Buf,
T  Val 
)
inline

Definition at line 233 of file stream.hpp.

References append(), cl::sycl::isinf(), cl::sycl::isnan(), and cl::sycl::signbit().

◆ checkForInfNan() [2/2]

template<typename T >
detail::enable_if_t<std::is_same<T, half>::value, unsigned> cl::sycl::detail::checkForInfNan ( char Buf,
T  Val 
)
inline

Definition at line 246 of file stream.hpp.

References append().

Referenced by ScalarToStr().

◆ checkHostUnifiedMemory()

static bool cl::sycl::detail::checkHostUnifiedMemory ( const ContextImplPtr Ctx)
static

Definition at line 627 of file graph_builder.cpp.

◆ checkImageValueRange()

template<info::device Param>
static bool cl::sycl::detail::checkImageValueRange ( const std::vector< device > &  Devices,
const size_t  Value 
)
static

Definition at line 22 of file image_impl.cpp.

◆ checkValueRange() [1/3]

template<int Dims>
void cl::sycl::detail::checkValueRange ( const range< Dims > &  R,
const id< Dims > &  O 
)

Definition at line 172 of file handler.hpp.

◆ checkValueRange() [2/3]

template<int Dims, typename T >
detail::enable_if_t<std::is_same<T, range<Dims> >::value || std::is_same<T, id<Dims> >::value> cl::sycl::detail::checkValueRange ( const T V)

Definition at line 153 of file handler.hpp.

◆ checkValueRange() [3/3]

template<int Dims, typename T >
detail::enable_if_t<std::is_same<T, nd_range<Dims> >::value> cl::sycl::detail::checkValueRange ( const T V)

Definition at line 190 of file handler.hpp.

◆ codeToString()

static std::string cl::sycl::detail::codeToString ( cl_int  code)
inlinestatic

◆ combineAccessModes()

static access::mode cl::sycl::detail::combineAccessModes ( access::mode  A,
access::mode  B 
)
static

Combines two access modes into a single one that allows both.

Definition at line 74 of file graph_builder.cpp.

References write().

Referenced by combineAccessModesOfReqs().

◆ combineAccessModesOfReqs()

static void cl::sycl::detail::combineAccessModesOfReqs ( std::vector< Requirement * > &  Reqs)
static

Definition at line 861 of file graph_builder.cpp.

References combineAccessModes().

Referenced by cl::sycl::detail::Scheduler::GraphBuilder::addCG().

◆ compatibleWithDevice()

static bool cl::sycl::detail::compatibleWithDevice ( RTDeviceBinaryImage BinImage,
const device Dev 
)
static

◆ compile_impl()

std::shared_ptr< detail::kernel_bundle_impl > cl::sycl::detail::compile_impl ( const kernel_bundle< bundle_state::input > &  InputBundle,
const std::vector< device > &  Devs,
const property_list PropList 
)

Definition at line 225 of file kernel_bundle.cpp.

◆ context_impl::get_info< info::context::atomic_memory_order_capabilities >()

◆ context_impl::get_info< info::context::devices >()

Definition at line 146 of file context_impl.cpp.

◆ context_impl::get_info< info::context::platform >()

◆ context_impl::get_info< info::context::reference_count >()

◆ convertChannelOrder() [1/2]

◆ convertChannelOrder() [2/2]

◆ convertChannelType() [1/2]

◆ convertChannelType() [2/2]

◆ convertDataToType() [1/2]

template<typename FROM , typename TO >
detail::enable_if_t<is_vgentype<FROM>::value && is_vgentype<TO>::value && sizeof(TO) == sizeof(FROM), TO> cl::sycl::detail::convertDataToType ( FROM  t)

Definition at line 481 of file generic_type_traits.hpp.

◆ convertDataToType() [2/2]

template<typename FROM , typename TO >
detail::enable_if_t<!(is_vgentype<FROM>::value && is_vgentype<TO>::value) && sizeof(TO) == sizeof(FROM), TO> cl::sycl::detail::convertDataToType ( FROM  t)

Definition at line 490 of file generic_type_traits.hpp.

References TryToGetPointer().

◆ convertImpl() [1/3]

template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t<std::is_same<T, R>::value, R> cl::sycl::detail::convertImpl ( T  Value)

Definition at line 266 of file types.hpp.

◆ convertImpl() [2/3]

template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t<!std::is_same<T, R>::value && (is_int_to_int<T, R>::value || is_int_to_float<T, R>::value || is_float_to_float<T, R>::value), R> cl::sycl::detail::convertImpl ( T  Value)

Definition at line 281 of file types.hpp.

◆ convertImpl() [3/3]

template<typename T , typename R , rounding_mode roundingMode, typename OpenCLT , typename OpenCLR >
detail::enable_if_t<is_float_to_int<T, R>::value, R> cl::sycl::detail::convertImpl ( T  Value)

◆ convertReadData() [1/4]

template<typename ChannelType >
void cl::sycl::detail::convertReadData ( const vec< ChannelType, 4 >  PixelData,
const image_channel_type  ImageChannelType,
vec< cl_float, 4 > &  RetData 
)

Definition at line 328 of file image_accessor_util.hpp.

References cl::sycl::fmax(), and PI_INVALID_VALUE.

◆ convertReadData() [2/4]

template<typename ChannelType >
void cl::sycl::detail::convertReadData ( const vec< ChannelType, 4 >  PixelData,
const image_channel_type  ImageChannelType,
vec< cl_half, 4 > &  RetData 
)

Definition at line 418 of file image_accessor_util.hpp.

References cl::sycl::fmax(), PI_INVALID_OPERATION, and PI_INVALID_VALUE.

◆ convertReadData() [3/4]

template<typename ChannelType >
void cl::sycl::detail::convertReadData ( const vec< ChannelType, 4 >  PixelData,
const image_channel_type  ImageChannelType,
vec< cl_int, 4 > &  RetData 
)

Definition at line 306 of file image_accessor_util.hpp.

References PI_INVALID_VALUE.

◆ convertReadData() [4/4]

template<typename ChannelType >
void cl::sycl::detail::convertReadData ( const vec< ChannelType, 4 >  PixelData,
const image_channel_type  ImageChannelType,
vec< cl_uint, 4 > &  RetData 
)

Definition at line 284 of file image_accessor_util.hpp.

References PI_INVALID_VALUE.

◆ convertToArrayOfN()

template<int NewDim, int DefaultValue, template< int > class T, int OldDim>
static T<NewDim> cl::sycl::detail::convertToArrayOfN ( T< OldDim >  OldObj)
static

Definition at line 252 of file accessor.hpp.

◆ convertToExtendedMembers()

static std::shared_ptr<std::vector<ExtendedMemberT> > cl::sycl::detail::convertToExtendedMembers ( const std::shared_ptr< const void > &  SPtr)
static

◆ convertToFloat4() [1/3]

template<typename T >
detail::enable_if_t<IsValidCoordType<T>::value, cl_float4> cl::sycl::detail::convertToFloat4 ( T  Coords)

Definition at line 60 of file image_accessor_util.hpp.

◆ convertToFloat4() [2/3]

template<typename T >
detail::enable_if_t<IsValidCoordType<T>::value, cl_float4> cl::sycl::detail::convertToFloat4 ( vec< T, 2 >  Coords)

Definition at line 66 of file image_accessor_util.hpp.

◆ convertToFloat4() [3/3]

template<typename T >
detail::enable_if_t<IsValidCoordType<T>::value, cl_float4> cl::sycl::detail::convertToFloat4 ( vec< T, 4 >  Coords)

Definition at line 73 of file image_accessor_util.hpp.

Referenced by imageReadSamplerHostImpl().

◆ convertWriteData() [1/4]

template<typename ChannelType >
vec<ChannelType, 4> cl::sycl::detail::convertWriteData ( const vec< cl_float, 4 >  WriteData,
const image_channel_type  ImageChannelType 
)

Definition at line 558 of file image_accessor_util.hpp.

References PI_INVALID_OPERATION, and PI_INVALID_VALUE.

◆ convertWriteData() [2/4]

template<typename ChannelType >
vec<ChannelType, 4> cl::sycl::detail::convertWriteData ( const vec< cl_half, 4 >  WriteData,
const image_channel_type  ImageChannelType 
)

Definition at line 636 of file image_accessor_util.hpp.

References PI_INVALID_OPERATION, and PI_INVALID_VALUE.

◆ convertWriteData() [3/4]

template<typename ChannelType >
vec<ChannelType, 4> cl::sycl::detail::convertWriteData ( const vec< cl_int, 4 >  WriteData,
const image_channel_type  ImageChannelType 
)

Definition at line 515 of file image_accessor_util.hpp.

References cl::sycl::clamp(), and PI_INVALID_VALUE.

◆ convertWriteData() [4/4]

template<typename ChannelType >
vec<ChannelType, 4> cl::sycl::detail::convertWriteData ( const vec< cl_uint, 4 >  WriteData,
const image_channel_type  ImageChannelType 
)

Definition at line 482 of file image_accessor_util.hpp.

References cl::sycl::clamp(), and PI_INVALID_VALUE.

◆ copyD2D()

void cl::sycl::detail::copyD2D ( SYCLMemObjI SYCLMemObj,
RT::PiMem  SrcMem,
QueueImplPtr  SrcQueue,
unsigned int  DimSrc,
sycl::range< 3 >  SrcSize,
sycl::range< 3 >  SrcAccessRange,
sycl::id< 3 >  SrcOffset,
unsigned int  SrcElemSize,
RT::PiMem  DstMem,
QueueImplPtr  ,
unsigned int  DimDst,
sycl::range< 3 >  DstSize,
sycl::range< 3 >  ,
sycl::id< 3 >  DstOffset,
unsigned int  DstElemSize,
std::vector< RT::PiEvent DepEvents,
RT::PiEvent OutEvent 
)

◆ copyD2H()

void cl::sycl::detail::copyD2H ( SYCLMemObjI SYCLMemObj,
RT::PiMem  SrcMem,
QueueImplPtr  SrcQueue,
unsigned int  DimSrc,
sycl::range< 3 >  SrcSize,
sycl::range< 3 >  SrcAccessRange,
sycl::id< 3 >  SrcOffset,
unsigned int  SrcElemSize,
char DstMem,
QueueImplPtr  ,
unsigned int  DimDst,
sycl::range< 3 >  DstSize,
sycl::range< 3 >  DstAccessRange,
sycl::id< 3 >  DstOffset,
unsigned int  DstElemSize,
std::vector< RT::PiEvent DepEvents,
RT::PiEvent OutEvent 
)

◆ copyH2D()

void cl::sycl::detail::copyH2D ( SYCLMemObjI SYCLMemObj,
char SrcMem,
QueueImplPtr  ,
unsigned int  DimSrc,
sycl::range< 3 >  SrcSize,
sycl::range< 3 >  SrcAccessRange,
sycl::id< 3 >  SrcOffset,
unsigned int  SrcElemSize,
RT::PiMem  DstMem,
QueueImplPtr  TgtQueue,
unsigned int  DimDst,
sycl::range< 3 >  DstSize,
sycl::range< 3 >  DstAccessRange,
sycl::id< 3 >  DstOffset,
unsigned int  DstElemSize,
std::vector< RT::PiEvent DepEvents,
RT::PiEvent OutEvent 
)

◆ copyH2H()

static void cl::sycl::detail::copyH2H ( SYCLMemObjI ,
char SrcMem,
QueueImplPtr  ,
unsigned int  DimSrc,
sycl::range< 3 >  SrcSize,
sycl::range< 3 >  SrcAccessRange,
sycl::id< 3 >  SrcOffset,
unsigned int  SrcElemSize,
char DstMem,
QueueImplPtr  ,
unsigned int  DimDst,
sycl::range< 3 >  DstSize,
sycl::range< 3 >  DstAccessRange,
sycl::id< 3 >  DstOffset,
unsigned int  DstElemSize,
std::vector< RT::PiEvent ,
RT::PiEvent  
)
static

Definition at line 493 of file memory_manager.cpp.

References memcpy(), and PI_INVALID_OPERATION.

Referenced by cl::sycl::detail::MemoryManager::copy().

◆ createBinaryProgram()

static RT::PiProgram cl::sycl::detail::createBinaryProgram ( const ContextImplPtr  Context,
const device Device,
const unsigned char Data,
size_t  DataLen,
const std::vector< pi_device_binary_property Metadata 
)
static

◆ createKernelArgMask()

static ProgramManager::KernelArgMask cl::sycl::detail::createKernelArgMask ( const pi::ByteArray Bytes)
static

Definition at line 998 of file program_manager.cpp.

Referenced by cl::sycl::detail::ProgramManager::addImages().

◆ createSpirvProgram()

static RT::PiProgram cl::sycl::detail::createSpirvProgram ( const ContextImplPtr  Context,
const unsigned char Data,
size_t  DataLen 
)
static

◆ createSyclObjFromImpl()

template<class T >
T cl::sycl::detail::createSyclObjFromImpl ( decltype(T::impl)  ImplObj)

Definition at line 199 of file common.hpp.

Referenced by cl::sycl::kernel::get_kernel_bundle(), and cl::sycl::get_kernel_bundle().

◆ deallocateStreams()

static void cl::sycl::detail::deallocateStreams ( std::vector< std::shared_ptr< stream_impl >> &  StreamsToDeallocate)
static

◆ declptr()

◆ demangleKernelName()

static std::string cl::sycl::detail::demangleKernelName ( std::string  Name)
static

◆ deviceIsAllowed()

bool cl::sycl::detail::deviceIsAllowed ( const DeviceDescT DeviceDesc,
const AllowListParsedT AllowListParsed 
)

◆ deviceToString()

◆ digitToChar()

char cl::sycl::detail::digitToChar ( const int  Digit)
inline

Definition at line 150 of file stream.hpp.

Referenced by floatingPointToDecStr(), and integralToBase().

◆ DispatchNativeKernel()

void cl::sycl::detail::DispatchNativeKernel ( void *  Blob)

◆ doOverlap() [1/2]

◆ doOverlap() [2/2]

static bool cl::sycl::detail::doOverlap ( const Requirement LHS,
const Requirement RHS 
)
static

Checks whether two requirements overlap or not.

This information can be used to prove that executing two kernels that work on different parts of the memory object in parallel is legal.

Definition at line 37 of file graph_builder.cpp.

References cl::sycl::detail::AccessorImplHost::MAccessRange, cl::sycl::detail::AccessorImplHost::MElemSize, cl::sycl::detail::AccessorImplHost::MOffsetInBytes, and cl::sycl::range< dimensions >::size().

◆ dumpConfig()

void cl::sycl::detail::dumpConfig ( )

Definition at line 148 of file config.cpp.

◆ enableITTAnnotationsIfNeeded()

static void cl::sycl::detail::enableITTAnnotationsIfNeeded ( const RT::PiProgram Prog,
const plugin Plugin 
)
static

This function enables ITT annotations in SPIR-V module by setting a specialization constant if INTEL_LIBITTNOTIFY64 env variable is set.

Definition at line 54 of file program_manager.cpp.

References cl::sycl::detail::plugin::call(), ITTSpecConstId, and piextProgramSetSpecializationConstant().

Referenced by cl::sycl::detail::ProgramManager::build(), cl::sycl::detail::ProgramManager::compile(), and cl::sycl::detail::ProgramManager::getBuiltPIProgram().

◆ event_impl::get_info< info::event::command_execution_status >()

◆ event_impl::get_info< info::event::reference_count >()

◆ event_impl::get_profiling_info< info::event_profiling::command_end >()

◆ event_impl::get_profiling_info< info::event_profiling::command_start >()

◆ event_impl::get_profiling_info< info::event_profiling::command_submit >()

◆ filterDeviceFilter()

◆ find_device_intersection()

std::vector< sycl::device > cl::sycl::detail::find_device_intersection ( const std::vector< kernel_bundle< bundle_state::object >> &  ObjectBundles)

Definition at line 247 of file kernel_bundle.cpp.

References cl::sycl::device::get_devices().

◆ float2Half()

__SYCL_CONSTEXPR_HALF uint16_t cl::sycl::detail::float2Half ( const float &  Val)
inline

Definition at line 40 of file half_type.hpp.

References __builtin_expect.

◆ floatingPointToDecStr()

template<typename T >
EnableIfFP<T, unsigned> cl::sycl::detail::floatingPointToDecStr ( T  AbsVal,
char Digits,
int  Precision,
bool  IsSci 
)

Definition at line 264 of file stream.hpp.

References cl::sycl::abs(), digitToChar(), MAX_FLOATING_POINT_DIGITS, and P.

Referenced by ScalarToStr().

◆ flushBuffer()

void cl::sycl::detail::flushBuffer ( GlobalOffsetAccessorT GlobalOffset,
GlobalBufAccessorT GlobalBuf,
GlobalBufAccessorT GlobalFlushBuf,
unsigned  WIOffset 
)
inline

◆ for_each()

template<typename Group , typename Ptr , class Function >
Function cl::sycl::detail::for_each ( Group  g,
Ptr  first,
Ptr  last,
Function  f 
)

Definition at l