DPC++ Runtime
Runtime libraries for oneAPI DPC++
sycl::_V1::ext::oneapi::experimental Namespace Reference

Namespaces

 cplx
 
 cuda
 
 default_sorters
 
 detail
 
 info
 
 matrix
 
 native
 
 property
 
 radix_sorters
 
 simd_abi
 
 this_kernel
 
 this_work_item
 

Classes

class  group_with_scratchpad
 
struct  is_fixed_topology_group
 
class  root_group
 
struct  is_fixed_topology_group< root_group< Dimensions > >
 
struct  is_fixed_topology_group< sycl::group< Dimensions > >
 
struct  is_fixed_topology_group< sycl::ext::oneapi::sub_group >
 
struct  is_fixed_topology_group< sycl::sub_group >
 
struct  is_user_constructed_group
 
struct  property_value< sycl::ext::intel::esimd::cache_hint_L1_key, std::integral_constant< sycl::ext::intel::esimd::cache_hint, Hint > >
 
struct  property_value< sycl::ext::intel::esimd::cache_hint_L2_key, std::integral_constant< sycl::ext::intel::esimd::cache_hint, Hint > >
 
struct  property_value< sycl::ext::intel::esimd::cache_hint_L3_key, std::integral_constant< sycl::ext::intel::esimd::cache_hint, Hint > >
 
struct  is_property_list< sycl::ext::intel::esimd::properties< std::tuple< PropertyValueTs... > > >
 
class  annotated_ptr
 
struct  is_property_key_of< intel::experimental::read_hint_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::read_assertion_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::write_hint_key, annotated_ptr< T, PropertyListT > >
 
struct  propagateToPtrAnnotation< intel::experimental::read_hint_key >
 
struct  propagateToPtrAnnotation< intel::experimental::read_assertion_key >
 
struct  propagateToPtrAnnotation< intel::experimental::write_hint_key >
 
struct  is_valid_property< T, intel::experimental::read_hint_key::value_t< Cs... > >
 
struct  is_valid_property< T, intel::experimental::read_assertion_key::value_t< Cs... > >
 
struct  is_valid_property< T, intel::experimental::write_hint_key::value_t< Cs... > >
 
struct  is_property_key_of< intel::experimental::fp_control_key, intel::experimental::kernel_attribute< T, PropertyListT > >
 
class  annotated_arg
 
struct  is_property_key_of< register_map_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< conduit_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< stable_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< buffer_location_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< awidth_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< dwidth_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< latency_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< read_write_mode_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< maxburst_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< wait_request_key, annotated_arg< T, PropertyListT > >
 
struct  is_property_key_of< register_map_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< conduit_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< stable_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< buffer_location_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< awidth_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< dwidth_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< latency_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< read_write_mode_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< maxburst_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< wait_request_key, annotated_ptr< T, PropertyListT > >
 
struct  is_valid_property< T, buffer_location_key::value_t< N > >
 
struct  is_valid_property< T, awidth_key::value_t< W > >
 
struct  is_valid_property< T, dwidth_key::value_t< W > >
 
struct  is_valid_property< T, latency_key::value_t< N > >
 
struct  is_valid_property< T, read_write_mode_key::value_t< Mode > >
 
struct  is_valid_property< T, maxburst_key::value_t< N > >
 
struct  is_valid_property< T, wait_request_key::value_t< Enable > >
 
struct  is_valid_property< T, register_map_key::value_t >
 
struct  is_valid_property< T, conduit_key::value_t >
 
struct  is_valid_property< T, stable_key::value_t >
 
struct  propagateToPtrAnnotation< buffer_location_key >
 
struct  is_property_key_of< intel::experimental::streaming_interface_key, intel::experimental::fpga_kernel_attribute< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::register_map_interface_key, intel::experimental::fpga_kernel_attribute< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::pipelined_key, intel::experimental::fpga_kernel_attribute< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::fpga_cluster_key, intel::experimental::fpga_kernel_attribute< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::pipelined_key, intel::experimental::task_sequence< f, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::fpga_cluster_key, intel::experimental::task_sequence< f, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::resource_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::num_banks_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::stride_size_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::word_size_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::bi_directional_ports_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::clock_2x_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::ram_stitching_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::max_private_copies_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::num_replicates_key, intel::experimental::fpga_mem< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::cache_config_key, intel::experimental::gpu_kernel_attribute< T, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::balanced_key, intel::experimental::task_sequence< f, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::invocation_capacity_key, intel::experimental::task_sequence< f, PropertyListT > >
 
struct  is_property_key_of< intel::experimental::response_capacity_key, intel::experimental::task_sequence< f, PropertyListT > >
 
struct  unsampled_image_handle
 Opaque unsampled image handle type. More...
 
struct  sampled_image_handle
 Opaque sampled image handle type. More...
 
struct  image_descriptor
 A struct to describe the properties of an image. More...
 
struct  interop_mem_handle
 Opaque interop memory handle type. More...
 
struct  interop_semaphore_handle
 Opaque interop semaphore handle type. More...
 
struct  resource_fd
 
struct  resource_win32_handle
 
struct  resource_win32_name
 
struct  external_mem_descriptor
 Opaque external memory descriptor type. More...
 
struct  external_semaphore_descriptor
 
struct  external_mem_fd
 EVERYTHING BELOW IS DEPRECATED. More...
 
struct  external_mem_win32
 Windows external memory type. More...
 
struct  external_semaphore_fd
 External semaphore file descriptor type. More...
 
struct  image_mem_handle
 Opaque image memory handle type. More...
 
class  image_mem
 A class that represents image memory. More...
 
struct  bindless_image_sampler
 
class  device_global
 
class  device_global< T, detail::properties_t< Props... > >
 
struct  device_image_scope_key
 
struct  host_access_key
 
struct  init_mode_key
 
struct  implement_in_csr_key
 
struct  is_property_key_of< device_image_scope_key, device_global< T, PropertyListT > >
 
struct  is_property_key_of< host_access_key, device_global< T, PropertyListT > >
 
struct  is_property_key_of< init_mode_key, device_global< T, PropertyListT > >
 
struct  is_property_key_of< implement_in_csr_key, device_global< T, PropertyListT > >
 
class  annotated_ref
 
struct  annotationHelper
 
struct  annotationHelper< I, detail::properties_t< P... > >
 
class  annotated_ref< T, detail::properties_t< Props... > >
 
struct  usm_kind_key
 
struct  is_valid_property< T, usm_kind_key::value_t< Kind > >
 
struct  is_property_key_of< usm_kind_key, annotated_ptr< T, PropertyListT > >
 
class  ballot_group
 
struct  is_user_constructed_group< ballot_group< ParentGroup > >
 
struct  is_valid_property
 
struct  check_property_list
 
struct  check_property_list< T, Prop, Props... >
 
struct  propagateToPtrAnnotation
 
struct  propagateToPtrAnnotation< property_value< PropKeyT, PropValuesTs... > >
 
struct  alignment_key
 
struct  is_valid_property< T, alignment_key::value_t< W > >
 
struct  is_property_key_of< alignment_key, annotated_ptr< T, PropertyListT > >
 
struct  is_property_key_of< alignment_key, annotated_arg< T, PropertyListT > >
 
struct  propagateToPtrAnnotation< alignment_key >
 
struct  is_genfloat
 FORWARD DECLARATIONS. More...
 
class  complex
 
struct  is_gencomplex
 
class  complex< _Tp, typename std::enable_if_t< is_genfloat< _Tp >::value > >
 
class  launch_config
 
class  fixed_size_group
 
struct  is_user_constructed_group< fixed_size_group< PartitionSize, ParentGroup > >
 
class  command_graph
 Graph in the modifiable state. More...
 
class  node
 Class representing a node in the graph, returned by command_graph::add(). More...
 
class  command_graph< graph_state::executable >
 
class  dynamic_parameter
 
class  default_sorter
 
class  radix_sorter
 
struct  data_placement_key
 
struct  contiguous_memory_key
 
struct  full_group_key
 
class  tangle_group
 
class  opportunistic_group
 
struct  is_user_constructed_group< opportunistic_group >
 
struct  prefetch_hint_key
 
struct  is_user_constructed_group< tangle_group< ParentGroup > >
 
class  uniform
 
struct  use_root_sync_key
 
struct  indirectly_callable_key
 
struct  calls_indirectly_key
 
struct  is_property_key< indirectly_callable_key >
 
struct  is_property_key< calls_indirectly_key >
 
struct  properties_tag
 
struct  work_group_size_key
 
struct  work_group_size_hint_key
 
struct  sub_group_size_key
 
struct  device_has_key
 
struct  nd_range_kernel_key
 
struct  single_task_kernel_key
 
struct  property_value< work_group_size_key, std::integral_constant< size_t, Dim0 >, std::integral_constant< size_t, Dims >... >
 
struct  property_value< work_group_size_hint_key, std::integral_constant< size_t, Dim0 >, std::integral_constant< size_t, Dims >... >
 
struct  property_value< sub_group_size_key, std::integral_constant< uint32_t, Size > >
 
struct  property_value< device_has_key, std::integral_constant< aspect, Aspects >... >
 
struct  property_value< nd_range_kernel_key, std::integral_constant< int, Dims > >
 
struct  property_value< single_task_kernel_key >
 
struct  work_group_progress_key
 
struct  sub_group_progress_key
 
struct  work_item_progress_key
 
struct  property_value< work_group_progress_key, std::integral_constant< forward_progress_guarantee, Guarantee >, std::integral_constant< execution_scope, CoordinationScope > >
 
struct  property_value< sub_group_progress_key, std::integral_constant< forward_progress_guarantee, Guarantee >, std::integral_constant< execution_scope, CoordinationScope > >
 
struct  property_value< work_item_progress_key, std::integral_constant< forward_progress_guarantee, Guarantee >, std::integral_constant< execution_scope, CoordinationScope > >
 
struct  is_property_key< work_group_progress_key >
 
struct  is_property_key< sub_group_progress_key >
 
struct  is_property_key< work_item_progress_key >
 
struct  property_value< intel::experimental::latency_constraint_key, std::integral_constant< int, Target >, std::integral_constant< intel::experimental::latency_control_type, Type >, std::integral_constant< int, Cycle > >
 
class  properties
 
struct  is_property_list
 
struct  is_property_list< properties< std::tuple< PropertyValueTs... > > >
 
struct  is_property_key
 
struct  is_property_key_of
 
struct  property_value
 
struct  is_property_value
 
struct  is_property_value_of
 
struct  is_property_value< V, std::void_t< typename V::key_t > >
 
struct  is_property_value_of< V, O, std::void_t< typename V::key_t > >
 
struct  build_options
 
struct  is_property_key_of< build_options_key, sycl::kernel_bundle< bundle_state::ext_oneapi_source > >
 
struct  save_log
 
struct  is_property_key_of< save_log_key, sycl::kernel_bundle< bundle_state::ext_oneapi_source > >
 
struct  cl_version
 

Typedefs

using register_map_key = intel::experimental::register_map_key
 
using conduit_key = intel::experimental::conduit_key
 
using stable_key = intel::experimental::stable_key
 
using buffer_location_key = intel::experimental::buffer_location_key
 
using awidth_key = intel::experimental::awidth_key
 
using dwidth_key = intel::experimental::dwidth_key
 
using latency_key = intel::experimental::latency_key
 
using read_write_mode_key = intel::experimental::read_write_mode_key
 
using maxburst_key = intel::experimental::maxburst_key
 
using wait_request_key = intel::experimental::wait_request_key
 
using read_write_mode_enum = intel::experimental::read_write_mode_enum
 
using global_pointer_t = typename decorated_global_ptr< T >::pointer
 
using UnderlyingT = T
 
using property_list_t = detail::properties_t< Props... >
 
using reference = sycl::ext::oneapi::experimental::annotated_ref< T, property_list_t >
 
template<typename T , typename ListA , typename ListB >
using CheckDevicePtrTAndPropLists = typename detail::CheckTAndPropListsWithUsmKind< sycl::usm::alloc::device, T, ListA, ListB >
 
template<typename PropertyListT >
using GetAnnotatedDevicePtrProperties = detail::GetAnnotatedPtrPropertiesWithUsmKind< sycl::usm::alloc::device, PropertyListT >
 
template<typename T , typename ListA , typename ListB >
using CheckHostPtrTAndPropLists = typename detail::CheckTAndPropListsWithUsmKind< sycl::usm::alloc::host, T, ListA, ListB >
 
template<typename PropertyListT >
using GetAnnotatedHostPtrProperties = detail::GetAnnotatedPtrPropertiesWithUsmKind< sycl::usm::alloc::host, PropertyListT >
 
template<typename T , typename ListA , typename ListB >
using CheckSharedPtrTAndPropLists = typename detail::CheckTAndPropListsWithUsmKind< sycl::usm::alloc::shared, T, ListA, ListB >
 
template<typename PropertyListT >
using GetAnnotatedSharedPtrProperties = detail::GetAnnotatedPtrPropertiesWithUsmKind< sycl::usm::alloc::shared, PropertyListT >
 
template<class T , int N>
using simd = std::experimental::simd< T, simd_abi::native_fixed_size< T, N > >
 
template<class T , int N>
using simd_mask = std::experimental::simd_mask< T, simd_abi::native_fixed_size< T, N > >
 
using empty_properties_t = properties< std::tuple<> >
 
using build_options_key = build_options
 
using save_log_key = save_log
 
using source_kb = kernel_bundle< sycl::bundle_state::ext_oneapi_source >
 
using exe_kb = kernel_bundle< bundle_state::executable >
 
using kernel_bundle_impl = sycl::detail::kernel_bundle_impl
 

Enumerations

enum class  image_type : unsigned int { standard = 0 , mipmap = 1 , array = 2 , cubemap = 3 }
 image type enum More...
 
enum  image_copy_flags : unsigned int { HtoD = 0 , DtoH = 1 , DtoD = 2 }
 Direction to copy data from bindless image handle (Host -> Device) (Device -> Host) etc. More...
 
enum class  cubemap_filtering_mode : unsigned int { disjointed = PI_SAMPLER_CUBEMAP_FILTER_MODE_DISJOINTED , seamless = PI_SAMPLER_CUBEMAP_FILTER_MODE_SEAMLESS }
 cubemap filtering mode enum More...
 
enum class  host_access_enum : std::uint16_t { read , write , read_write , none }
 
enum class  init_mode_enum : std::uint16_t { reprogram , reset }
 
enum class  architecture : uint64_t {
  x86_64 = 0x9900000000000000 , intel_cpu_spr = 0x0300000000000800 , intel_cpu_gnr = 0x0300000000000900 , intel_gpu_bdw ,
  intel_gpu_skl , intel_gpu_kbl = 0x0000000240400900 , intel_gpu_cfl = 0x0000000240800900 , intel_gpu_apl = 0x0000000240c00000 ,
  intel_gpu_bxt = intel_gpu_apl , intel_gpu_glk = 0x0000000241000000 , intel_gpu_whl = 0x0000000241400000 , intel_gpu_aml = 0x0000000241800000 ,
  intel_gpu_cml = 0x0000000241c00000 , intel_gpu_icllp = 0x00000002c0000000 , intel_gpu_icl = intel_gpu_icllp , intel_gpu_ehl = 0x00000002c0800000 ,
  intel_gpu_jsl = intel_gpu_ehl , intel_gpu_tgllp = 0x0000000300000000 , intel_gpu_tgl = intel_gpu_tgllp , intel_gpu_rkl = 0x0000000300400000 ,
  intel_gpu_adl_s = 0x0000000300800000 , intel_gpu_rpl_s = intel_gpu_adl_s , intel_gpu_adl_p = 0x0000000300c00000 , intel_gpu_adl_n = 0x0000000301000000 ,
  intel_gpu_dg1 = 0x0000000302800000 , intel_gpu_acm_g10 = 0x000000030dc00800 , intel_gpu_dg2_g10 = intel_gpu_acm_g10 , intel_gpu_acm_g11 = 0x000000030e000500 ,
  intel_gpu_dg2_g11 = intel_gpu_acm_g11 , intel_gpu_acm_g12 = 0x000000030e400000 , intel_gpu_dg2_g12 = intel_gpu_acm_g12 , intel_gpu_pvc = 0x000000030f000700 ,
  intel_gpu_pvc_vg = 0x000000030f400700 , intel_gpu_mtl_u = 0x0000000311800400 , intel_gpu_mtl_s = intel_gpu_mtl_u , intel_gpu_arl_u = intel_gpu_mtl_u ,
  intel_gpu_arl_s = intel_gpu_mtl_u , intel_gpu_mtl_h = 0x0000000311c00400 , intel_gpu_arl_h = 0x0000000312800400 , intel_gpu_bmg_g21 = 0x0000000500400400 ,
  intel_gpu_lnl_m = 0x0000000501000400 , nvidia_gpu_sm_50 = 0x0100000000005000 , nvidia_gpu_sm_52 = 0x0100000000005200 , nvidia_gpu_sm_53 = 0x0100000000005300 ,
  nvidia_gpu_sm_60 = 0x0100000000006000 , nvidia_gpu_sm_61 = 0x0100000000006100 , nvidia_gpu_sm_62 = 0x0100000000006200 , nvidia_gpu_sm_70 = 0x0100000000007000 ,
  nvidia_gpu_sm_72 = 0x0100000000007200 , nvidia_gpu_sm_75 = 0x0100000000007500 , nvidia_gpu_sm_80 = 0x0100000000008000 , nvidia_gpu_sm_86 = 0x0100000000008600 ,
  nvidia_gpu_sm_87 = 0x0100000000008700 , nvidia_gpu_sm_89 = 0x0100000000008900 , nvidia_gpu_sm_90 = 0x0100000000009000 , nvidia_gpu_sm_90a = 0x01000000000090a0 ,
  amd_gpu_gfx700 = 0x0200000000070000 , amd_gpu_gfx701 = 0x0200000000070100 , amd_gpu_gfx702 = 0x0200000000070200 , amd_gpu_gfx801 = 0x0200000000080100 ,
  amd_gpu_gfx802 = 0x0200000000080200 , amd_gpu_gfx803 = 0x0200000000080300 , amd_gpu_gfx805 = 0x0200000000080500 , amd_gpu_gfx810 = 0x0200000000081000 ,
  amd_gpu_gfx900 = 0x0200000000090000 , amd_gpu_gfx902 = 0x0200000000090200 , amd_gpu_gfx904 = 0x0200000000090400 , amd_gpu_gfx906 = 0x0200000000090600 ,
  amd_gpu_gfx908 = 0x0200000000090800 , amd_gpu_gfx909 = 0x0200000000090900 , amd_gpu_gfx90a = 0x0200000000090a00 , amd_gpu_gfx90c = 0x0200000000090c00 ,
  amd_gpu_gfx940 = 0x0200000000094000 , amd_gpu_gfx941 = 0x0200000000094100 , amd_gpu_gfx942 = 0x0200000000094200 , amd_gpu_gfx1010 = 0x0200000000101000 ,
  amd_gpu_gfx1011 = 0x0200000000101100 , amd_gpu_gfx1012 = 0x0200000000101200 , amd_gpu_gfx1013 = 0x0200000000101300 , amd_gpu_gfx1030 = 0x0200000000103000 ,
  amd_gpu_gfx1031 = 0x0200000000103100 , amd_gpu_gfx1032 = 0x0200000000103200 , amd_gpu_gfx1033 = 0x0200000000103300 , amd_gpu_gfx1034 = 0x0200000000103400 ,
  amd_gpu_gfx1035 = 0x0200000000103500 , amd_gpu_gfx1036 = 0x0200000000103600 , amd_gpu_gfx1100 = 0x0200000000110000 , amd_gpu_gfx1101 = 0x0200000000110100 ,
  amd_gpu_gfx1102 = 0x0200000000110200 , amd_gpu_gfx1103 = 0x0200000000110300 , amd_gpu_gfx1150 = 0x0200000000115000 , amd_gpu_gfx1151 = 0x0200000000115100 ,
  amd_gpu_gfx1200 = 0x0200000000120000 , amd_gpu_gfx1201 = 0x0200000000120100 , intel_gpu_8_0_0 = intel_gpu_bdw , intel_gpu_9_0_9 = intel_gpu_skl ,
  intel_gpu_9_1_9 = intel_gpu_kbl , intel_gpu_9_2_9 = intel_gpu_cfl , intel_gpu_9_3_0 = intel_gpu_apl , intel_gpu_9_4_0 = intel_gpu_glk ,
  intel_gpu_9_5_0 = intel_gpu_whl , intel_gpu_9_6_0 = intel_gpu_aml , intel_gpu_9_7_0 = intel_gpu_cml , intel_gpu_11_0_0 = intel_gpu_icllp ,
  intel_gpu_11_2_0 = intel_gpu_ehl , intel_gpu_12_0_0 = intel_gpu_tgllp , intel_gpu_12_1_0 = intel_gpu_rkl , intel_gpu_12_2_0 = intel_gpu_adl_s ,
  intel_gpu_12_3_0 = intel_gpu_adl_p , intel_gpu_12_4_0 = intel_gpu_adl_n , intel_gpu_12_10_0 = intel_gpu_dg1 , intel_gpu_12_55_8 = intel_gpu_acm_g10 ,
  intel_gpu_12_56_5 = intel_gpu_acm_g11 , intel_gpu_12_57_0 = intel_gpu_acm_g12 , intel_gpu_12_60_7 = intel_gpu_pvc , intel_gpu_12_61_7 = intel_gpu_pvc_vg ,
  intel_gpu_12_70_4 = intel_gpu_mtl_u , intel_gpu_12_71_4 = intel_gpu_mtl_h , intel_gpu_12_74_4 = intel_gpu_arl_h , intel_gpu_20_1_4 = intel_gpu_bmg_g21 ,
  intel_gpu_20_4_4 = intel_gpu_lnl_m
}
 
