DPC++ Runtime
Runtime libraries for oneAPI DPC++
cg.hpp
Go to the documentation of this file.
1 //==-------------- CG.hpp - SYCL standard header file ----------------------==//
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/accessor.hpp>
12 #include <sycl/backend_types.hpp>
13 #include <sycl/detail/cg_types.hpp>
14 #include <sycl/detail/common.hpp>
15 #include <sycl/detail/export.hpp>
16 #include <sycl/detail/helpers.hpp>
20 #include <sycl/group.hpp>
21 #include <sycl/id.hpp>
22 #include <sycl/interop_handle.hpp>
23 #include <sycl/interop_handler.hpp>
24 #include <sycl/kernel.hpp>
25 #include <sycl/nd_item.hpp>
26 #include <sycl/range.hpp>
27 
28 #include <memory>
29 #include <string>
30 #include <type_traits>
31 #include <vector>
32 
33 namespace sycl {
35 
36 // Forward declarations
37 class queue;
38 
39 namespace detail {
40 
41 class event_impl;
42 using EventImplPtr = std::shared_ptr<event_impl>;
43 
44 class stream_impl;
45 class queue_impl;
46 class kernel_bundle_impl;
47 
48 // If there's a need to add new members to CG classes without breaking ABI
49 // compatibility, we can bring back the extended members mechanism. See
50 // https://github.com/intel/llvm/pull/6759
52 class CG {
53 public:
55  enum CGTYPE : unsigned int {
56  None = 0,
57  Kernel = 1,
58  CopyAccToPtr = 2,
59  CopyPtrToAcc = 3,
60  CopyAccToAcc = 4,
61  Barrier = 5,
62  BarrierWaitlist = 6,
63  Fill = 7,
64  UpdateHost = 8,
65  RunOnHostIntel = 9,
66  CopyUSM = 10,
67  FillUSM = 11,
68  PrefetchUSM = 12,
69  CodeplayInteropTask = 13,
70  CodeplayHostTask = 14,
71  AdviseUSM = 15,
72  };
73 
74  CG(CGTYPE Type, std::vector<std::vector<char>> ArgsStorage,
75  std::vector<detail::AccessorImplPtr> AccStorage,
76  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
77  std::vector<AccessorImplHost *> Requirements,
78  std::vector<detail::EventImplPtr> Events, detail::code_location loc = {})
79  : MType(Type), MArgsStorage(std::move(ArgsStorage)),
80  MAccStorage(std::move(AccStorage)),
81  MSharedPtrStorage(std::move(SharedPtrStorage)),
82  MRequirements(std::move(Requirements)), MEvents(std::move(Events)) {
83  // Capture the user code-location from Q.submit(), Q.parallel_for()
84  // etc for later use; if code location information is not available,
85  // the file name and function name members will be empty strings
86  if (loc.functionName())
87  MFunctionName = loc.functionName();
88  if (loc.fileName())
89  MFileName = loc.fileName();
90  MLine = loc.lineNumber();
91  MColumn = loc.columnNumber();
92  }
93 
94  CG(CG &&CommandGroup) = default;
95 
96  CGTYPE getType() { return MType; }
97 
98  virtual ~CG() = default;
99 
100 private:
101  CGTYPE MType;
102  // The following storages are needed to ensure that arguments won't die while
103  // we are using them.
105  std::vector<std::vector<char>> MArgsStorage;
107  std::vector<detail::AccessorImplPtr> MAccStorage;
109  std::vector<std::shared_ptr<const void>> MSharedPtrStorage;
110 
111 public:
114  std::vector<AccessorImplHost *> MRequirements;
116  std::vector<detail::EventImplPtr> MEvents;
117  // Member variables to capture the user code-location
118  // information from Q.submit(), Q.parallel_for() etc
119  // Storage for function name and source file name
120  std::string MFunctionName, MFileName;
121  // Storage for line and column of code location
122  int32_t MLine, MColumn;
123 };
124 
126 class CGExecKernel : public CG {
127 public:
130  std::unique_ptr<HostKernelBase> MHostKernel;
131  std::shared_ptr<detail::kernel_impl> MSyclKernel;
132  std::shared_ptr<detail::kernel_bundle_impl> MKernelBundle;
133  std::vector<ArgDesc> MArgs;
134  std::string MKernelName;
136  std::vector<std::shared_ptr<detail::stream_impl>> MStreams;
137  std::vector<std::shared_ptr<const void>> MAuxiliaryResources;
138 
139  CGExecKernel(NDRDescT NDRDesc, std::unique_ptr<HostKernelBase> HKernel,
140  std::shared_ptr<detail::kernel_impl> SyclKernel,
141  std::shared_ptr<detail::kernel_bundle_impl> KernelBundle,
142  std::vector<std::vector<char>> ArgsStorage,
143  std::vector<detail::AccessorImplPtr> AccStorage,
144  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
145  std::vector<AccessorImplHost *> Requirements,
146  std::vector<detail::EventImplPtr> Events,
147  std::vector<ArgDesc> Args, std::string KernelName,
149  std::vector<std::shared_ptr<detail::stream_impl>> Streams,
150  std::vector<std::shared_ptr<const void>> AuxiliaryResources,
151  CGTYPE Type, detail::code_location loc = {})
152  : CG(Type, std::move(ArgsStorage), std::move(AccStorage),
153  std::move(SharedPtrStorage), std::move(Requirements),
154  std::move(Events), std::move(loc)),
155  MNDRDesc(std::move(NDRDesc)), MHostKernel(std::move(HKernel)),
156  MSyclKernel(std::move(SyclKernel)),
157  MKernelBundle(std::move(KernelBundle)), MArgs(std::move(Args)),
158  MKernelName(std::move(KernelName)), MOSModuleHandle(OSModuleHandle),
159  MStreams(std::move(Streams)),
160  MAuxiliaryResources(std::move(AuxiliaryResources)) {
161  assert((getType() == RunOnHostIntel || getType() == Kernel) &&
162  "Wrong type of exec kernel CG.");
163  }
164 
165  std::vector<ArgDesc> getArguments() const { return MArgs; }
166  std::string getKernelName() const { return MKernelName; }
167  std::vector<std::shared_ptr<detail::stream_impl>> getStreams() const {
168  return MStreams;
169  }
170 
171  std::vector<std::shared_ptr<const void>> getAuxiliaryResources() const {
172  return MAuxiliaryResources;
173  }
174 
175  std::shared_ptr<detail::kernel_bundle_impl> getKernelBundle() {
176  return MKernelBundle;
177  }
178 
179  void clearStreams() { MStreams.clear(); }
180  bool hasStreams() { return !MStreams.empty(); }
181 
182  void clearAuxiliaryResources() { MAuxiliaryResources.clear(); }
183  bool hasAuxiliaryResources() { return !MAuxiliaryResources.empty(); }
184 };
185 
187 class CGCopy : public CG {
188  void *MSrc;
189  void *MDst;
190 
191 public:
192  CGCopy(CGTYPE CopyType, void *Src, void *Dst,
193  std::vector<std::vector<char>> ArgsStorage,
194  std::vector<detail::AccessorImplPtr> AccStorage,
195  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
196  std::vector<AccessorImplHost *> Requirements,
197  std::vector<detail::EventImplPtr> Events,
198  detail::code_location loc = {})
199  : CG(CopyType, std::move(ArgsStorage), std::move(AccStorage),
200  std::move(SharedPtrStorage), std::move(Requirements),
201  std::move(Events), std::move(loc)),
202  MSrc(Src), MDst(Dst) {}
203  void *getSrc() { return MSrc; }
204  void *getDst() { return MDst; }
205 };
206 
208 class CGFill : public CG {
209 public:
210  std::vector<char> MPattern;
212 
213  CGFill(std::vector<char> Pattern, void *Ptr,
214  std::vector<std::vector<char>> ArgsStorage,
215  std::vector<detail::AccessorImplPtr> AccStorage,
216  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
217  std::vector<AccessorImplHost *> Requirements,
218  std::vector<detail::EventImplPtr> Events,
219  detail::code_location loc = {})
220  : CG(Fill, std::move(ArgsStorage), std::move(AccStorage),
221  std::move(SharedPtrStorage), std::move(Requirements),
222  std::move(Events), std::move(loc)),
223  MPattern(std::move(Pattern)), MPtr((AccessorImplHost *)Ptr) {}
224  AccessorImplHost *getReqToFill() { return MPtr; }
225 };
226 
228 class CGUpdateHost : public CG {
229  AccessorImplHost *MPtr;
230 
231 public:
232  CGUpdateHost(void *Ptr, std::vector<std::vector<char>> ArgsStorage,
233  std::vector<detail::AccessorImplPtr> AccStorage,
234  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
235  std::vector<AccessorImplHost *> Requirements,
236  std::vector<detail::EventImplPtr> Events,
237  detail::code_location loc = {})
238  : CG(UpdateHost, std::move(ArgsStorage), std::move(AccStorage),
239  std::move(SharedPtrStorage), std::move(Requirements),
240  std::move(Events), std::move(loc)),
241  MPtr((AccessorImplHost *)Ptr) {}
242 
243  AccessorImplHost *getReqToUpdate() { return MPtr; }
244 };
245 
247 class CGCopyUSM : public CG {
248  void *MSrc;
249  void *MDst;
250  size_t MLength;
251 
252 public:
253  CGCopyUSM(void *Src, void *Dst, size_t Length,
254  std::vector<std::vector<char>> ArgsStorage,
255  std::vector<detail::AccessorImplPtr> AccStorage,
256  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
257  std::vector<AccessorImplHost *> Requirements,
258  std::vector<detail::EventImplPtr> Events,
259  detail::code_location loc = {})
260  : CG(CopyUSM, std::move(ArgsStorage), std::move(AccStorage),
261  std::move(SharedPtrStorage), std::move(Requirements),
262  std::move(Events), std::move(loc)),
263  MSrc(Src), MDst(Dst), MLength(Length) {}
264 
265  void *getSrc() { return MSrc; }
266  void *getDst() { return MDst; }
267  size_t getLength() { return MLength; }
268 };
269 
271 class CGFillUSM : public CG {
272  std::vector<char> MPattern;
273  void *MDst;
274  size_t MLength;
275 
276 public:
277  CGFillUSM(std::vector<char> Pattern, void *DstPtr, size_t Length,
278  std::vector<std::vector<char>> ArgsStorage,
279  std::vector<detail::AccessorImplPtr> AccStorage,
280  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
281  std::vector<AccessorImplHost *> Requirements,
282  std::vector<detail::EventImplPtr> Events,
283  detail::code_location loc = {})
284  : CG(FillUSM, std::move(ArgsStorage), std::move(AccStorage),
285  std::move(SharedPtrStorage), std::move(Requirements),
286  std::move(Events), std::move(loc)),
287  MPattern(std::move(Pattern)), MDst(DstPtr), MLength(Length) {}
288  void *getDst() { return MDst; }
289  size_t getLength() { return MLength; }
290  int getFill() { return MPattern[0]; }
291 };
292 
294 class CGPrefetchUSM : public CG {
295  void *MDst;
296  size_t MLength;
297 
298 public:
299  CGPrefetchUSM(void *DstPtr, size_t Length,
300  std::vector<std::vector<char>> ArgsStorage,
301  std::vector<detail::AccessorImplPtr> AccStorage,
302  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
303  std::vector<AccessorImplHost *> Requirements,
304  std::vector<detail::EventImplPtr> Events,
305  detail::code_location loc = {})
306  : CG(PrefetchUSM, std::move(ArgsStorage), std::move(AccStorage),
307  std::move(SharedPtrStorage), std::move(Requirements),
308  std::move(Events), std::move(loc)),
309  MDst(DstPtr), MLength(Length) {}
310  void *getDst() { return MDst; }
311  size_t getLength() { return MLength; }
312 };
313 
315 class CGAdviseUSM : public CG {
316  void *MDst;
317  size_t MLength;
318  pi_mem_advice MAdvice;
319 
320 public:
321  CGAdviseUSM(void *DstPtr, size_t Length, pi_mem_advice Advice,
322  std::vector<std::vector<char>> ArgsStorage,
323  std::vector<detail::AccessorImplPtr> AccStorage,
324  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
325  std::vector<AccessorImplHost *> Requirements,
326  std::vector<detail::EventImplPtr> Events, CGTYPE Type,
327  detail::code_location loc = {})
328  : CG(Type, std::move(ArgsStorage), std::move(AccStorage),
329  std::move(SharedPtrStorage), std::move(Requirements),
330  std::move(Events), std::move(loc)),
331  MDst(DstPtr), MLength(Length), MAdvice(Advice) {}
332  void *getDst() { return MDst; }
333  size_t getLength() { return MLength; }
334  pi_mem_advice getAdvice() { return MAdvice; }
335 };
336 
337 class CGInteropTask : public CG {
338 public:
339  std::unique_ptr<InteropTask> MInteropTask;
340 
341  CGInteropTask(std::unique_ptr<InteropTask> InteropTask,
342  std::vector<std::vector<char>> ArgsStorage,
343  std::vector<detail::AccessorImplPtr> AccStorage,
344  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
345  std::vector<AccessorImplHost *> Requirements,
346  std::vector<detail::EventImplPtr> Events, CGTYPE Type,
347  detail::code_location loc = {})
348  : CG(Type, std::move(ArgsStorage), std::move(AccStorage),
349  std::move(SharedPtrStorage), std::move(Requirements),
350  std::move(Events), std::move(loc)),
351  MInteropTask(std::move(InteropTask)) {}
352 };
353 
354 class CGHostTask : public CG {
355 public:
356  std::unique_ptr<HostTask> MHostTask;
357  // queue for host-interop task
358  std::shared_ptr<detail::queue_impl> MQueue;
359  // context for host-interop task
360  std::shared_ptr<detail::context_impl> MContext;
361  std::vector<ArgDesc> MArgs;
362 
363  CGHostTask(std::unique_ptr<HostTask> HostTask,
364  std::shared_ptr<detail::queue_impl> Queue,
365  std::shared_ptr<detail::context_impl> Context,
366  std::vector<ArgDesc> Args,
367  std::vector<std::vector<char>> ArgsStorage,
368  std::vector<detail::AccessorImplPtr> AccStorage,
369  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
370  std::vector<AccessorImplHost *> Requirements,
371  std::vector<detail::EventImplPtr> Events, CGTYPE Type,
372  detail::code_location loc = {})
373  : CG(Type, std::move(ArgsStorage), std::move(AccStorage),
374  std::move(SharedPtrStorage), std::move(Requirements),
375  std::move(Events), std::move(loc)),
376  MHostTask(std::move(HostTask)), MQueue(Queue), MContext(Context),
377  MArgs(std::move(Args)) {}
378 };
379 
380 class CGBarrier : public CG {
381 public:
382  std::vector<detail::EventImplPtr> MEventsWaitWithBarrier;
383 
384  CGBarrier(std::vector<detail::EventImplPtr> EventsWaitWithBarrier,
385  std::vector<std::vector<char>> ArgsStorage,
386  std::vector<detail::AccessorImplPtr> AccStorage,
387  std::vector<std::shared_ptr<const void>> SharedPtrStorage,
388  std::vector<AccessorImplHost *> Requirements,
389  std::vector<detail::EventImplPtr> Events, CGTYPE Type,
390  detail::code_location loc = {})
391  : CG(Type, std::move(ArgsStorage), std::move(AccStorage),
392  std::move(SharedPtrStorage), std::move(Requirements),
393  std::move(Events), std::move(loc)),
394  MEventsWaitWithBarrier(std::move(EventsWaitWithBarrier)) {}
395 };
396 
397 } // namespace detail
398 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
399 } // namespace sycl
The file contains implementations of accessor class.
"Advise USM" command group class.
Definition: cg.hpp:315
pi_mem_advice getAdvice()
Definition: cg.hpp:334
CGAdviseUSM(void *DstPtr, size_t Length, pi_mem_advice Advice, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, CGTYPE Type, detail::code_location loc={})
Definition: cg.hpp:321
CGBarrier(std::vector< detail::EventImplPtr > EventsWaitWithBarrier, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, CGTYPE Type, detail::code_location loc={})
Definition: cg.hpp:384
std::vector< detail::EventImplPtr > MEventsWaitWithBarrier
Definition: cg.hpp:382
"Copy USM" command group class.
Definition: cg.hpp:247
CGCopyUSM(void *Src, void *Dst, size_t Length, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, detail::code_location loc={})
Definition: cg.hpp:253
"Copy memory" command group class.
Definition: cg.hpp:187
CGCopy(CGTYPE CopyType, void *Src, void *Dst, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, detail::code_location loc={})
Definition: cg.hpp:192
"Execute kernel" command group class.
Definition: cg.hpp:126
std::shared_ptr< detail::kernel_bundle_impl > MKernelBundle
Definition: cg.hpp:132
std::vector< std::shared_ptr< const void > > MAuxiliaryResources
Definition: cg.hpp:137
std::string getKernelName() const
Definition: cg.hpp:166
std::vector< ArgDesc > MArgs
Definition: cg.hpp:133
NDRDescT MNDRDesc
Stores ND-range description.
Definition: cg.hpp:129
std::vector< std::shared_ptr< const void > > getAuxiliaryResources() const
Definition: cg.hpp:171
std::unique_ptr< HostKernelBase > MHostKernel
Definition: cg.hpp:130
std::shared_ptr< detail::kernel_impl > MSyclKernel
Definition: cg.hpp:131
std::vector< std::shared_ptr< detail::stream_impl > > getStreams() const
Definition: cg.hpp:167
std::vector< std::shared_ptr< detail::stream_impl > > MStreams
Definition: cg.hpp:136
std::shared_ptr< detail::kernel_bundle_impl > getKernelBundle()
Definition: cg.hpp:175
std::vector< ArgDesc > getArguments() const
Definition: cg.hpp:165
CGExecKernel(NDRDescT NDRDesc, std::unique_ptr< HostKernelBase > HKernel, std::shared_ptr< detail::kernel_impl > SyclKernel, std::shared_ptr< detail::kernel_bundle_impl > KernelBundle, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, std::vector< ArgDesc > Args, std::string KernelName, detail::OSModuleHandle OSModuleHandle, std::vector< std::shared_ptr< detail::stream_impl >> Streams, std::vector< std::shared_ptr< const void >> AuxiliaryResources, CGTYPE Type, detail::code_location loc={})
Definition: cg.hpp:139
detail::OSModuleHandle MOSModuleHandle
Definition: cg.hpp:135
"Fill USM" command group class.
Definition: cg.hpp:271
CGFillUSM(std::vector< char > Pattern, void *DstPtr, size_t Length, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, detail::code_location loc={})
Definition: cg.hpp:277
"Fill memory" command group class.
Definition: cg.hpp:208
std::vector< char > MPattern
Definition: cg.hpp:210
AccessorImplHost * getReqToFill()
Definition: cg.hpp:224
AccessorImplHost * MPtr
Definition: cg.hpp:211
CGFill(std::vector< char > Pattern, void *Ptr, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, detail::code_location loc={})
Definition: cg.hpp:213
std::unique_ptr< HostTask > MHostTask
Definition: cg.hpp:356
CGHostTask(std::unique_ptr< HostTask > HostTask, std::shared_ptr< detail::queue_impl > Queue, std::shared_ptr< detail::context_impl > Context, std::vector< ArgDesc > Args, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, CGTYPE Type, detail::code_location loc={})
Definition: cg.hpp:363
std::shared_ptr< detail::context_impl > MContext
Definition: cg.hpp:360
std::shared_ptr< detail::queue_impl > MQueue
Definition: cg.hpp:358
std::vector< ArgDesc > MArgs
Definition: cg.hpp:361
CGInteropTask(std::unique_ptr< InteropTask > InteropTask, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, CGTYPE Type, detail::code_location loc={})
Definition: cg.hpp:341
std::unique_ptr< InteropTask > MInteropTask
Definition: cg.hpp:339
"Prefetch USM" command group class.
Definition: cg.hpp:294
CGPrefetchUSM(void *DstPtr, size_t Length, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, detail::code_location loc={})
Definition: cg.hpp:299
"Update host" command group class.
Definition: cg.hpp:228
AccessorImplHost * getReqToUpdate()
Definition: cg.hpp:243
CGUpdateHost(void *Ptr, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, detail::code_location loc={})
Definition: cg.hpp:232
Base class for all types of command groups.
Definition: cg.hpp:52
CG(CGTYPE Type, std::vector< std::vector< char >> ArgsStorage, std::vector< detail::AccessorImplPtr > AccStorage, std::vector< std::shared_ptr< const void >> SharedPtrStorage, std::vector< AccessorImplHost * > Requirements, std::vector< detail::EventImplPtr > Events, detail::code_location loc={})
Definition: cg.hpp:74
virtual ~CG()=default
std::string MFileName
Definition: cg.hpp:120
CGTYPE getType()
Definition: cg.hpp:96
int32_t MColumn
Definition: cg.hpp:122
std::vector< detail::EventImplPtr > MEvents
List of events that order the execution of this CG.
Definition: cg.hpp:116
CG(CG &&CommandGroup)=default
std::vector< AccessorImplHost * > MRequirements
List of requirements that specify which memory is needed for the command group to be executed.
Definition: cg.hpp:114
CGTYPE
Type of the command group.
Definition: cg.hpp:55
#define __SYCL_INLINE_VER_NAMESPACE(X)
std::shared_ptr< event_impl > EventImplPtr
Definition: cg.hpp:42
intptr_t OSModuleHandle
Uniquely identifies an operating system module (executable or a dynamic library)
Definition: os_util.hpp:48
---— Error handling, matching OpenCL plugin semantics.
Definition: access.hpp:14
_pi_mem_advice
Definition: pi.h:422