DPC++ Runtime
Runtime libraries for oneAPI DPC++
level_zero.hpp
Go to the documentation of this file.
1 //==--------- level_zero.hpp - SYCL Level-Zero backend ---------------------==//
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/backend.hpp>
12 
13 #include <vector>
14 
15 namespace sycl {
17 namespace ext::oneapi::level_zero {
18 // Implementation of various "make" functions resides in libsycl.so and thus
19 // their interface needs to be backend agnostic.
20 // TODO: remove/merge with similar functions in sycl::detail
21 __SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle);
22 __SYCL_EXPORT device make_device(const platform &Platform,
23  pi_native_handle NativeHandle);
24 __SYCL_EXPORT context make_context(const std::vector<device> &DeviceList,
25  pi_native_handle NativeHandle,
26  bool keep_ownership = false);
27 __SYCL_DEPRECATED("Use make_queue with device parameter")
28 __SYCL_EXPORT queue make_queue(const context &Context,
29  pi_native_handle InteropHandle,
30  bool keep_ownership = false);
31 __SYCL_EXPORT queue make_queue(const context &Context, const device &Device,
32  pi_native_handle InteropHandle,
33  bool keep_ownership = false);
34 __SYCL_EXPORT event make_event(const context &Context,
35  pi_native_handle InteropHandle,
36  bool keep_ownership = false);
37 
38 // Construction of SYCL platform.
39 template <typename T, typename sycl::detail::enable_if_t<
40  std::is_same<T, platform>::value> * = nullptr>
41 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_platform free function")
42 T make(typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
43  Interop) {
44  return make_platform(reinterpret_cast<pi_native_handle>(Interop));
45 }
46 
47 // Construction of SYCL device.
48 template <typename T, typename sycl::detail::enable_if_t<
49  std::is_same<T, device>::value> * = nullptr>
50 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_device free function")
51 T make(const platform &Platform,
52  typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
53  Interop) {
54  return make_device(Platform, reinterpret_cast<pi_native_handle>(Interop));
55 }
56 
66 template <typename T, typename std::enable_if<
67  std::is_same<T, context>::value>::type * = nullptr>
68 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_context free function")
69 T make(const std::vector<device> &DeviceList,
70  typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
71  Interop,
72  ownership Ownership = ownership::transfer) {
73  return make_context(DeviceList,
74  sycl::detail::pi::cast<pi_native_handle>(Interop),
75  Ownership == ownership::keep);
76 }
77 
78 // Construction of SYCL queue.
79 template <typename T, typename sycl::detail::enable_if_t<
80  std::is_same<T, queue>::value> * = nullptr>
81 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_queue free function")
82 T make(const context &Context,
83  typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
84  Interop,
85  ownership Ownership = ownership::transfer) {
86  return make_queue(Context, reinterpret_cast<pi_native_handle>(Interop),
87  Ownership == ownership::keep);
88 }
89 
90 // Construction of SYCL event.
91 template <typename T, typename sycl::detail::enable_if_t<
92  std::is_same<T, event>::value> * = nullptr>
93 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_event free function")
94 T make(const context &Context,
95  typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
96  Interop,
97  ownership Ownership = ownership::transfer) {
98  return make_event(Context, reinterpret_cast<pi_native_handle>(Interop),
99  Ownership == ownership::keep);
100 }
101 } // namespace ext::oneapi::level_zero
102 
103 // Specialization of sycl::make_context for Level-Zero backend.
104 template <>
105 inline context make_context<backend::ext_oneapi_level_zero>(
107  &BackendObject,
108  const async_handler &Handler) {
109  (void)Handler;
111  BackendObject.DeviceList,
112  detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
113  BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
114 }
115 
116 // Specialization of sycl::make_queue for Level-Zero backend.
117 template <>
118 inline queue make_queue<backend::ext_oneapi_level_zero>(
120  const context &TargetContext, const async_handler Handler) {
121  (void)Handler;
122  const device Device = device{BackendObject.Device};
124  TargetContext, Device,
125  detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
126  BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
127 }
128 
129 // Specialization of sycl::make_event for Level-Zero backend.
130 template <>
131 inline event make_event<backend::ext_oneapi_level_zero>(
133  const context &TargetContext) {
135  TargetContext,
136  detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
137  BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
138 }
139 
140 // Specialization of sycl::make_kernel_bundle for Level-Zero backend.
141 template <>
142 inline kernel_bundle<bundle_state::executable>
143 make_kernel_bundle<backend::ext_oneapi_level_zero, bundle_state::executable>(
144  const backend_input_t<backend::ext_oneapi_level_zero,
146  &BackendObject,
147  const context &TargetContext) {
148  std::shared_ptr<detail::kernel_bundle_impl> KBImpl =
150  detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
151  TargetContext,
152  BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep,
153  bundle_state::executable, backend::ext_oneapi_level_zero);
154  return detail::createSyclObjFromImpl<kernel_bundle<bundle_state::executable>>(
155  KBImpl);
156 }
157 
158 // Specialization of sycl::make_kernel for Level-Zero backend.
159 template <>
160 inline kernel make_kernel<backend::ext_oneapi_level_zero>(
162  &BackendObject,
163  const context &TargetContext) {
164  return detail::make_kernel(
165  TargetContext, BackendObject.KernelBundle,
166  detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
167  BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep,
168  backend::ext_oneapi_level_zero);
169 }
170 
171 // Specialization of sycl::make_buffer with event for Level-Zero backend.
172 template <backend Backend, typename T, int Dimensions = 1,
173  typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
174 typename std::enable_if<Backend == backend::ext_oneapi_level_zero,
175  buffer<T, Dimensions, AllocatorT>>::type
177  const backend_input_t<backend::ext_oneapi_level_zero,
178  buffer<T, Dimensions, AllocatorT>> &BackendObject,
179  const context &TargetContext, event AvailableEvent) {
180  return detail::make_buffer_helper<T, Dimensions, AllocatorT>(
181  detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
182  TargetContext, AvailableEvent,
183  !(BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep));
184 }
185 
186 // Specialization of sycl::make_buffer for Level-Zero backend.
187 template <backend Backend, typename T, int Dimensions = 1,
188  typename AllocatorT = buffer_allocator<std::remove_const_t<T>>>
189 typename std::enable_if<Backend == backend::ext_oneapi_level_zero,
190  buffer<T, Dimensions, AllocatorT>>::type
192  const backend_input_t<backend::ext_oneapi_level_zero,
193  buffer<T, Dimensions, AllocatorT>> &BackendObject,
194  const context &TargetContext) {
195  return detail::make_buffer_helper<T, Dimensions, AllocatorT>(
196  detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
197  TargetContext, event{},
198  !(BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep));
199 }
200 
201 namespace __SYCL2020_DEPRECATED("use 'ext::oneapi::level_zero' instead")
202  level_zero {
203 using namespace ext::oneapi::level_zero;
204 }
205 
206 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
207 } // namespace sycl
sycl::_V1::__SYCL2020_DEPRECATED
signed char __SYCL2020_DEPRECATED
Definition: aliases.hpp:96
sycl::_V1::instead
std::uint8_t instead
Definition: aliases.hpp:95
sycl::_V1::backend
backend
Definition: backend_types.hpp:21
T
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:220
__SYCL_INLINE_VER_NAMESPACE
#define __SYCL_INLINE_VER_NAMESPACE(X)
Definition: defines_elementary.hpp:11
sycl::_V1::buffer
Defines a shared array that can be used by kernels in queues.
Definition: buffer.hpp:37
sycl::_V1::ext::oneapi::level_zero::make
T make(const context &Context, typename sycl::detail::interop< backend::ext_oneapi_level_zero, T >::type Interop, ownership Ownership=ownership::transfer)
Definition: level_zero.hpp:82
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:2854
sycl
---— Error handling, matching OpenCL plugin semantics.
Definition: access.hpp:14
sycl::_V1::detail::make_kernel
kernel make_kernel(pi_native_handle NativeHandle, const context &TargetContext, backend Backend)
Definition: backend.cpp:267
sycl::_V1::event
An event object can be used to synchronize memory transfers, enqueues of kernels and signaling barrie...
Definition: event.hpp:40
__SYCL_DEPRECATED
#define __SYCL_DEPRECATED(message)
Definition: defines_elementary.hpp:46
sycl::_V1::detail::enable_if_t
typename std::enable_if< B, T >::type enable_if_t
Definition: stl_type_traits.hpp:24
sycl::_V1::kernel
Provides an abstraction of a SYCL kernel.
Definition: kernel.hpp:71
sycl::_V1::backend_input_t
typename backend_traits< Backend >::template input_type< SyclType > backend_input_t
Definition: backend.hpp:68
sycl::_V1::ext::oneapi::level_zero::make_context
context make_context(const std::vector< device > &DeviceList, pi_native_handle NativeHandle, bool keep_ownership=false)
Definition: level_zero.cpp:44
sycl::_V1::queue
Encapsulates a single SYCL queue which schedules kernels on a SYCL device.
Definition: queue.hpp:89
sycl::_V1::kernel_bundle< bundle_state::executable >
sycl::_V1::device
The SYCL device class encapsulates a single SYCL device on which kernels may be executed.
Definition: device.hpp:49
pi_native_handle
uintptr_t pi_native_handle
Definition: pi.h:133
sycl::_V1::ext::oneapi::level_zero::ownership
ownership
Definition: level_zero_ownership.hpp:21
sycl::_V1::ext::oneapi::level_zero::make_event
event make_event(const context &Context, pi_native_handle InteropHandle, bool keep_ownership=false)
Definition: level_zero.cpp:84
sycl::_V1::ext::oneapi::level_zero::make_platform
platform make_platform(pi_native_handle NativeHandle)
Definition: level_zero.cpp:23
std
Definition: accessor.hpp:3230
backend.hpp
sycl::_V1::async_handler
std::function< void(sycl::exception_list)> async_handler
Definition: exception_list.hpp:54
sycl::_V1::ext::oneapi::level_zero::make_device
device make_device(const platform &Platform, pi_native_handle NativeHandle)
Definition: level_zero.cpp:29
sycl::_V1::make_buffer
std::enable_if< Backend==backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT > >::type make_buffer(const backend_input_t< backend::ext_oneapi_level_zero, buffer< T, Dimensions, AllocatorT >> &BackendObject, const context &TargetContext)
Definition: level_zero.hpp:191
sycl::_V1::ext::oneapi::experimental::matrix::use
use
Definition: matrix-unified-utils.hpp:17
sycl::_V1::platform
Encapsulates a SYCL platform on which kernels may be executed.
Definition: platform.hpp:45
sycl::_V1::ext::oneapi::level_zero::make_queue
queue make_queue(const context &Context, const device &Device, pi_native_handle InteropHandle, bool keep_ownership=false)
Definition: level_zero.cpp:73
sycl::_V1::context
The context class represents a SYCL context on which kernel functions may be executed.
Definition: context.hpp:41