enum class  arch_category { intel_gpu = 0 , nvidia_gpu = 1 , amd_gpu = 2 }
 
enum class  forward_progress_guarantee { concurrent , parallel , weakly_parallel }
 
enum class  execution_scope { work_item , sub_group , work_group , root_group }
 
enum class  graph_state { modifiable , executable }
 State to template the command_graph class on. More...
 
enum class  node_type {
  empty = 0 , subgraph = 1 , kernel = 2 , memcpy = 3 ,
  memset = 4 , memfill = 5 , prefetch = 6 , memadvise = 7 ,
  ext_oneapi_barrier = 8 , host_task = 9
}
 
enum class  sorting_order { ascending , descending }
 
enum class  data_placement_enum { blocked , striped }
 
enum class  cache_level { L1 = 0 , L2 = 1 , L3 = 2 , L4 = 3 }
 
enum class  source_language : int { opencl = 0 , spirv = 1 }
 

Functions

image_mem_handle alloc_image_mem (const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Allocate image memory based on image_descriptor. More...
 
image_mem_handle alloc_image_mem (const image_descriptor &desc, const sycl::queue &syclQueue)
 Allocate image memory based on image_descriptor. More...
 
void free_image_mem (image_mem_handle handle, const sycl::device &syclDevice, const sycl::context &syclContext)
 [Deprecated] Free image memory More...
 
void free_image_mem (image_mem_handle handle, const sycl::queue &syclQueue)
 [Deprecated] Free image memory More...
 
void free_image_mem (image_mem_handle handle, image_type imageType, const sycl::device &syclDevice, const sycl::context &syclContext)
 Free image memory. More...
 
void free_image_mem (image_mem_handle handle, image_type imageType, const sycl::queue &syclQueue)
 Free image memory. More...
 
image_mem_handle alloc_mipmap_mem (const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 [Deprecated] Allocate mipmap memory based on image_descriptor More...
 
image_mem_handle alloc_mipmap_mem (const image_descriptor &desc, const sycl::device &syclQueue)
 [Deprecated] Allocate mipmap memory based on image_descriptor More...
 
void free_mipmap_mem (image_mem_handle handle, const sycl::device &syclDevice, const sycl::context &syclContext)
 [Deprecated] Free mipmap memory More...
 
void free_mipmap_mem (image_mem_handle handle, const sycl::queue &syclQueue)
 [Deprecated] Free mipmap memory More...
 
image_mem_handle get_mip_level_mem_handle (const image_mem_handle mipMem, const unsigned int level, const sycl::device &syclDevice, const sycl::context &syclContext)
 Retrieve the memory handle to an individual mipmap image. More...
 
image_mem_handle get_mip_level_mem_handle (const image_mem_handle mipMem, const unsigned int level, const sycl::queue &syclQueue)
 Retrieve the memory handle to an individual mipmap image. More...
 
template<typename ExternalMemHandleType >
interop_mem_handle import_external_memory (external_mem_descriptor< ExternalMemHandleType > externalMem, const sycl::device &syclDevice, const sycl::context &syclContext)
 Import external memory taking an external memory handle (the type of which is dependent on the OS & external API) and return an interop memory handle. More...
 
template<typename ExternalMemHandleType >
interop_mem_handle import_external_memory (external_mem_descriptor< ExternalMemHandleType > externalMem, const sycl::queue &syclQueue)
 Import external memory taking an external memory handle (the type of which is dependent on the OS & external API) and return an interop memory handle. More...
 
image_mem_handle map_external_memory_array (interop_mem_handle memHandle, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 [Deprecated] Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout) More...
 
image_mem_handle map_external_memory_array (interop_mem_handle memHandle, const image_descriptor &desc, const sycl::queue &syclQueue)
 [Deprecated] Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout) More...
 
image_mem_handle map_external_image_memory (interop_mem_handle memHandle, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout) More...
 
image_mem_handle map_external_image_memory (interop_mem_handle memHandle, const image_descriptor &desc, const sycl::queue &syclQueue)
 Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout) More...
 
template<typename ExternalSemaphoreHandleType >
interop_semaphore_handle import_external_semaphore (external_semaphore_descriptor< ExternalSemaphoreHandleType > externalSemaphoreDesc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Import external semaphore taking an external semaphore handle (the type of which is dependent on the OS & external API) More...
 
template<typename ExternalSemaphoreHandleType >
interop_semaphore_handle import_external_semaphore (external_semaphore_descriptor< ExternalSemaphoreHandleType > externalSemaphoreDesc, const sycl::queue &syclQueue)
 Import external semaphore taking an external semaphore handle (the type of which is dependent on the OS & external API) More...
 
void destroy_external_semaphore (interop_semaphore_handle semaphoreHandle, const sycl::device &syclDevice, const sycl::context &syclContext)
 Destroy the external semaphore handle. More...
 
void destroy_external_semaphore (interop_semaphore_handle semaphoreHandle, const sycl::queue &syclQueue)
 Destroy the external semaphore handle. More...
 
void release_external_memory (interop_mem_handle interopHandle, const sycl::device &syclDevice, const sycl::context &syclContext)
 Release external memory. More...
 
void release_external_memory (interop_mem_handle interopHandle, const sycl::queue &syclQueue)
 Release external memory. More...
 
unsampled_image_handle create_image (image_mem &memHandle, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Create an image and return the device image handle. More...
 
unsampled_image_handle create_image (image_mem &memHandle, const image_descriptor &desc, const sycl::queue &syclQueue)
 Create an image and return the device image handle. More...
 
unsampled_image_handle create_image (image_mem_handle memHandle, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Create an image and return the device image handle. More...
 
unsampled_image_handle create_image (image_mem_handle memHandle, const image_descriptor &desc, const sycl::queue &syclQueue)
 Create an image and return the device image handle. More...
 
sampled_image_handle create_image (void *imgMem, size_t pitch, const bindless_image_sampler &sampler, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Create a sampled image and return the device image handle. More...
 
sampled_image_handle create_image (void *imgMem, size_t pitch, const bindless_image_sampler &sampler, const image_descriptor &desc, const sycl::queue &syclQueue)
 Create a sampled image and return the device image handle. More...
 
sampled_image_handle create_image (image_mem &memHandle, const bindless_image_sampler &sampler, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Create a sampled image and return the device image handle. More...
 
sampled_image_handle create_image (image_mem &memHandle, const bindless_image_sampler &sampler, const image_descriptor &desc, const sycl::queue &syclQueue)
 Create a sampled image and return the device image handle. More...
 
sampled_image_handle create_image (image_mem_handle memHandle, const bindless_image_sampler &sampler, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Create a sampled image and return the device image handle. More...
 
sampled_image_handle create_image (image_mem_handle memHandle, const bindless_image_sampler &sampler, const image_descriptor &desc, const sycl::queue &syclQueue)
 Create a sampled image and return the device image handle. More...
 
void destroy_image_handle (unsampled_image_handle &imageHandle, const sycl::device &syclDevice, const sycl::context &syclContext)
 Destroy an unsampled image handle. More...
 
void destroy_image_handle (unsampled_image_handle &imageHandle, const sycl::queue &syclQueue)
 Destroy an unsampled image handle. More...
 
void destroy_image_handle (sampled_image_handle &imageHandle, const sycl::device &syclDevice, const sycl::context &syclContext)
 Destroy a sampled image handle. More...
 
void destroy_image_handle (sampled_image_handle &imageHandle, const sycl::queue &syclQueue)
 Destroy a sampled image handle. More...
 
void * pitched_alloc_device (size_t *resultPitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes, const sycl::queue &syclQueue)
 Allocate pitched USM image memory. More...
 
void * pitched_alloc_device (size_t *resultPitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes, const sycl::device &syclDevice, const sycl::context &syclContext)
 Allocate pitched USM image memory. More...
 
void * pitched_alloc_device (size_t *resultPitch, const image_descriptor &desc, const sycl::queue &syclQueue)
 Allocate pitched USM image memory. More...
 
void * pitched_alloc_device (size_t *resultPitch, const image_descriptor &desc, const sycl::device &syclDevice, const sycl::context &syclContext)
 Allocate pitched USM image memory. More...
 
sycl::range< 3 > get_image_range (const image_mem_handle memHandle, const sycl::device &syclDevice, const sycl::context &syclContext)
 Get the range that describes the image's dimensions. More...
 
sycl::range< 3 > get_image_range (const image_mem_handle memHandle, const sycl::queue &syclQueue)
 Get the range that describes the image's dimensions. More...
 
sycl::image_channel_type get_image_channel_type (const image_mem_handle memHandle, const sycl::device &syclDevice, const sycl::context &syclContext)
 Get the channel type that describes the image memory. More...
 
sycl::image_channel_type get_image_channel_type (const image_mem_handle memHandle, const sycl::queue &syclQueue)
 Get the channel type that describes the image memory. More...
 
unsigned int get_image_num_channels (const image_mem_handle memHandle, const sycl::device &syclDevice, const sycl::context &syclContext)
 Get the number of channels that describes the image memory. More...
 
unsigned int get_image_num_channels (const image_mem_handle memHandle, const sycl::queue &syclQueue)
 Get the number of channels that describes the image memory. More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
DataT fetch_image (const unsampled_image_handle &imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]])
 Fetch data from an unsampled image using its handle. More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
 __SYCL_DEPRECATED ("read_image for standard unsampled images is deprecated. " "Instead use fetch_image.") DataT read_image(const unsampled_image_handle &imageHandle
 [Deprecated] Read an unsampled image using its handle More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
DataT fetch_image (const sampled_image_handle &imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]])
 Fetch data from a sampled image using its handle. More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
DataT sample_image (const sampled_image_handle &imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]])
 Sample data from a sampled image using its handle. More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
 __SYCL_DEPRECATED ("read_image for standard sampled images is deprecated. " "Instead use sample_image with floating point coordinates or " "fetch_image with integer coordinates.") DataT read_image(const sampled_image_handle &imageHandle
 [Deprecated] Read a sampled image using its handle More...
 
constexpr if (detail::are_floating_coords< CoordT >())
 
else constexpr if (detail::are_integer_coords< CoordT >())
 
template<typename DataT , typename HintT = DataT, typename CoordT >
DataT sample_mipmap (const sampled_image_handle &imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]], const float level[[maybe_unused]])
 Sample a mipmap image using its handle with LOD filtering. More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
DataT sample_mipmap (const sampled_image_handle &imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]], const CoordT &dX[[maybe_unused]], const CoordT &dY[[maybe_unused]])
 Sample a mipmap image using its handle with anisotropic filtering. More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
 __SYCL_DEPRECATED ("read_mipmap has been deprecated. " "Instead use sample_mipmap.") DataT read_mipmap(const sampled_image_handle &imageHandle
 [Deprecated] Read a mipmap image using its handle with LOD filtering More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
 __SYCL_DEPRECATED ("read_image for mipmaps is deprecated. " "Instead use sample_mipmap.") DataT read_image(const sampled_image_handle &imageHandle
 [Deprecated] Read a mipmap image using its handle with LOD filtering More...
 
template<typename DataT , typename HintT = DataT, typename CoordT >
DataT fetch_image_array (const unsampled_image_handle &imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]], const int arrayLayer[[maybe_unused]])
 Fetch data from an unsampled image array using its handle. More...
 
template<typename DataT , typename HintT = DataT>
DataT fetch_cubemap (const unsampled_image_handle &imageHandle, const int2 &coords, const unsigned int face)
 Fetch data from an unsampled cubemap image using its handle. More...
 
template<typename DataT , typename HintT = DataT>
DataT sample_cubemap (const sampled_image_handle &imageHandle[[maybe_unused]], const sycl::float3 &dirVec[[maybe_unused]])
 Sample a cubemap image using its handle. More...
 
template<typename DataT , typename CoordT >
void write_image (unsampled_image_handle imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]], const DataT &color[[maybe_unused]])
 Write to an unsampled image using its handle. More...
 
template<typename DataT , typename CoordT >
void write_image_array (unsampled_image_handle imageHandle[[maybe_unused]], const CoordT &coords[[maybe_unused]], const int arrayLayer[[maybe_unused]], const DataT &color[[maybe_unused]])
 Write to an unsampled image array using its handle. More...
 
template<typename DataT >
void write_cubemap (unsampled_image_handle imageHandle, const sycl::int2 &coords, const int face, const DataT &color)
 Write to an unsampled cubemap using its handle. More...
 
template<access::address_space Space, access::decorated DecorateAddress, typename ElementType >
multi_ptr< ElementType, Space, DecorateAddress > static_address_cast (ElementType *Ptr)
 
template<access::address_space Space, access::decorated DecorateAddress, typename ElementType >
multi_ptr< ElementType, Space, DecorateAddress > dynamic_address_cast (ElementType *Ptr)
 
template<typename ElementType , auto & SizeSpecName, access::decorated DecorateAddress>
private_ptr< ElementType, DecorateAddress > private_alloca (kernel_handler &kh)
 
template<typename ElementType , std::size_t Alignment, auto & SizeSpecName, access::decorated DecorateAddress>
private_ptr< ElementType, DecorateAddress > aligned_private_alloca (kernel_handler &kh)
 
template<typename T , typename... Args>
 annotated_arg (T, Args...) -> annotated_arg< T, typename detail::DeducedProperties< Args... >::type >
 
template<typename T , typename old , typename... ArgT>
 annotated_arg (annotated_arg< T, old >, properties< std::tuple< ArgT... >>) -> annotated_arg< T, detail::merged_properties_t< old, detail::properties_t< ArgT... >>>
 
template<typename T , typename... Props>
class __SYCL_SPECIAL_CLASS __SYCL_TYPE (annotated_arg) annotated_arg< T *
 
 annotated_arg (const annotated_arg &)=default
 
annotated_argoperator= (annotated_arg &)=default
 
 annotated_arg (T *_ptr, const property_list_t &PropList=property_list_t{}) noexcept
 
template<typename... PropertyValueTs>
 annotated_arg (T *_ptr, const PropertyValueTs &...props) noexcept
 
template<typename T2 , typename PropertyList2 >
 annotated_arg (const annotated_arg< T2, PropertyList2 > &other) noexcept
 
template<typename T2 , typename PropertyListU , typename PropertyListV >
 annotated_arg (const annotated_arg< T2, PropertyListU > &other, const PropertyListV &proplist) noexcept
 
 operator T* () noexcept
 
T & operator[] (std::ptrdiff_t idx) const noexcept
 
T * operator-> () const noexcept
 
template<typename PropertyT >
static constexpr bool has_property ()
 
template<typename PropertyT >
static constexpr auto get_property ()
 
 annotated_arg (const T &_obj, const property_list_t &PropList=property_list_t{}) noexcept
 
template<typename... PropertyValueTs>
 annotated_arg (const T &_obj, PropertyValueTs... props) noexcept
 
 operator T () noexcept
 
template<typename T , typename... Props>
class __SYCL_SPECIAL_CLASS __SYCL_TYPE (annotated_ptr) annotated_ptr< T
 
 annotated_ptr (const annotated_ptr &)=default
 
annotated_ptroperator= (const annotated_ptr &)=default
 
 annotated_ptr (T *Ptr, const property_list_t &=property_list_t{}) noexcept
 
template<typename... PropertyValueTs>
 annotated_ptr (T *Ptr, const PropertyValueTs &...props) noexcept
 
template<typename T2 , typename PropertyList2 >
 annotated_ptr (const annotated_ptr< T2, PropertyList2 > &other) noexcept
 
template<typename T2 , typename PropertyListU , typename PropertyListV >
 annotated_ptr (const annotated_ptr< T2, PropertyListU > &other, const PropertyListV &) noexcept
 
reference operator* () const noexcept
 
std::ptrdiff_t operator- (annotated_ptr other) const noexcept
 
 operator bool () const noexcept
 
T * get () const noexcept
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<!has_alignment>>
annotated_ptr operator+ (size_t offset) const noexcept
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<has_alignment>>
auto operator+ (size_t offset) const noexcept -> decltype("operator+ is not available when alignment is specified!")=delete
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<!has_alignment>>
annotated_ptroperator++ () noexcept
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<has_alignment>>
auto operator++ () noexcept -> decltype("operator++ is not available when alignment is specified!")=delete
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<!has_alignment>>
annotated_ptr operator++ (int) noexcept
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<has_alignment>>
auto operator++ (int) noexcept -> decltype("operator++ is not available when alignment is specified!")=delete
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<!has_alignment>>
annotated_ptroperator-- () noexcept
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<has_alignment>>
auto operator-- () noexcept -> decltype("operator-- is not available when alignment is specified!")=delete
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<!has_alignment>>
annotated_ptr operator-- (int) noexcept
 
