DPC++ Runtime
Runtime libraries for oneAPI DPC++
backend.hpp
Go to the documentation of this file.
1 //==---------------- backend.hpp - SYCL PI backends ------------------------==//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #pragma once
10 
11 #include <sycl/access/access.hpp> // for mode, placeholder
12 #include <sycl/accessor.hpp> // for accessor
13 #include <sycl/async_handler.hpp> // for async_handler
14 #include <sycl/backend_types.hpp> // for backend
15 #include <sycl/buffer.hpp> // for buffer_allocator
16 #include <sycl/context.hpp> // for context, get_na...
17 #include <sycl/detail/backend_traits.hpp> // for InteropFeatureS...
18 #include <sycl/detail/cl.h> // for _cl_event
19 #include <sycl/detail/defines_elementary.hpp> // for __SYCL_DEPRECATED
20 #include <sycl/detail/export.hpp> // for __SYCL_EXPORT
21 #include <sycl/detail/impl_utils.hpp> // for createSyclObjFr...
22 #include <sycl/detail/pi.h> // for pi_native_handle
23 #include <sycl/device.hpp> // for device, get_native
24 #include <sycl/event.hpp> // for event, get_native
25 #include <sycl/exception.hpp> // for make_error_code
26 #include <sycl/feature_test.hpp> // for SYCL_BACKEND_OP...
27 #include <sycl/handler.hpp> // for buffer
28 #include <sycl/image.hpp> // for image, image_al...
29 #include <sycl/kernel.hpp> // for kernel, get_native
30 #include <sycl/kernel_bundle.hpp> // for kernel_bundle
31 #include <sycl/kernel_bundle_enums.hpp> // for bundle_state
32 #include <sycl/platform.hpp> // for platform, get_n...
33 #include <sycl/property_list.hpp> // for property_list
34 #include <sycl/queue.hpp> // for queue, get_native
35 
36 #if SYCL_BACKEND_OPENCL
37 #include <sycl/detail/backend_traits_opencl.hpp> // for interop
38 #endif
39 #if SYCL_EXT_ONEAPI_BACKEND_CUDA
40 #ifdef SYCL_EXT_ONEAPI_BACKEND_CUDA_EXPERIMENTAL
42 #else
44 #endif
45 #endif
46 #if SYCL_EXT_ONEAPI_BACKEND_HIP
48 #endif
49 #if SYCL_EXT_ONEAPI_BACKEND_LEVEL_ZERO
50 #include <sycl/detail/backend_traits_level_zero.hpp> // for _ze_command_lis...
51 #endif
52 
53 #include <memory> // for shared_ptr
54 #include <stdint.h> // for int32_t
55 #include <type_traits> // for enable_if_t
56 #include <vector> // for vector
57 
58 namespace sycl {
59 inline namespace _V1 {
60 
61 namespace detail {
62 // TODO each backend can have its own custom errc enumeration
63 // but the details for this are not fully specified yet
64 enum class backend_errc : unsigned int {};
65 
66 // Convert from PI backend to SYCL backend enum
68 } // namespace detail
69 
70 template <backend Backend> class backend_traits {
71 public:
72  template <class T>
74 
75  template <class T>
77 
79 };
80 
81 template <backend Backend, typename SyclType>
82 using backend_input_t =
83  typename backend_traits<Backend>::template input_type<SyclType>;
84 
85 template <backend Backend, typename SyclType>
86 using backend_return_t =
87  typename backend_traits<Backend>::template return_type<SyclType>;
88 
89 namespace detail {
90 template <backend Backend, typename DataT, int Dimensions, typename AllocatorT>
91 struct BufferInterop {
92  using ReturnType =
94 
95  static ReturnType GetNativeObjs(const std::vector<pi_native_handle> &Handle) {
96  ReturnType ReturnValue = 0;
97  if (Handle.size()) {
98  ReturnValue = detail::pi::cast<ReturnType>(Handle[0]);
99  }
100  return ReturnValue;
101  }
102 };
103 
104 template <typename DataT, int Dimensions, typename AllocatorT>
105 struct BufferInterop<backend::opencl, DataT, Dimensions, AllocatorT> {
106  using ReturnType =
108 
109  static ReturnType GetNativeObjs(const std::vector<pi_native_handle> &Handle) {
110  ReturnType ReturnValue{};
111  for (auto &Obj : Handle) {
112  ReturnValue.push_back(
113  detail::pi::cast<typename decltype(ReturnValue)::value_type>(Obj));
114  }
115  return ReturnValue;
116  }
117 };
118 
119 #if SYCL_EXT_ONEAPI_BACKEND_LEVEL_ZERO
120 template <backend BackendName, typename DataT, int Dimensions,
121  typename AllocatorT>
123  -> backend_return_t<BackendName,
125  // No check for backend mismatch because buffer can be allocated on different
126  // backends
127  if (BackendName == backend::ext_oneapi_level_zero)
129  "Buffer interop is not supported by level zero yet");
130  return Obj.template getNative<BackendName>();
131 }
132 #endif
133 } // namespace detail
134 
135 template <backend BackendName, class SyclObjectT>
136 auto get_native(const SyclObjectT &Obj)
138  if (Obj.get_backend() != BackendName) {
140  "Backends mismatch");
141  }
142  return reinterpret_cast<backend_return_t<BackendName, SyclObjectT>>(
143  Obj.getNative());
144 }
145 
146 template <backend BackendName>
148  if (Obj.get_backend() != BackendName) {
150  "Backends mismatch");
151  }
152  int32_t IsImmCmdList;
153  pi_native_handle Handle = Obj.getNative(IsImmCmdList);
155  if constexpr (BackendName == backend::ext_oneapi_level_zero)
156  RetVal = IsImmCmdList
157  ? backend_return_t<BackendName, queue>{reinterpret_cast<
158  ze_command_list_handle_t>(Handle)}
160  reinterpret_cast<ze_command_queue_handle_t>(Handle)};
161  else
162  RetVal = reinterpret_cast<backend_return_t<BackendName, queue>>(Handle);
163 
164  return RetVal;
165 }
166 
167 template <backend BackendName, bundle_state State>
170  if (Obj.get_backend() != BackendName) {
172  "Backends mismatch");
173  }
174  return Obj.template getNative<BackendName>();
175 }
176 
177 template <backend BackendName, typename DataT, int Dimensions,
178  typename AllocatorT>
181  return detail::get_native_buffer<BackendName>(Obj);
182 }
183 
184 #if SYCL_BACKEND_OPENCL
185 template <>
187 get_native<backend::opencl, event>(const event &Obj) {
188  if (Obj.get_backend() != backend::opencl) {
190  "Backends mismatch");
191  }
192  backend_return_t<backend::opencl, event> ReturnValue;
193  for (auto const &element : Obj.getNativeVector()) {
194  ReturnValue.push_back(
195  reinterpret_cast<
197  element));
198  }
199  return ReturnValue;
200 }
201 #endif
202 
203 #if SYCL_EXT_ONEAPI_BACKEND_CUDA
204 template <>
205 inline backend_return_t<backend::ext_oneapi_cuda, device>
206 get_native<backend::ext_oneapi_cuda, device>(const device &Obj) {
207  if (Obj.get_backend() != backend::ext_oneapi_cuda) {
209  "Backends mismatch");
210  }
211  // CUDA uses a 32-bit int instead of an opaque pointer like other backends,
212  // so we need a specialization with static_cast instead of reinterpret_cast.
213  return static_cast<backend_return_t<backend::ext_oneapi_cuda, device>>(
214  Obj.getNative());
215 }
216 #endif
217 
218 template <backend BackendName, typename DataT, int Dimensions,
219  access::mode AccessMode, access::target AccessTarget,
221 auto get_native(const accessor<DataT, Dimensions, AccessMode, AccessTarget,
222  IsPlaceholder> &Obj) ->
223  typename detail::interop<
224  BackendName, accessor<DataT, Dimensions, AccessMode, AccessTarget,
225  IsPlaceholder>>::type = delete;
226 
227 namespace detail {
228 // Forward declaration
229 class kernel_bundle_impl;
230 
231 __SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle,
232  backend Backend);
233 __SYCL_EXPORT device make_device(pi_native_handle NativeHandle,
234  backend Backend);
235 __SYCL_EXPORT context make_context(pi_native_handle NativeHandle,
236  const async_handler &Handler,
237  backend Backend);
238 __SYCL_EXPORT queue make_queue(pi_native_handle NativeHandle,
239  int32_t nativeHandleDesc,
240  const context &TargetContext,
241  const device *TargetDevice, bool KeepOwnership,
242  const property_list &PropList,
243  const async_handler &Handler, backend Backend);
244 __SYCL_EXPORT event make_event(pi_native_handle NativeHandle,
245  const context &TargetContext, backend Backend);
246 __SYCL_EXPORT event make_event(pi_native_handle NativeHandle,
247  const context &TargetContext, bool KeepOwnership,
248  backend Backend);
249 // TODO: Unused. Remove when allowed.
250 __SYCL_EXPORT kernel make_kernel(pi_native_handle NativeHandle,
251  const context &TargetContext, backend Backend);
252 __SYCL_EXPORT kernel make_kernel(
253  const context &TargetContext,
254  const kernel_bundle<bundle_state::executable> &KernelBundle,
255  pi_native_handle NativeKernelHandle, bool KeepOwnership, backend Backend);
256 // TODO: Unused. Remove when allowed.
257 __SYCL_EXPORT std::shared_ptr<detail::kernel_bundle_impl>
258 make_kernel_bundle(pi_native_handle NativeHandle, const context &TargetContext,
259  bundle_state State, backend Backend);
260 __SYCL_EXPORT std::shared_ptr<detail::kernel_bundle_impl>
261 make_kernel_bundle(pi_native_handle NativeHandle, const context &TargetContext,
262  bool KeepOwnership, bundle_state State, backend Backend);
263 } // namespace detail
264 
265 template <backend Backend>
266 std::enable_if_t<
269  const typename backend_traits<Backend>::template input_type<platform>
270  &BackendObject) {
271  return detail::make_platform(
272  detail::pi::cast<pi_native_handle>(BackendObject), Backend);
273 }
274 
275 template <backend Backend>
276 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeDevice == true,
277  device>
278 make_device(const typename backend_traits<Backend>::template input_type<device>
279  &BackendObject) {
280  return detail::make_device(detail::pi::cast<pi_native_handle>(BackendObject),
281  Backend);
282 }
283 
284 template <backend Backend>
285 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeContext == true,
286  context>
288  const typename backend_traits<Backend>::template input_type<context>
289  &BackendObject,
290  const async_handler &Handler = {}) {
291  return detail::make_context(detail::pi::cast<pi_native_handle>(BackendObject),
292  Handler, Backend);
293 }
294 
295 template <backend Backend>
296 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeQueue == true,
297  queue>
298 make_queue(const typename backend_traits<Backend>::template input_type<queue>
299  &BackendObject,
300  const context &TargetContext, const async_handler Handler = {}) {
301  auto KeepOwnership =
302  Backend == backend::ext_oneapi_cuda || Backend == backend::ext_oneapi_hip;
303  return detail::make_queue(detail::pi::cast<pi_native_handle>(BackendObject),
304  false, TargetContext, nullptr, KeepOwnership, {},
305  Handler, Backend);
306 }
307 
308 template <backend Backend>
309 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeEvent == true,
310  event>
311 make_event(const typename backend_traits<Backend>::template input_type<event>
312  &BackendObject,
313  const context &TargetContext) {
314  return detail::make_event(detail::pi::cast<pi_native_handle>(BackendObject),
315  TargetContext, Backend);
316 }
317 
318 template <backend Backend>
319 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_event free function")
320 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeEvent == true,
321  event> make_event(const typename backend_traits<Backend>::
322  template input_type<event>
323  &BackendObject,
324  const context &TargetContext,
325  bool KeepOwnership) {
326  return detail::make_event(detail::pi::cast<pi_native_handle>(BackendObject),
327  TargetContext, KeepOwnership, Backend);
328 }
329 
330 template <backend Backend, typename T, int Dimensions = 1,
331  typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
332 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeBuffer ==
333  true &&
337  buffer<T, Dimensions, AllocatorT>> &BackendObject,
338  const context &TargetContext, event AvailableEvent = {}) {
339  return detail::make_buffer_helper<T, Dimensions, AllocatorT>(
340  detail::pi::cast<pi_native_handle>(BackendObject), TargetContext,
341  AvailableEvent);
342 }
343 
344 template <backend Backend, int Dimensions = 1,
345  typename AllocatorT = image_allocator>
346 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeImage == true &&
348  image<Dimensions, AllocatorT>>
350  image<Dimensions, AllocatorT>> &BackendObject,
351  const context &TargetContext, event AvailableEvent = {}) {
353  detail::pi::cast<pi_native_handle>(BackendObject), TargetContext,
354  AvailableEvent);
355 }
356 
357 template <backend Backend>
358 kernel
359 make_kernel(const typename backend_traits<Backend>::template input_type<kernel>
360  &BackendObject,
361  const context &TargetContext) {
362  return detail::make_kernel(detail::pi::cast<pi_native_handle>(BackendObject),
363  TargetContext, Backend);
364 }
365 
366 template <backend Backend, bundle_state State>
367 std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeKernelBundle ==
368  true,
371  kernel_bundle<State>> &BackendObject,
372  const context &TargetContext) {
373  std::shared_ptr<detail::kernel_bundle_impl> KBImpl =
375  detail::pi::cast<pi_native_handle>(BackendObject), TargetContext,
376  false, State, Backend);
377  return detail::createSyclObjFromImpl<kernel_bundle<State>>(KBImpl);
378 }
379 } // namespace _V1
380 } // namespace sycl
sycl::_V1::IsPlaceholder
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS IsPlaceholder
Definition: accessor.hpp:3216
sycl::_V1::errc::backend_mismatch
@ backend_mismatch
property_list.hpp
ze_command_list_handle_t
struct _ze_command_list_handle_t * ze_command_list_handle_t
Definition: backend_traits_level_zero.hpp:38
sycl::_V1::image
Defines a shared image data.
Definition: image.hpp:49
sycl::_V1::access::mode
mode
Definition: access.hpp:34
backend_traits_opencl.hpp
queue.hpp
pi.h
sycl::_V1::errc::platform
@ platform
_pi_platform_backend
_pi_platform_backend
Definition: pi.h:264
sycl::_V1::backend
backend
Definition: backend_types.hpp:18
sycl::_V1::make_queue
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeQueue==true, queue > make_queue(const typename backend_traits< Backend >::template input_type< queue > &BackendObject, const context &TargetContext, const async_handler Handler={})
Definition: backend.hpp:298
sycl::_V1::detail::backend_errc
backend_errc
Definition: backend.hpp:64
sycl::_V1::make_kernel
kernel make_kernel(const typename backend_traits< Backend >::template input_type< kernel > &BackendObject, const context &TargetContext)
Definition: backend.hpp:359
sycl::_V1::detail::make_kernel_bundle
std::shared_ptr< detail::kernel_bundle_impl > make_kernel_bundle(pi_native_handle NativeHandle, const context &TargetContext, bundle_state State, backend Backend)
Definition: backend.cpp:247
sycl::_V1::make_platform
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakePlatform==true, platform > make_platform(const typename backend_traits< Backend >::template input_type< platform > &BackendObject)
Definition: backend.hpp:268
sycl::_V1::detail::BufferInterop< backend::opencl, DataT, Dimensions, AllocatorT >::ReturnType
backend_return_t< backend::opencl, buffer< DataT, Dimensions, AllocatorT > > ReturnType
Definition: backend.hpp:107
sycl::_V1::make_error_code
std::error_code make_error_code(sycl::errc E) noexcept
Constructs an error code using e and sycl_category()
Definition: exception.cpp:94
sycl::_V1::backend::ext_oneapi_level_zero
@ ext_oneapi_level_zero
sycl::_V1::errc::feature_not_supported
@ feature_not_supported
sycl::_V1::buffer
Defines a shared array that can be used by kernels in queues.
Definition: buffer.hpp:60
sycl::_V1::detail::BufferInterop
Definition: backend.hpp:91
ze_command_queue_handle_t
struct _ze_command_queue_handle_t * ze_command_queue_handle_t
Definition: backend_traits_level_zero.hpp:37
sycl::_V1::detail::convertBackend
backend convertBackend(pi_platform_backend PiBackend)
Definition: backend.cpp:49
event.hpp
sycl::_V1::detail::make_queue
queue make_queue(pi_native_handle NativeHandle, int32_t nativeHandleDesc, const context &TargetContext, const device *TargetDevice, bool KeepOwnership, const property_list &PropList, const async_handler &Handler, backend Backend)
Definition: backend.cpp:107
sycl::_V1::detail::interop< backend::opencl, event >::value_type
cl_event value_type
Definition: backend_traits_opencl.hpp:85
sycl::_V1::detail::get_native_buffer
auto get_native_buffer(const buffer< DataT, Dimensions, Allocator, void > &Obj) -> backend_return_t< BackendName, buffer< DataT, Dimensions, Allocator, void >>
sycl::_V1::backend::ext_oneapi_hip
@ ext_oneapi_hip
detail
---— Error handling, matching OpenCL plugin semantics.
Definition: common.hpp:44
sycl::_V1::backend_traits
Definition: backend.hpp:70
sycl::_V1::Dimensions
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS Dimensions
Definition: accessor.hpp:3215
sycl
Definition: access.hpp:18
sycl::_V1::detail::BufferInterop::ReturnType
backend_return_t< Backend, buffer< DataT, Dimensions, AllocatorT > > ReturnType
Definition: backend.hpp:93
sycl::_V1::accessor
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor accessor(buffer< DataT, Dimensions, AllocatorT >) -> accessor< DataT, Dimensions, access::mode::read_write, target::device, access::placeholder::true_t >
Buffer accessor.
sycl::_V1::detail::make_kernel
kernel make_kernel(pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
Definition: backend.cpp:295
sycl::_V1::event
An event object can be used to synchronize memory transfers, enqueues of kernels and signaling barrie...
Definition: event.hpp:44
access.hpp
backend_traits.hpp
sycl::_V1::detail::BackendInput
Definition: backend_traits.hpp:19
sycl::_V1::backend::ext_oneapi_cuda
@ ext_oneapi_cuda
__SYCL_DEPRECATED
#define __SYCL_DEPRECATED(message)
Definition: defines_elementary.hpp:44
sycl::_V1::backend_input_t
typename backend_traits< Backend >::template input_type< SyclType > backend_input_t
Definition: backend.hpp:83
backend_traits_level_zero.hpp
export.hpp
sycl::_V1::access::placeholder
placeholder
Definition: access.hpp:49
defines_elementary.hpp
sycl::_V1::make_context
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeContext==true, context > make_context(const typename backend_traits< Backend >::template input_type< context > &BackendObject, const async_handler &Handler={})
Definition: backend.hpp:287
sycl::_V1::make_device
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeDevice==true, device > make_device(const typename backend_traits< Backend >::template input_type< device > &BackendObject)
Definition: backend.hpp:278
kernel_bundle.hpp
backend_traits_cuda.hpp
cl.h
sycl::_V1::queue
Encapsulates a single SYCL queue which schedules kernels on a SYCL device.
Definition: queue.hpp:119
kernel_bundle_enums.hpp
sycl::_V1::event::get_backend
backend get_backend() const noexcept
Returns the backend associated with this platform.
Definition: event.cpp:105
sycl::_V1::exception
Definition: exception.hpp:68
sycl::_V1::kernel_bundle
The kernel_bundle class represents collection of device images in a particular state.
Definition: kernel.hpp:32
sycl::_V1::make_buffer
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeBuffer==true &&Backend !=backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT > > make_buffer(const typename backend_traits< Backend >::template input_type< buffer< T, Dimensions, AllocatorT >> &BackendObject, const context &TargetContext, event AvailableEvent={})
Definition: backend.hpp:336
sycl::_V1::backend_return_t
typename backend_traits< Backend >::template return_type< SyclType > backend_return_t
Definition: backend.hpp:87
sycl::_V1::image_allocator
detail::aligned_allocator< byte > image_allocator
Definition: image.hpp:110
sycl::_V1::detail::make_platform
platform make_platform(pi_native_handle NativeHandle, backend Backend)
Definition: backend.cpp:70
sycl::_V1::device
The SYCL device class encapsulates a single SYCL device on which kernels may be executed.
Definition: device.hpp:59
device.hpp
backend_traits_hip.hpp
sycl::_V1::access::target
target
Definition: access.hpp:22
sycl::_V1::access::target::device
@ device
sycl::_V1::detail::InteropFeatureSupportMap::MakePlatform
static constexpr bool MakePlatform
Definition: backend_traits.hpp:24
sycl::_V1::detail::BufferInterop< backend::opencl, DataT, Dimensions, AllocatorT >::GetNativeObjs
static ReturnType GetNativeObjs(const std::vector< pi_native_handle > &Handle)
Definition: backend.hpp:109
sycl::_V1::detail::pi::cast
PiProgram cast(cl_program)=delete
pi_native_handle
uintptr_t pi_native_handle
Definition: pi.h:198
accessor.hpp
sycl::_V1::detail::BackendReturn
Definition: backend_traits.hpp:21
sycl::_V1::backend::opencl
@ opencl
sycl::_V1::make_kernel_bundle
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeKernelBundle==true, kernel_bundle< State > > make_kernel_bundle(const typename backend_traits< Backend >::template input_type< kernel_bundle< State >> &BackendObject, const context &TargetContext)
Definition: backend.hpp:370
sycl::_V1::detail::make_context
context make_context(pi_native_handle NativeHandle, const async_handler &Handler, backend Backend)
Definition: backend.cpp:94
backend_types.hpp
handler.hpp
exception.hpp
std
Definition: accessor.hpp:4139
sycl::_V1::backend_traits::input_type
typename detail::BackendInput< Backend, T >::type input_type
Definition: backend.hpp:73
image.hpp
sycl::_V1::detail::BufferInterop::GetNativeObjs
static ReturnType GetNativeObjs(const std::vector< pi_native_handle > &Handle)
Definition: backend.hpp:95
sycl::_V1::make_event
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeEvent==true, event > make_event(const typename backend_traits< Backend >::template input_type< event > &BackendObject, const context &TargetContext)
Definition: backend.hpp:311
sycl::_V1::async_handler
std::function< void(sycl::exception_list)> async_handler
Definition: async_handler.hpp:19
context.hpp
sycl::_V1::detail::make_device
device make_device(pi_native_handle NativeHandle, backend Backend)
Definition: backend.cpp:82
platform.hpp
buffer.hpp
backend_traits_cuda.hpp
sycl::_V1::bundle_state
bundle_state
Definition: kernel_bundle_enums.hpp:14
sycl::_V1::make_image
std::enable_if_t< detail::InteropFeatureSupportMap< Backend >::MakeImage==true &&Backend !=backend::ext_oneapi_level_zero, image< Dimensions, AllocatorT > > make_image(const typename backend_traits< Backend >::template input_type< image< Dimensions, AllocatorT >> &BackendObject, const context &TargetContext, event AvailableEvent={})
Definition: backend.hpp:349
sycl::_V1::buffer_allocator
detail::sycl_memory_object_allocator< DataT > buffer_allocator
Definition: buffer.hpp:54
sycl::_V1::AccessMode
class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor class __SYCL_EBO __SYCL_SPECIAL_CLASS AccessMode
Definition: accessor.hpp:3215
sycl::_V1::detail::make_event
event make_event(pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
Definition: backend.cpp:141
kernel.hpp
sycl::_V1::errc::kernel
@ kernel
async_handler.hpp
sycl::_V1::get_native
auto get_native(const SyclObjectT &Obj) -> backend_return_t< BackendName, SyclObjectT >
Definition: backend.hpp:136
sycl::_V1::backend_traits::return_type
typename detail::BackendReturn< Backend, T >::type return_type
Definition: backend.hpp:76
sycl::_V1::context
The context class represents a SYCL context on which kernel functions may be executed.
Definition: context.hpp:51
impl_utils.hpp