alpaka
Abstraction Library for Parallel Kernel Acceleration
Loading...
Searching...
No Matches
ApiCudaRt.hpp
Go to the documentation of this file.
1/* Copyright 2022 Andrea Bocci
2 * SPDX-License-Identifier: MPL-2.0
3 */
4
5#pragma once
6
9
10#ifdef ALPAKA_ACC_GPU_CUDA_ENABLED
11# include <cuda_runtime_api.h>
12
13namespace alpaka
14{
15 struct ApiCudaRt
16 {
17 // Names
18 static constexpr char name[] = "Cuda";
19 static constexpr auto version = ALPAKA_LANG_CUDA;
20
21 // Types
22 using DeviceAttr_t = ::cudaDeviceAttr;
23 using DeviceProp_t = ::cudaDeviceProp;
24 using Error_t = ::cudaError_t;
25 using Event_t = ::cudaEvent_t;
26 using Extent_t = ::cudaExtent;
27 using Flag_t = unsigned int;
28 using FuncAttributes_t = ::cudaFuncAttributes;
29 using HostFn_t = void (*)(void* data); // same as cudaHostFn_t, without the CUDART_CB calling convention
30 using Limit_t = ::cudaLimit;
31 using Memcpy3DParms_t = ::cudaMemcpy3DParms;
32 using MemcpyKind_t = ::cudaMemcpyKind;
33 using PitchedPtr_t = ::cudaPitchedPtr;
34 using Pos_t = ::cudaPos;
35 using Stream_t = ::cudaStream_t;
36
37 // Constants
38 static constexpr Error_t success = ::cudaSuccess;
39 static constexpr Error_t errorNotReady = ::cudaErrorNotReady;
40 static constexpr Error_t errorHostMemoryAlreadyRegistered = ::cudaErrorHostMemoryAlreadyRegistered;
41 static constexpr Error_t errorHostMemoryNotRegistered = ::cudaErrorHostMemoryNotRegistered;
42 static constexpr Error_t errorUnsupportedLimit = ::cudaErrorUnsupportedLimit;
43 static constexpr Error_t errorUnknown = ::cudaErrorUnknown;
44
45 static constexpr Flag_t eventDefault = cudaEventDefault;
46 static constexpr Flag_t eventBlockingSync = cudaEventBlockingSync;
47 static constexpr Flag_t eventDisableTiming = cudaEventDisableTiming;
48 static constexpr Flag_t eventInterprocess = cudaEventInterprocess;
49
50 static constexpr Flag_t hostMallocDefault = cudaHostAllocDefault;
51 static constexpr Flag_t hostMallocMapped = cudaHostAllocMapped;
52 static constexpr Flag_t hostMallocPortable = cudaHostAllocPortable;
53 static constexpr Flag_t hostMallocWriteCombined = cudaHostAllocWriteCombined;
54 static constexpr Flag_t hostMallocCoherent = cudaHostAllocDefault; // Not supported.
55 static constexpr Flag_t hostMallocNonCoherent = cudaHostAllocDefault; // Not supported.
56
57 static constexpr Flag_t hostRegisterDefault = cudaHostRegisterDefault;
58 static constexpr Flag_t hostRegisterPortable = cudaHostRegisterPortable;
59 static constexpr Flag_t hostRegisterMapped = cudaHostRegisterMapped;
60 static constexpr Flag_t hostRegisterIoMemory = cudaHostRegisterIoMemory;
61
62 static constexpr MemcpyKind_t memcpyDefault = ::cudaMemcpyDefault;
63 static constexpr MemcpyKind_t memcpyDeviceToDevice = ::cudaMemcpyDeviceToDevice;
64 static constexpr MemcpyKind_t memcpyDeviceToHost = ::cudaMemcpyDeviceToHost;
65 static constexpr MemcpyKind_t memcpyHostToDevice = ::cudaMemcpyHostToDevice;
66
67 static constexpr Flag_t streamDefault = cudaStreamDefault;
68 static constexpr Flag_t streamNonBlocking = cudaStreamNonBlocking;
69
70 static constexpr DeviceAttr_t deviceAttributeMaxBlockDimX = ::cudaDevAttrMaxBlockDimX;
71 static constexpr DeviceAttr_t deviceAttributeMaxBlockDimY = ::cudaDevAttrMaxBlockDimY;
72 static constexpr DeviceAttr_t deviceAttributeMaxBlockDimZ = ::cudaDevAttrMaxBlockDimZ;
73 static constexpr DeviceAttr_t deviceAttributeMaxGridDimX = ::cudaDevAttrMaxGridDimX;
74 static constexpr DeviceAttr_t deviceAttributeMaxGridDimY = ::cudaDevAttrMaxGridDimY;
75 static constexpr DeviceAttr_t deviceAttributeMaxGridDimZ = ::cudaDevAttrMaxGridDimZ;
76 static constexpr DeviceAttr_t deviceAttributeMaxSharedMemoryPerBlock = ::cudaDevAttrMaxSharedMemoryPerBlock;
77 static constexpr DeviceAttr_t deviceAttributeMaxThreadsPerBlock = ::cudaDevAttrMaxThreadsPerBlock;
78 static constexpr DeviceAttr_t deviceAttributeMultiprocessorCount = ::cudaDevAttrMultiProcessorCount;
79 static constexpr DeviceAttr_t deviceAttributeWarpSize = ::cudaDevAttrWarpSize;
80
81 static constexpr Limit_t limitPrintfFifoSize = ::cudaLimitPrintfFifoSize;
82 static constexpr Limit_t limitMallocHeapSize = ::cudaLimitMallocHeapSize;
83
84 // Host function helper
85 // Encapsulates the different function signatures used by cudaStreamAddCallback and cudaLaunchHostFn, and the
86 // different calling conventions used by CUDA (__stdcall on Win32) and HIP (standard).
88 {
90 void* data_;
91
92 static void CUDART_CB hostFunction(void* data)
93 {
94 auto ptr = reinterpret_cast<HostFnAdaptor*>(data);
95 ptr->func_(ptr->data_);
96 delete ptr;
97 }
98
99 static void CUDART_CB streamCallback(Stream_t, Error_t, void* data)
100 {
101 auto ptr = reinterpret_cast<HostFnAdaptor*>(data);
102 ptr->func_(ptr->data_);
103 delete ptr;
104 }
105 };
106
107 // Runtime API
108 static inline Error_t deviceGetAttribute(int* value, DeviceAttr_t attr, int device)
109 {
110 return ::cudaDeviceGetAttribute(value, attr, device);
111 }
112
113 static inline Error_t deviceGetLimit(size_t* pValue, Limit_t limit)
114 {
115 return ::cudaDeviceGetLimit(pValue, limit);
116 }
117
118 static inline Error_t deviceReset()
119 {
120 return ::cudaDeviceReset();
121 }
122
123 static inline Error_t deviceSetLimit(Limit_t limit, size_t value)
124 {
125 return ::cudaDeviceSetLimit(limit, value);
126 }
127
129 {
130 return ::cudaDeviceSynchronize();
131 }
132
133 static inline Error_t eventCreate(Event_t* event)
134 {
135 return ::cudaEventCreate(event);
136 }
137
138 static inline Error_t eventCreateWithFlags(Event_t* event, Flag_t flags)
139 {
140 return ::cudaEventCreateWithFlags(event, flags);
141 }
142
143 static inline Error_t eventDestroy(Event_t event)
144 {
145 return ::cudaEventDestroy(event);
146 }
147
148 static inline Error_t eventQuery(Event_t event)
149 {
150 return ::cudaEventQuery(event);
151 }
152
153 static inline Error_t eventRecord(Event_t event, Stream_t stream)
154 {
155 return ::cudaEventRecord(event, stream);
156 }
157
158 static inline Error_t eventSynchronize(Event_t event)
159 {
160 return ::cudaEventSynchronize(event);
161 }
162
163 static inline Error_t free(void* devPtr)
164 {
165 return ::cudaFree(devPtr);
166 }
167
168 static inline Error_t freeAsync([[maybe_unused]] void* devPtr, [[maybe_unused]] Stream_t stream)
169 {
170# if CUDART_VERSION >= 11020
171 return ::cudaFreeAsync(devPtr, stream);
172# else
173 // Not implemented.
174 return errorUnknown;
175# endif
176 }
177
178 static inline Error_t funcGetAttributes(FuncAttributes_t* attr, void const* func)
179 {
180 return ::cudaFuncGetAttributes(attr, func);
181 }
182
183 template<typename T>
184 static inline Error_t funcGetAttributes(FuncAttributes_t* attr, T* func)
185 {
186# if ALPAKA_COMP_GNUC
187# pragma GCC diagnostic push
188# pragma GCC diagnostic ignored "-Wconditionally-supported"
189# endif
190 return ::cudaFuncGetAttributes(attr, reinterpret_cast<void const*>(func));
191# if ALPAKA_COMP_GNUC
192# pragma GCC diagnostic pop
193# endif
194 }
195
196 static inline int getCurrentDevice()
197 {
198 int device;
199 using TApi = alpaka::ApiCudaRt;
200 ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(::cudaGetDevice(&device));
201
202 return device;
203 }
204
205 static inline Error_t getDeviceCount(int* count)
206 {
207 return ::cudaGetDeviceCount(count);
208 }
209
210 static inline Error_t getDeviceProperties(DeviceProp_t* prop, int device)
211 {
212 return ::cudaGetDeviceProperties(prop, device);
213 }
214
215 static inline char const* getErrorName(Error_t error)
216 {
217 return ::cudaGetErrorName(error);
218 }
219
220 static inline char const* getErrorString(Error_t error)
221 {
222 return ::cudaGetErrorString(error);
223 }
224
225 static inline Error_t getLastError()
226 {
227 return ::cudaGetLastError();
228 }
229
230 static inline Error_t getSymbolAddress(void** devPtr, void const* symbol)
231 {
232 return ::cudaGetSymbolAddress(devPtr, symbol);
233 }
234
235 template<class T>
236 static inline Error_t getSymbolAddress(void** devPtr, T const& symbol)
237 {
238 return ::cudaGetSymbolAddress(devPtr, symbol);
239 }
240
241 static inline Error_t hostGetDevicePointer(void** pDevice, void* pHost, Flag_t flags)
242 {
243 return ::cudaHostGetDevicePointer(pDevice, pHost, flags);
244 }
245
246 static inline Error_t hostFree(void* ptr)
247 {
248 return ::cudaFreeHost(ptr);
249 }
250
251 static inline Error_t hostMalloc(void** ptr, size_t size, Flag_t flags)
252 {
253 return ::cudaHostAlloc(ptr, size, flags);
254 }
255
256 static inline Error_t hostRegister(void* ptr, size_t size, Flag_t flags)
257 {
258 return ::cudaHostRegister(ptr, size, flags);
259 }
260
261 static inline Error_t hostUnregister(void* ptr)
262 {
263 return ::cudaHostUnregister(ptr);
264 }
265
266 static inline Error_t launchHostFunc(Stream_t stream, HostFn_t fn, void* userData)
267 {
268# if CUDART_VERSION >= 10000
269 // Wrap the host function using the proper calling convention
270 return ::cudaLaunchHostFunc(stream, HostFnAdaptor::hostFunction, new HostFnAdaptor{fn, userData});
271# else
272 // Emulate cudaLaunchHostFunc using cudaStreamAddCallback with a callback adaptor.
273 return ::cudaStreamAddCallback(stream, HostFnAdaptor::streamCallback, new HostFnAdaptor{fn, userData}, 0);
274# endif
275 }
276
277 static inline Error_t malloc(void** devPtr, size_t size)
278 {
279 return ::cudaMalloc(devPtr, size);
280 }
281
282 static inline Error_t malloc3D(PitchedPtr_t* pitchedDevPtr, Extent_t extent)
283 {
284 return ::cudaMalloc3D(pitchedDevPtr, extent);
285 }
286
287 static inline Error_t mallocAsync(
288 [[maybe_unused]] void** devPtr,
289 [[maybe_unused]] size_t size,
290 [[maybe_unused]] Stream_t stream)
291 {
292# if CUDART_VERSION >= 11020
293 return ::cudaMallocAsync(devPtr, size, stream);
294# else
295 // Not implemented.
296 return errorUnknown;
297# endif
298 }
299
300 static inline Error_t mallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height)
301 {
302 return ::cudaMallocPitch(devPtr, pitch, width, height);
303 }
304
305 static inline Error_t memGetInfo(size_t* free, size_t* total)
306 {
307 return ::cudaMemGetInfo(free, total);
308 }
309
310 static inline Error_t memcpy(void* dst, void const* src, size_t count, MemcpyKind_t kind)
311 {
312 return ::cudaMemcpy(dst, src, count, kind);
313 }
314
315 static inline Error_t memcpy2DAsync(
316 void* dst,
317 size_t dpitch,
318 void const* src,
319 size_t spitch,
320 size_t width,
321 size_t height,
322 MemcpyKind_t kind,
323 Stream_t stream)
324 {
325 return ::cudaMemcpy2DAsync(dst, dpitch, src, spitch, width, height, kind, stream);
326 }
327
328 static inline Error_t memcpy3DAsync(Memcpy3DParms_t const* p, Stream_t stream)
329 {
330 return ::cudaMemcpy3DAsync(p, stream);
331 }
332
333 static inline Error_t memcpyAsync(void* dst, void const* src, size_t count, MemcpyKind_t kind, Stream_t stream)
334 {
335 return ::cudaMemcpyAsync(dst, src, count, kind, stream);
336 }
337
338 static inline Error_t memset2DAsync(
339 void* devPtr,
340 size_t pitch,
341 int value,
342 size_t width,
343 size_t height,
344 Stream_t stream)
345 {
346 return ::cudaMemset2DAsync(devPtr, pitch, value, width, height, stream);
347 }
348
349 static inline Error_t memset3DAsync(PitchedPtr_t pitchedDevPtr, int value, Extent_t extent, Stream_t stream)
350 {
351 return ::cudaMemset3DAsync(pitchedDevPtr, value, extent, stream);
352 }
353
354 static inline Error_t memsetAsync(void* devPtr, int value, size_t count, Stream_t stream)
355 {
356 return ::cudaMemsetAsync(devPtr, value, count, stream);
357 }
358
359 static inline Error_t setDevice(int device)
360 {
361 return ::cudaSetDevice(device);
362 }
363
364 static inline Error_t streamCreate(Stream_t* pStream)
365 {
366 return ::cudaStreamCreate(pStream);
367 }
368
369 static inline Error_t streamCreateWithFlags(Stream_t* pStream, Flag_t flags)
370 {
371 return ::cudaStreamCreateWithFlags(pStream, flags);
372 }
373
374 static inline Error_t streamDestroy(Stream_t stream)
375 {
376 return ::cudaStreamDestroy(stream);
377 }
378
379 static inline Error_t streamQuery(Stream_t stream)
380 {
381 return ::cudaStreamQuery(stream);
382 }
383
384 static inline Error_t streamSynchronize(Stream_t stream)
385 {
386 return ::cudaStreamSynchronize(stream);
387 }
388
389 static inline Error_t streamWaitEvent(Stream_t stream, Event_t event, Flag_t flags)
390 {
391 return ::cudaStreamWaitEvent(stream, event, flags);
392 }
393
394 static inline PitchedPtr_t makePitchedPtr(void* d, size_t p, size_t xsz, size_t ysz)
395 {
396 return ::make_cudaPitchedPtr(d, p, xsz, ysz);
397 }
398
399 static inline Pos_t makePos(size_t x, size_t y, size_t z)
400 {
401 return ::make_cudaPos(x, y, z);
402 }
403
404 static inline Extent_t makeExtent(size_t w, size_t h, size_t d)
405 {
406 return ::make_cudaExtent(w, h, d);
407 }
408 };
409
410} // namespace alpaka
411
412#endif // ALPAKA_ACC_GPU_CUDA_ENABLED
#define ALPAKA_LANG_CUDA
Definition Config.hpp:210
#define ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(cmd)
CUDA/HIP runtime error checking with log and exception.
The alpaka accelerator library.
static void CUDART_CB streamCallback(Stream_t, Error_t, void *data)
Definition ApiCudaRt.hpp:99
static void CUDART_CB hostFunction(void *data)
Definition ApiCudaRt.hpp:92
static constexpr DeviceAttr_t deviceAttributeMaxBlockDimX
Definition ApiCudaRt.hpp:70
static Error_t getDeviceCount(int *count)
static Error_t hostMalloc(void **ptr, size_t size, Flag_t flags)
static constexpr Flag_t eventDefault
Definition ApiCudaRt.hpp:45
static Error_t deviceReset()
static constexpr Flag_t eventInterprocess
Definition ApiCudaRt.hpp:48
static Error_t streamWaitEvent(Stream_t stream, Event_t event, Flag_t flags)
unsigned int Flag_t
Definition ApiCudaRt.hpp:27
static constexpr DeviceAttr_t deviceAttributeMultiprocessorCount
Definition ApiCudaRt.hpp:78
static constexpr DeviceAttr_t deviceAttributeMaxBlockDimZ
Definition ApiCudaRt.hpp:72
static int getCurrentDevice()
static Error_t funcGetAttributes(FuncAttributes_t *attr, T *func)
::cudaStream_t Stream_t
Definition ApiCudaRt.hpp:35
::cudaMemcpy3DParms Memcpy3DParms_t
Definition ApiCudaRt.hpp:31
static constexpr Flag_t eventDisableTiming
Definition ApiCudaRt.hpp:47
static constexpr Flag_t hostMallocPortable
Definition ApiCudaRt.hpp:52
static Error_t memcpyAsync(void *dst, void const *src, size_t count, MemcpyKind_t kind, Stream_t stream)
static Error_t memset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, Stream_t stream)
static constexpr Flag_t hostMallocWriteCombined
Definition ApiCudaRt.hpp:53
static Error_t freeAsync(void *devPtr, Stream_t stream)
static Error_t streamDestroy(Stream_t stream)
::cudaEvent_t Event_t
Definition ApiCudaRt.hpp:25
static constexpr Flag_t eventBlockingSync
Definition ApiCudaRt.hpp:46
static constexpr char name[]
Definition ApiCudaRt.hpp:18
static Error_t getLastError()
static constexpr DeviceAttr_t deviceAttributeMaxSharedMemoryPerBlock
Definition ApiCudaRt.hpp:76
::cudaPitchedPtr PitchedPtr_t
Definition ApiCudaRt.hpp:33
static constexpr Flag_t hostMallocDefault
Definition ApiCudaRt.hpp:50
static Error_t malloc(void **devPtr, size_t size)
static Error_t hostUnregister(void *ptr)
static Error_t hostFree(void *ptr)
static constexpr Flag_t hostRegisterPortable
Definition ApiCudaRt.hpp:58
static Error_t deviceSetLimit(Limit_t limit, size_t value)
static constexpr Limit_t limitMallocHeapSize
Definition ApiCudaRt.hpp:82
static Error_t memGetInfo(size_t *free, size_t *total)
static constexpr Error_t errorNotReady
Definition ApiCudaRt.hpp:39
static Error_t eventSynchronize(Event_t event)
static PitchedPtr_t makePitchedPtr(void *d, size_t p, size_t xsz, size_t ysz)
static constexpr Flag_t hostMallocNonCoherent
Definition ApiCudaRt.hpp:55
static constexpr Limit_t limitPrintfFifoSize
Definition ApiCudaRt.hpp:81
static constexpr auto version
Definition ApiCudaRt.hpp:19
static Error_t streamCreate(Stream_t *pStream)
static Error_t mallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height)
static Error_t funcGetAttributes(FuncAttributes_t *attr, void const *func)
static constexpr Flag_t streamNonBlocking
Definition ApiCudaRt.hpp:68
static Error_t hostGetDevicePointer(void **pDevice, void *pHost, Flag_t flags)
static constexpr Flag_t hostMallocMapped
Definition ApiCudaRt.hpp:51
static Extent_t makeExtent(size_t w, size_t h, size_t d)
static Error_t deviceSynchronize()
::cudaMemcpyKind MemcpyKind_t
Definition ApiCudaRt.hpp:32
static constexpr Error_t success
Definition ApiCudaRt.hpp:38
static Error_t eventQuery(Event_t event)
static Error_t deviceGetAttribute(int *value, DeviceAttr_t attr, int device)
static constexpr Flag_t hostRegisterDefault
Definition ApiCudaRt.hpp:57
static constexpr DeviceAttr_t deviceAttributeMaxThreadsPerBlock
Definition ApiCudaRt.hpp:77
::cudaError_t Error_t
Definition ApiCudaRt.hpp:24
static constexpr Error_t errorUnknown
Definition ApiCudaRt.hpp:43
static Error_t getSymbolAddress(void **devPtr, T const &symbol)
static Error_t memcpy2DAsync(void *dst, size_t dpitch, void const *src, size_t spitch, size_t width, size_t height, MemcpyKind_t kind, Stream_t stream)
::cudaFuncAttributes FuncAttributes_t
Definition ApiCudaRt.hpp:28
static Error_t free(void *devPtr)
static constexpr MemcpyKind_t memcpyDeviceToDevice
Definition ApiCudaRt.hpp:63
static char const * getErrorString(Error_t error)
static Error_t streamSynchronize(Stream_t stream)
static Pos_t makePos(size_t x, size_t y, size_t z)
static constexpr MemcpyKind_t memcpyHostToDevice
Definition ApiCudaRt.hpp:65
static constexpr Flag_t hostRegisterMapped
Definition ApiCudaRt.hpp:59
void(*)(void *data) HostFn_t
Definition ApiCudaRt.hpp:29
static Error_t mallocAsync(void **devPtr, size_t size, Stream_t stream)
static char const * getErrorName(Error_t error)
static Error_t streamCreateWithFlags(Stream_t *pStream, Flag_t flags)
static Error_t streamQuery(Stream_t stream)
static constexpr Error_t errorHostMemoryAlreadyRegistered
Definition ApiCudaRt.hpp:40
static Error_t getDeviceProperties(DeviceProp_t *prop, int device)
static constexpr Flag_t hostMallocCoherent
Definition ApiCudaRt.hpp:54
static Error_t getSymbolAddress(void **devPtr, void const *symbol)
static Error_t memcpy3DAsync(Memcpy3DParms_t const *p, Stream_t stream)
static Error_t eventRecord(Event_t event, Stream_t stream)
static Error_t launchHostFunc(Stream_t stream, HostFn_t fn, void *userData)
::cudaLimit Limit_t
Definition ApiCudaRt.hpp:30
static Error_t eventCreate(Event_t *event)
static constexpr Flag_t hostRegisterIoMemory
Definition ApiCudaRt.hpp:60
::cudaExtent Extent_t
Definition ApiCudaRt.hpp:26
static constexpr DeviceAttr_t deviceAttributeMaxGridDimX
Definition ApiCudaRt.hpp:73
static constexpr Flag_t streamDefault
Definition ApiCudaRt.hpp:67
static Error_t hostRegister(void *ptr, size_t size, Flag_t flags)
static Error_t setDevice(int device)
static constexpr MemcpyKind_t memcpyDeviceToHost
Definition ApiCudaRt.hpp:64
::cudaDeviceAttr DeviceAttr_t
Definition ApiCudaRt.hpp:22
static constexpr DeviceAttr_t deviceAttributeMaxBlockDimY
Definition ApiCudaRt.hpp:71
static Error_t malloc3D(PitchedPtr_t *pitchedDevPtr, Extent_t extent)
static Error_t memset3DAsync(PitchedPtr_t pitchedDevPtr, int value, Extent_t extent, Stream_t stream)
::cudaDeviceProp DeviceProp_t
Definition ApiCudaRt.hpp:23
static Error_t memcpy(void *dst, void const *src, size_t count, MemcpyKind_t kind)
static constexpr MemcpyKind_t memcpyDefault
Definition ApiCudaRt.hpp:62
static constexpr DeviceAttr_t deviceAttributeMaxGridDimZ
Definition ApiCudaRt.hpp:75
static Error_t deviceGetLimit(size_t *pValue, Limit_t limit)
static Error_t eventCreateWithFlags(Event_t *event, Flag_t flags)
static constexpr Error_t errorHostMemoryNotRegistered
Definition ApiCudaRt.hpp:41
static constexpr DeviceAttr_t deviceAttributeWarpSize
Definition ApiCudaRt.hpp:79
static Error_t memsetAsync(void *devPtr, int value, size_t count, Stream_t stream)
static constexpr DeviceAttr_t deviceAttributeMaxGridDimY
Definition ApiCudaRt.hpp:74
static Error_t eventDestroy(Event_t event)
static constexpr Error_t errorUnsupportedLimit
Definition ApiCudaRt.hpp:42