template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<has_alignment>>
auto operator-- (int) noexcept -> decltype("operator-- is not available when alignment is specified!")=delete
 
template<typename PropertyT >
static constexpr bool has_property ()
 
template<typename PropertyT >
static constexpr auto get_property ()
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_annotated (size_t alignment, size_t numBytes, const device &syclDevice, const context &syclContext, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_annotated (size_t alignment, size_t count, const device &syclDevice, const context &syclContext, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_annotated (size_t alignment, size_t numBytes, const queue &syclQueue, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_annotated (size_t alignment, size_t count, const queue &syclQueue, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_annotated (size_t numBytes, const device &syclDevice, const context &syclContext, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_annotated (size_t count, const device &syclDevice, const context &syclContext, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_annotated (size_t numBytes, const queue &syclQueue, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_annotated (size_t count, const queue &syclQueue, sycl::usm::alloc kind, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_annotated (size_t numBytes, const device &syclDevice, const context &syclContext, const propertyListA &propList)
 
template<typename T , typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_annotated (size_t count, const device &syclDevice, const context &syclContext, const propertyListA &propList)
 
template<typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_annotated (size_t numBytes, const queue &syclQueue, const propertyListA &propList)
 
template<typename T , typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_annotated (size_t count, const queue &syclQueue, const propertyListA &propList)
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_device_annotated (size_t alignment, size_t numBytes, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_device_annotated (size_t alignment, size_t count, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_device_annotated (size_t alignment, size_t numBytes, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_device_annotated (size_t alignment, size_t count, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_device_annotated (size_t numBytes, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_device_annotated (size_t count, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_device_annotated (size_t numBytes, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_device_annotated (size_t count, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_host_annotated (size_t alignment, size_t numBytes, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_host_annotated (size_t alignment, size_t count, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_host_annotated (size_t alignment, size_t numBytes, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_host_annotated (size_t alignment, size_t count, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_host_annotated (size_t numBytes, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_host_annotated (size_t count, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_host_annotated (size_t numBytes, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_host_annotated (size_t count, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_shared_annotated (size_t alignment, size_t numBytes, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_shared_annotated (size_t alignment, size_t count, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > aligned_alloc_shared_annotated (size_t alignment, size_t numBytes, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > aligned_alloc_shared_annotated (size_t alignment, size_t count, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_shared_annotated (size_t numBytes, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_shared_annotated (size_t count, const device &syclDevice, const context &syclContext, const propertyListA &propList=propertyListA{})
 
template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< void, propertyListA, propertyListB >::value, annotated_ptr< void, propertyListB > > malloc_shared_annotated (size_t numBytes, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists< T, propertyListA, propertyListB >::value, annotated_ptr< T, propertyListB > > malloc_shared_annotated (size_t count, const queue &syclQueue, const propertyListA &propList=propertyListA{})
 
template<typename PropertyListT >
property_list get_usm_property_list ()
 
size_t combine_align (size_t alignA, size_t alignB)
 
template<typename T , typename propList >
void free (annotated_ptr< T, propList > &ptr, const context &syclContext)
 
template<typename T , typename propList >
void free (annotated_ptr< T, propList > &ptr, const queue &syclQueue)
 
template<int Dimensions>
static range< Dimensionsauto_range ()
 
template<typename Group >
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&std::is_same_v< Group, sycl::sub_group >, ballot_group< Group > > get_ballot_group (Group group, bool predicate)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, bfloat16 >, bool > isnan (T x)
 
template<size_t N>
sycl::marray< bool, N > isnan (sycl::marray< bfloat16, N > x)
 
template<typename T , int N = num_elements_v<T>>
std::enable_if_t< is_vec_or_swizzle_bf16_v< T >, sycl::vec< int16_t, N > > isnan (T x)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, bfloat16 >, T > fabs (T x)
 
template<size_t N>
sycl::marray< bfloat16, N > fabs (sycl::marray< bfloat16, N > x)
 
template<typename T , int N = num_elements_v<T>>
std::enable_if_t< is_vec_or_swizzle_bf16_v< T >, sycl::vec< bfloat16, N > > fabs (T x)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, bfloat16 >, T > fmin (T x, T y)
 
template<size_t N>
sycl::marray< bfloat16, N > fmin (sycl::marray< bfloat16, N > x, sycl::marray< bfloat16, N > y)
 
template<typename T1 , typename T2 , int N1 = num_elements_v<T1>, int N2 = num_elements_v<T2>>
std::enable_if_t< is_vec_or_swizzle_bf16_v< T1 > &&is_vec_or_swizzle_bf16_v< T2 > &&N1==N2, sycl::vec< bfloat16, N1 > > fmin (T1 x, T2 y)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, bfloat16 >, T > fmax (T x, T y)
 
template<size_t N>
sycl::marray< bfloat16, N > fmax (sycl::marray< bfloat16, N > x, sycl::marray< bfloat16, N > y)
 
template<typename T1 , typename T2 , int N1 = num_elements_v<T1>, int N2 = num_elements_v<T2>>
std::enable_if_t< is_vec_or_swizzle_bf16_v< T1 > &&is_vec_or_swizzle_bf16_v< T2 > &&N1==N2, sycl::vec< bfloat16, N1 > > fmax (T1 x, T2 y)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, bfloat16 >, T > fma (T x, T y, T z)
 
template<size_t N>
sycl::marray< bfloat16, N > fma (sycl::marray< bfloat16, N > x, sycl::marray< bfloat16, N > y, sycl::marray< bfloat16, N > z)
 
template<typename T1 , typename T2 , typename T3 , int N1 = num_elements_v<T1>, int N2 = num_elements_v<T2>, int N3 = num_elements_v<T3>>
std::enable_if_t< is_vec_or_swizzle_bf16_v< T1 > &&is_vec_or_swizzle_bf16_v< T2 > &&is_vec_or_swizzle_bf16_v< T3 > &&N1==N2 &&N2==N3, sycl::vec< bfloat16, N1 > > fma (T1 x, T2 y, T3 z)
 
template<typename FormatT , typename... Args>
int printf (const FormatT *__format, Args... args)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, _Tp > abs (const complex< _Tp > &__c)
 FUNCTIONS. More...
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, _Tp > arg (const complex< _Tp > &__c)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits< _Tp >::_ValueType arg (_Tp __re)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, _Tp > norm (const complex< _Tp > &__c)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits< _Tp >::_ValueType norm (_Tp __re)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > conj (const complex< _Tp > &__c)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits< _Tp >::_ComplexType conj (_Tp __re)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > proj (const complex< _Tp > &__c)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits< _Tp >::_ComplexType proj (_Tp __re)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > polar (const _Tp &__rho, const _Tp &__theta=_Tp())
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > log (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > log10 (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > sqrt (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > exp (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > pow (const complex< _Tp > &__x, const complex< _Tp > &__y)
 
template<class _Tp , class _Up >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< typename cplx::detail::__promote< _Tp, _Up >::type > > pow (const complex< _Tp > &__x, const complex< _Up > &__y)
 
template<class _Tp , class _Up >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value &&is_genfloat< _Up >::value, complex< typename cplx::detail::__promote< _Tp, _Up >::type > > pow (const complex< _Tp > &__x, const _Up &__y)
 
template<class _Tp , class _Up >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value &&is_genfloat< _Up >::value, complex< typename cplx::detail::__promote< _Tp, _Up >::type > > pow (const _Tp &__x, const complex< _Up > &__y)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > asinh (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > acosh (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > atanh (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > sinh (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > cosh (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > tanh (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > asin (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > acos (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > atan (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > sin (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > cos (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, complex< _Tp > > tan (const complex< _Tp > &__x)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL constexpr _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, _Tp > real (const complex< _Tp > &__c)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL constexpr _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits< _Tp >::_ValueType real (_Tp __re)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL constexpr _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t< is_genfloat< _Tp >::value, _Tp > imag (const complex< _Tp > &__c)
 
template<class _Tp >
__DPCPP_SYCL_EXTERNAL constexpr _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits< _Tp >::_ValueType imag (_Tp)
 
std::vector< deviceget_composite_devices ()
 
template<architecture... Archs, typename T >
constexpr static auto if_architecture_is (T fn)
 The condition is true only if the device which executes the if_architecture_is function has any one of the architectures listed in the. More...
 
template<architecture Arch, typename T >
constexpr static auto if_architecture_is_lt (T fn)
 The condition is true only if the device which executes the if_architecture_is_lt function has an architecture that is in the same family as. More...
 
template<architecture Arch, typename T >
constexpr static auto if_architecture_is_le (T fn)
 The condition is true only if the device which executes the if_architecture_is_le function has an architecture that is in the same family as. More...
 
template<architecture Arch, typename T >
constexpr static auto if_architecture_is_gt (T fn)
 The condition is true only if the device which executes the if_architecture_is_gt function has an architecture that is in the same family as. More...
 
template<architecture Arch, typename T >
constexpr static auto if_architecture_is_ge (T fn)
 The condition is true only if the device which executes the if_architecture_is_ge function has an architecture that is in the same family as. More...
 
template<architecture Arch1, architecture Arch2, typename T >
constexpr static auto if_architecture_is_between (T fn)
 The condition is true only if the device which executes the if_architecture_is_between function has an architecture that is in the same family as. More...
 
template<typename CommandGroupFunc >
void submit (queue Q, CommandGroupFunc &&CGF, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
template<typename CommandGroupFunc >
event submit_with_event (queue Q, CommandGroupFunc &&CGF, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
template<typename KernelName = sycl::detail::auto_name, typename KernelType >
void single_task (handler &CGH, const KernelType &KernelObj)
 
template<typename KernelName = sycl::detail::auto_name, typename KernelType >
void single_task (queue Q, const KernelType &KernelObj, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
template<typename... ArgsT>
void single_task (handler &CGH, const kernel &KernelObj, ArgsT &&...Args)
 
template<typename... ArgsT>
void single_task (queue Q, const kernel &KernelObj, ArgsT &&...Args)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename KernelType , typename... ReductionsT>
void parallel_for (handler &CGH, range< Dimensions > Range, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename KernelType , typename... ReductionsT>
void parallel_for (queue Q, range< Dimensions > Range, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename Properties , typename KernelType , typename... ReductionsT>
void parallel_for (handler &CGH, launch_config< range< Dimensions >, Properties > Config, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename Properties , typename KernelType , typename... ReductionsT>
void parallel_for (queue Q, launch_config< range< Dimensions >, Properties > Config, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<int Dimensions, typename... ArgsT>
void parallel_for (handler &CGH, range< Dimensions > Range, const kernel &KernelObj, ArgsT &&...Args)
 
template<int Dimensions, typename... ArgsT>
void parallel_for (queue Q, range< Dimensions > Range, const kernel &KernelObj, ArgsT &&...Args)
 
template<int Dimensions, typename Properties , typename... ArgsT>
void parallel_for (handler &CGH, launch_config< range< Dimensions >, Properties > Config, const kernel &KernelObj, ArgsT &&...Args)
 
template<int Dimensions, typename Properties , typename... ArgsT>
void parallel_for (queue Q, launch_config< range< Dimensions >, Properties > Config, const kernel &KernelObj, ArgsT &&...Args)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename KernelType , typename... ReductionsT>
void nd_launch (handler &CGH, nd_range< Dimensions > Range, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename KernelType , typename... ReductionsT>
void nd_launch (queue Q, nd_range< Dimensions > Range, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename Properties , typename KernelType , typename... ReductionsT>
void nd_launch (handler &CGH, launch_config< nd_range< Dimensions >, Properties > Config, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename Properties , typename KernelType , typename... ReductionsT>
void nd_launch (queue Q, launch_config< nd_range< Dimensions >, Properties > Config, const KernelType &KernelObj, ReductionsT &&...Reductions)
 
template<int Dimensions, typename... ArgsT>
void nd_launch (handler &CGH, nd_range< Dimensions > Range, const kernel &KernelObj, ArgsT &&...Args)
 
template<int Dimensions, typename... ArgsT>
void nd_launch (queue Q, nd_range< Dimensions > Range, const kernel &KernelObj, ArgsT &&...Args)
 
template<int Dimensions, typename Properties , typename... ArgsT>
void nd_launch (handler &CGH, launch_config< nd_range< Dimensions >, Properties > Config, const kernel &KernelObj, ArgsT &&...Args)
 
template<int Dimensions, typename Properties , typename... ArgsT>
void nd_launch (queue Q, launch_config< nd_range< Dimensions >, Properties > Config, const kernel &KernelObj, ArgsT &&...Args)
 
void memcpy (handler &CGH, void *Dest, const void *Src, size_t NumBytes)
 
void memcpy (queue Q, void *Dest, const void *Src, size_t NumBytes, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
template<typename T >
void copy (handler &CGH, const T *Src, T *Dest, size_t Count)
 
template<typename T >
void copy (queue Q, const T *Src, T *Dest, size_t Count, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
void memset (handler &CGH, void *Ptr, int Value, size_t NumBytes)
 
void memset (queue Q, void *Ptr, int Value, size_t NumBytes, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
template<typename T >
void fill (sycl::handler &CGH, T *Ptr, const T &Pattern, size_t Count)
 
template<typename T >
void fill (sycl::queue Q, T *Ptr, const T &Pattern, size_t Count, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
void prefetch (handler &CGH, void *Ptr, size_t NumBytes)
 
void prefetch (queue Q, void *Ptr, size_t NumBytes, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
void mem_advise (handler &CGH, void *Ptr, size_t NumBytes, int Advice)
 
void mem_advise (queue Q, void *Ptr, size_t NumBytes, int Advice, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
void barrier (handler &CGH)
 
void barrier (queue Q, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
void partial_barrier (handler &CGH, const std::vector< event > &Events)
 
void partial_barrier (queue Q, const std::vector< event > &Events, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
template<size_t PartitionSize, typename Group >
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&std::is_same_v< Group, sycl::sub_group >, fixed_size_group< PartitionSize, Group > > get_fixed_size_group (Group group)
 
template<typename ValueT >
 dynamic_parameter (experimental::command_graph< graph_state::modifiable > Graph, const ValueT &Param) -> dynamic_parameter< ValueT >
 Additional CTAD deduction guides. More...
 
template<graph_state State = graph_state::modifiable>
 command_graph (const context &SyclContext, const device &SyclDevice, const property_list &PropList) -> command_graph< State >
 
template<typename... Args>
void group_load (Args...)
 
template<typename... Args>
void group_store (Args...)
 
template<typename Group , typename T , typename Sorter >
std::enable_if_t< detail::is_sorter< Sorter, Group, T >::value, T > sort_over_group ([[maybe_unused]] Group group, [[maybe_unused]] T value, [[maybe_unused]] Sorter sorter)
 
template<typename Group , typename T , typename Compare , size_t Extent>
std::enable_if_t<!detail::is_sorter< Compare, Group, T >::value, T > sort_over_group (experimental::group_with_scratchpad< Group, Extent > exec, T value, Compare comp)
 
template<typename Group , typename T , size_t Extent>
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > >, T > sort_over_group (experimental::group_with_scratchpad< Group, Extent > exec, T value)
 
template<typename Group , typename Iter , typename Sorter >
std::enable_if_t< detail::is_sorter< Sorter, Group, Iter >::value, void > joint_sort ([[maybe_unused]] Group group, [[maybe_unused]] Iter first, [[maybe_unused]] Iter last, [[maybe_unused]] Sorter sorter)
 
template<typename Group , typename Iter , typename Compare , size_t Extent>
std::enable_if_t<!detail::is_sorter< Compare, Group, Iter >::value, void > joint_sort (experimental::group_with_scratchpad< Group, Extent > exec, Iter first, Iter last, Compare comp)
 
template<typename Group , typename Iter , size_t Extent>
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > >, void > joint_sort (experimental::group_with_scratchpad< Group, Extent > exec, Iter first, Iter last)
 
template<class Callable , class... T>
 __attribute__ ((always_inline)) auto invoke_simd(sycl
 The invoke_simd free function invokes a SIMD function using all work-items in a sub_group. More...
 
template<typename Properties = empty_properties_t>
std::enable_if_t< is_property_list_v< std::decay_t< Properties > > > prefetch (void *ptr, Properties properties={})
 
template<typename Properties = empty_properties_t>
std::enable_if_t< is_property_list_v< std::decay_t< Properties > > > prefetch (void *ptr, size_t bytes, Properties properties={})
 
template<typename T , typename Properties = empty_properties_t>
std::enable_if_t< is_property_list_v< std::decay_t< Properties > > > prefetch (T *ptr, Properties properties={})
 
template<typename T , typename Properties = empty_properties_t>
std::enable_if_t< is_property_list_v< std::decay_t< Properties > > > prefetch (T *ptr, size_t count, Properties properties={})
 
template<access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&is_property_list_v< std::decay_t< Properties > > > prefetch (multi_ptr< void, AddressSpace, IsDecorated > ptr, Properties properties={})
 
template<access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&is_property_list_v< std::decay_t< Properties > > > prefetch (multi_ptr< void, AddressSpace, IsDecorated > ptr, size_t bytes, Properties properties={})
 
template<typename T , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&is_property_list_v< std::decay_t< Properties > > > prefetch (multi_ptr< T, AddressSpace, IsDecorated > ptr, Properties properties={})
 
template<typename T , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&is_property_list_v< std::decay_t< Properties > > > prefetch (multi_ptr< T, AddressSpace, IsDecorated > ptr, size_t count, Properties properties={})
 
template<typename DataT , int Dimensions, access_mode AccessMode, access::placeholder IsPlaceholder, typename Properties = empty_properties_t, typename AccessorProperties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_acc_mode< AccessMode > &&(Dimensions > 0) &&is_property_list_v< std::decay_t< Properties > > > prefetch (accessor< DataT, Dimensions, AccessMode, target::device, IsPlaceholder, AccessorProperties > acc, id< Dimensions > offset, Properties properties={})
 
template<typename DataT , int Dimensions, access_mode AccessMode, access::placeholder IsPlaceholder, typename Properties = empty_properties_t, typename AccessorProperties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_acc_mode< AccessMode > &&(Dimensions > 0) &&is_property_list_v< std::decay_t< Properties > > > prefetch (accessor< DataT, Dimensions, AccessMode, target::device, IsPlaceholder, AccessorProperties > acc, size_t offset, size_t count, Properties properties={})
 
template<typename Group , typename Properties = empty_properties_t>
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, void *ptr, Properties properties={})
 
template<typename Group , typename Properties = empty_properties_t>
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, void *ptr, size_t bytes, Properties properties={})
 
template<typename Group , typename T , typename Properties = empty_properties_t>
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, T *ptr, Properties properties={})
 
template<typename Group , typename T , typename Properties = empty_properties_t>
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, T *ptr, size_t count, Properties properties={})
 
template<typename Group , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, multi_ptr< void, AddressSpace, IsDecorated > ptr, Properties properties={})
 
template<typename Group , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, multi_ptr< void, AddressSpace, IsDecorated > ptr, size_t bytes, Properties properties={})
 
template<typename Group , typename T , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, multi_ptr< T, AddressSpace, IsDecorated > ptr, Properties properties={})
 
template<typename Group , typename T , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_AS< AddressSpace > &&sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, multi_ptr< T, AddressSpace, IsDecorated > ptr, size_t count, Properties properties={})
 
template<typename Group , typename DataT , int Dimensions, access_mode AccessMode, access::placeholder IsPlaceholder, typename Properties = empty_properties_t, typename AccessorProperties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_acc_mode< AccessMode > &&(Dimensions > 0) &&sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, accessor< DataT, Dimensions, AccessMode, target::device, IsPlaceholder, AccessorProperties > acc, size_t offset, Properties properties={})
 
template<typename Group , typename DataT , int Dimensions, access_mode AccessMode, access::placeholder IsPlaceholder, typename Properties = empty_properties_t, typename AccessorProperties = empty_properties_t>
std::enable_if_t< detail::check_prefetch_acc_mode< AccessMode > &&(Dimensions > 0) &&sycl::is_group_v< std::decay_t< Group > > &&is_property_list_v< std::decay_t< Properties > > > joint_prefetch (Group g, accessor< DataT, Dimensions, AccessMode, target::device, IsPlaceholder, AccessorProperties > acc, size_t offset, size_t count, Properties properties={})
 
event submit_profiling_tag (queue &Queue, const sycl::detail::code_location &CodeLoc=sycl::detail::code_location::current())
 
template<typename Group >
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&std::is_same_v< Group, sycl::sub_group >, tangle_group< Group > > get_tangle_group (Group group)
 
template<typename GroupHelper , typename T , typename BinaryOperation >
std::enable_if_t<(is_group_helper_v< GroupHelper >), T > reduce_over_group (GroupHelper group_helper, T x, BinaryOperation binary_op)
 
template<typename GroupHelper , typename V , typename T , typename BinaryOperation >
std::enable_if_t<(is_group_helper_v< GroupHelper >), T > reduce_over_group (GroupHelper group_helper, V x, T init, BinaryOperation binary_op)
 
template<typename GroupHelper , typename Ptr , typename BinaryOperation >
std::enable_if_t<(is_group_helper_v< GroupHelper > &&sycl::detail::is_pointer_v< Ptr >), typename std::iterator_traits< Ptr >::value_typejoint_reduce (GroupHelper group_helper, Ptr first, Ptr last, BinaryOperation binary_op)
 
template<typename GroupHelper , typename Ptr , typename T , typename BinaryOperation >
std::enable_if_t<(is_group_helper_v< GroupHelper > &&sycl::detail::is_pointer_v< Ptr >), T > joint_reduce (GroupHelper group_helper, Ptr first, Ptr last, T init, BinaryOperation binary_op)
 
template<int Dims>
 __SYCL_DEPRECATED ("use sycl::ext::oneapi::this_work_item::get_nd_item() instead") nd_item< Dims > this_nd_item()
 
template<int Dims>
 __SYCL_DEPRECATED ("use sycl::ext::oneapi::this_work_item::get_work_group() instead") group< Dims > this_group()
 
 __SYCL_DEPRECATED ("use sycl::ext::oneapi::this_work_item::get_sub_group() instead") inline sycl
 
template<int Dims>
 __SYCL_DEPRECATED ("use nd_range kernel and " "sycl::ext::oneapi::this_work_item::get_nd_item() instead") item< Dims > this_item()
 
template<typename PropertyT , typename... A, typename... B>
constexpr std::enable_if_t< detail::IsCompileTimeProperty< PropertyT >::value, bool > operator== (const property_value< PropertyT, A... > &, const property_value< PropertyT, B... > &)
 
template<typename PropertyT , typename... A, typename... B>
constexpr std::enable_if_t< detail::IsCompileTimeProperty< PropertyT >::value, bool > operator!= (const property_value< PropertyT, A... > &, const property_value< PropertyT, B... > &)
 
bool is_source_kernel_bundle_supported (backend BE, source_language Language)
 
kernel_bundle< bundle_state::ext_oneapi_sourcecreate_kernel_bundle_from_source (const context &SyclContext, source_language Language, const std::string &Source)
 
kernel_bundle< bundle_state::ext_oneapi_sourcecreate_kernel_bundle_from_source (const context &SyclContext, source_language Language, const std::vector< std::byte > &Bytes)
 
template<typename PropertyListT = empty_properties_t, typename = std::enable_if_t< is_property_list_v<PropertyListT> && detail::all_props_are_keys_of< kernel_bundle<bundle_state::ext_oneapi_source>, PropertyListT>::value>>
kernel_bundle< bundle_state::executablebuild (kernel_bundle< bundle_state::ext_oneapi_source > &SourceKB, const std::vector< device > &Devices, PropertyListT props={})
 
template<typename PropertyListT = empty_properties_t, typename = std::enable_if_t< is_property_list_v<PropertyListT> && detail::all_props_are_keys_of< kernel_bundle<bundle_state::ext_oneapi_source>, PropertyListT>::value>>
kernel_bundle< bundle_state::executablebuild (kernel_bundle< bundle_state::ext_oneapi_source > &SourceKB, PropertyListT props={})
 
void prepare_for_device_copy (const void *Ptr, size_t Size, const context &Context)
 
void prepare_for_device_copy (const void *Ptr, size_t Size, const queue &Queue)
 
void release_from_device_copy (const void *Ptr, const context &Context)
 
void release_from_device_copy (const void *Ptr, const queue &Queue)
 
void populate_pi_structs (const image_descriptor &desc, pi_image_desc &piDesc, pi_image_format &piFormat, size_t pitch=0)
 
image_mem_handle alloc_mipmap_mem (const image_descriptor &desc, const sycl::queue &syclQueue)
 
template<>
interop_mem_handle import_external_memory< resource_fd > (external_mem_descriptor< resource_fd > externalMem, const sycl::device &syclDevice, const sycl::context &syclContext)
 
template<>
interop_mem_handle import_external_memory< resource_fd > (external_mem_descriptor< resource_fd > externalMem, const sycl::queue &syclQueue)
 
template<>
interop_mem_handle import_external_memory< external_mem_fd > (external_mem_descriptor< external_mem_fd > externalMem, const sycl::device &syclDevice, const sycl::context &syclContext)
 
template<>
interop_mem_handle import_external_memory< external_mem_fd > (external_mem_descriptor< external_mem_fd > externalMem, const sycl::queue &syclQueue)
 
template<>
interop_semaphore_handle import_external_semaphore (external_semaphore_descriptor< resource_fd > externalSemaphoreDesc, const sycl::device &syclDevice, const sycl::context &syclContext)
 
template<>
interop_semaphore_handle import_external_semaphore (external_semaphore_descriptor< resource_fd > externalSemaphoreDesc, const sycl::queue &syclQueue)
 
template<>
interop_semaphore_handle import_external_semaphore (external_semaphore_descriptor< external_semaphore_fd > externalSemaphoreDesc, const sycl::device &syclDevice, const sycl::context &syclContext)
 
template<>
interop_semaphore_handle import_external_semaphore (external_semaphore_descriptor< external_semaphore_fd > externalSemaphoreDesc, const sycl::queue &syclQueue)
 

Variables

template<class T >
constexpr bool is_fixed_topology_group_v
 
template<class T >
constexpr bool is_user_constructed_group_v
 
template<class T >
constexpr bool is_group_helper_v
 
const CoordT & coords
 
const CoordT const float level
 
const CoordT const CoordT & dX
 
const CoordT const CoordT const CoordT & dY
 
constexpr device_image_scope_key::value_t device_image_scope
 
template<host_access_enum Access>
constexpr host_access_key::value_t< Access > host_access
 
constexpr host_access_key::value_t< host_access_enum::readhost_access_read
 
constexpr host_access_key::value_t< host_access_enum::writehost_access_write
 
constexpr host_access_key::value_t< host_access_enum::read_writehost_access_read_write
 
constexpr host_access_key::value_t< host_access_enum::nonehost_access_none
 
template<init_mode_enum Trigger>
constexpr init_mode_key::value_t< Trigger > init_mode
 
constexpr init_mode_key::value_t< init_mode_enum::reprograminit_mode_reprogram
 
constexpr init_mode_key::value_t< init_mode_enum::resetinit_mode_reset
 
template<bool Enable>
constexpr implement_in_csr_key::value_t< Enable > implement_in_csr
 
constexpr implement_in_csr_key::value_t< true > implement_in_csr_on
 
constexpr implement_in_csr_key::value_t< false > implement_in_csr_off
 
T * obj
 
static constexpr bool is_valid_property_list
 
static constexpr bool contains_valid_properties
 
static constexpr bool hasValidFPGAProperties
 
static constexpr bool hasConduitAndRegisterMapProperties
 
static constexpr bool is_device_copyable = is_device_copyable_v<T>
 
static constexpr bool has_buffer_location
 
static constexpr bool has_awidth = has_property<awidth_key>()
 
static constexpr bool has_dwidth = has_property<dwidth_key>()
 
static constexpr bool has_latency = has_property<latency_key>()
 
static constexpr bool has_read_write_mode
 
static constexpr bool has_maxburst = has_property<maxburst_key>()
 
static constexpr bool has_wait_request = has_property<wait_request_key>()
 
static constexpr bool has_alignment = has_property<alignment_key>()
 
static constexpr bool has_usm_kind = has_property<usm_kind_key>()
 
T * m_Ptr
 
static constexpr bool is_valid_property_list
 
static constexpr bool contains_valid_properties
 
static constexpr bool hasValidFPGAProperties
 
static constexpr bool hasConduitAndRegisterMapProperties
 
template<sycl::usm::alloc Kind>
constexpr usm_kind_key::value_t< Kind > usm_kind
 
constexpr usm_kind_key::value_t< sycl::usm::alloc::device > usm_kind_device
 
constexpr usm_kind_key::value_t< sycl::usm::alloc::host > usm_kind_host
 
constexpr usm_kind_key::value_t< sycl::usm::alloc::shared > usm_kind_shared
 
template<typename T >
constexpr bool is_vec_or_swizzle_bf16_v
 
template<typename T >
constexpr int num_elements_v = sycl::detail::num_elements<T>::value
 
template<int K>
constexpr alignment_key::value_t< K > alignment
 
template<data_placement_enum Placement>
constexpr data_placement_key::value_t< Placement > data_placement
 
constexpr data_placement_key::value_t< data_placement_enum::blockeddata_placement_blocked
 
constexpr data_placement_key::value_t< data_placement_enum::stripeddata_placement_striped
 
constexpr contiguous_memory_key::value_t contiguous_memory
 
constexpr full_group_key::value_t full_group
 
template<cache_level Level, typename Hint >
constexpr prefetch_hint_key::value_t< Level, Hint > prefetch_hint
 
constexpr prefetch_hint_key::value_t< cache_level::L1, void > prefetch_hint_L1
 
constexpr prefetch_hint_key::value_t< cache_level::L2, void > prefetch_hint_L2
 
constexpr prefetch_hint_key::value_t< cache_level::L3, void > prefetch_hint_L3
 
constexpr prefetch_hint_key::value_t< cache_level::L4, void > prefetch_hint_L4
 
constexpr prefetch_hint_key::value_t< cache_level::L1, nontemporal > prefetch_hint_L1_nt
 
constexpr prefetch_hint_key::value_t< cache_level::L2, nontemporal > prefetch_hint_L2_nt
 
constexpr prefetch_hint_key::value_t< cache_level::L3, nontemporal > prefetch_hint_L3_nt
 
constexpr prefetch_hint_key::value_t< cache_level::L4, nontemporal > prefetch_hint_L4_nt
 
constexpr use_root_sync_key::value_t use_root_sync
 
template<typename Set = void>
constexpr indirectly_callable_key::value_t< Set > indirectly_callable
 
template<typename First = void, typename... Rest>
constexpr calls_indirectly_key::value_t< First, Rest... > calls_indirectly
 
template<size_t Dim0, size_t... Dims>
constexpr work_group_size_key::value_t< Dim0, Dims... > work_group_size
 
template<size_t Dim0, size_t... Dims>
constexpr work_group_size_hint_key::value_t< Dim0, Dims... > work_group_size_hint
 
template<uint32_t Size>
constexpr sub_group_size_key::value_t< Size > sub_group_size
 
template<aspect... Aspects>
constexpr device_has_key::value_t< Aspects... > device_has
 
template<int Dims>
constexpr nd_range_kernel_key::value_t< Dims > nd_range_kernel
 
constexpr single_task_kernel_key::value_t single_task_kernel
 
template<forward_progress_guarantee Guarantee, execution_scope CoordinationScope>
constexpr work_group_progress_key::value_t< Guarantee, CoordinationScope > work_group_progress
 
template<forward_progress_guarantee Guarantee, execution_scope CoordinationScope>
constexpr sub_group_progress_key::value_t< Guarantee, CoordinationScope > sub_group_progress
 
template<forward_progress_guarantee Guarantee, execution_scope CoordinationScope>
constexpr work_item_progress_key::value_t< Guarantee, CoordinationScope > work_item_progress
 
constexpr cl_version opencl_c_1_0 = {1, 0, 0}
 
constexpr cl_version opencl_c_1_1 = {1, 1, 0}
 
constexpr cl_version opencl_c_1_2 = {1, 2, 0}
 
constexpr cl_version opencl_c_2_0 = {2, 0, 0}
 
constexpr cl_version opencl_c_3_0 = {3, 0, 0}
 

Typedef Documentation

◆ awidth_key

◆ buffer_location_key

◆ build_options_key

◆ CheckDevicePtrTAndPropLists

template<typename T , typename ListA , typename ListB >
using sycl::_V1::ext::oneapi::experimental::CheckDevicePtrTAndPropLists = typedef typename detail::CheckTAndPropListsWithUsmKind<sycl::usm::alloc::device, T, ListA, ListB>

Definition at line 20 of file alloc_device.hpp.

◆ CheckHostPtrTAndPropLists

template<typename T , typename ListA , typename ListB >
using sycl::_V1::ext::oneapi::experimental::CheckHostPtrTAndPropLists = typedef typename detail::CheckTAndPropListsWithUsmKind<sycl::usm::alloc::host, T, ListA, ListB>

Definition at line 20 of file alloc_host.hpp.

◆ CheckSharedPtrTAndPropLists

template<typename T , typename ListA , typename ListB >
using sycl::_V1::ext::oneapi::experimental::CheckSharedPtrTAndPropLists = typedef typename detail::CheckTAndPropListsWithUsmKind<sycl::usm::alloc::shared, T, ListA, ListB>

Definition at line 20 of file alloc_shared.hpp.

◆ conduit_key

◆ dwidth_key

◆ empty_properties_t

Definition at line 234 of file properties.hpp.

◆ exe_kb

◆ GetAnnotatedDevicePtrProperties

template<typename PropertyListT >
using sycl::_V1::ext::oneapi::experimental::GetAnnotatedDevicePtrProperties = typedef detail::GetAnnotatedPtrPropertiesWithUsmKind<sycl::usm::alloc::device, PropertyListT>

Definition at line 25 of file alloc_device.hpp.

◆ GetAnnotatedHostPtrProperties

template<typename PropertyListT >
using sycl::_V1::ext::oneapi::experimental::GetAnnotatedHostPtrProperties = typedef detail::GetAnnotatedPtrPropertiesWithUsmKind<sycl::usm::alloc::host, PropertyListT>

Definition at line 25 of file alloc_host.hpp.

◆ GetAnnotatedSharedPtrProperties

template<typename PropertyListT >
using sycl::_V1::ext::oneapi::experimental::GetAnnotatedSharedPtrProperties = typedef detail::GetAnnotatedPtrPropertiesWithUsmKind<sycl::usm::alloc::shared, PropertyListT>

Definition at line 25 of file alloc_shared.hpp.

◆ global_pointer_t

◆ kernel_bundle_impl

using sycl::_V1::ext::oneapi::experimental::kernel_bundle_impl = typedef sycl::detail::kernel_bundle_impl

Definition at line 368 of file kernel_bundle.cpp.

◆ latency_key

◆ maxburst_key

◆ property_list_t

◆ read_write_mode_enum

◆ read_write_mode_key

◆ reference

◆ register_map_key

◆ save_log_key

◆ simd

template<class T , int N>
using sycl::_V1::ext::oneapi::experimental::simd = typedef std::experimental::simd<T, simd_abi::native_fixed_size<T, N> >

Definition at line 38 of file invoke_simd_types.hpp.

◆ simd_mask

template<class T , int N>
using sycl::_V1::ext::oneapi::experimental::simd_mask = typedef std::experimental::simd_mask<T, simd_abi::native_fixed_size<T, N> >

This is basically an alias of the detail::simd_mask_impl class.

Definition at line 42 of file invoke_simd_types.hpp.

◆ source_kb

using sycl::_V1::ext::oneapi::experimental::source_kb = typedef kernel_bundle<sycl::bundle_state::ext_oneapi_source>

Definition at line 366 of file kernel_bundle.cpp.

◆ stable_key

◆ UnderlyingT

Definition at line 233 of file annotated_arg.hpp.

◆ wait_request_key

Enumeration Type Documentation

◆ arch_category

Enumerator
intel_gpu 
nvidia_gpu 
amd_gpu 

Definition at line 200 of file device_architecture.hpp.

◆ architecture

Enumerator
x86_64 
intel_cpu_spr 
intel_cpu_gnr 
intel_gpu_bdw 
intel_gpu_skl 
intel_gpu_kbl 
intel_gpu_cfl 
intel_gpu_apl 
intel_gpu_bxt 
intel_gpu_glk 
intel_gpu_whl 
intel_gpu_aml 
intel_gpu_cml 
intel_gpu_icllp 
intel_gpu_icl 
intel_gpu_ehl 
intel_gpu_jsl 
intel_gpu_tgllp 
intel_gpu_tgl 
intel_gpu_rkl 
intel_gpu_adl_s 
intel_gpu_rpl_s 
intel_gpu_adl_p 
intel_gpu_adl_n 
intel_gpu_dg1 
intel_gpu_acm_g10 
intel_gpu_dg2_g10 
intel_gpu_acm_g11 
intel_gpu_dg2_g11 
intel_gpu_acm_g12 
intel_gpu_dg2_g12 
intel_gpu_pvc 
intel_gpu_pvc_vg 
intel_gpu_mtl_u 
intel_gpu_mtl_s 
intel_gpu_arl_u 
intel_gpu_arl_s 
intel_gpu_mtl_h 
intel_gpu_arl_h 
intel_gpu_bmg_g21 
intel_gpu_lnl_m 
nvidia_gpu_sm_50 
nvidia_gpu_sm_52 
nvidia_gpu_sm_53 
nvidia_gpu_sm_60 
nvidia_gpu_sm_61 
nvidia_gpu_sm_62 
nvidia_gpu_sm_70 
nvidia_gpu_sm_72 
nvidia_gpu_sm_75 
nvidia_gpu_sm_80 
nvidia_gpu_sm_86 
nvidia_gpu_sm_87 
nvidia_gpu_sm_89 
nvidia_gpu_sm_90 
nvidia_gpu_sm_90a 
amd_gpu_gfx700 
amd_gpu_gfx701 
amd_gpu_gfx702 
amd_gpu_gfx801 
amd_gpu_gfx802 
amd_gpu_gfx803 
amd_gpu_gfx805 
amd_gpu_gfx810 
amd_gpu_gfx900 
amd_gpu_gfx902 
amd_gpu_gfx904 
amd_gpu_gfx906 
amd_gpu_gfx908 
amd_gpu_gfx909 
amd_gpu_gfx90a 
amd_gpu_gfx90c 
amd_gpu_gfx940 
amd_gpu_gfx941 
amd_gpu_gfx942 
amd_gpu_gfx1010 
amd_gpu_gfx1011 
amd_gpu_gfx1012 
amd_gpu_gfx1013 
amd_gpu_gfx1030 
amd_gpu_gfx1031 
amd_gpu_gfx1032 
amd_gpu_gfx1033 
amd_gpu_gfx1034 
amd_gpu_gfx1035 
amd_gpu_gfx1036 
amd_gpu_gfx1100 
amd_gpu_gfx1101 
amd_gpu_gfx1102 
amd_gpu_gfx1103 
amd_gpu_gfx1150 
amd_gpu_gfx1151 
amd_gpu_gfx1200 
amd_gpu_gfx1201 
intel_gpu_8_0_0 
intel_gpu_9_0_9 
intel_gpu_9_1_9 
intel_gpu_9_2_9 
intel_gpu_9_3_0 
intel_gpu_9_4_0 
intel_gpu_9_5_0 
intel_gpu_9_6_0 
intel_gpu_9_7_0 
intel_gpu_11_0_0 
intel_gpu_11_2_0 
intel_gpu_12_0_0 
intel_gpu_12_1_0 
intel_gpu_12_2_0 
intel_gpu_12_3_0 
intel_gpu_12_4_0 
intel_gpu_12_10_0 
intel_gpu_12_55_8 
intel_gpu_12_56_5 
intel_gpu_12_57_0 
intel_gpu_12_60_7 
intel_gpu_12_61_7 
intel_gpu_12_70_4 
intel_gpu_12_71_4 
intel_gpu_12_74_4 
intel_gpu_20_1_4 
intel_gpu_20_4_4 

Definition at line 19 of file device_architecture.hpp.

◆ cache_level

Enumerator
L1 
L2 
L3 
L4 

Definition at line 19 of file prefetch.hpp.

◆ cubemap_filtering_mode

cubemap filtering mode enum

Enumerator
disjointed 
seamless 

Definition at line 18 of file bindless_images_sampler.hpp.

◆ data_placement_enum

Enumerator
blocked 
striped 

Definition at line 23 of file group_load_store.hpp.

◆ execution_scope

Enumerator
work_item 
sub_group 
work_group 
root_group 

Definition at line 19 of file forward_progress.hpp.

◆ forward_progress_guarantee

Enumerator
concurrent 
parallel 
weakly_parallel 

Definition at line 17 of file forward_progress.hpp.

◆ graph_state

State to template the command_graph class on.

Enumerator
modifiable 

In modifiable state, commands can be added to graph.

executable 

In executable state, the graph is ready to execute.

Definition at line 37 of file graph.hpp.

◆ host_access_enum

Enumerator
read 
write 
read_write 
none 

Definition at line 29 of file properties.hpp.

◆ image_copy_flags

Direction to copy data from bindless image handle (Host -> Device) (Device -> Host) etc.

Enumerator
HtoD 
DtoH 
DtoD 

Definition at line 101 of file bindless_images_memory.hpp.

◆ image_type

image type enum

Enumerator
standard 
mipmap 
array 
cubemap 

Definition at line 44 of file bindless_images_descriptor.hpp.

◆ init_mode_enum

Enumerator
reprogram 
reset 

Definition at line 39 of file properties.hpp.

◆ node_type

Enumerator
empty 
subgraph 
kernel 
memcpy 
memset 
memfill 
prefetch 
memadvise 
ext_oneapi_barrier 
host_task 

Definition at line 91 of file graph.hpp.

◆ sorting_order

Enumerator
ascending 
descending 

Definition at line 145 of file group_helpers_sorters.hpp.

◆ source_language

Enumerator
opencl 
spirv 

Definition at line 23 of file kernel_bundle_enums.hpp.

Function Documentation

◆ __attribute__()

template<class Callable , class... T>
sycl::_V1::ext::oneapi::experimental::__attribute__ ( (always_inline)  )

The invoke_simd free function invokes a SIMD function using all work-items in a sub_group.

The invoke_simd interface marshals data between the SPMD context of the calling kernel and the SIMD context of the callee, converting arguments and return values between scalar and SIMD types as appropriate.

Parameters
sgthe subgroup simd function is invoked from
frepresents the invoked simd function. Must be a C++ callable that can be invoked with the same number of arguments specified in the args parameter pack. Callable may be a function object, a lambda, or a function pointer (if the device supports SPV_INTEL_function_pointers). Callable must be an immutable callable with the same type and state for all work-items in the sub-group, otherwise behavior is undefined.
argsSPMD parameters to the invoked function, which undergo transformation before actual passing to the simd function, as described in the specification.

Definition at line 464 of file invoke_simd.hpp.

References __builtin_invoke_simd(), sycl::_V1::ext::oneapi::experimental::detail::get_sg_size(), sycl::_V1::ext::oneapi::experimental::detail::unwrap_uniform< T >::impl(), sycl::_V1::ext::oneapi::experimental::detail::simd_func_call_helper(), sycl::_V1::ext::oneapi::experimental::detail::simd_obj_call_helper(), sycl::_V1::ext::oneapi::experimental::detail::verify_return_type_matches_sg_size(), and sycl::_V1::ext::oneapi::experimental::detail::verify_valid_args_and_ret().

Referenced by sycl::_V1::ext::oneapi::group_local_memory(), sycl::_V1::ext::oneapi::group_local_memory_for_overwrite(), and sycl::_V1::ext::oneapi::experimental::detail::prefetch_impl().

◆ __SYCL_DEPRECATED() [1/8]

template<typename DataT , typename HintT = DataT, typename CoordT >
sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "read_image for mipmaps is deprecated. " "Instead use sample_mipmap."  ) const &

[Deprecated] Read a mipmap image using its handle with LOD filtering

[Deprecated] Read a mipmap image using its handle with anisotropic filtering

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. float, float2, or float3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe mipmap image handle
coordsThe coordinates at which to sample mipmap image data
levelThe mipmap level at which to sample
Returns
Mipmap image data with LOD filtering
Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. float, float2, or float3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe mipmap image handle
coordsThe coordinates at which to fetch mipmap image data
dXScreen space gradient in the x dimension
dYScreen space gradient in the y dimension
Returns
Mipmap image data with anisotropic filtering

References coords, and level.

◆ __SYCL_DEPRECATED() [2/8]

template<typename DataT , typename HintT = DataT, typename CoordT >
sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "read_image for standard sampled images is deprecated. " "Instead use sample_image with floating point coordinates or " "fetch_image with integer coordinates."  ) const &

[Deprecated] Read a sampled image using its handle

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. float, float2, or float3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe image handle
coordsThe coordinates at which to sample image data
Returns
Sampled image data

NVPTX: Name mangling info Cuda surfaces require integer coords (by bytes) Cuda textures require float coords (by element or normalized) for sampling, and integer coords (by bytes) for fetching The name mangling should therefore not interfere with one another

◆ __SYCL_DEPRECATED() [3/8]

template<typename DataT , typename HintT = DataT, typename CoordT >
sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "read_image for standard unsampled images is deprecated. " "Instead use fetch_image."  ) const &

[Deprecated] Read an unsampled image using its handle

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. int, int2, or int3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe image handle
coordsThe coordinates at which to fetch image data
Returns
Image data

NVPTX: Name mangling info Cuda surfaces require integer coords (by bytes) Cuda textures require float coords (by element or normalized) for sampling, and integer coords (by bytes) for fetching The name mangling should therefore not interfere with one another

◆ __SYCL_DEPRECATED() [4/8]

template<typename DataT , typename HintT = DataT, typename CoordT >
sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "read_mipmap has been deprecated. " "Instead use sample_mipmap."  ) const &

[Deprecated] Read a mipmap image using its handle with LOD filtering

[Deprecated] Read a mipmap image using its handle with anisotropic filtering

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. float, float2, or float3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe mipmap image handle
coordsThe coordinates at which to sample mipmap image data
levelThe mipmap level at which to sample
Returns
Mipmap image data with LOD filtering
Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. float, float2, or float3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe mipmap image handle
coordsThe coordinates at which to sample mipmap image data
dXScreen space gradient in the x dimension
dYScreen space gradient in the y dimension
Returns
Mipmap image data with anisotropic filtering

◆ __SYCL_DEPRECATED() [5/8]

template<int Dims>
sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "use nd_range kernel and " "sycl::ext::oneapi::this_work_item::get_nd_item() instead )

Definition at line 70 of file free_function_queries.hpp.

References sycl::_V1::detail::declptr().

◆ __SYCL_DEPRECATED() [6/8]

template<int Dims>
sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "use sycl::ext::oneapi::this_work_item::get_nd_item() instead )

Definition at line 50 of file free_function_queries.hpp.

◆ __SYCL_DEPRECATED() [7/8]

sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "use sycl::ext::oneapi::this_work_item::get_sub_group() instead )

◆ __SYCL_DEPRECATED() [8/8]

template<int Dims>
sycl::_V1::ext::oneapi::experimental::__SYCL_DEPRECATED ( "use sycl::ext::oneapi::this_work_item::get_work_group() instead )

Definition at line 57 of file free_function_queries.hpp.

◆ __SYCL_TYPE() [1/2]

template<typename T , typename... Props>
class __SYCL_SPECIAL_CLASS sycl::_V1::ext::oneapi::experimental::__SYCL_TYPE ( annotated_arg  )

◆ __SYCL_TYPE() [2/2]

template<typename T , typename... Props>
class __SYCL_SPECIAL_CLASS sycl::_V1::ext::oneapi::experimental::__SYCL_TYPE ( annotated_ptr  )

◆ abs()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, _Tp> sycl::_V1::ext::oneapi::experimental::abs ( const complex< _Tp > &  __c)

FUNCTIONS.

Definition at line 122 of file complex_math.hpp.

Referenced by log(), and sqrt().

◆ acos()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::acos ( const complex< _Tp > &  __x)

◆ acosh()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::acosh ( const complex< _Tp > &  __x)

◆ aligned_alloc_annotated() [1/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_annotated ( size_t  alignment,
size_t  count,
const device syclDevice,
const context syclContext,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 86 of file alloc_base.hpp.

◆ aligned_alloc_annotated() [2/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_annotated ( size_t  alignment,
size_t  count,
const queue syclQueue,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 141 of file alloc_base.hpp.

◆ aligned_alloc_annotated() [3/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_annotated ( size_t  alignment,
size_t  numBytes,
const device syclDevice,
const context syclContext,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 44 of file alloc_base.hpp.

◆ aligned_alloc_annotated() [4/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_annotated ( size_t  alignment,
size_t  numBytes,
const queue syclQueue,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 128 of file alloc_base.hpp.

◆ aligned_alloc_device_annotated() [1/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_device_annotated ( size_t  alignment,
size_t  count,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 62 of file alloc_device.hpp.

◆ aligned_alloc_device_annotated() [2/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_device_annotated ( size_t  alignment,
size_t  count,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 92 of file alloc_device.hpp.

◆ aligned_alloc_device_annotated() [3/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_device_annotated ( size_t  alignment,
size_t  numBytes,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 46 of file alloc_device.hpp.

◆ aligned_alloc_device_annotated() [4/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_device_annotated ( size_t  alignment,
size_t  numBytes,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 78 of file alloc_device.hpp.

◆ aligned_alloc_host_annotated() [1/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_host_annotated ( size_t  alignment,
size_t  count,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 61 of file alloc_host.hpp.

◆ aligned_alloc_host_annotated() [2/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_host_annotated ( size_t  alignment,
size_t  count,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 88 of file alloc_host.hpp.

◆ aligned_alloc_host_annotated() [3/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_host_annotated ( size_t  alignment,
size_t  numBytes,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 47 of file alloc_host.hpp.

◆ aligned_alloc_host_annotated() [4/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_host_annotated ( size_t  alignment,
size_t  numBytes,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 75 of file alloc_host.hpp.

◆ aligned_alloc_shared_annotated() [1/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_shared_annotated ( size_t  alignment,
size_t  count,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 62 of file alloc_shared.hpp.

◆ aligned_alloc_shared_annotated() [2/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_shared_annotated ( size_t  alignment,
size_t  count,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 92 of file alloc_shared.hpp.

◆ aligned_alloc_shared_annotated() [3/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_shared_annotated ( size_t  alignment,
size_t  numBytes,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 46 of file alloc_shared.hpp.

◆ aligned_alloc_shared_annotated() [4/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::aligned_alloc_shared_annotated ( size_t  alignment,
size_t  numBytes,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 78 of file alloc_shared.hpp.

◆ aligned_private_alloca()

template<typename ElementType , std::size_t Alignment, auto & SizeSpecName, access::decorated DecorateAddress>
private_ptr<ElementType, DecorateAddress> sycl::_V1::ext::oneapi::experimental::aligned_private_alloca ( kernel_handler &  kh)

Definition at line 72 of file alloca.hpp.

◆ alloc_image_mem() [1/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::alloc_image_mem ( const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Allocate image memory based on image_descriptor.

Parameters
descThe image descriptor
syclDeviceThe device in which we create our memory handle
syclContextThe context in which we create our memory handle
Returns
Memory handle to allocated memory on the device

Definition at line 161 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), piextMemImageAllocate(), populate_pi_structs(), sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle, and sycl::_V1::ext::oneapi::experimental::image_descriptor::verify().

Referenced by alloc_image_mem(), and sycl::_V1::ext::oneapi::experimental::detail::image_mem_impl::image_mem_impl().

◆ alloc_image_mem() [2/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::alloc_image_mem ( const image_descriptor desc,
const sycl::queue syclQueue 
)

Allocate image memory based on image_descriptor.

Parameters
descThe image descriptor
syclQueueThe queue in which we create our memory handle
Returns
Memory handle to allocated memory on the device

Definition at line 187 of file bindless_images.cpp.

References alloc_image_mem(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ alloc_mipmap_mem() [1/3]

image_mem_handle sycl::_V1::ext::oneapi::experimental::alloc_mipmap_mem ( const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

[Deprecated] Allocate mipmap memory based on image_descriptor

Parameters
descThe image descriptor
syclDeviceThe device in which we create our memory handle
syclContextThe context in which we create our memory handle
Returns
Memory handle to allocated memory on the device

Definition at line 194 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), piextMemImageAllocate(), populate_pi_structs(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

Referenced by alloc_mipmap_mem().

◆ alloc_mipmap_mem() [2/3]

image_mem_handle sycl::_V1::ext::oneapi::experimental::alloc_mipmap_mem ( const image_descriptor desc,
const sycl::device syclQueue 
)

[Deprecated] Allocate mipmap memory based on image_descriptor

Parameters
descThe image descriptor
syclQueueThe queue in which we create our memory handle
Returns
Memory handle to allocated memory on the device

◆ alloc_mipmap_mem() [3/3]

image_mem_handle sycl::_V1::ext::oneapi::experimental::alloc_mipmap_mem ( const image_descriptor desc,
const sycl::queue syclQueue 
)

Definition at line 222 of file bindless_images.cpp.

References alloc_mipmap_mem().

◆ annotated_arg() [1/9]

template<typename T , typename old , typename... ArgT>
sycl::_V1::ext::oneapi::experimental::annotated_arg ( annotated_arg< T, old >  ,
properties< std::tuple< ArgT... >>   
) -> annotated_arg< T, detail::merged_properties_t< old, detail::properties_t< ArgT... >>>

◆ annotated_arg() [2/9]

◆ annotated_arg() [3/9]

template<typename T2 , typename PropertyList2 >
sycl::_V1::ext::oneapi::experimental::annotated_arg ( const annotated_arg< T2, PropertyList2 > &  other)
explicitnoexcept

Definition at line 143 of file annotated_arg.hpp.

◆ annotated_arg() [4/9]

template<typename T2 , typename PropertyListU , typename PropertyListV >
sycl::_V1::ext::oneapi::experimental::annotated_arg ( const annotated_arg< T2, PropertyListU > &  other,
const PropertyListV &  proplist 
)
explicitnoexcept

Definition at line 165 of file annotated_arg.hpp.

◆ annotated_arg() [5/9]

sycl::_V1::ext::oneapi::experimental::annotated_arg ( const T &  _obj,
const property_list_t PropList = property_list_t{} 
)
noexcept

Definition at line 252 of file annotated_arg.hpp.

◆ annotated_arg() [6/9]

template<typename... PropertyValueTs>
sycl::_V1::ext::oneapi::experimental::annotated_arg ( const T &  _obj,
PropertyValueTs...  props 
)
noexcept

Definition at line 263 of file annotated_arg.hpp.

◆ annotated_arg() [7/9]

sycl::_V1::ext::oneapi::experimental::annotated_arg ( T *  _ptr,
const property_list_t PropList = property_list_t{} 
)
noexcept

Definition at line 116 of file annotated_arg.hpp.

◆ annotated_arg() [8/9]

template<typename... PropertyValueTs>
sycl::_V1::ext::oneapi::experimental::annotated_arg ( T *  _ptr,
const PropertyValueTs &...  props 
)
noexcept

Definition at line 127 of file annotated_arg.hpp.

◆ annotated_arg() [9/9]

template<typename T , typename... Args>
sycl::_V1::ext::oneapi::experimental::annotated_arg ( ,
Args...   
) -> annotated_arg< T, typename detail::DeducedProperties< Args... >::type >

◆ annotated_ptr() [1/5]

◆ annotated_ptr() [2/5]

template<typename T2 , typename PropertyList2 >
sycl::_V1::ext::oneapi::experimental::annotated_ptr ( const annotated_ptr< T2, PropertyList2 > &  other)
explicitnoexcept

Definition at line 332 of file annotated_ptr.hpp.

◆ annotated_ptr() [3/5]

template<typename T2 , typename PropertyListU , typename PropertyListV >
sycl::_V1::ext::oneapi::experimental::annotated_ptr ( const annotated_ptr< T2, PropertyListU > &  other,
const PropertyListV &   
)
explicitnoexcept

Definition at line 355 of file annotated_ptr.hpp.

◆ annotated_ptr() [4/5]

Definition at line 305 of file annotated_ptr.hpp.

◆ annotated_ptr() [5/5]

template<typename... PropertyValueTs>
sycl::_V1::ext::oneapi::experimental::annotated_ptr ( T *  Ptr,
const PropertyValueTs &...  props 
)
explicitnoexcept

Definition at line 314 of file annotated_ptr.hpp.

◆ arg() [1/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits<_Tp>::_ValueType sycl::_V1::ext::oneapi::experimental::arg ( _Tp  __re)

Definition at line 138 of file complex_math.hpp.

◆ arg() [2/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, _Tp> sycl::_V1::ext::oneapi::experimental::arg ( const complex< _Tp > &  __c)

Definition at line 131 of file complex_math.hpp.

Referenced by log(), and sqrt().

◆ asin()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::asin ( const complex< _Tp > &  __x)

Definition at line 515 of file complex_math.hpp.

References asinh().

◆ asinh()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::asinh ( const complex< _Tp > &  __x)

◆ atan()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::atan ( const complex< _Tp > &  __x)

Definition at line 561 of file complex_math.hpp.

References atanh().

◆ atanh()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::atanh ( const complex< _Tp > &  __x)

◆ auto_range()

template<int Dimensions>
static range<Dimensions> sycl::_V1::ext::oneapi::experimental::auto_range ( )
inlinestatic

Definition at line 17 of file auto_local_range.hpp.

References sycl::_V1::Dimensions.

◆ barrier() [1/2]

void sycl::_V1::ext::oneapi::experimental::barrier ( handler CGH)
inline

Definition at line 335 of file enqueue_functions.hpp.

References sycl::_V1::handler::ext_oneapi_barrier().

Referenced by barrier().

◆ barrier() [2/2]

void sycl::_V1::ext::oneapi::experimental::barrier ( queue  Q,
const sycl::detail::code_location &  CodeLoc = sycl::detail::code_location::current() 
)
inline

Definition at line 337 of file enqueue_functions.hpp.

References barrier(), and submit().

◆ build() [1/2]

template<typename PropertyListT = empty_properties_t, typename = std::enable_if_t< is_property_list_v<PropertyListT> && detail::all_props_are_keys_of< kernel_bundle<bundle_state::ext_oneapi_source>, PropertyListT>::value>>
kernel_bundle<bundle_state::executable> sycl::_V1::ext::oneapi::experimental::build ( kernel_bundle< bundle_state::ext_oneapi_source > &  SourceKB,
const std::vector< device > &  Devices,
PropertyListT  props = {} 
)

Definition at line 890 of file kernel_bundle.hpp.

◆ build() [2/2]

template<typename PropertyListT = empty_properties_t, typename = std::enable_if_t< is_property_list_v<PropertyListT> && detail::all_props_are_keys_of< kernel_bundle<bundle_state::ext_oneapi_source>, PropertyListT>::value>>
kernel_bundle<bundle_state::executable> sycl::_V1::ext::oneapi::experimental::build ( kernel_bundle< bundle_state::ext_oneapi_source > &  SourceKB,
PropertyListT  props = {} 
)

Definition at line 910 of file kernel_bundle.hpp.

◆ combine_align()

size_t sycl::_V1::ext::oneapi::experimental::combine_align ( size_t  alignA,
size_t  alignB 
)
inline

Definition at line 238 of file alloc_util.hpp.

◆ command_graph()

template<graph_state State = graph_state::modifiable>
sycl::_V1::ext::oneapi::experimental::command_graph ( const context SyclContext,
const device SyclDevice,
const property_list PropList 
) -> command_graph< State >

◆ conj() [1/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits<_Tp>::_ComplexType sycl::_V1::ext::oneapi::experimental::conj ( _Tp  __re)

Definition at line 180 of file complex_math.hpp.

◆ conj() [2/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::conj ( const complex< _Tp > &  __c)

Definition at line 173 of file complex_math.hpp.

◆ copy() [1/2]

◆ copy() [2/2]

template<typename T >
void sycl::_V1::ext::oneapi::experimental::copy ( queue  Q,
const T *  Src,
T *  Dest,
size_t  Count,
const sycl::detail::code_location &  CodeLoc = sycl::detail::code_location::current() 
)

Definition at line 285 of file enqueue_functions.hpp.

References submit().

◆ cos()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::cos ( const complex< _Tp > &  __x)

Definition at line 581 of file complex_math.hpp.

References cosh().

◆ cosh()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::cosh ( const complex< _Tp > &  __x)

Definition at line 473 of file complex_math.hpp.

References sycl::_V1::ext::oneapi::fabs(), and sinh().

Referenced by cos(), sinh(), and tanh().

◆ create_image() [1/10]

sampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem memHandle,
const bindless_image_sampler sampler,
const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Create a sampled image and return the device image handle.

Parameters
memHandleDevice memory handle wrapper for allocated image memory
samplerbindless image sampler used to sample the image
descThe image descriptor
syclDeviceThe device in which we create our image handle
syclContextThe context in which we create our image handle
Returns
Image handle to created image object on the device

Definition at line 397 of file bindless_images.cpp.

References create_image(), sycl::_V1::ext::oneapi::experimental::image_mem::get_handle(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

◆ create_image() [2/10]

sampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem memHandle,
const bindless_image_sampler sampler,
const image_descriptor desc,
const sycl::queue syclQueue 
)

Create a sampled image and return the device image handle.

Parameters
memHandleDevice memory handle wrapper for allocated image memory
samplerbindless image sampler used to sample the image
descThe image descriptor
syclQueueThe queue in which we create our image handle
Returns
Image handle to created image object on the device

Definition at line 405 of file bindless_images.cpp.

References create_image(), sycl::_V1::queue::get_context(), sycl::_V1::queue::get_device(), sycl::_V1::ext::oneapi::experimental::image_mem::get_handle(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

◆ create_image() [3/10]

unsampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem memHandle,
const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Create an image and return the device image handle.

Parameters
memHandleDevice memory handle wrapper for allocated image memory
descThe image descriptor
syclDeviceThe device in which we created our image handle
syclContextThe context in which we create our image handle
Returns
Image handle to created image object on the device

Definition at line 336 of file bindless_images.cpp.

References sycl::_V1::ext::oneapi::experimental::image_mem::get_handle().

Referenced by create_image().

◆ create_image() [4/10]

unsampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem memHandle,
const image_descriptor desc,
const sycl::queue syclQueue 
)

Create an image and return the device image handle.

Parameters
memHandleDevice memory handle wrapper for allocated image memory
descThe image descriptor
syclqueueThe queue in which we created our image handle
Returns
Image handle to created image object on the device

Definition at line 342 of file bindless_images.cpp.

References create_image(), sycl::_V1::queue::get_context(), sycl::_V1::queue::get_device(), and sycl::_V1::ext::oneapi::experimental::image_mem::get_handle().

◆ create_image() [5/10]

sampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem_handle  memHandle,
const bindless_image_sampler sampler,
const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Create a sampled image and return the device image handle.

Parameters
memHandleDevice memory handle for allocated image memory
samplerbindless image sampler used to sample the image
descThe image descriptor
syclDeviceThe device in which we create our image handle
syclContextThe context in which we create our image handle
Returns
Image handle to created image object on the device

Definition at line 382 of file bindless_images.cpp.

References create_image(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

◆ create_image() [6/10]

sampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem_handle  memHandle,
const bindless_image_sampler sampler,
const image_descriptor desc,
const sycl::queue syclQueue 
)

Create a sampled image and return the device image handle.

Parameters
memHandleDevice memory handle for allocated image memory
samplerbindless image sampler used to sample the image
descThe image descriptor
syclQueueThe queue in which we create our image handle
Returns
Image handle to created image object on the device

Definition at line 390 of file bindless_images.cpp.

References create_image(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ create_image() [7/10]

unsampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem_handle  memHandle,
const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Create an image and return the device image handle.

Parameters
memHandleDevice memory handle for allocated image memory
descThe image descriptor
syclDeviceThe device in which we created our image handle
syclContextThe context in which we create our image handle
Returns
Image handle to created image object on the device

Definition at line 349 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), piextMemUnsampledImageCreate(), populate_pi_structs(), sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle, and sycl::_V1::ext::oneapi::experimental::image_descriptor::verify().

◆ create_image() [8/10]

unsampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( image_mem_handle  memHandle,
const image_descriptor desc,
const sycl::queue syclQueue 
)

Create an image and return the device image handle.

Parameters
memHandleDevice memory handle for allocated image memory
descThe image descriptor
syclQueueThe queue in which we created our image handle
Returns
Image handle to created image object on the device

Definition at line 375 of file bindless_images.cpp.

References create_image(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ create_image() [9/10]

sampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( void *  imgMem,
size_t  pitch,
const bindless_image_sampler sampler,
const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

◆ create_image() [10/10]

sampled_image_handle sycl::_V1::ext::oneapi::experimental::create_image ( void *  imgMem,
size_t  pitch,
const bindless_image_sampler sampler,
const image_descriptor desc,
const sycl::queue syclQueue 
)

Create a sampled image and return the device image handle.

Parameters
imgMemDevice memory pointer to allocated image memory
pitchThe allocation pitch value
samplerbindless image sampler used to sample the image
descThe image descriptor
syclQueueThe queue in which we create our image handle
Returns
Image handle to created image object on the device

Definition at line 462 of file bindless_images.cpp.

References create_image(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ create_kernel_bundle_from_source() [1/2]

source_kb sycl::_V1::ext::oneapi::experimental::create_kernel_bundle_from_source ( const context SyclContext,
source_language  Language,
const std::string &  Source 
)

◆ create_kernel_bundle_from_source() [2/2]

source_kb sycl::_V1::ext::oneapi::experimental::create_kernel_bundle_from_source ( const context SyclContext,
source_language  Language,
const std::vector< std::byte > &  Bytes 
)

◆ destroy_external_semaphore() [1/2]

void sycl::_V1::ext::oneapi::experimental::destroy_external_semaphore ( interop_semaphore_handle  semaphoreHandle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Destroy the external semaphore handle.

Parameters
semaphoreHandleThe interop semaphore handle to destroy
syclDeviceThe device in which the interop semaphore handle was created
syclContextThe context in which the interop semaphore handle was created

Definition at line 657 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), piextDestroyExternalSemaphore(), and sycl::_V1::ext::oneapi::experimental::interop_semaphore_handle::raw_handle.

Referenced by destroy_external_semaphore().

◆ destroy_external_semaphore() [2/2]

void sycl::_V1::ext::oneapi::experimental::destroy_external_semaphore ( interop_semaphore_handle  semaphoreHandle,
const sycl::queue syclQueue 
)

Destroy the external semaphore handle.

Parameters
semaphoreHandleThe interop semaphore handle to destroy
syclQueueThe queue in which the interop semaphore handle was created

Definition at line 674 of file bindless_images.cpp.

References destroy_external_semaphore(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ destroy_image_handle() [1/4]

void sycl::_V1::ext::oneapi::experimental::destroy_image_handle ( sampled_image_handle imageHandle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Destroy a sampled image handle.

Does not free memory backing the handle

Parameters
imageHandleThe sampled image handle to destroy
syclDeviceThe device in which we created our image handle
syclContextThe context in which we created our image handle

Definition at line 137 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), piextMemSampledImageHandleDestroy(), and sycl::_V1::ext::oneapi::experimental::sampled_image_handle::raw_handle.

◆ destroy_image_handle() [2/4]

void sycl::_V1::ext::oneapi::experimental::destroy_image_handle ( sampled_image_handle imageHandle,
const sycl::queue syclQueue 
)

Destroy a sampled image handle.

Does not free memory backing the handle

Parameters
imageHandleThe sampled image handle to destroy
syclQueueThe queue in which we created our image handle

Definition at line 154 of file bindless_images.cpp.

References destroy_image_handle(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ destroy_image_handle() [3/4]

void sycl::_V1::ext::oneapi::experimental::destroy_image_handle ( unsampled_image_handle imageHandle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Destroy an unsampled image handle.

Does not free memory backing the handle

Parameters
imageHandleThe unsampled image handle to destroy
syclDeviceThe device in which we created our image handle
syclContextThe context in which we created our image handle

Definition at line 114 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), piextMemUnsampledImageHandleDestroy(), and sycl::_V1::ext::oneapi::experimental::unsampled_image_handle::raw_handle.

Referenced by destroy_image_handle().

◆ destroy_image_handle() [4/4]

void sycl::_V1::ext::oneapi::experimental::destroy_image_handle ( unsampled_image_handle imageHandle,
const sycl::queue syclQueue 
)

Destroy an unsampled image handle.

Does not free memory backing the handle

Parameters
imageHandleThe unsampled image handle to destroy
syclQueueThe queue in which we created our image handle

Definition at line 131 of file bindless_images.cpp.

References destroy_image_handle(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ dynamic_address_cast()

template<access::address_space Space, access::decorated DecorateAddress, typename ElementType >
multi_ptr<ElementType, Space, DecorateAddress> sycl::_V1::ext::oneapi::experimental::dynamic_address_cast ( ElementType *  Ptr)

Definition at line 35 of file address_cast.hpp.

◆ dynamic_parameter()

template<typename ValueT >
sycl::_V1::ext::oneapi::experimental::dynamic_parameter ( experimental::command_graph< graph_state::modifiable Graph,
const ValueT &  Param 
) -> dynamic_parameter< ValueT >

Additional CTAD deduction guides.

◆ exp()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::exp ( const complex< _Tp > &  __x)

Definition at line 284 of file complex_math.hpp.

References sycl::_V1::ext::intel::math::copysign().

Referenced by pow().

◆ fabs() [1/3]

◆ fabs() [2/3]

template<typename T >
std::enable_if_t<std::is_same_v<T, bfloat16>, T> sycl::_V1::ext::oneapi::experimental::fabs ( x)

◆ fabs() [3/3]

template<typename T , int N = num_elements_v<T>>
std::enable_if_t<is_vec_or_swizzle_bf16_v<T>, sycl::vec<bfloat16, N> > sycl::_V1::ext::oneapi::experimental::fabs ( x)

Definition at line 122 of file bfloat16_math.hpp.

References fabs().

◆ fetch_cubemap()

template<typename DataT , typename HintT = DataT>
DataT sycl::_V1::ext::oneapi::experimental::fetch_cubemap ( const unsampled_image_handle imageHandle,
const int2 &  coords,
const unsigned int  face 
)

Fetch data from an unsampled cubemap image using its handle.

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
Parameters
imageHandleThe image handle
coordsThe coordinates at which to fetch image data (int2 only)
faceThe cubemap face at which to fetch
Returns
Image data

Definition at line 1349 of file bindless_images.hpp.

References coords.

◆ fetch_image() [1/2]

template<typename DataT , typename HintT = DataT, typename CoordT >
DataT sycl::_V1::ext::oneapi::experimental::fetch_image ( const sampled_image_handle &imageHandle]  [[maybe_unused],
const CoordT &coords [[maybe_unused] 
)

Fetch data from a sampled image using its handle.

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. int, int2, or int3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe image handle
coordsThe coordinates at which to fetch image data
Returns
Fetched image data

NVPTX: Name mangling info Cuda surfaces require integer coords (by bytes) Cuda textures require float coords (by element or normalized) for sampling, and integer coords (by bytes) for fetching The name mangling should therefore not interfere with one another

Definition at line 966 of file bindless_images.hpp.

References coords.

◆ fetch_image() [2/2]

template<typename DataT , typename HintT = DataT, typename CoordT >
DataT sycl::_V1::ext::oneapi::experimental::fetch_image ( const unsampled_image_handle &imageHandle]  [[maybe_unused],
const CoordT &coords [[maybe_unused] 
)

Fetch data from an unsampled image using its handle.

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. int, int2, or int3 for 1D, 2D, and 3D, respectively
Parameters
imageHandleThe image handle
coordsThe coordinates at which to fetch image data
Returns
Image data

NVPTX: Name mangling info Cuda surfaces require integer coords (by bytes) Cuda textures require float coords (by element or normalized) for sampling, and integer coords (by bytes) for fetching The name mangling should therefore not interfere with one another

Definition at line 882 of file bindless_images.hpp.

References coords.

◆ fetch_image_array()

template<typename DataT , typename HintT = DataT, typename CoordT >
DataT sycl::_V1::ext::oneapi::experimental::fetch_image_array ( const unsampled_image_handle &imageHandle]  [[maybe_unused],
const CoordT &coords [[maybe_unused],
const int arrayLayer]  [[maybe_unused] 
)

Fetch data from an unsampled image array using its handle.

Template Parameters
DataTThe return type
HintTA hint type that can be used to select for a specialized backend intrinsic when a user-defined type is passed as DataT. HintT should be a sycl::vec type, sycl::half type, or POD type. HintT must also have the same size as DataT.
CoordTThe input coordinate type. e.g. int or int2 for 1D or 2D, respectively
Parameters
imageHandleThe image handle
coordsThe coordinates at which to fetch image data
arrayLayerThe image array layer at which to fetch
Returns
Image data

NVPTX: Name mangling info Cuda surfaces require integer coords (by bytes) Cuda textures require float coords (by element or normalized) The name mangling should therefore not interfere with one another

Definition at line 1299 of file bindless_images.hpp.

References coords.

◆ fill() [1/2]

template<typename T >
void sycl::_V1::ext::oneapi::experimental::fill ( sycl::handler CGH,
T *  Ptr,
const T &  Pattern,
size_t  Count 
)

◆ fill() [2/2]

template<typename T >
void sycl::_V1::ext::oneapi::experimental::fill ( sycl::queue  Q,
T *  Ptr,
const T &  Pattern,
size_t  Count,
const sycl::detail::code_location &  CodeLoc = sycl::detail::code_location::current() 
)

Definition at line 307 of file enqueue_functions.hpp.

References submit().

◆ fma() [1/3]

◆ fma() [2/3]

template<typename T >
std::enable_if_t<std::is_same_v<T, bfloat16>, T> sycl::_V1::ext::oneapi::experimental::fma ( x,
y,
z 
)

◆ fma() [3/3]

template<typename T1 , typename T2 , typename T3 , int N1 = num_elements_v<T1>, int N2 = num_elements_v<T2>, int N3 = num_elements_v<T3>>
std::enable_if_t<is_vec_or_swizzle_bf16_v<T1> && is_vec_or_swizzle_bf16_v<T2> && is_vec_or_swizzle_bf16_v<T3> && N1 == N2 && N2 == N3, sycl::vec<bfloat16, N1> > sycl::_V1::ext::oneapi::experimental::fma ( T1  x,
T2  y,
T3  z 
)

Definition at line 329 of file bfloat16_math.hpp.

References fma().

◆ fmax() [1/3]

◆ fmax() [2/3]

template<typename T >
std::enable_if_t<std::is_same_v<T, bfloat16>, T> sycl::_V1::ext::oneapi::experimental::fmax ( x,
y 
)

◆ fmax() [3/3]

template<typename T1 , typename T2 , int N1 = num_elements_v<T1>, int N2 = num_elements_v<T2>>
std::enable_if_t<is_vec_or_swizzle_bf16_v<T1> && is_vec_or_swizzle_bf16_v<T2> && N1 == N2, sycl::vec<bfloat16, N1> > sycl::_V1::ext::oneapi::experimental::fmax ( T1  x,
T2  y 
)

Definition at line 267 of file bfloat16_math.hpp.

References fmax().

◆ fmin() [1/3]

◆ fmin() [2/3]

template<typename T >
std::enable_if_t<std::is_same_v<T, bfloat16>, T> sycl::_V1::ext::oneapi::experimental::fmin ( x,
y 
)

◆ fmin() [3/3]

template<typename T1 , typename T2 , int N1 = num_elements_v<T1>, int N2 = num_elements_v<T2>>
std::enable_if_t<is_vec_or_swizzle_bf16_v<T1> && is_vec_or_swizzle_bf16_v<T2> && N1 == N2, sycl::vec<bfloat16, N1> > sycl::_V1::ext::oneapi::experimental::fmin ( T1  x,
T2  y 
)

Definition at line 195 of file bfloat16_math.hpp.

References fmin().

◆ free() [1/2]

template<typename T , typename propList >
void sycl::_V1::ext::oneapi::experimental::free ( annotated_ptr< T, propList > &  ptr,
const context syclContext 
)

Definition at line 24 of file dealloc.hpp.

◆ free() [2/2]

template<typename T , typename propList >
void sycl::_V1::ext::oneapi::experimental::free ( annotated_ptr< T, propList > &  ptr,
const queue syclQueue 
)

Definition at line 29 of file dealloc.hpp.

◆ free_image_mem() [1/4]

void sycl::_V1::ext::oneapi::experimental::free_image_mem ( image_mem_handle  handle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

[Deprecated] Free image memory

Parameters
handleMemory handle to allocated memory on the device
syclDeviceThe device in which we create our memory handle
syclContextThe context in which we created our memory handle

Definition at line 295 of file bindless_images.cpp.

References standard.

Referenced by free_image_mem(), and sycl::_V1::ext::oneapi::experimental::detail::image_mem_impl::~image_mem_impl().

◆ free_image_mem() [2/4]

void sycl::_V1::ext::oneapi::experimental::free_image_mem ( image_mem_handle  handle,
const sycl::queue syclQueue 
)

[Deprecated] Free image memory

Parameters
handleMemory handle to allocated memory on the device
syclQueueThe queue in which we create our memory handle

Definition at line 303 of file bindless_images.cpp.

References free_image_mem().

◆ free_image_mem() [3/4]

void sycl::_V1::ext::oneapi::experimental::free_image_mem ( image_mem_handle  handle,
image_type  imageType,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Free image memory.

Parameters
handleMemory handle to allocated memory on the device
imageTypeType of image memory to be freed
syclDeviceThe device in which we create our memory handle
syclContextThe context in which we created our memory handle

Definition at line 256 of file bindless_images.cpp.

References array, cubemap, sycl::_V1::detail::getSyclObjImpl(), mipmap, piextMemImageFree(), piextMemMipmapFree(), sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle, and standard.

◆ free_image_mem() [4/4]

void sycl::_V1::ext::oneapi::experimental::free_image_mem ( image_mem_handle  handle,
image_type  imageType,
const sycl::queue syclQueue 
)

Free image memory.

Parameters
handleMemory handle to allocated memory on the device
imageTypeType of image memory to be freed
syclQueueThe queue in which we create our memory handle

Definition at line 286 of file bindless_images.cpp.

References free_image_mem(), sycl::_V1::queue::get_context(), and sycl::_V1::queue::get_device().

◆ free_mipmap_mem() [1/2]

void sycl::_V1::ext::oneapi::experimental::free_mipmap_mem ( image_mem_handle  handle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

[Deprecated] Free mipmap memory

Parameters
handleThe mipmap memory handle
syclDeviceThe device in which we created our memory handle
syclContextThe context in which we created our memory handle

Definition at line 310 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), and piextMemMipmapFree().

Referenced by free_mipmap_mem().

◆ free_mipmap_mem() [2/2]

void sycl::_V1::ext::oneapi::experimental::free_mipmap_mem ( image_mem_handle  handle,
const sycl::queue syclQueue 
)

[Deprecated] Free mipmap memory

Parameters
handleThe mipmap memory handle
syclQueueThe queue in which we created our memory handle

Definition at line 329 of file bindless_images.cpp.

References free_mipmap_mem().

◆ get()

◆ get_ballot_group()

template<typename Group >
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&std::is_same_v< Group, sycl::sub_group >, ballot_group< Group > > sycl::_V1::ext::oneapi::experimental::get_ballot_group ( Group  group,
bool  predicate 
)
inline

◆ get_composite_devices()

std::vector< device > sycl::_V1::ext::oneapi::experimental::get_composite_devices ( )

Definition at line 17 of file composite_device.cpp.

◆ get_fixed_size_group()

template<size_t PartitionSize, typename Group >
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&std::is_same_v< Group, sycl::sub_group >, fixed_size_group< PartitionSize, Group > > sycl::_V1::ext::oneapi::experimental::get_fixed_size_group ( Group  group)
inline

Definition at line 152 of file fixed_size_group.hpp.

◆ get_image_channel_type() [1/2]

sycl::image_channel_type sycl::_V1::ext::oneapi::experimental::get_image_channel_type ( const image_mem_handle  memHandle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Get the channel type that describes the image memory.

Parameters
memHandleMemory handle to allocated memory on the device
syclDeviceThe device in which we created our image memory handle
syclContextThe context in which we created our image memory handle
Returns
sycl image channel type that describes the image

Definition at line 712 of file bindless_images.cpp.

References sycl::_V1::detail::convertChannelType(), sycl::_V1::detail::getSyclObjImpl(), _pi_image_format::image_channel_data_type, PI_IMAGE_INFO_FORMAT, piextMemImageGetInfo(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

Referenced by get_image_channel_type().

◆ get_image_channel_type() [2/2]

sycl::image_channel_type sycl::_V1::ext::oneapi::experimental::get_image_channel_type ( const image_mem_handle  memHandle,
const sycl::queue syclQueue 
)

Get the channel type that describes the image memory.

Parameters
memHandleMemory handle to allocated memory on the device
syclQueueThe queue in which we created our image memory handle
Returns
sycl image channel type that describes the image

Definition at line 733 of file bindless_images.cpp.

References sycl::_V1::queue::get_context(), sycl::_V1::queue::get_device(), and get_image_channel_type().

◆ get_image_num_channels() [1/2]

unsigned int sycl::_V1::ext::oneapi::experimental::get_image_num_channels ( const image_mem_handle  memHandle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Get the number of channels that describes the image memory.

Parameters
memHandleMemory handle to allocated memory on the device
syclDeviceThe device in which we created our image memory handle
syclContextThe context in which we created our image memory handle
Returns
The number of channels describing the image

Definition at line 802 of file bindless_images.cpp.

References sycl::_V1::detail::convertChannelOrder(), sycl::_V1::detail::getImageNumberChannels(), sycl::_V1::detail::getSyclObjImpl(), _pi_image_format::image_channel_order, PI_IMAGE_INFO_FORMAT, piextMemImageGetInfo(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

Referenced by get_image_num_channels().

◆ get_image_num_channels() [2/2]

unsigned int sycl::_V1::ext::oneapi::experimental::get_image_num_channels ( const image_mem_handle  memHandle,
const sycl::queue syclQueue 
)

Get the number of channels that describes the image memory.

Parameters
memHandleMemory handle to allocated memory on the device
syclQueueThe queue in which we created our image memory handle
Returns
The number of channels describing the image

Definition at line 823 of file bindless_images.cpp.

References sycl::_V1::queue::get_context(), sycl::_V1::queue::get_device(), and get_image_num_channels().

◆ get_image_range() [1/2]

sycl::range< 3 > sycl::_V1::ext::oneapi::experimental::get_image_range ( const image_mem_handle  memHandle,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Get the range that describes the image's dimensions.

Parameters
memHandleMemory handle to allocated memory on the device
syclDeviceThe device in which we created our image memory handle
syclContextThe context in which we created our image memory handle
Returns
sycl range describing image's dimensions

Definition at line 680 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), PI_IMAGE_INFO_DEPTH, PI_IMAGE_INFO_HEIGHT, PI_IMAGE_INFO_WIDTH, piextMemImageGetInfo(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

Referenced by get_image_range().

◆ get_image_range() [2/2]

sycl::range< 3 > sycl::_V1::ext::oneapi::experimental::get_image_range ( const image_mem_handle  memHandle,
const sycl::queue syclQueue 
)

Get the range that describes the image's dimensions.

Parameters
memHandleMemory handle to allocated memory on the device
syclQueueThe queue in which we created our image memory handle
Returns
sycl range describing image's dimensions

Definition at line 705 of file bindless_images.cpp.

References sycl::_V1::queue::get_context(), sycl::_V1::queue::get_device(), and get_image_range().

◆ get_mip_level_mem_handle() [1/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::get_mip_level_mem_handle ( const image_mem_handle  mipMem,
const unsigned int  level,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Retrieve the memory handle to an individual mipmap image.

Parameters
mipMemThe memory handle to the mipmapped array
levelThe requested level of the mipmap
syclDeviceThe device in which we created our memory handle
syclContextThe context in which we created our memory handle
Returns
Memory handle to the individual mipmap image

Definition at line 228 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), level, piextMemMipmapGetLevel(), and sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle.

Referenced by get_mip_level_mem_handle(), and sycl::_V1::ext::oneapi::experimental::image_mem::get_mip_level_mem_handle().

◆ get_mip_level_mem_handle() [2/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::get_mip_level_mem_handle ( const image_mem_handle  mipMem,
const unsigned int  level,
const sycl::queue syclQueue 
)

Retrieve the memory handle to an individual mipmap image.

Parameters
mipMemThe memory handle to the mipmapped array
levelThe requested level of the mipmap
syclQueueThe queue in which we created our memory handle
Returns
Memory handle to the individual mipmap image

Definition at line 250 of file bindless_images.cpp.

References sycl::_V1::queue::get_context(), sycl::_V1::queue::get_device(), get_mip_level_mem_handle(), and level.

◆ get_property() [1/2]

template<typename PropertyT >
static constexpr auto sycl::_V1::ext::oneapi::experimental::get_property ( )
staticconstexpr

Definition at line 195 of file annotated_arg.hpp.

◆ get_property() [2/2]

template<typename PropertyT >
static constexpr auto sycl::_V1::ext::oneapi::experimental::get_property ( )
staticconstexpr

Definition at line 471 of file annotated_ptr.hpp.

◆ get_tangle_group()

template<typename Group >
std::enable_if_t< sycl::is_group_v< std::decay_t< Group > > &&std::is_same_v< Group, sycl::sub_group >, tangle_group< Group > > sycl::_V1::ext::oneapi::experimental::get_tangle_group ( Group  group)
inline

Definition at line 143 of file tangle_group.hpp.

References sycl::_V1::ext::oneapi::group_ballot().

◆ get_usm_property_list()

template<typename PropertyListT >
property_list sycl::_V1::ext::oneapi::experimental::get_usm_property_list ( )
inline

◆ group_load()

template<typename... Args>
void sycl::_V1::ext::oneapi::experimental::group_load ( Args...  )

Definition at line 393 of file group_load_store.hpp.

◆ group_store()

template<typename... Args>
void sycl::_V1::ext::oneapi::experimental::group_store ( Args...  )

Definition at line 398 of file group_load_store.hpp.

◆ has_property() [1/2]

template<typename PropertyT >
static constexpr bool sycl::_V1::ext::oneapi::experimental::has_property ( )
staticconstexpr

◆ has_property() [2/2]

template<typename PropertyT >
static constexpr bool sycl::_V1::ext::oneapi::experimental::has_property ( )
staticconstexpr

Definition at line 467 of file annotated_ptr.hpp.

◆ if() [1/2]

constexpr sycl::_V1::ext::oneapi::experimental::if ( detail::are_floating_coords< CoordT >  ())
constexpr

Definition at line 1074 of file bindless_images.hpp.

References coords.

◆ if() [2/2]

else constexpr sycl::_V1::ext::oneapi::experimental::if ( detail::are_integer_coords< CoordT >  ())
constexpr

Definition at line 1076 of file bindless_images.hpp.

◆ if_architecture_is()

template<architecture... Archs, typename T >
constexpr static auto sycl::_V1::ext::oneapi::experimental::if_architecture_is ( fn)
staticconstexpr

The condition is true only if the device which executes the if_architecture_is function has any one of the architectures listed in the.

The condition is true only if the device which executes the if_architecture_is function has an architecture that is in any one of the categories listed in the.

Template Parameters
Archspack.
Categoriespack.

Definition at line 1246 of file device_architecture.hpp.

◆ if_architecture_is_between()

template<architecture Arch1, architecture Arch2, typename T >
constexpr static auto sycl::_V1::ext::oneapi::experimental::if_architecture_is_between ( fn)
staticconstexpr

The condition is true only if the device which executes the if_architecture_is_between function has an architecture that is in the same family as.

Template Parameters
Arch1and is greater than or equal to
Arch1and is less than or equal to
Arch2.

Definition at line 1341 of file device_architecture.hpp.

References sycl::_V1::detail::device_arch_compare_op_ge, and sycl::_V1::detail::device_arch_compare_op_le.

◆ if_architecture_is_ge()

template<architecture Arch, typename T >
constexpr static auto sycl::_V1::ext::oneapi::experimental::if_architecture_is_ge ( fn)
staticconstexpr

The condition is true only if the device which executes the if_architecture_is_ge function has an architecture that is in the same family as.

Template Parameters
Archand compares greater than or equal to
Arch.

Definition at line 1325 of file device_architecture.hpp.

References sycl::_V1::detail::device_arch_compare_op_ge.

◆ if_architecture_is_gt()

template<architecture Arch, typename T >
constexpr static auto sycl::_V1::ext::oneapi::experimental::if_architecture_is_gt ( fn)
staticconstexpr

The condition is true only if the device which executes the if_architecture_is_gt function has an architecture that is in the same family as.

Template Parameters
Archand compares greater than
Arch.

Definition at line 1310 of file device_architecture.hpp.

References sycl::_V1::detail::device_arch_compare_op_gt.

◆ if_architecture_is_le()

template<architecture Arch, typename T >
constexpr static auto sycl::_V1::ext::oneapi::experimental::if_architecture_is_le ( fn)
staticconstexpr

The condition is true only if the device which executes the if_architecture_is_le function has an architecture that is in the same family as.

Template Parameters
Archand compares less than or equal to
Arch.

Definition at line 1295 of file device_architecture.hpp.

References sycl::_V1::detail::device_arch_compare_op_le.

◆ if_architecture_is_lt()

template<architecture Arch, typename T >
constexpr static auto sycl::_V1::ext::oneapi::experimental::if_architecture_is_lt ( fn)
staticconstexpr

The condition is true only if the device which executes the if_architecture_is_lt function has an architecture that is in the same family as.

Template Parameters
Archand compares less than
Arch.

Definition at line 1280 of file device_architecture.hpp.

References sycl::_V1::detail::device_arch_compare_op_lt.

◆ imag() [1/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL constexpr _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits<_Tp>::_ValueType sycl::_V1::ext::oneapi::experimental::imag ( _Tp  )
constexpr

Definition at line 623 of file complex_math.hpp.

◆ imag() [2/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL constexpr _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, _Tp> sycl::_V1::ext::oneapi::experimental::imag ( const complex< _Tp > &  __c)
constexpr

Definition at line 616 of file complex_math.hpp.

◆ import_external_memory() [1/2]

template<typename ExternalMemHandleType >
interop_mem_handle sycl::_V1::ext::oneapi::experimental::import_external_memory ( external_mem_descriptor< ExternalMemHandleType >  externalMem,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Import external memory taking an external memory handle (the type of which is dependent on the OS & external API) and return an interop memory handle.

Template Parameters
ExternalMemHandleTypeHandle type describing external memory handle
Parameters
externalMemExternal memory descriptor
syclDeviceThe device in which we create our interop memory
syclContextThe context in which we create our interop memory handle
Returns
Interop memory handle to the external memory

◆ import_external_memory() [2/2]

template<typename ExternalMemHandleType >
interop_mem_handle sycl::_V1::ext::oneapi::experimental::import_external_memory ( external_mem_descriptor< ExternalMemHandleType >  externalMem,
const sycl::queue syclQueue 
)

Import external memory taking an external memory handle (the type of which is dependent on the OS & external API) and return an interop memory handle.

Template Parameters
ExternalMemHandleTypeHandle type describing external memory handle
Parameters
externalMemExternal memory descriptor
syclQueueThe queue in which we create our interop memory handle
Returns
Interop memory handle to the external memory

◆ import_external_memory< external_mem_fd >() [1/2]

◆ import_external_memory< external_mem_fd >() [2/2]

◆ import_external_memory< resource_fd >() [1/2]

◆ import_external_memory< resource_fd >() [2/2]

◆ import_external_semaphore() [1/6]

template<>
interop_semaphore_handle sycl::_V1::ext::oneapi::experimental::import_external_semaphore ( external_semaphore_descriptor< external_semaphore_fd externalSemaphoreDesc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

◆ import_external_semaphore() [2/6]

template<>
interop_semaphore_handle sycl::_V1::ext::oneapi::experimental::import_external_semaphore ( external_semaphore_descriptor< external_semaphore_fd externalSemaphoreDesc,
const sycl::queue syclQueue 
)

Definition at line 649 of file bindless_images.cpp.

References import_external_semaphore().

◆ import_external_semaphore() [3/6]

template<typename ExternalSemaphoreHandleType >
interop_semaphore_handle sycl::_V1::ext::oneapi::experimental::import_external_semaphore ( external_semaphore_descriptor< ExternalSemaphoreHandleType >  externalSemaphoreDesc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Import external semaphore taking an external semaphore handle (the type of which is dependent on the OS & external API)

Template Parameters
ExternalSemaphoreHandleTypeHandle type describing external semaphore handle
Parameters
externalSemaphoreDescExternal semaphore descriptor
syclDeviceThe device in which we create our interop semaphore handle
syclContextThe context in which we create our interop semaphore handle
Returns
Interop semaphore handle to the external semaphore

Referenced by import_external_semaphore().

◆ import_external_semaphore() [4/6]

template<typename ExternalSemaphoreHandleType >
interop_semaphore_handle sycl::_V1::ext::oneapi::experimental::import_external_semaphore ( external_semaphore_descriptor< ExternalSemaphoreHandleType >  externalSemaphoreDesc,
const sycl::queue syclQueue 
)

Import external semaphore taking an external semaphore handle (the type of which is dependent on the OS & external API)

Template Parameters
ExternalSemaphoreHandleTypeHandle type describing external semaphore handle
Parameters
externalSemaphoreDescExternal semaphore descriptor
syclQueueThe queue in which we create our interop semaphore handle
Returns
Interop semaphore handle to the external semaphore

◆ import_external_semaphore() [5/6]

template<>
interop_semaphore_handle sycl::_V1::ext::oneapi::experimental::import_external_semaphore ( external_semaphore_descriptor< resource_fd externalSemaphoreDesc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

◆ import_external_semaphore() [6/6]

template<>
interop_semaphore_handle sycl::_V1::ext::oneapi::experimental::import_external_semaphore ( external_semaphore_descriptor< resource_fd externalSemaphoreDesc,
const sycl::queue syclQueue 
)

◆ is_source_kernel_bundle_supported()

bool sycl::_V1::ext::oneapi::experimental::is_source_kernel_bundle_supported ( backend  BE,
source_language  Language 
)

◆ isnan() [1/3]

template<size_t N>
sycl::marray<bool, N> sycl::_V1::ext::oneapi::experimental::isnan ( sycl::marray< bfloat16, N >  x)

Definition at line 53 of file bfloat16_math.hpp.

References isnan().

◆ isnan() [2/3]

◆ isnan() [3/3]

template<typename T , int N = num_elements_v<T>>
std::enable_if_t<is_vec_or_swizzle_bf16_v<T>, sycl::vec<int16_t, N> > sycl::_V1::ext::oneapi::experimental::isnan ( x)

Definition at line 64 of file bfloat16_math.hpp.

References isnan().

◆ joint_prefetch() [1/10]

template<typename Group , typename DataT , int Dimensions, access_mode AccessMode, access::placeholder IsPlaceholder, typename Properties = empty_properties_t, typename AccessorProperties = empty_properties_t>
std::enable_if_t<detail::check_prefetch_acc_mode<AccessMode> && (Dimensions > 0) && sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
accessor< DataT, Dimensions, AccessMode, target::device, IsPlaceholder, AccessorProperties >  acc,
size_t  offset,
Properties  properties = {} 
)

Definition at line 272 of file prefetch.hpp.

◆ joint_prefetch() [2/10]

template<typename Group , typename DataT , int Dimensions, access_mode AccessMode, access::placeholder IsPlaceholder, typename Properties = empty_properties_t, typename AccessorProperties = empty_properties_t>
std::enable_if_t<detail::check_prefetch_acc_mode<AccessMode> && (Dimensions > 0) && sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
accessor< DataT, Dimensions, AccessMode, target::device, IsPlaceholder, AccessorProperties >  acc,
size_t  offset,
size_t  count,
Properties  properties = {} 
)

Definition at line 287 of file prefetch.hpp.

◆ joint_prefetch() [3/10]

template<typename Group , typename T , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t<detail::check_prefetch_AS<AddressSpace> && sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
multi_ptr< T, AddressSpace, IsDecorated >  ptr,
Properties  properties = {} 
)

Definition at line 249 of file prefetch.hpp.

◆ joint_prefetch() [4/10]

template<typename Group , typename T , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t<detail::check_prefetch_AS<AddressSpace> && sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
multi_ptr< T, AddressSpace, IsDecorated >  ptr,
size_t  count,
Properties  properties = {} 
)

Definition at line 260 of file prefetch.hpp.

◆ joint_prefetch() [5/10]

template<typename Group , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t<detail::check_prefetch_AS<AddressSpace> && sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
multi_ptr< void, AddressSpace, IsDecorated >  ptr,
Properties  properties = {} 
)

Definition at line 227 of file prefetch.hpp.

◆ joint_prefetch() [6/10]

template<typename Group , access::address_space AddressSpace, access::decorated IsDecorated, typename Properties = empty_properties_t>
std::enable_if_t<detail::check_prefetch_AS<AddressSpace> && sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
multi_ptr< void, AddressSpace, IsDecorated >  ptr,
size_t  bytes,
Properties  properties = {} 
)

Definition at line 238 of file prefetch.hpp.

◆ joint_prefetch() [7/10]

template<typename Group , typename T , typename Properties = empty_properties_t>
std::enable_if_t<sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
T *  ptr,
Properties  properties = {} 
)

Definition at line 210 of file prefetch.hpp.

◆ joint_prefetch() [8/10]

template<typename Group , typename T , typename Properties = empty_properties_t>
std::enable_if_t<sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
T *  ptr,
size_t  count,
Properties  properties = {} 
)

Definition at line 217 of file prefetch.hpp.

◆ joint_prefetch() [9/10]

template<typename Group , typename Properties = empty_properties_t>
std::enable_if_t<sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
void *  ptr,
Properties  properties = {} 
)

Definition at line 196 of file prefetch.hpp.

◆ joint_prefetch() [10/10]

template<typename Group , typename Properties = empty_properties_t>
std::enable_if_t<sycl::is_group_v<std::decay_t<Group> > && is_property_list_v<std::decay_t<Properties> > > sycl::_V1::ext::oneapi::experimental::joint_prefetch ( Group  g,
void *  ptr,
size_t  bytes,
Properties  properties = {} 
)

Definition at line 203 of file prefetch.hpp.

◆ joint_reduce() [1/2]

template<typename GroupHelper , typename Ptr , typename BinaryOperation >
std::enable_if_t<(is_group_helper_v<GroupHelper> && sycl::detail::is_pointer_v<Ptr>), typename std::iterator_traits<Ptr>::value_type> sycl::_V1::ext::oneapi::experimental::joint_reduce ( GroupHelper  group_helper,
Ptr  first,
Ptr  last,
BinaryOperation  binary_op 
)

◆ joint_reduce() [2/2]

template<typename GroupHelper , typename Ptr , typename T , typename BinaryOperation >
std::enable_if_t< (is_group_helper_v<GroupHelper> && sycl::detail::is_pointer_v<Ptr>), T> sycl::_V1::ext::oneapi::experimental::joint_reduce ( GroupHelper  group_helper,
Ptr  first,
Ptr  last,
init,
BinaryOperation  binary_op 
)

Definition at line 123 of file user_defined_reductions.hpp.

References joint_reduce().

◆ joint_sort() [1/3]

template<typename Group , typename Iter , typename Sorter >
std::enable_if_t<detail::is_sorter<Sorter, Group, Iter>::value, void> sycl::_V1::ext::oneapi::experimental::joint_sort ( [[maybe_unused] ] Group  group,
[[maybe_unused] ] Iter  first,
[[maybe_unused] ] Iter  last,
[[maybe_unused] ] Sorter  sorter 
)

Definition at line 107 of file group_sort.hpp.

Referenced by joint_sort().

◆ joint_sort() [2/3]

template<typename Group , typename Iter , size_t Extent>
std::enable_if_t<sycl::is_group_v<std::decay_t<Group> >, void> sycl::_V1::ext::oneapi::experimental::joint_sort ( experimental::group_with_scratchpad< Group, Extent >  exec,
Iter  first,
Iter  last 
)

◆ joint_sort() [3/3]

template<typename Group , typename Iter , typename Compare , size_t Extent>
std::enable_if_t<!detail::is_sorter<Compare, Group, Iter>::value, void> sycl::_V1::ext::oneapi::experimental::joint_sort ( experimental::group_with_scratchpad< Group, Extent >  exec,
Iter  first,
Iter  last,
Compare  comp 
)

◆ log()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::log ( const complex< _Tp > &  __x)

Definition at line 247 of file complex_math.hpp.

References abs(), and arg().

Referenced by acos(), acosh(), asinh(), atanh(), log10(), and pow().

◆ log10()

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, complex<_Tp> > sycl::_V1::ext::oneapi::experimental::log10 ( const complex< _Tp > &  __x)

Definition at line 256 of file complex_math.hpp.

References log().

◆ malloc_annotated() [1/8]

template<typename T , typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  count,
const device syclDevice,
const context syclContext,
const propertyListA &  propList 
)

Definition at line 228 of file alloc_base.hpp.

◆ malloc_annotated() [2/8]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  count,
const device syclDevice,
const context syclContext,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 167 of file alloc_base.hpp.

◆ malloc_annotated() [3/8]

template<typename T , typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  count,
const queue syclQueue,
const propertyListA &  propList 
)

◆ malloc_annotated() [4/8]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  count,
const queue syclQueue,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 192 of file alloc_base.hpp.

◆ malloc_annotated() [5/8]

template<typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  numBytes,
const device syclDevice,
const context syclContext,
const propertyListA &  propList 
)

Definition at line 212 of file alloc_base.hpp.

References malloc_annotated().

◆ malloc_annotated() [6/8]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  numBytes,
const device syclDevice,
const context syclContext,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 154 of file alloc_base.hpp.

Referenced by malloc_annotated().

◆ malloc_annotated() [7/8]

template<typename propertyListA , typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  numBytes,
const queue syclQueue,
const propertyListA &  propList 
)

◆ malloc_annotated() [8/8]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename detail::GetCompileTimeProperties<propertyListA>::type>
std::enable_if_t< detail::CheckTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_annotated ( size_t  numBytes,
const queue syclQueue,
sycl::usm::alloc  kind,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 180 of file alloc_base.hpp.

◆ malloc_device_annotated() [1/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_device_annotated ( size_t  count,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 126 of file alloc_device.hpp.

◆ malloc_device_annotated() [2/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_device_annotated ( size_t  count,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 151 of file alloc_device.hpp.

◆ malloc_device_annotated() [3/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_device_annotated ( size_t  numBytes,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 113 of file alloc_device.hpp.

◆ malloc_device_annotated() [4/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedDevicePtrProperties<propertyListA>::type>
std::enable_if_t< CheckDevicePtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_device_annotated ( size_t  numBytes,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 139 of file alloc_device.hpp.

◆ malloc_host_annotated() [1/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_host_annotated ( size_t  count,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 119 of file alloc_host.hpp.

◆ malloc_host_annotated() [2/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_host_annotated ( size_t  count,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 141 of file alloc_host.hpp.

◆ malloc_host_annotated() [3/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_host_annotated ( size_t  numBytes,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 108 of file alloc_host.hpp.

◆ malloc_host_annotated() [4/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedHostPtrProperties<propertyListA>::type>
std::enable_if_t< CheckHostPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_host_annotated ( size_t  numBytes,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 130 of file alloc_host.hpp.

◆ malloc_shared_annotated() [1/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_shared_annotated ( size_t  count,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 126 of file alloc_shared.hpp.

◆ malloc_shared_annotated() [2/4]

template<typename T , typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<T, propertyListA, propertyListB>::value, annotated_ptr<T, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_shared_annotated ( size_t  count,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 151 of file alloc_shared.hpp.

◆ malloc_shared_annotated() [3/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_shared_annotated ( size_t  numBytes,
const device syclDevice,
const context syclContext,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 113 of file alloc_shared.hpp.

◆ malloc_shared_annotated() [4/4]

template<typename propertyListA = empty_properties_t, typename propertyListB = typename GetAnnotatedSharedPtrProperties<propertyListA>::type>
std::enable_if_t< CheckSharedPtrTAndPropLists<void, propertyListA, propertyListB>::value, annotated_ptr<void, propertyListB> > sycl::_V1::ext::oneapi::experimental::malloc_shared_annotated ( size_t  numBytes,
const queue syclQueue,
const propertyListA &  propList = propertyListA{} 
)

Definition at line 139 of file alloc_shared.hpp.

◆ map_external_image_memory() [1/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::map_external_image_memory ( interop_mem_handle  memHandle,
const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout)

Parameters
memHandleInterop memory handle
descThe image descriptor
syclDeviceThe device in which we create our image memory handle
syclContextThe conext in which we create our image memory handle
Returns
Memory handle to externally allocated memory on the device

Definition at line 524 of file bindless_images.cpp.

References sycl::_V1::detail::getSyclObjImpl(), piextMemMapExternalArray(), populate_pi_structs(), sycl::_V1::ext::oneapi::experimental::interop_mem_handle::raw_handle, sycl::_V1::ext::oneapi::experimental::image_mem_handle::raw_handle, and sycl::_V1::ext::oneapi::experimental::image_descriptor::verify().

Referenced by map_external_image_memory(), and map_external_memory_array().

◆ map_external_image_memory() [2/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::map_external_image_memory ( interop_mem_handle  memHandle,
const image_descriptor desc,
const sycl::queue syclQueue 
)

Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout)

Parameters
memHandleInterop memory handle
descThe image descriptor
syclQueueThe queue in which we create our image memory handle
Returns
Memory handle to externally allocated memory on the device

Definition at line 553 of file bindless_images.cpp.

References sycl::_V1::queue::get_context(), sycl::_V1::queue::get_device(), and map_external_image_memory().

◆ map_external_memory_array() [1/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::map_external_memory_array ( interop_mem_handle  memHandle,
const image_descriptor desc,
const sycl::device syclDevice,
const sycl::context syclContext 
)

[Deprecated] Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout)

Parameters
memHandleInterop memory handle
descThe image descriptor
syclDeviceThe device in which we create our image memory handle
syclContextThe conext in which we create our image memory handle
Returns
Memory handle to externally allocated memory on the device

Definition at line 562 of file bindless_images.cpp.

References map_external_image_memory().

Referenced by map_external_memory_array().

◆ map_external_memory_array() [2/2]

image_mem_handle sycl::_V1::ext::oneapi::experimental::map_external_memory_array ( interop_mem_handle  memHandle,
const image_descriptor desc,
const sycl::queue syclQueue 
)

[Deprecated] Maps an interop memory handle to an image memory handle (which may have a device optimized memory layout)

Parameters
memHandleInterop memory handle
descThe image descriptor
syclQueueThe queue in which we create our image memory handle
Returns
Memory handle to externally allocated memory on the device

Definition at line 571 of file bindless_images.cpp.

References map_external_memory_array().

◆ mem_advise() [1/2]

void sycl::_V1::ext::oneapi::experimental::mem_advise ( handler CGH,
void *  Ptr,
size_t  NumBytes,
int  Advice 
)
inline

Definition at line 323 of file enqueue_functions.hpp.

References sycl::_V1::handler::mem_advise().

Referenced by mem_advise().

◆ mem_advise() [2/2]

void sycl::_V1::ext::oneapi::experimental::mem_advise ( queue  Q,
void *  Ptr,
size_t  NumBytes,
int  Advice,
const sycl::detail::code_location &  CodeLoc = sycl::detail::code_location::current() 
)
inline

Definition at line 327 of file enqueue_functions.hpp.

References mem_advise(), and submit().

◆ memcpy() [1/2]

void sycl::_V1::ext::oneapi::experimental::memcpy ( handler CGH,
void *  Dest,
const void *  Src,
size_t  NumBytes 
)
inline

Definition at line 269 of file enqueue_functions.hpp.

References sycl::_V1::handler::memcpy().

Referenced by memcpy().

◆ memcpy() [2/2]

void sycl::_V1::ext::oneapi::experimental::memcpy ( queue  Q,
void *  Dest,
const void *  Src,
size_t  NumBytes,
const sycl::detail::code_location &  CodeLoc = sycl::detail::code_location::current() 
)
inline

Definition at line 273 of file enqueue_functions.hpp.

References memcpy(), and submit().

◆ memset() [1/2]

void sycl::_V1::ext::oneapi::experimental::memset ( handler CGH,
void *  Ptr,
int  Value,
size_t  NumBytes 
)
inline

Definition at line 291 of file enqueue_functions.hpp.

References sycl::_V1::handler::memset().

Referenced by memset().

◆ memset() [2/2]

void sycl::_V1::ext::oneapi::experimental::memset ( queue  Q,
void *  Ptr,
int  Value,
size_t  NumBytes,
const sycl::detail::code_location &  CodeLoc = sycl::detail::code_location::current() 
)
inline

Definition at line 295 of file enqueue_functions.hpp.

References memset(), and submit().

◆ nd_launch() [1/8]

template<int Dimensions, typename Properties , typename... ArgsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( handler CGH,
launch_config< nd_range< Dimensions >, Properties >  Config,
const kernel KernelObj,
ArgsT &&...  Args 
)

◆ nd_launch() [2/8]

template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename Properties , typename KernelType , typename... ReductionsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( handler CGH,
launch_config< nd_range< Dimensions >, Properties >  Config,
const KernelType &  KernelObj,
ReductionsT &&...  Reductions 
)

◆ nd_launch() [3/8]

template<int Dimensions, typename... ArgsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( handler CGH,
nd_range< Dimensions Range,
const kernel KernelObj,
ArgsT &&...  Args 
)

◆ nd_launch() [4/8]

template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename KernelType , typename... ReductionsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( handler CGH,
nd_range< Dimensions Range,
const KernelType &  KernelObj,
ReductionsT &&...  Reductions 
)

Definition at line 197 of file enqueue_functions.hpp.

References sycl::_V1::handler::parallel_for().

Referenced by nd_launch().

◆ nd_launch() [5/8]

template<int Dimensions, typename Properties , typename... ArgsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( queue  Q,
launch_config< nd_range< Dimensions >, Properties >  Config,
const kernel KernelObj,
ArgsT &&...  Args 
)

Definition at line 262 of file enqueue_functions.hpp.

References nd_launch(), and submit().

◆ nd_launch() [6/8]

template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename Properties , typename KernelType , typename... ReductionsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( queue  Q,
launch_config< nd_range< Dimensions >, Properties >  Config,
const KernelType &  KernelObj,
ReductionsT &&...  Reductions 
)

Definition at line 228 of file enqueue_functions.hpp.

References nd_launch(), and submit().

◆ nd_launch() [7/8]

template<int Dimensions, typename... ArgsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( queue  Q,
nd_range< Dimensions Range,
const kernel KernelObj,
ArgsT &&...  Args 
)

Definition at line 243 of file enqueue_functions.hpp.

References nd_launch(), and submit().

◆ nd_launch() [8/8]

template<typename KernelName = sycl::detail::auto_name, int Dimensions, typename KernelType , typename... ReductionsT>
void sycl::_V1::ext::oneapi::experimental::nd_launch ( queue  Q,
nd_range< Dimensions Range,
const KernelType &  KernelObj,
ReductionsT &&...  Reductions 
)

Definition at line 205 of file enqueue_functions.hpp.

References nd_launch(), and submit().

◆ norm() [1/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY cplx::detail::__libcpp_complex_overload_traits<_Tp>::_ValueType sycl::_V1::ext::oneapi::experimental::norm ( _Tp  __re)

Definition at line 161 of file complex_math.hpp.

◆ norm() [2/2]

template<class _Tp >
__DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY std::enable_if_t<is_genfloat<_Tp>::value, _Tp> sycl::_V1::ext::oneapi::experimental::norm ( const complex< _Tp > &  __c)

Definition at line 150 of file complex_math.hpp.

References sycl::_V1::ext::oneapi::fabs().

◆ operator bool()

sycl::_V1::ext::oneapi::experimental::operator bool ( ) const
explicitnoexcept

Definition at line 380 of file annotated_ptr.hpp.

References m_Ptr.

◆ operator T()

sycl::_V1::ext::oneapi::experimental::operator T ( )
noexcept

Definition at line 320 of file annotated_arg.hpp.

References obj.

◆ operator T*()

sycl::_V1::ext::oneapi::experimental::operator T* ( )
deletenoexcept

Definition at line 184 of file annotated_arg.hpp.

References obj.

◆ operator!=()

template<typename PropertyT , typename... A, typename... B>
constexpr std::enable_if_t<detail::IsCompileTimeProperty<PropertyT>::value, bool> sycl::_V1::ext::oneapi::experimental::operator!= ( const property_value< PropertyT, A... > &  ,
const property_value< PropertyT, B... > &   
)
constexpr

Definition at line 55 of file property_value.hpp.

◆ operator*()

reference sycl::_V1::ext::oneapi::experimental::operator* ( ) const
noexcept

Definition at line 374 of file annotated_ptr.hpp.

References m_Ptr.

◆ operator+() [1/2]

template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<!has_alignment>>
annotated_ptr sycl::_V1::ext::oneapi::experimental::operator+ ( size_t  offset) const
deletenoexcept

Definition at line 411 of file annotated_ptr.hpp.

References annotated_ptr, and m_Ptr.

◆ operator+() [2/2]

template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<has_alignment>>
auto sycl::_V1::ext::oneapi::experimental::operator+ ( size_t  offset) const -> decltype("operator+ is not available when alignment is specified!")=delete
deletenoexcept

Definition at line 411 of file annotated_ptr.hpp.

References annotated_ptr, and m_Ptr.

◆ operator++() [1/4]

template<bool has_alignment = detail::contains_alignment<Props...>::value, class = std::enable_if_t<!has_alignment>>
annotated_ptr& sycl::_V1::ext::oneapi::experimental::operator++ ( )