DPC++ Runtime
Runtime libraries for oneAPI DPC++
usm.hpp
Go to the documentation of this file.
1 //==---------------- usm.hpp - SYCL USM ------------------------*- C++ -*---==//
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 #pragma once
9 
10 #include <sycl/detail/common.hpp>
11 #include <sycl/detail/export.hpp>
14 #include <sycl/usm/usm_enums.hpp>
15 
16 #include <cstddef>
17 
18 namespace sycl {
21 // Explicit USM
23 __SYCL_EXPORT void *malloc_device(size_t size, const device &dev,
24  const context &ctxt _CODELOCPARAM(&CodeLoc));
25 __SYCL_EXPORT void *
26 malloc_device(size_t size, const device &dev, const context &ctxt,
27  const property_list &propList _CODELOCPARAM(&CodeLoc));
28 __SYCL_EXPORT void *malloc_device(size_t size,
29  const queue &q _CODELOCPARAM(&CodeLoc));
30 __SYCL_EXPORT void *
31 malloc_device(size_t size, const queue &q,
32  const property_list &propList _CODELOCPARAM(&CodeLoc));
33 
34 __SYCL_EXPORT void *
35 aligned_alloc_device(size_t alignment, size_t size, const device &dev,
36  const context &ctxt _CODELOCPARAM(&CodeLoc));
37 __SYCL_EXPORT void *
38 aligned_alloc_device(size_t alignment, size_t size, const device &dev,
39  const context &ctxt,
40  const property_list &propList _CODELOCPARAM(&CodeLoc));
41 __SYCL_EXPORT void *
42 aligned_alloc_device(size_t alignment, size_t size,
43  const queue &q _CODELOCPARAM(&CodeLoc));
44 __SYCL_EXPORT void *
45 aligned_alloc_device(size_t alignment, size_t size, const queue &q,
46  const property_list &propList _CODELOCPARAM(&CodeLoc));
47 
48 __SYCL_EXPORT void free(void *ptr, const context &ctxt _CODELOCPARAM(&CodeLoc));
49 __SYCL_EXPORT void free(void *ptr, const queue &q _CODELOCPARAM(&CodeLoc));
50 
52 // Restricted USM
54 __SYCL_EXPORT void *malloc_host(size_t size,
55  const context &ctxt _CODELOCPARAM(&CodeLoc));
56 __SYCL_EXPORT void *
57 malloc_host(size_t size, const context &ctxt,
58  const property_list &propList _CODELOCPARAM(&CodeLoc));
59 __SYCL_EXPORT void *malloc_host(size_t size,
60  const queue &q _CODELOCPARAM(&CodeLoc));
61 __SYCL_EXPORT void *
62 malloc_host(size_t size, const queue &q,
63  const property_list &propList _CODELOCPARAM(&CodeLoc));
64 
65 __SYCL_EXPORT void *malloc_shared(size_t size, const device &dev,
66  const context &ctxt _CODELOCPARAM(&CodeLoc));
67 __SYCL_EXPORT void *
68 malloc_shared(size_t size, const device &dev, const context &ctxt,
69  const property_list &propList _CODELOCPARAM(&CodeLoc));
70 __SYCL_EXPORT void *malloc_shared(size_t size,
71  const queue &q _CODELOCPARAM(&CodeLoc));
72 __SYCL_EXPORT void *
73 malloc_shared(size_t size, const queue &q,
74  const property_list &propList _CODELOCPARAM(&CodeLoc));
75 
76 __SYCL_EXPORT void *
77 aligned_alloc_host(size_t alignment, size_t size,
78  const context &ctxt _CODELOCPARAM(&CodeLoc));
79 __SYCL_EXPORT void *
80 aligned_alloc_host(size_t alignment, size_t size, const context &ctxt,
81  const property_list &propList _CODELOCPARAM(&CodeLoc));
82 __SYCL_EXPORT void *aligned_alloc_host(size_t alignment, size_t size,
83  const queue &q _CODELOCPARAM(&CodeLoc));
84 __SYCL_EXPORT void *
85 aligned_alloc_host(size_t alignment, size_t size, const queue &q,
86  const property_list &propList _CODELOCPARAM(&CodeLoc));
87 
88 __SYCL_EXPORT void *
89 aligned_alloc_shared(size_t alignment, size_t size, const device &dev,
90  const context &ctxt _CODELOCPARAM(&CodeLoc));
91 __SYCL_EXPORT void *
92 aligned_alloc_shared(size_t alignment, size_t size, const device &dev,
93  const context &ctxt,
94  const property_list &propList _CODELOCPARAM(&CodeLoc));
95 __SYCL_EXPORT void *
96 aligned_alloc_shared(size_t alignment, size_t size,
97  const queue &q _CODELOCPARAM(&CodeLoc));
98 __SYCL_EXPORT void *
99 aligned_alloc_shared(size_t alignment, size_t size, const queue &q,
100  const property_list &propList _CODELOCPARAM(&CodeLoc));
101 
103 // single form
105 __SYCL_EXPORT void *malloc(size_t size, const device &dev, const context &ctxt,
106  usm::alloc kind _CODELOCPARAM(&CodeLoc));
107 __SYCL_EXPORT void *
108 malloc(size_t size, const device &dev, const context &ctxt, usm::alloc kind,
109  const property_list &propList _CODELOCPARAM(&CodeLoc));
110 __SYCL_EXPORT void *malloc(size_t size, const queue &q,
111  usm::alloc kind _CODELOCPARAM(&CodeLoc));
112 __SYCL_EXPORT void *
113 malloc(size_t size, const queue &q, usm::alloc kind,
114  const property_list &propList _CODELOCPARAM(&CodeLoc));
115 
116 __SYCL_EXPORT void *aligned_alloc(size_t alignment, size_t size,
117  const device &dev, const context &ctxt,
118  usm::alloc kind _CODELOCPARAM(&CodeLoc));
119 __SYCL_EXPORT void *
120 aligned_alloc(size_t alignment, size_t size, const device &dev,
121  const context &ctxt, usm::alloc kind,
122  const property_list &propList _CODELOCPARAM(&CodeLoc));
123 __SYCL_EXPORT void *aligned_alloc(size_t alignment, size_t size, const queue &q,
124  usm::alloc kind _CODELOCPARAM(&CodeLoc));
125 __SYCL_EXPORT void *
126 aligned_alloc(size_t alignment, size_t size, const queue &q, usm::alloc kind,
127  const property_list &propList _CODELOCPARAM(&CodeLoc));
128 
130 // Template forms
132 template <typename T>
134  size_t Count, const device &Dev, const context &Ctxt,
135  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
136  _CODELOCARG(&CodeLoc);
137  return static_cast<T *>(aligned_alloc_device(alignof(T), Count * sizeof(T),
138  Dev, Ctxt, PropList, CodeLoc));
139 }
140 
141 template <typename T>
143  size_t Count, const queue &Q,
144  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
145  _CODELOCARG(&CodeLoc);
146  return malloc_device<T>(Count, Q.get_device(), Q.get_context(), PropList,
147  CodeLoc);
148 }
149 
150 template <typename T>
152  size_t Alignment, size_t Count, const device &Dev, const context &Ctxt,
153  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
154  _CODELOCARG(&CodeLoc);
155  return static_cast<T *>(aligned_alloc_device(max(Alignment, alignof(T)),
156  Count * sizeof(T), Dev, Ctxt,
157  PropList, CodeLoc));
158 }
159 
160 template <typename T>
162  size_t Alignment, size_t Count, const queue &Q,
163  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
164  _CODELOCARG(&CodeLoc);
165  return aligned_alloc_device<T>(Alignment, Count, Q.get_device(),
166  Q.get_context(), PropList, CodeLoc);
167 }
168 
169 template <typename T>
171  size_t Count, const context &Ctxt,
172  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
173  _CODELOCARG(&CodeLoc);
174  return static_cast<T *>(aligned_alloc_host(alignof(T), Count * sizeof(T),
175  Ctxt, PropList, CodeLoc));
176 }
177 
178 template <typename T>
180  size_t Count, const queue &Q,
181  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
182  _CODELOCARG(&CodeLoc);
183  return malloc_host<T>(Count, Q.get_context(), PropList, CodeLoc);
184 }
185 
186 template <typename T>
188  size_t Count, const device &Dev, const context &Ctxt,
189  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
190  _CODELOCARG(&CodeLoc);
191  return static_cast<T *>(aligned_alloc_shared(alignof(T), Count * sizeof(T),
192  Dev, Ctxt, PropList, CodeLoc));
193 }
194 
195 template <typename T>
197  size_t Count, const queue &Q,
198  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
199  _CODELOCARG(&CodeLoc);
200  return malloc_shared<T>(Count, Q.get_device(), Q.get_context(), PropList,
201  CodeLoc);
202 }
203 
204 template <typename T>
206  size_t Alignment, size_t Count, const context &Ctxt,
207  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
208  _CODELOCARG(&CodeLoc);
209  return static_cast<T *>(aligned_alloc_host(std ::max(Alignment, alignof(T)),
210  Count * sizeof(T), Ctxt, PropList,
211  CodeLoc));
212 }
213 
214 template <typename T>
216  size_t Alignment, size_t Count, const queue &Q,
217  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
218  _CODELOCARG(&CodeLoc);
219  return aligned_alloc_host<T>(Alignment, Count, Q.get_context(), PropList,
220  CodeLoc);
221 }
222 
223 template <typename T>
225  size_t Alignment, size_t Count, const device &Dev, const context &Ctxt,
226  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
227  _CODELOCARG(&CodeLoc);
228  return static_cast<T *>(aligned_alloc_shared(max(Alignment, alignof(T)),
229  Count * sizeof(T), Dev, Ctxt,
230  PropList, CodeLoc));
231 }
232 
233 template <typename T>
235  size_t Alignment, size_t Count, const queue &Q,
236  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
237  _CODELOCARG(&CodeLoc);
238  return aligned_alloc_shared<T>(Alignment, Count, Q.get_device(),
239  Q.get_context(), PropList, CodeLoc);
240 }
241 
242 template <typename T>
244  size_t Count, const device &Dev, const context &Ctxt, usm::alloc Kind,
245  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
246  _CODELOCARG(&CodeLoc);
247  return static_cast<T *>(aligned_alloc(alignof(T), Count * sizeof(T), Dev,
248  Ctxt, Kind, PropList, CodeLoc));
249 }
250 
251 template <typename T>
253  size_t Count, const queue &Q, usm::alloc Kind,
254  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
255  _CODELOCARG(&CodeLoc);
256  return malloc<T>(Count, Q.get_device(), Q.get_context(), Kind, PropList,
257  CodeLoc);
258 }
259 
260 template <typename T>
262  size_t Alignment, size_t Count, const device &Dev, const context &Ctxt,
263  usm::alloc Kind,
264  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
265  _CODELOCARG(&CodeLoc);
266  return static_cast<T *>(aligned_alloc(max(Alignment, alignof(T)),
267  Count * sizeof(T), Dev, Ctxt, Kind,
268  PropList, CodeLoc));
269 }
270 
271 template <typename T>
273  size_t Alignment, size_t Count, const queue &Q, usm::alloc Kind,
274  const property_list &PropList = {} _CODELOCPARAM(&CodeLoc)) {
275  _CODELOCARG(&CodeLoc);
276  return aligned_alloc<T>(Alignment, Count, Q.get_device(), Q.get_context(),
277  Kind, PropList, CodeLoc);
278 }
279 
280 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
281 } // namespace sycl
sycl::_V1::property_list
Objects of the property_list class are containers for the SYCL properties.
Definition: property_list.hpp:24
sycl::_V1::aligned_alloc_device
T * aligned_alloc_device(size_t Alignment, size_t Count, const queue &Q, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:161
sycl::_V1::aligned_alloc_host
T * aligned_alloc_host(size_t Alignment, size_t Count, const queue &Q, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:215
T
__SYCL_INLINE_VER_NAMESPACE
#define __SYCL_INLINE_VER_NAMESPACE(X)
Definition: defines_elementary.hpp:11
sycl::_V1::ext::oneapi::experimental::alignment
constexpr alignment_key::value_t< K > alignment
Definition: properties.hpp:349
sycl::_V1::malloc
T * malloc(size_t Count, const queue &Q, usm::alloc Kind, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:252
sycl
---— Error handling, matching OpenCL plugin semantics.
Definition: access.hpp:14
max
simd< _Tp, _Abi > max(const simd< _Tp, _Abi > &, const simd< _Tp, _Abi > &) noexcept
sycl::_V1::aligned_alloc_shared
T * aligned_alloc_shared(size_t Alignment, size_t Count, const queue &Q, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:234
export.hpp
_CODELOCPARAM
#define _CODELOCPARAM(a)
Definition: common.hpp:108
sycl::_V1::queue
Encapsulates a single SYCL queue which schedules kernels on a SYCL device.
Definition: queue.hpp:89
_CODELOCARG
#define _CODELOCARG(a)
Definition: common.hpp:112
usm_allocator.hpp
sycl::_V1::usm::alloc
alloc
Definition: usm_enums.hpp:14
common.hpp
sycl::_V1::ext::oneapi::experimental::detail::Alignment
@ Alignment
Definition: property.hpp:189
sycl::_V1::device
The SYCL device class encapsulates a single SYCL device on which kernels may be executed.
Definition: device.hpp:49
sycl::_V1::free
void free(void *ptr, const queue &q _CODELOCPARAM(&CodeLoc))
sycl::_V1::queue::get_context
context get_context() const
Definition: queue.cpp:75
sycl::_V1::aligned_alloc
T * aligned_alloc(size_t Alignment, size_t Count, const queue &Q, usm::alloc Kind, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:272
sycl::_V1::malloc_shared
T * malloc_shared(size_t Count, const queue &Q, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:196
sycl::_V1::malloc_device
T * malloc_device(size_t Count, const queue &Q, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:142
sycl::_V1::malloc_host
T * malloc_host(size_t Count, const queue &Q, const property_list &PropList={} _CODELOCPARAM(&CodeLoc))
Definition: usm.hpp:179
usm_properties.hpp
usm_enums.hpp
sycl::_V1::queue::get_device
device get_device() const
Definition: queue.cpp:77
sycl::_V1::context
The context class represents a SYCL context on which kernel functions may be executed.
Definition: context.hpp:41