• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Auto-generated, do not edit.
2
3extern "C" {
4
5extern __host__ cudaError_t CUDARTAPI cudaDeviceReset(void) {
6  using FuncPtr = cudaError_t(CUDARTAPI *)();
7  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceReset");
8  if (!func_ptr) return GetSymbolNotFoundError();
9  return func_ptr();
10}
11
12extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
13cudaDeviceSynchronize(void) {
14  using FuncPtr = cudaError_t(CUDARTAPI *)();
15  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceSynchronize");
16  if (!func_ptr) return GetSymbolNotFoundError();
17  return func_ptr();
18}
19
20extern __host__ cudaError_t CUDARTAPI cudaDeviceSetLimit(enum cudaLimit limit,
21                                                         size_t value) {
22  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaLimit, size_t);
23  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceSetLimit");
24  if (!func_ptr) return GetSymbolNotFoundError();
25  return func_ptr(limit, value);
26}
27
28extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
29cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit) {
30  using FuncPtr = cudaError_t(CUDARTAPI *)(size_t *, enum cudaLimit);
31  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetLimit");
32  if (!func_ptr) return GetSymbolNotFoundError();
33  return func_ptr(pValue, limit);
34}
35
36extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
37cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig) {
38  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaFuncCache *);
39  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetCacheConfig");
40  if (!func_ptr) return GetSymbolNotFoundError();
41  return func_ptr(pCacheConfig);
42}
43
44extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
45cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority) {
46  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, int *);
47  static auto func_ptr =
48      LoadSymbol<FuncPtr>("cudaDeviceGetStreamPriorityRange");
49  if (!func_ptr) return GetSymbolNotFoundError();
50  return func_ptr(leastPriority, greatestPriority);
51}
52
53extern __host__ cudaError_t CUDARTAPI
54cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig) {
55  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaFuncCache);
56  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceSetCacheConfig");
57  if (!func_ptr) return GetSymbolNotFoundError();
58  return func_ptr(cacheConfig);
59}
60
61extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
62cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig) {
63  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaSharedMemConfig *);
64  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetSharedMemConfig");
65  if (!func_ptr) return GetSymbolNotFoundError();
66  return func_ptr(pConfig);
67}
68
69extern __host__ cudaError_t CUDARTAPI
70cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config) {
71  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaSharedMemConfig);
72  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceSetSharedMemConfig");
73  if (!func_ptr) return GetSymbolNotFoundError();
74  return func_ptr(config);
75}
76
77extern __host__ cudaError_t CUDARTAPI
78cudaDeviceGetByPCIBusId(int *device, const char *pciBusId) {
79  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, const char *);
80  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetByPCIBusId");
81  if (!func_ptr) return GetSymbolNotFoundError();
82  return func_ptr(device, pciBusId);
83}
84
85extern __host__ cudaError_t CUDARTAPI cudaDeviceGetPCIBusId(char *pciBusId,
86                                                            int len,
87                                                            int device) {
88  using FuncPtr = cudaError_t(CUDARTAPI *)(char *, int, int);
89  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetPCIBusId");
90  if (!func_ptr) return GetSymbolNotFoundError();
91  return func_ptr(pciBusId, len, device);
92}
93
94extern __host__ cudaError_t CUDARTAPI
95cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event) {
96  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaIpcEventHandle_t *, cudaEvent_t);
97  static auto func_ptr = LoadSymbol<FuncPtr>("cudaIpcGetEventHandle");
98  if (!func_ptr) return GetSymbolNotFoundError();
99  return func_ptr(handle, event);
100}
101
102extern __host__ cudaError_t CUDARTAPI
103cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle) {
104  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t *, cudaIpcEventHandle_t);
105  static auto func_ptr = LoadSymbol<FuncPtr>("cudaIpcOpenEventHandle");
106  if (!func_ptr) return GetSymbolNotFoundError();
107  return func_ptr(event, handle);
108}
109
110extern __host__ cudaError_t CUDARTAPI
111cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr) {
112  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaIpcMemHandle_t *, void *);
113  static auto func_ptr = LoadSymbol<FuncPtr>("cudaIpcGetMemHandle");
114  if (!func_ptr) return GetSymbolNotFoundError();
115  return func_ptr(handle, devPtr);
116}
117
118extern __host__ cudaError_t CUDARTAPI cudaIpcOpenMemHandle(
119    void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags) {
120  using FuncPtr =
121      cudaError_t(CUDARTAPI *)(void **, cudaIpcMemHandle_t, unsigned int);
122  static auto func_ptr = LoadSymbol<FuncPtr>("cudaIpcOpenMemHandle");
123  if (!func_ptr) return GetSymbolNotFoundError();
124  return func_ptr(devPtr, handle, flags);
125}
126
127extern __host__ cudaError_t CUDARTAPI cudaIpcCloseMemHandle(void *devPtr) {
128  using FuncPtr = cudaError_t(CUDARTAPI *)(void *);
129  static auto func_ptr = LoadSymbol<FuncPtr>("cudaIpcCloseMemHandle");
130  if (!func_ptr) return GetSymbolNotFoundError();
131  return func_ptr(devPtr);
132}
133
134extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI cudaThreadExit(void) {
135  using FuncPtr = cudaError_t(CUDARTAPI *)();
136  static auto func_ptr = LoadSymbol<FuncPtr>("cudaThreadExit");
137  if (!func_ptr) return GetSymbolNotFoundError();
138  return func_ptr();
139}
140
141extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
142cudaThreadSynchronize(void) {
143  using FuncPtr = cudaError_t(CUDARTAPI *)();
144  static auto func_ptr = LoadSymbol<FuncPtr>("cudaThreadSynchronize");
145  if (!func_ptr) return GetSymbolNotFoundError();
146  return func_ptr();
147}
148
149extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
150cudaThreadSetLimit(enum cudaLimit limit, size_t value) {
151  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaLimit, size_t);
152  static auto func_ptr = LoadSymbol<FuncPtr>("cudaThreadSetLimit");
153  if (!func_ptr) return GetSymbolNotFoundError();
154  return func_ptr(limit, value);
155}
156
157extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
158cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit) {
159  using FuncPtr = cudaError_t(CUDARTAPI *)(size_t *, enum cudaLimit);
160  static auto func_ptr = LoadSymbol<FuncPtr>("cudaThreadGetLimit");
161  if (!func_ptr) return GetSymbolNotFoundError();
162  return func_ptr(pValue, limit);
163}
164
165extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
166cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig) {
167  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaFuncCache *);
168  static auto func_ptr = LoadSymbol<FuncPtr>("cudaThreadGetCacheConfig");
169  if (!func_ptr) return GetSymbolNotFoundError();
170  return func_ptr(pCacheConfig);
171}
172
173extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
174cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig) {
175  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaFuncCache);
176  static auto func_ptr = LoadSymbol<FuncPtr>("cudaThreadSetCacheConfig");
177  if (!func_ptr) return GetSymbolNotFoundError();
178  return func_ptr(cacheConfig);
179}
180
181extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
182cudaGetLastError(void) {
183  using FuncPtr = cudaError_t(CUDARTAPI *)();
184  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetLastError");
185  if (!func_ptr) return GetSymbolNotFoundError();
186  return func_ptr();
187}
188
189extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
190cudaPeekAtLastError(void) {
191  using FuncPtr = cudaError_t(CUDARTAPI *)();
192  static auto func_ptr = LoadSymbol<FuncPtr>("cudaPeekAtLastError");
193  if (!func_ptr) return GetSymbolNotFoundError();
194  return func_ptr();
195}
196
197extern __host__ __cudart_builtin__ const char *CUDARTAPI
198cudaGetErrorName(cudaError_t error) {
199  using FuncPtr = const char *(CUDARTAPI *)(cudaError_t);
200  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetErrorName");
201  if (!func_ptr) return "cudaGetErrorName symbol not found.";
202  return func_ptr(error);
203}
204
205extern __host__ __cudart_builtin__ const char *CUDARTAPI
206cudaGetErrorString(cudaError_t error) {
207  using FuncPtr = const char *(CUDARTAPI *)(cudaError_t);
208  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetErrorString");
209  if (!func_ptr) return "cudaGetErrorString symbol not found.";
210  return func_ptr(error);
211}
212
213extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
214cudaGetDeviceCount(int *count) {
215  using FuncPtr = cudaError_t(CUDARTAPI *)(int *);
216  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetDeviceCount");
217  if (!func_ptr) return GetSymbolNotFoundError();
218  return func_ptr(count);
219}
220
221extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
222cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device) {
223  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaDeviceProp *, int);
224  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetDeviceProperties");
225  if (!func_ptr) return GetSymbolNotFoundError();
226  return func_ptr(prop, device);
227}
228
229extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
230cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device) {
231  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, enum cudaDeviceAttr, int);
232  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetAttribute");
233  if (!func_ptr) return GetSymbolNotFoundError();
234  return func_ptr(value, attr, device);
235}
236
237extern __host__ cudaError_t CUDARTAPI cudaDeviceGetNvSciSyncAttributes(
238    void *nvSciSyncAttrList, int device, int flags) {
239  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, int, int);
240  static auto func_ptr =
241      LoadSymbol<FuncPtr>("cudaDeviceGetNvSciSyncAttributes");
242  if (!func_ptr) return GetSymbolNotFoundError();
243  return func_ptr(nvSciSyncAttrList, device, flags);
244}
245
246extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
247cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr,
248                          int srcDevice, int dstDevice) {
249  using FuncPtr =
250      cudaError_t(CUDARTAPI *)(int *, enum cudaDeviceP2PAttr, int, int);
251  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetP2PAttribute");
252  if (!func_ptr) return GetSymbolNotFoundError();
253  return func_ptr(value, attr, srcDevice, dstDevice);
254}
255
256extern __host__ cudaError_t CUDARTAPI
257cudaChooseDevice(int *device, const struct cudaDeviceProp *prop) {
258  using FuncPtr =
259      cudaError_t(CUDARTAPI *)(int *, const struct cudaDeviceProp *);
260  static auto func_ptr = LoadSymbol<FuncPtr>("cudaChooseDevice");
261  if (!func_ptr) return GetSymbolNotFoundError();
262  return func_ptr(device, prop);
263}
264
265extern __host__ cudaError_t CUDARTAPI cudaSetDevice(int device) {
266  using FuncPtr = cudaError_t(CUDARTAPI *)(int);
267  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDevice");
268  if (!func_ptr) return GetSymbolNotFoundError();
269  return func_ptr(device);
270}
271
272extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
273cudaGetDevice(int *device) {
274  using FuncPtr = cudaError_t(CUDARTAPI *)(int *);
275  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetDevice");
276  if (!func_ptr) return GetSymbolNotFoundError();
277  return func_ptr(device);
278}
279
280extern __host__ cudaError_t CUDARTAPI cudaSetValidDevices(int *device_arr,
281                                                          int len) {
282  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, int);
283  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetValidDevices");
284  if (!func_ptr) return GetSymbolNotFoundError();
285  return func_ptr(device_arr, len);
286}
287
288extern __host__ cudaError_t CUDARTAPI cudaSetDeviceFlags(unsigned int flags) {
289  using FuncPtr = cudaError_t(CUDARTAPI *)(unsigned int);
290  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDeviceFlags");
291  if (!func_ptr) return GetSymbolNotFoundError();
292  return func_ptr(flags);
293}
294
295extern __host__ cudaError_t CUDARTAPI cudaGetDeviceFlags(unsigned int *flags) {
296  using FuncPtr = cudaError_t(CUDARTAPI *)(unsigned int *);
297  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetDeviceFlags");
298  if (!func_ptr) return GetSymbolNotFoundError();
299  return func_ptr(flags);
300}
301
302extern __host__ cudaError_t CUDARTAPI cudaStreamCreate(cudaStream_t *pStream) {
303  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t *);
304  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamCreate");
305  if (!func_ptr) return GetSymbolNotFoundError();
306  return func_ptr(pStream);
307}
308
309extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
310cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags) {
311  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t *, unsigned int);
312  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamCreateWithFlags");
313  if (!func_ptr) return GetSymbolNotFoundError();
314  return func_ptr(pStream, flags);
315}
316
317extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
318cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags,
319                             int priority) {
320  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t *, unsigned int, int);
321  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamCreateWithPriority");
322  if (!func_ptr) return GetSymbolNotFoundError();
323  return func_ptr(pStream, flags, priority);
324}
325
326extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
327cudaStreamGetPriority(cudaStream_t hStream, int *priority) {
328  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, int *);
329  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamGetPriority");
330  if (!func_ptr) return GetSymbolNotFoundError();
331  return func_ptr(hStream, priority);
332}
333
334extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
335cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags) {
336  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, unsigned int *);
337  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamGetFlags");
338  if (!func_ptr) return GetSymbolNotFoundError();
339  return func_ptr(hStream, flags);
340}
341
342extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
343cudaStreamDestroy(cudaStream_t stream) {
344  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t);
345  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamDestroy");
346  if (!func_ptr) return GetSymbolNotFoundError();
347  return func_ptr(stream);
348}
349
350extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaStreamWaitEvent(
351    cudaStream_t stream, cudaEvent_t event, unsigned int flags) {
352  using FuncPtr =
353      cudaError_t(CUDARTAPI *)(cudaStream_t, cudaEvent_t, unsigned int);
354  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamWaitEvent");
355  if (!func_ptr) return GetSymbolNotFoundError();
356  return func_ptr(stream, event, flags);
357}
358
359extern __host__ cudaError_t CUDARTAPI
360cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback,
361                      void *userData, unsigned int flags) {
362  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, cudaStreamCallback_t,
363                                           void *, unsigned int);
364  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamAddCallback");
365  if (!func_ptr) return GetSymbolNotFoundError();
366  return func_ptr(stream, callback, userData, flags);
367}
368
369extern __host__ cudaError_t CUDARTAPI
370cudaStreamSynchronize(cudaStream_t stream) {
371  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t);
372  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamSynchronize");
373  if (!func_ptr) return GetSymbolNotFoundError();
374  return func_ptr(stream);
375}
376
377extern __host__ cudaError_t CUDARTAPI cudaStreamQuery(cudaStream_t stream) {
378  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t);
379  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamQuery");
380  if (!func_ptr) return GetSymbolNotFoundError();
381  return func_ptr(stream);
382}
383
384extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
385cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr,
386                         size_t length __dv(0),
387                         unsigned int flags __dv(cudaMemAttachSingle)) {
388  using FuncPtr =
389      cudaError_t(CUDARTAPI *)(cudaStream_t, void *, size_t, unsigned int);
390  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamAttachMemAsync");
391  if (!func_ptr) return GetSymbolNotFoundError();
392  return func_ptr(stream, devPtr, length, flags);
393}
394
395extern __host__ cudaError_t CUDARTAPI
396cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode) {
397  using FuncPtr =
398      cudaError_t(CUDARTAPI *)(cudaStream_t, enum cudaStreamCaptureMode);
399  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamBeginCapture");
400  if (!func_ptr) return GetSymbolNotFoundError();
401  return func_ptr(stream, mode);
402}
403
404extern __host__ cudaError_t CUDARTAPI
405cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode) {
406  using FuncPtr = cudaError_t(CUDARTAPI *)(enum cudaStreamCaptureMode *);
407  static auto func_ptr =
408      LoadSymbol<FuncPtr>("cudaThreadExchangeStreamCaptureMode");
409  if (!func_ptr) return GetSymbolNotFoundError();
410  return func_ptr(mode);
411}
412
413extern __host__ cudaError_t CUDARTAPI
414cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph) {
415  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, cudaGraph_t *);
416  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamEndCapture");
417  if (!func_ptr) return GetSymbolNotFoundError();
418  return func_ptr(stream, pGraph);
419}
420
421extern __host__ cudaError_t CUDARTAPI cudaStreamIsCapturing(
422    cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus) {
423  using FuncPtr =
424      cudaError_t(CUDARTAPI *)(cudaStream_t, enum cudaStreamCaptureStatus *);
425  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamIsCapturing");
426  if (!func_ptr) return GetSymbolNotFoundError();
427  return func_ptr(stream, pCaptureStatus);
428}
429
430extern __host__ cudaError_t CUDARTAPI cudaStreamGetCaptureInfo(
431    cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus,
432    unsigned long long *pId) {
433  using FuncPtr = cudaError_t(CUDARTAPI *)(
434      cudaStream_t, enum cudaStreamCaptureStatus *, unsigned long long *);
435  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamGetCaptureInfo");
436  if (!func_ptr) return GetSymbolNotFoundError();
437  return func_ptr(stream, pCaptureStatus, pId);
438}
439
440extern __host__ cudaError_t CUDARTAPI cudaEventCreate(cudaEvent_t *event) {
441  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t *);
442  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventCreate");
443  if (!func_ptr) return GetSymbolNotFoundError();
444  return func_ptr(event);
445}
446
447extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
448cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags) {
449  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t *, unsigned int);
450  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventCreateWithFlags");
451  if (!func_ptr) return GetSymbolNotFoundError();
452  return func_ptr(event, flags);
453}
454
455extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
456cudaEventRecord(cudaEvent_t event, cudaStream_t stream __dv(0)) {
457  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t, cudaStream_t);
458  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventRecord");
459  if (!func_ptr) return GetSymbolNotFoundError();
460  return func_ptr(event, stream);
461}
462
463extern __host__ cudaError_t CUDARTAPI cudaEventQuery(cudaEvent_t event) {
464  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t);
465  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventQuery");
466  if (!func_ptr) return GetSymbolNotFoundError();
467  return func_ptr(event);
468}
469
470extern __host__ cudaError_t CUDARTAPI cudaEventSynchronize(cudaEvent_t event) {
471  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t);
472  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventSynchronize");
473  if (!func_ptr) return GetSymbolNotFoundError();
474  return func_ptr(event);
475}
476
477extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
478cudaEventDestroy(cudaEvent_t event) {
479  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t);
480  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventDestroy");
481  if (!func_ptr) return GetSymbolNotFoundError();
482  return func_ptr(event);
483}
484
485extern __host__ cudaError_t CUDARTAPI cudaEventElapsedTime(float *ms,
486                                                           cudaEvent_t start,
487                                                           cudaEvent_t end) {
488  using FuncPtr = cudaError_t(CUDARTAPI *)(float *, cudaEvent_t, cudaEvent_t);
489  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventElapsedTime");
490  if (!func_ptr) return GetSymbolNotFoundError();
491  return func_ptr(ms, start, end);
492}
493
494extern __host__ cudaError_t CUDARTAPI cudaImportExternalMemory(
495    cudaExternalMemory_t *extMem_out,
496    const struct cudaExternalMemoryHandleDesc *memHandleDesc) {
497  using FuncPtr = cudaError_t(CUDARTAPI *)(
498      cudaExternalMemory_t *, const struct cudaExternalMemoryHandleDesc *);
499  static auto func_ptr = LoadSymbol<FuncPtr>("cudaImportExternalMemory");
500  if (!func_ptr) return GetSymbolNotFoundError();
501  return func_ptr(extMem_out, memHandleDesc);
502}
503
504extern __host__ cudaError_t CUDARTAPI cudaExternalMemoryGetMappedBuffer(
505    void **devPtr, cudaExternalMemory_t extMem,
506    const struct cudaExternalMemoryBufferDesc *bufferDesc) {
507  using FuncPtr =
508      cudaError_t(CUDARTAPI *)(void **, cudaExternalMemory_t,
509                               const struct cudaExternalMemoryBufferDesc *);
510  static auto func_ptr =
511      LoadSymbol<FuncPtr>("cudaExternalMemoryGetMappedBuffer");
512  if (!func_ptr) return GetSymbolNotFoundError();
513  return func_ptr(devPtr, extMem, bufferDesc);
514}
515
516extern __host__ cudaError_t CUDARTAPI cudaExternalMemoryGetMappedMipmappedArray(
517    cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem,
518    const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc) {
519  using FuncPtr = cudaError_t(CUDARTAPI *)(
520      cudaMipmappedArray_t *, cudaExternalMemory_t,
521      const struct cudaExternalMemoryMipmappedArrayDesc *);
522  static auto func_ptr =
523      LoadSymbol<FuncPtr>("cudaExternalMemoryGetMappedMipmappedArray");
524  if (!func_ptr) return GetSymbolNotFoundError();
525  return func_ptr(mipmap, extMem, mipmapDesc);
526}
527
528extern __host__ cudaError_t CUDARTAPI
529cudaDestroyExternalMemory(cudaExternalMemory_t extMem) {
530  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaExternalMemory_t);
531  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDestroyExternalMemory");
532  if (!func_ptr) return GetSymbolNotFoundError();
533  return func_ptr(extMem);
534}
535
536extern __host__ cudaError_t CUDARTAPI cudaImportExternalSemaphore(
537    cudaExternalSemaphore_t *extSem_out,
538    const struct cudaExternalSemaphoreHandleDesc *semHandleDesc) {
539  using FuncPtr =
540      cudaError_t(CUDARTAPI *)(cudaExternalSemaphore_t *,
541                               const struct cudaExternalSemaphoreHandleDesc *);
542  static auto func_ptr = LoadSymbol<FuncPtr>("cudaImportExternalSemaphore");
543  if (!func_ptr) return GetSymbolNotFoundError();
544  return func_ptr(extSem_out, semHandleDesc);
545}
546
547extern __host__ cudaError_t CUDARTAPI cudaSignalExternalSemaphoresAsync(
548    const cudaExternalSemaphore_t *extSemArray,
549    const struct cudaExternalSemaphoreSignalParams *paramsArray,
550    unsigned int numExtSems, cudaStream_t stream __dv(0)) {
551  using FuncPtr =
552      cudaError_t(CUDARTAPI *)(const cudaExternalSemaphore_t *,
553                               const struct cudaExternalSemaphoreSignalParams *,
554                               unsigned int, cudaStream_t);
555  static auto func_ptr =
556      LoadSymbol<FuncPtr>("cudaSignalExternalSemaphoresAsync");
557  if (!func_ptr) return GetSymbolNotFoundError();
558  return func_ptr(extSemArray, paramsArray, numExtSems, stream);
559}
560
561extern __host__ cudaError_t CUDARTAPI cudaWaitExternalSemaphoresAsync(
562    const cudaExternalSemaphore_t *extSemArray,
563    const struct cudaExternalSemaphoreWaitParams *paramsArray,
564    unsigned int numExtSems, cudaStream_t stream __dv(0)) {
565  using FuncPtr =
566      cudaError_t(CUDARTAPI *)(const cudaExternalSemaphore_t *,
567                               const struct cudaExternalSemaphoreWaitParams *,
568                               unsigned int, cudaStream_t);
569  static auto func_ptr = LoadSymbol<FuncPtr>("cudaWaitExternalSemaphoresAsync");
570  if (!func_ptr) return GetSymbolNotFoundError();
571  return func_ptr(extSemArray, paramsArray, numExtSems, stream);
572}
573
574extern __host__ cudaError_t CUDARTAPI
575cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) {
576  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaExternalSemaphore_t);
577  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDestroyExternalSemaphore");
578  if (!func_ptr) return GetSymbolNotFoundError();
579  return func_ptr(extSem);
580}
581
582extern __host__ cudaError_t CUDARTAPI
583cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args,
584                 size_t sharedMem, cudaStream_t stream) {
585  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, dim3, dim3, void **,
586                                           size_t, cudaStream_t);
587  static auto func_ptr = LoadSymbol<FuncPtr>("cudaLaunchKernel");
588  if (!func_ptr) return GetSymbolNotFoundError();
589  return func_ptr(func, gridDim, blockDim, args, sharedMem, stream);
590}
591
592extern __host__ cudaError_t CUDARTAPI cudaLaunchCooperativeKernel(
593    const void *func, dim3 gridDim, dim3 blockDim, void **args,
594    size_t sharedMem, cudaStream_t stream) {
595  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, dim3, dim3, void **,
596                                           size_t, cudaStream_t);
597  static auto func_ptr = LoadSymbol<FuncPtr>("cudaLaunchCooperativeKernel");
598  if (!func_ptr) return GetSymbolNotFoundError();
599  return func_ptr(func, gridDim, blockDim, args, sharedMem, stream);
600}
601
602extern __host__ cudaError_t CUDARTAPI cudaLaunchCooperativeKernelMultiDevice(
603    struct cudaLaunchParams *launchParamsList, unsigned int numDevices,
604    unsigned int flags __dv(0)) {
605  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaLaunchParams *,
606                                           unsigned int, unsigned int);
607  static auto func_ptr =
608      LoadSymbol<FuncPtr>("cudaLaunchCooperativeKernelMultiDevice");
609  if (!func_ptr) return GetSymbolNotFoundError();
610  return func_ptr(launchParamsList, numDevices, flags);
611}
612
613extern __host__ cudaError_t CUDARTAPI
614cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig) {
615  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, enum cudaFuncCache);
616  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncSetCacheConfig");
617  if (!func_ptr) return GetSymbolNotFoundError();
618  return func_ptr(func, cacheConfig);
619}
620
621extern __host__ cudaError_t CUDARTAPI
622cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config) {
623  using FuncPtr =
624      cudaError_t(CUDARTAPI *)(const void *, enum cudaSharedMemConfig);
625  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncSetSharedMemConfig");
626  if (!func_ptr) return GetSymbolNotFoundError();
627  return func_ptr(func, config);
628}
629
630extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
631cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func) {
632  using FuncPtr =
633      cudaError_t(CUDARTAPI *)(struct cudaFuncAttributes *, const void *);
634  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncGetAttributes");
635  if (!func_ptr) return GetSymbolNotFoundError();
636  return func_ptr(attr, func);
637}
638
639extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
640cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value) {
641  using FuncPtr =
642      cudaError_t(CUDARTAPI *)(const void *, enum cudaFuncAttribute, int);
643  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncSetAttribute");
644  if (!func_ptr) return GetSymbolNotFoundError();
645  return func_ptr(func, attr, value);
646}
647
648extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
649cudaSetDoubleForDevice(double *d) {
650  using FuncPtr = cudaError_t(CUDARTAPI *)(double *);
651  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDoubleForDevice");
652  if (!func_ptr) return GetSymbolNotFoundError();
653  return func_ptr(d);
654}
655
656extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
657cudaSetDoubleForHost(double *d) {
658  using FuncPtr = cudaError_t(CUDARTAPI *)(double *);
659  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDoubleForHost");
660  if (!func_ptr) return GetSymbolNotFoundError();
661  return func_ptr(d);
662}
663
664extern __host__ cudaError_t CUDARTAPI cudaLaunchHostFunc(cudaStream_t stream,
665                                                         cudaHostFn_t fn,
666                                                         void *userData) {
667  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, cudaHostFn_t, void *);
668  static auto func_ptr = LoadSymbol<FuncPtr>("cudaLaunchHostFunc");
669  if (!func_ptr) return GetSymbolNotFoundError();
670  return func_ptr(stream, fn, userData);
671}
672
673extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
674cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func,
675                                              int blockSize,
676                                              size_t dynamicSMemSize) {
677  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, const void *, int, size_t);
678  static auto func_ptr =
679      LoadSymbol<FuncPtr>("cudaOccupancyMaxActiveBlocksPerMultiprocessor");
680  if (!func_ptr) return GetSymbolNotFoundError();
681  return func_ptr(numBlocks, func, blockSize, dynamicSMemSize);
682}
683
684extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
685cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks,
686                                                       const void *func,
687                                                       int blockSize,
688                                                       size_t dynamicSMemSize,
689                                                       unsigned int flags) {
690  using FuncPtr =
691      cudaError_t(CUDARTAPI *)(int *, const void *, int, size_t, unsigned int);
692  static auto func_ptr = LoadSymbol<FuncPtr>(
693      "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags");
694  if (!func_ptr) return GetSymbolNotFoundError();
695  return func_ptr(numBlocks, func, blockSize, dynamicSMemSize, flags);
696}
697
698extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMallocManaged(
699    void **devPtr, size_t size, unsigned int flags __dv(cudaMemAttachGlobal)) {
700  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t, unsigned int);
701  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocManaged");
702  if (!func_ptr) return GetSymbolNotFoundError();
703  return func_ptr(devPtr, size, flags);
704}
705
706extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
707cudaMalloc(void **devPtr, size_t size) {
708  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t);
709  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMalloc");
710  if (!func_ptr) return GetSymbolNotFoundError();
711  return func_ptr(devPtr, size);
712}
713
714extern __host__ cudaError_t CUDARTAPI cudaMallocHost(void **ptr, size_t size) {
715  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t);
716  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocHost");
717  if (!func_ptr) return GetSymbolNotFoundError();
718  return func_ptr(ptr, size);
719}
720
721extern __host__ cudaError_t CUDARTAPI cudaMallocPitch(void **devPtr,
722                                                      size_t *pitch,
723                                                      size_t width,
724                                                      size_t height) {
725  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t *, size_t, size_t);
726  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocPitch");
727  if (!func_ptr) return GetSymbolNotFoundError();
728  return func_ptr(devPtr, pitch, width, height);
729}
730
731extern __host__ cudaError_t CUDARTAPI cudaMallocArray(
732    cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width,
733    size_t height __dv(0), unsigned int flags __dv(0)) {
734  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t *,
735                                           const struct cudaChannelFormatDesc *,
736                                           size_t, size_t, unsigned int);
737  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocArray");
738  if (!func_ptr) return GetSymbolNotFoundError();
739  return func_ptr(array, desc, width, height, flags);
740}
741
742extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
743cudaFree(void *devPtr) {
744  using FuncPtr = cudaError_t(CUDARTAPI *)(void *);
745  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFree");
746  if (!func_ptr) return GetSymbolNotFoundError();
747  return func_ptr(devPtr);
748}
749
750extern __host__ cudaError_t CUDARTAPI cudaFreeHost(void *ptr) {
751  using FuncPtr = cudaError_t(CUDARTAPI *)(void *);
752  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFreeHost");
753  if (!func_ptr) return GetSymbolNotFoundError();
754  return func_ptr(ptr);
755}
756
757extern __host__ cudaError_t CUDARTAPI cudaFreeArray(cudaArray_t array) {
758  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t);
759  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFreeArray");
760  if (!func_ptr) return GetSymbolNotFoundError();
761  return func_ptr(array);
762}
763
764extern __host__ cudaError_t CUDARTAPI
765cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) {
766  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaMipmappedArray_t);
767  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFreeMipmappedArray");
768  if (!func_ptr) return GetSymbolNotFoundError();
769  return func_ptr(mipmappedArray);
770}
771
772extern __host__ cudaError_t CUDARTAPI cudaHostAlloc(void **pHost, size_t size,
773                                                    unsigned int flags) {
774  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t, unsigned int);
775  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostAlloc");
776  if (!func_ptr) return GetSymbolNotFoundError();
777  return func_ptr(pHost, size, flags);
778}
779
780extern __host__ cudaError_t CUDARTAPI cudaHostRegister(void *ptr, size_t size,
781                                                       unsigned int flags) {
782  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, unsigned int);
783  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostRegister");
784  if (!func_ptr) return GetSymbolNotFoundError();
785  return func_ptr(ptr, size, flags);
786}
787
788extern __host__ cudaError_t CUDARTAPI cudaHostUnregister(void *ptr) {
789  using FuncPtr = cudaError_t(CUDARTAPI *)(void *);
790  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostUnregister");
791  if (!func_ptr) return GetSymbolNotFoundError();
792  return func_ptr(ptr);
793}
794
795extern __host__ cudaError_t CUDARTAPI
796cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags) {
797  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, void *, unsigned int);
798  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostGetDevicePointer");
799  if (!func_ptr) return GetSymbolNotFoundError();
800  return func_ptr(pDevice, pHost, flags);
801}
802
803extern __host__ cudaError_t CUDARTAPI cudaHostGetFlags(unsigned int *pFlags,
804                                                       void *pHost) {
805  using FuncPtr = cudaError_t(CUDARTAPI *)(unsigned int *, void *);
806  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostGetFlags");
807  if (!func_ptr) return GetSymbolNotFoundError();
808  return func_ptr(pFlags, pHost);
809}
810
811extern __host__ cudaError_t CUDARTAPI
812cudaMalloc3D(struct cudaPitchedPtr *pitchedDevPtr, struct cudaExtent extent) {
813  using FuncPtr =
814      cudaError_t(CUDARTAPI *)(struct cudaPitchedPtr *, struct cudaExtent);
815  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMalloc3D");
816  if (!func_ptr) return GetSymbolNotFoundError();
817  return func_ptr(pitchedDevPtr, extent);
818}
819
820extern __host__ cudaError_t CUDARTAPI
821cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc,
822                  struct cudaExtent extent, unsigned int flags __dv(0)) {
823  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t *,
824                                           const struct cudaChannelFormatDesc *,
825                                           struct cudaExtent, unsigned int);
826  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMalloc3DArray");
827  if (!func_ptr) return GetSymbolNotFoundError();
828  return func_ptr(array, desc, extent, flags);
829}
830
831extern __host__ cudaError_t CUDARTAPI cudaMallocMipmappedArray(
832    cudaMipmappedArray_t *mipmappedArray,
833    const struct cudaChannelFormatDesc *desc, struct cudaExtent extent,
834    unsigned int numLevels, unsigned int flags __dv(0)) {
835  using FuncPtr = cudaError_t(CUDARTAPI *)(
836      cudaMipmappedArray_t *, const struct cudaChannelFormatDesc *,
837      struct cudaExtent, unsigned int, unsigned int);
838  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocMipmappedArray");
839  if (!func_ptr) return GetSymbolNotFoundError();
840  return func_ptr(mipmappedArray, desc, extent, numLevels, flags);
841}
842
843extern __host__ cudaError_t CUDARTAPI cudaGetMipmappedArrayLevel(
844    cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray,
845    unsigned int level) {
846  using FuncPtr = cudaError_t(CUDARTAPI *)(
847      cudaArray_t *, cudaMipmappedArray_const_t, unsigned int);
848  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetMipmappedArrayLevel");
849  if (!func_ptr) return GetSymbolNotFoundError();
850  return func_ptr(levelArray, mipmappedArray, level);
851}
852
853extern __host__ cudaError_t CUDARTAPI
854cudaMemcpy3D(const struct cudaMemcpy3DParms *p) {
855  using FuncPtr = cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DParms *);
856  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3D");
857  if (!func_ptr) return GetSymbolNotFoundError();
858  return func_ptr(p);
859}
860
861extern __host__ cudaError_t CUDARTAPI
862cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p) {
863  using FuncPtr =
864      cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DPeerParms *);
865  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3DPeer");
866  if (!func_ptr) return GetSymbolNotFoundError();
867  return func_ptr(p);
868}
869
870extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMemcpy3DAsync(
871    const struct cudaMemcpy3DParms *p, cudaStream_t stream __dv(0)) {
872  using FuncPtr =
873      cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DParms *, cudaStream_t);
874  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3DAsync");
875  if (!func_ptr) return GetSymbolNotFoundError();
876  return func_ptr(p, stream);
877}
878
879extern __host__ cudaError_t CUDARTAPI cudaMemcpy3DPeerAsync(
880    const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream __dv(0)) {
881  using FuncPtr = cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DPeerParms *,
882                                           cudaStream_t);
883  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3DPeerAsync");
884  if (!func_ptr) return GetSymbolNotFoundError();
885  return func_ptr(p, stream);
886}
887
888extern __host__ cudaError_t CUDARTAPI cudaMemGetInfo(size_t *free,
889                                                     size_t *total) {
890  using FuncPtr = cudaError_t(CUDARTAPI *)(size_t *, size_t *);
891  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemGetInfo");
892  if (!func_ptr) return GetSymbolNotFoundError();
893  return func_ptr(free, total);
894}
895
896extern __host__ cudaError_t CUDARTAPI
897cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent,
898                 unsigned int *flags, cudaArray_t array) {
899  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaChannelFormatDesc *,
900                                           struct cudaExtent *, unsigned int *,
901                                           cudaArray_t);
902  static auto func_ptr = LoadSymbol<FuncPtr>("cudaArrayGetInfo");
903  if (!func_ptr) return GetSymbolNotFoundError();
904  return func_ptr(desc, extent, flags, array);
905}
906
907extern __host__ cudaError_t CUDARTAPI cudaMemcpy(void *dst, const void *src,
908                                                 size_t count,
909                                                 enum cudaMemcpyKind kind) {
910  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t,
911                                           enum cudaMemcpyKind);
912  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy");
913  if (!func_ptr) return GetSymbolNotFoundError();
914  return func_ptr(dst, src, count, kind);
915}
916
917extern __host__ cudaError_t CUDARTAPI cudaMemcpyPeer(void *dst, int dstDevice,
918                                                     const void *src,
919                                                     int srcDevice,
920                                                     size_t count) {
921  using FuncPtr =
922      cudaError_t(CUDARTAPI *)(void *, int, const void *, int, size_t);
923  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyPeer");
924  if (!func_ptr) return GetSymbolNotFoundError();
925  return func_ptr(dst, dstDevice, src, srcDevice, count);
926}
927
928extern __host__ cudaError_t CUDARTAPI cudaMemcpy2D(void *dst, size_t dpitch,
929                                                   const void *src,
930                                                   size_t spitch, size_t width,
931                                                   size_t height,
932                                                   enum cudaMemcpyKind kind) {
933  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, const void *, size_t,
934                                           size_t, size_t, enum cudaMemcpyKind);
935  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2D");
936  if (!func_ptr) return GetSymbolNotFoundError();
937  return func_ptr(dst, dpitch, src, spitch, width, height, kind);
938}
939
940extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DToArray(
941    cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src,
942    size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind) {
943  using FuncPtr =
944      cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t, const void *,
945                               size_t, size_t, size_t, enum cudaMemcpyKind);
946  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DToArray");
947  if (!func_ptr) return GetSymbolNotFoundError();
948  return func_ptr(dst, wOffset, hOffset, src, spitch, width, height, kind);
949}
950
951extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArray(
952    void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset,
953    size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind) {
954  using FuncPtr =
955      cudaError_t(CUDARTAPI *)(void *, size_t, cudaArray_const_t, size_t,
956                               size_t, size_t, size_t, enum cudaMemcpyKind);
957  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DFromArray");
958  if (!func_ptr) return GetSymbolNotFoundError();
959  return func_ptr(dst, dpitch, src, wOffset, hOffset, width, height, kind);
960}
961
962extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DArrayToArray(
963    cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst,
964    cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width,
965    size_t height, enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) {
966  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t,
967                                           cudaArray_const_t, size_t, size_t,
968                                           size_t, size_t, enum cudaMemcpyKind);
969  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DArrayToArray");
970  if (!func_ptr) return GetSymbolNotFoundError();
971  return func_ptr(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc,
972                  width, height, kind);
973}
974
975extern __host__ cudaError_t CUDARTAPI cudaMemcpyToSymbol(
976    const void *symbol, const void *src, size_t count, size_t offset __dv(0),
977    enum cudaMemcpyKind kind __dv(cudaMemcpyHostToDevice)) {
978  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, const void *, size_t,
979                                           size_t, enum cudaMemcpyKind);
980  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToSymbol");
981  if (!func_ptr) return GetSymbolNotFoundError();
982  return func_ptr(symbol, src, count, offset, kind);
983}
984
985extern __host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbol(
986    void *dst, const void *symbol, size_t count, size_t offset __dv(0),
987    enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToHost)) {
988  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t, size_t,
989                                           enum cudaMemcpyKind);
990  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromSymbol");
991  if (!func_ptr) return GetSymbolNotFoundError();
992  return func_ptr(dst, symbol, count, offset, kind);
993}
994
995extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
996cudaMemcpyAsync(void *dst, const void *src, size_t count,
997                enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
998  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t,
999                                           enum cudaMemcpyKind, cudaStream_t);
1000  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyAsync");
1001  if (!func_ptr) return GetSymbolNotFoundError();
1002  return func_ptr(dst, src, count, kind, stream);
1003}
1004
1005extern __host__ cudaError_t CUDARTAPI
1006cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice,
1007                    size_t count, cudaStream_t stream __dv(0)) {
1008  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, int, const void *, int,
1009                                           size_t, cudaStream_t);
1010  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyPeerAsync");
1011  if (!func_ptr) return GetSymbolNotFoundError();
1012  return func_ptr(dst, dstDevice, src, srcDevice, count, stream);
1013}
1014
1015extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMemcpy2DAsync(
1016    void *dst, size_t dpitch, const void *src, size_t spitch, size_t width,
1017    size_t height, enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
1018  using FuncPtr =
1019      cudaError_t(CUDARTAPI *)(void *, size_t, const void *, size_t, size_t,
1020                               size_t, enum cudaMemcpyKind, cudaStream_t);
1021  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DAsync");
1022  if (!func_ptr) return GetSymbolNotFoundError();
1023  return func_ptr(dst, dpitch, src, spitch, width, height, kind, stream);
1024}
1025
1026extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DToArrayAsync(
1027    cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src,
1028    size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind,
1029    cudaStream_t stream __dv(0)) {
1030  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t,
1031                                           const void *, size_t, size_t, size_t,
1032                                           enum cudaMemcpyKind, cudaStream_t);
1033  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DToArrayAsync");
1034  if (!func_ptr) return GetSymbolNotFoundError();
1035  return func_ptr(dst, wOffset, hOffset, src, spitch, width, height, kind,
1036                  stream);
1037}
1038
1039extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArrayAsync(
1040    void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset,
1041    size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind,
1042    cudaStream_t stream __dv(0)) {
1043  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, cudaArray_const_t,
1044                                           size_t, size_t, size_t, size_t,
1045                                           enum cudaMemcpyKind, cudaStream_t);
1046  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DFromArrayAsync");
1047  if (!func_ptr) return GetSymbolNotFoundError();
1048  return func_ptr(dst, dpitch, src, wOffset, hOffset, width, height, kind,
1049                  stream);
1050}
1051
1052extern __host__ cudaError_t CUDARTAPI cudaMemcpyToSymbolAsync(
1053    const void *symbol, const void *src, size_t count, size_t offset,
1054    enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
1055  using FuncPtr =
1056      cudaError_t(CUDARTAPI *)(const void *, const void *, size_t, size_t,
1057                               enum cudaMemcpyKind, cudaStream_t);
1058  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToSymbolAsync");
1059  if (!func_ptr) return GetSymbolNotFoundError();
1060  return func_ptr(symbol, src, count, offset, kind, stream);
1061}
1062
1063extern __host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbolAsync(
1064    void *dst, const void *symbol, size_t count, size_t offset,
1065    enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
1066  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t, size_t,
1067                                           enum cudaMemcpyKind, cudaStream_t);
1068  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromSymbolAsync");
1069  if (!func_ptr) return GetSymbolNotFoundError();
1070  return func_ptr(dst, symbol, count, offset, kind, stream);
1071}
1072
1073extern __host__ cudaError_t CUDARTAPI cudaMemset(void *devPtr, int value,
1074                                                 size_t count) {
1075  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, int, size_t);
1076  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset");
1077  if (!func_ptr) return GetSymbolNotFoundError();
1078  return func_ptr(devPtr, value, count);
1079}
1080
1081extern __host__ cudaError_t CUDARTAPI cudaMemset2D(void *devPtr, size_t pitch,
1082                                                   int value, size_t width,
1083                                                   size_t height) {
1084  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, int, size_t, size_t);
1085  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset2D");
1086  if (!func_ptr) return GetSymbolNotFoundError();
1087  return func_ptr(devPtr, pitch, value, width, height);
1088}
1089
1090extern __host__ cudaError_t CUDARTAPI cudaMemset3D(
1091    struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent) {
1092  using FuncPtr =
1093      cudaError_t(CUDARTAPI *)(struct cudaPitchedPtr, int, struct cudaExtent);
1094  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset3D");
1095  if (!func_ptr) return GetSymbolNotFoundError();
1096  return func_ptr(pitchedDevPtr, value, extent);
1097}
1098
1099extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMemsetAsync(
1100    void *devPtr, int value, size_t count, cudaStream_t stream __dv(0)) {
1101  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, int, size_t, cudaStream_t);
1102  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemsetAsync");
1103  if (!func_ptr) return GetSymbolNotFoundError();
1104  return func_ptr(devPtr, value, count, stream);
1105}
1106
1107extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
1108cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width,
1109                  size_t height, cudaStream_t stream __dv(0)) {
1110  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, int, size_t, size_t,
1111                                           cudaStream_t);
1112  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset2DAsync");
1113  if (!func_ptr) return GetSymbolNotFoundError();
1114  return func_ptr(devPtr, pitch, value, width, height, stream);
1115}
1116
1117extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
1118cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value,
1119                  struct cudaExtent extent, cudaStream_t stream __dv(0)) {
1120  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaPitchedPtr, int,
1121                                           struct cudaExtent, cudaStream_t);
1122  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset3DAsync");
1123  if (!func_ptr) return GetSymbolNotFoundError();
1124  return func_ptr(pitchedDevPtr, value, extent, stream);
1125}
1126
1127extern __host__ cudaError_t CUDARTAPI cudaGetSymbolAddress(void **devPtr,
1128                                                           const void *symbol) {
1129  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, const void *);
1130  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetSymbolAddress");
1131  if (!func_ptr) return GetSymbolNotFoundError();
1132  return func_ptr(devPtr, symbol);
1133}
1134
1135extern __host__ cudaError_t CUDARTAPI cudaGetSymbolSize(size_t *size,
1136                                                        const void *symbol) {
1137  using FuncPtr = cudaError_t(CUDARTAPI *)(size_t *, const void *);
1138  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetSymbolSize");
1139  if (!func_ptr) return GetSymbolNotFoundError();
1140  return func_ptr(size, symbol);
1141}
1142
1143extern __host__ cudaError_t CUDARTAPI
1144cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice,
1145                     cudaStream_t stream __dv(0)) {
1146  using FuncPtr =
1147      cudaError_t(CUDARTAPI *)(const void *, size_t, int, cudaStream_t);
1148  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemPrefetchAsync");
1149  if (!func_ptr) return GetSymbolNotFoundError();
1150  return func_ptr(devPtr, count, dstDevice, stream);
1151}
1152
1153extern __host__ cudaError_t CUDARTAPI
1154cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice,
1155              int device) {
1156  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, size_t,
1157                                           enum cudaMemoryAdvise, int);
1158  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemAdvise");
1159  if (!func_ptr) return GetSymbolNotFoundError();
1160  return func_ptr(devPtr, count, advice, device);
1161}
1162
1163extern __host__ cudaError_t CUDARTAPI cudaMemRangeGetAttribute(
1164    void *data, size_t dataSize, enum cudaMemRangeAttribute attribute,
1165    const void *devPtr, size_t count) {
1166  using FuncPtr = cudaError_t(CUDARTAPI *)(
1167      void *, size_t, enum cudaMemRangeAttribute, const void *, size_t);
1168  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemRangeGetAttribute");
1169  if (!func_ptr) return GetSymbolNotFoundError();
1170  return func_ptr(data, dataSize, attribute, devPtr, count);
1171}
1172
1173extern __host__ cudaError_t CUDARTAPI cudaMemRangeGetAttributes(
1174    void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes,
1175    size_t numAttributes, const void *devPtr, size_t count) {
1176  using FuncPtr =
1177      cudaError_t(CUDARTAPI *)(void **, size_t *, enum cudaMemRangeAttribute *,
1178                               size_t, const void *, size_t);
1179  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemRangeGetAttributes");
1180  if (!func_ptr) return GetSymbolNotFoundError();
1181  return func_ptr(data, dataSizes, attributes, numAttributes, devPtr, count);
1182}
1183
1184extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
1185cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset,
1186                  const void *src, size_t count, enum cudaMemcpyKind kind) {
1187  using FuncPtr = cudaError_t(CUDARTAPI *)(
1188      cudaArray_t, size_t, size_t, const void *, size_t, enum cudaMemcpyKind);
1189  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToArray");
1190  if (!func_ptr) return GetSymbolNotFoundError();
1191  return func_ptr(dst, wOffset, hOffset, src, count, kind);
1192}
1193
1194extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
1195cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset,
1196                    size_t hOffset, size_t count, enum cudaMemcpyKind kind) {
1197  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, cudaArray_const_t, size_t,
1198                                           size_t, size_t, enum cudaMemcpyKind);
1199  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromArray");
1200  if (!func_ptr) return GetSymbolNotFoundError();
1201  return func_ptr(dst, src, wOffset, hOffset, count, kind);
1202}
1203
1204extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI cudaMemcpyArrayToArray(
1205    cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst,
1206    cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count,
1207    enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) {
1208  using FuncPtr =
1209      cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t, cudaArray_const_t,
1210                               size_t, size_t, size_t, enum cudaMemcpyKind);
1211  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyArrayToArray");
1212  if (!func_ptr) return GetSymbolNotFoundError();
1213  return func_ptr(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc,
1214                  count, kind);
1215}
1216
1217extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI cudaMemcpyToArrayAsync(
1218    cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src,
1219    size_t count, enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
1220  using FuncPtr =
1221      cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t, const void *,
1222                               size_t, enum cudaMemcpyKind, cudaStream_t);
1223  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToArrayAsync");
1224  if (!func_ptr) return GetSymbolNotFoundError();
1225  return func_ptr(dst, wOffset, hOffset, src, count, kind, stream);
1226}
1227
1228extern __CUDA_DEPRECATED __host__ cudaError_t CUDARTAPI
1229cudaMemcpyFromArrayAsync(void *dst, cudaArray_const_t src, size_t wOffset,
1230                         size_t hOffset, size_t count, enum cudaMemcpyKind kind,
1231                         cudaStream_t stream __dv(0)) {
1232  using FuncPtr =
1233      cudaError_t(CUDARTAPI *)(void *, cudaArray_const_t, size_t, size_t,
1234                               size_t, enum cudaMemcpyKind, cudaStream_t);
1235  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromArrayAsync");
1236  if (!func_ptr) return GetSymbolNotFoundError();
1237  return func_ptr(dst, src, wOffset, hOffset, count, kind, stream);
1238}
1239
1240extern __host__ cudaError_t CUDARTAPI cudaPointerGetAttributes(
1241    struct cudaPointerAttributes *attributes, const void *ptr) {
1242  using FuncPtr =
1243      cudaError_t(CUDARTAPI *)(struct cudaPointerAttributes *, const void *);
1244  static auto func_ptr = LoadSymbol<FuncPtr>("cudaPointerGetAttributes");
1245  if (!func_ptr) return GetSymbolNotFoundError();
1246  return func_ptr(attributes, ptr);
1247}
1248
1249extern __host__ cudaError_t CUDARTAPI
1250cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice) {
1251  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, int, int);
1252  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceCanAccessPeer");
1253  if (!func_ptr) return GetSymbolNotFoundError();
1254  return func_ptr(canAccessPeer, device, peerDevice);
1255}
1256
1257extern __host__ cudaError_t CUDARTAPI
1258cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) {
1259  using FuncPtr = cudaError_t(CUDARTAPI *)(int, unsigned int);
1260  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceEnablePeerAccess");
1261  if (!func_ptr) return GetSymbolNotFoundError();
1262  return func_ptr(peerDevice, flags);
1263}
1264
1265extern __host__ cudaError_t CUDARTAPI
1266cudaDeviceDisablePeerAccess(int peerDevice) {
1267  using FuncPtr = cudaError_t(CUDARTAPI *)(int);
1268  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceDisablePeerAccess");
1269  if (!func_ptr) return GetSymbolNotFoundError();
1270  return func_ptr(peerDevice);
1271}
1272
1273extern __host__ cudaError_t CUDARTAPI
1274cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) {
1275  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphicsResource_t);
1276  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsUnregisterResource");
1277  if (!func_ptr) return GetSymbolNotFoundError();
1278  return func_ptr(resource);
1279}
1280
1281extern __host__ cudaError_t CUDARTAPI cudaGraphicsResourceSetMapFlags(
1282    cudaGraphicsResource_t resource, unsigned int flags) {
1283  using FuncPtr =
1284      cudaError_t(CUDARTAPI *)(cudaGraphicsResource_t, unsigned int);
1285  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsResourceSetMapFlags");
1286  if (!func_ptr) return GetSymbolNotFoundError();
1287  return func_ptr(resource, flags);
1288}
1289
1290extern __host__ cudaError_t CUDARTAPI cudaGraphicsMapResources(
1291    int count, cudaGraphicsResource_t *resources, cudaStream_t stream __dv(0)) {
1292  using FuncPtr =
1293      cudaError_t(CUDARTAPI *)(int, cudaGraphicsResource_t *, cudaStream_t);
1294  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsMapResources");
1295  if (!func_ptr) return GetSymbolNotFoundError();
1296  return func_ptr(count, resources, stream);
1297}
1298
1299extern __host__ cudaError_t CUDARTAPI cudaGraphicsUnmapResources(
1300    int count, cudaGraphicsResource_t *resources, cudaStream_t stream __dv(0)) {
1301  using FuncPtr =
1302      cudaError_t(CUDARTAPI *)(int, cudaGraphicsResource_t *, cudaStream_t);
1303  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsUnmapResources");
1304  if (!func_ptr) return GetSymbolNotFoundError();
1305  return func_ptr(count, resources, stream);
1306}
1307
1308extern __host__ cudaError_t CUDARTAPI cudaGraphicsResourceGetMappedPointer(
1309    void **devPtr, size_t *size, cudaGraphicsResource_t resource) {
1310  using FuncPtr =
1311      cudaError_t(CUDARTAPI *)(void **, size_t *, cudaGraphicsResource_t);
1312  static auto func_ptr =
1313      LoadSymbol<FuncPtr>("cudaGraphicsResourceGetMappedPointer");
1314  if (!func_ptr) return GetSymbolNotFoundError();
1315  return func_ptr(devPtr, size, resource);
1316}
1317
1318extern __host__ cudaError_t CUDARTAPI cudaGraphicsSubResourceGetMappedArray(
1319    cudaArray_t *array, cudaGraphicsResource_t resource,
1320    unsigned int arrayIndex, unsigned int mipLevel) {
1321  using FuncPtr = cudaError_t(CUDARTAPI *)(
1322      cudaArray_t *, cudaGraphicsResource_t, unsigned int, unsigned int);
1323  static auto func_ptr =
1324      LoadSymbol<FuncPtr>("cudaGraphicsSubResourceGetMappedArray");
1325  if (!func_ptr) return GetSymbolNotFoundError();
1326  return func_ptr(array, resource, arrayIndex, mipLevel);
1327}
1328
1329extern __host__ cudaError_t CUDARTAPI
1330cudaGraphicsResourceGetMappedMipmappedArray(
1331    cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource) {
1332  using FuncPtr =
1333      cudaError_t(CUDARTAPI *)(cudaMipmappedArray_t *, cudaGraphicsResource_t);
1334  static auto func_ptr =
1335      LoadSymbol<FuncPtr>("cudaGraphicsResourceGetMappedMipmappedArray");
1336  if (!func_ptr) return GetSymbolNotFoundError();
1337  return func_ptr(mipmappedArray, resource);
1338}
1339
1340extern __host__ cudaError_t CUDARTAPI cudaBindTexture(
1341    size_t *offset, const struct textureReference *texref, const void *devPtr,
1342    const struct cudaChannelFormatDesc *desc, size_t size __dv(UINT_MAX)) {
1343  using FuncPtr = cudaError_t(CUDARTAPI *)(
1344      size_t *, const struct textureReference *, const void *,
1345      const struct cudaChannelFormatDesc *, size_t);
1346  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTexture");
1347  if (!func_ptr) return GetSymbolNotFoundError();
1348  return func_ptr(offset, texref, devPtr, desc, size);
1349}
1350
1351extern __host__ cudaError_t CUDARTAPI
1352cudaBindTexture2D(size_t *offset, const struct textureReference *texref,
1353                  const void *devPtr, const struct cudaChannelFormatDesc *desc,
1354                  size_t width, size_t height, size_t pitch) {
1355  using FuncPtr = cudaError_t(CUDARTAPI *)(
1356      size_t *, const struct textureReference *, const void *,
1357      const struct cudaChannelFormatDesc *, size_t, size_t, size_t);
1358  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTexture2D");
1359  if (!func_ptr) return GetSymbolNotFoundError();
1360  return func_ptr(offset, texref, devPtr, desc, width, height, pitch);
1361}
1362
1363extern __host__ cudaError_t CUDARTAPI cudaBindTextureToArray(
1364    const struct textureReference *texref, cudaArray_const_t array,
1365    const struct cudaChannelFormatDesc *desc) {
1366  using FuncPtr = cudaError_t(CUDARTAPI *)(
1367      const struct textureReference *, cudaArray_const_t,
1368      const struct cudaChannelFormatDesc *);
1369  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTextureToArray");
1370  if (!func_ptr) return GetSymbolNotFoundError();
1371  return func_ptr(texref, array, desc);
1372}
1373
1374extern __host__ cudaError_t CUDARTAPI
1375cudaBindTextureToMipmappedArray(const struct textureReference *texref,
1376                                cudaMipmappedArray_const_t mipmappedArray,
1377                                const struct cudaChannelFormatDesc *desc) {
1378  using FuncPtr = cudaError_t(CUDARTAPI *)(
1379      const struct textureReference *, cudaMipmappedArray_const_t,
1380      const struct cudaChannelFormatDesc *);
1381  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTextureToMipmappedArray");
1382  if (!func_ptr) return GetSymbolNotFoundError();
1383  return func_ptr(texref, mipmappedArray, desc);
1384}
1385
1386extern __host__ cudaError_t CUDARTAPI
1387cudaUnbindTexture(const struct textureReference *texref) {
1388  using FuncPtr = cudaError_t(CUDARTAPI *)(const struct textureReference *);
1389  static auto func_ptr = LoadSymbol<FuncPtr>("cudaUnbindTexture");
1390  if (!func_ptr) return GetSymbolNotFoundError();
1391  return func_ptr(texref);
1392}
1393
1394extern __host__ cudaError_t CUDARTAPI cudaGetTextureAlignmentOffset(
1395    size_t *offset, const struct textureReference *texref) {
1396  using FuncPtr =
1397      cudaError_t(CUDARTAPI *)(size_t *, const struct textureReference *);
1398  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetTextureAlignmentOffset");
1399  if (!func_ptr) return GetSymbolNotFoundError();
1400  return func_ptr(offset, texref);
1401}
1402
1403extern __host__ cudaError_t CUDARTAPI cudaGetTextureReference(
1404    const struct textureReference **texref, const void *symbol) {
1405  using FuncPtr =
1406      cudaError_t(CUDARTAPI *)(const struct textureReference **, const void *);
1407  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetTextureReference");
1408  if (!func_ptr) return GetSymbolNotFoundError();
1409  return func_ptr(texref, symbol);
1410}
1411
1412extern __host__ cudaError_t CUDARTAPI cudaBindSurfaceToArray(
1413    const struct surfaceReference *surfref, cudaArray_const_t array,
1414    const struct cudaChannelFormatDesc *desc) {
1415  using FuncPtr = cudaError_t(CUDARTAPI *)(
1416      const struct surfaceReference *, cudaArray_const_t,
1417      const struct cudaChannelFormatDesc *);
1418  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindSurfaceToArray");
1419  if (!func_ptr) return GetSymbolNotFoundError();
1420  return func_ptr(surfref, array, desc);
1421}
1422
1423extern __host__ cudaError_t CUDARTAPI cudaGetSurfaceReference(
1424    const struct surfaceReference **surfref, const void *symbol) {
1425  using FuncPtr =
1426      cudaError_t(CUDARTAPI *)(const struct surfaceReference **, const void *);
1427  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetSurfaceReference");
1428  if (!func_ptr) return GetSymbolNotFoundError();
1429  return func_ptr(surfref, symbol);
1430}
1431
1432extern __host__ cudaError_t CUDARTAPI cudaGetChannelDesc(
1433    struct cudaChannelFormatDesc *desc, cudaArray_const_t array) {
1434  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaChannelFormatDesc *,
1435                                           cudaArray_const_t);
1436  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetChannelDesc");
1437  if (!func_ptr) return GetSymbolNotFoundError();
1438  return func_ptr(desc, array);
1439}
1440
1441extern __host__ cudaError_t CUDARTAPI cudaCreateTextureObject(
1442    cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc,
1443    const struct cudaTextureDesc *pTexDesc,
1444    const struct cudaResourceViewDesc *pResViewDesc) {
1445  using FuncPtr = cudaError_t(CUDARTAPI *)(
1446      cudaTextureObject_t *, const struct cudaResourceDesc *,
1447      const struct cudaTextureDesc *, const struct cudaResourceViewDesc *);
1448  static auto func_ptr = LoadSymbol<FuncPtr>("cudaCreateTextureObject");
1449  if (!func_ptr) return GetSymbolNotFoundError();
1450  return func_ptr(pTexObject, pResDesc, pTexDesc, pResViewDesc);
1451}
1452
1453extern __host__ cudaError_t CUDARTAPI
1454cudaDestroyTextureObject(cudaTextureObject_t texObject) {
1455  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaTextureObject_t);
1456  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDestroyTextureObject");
1457  if (!func_ptr) return GetSymbolNotFoundError();
1458  return func_ptr(texObject);
1459}
1460
1461extern __host__ cudaError_t CUDARTAPI cudaGetTextureObjectResourceDesc(
1462    struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject) {
1463  using FuncPtr =
1464      cudaError_t(CUDARTAPI *)(struct cudaResourceDesc *, cudaTextureObject_t);
1465  static auto func_ptr =
1466      LoadSymbol<FuncPtr>("cudaGetTextureObjectResourceDesc");
1467  if (!func_ptr) return GetSymbolNotFoundError();
1468  return func_ptr(pResDesc, texObject);
1469}
1470
1471extern __host__ cudaError_t CUDARTAPI cudaGetTextureObjectTextureDesc(
1472    struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject) {
1473  using FuncPtr =
1474      cudaError_t(CUDARTAPI *)(struct cudaTextureDesc *, cudaTextureObject_t);
1475  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetTextureObjectTextureDesc");
1476  if (!func_ptr) return GetSymbolNotFoundError();
1477  return func_ptr(pTexDesc, texObject);
1478}
1479
1480extern __host__ cudaError_t CUDARTAPI cudaGetTextureObjectResourceViewDesc(
1481    struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject) {
1482  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaResourceViewDesc *,
1483                                           cudaTextureObject_t);
1484  static auto func_ptr =
1485      LoadSymbol<FuncPtr>("cudaGetTextureObjectResourceViewDesc");
1486  if (!func_ptr) return GetSymbolNotFoundError();
1487  return func_ptr(pResViewDesc, texObject);
1488}
1489
1490extern __host__ cudaError_t CUDARTAPI cudaCreateSurfaceObject(
1491    cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc) {
1492  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaSurfaceObject_t *,
1493                                           const struct cudaResourceDesc *);
1494  static auto func_ptr = LoadSymbol<FuncPtr>("cudaCreateSurfaceObject");
1495  if (!func_ptr) return GetSymbolNotFoundError();
1496  return func_ptr(pSurfObject, pResDesc);
1497}
1498
1499extern __host__ cudaError_t CUDARTAPI
1500cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) {
1501  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaSurfaceObject_t);
1502  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDestroySurfaceObject");
1503  if (!func_ptr) return GetSymbolNotFoundError();
1504  return func_ptr(surfObject);
1505}
1506
1507extern __host__ cudaError_t CUDARTAPI cudaGetSurfaceObjectResourceDesc(
1508    struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject) {
1509  using FuncPtr =
1510      cudaError_t(CUDARTAPI *)(struct cudaResourceDesc *, cudaSurfaceObject_t);
1511  static auto func_ptr =
1512      LoadSymbol<FuncPtr>("cudaGetSurfaceObjectResourceDesc");
1513  if (!func_ptr) return GetSymbolNotFoundError();
1514  return func_ptr(pResDesc, surfObject);
1515}
1516
1517extern __host__ cudaError_t CUDARTAPI cudaDriverGetVersion(int *driverVersion) {
1518  using FuncPtr = cudaError_t(CUDARTAPI *)(int *);
1519  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDriverGetVersion");
1520  if (!func_ptr) return GetSymbolNotFoundError();
1521  return func_ptr(driverVersion);
1522}
1523
1524extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
1525cudaRuntimeGetVersion(int *runtimeVersion) {
1526  using FuncPtr = cudaError_t(CUDARTAPI *)(int *);
1527  static auto func_ptr = LoadSymbol<FuncPtr>("cudaRuntimeGetVersion");
1528  if (!func_ptr) return GetSymbolNotFoundError();
1529  return func_ptr(runtimeVersion);
1530}
1531
1532extern __host__ cudaError_t CUDARTAPI cudaGraphCreate(cudaGraph_t *pGraph,
1533                                                      unsigned int flags) {
1534  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraph_t *, unsigned int);
1535  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphCreate");
1536  if (!func_ptr) return GetSymbolNotFoundError();
1537  return func_ptr(pGraph, flags);
1538}
1539
1540extern __host__ cudaError_t CUDARTAPI cudaGraphAddKernelNode(
1541    cudaGraphNode_t *pGraphNode, cudaGraph_t graph,
1542    const cudaGraphNode_t *pDependencies, size_t numDependencies,
1543    const struct cudaKernelNodeParams *pNodeParams) {
1544  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t *, cudaGraph_t,
1545                                           const cudaGraphNode_t *, size_t,
1546                                           const struct cudaKernelNodeParams *);
1547  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphAddKernelNode");
1548  if (!func_ptr) return GetSymbolNotFoundError();
1549  return func_ptr(pGraphNode, graph, pDependencies, numDependencies,
1550                  pNodeParams);
1551}
1552
1553extern __host__ cudaError_t CUDARTAPI cudaGraphKernelNodeGetParams(
1554    cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams) {
1555  using FuncPtr =
1556      cudaError_t(CUDARTAPI *)(cudaGraphNode_t, struct cudaKernelNodeParams *);
1557  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphKernelNodeGetParams");
1558  if (!func_ptr) return GetSymbolNotFoundError();
1559  return func_ptr(node, pNodeParams);
1560}
1561
1562extern __host__ cudaError_t CUDARTAPI cudaGraphKernelNodeSetParams(
1563    cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams) {
1564  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t,
1565                                           const struct cudaKernelNodeParams *);
1566  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphKernelNodeSetParams");
1567  if (!func_ptr) return GetSymbolNotFoundError();
1568  return func_ptr(node, pNodeParams);
1569}
1570
1571extern __host__ cudaError_t CUDARTAPI cudaGraphAddMemcpyNode(
1572    cudaGraphNode_t *pGraphNode, cudaGraph_t graph,
1573    const cudaGraphNode_t *pDependencies, size_t numDependencies,
1574    const struct cudaMemcpy3DParms *pCopyParams) {
1575  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t *, cudaGraph_t,
1576                                           const cudaGraphNode_t *, size_t,
1577                                           const struct cudaMemcpy3DParms *);
1578  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphAddMemcpyNode");
1579  if (!func_ptr) return GetSymbolNotFoundError();
1580  return func_ptr(pGraphNode, graph, pDependencies, numDependencies,
1581                  pCopyParams);
1582}
1583
1584extern __host__ cudaError_t CUDARTAPI cudaGraphMemcpyNodeGetParams(
1585    cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams) {
1586  using FuncPtr =
1587      cudaError_t(CUDARTAPI *)(cudaGraphNode_t, struct cudaMemcpy3DParms *);
1588  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphMemcpyNodeGetParams");
1589  if (!func_ptr) return GetSymbolNotFoundError();
1590  return func_ptr(node, pNodeParams);
1591}
1592
1593extern __host__ cudaError_t CUDARTAPI cudaGraphMemcpyNodeSetParams(
1594    cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams) {
1595  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t,
1596                                           const struct cudaMemcpy3DParms *);
1597  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphMemcpyNodeSetParams");
1598  if (!func_ptr) return GetSymbolNotFoundError();
1599  return func_ptr(node, pNodeParams);
1600}
1601
1602extern __host__ cudaError_t CUDARTAPI cudaGraphAddMemsetNode(
1603    cudaGraphNode_t *pGraphNode, cudaGraph_t graph,
1604    const cudaGraphNode_t *pDependencies, size_t numDependencies,
1605    const struct cudaMemsetParams *pMemsetParams) {
1606  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t *, cudaGraph_t,
1607                                           const cudaGraphNode_t *, size_t,
1608                                           const struct cudaMemsetParams *);
1609  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphAddMemsetNode");
1610  if (!func_ptr) return GetSymbolNotFoundError();
1611  return func_ptr(pGraphNode, graph, pDependencies, numDependencies,
1612                  pMemsetParams);
1613}
1614
1615extern __host__ cudaError_t CUDARTAPI cudaGraphMemsetNodeGetParams(
1616    cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams) {
1617  using FuncPtr =
1618      cudaError_t(CUDARTAPI *)(cudaGraphNode_t, struct cudaMemsetParams *);
1619  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphMemsetNodeGetParams");
1620  if (!func_ptr) return GetSymbolNotFoundError();
1621  return func_ptr(node, pNodeParams);
1622}
1623
1624extern __host__ cudaError_t CUDARTAPI cudaGraphMemsetNodeSetParams(
1625    cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams) {
1626  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t,
1627                                           const struct cudaMemsetParams *);
1628  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphMemsetNodeSetParams");
1629  if (!func_ptr) return GetSymbolNotFoundError();
1630  return func_ptr(node, pNodeParams);
1631}
1632
1633extern __host__ cudaError_t CUDARTAPI cudaGraphAddHostNode(
1634    cudaGraphNode_t *pGraphNode, cudaGraph_t graph,
1635    const cudaGraphNode_t *pDependencies, size_t numDependencies,
1636    const struct cudaHostNodeParams *pNodeParams) {
1637  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t *, cudaGraph_t,
1638                                           const cudaGraphNode_t *, size_t,
1639                                           const struct cudaHostNodeParams *);
1640  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphAddHostNode");
1641  if (!func_ptr) return GetSymbolNotFoundError();
1642  return func_ptr(pGraphNode, graph, pDependencies, numDependencies,
1643                  pNodeParams);
1644}
1645
1646extern __host__ cudaError_t CUDARTAPI cudaGraphHostNodeGetParams(
1647    cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams) {
1648  using FuncPtr =
1649      cudaError_t(CUDARTAPI *)(cudaGraphNode_t, struct cudaHostNodeParams *);
1650  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphHostNodeGetParams");
1651  if (!func_ptr) return GetSymbolNotFoundError();
1652  return func_ptr(node, pNodeParams);
1653}
1654
1655extern __host__ cudaError_t CUDARTAPI cudaGraphHostNodeSetParams(
1656    cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams) {
1657  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t,
1658                                           const struct cudaHostNodeParams *);
1659  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphHostNodeSetParams");
1660  if (!func_ptr) return GetSymbolNotFoundError();
1661  return func_ptr(node, pNodeParams);
1662}
1663
1664extern __host__ cudaError_t CUDARTAPI
1665cudaGraphAddChildGraphNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph,
1666                           const cudaGraphNode_t *pDependencies,
1667                           size_t numDependencies, cudaGraph_t childGraph) {
1668  using FuncPtr =
1669      cudaError_t(CUDARTAPI *)(cudaGraphNode_t *, cudaGraph_t,
1670                               const cudaGraphNode_t *, size_t, cudaGraph_t);
1671  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphAddChildGraphNode");
1672  if (!func_ptr) return GetSymbolNotFoundError();
1673  return func_ptr(pGraphNode, graph, pDependencies, numDependencies,
1674                  childGraph);
1675}
1676
1677extern __host__ cudaError_t CUDARTAPI
1678cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph) {
1679  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t, cudaGraph_t *);
1680  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphChildGraphNodeGetGraph");
1681  if (!func_ptr) return GetSymbolNotFoundError();
1682  return func_ptr(node, pGraph);
1683}
1684
1685extern __host__ cudaError_t CUDARTAPI cudaGraphAddEmptyNode(
1686    cudaGraphNode_t *pGraphNode, cudaGraph_t graph,
1687    const cudaGraphNode_t *pDependencies, size_t numDependencies) {
1688  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t *, cudaGraph_t,
1689                                           const cudaGraphNode_t *, size_t);
1690  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphAddEmptyNode");
1691  if (!func_ptr) return GetSymbolNotFoundError();
1692  return func_ptr(pGraphNode, graph, pDependencies, numDependencies);
1693}
1694
1695extern __host__ cudaError_t CUDARTAPI
1696cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph) {
1697  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraph_t *, cudaGraph_t);
1698  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphClone");
1699  if (!func_ptr) return GetSymbolNotFoundError();
1700  return func_ptr(pGraphClone, originalGraph);
1701}
1702
1703extern __host__ cudaError_t CUDARTAPI
1704cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode,
1705                         cudaGraph_t clonedGraph) {
1706  using FuncPtr =
1707      cudaError_t(CUDARTAPI *)(cudaGraphNode_t *, cudaGraphNode_t, cudaGraph_t);
1708  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphNodeFindInClone");
1709  if (!func_ptr) return GetSymbolNotFoundError();
1710  return func_ptr(pNode, originalNode, clonedGraph);
1711}
1712
1713extern __host__ cudaError_t CUDARTAPI
1714cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType) {
1715  using FuncPtr =
1716      cudaError_t(CUDARTAPI *)(cudaGraphNode_t, enum cudaGraphNodeType *);
1717  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphNodeGetType");
1718  if (!func_ptr) return GetSymbolNotFoundError();
1719  return func_ptr(node, pType);
1720}
1721
1722extern __host__ cudaError_t CUDARTAPI cudaGraphGetNodes(cudaGraph_t graph,
1723                                                        cudaGraphNode_t *nodes,
1724                                                        size_t *numNodes) {
1725  using FuncPtr =
1726      cudaError_t(CUDARTAPI *)(cudaGraph_t, cudaGraphNode_t *, size_t *);
1727  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphGetNodes");
1728  if (!func_ptr) return GetSymbolNotFoundError();
1729  return func_ptr(graph, nodes, numNodes);
1730}
1731
1732extern __host__ cudaError_t CUDARTAPI cudaGraphGetRootNodes(
1733    cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes) {
1734  using FuncPtr =
1735      cudaError_t(CUDARTAPI *)(cudaGraph_t, cudaGraphNode_t *, size_t *);
1736  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphGetRootNodes");
1737  if (!func_ptr) return GetSymbolNotFoundError();
1738  return func_ptr(graph, pRootNodes, pNumRootNodes);
1739}
1740
1741extern __host__ cudaError_t CUDARTAPI cudaGraphGetEdges(cudaGraph_t graph,
1742                                                        cudaGraphNode_t *from,
1743                                                        cudaGraphNode_t *to,
1744                                                        size_t *numEdges) {
1745  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraph_t, cudaGraphNode_t *,
1746                                           cudaGraphNode_t *, size_t *);
1747  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphGetEdges");
1748  if (!func_ptr) return GetSymbolNotFoundError();
1749  return func_ptr(graph, from, to, numEdges);
1750}
1751
1752extern __host__ cudaError_t CUDARTAPI cudaGraphNodeGetDependencies(
1753    cudaGraphNode_t node, cudaGraphNode_t *pDependencies,
1754    size_t *pNumDependencies) {
1755  using FuncPtr =
1756      cudaError_t(CUDARTAPI *)(cudaGraphNode_t, cudaGraphNode_t *, size_t *);
1757  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphNodeGetDependencies");
1758  if (!func_ptr) return GetSymbolNotFoundError();
1759  return func_ptr(node, pDependencies, pNumDependencies);
1760}
1761
1762extern __host__ cudaError_t CUDARTAPI cudaGraphNodeGetDependentNodes(
1763    cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes,
1764    size_t *pNumDependentNodes) {
1765  using FuncPtr =
1766      cudaError_t(CUDARTAPI *)(cudaGraphNode_t, cudaGraphNode_t *, size_t *);
1767  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphNodeGetDependentNodes");
1768  if (!func_ptr) return GetSymbolNotFoundError();
1769  return func_ptr(node, pDependentNodes, pNumDependentNodes);
1770}
1771
1772extern __host__ cudaError_t CUDARTAPI
1773cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t *from,
1774                         const cudaGraphNode_t *to, size_t numDependencies) {
1775  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraph_t, const cudaGraphNode_t *,
1776                                           const cudaGraphNode_t *, size_t);
1777  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphAddDependencies");
1778  if (!func_ptr) return GetSymbolNotFoundError();
1779  return func_ptr(graph, from, to, numDependencies);
1780}
1781
1782extern __host__ cudaError_t CUDARTAPI
1783cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t *from,
1784                            const cudaGraphNode_t *to, size_t numDependencies) {
1785  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraph_t, const cudaGraphNode_t *,
1786                                           const cudaGraphNode_t *, size_t);
1787  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphRemoveDependencies");
1788  if (!func_ptr) return GetSymbolNotFoundError();
1789  return func_ptr(graph, from, to, numDependencies);
1790}
1791
1792extern __host__ cudaError_t CUDARTAPI
1793cudaGraphDestroyNode(cudaGraphNode_t node) {
1794  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphNode_t);
1795  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphDestroyNode");
1796  if (!func_ptr) return GetSymbolNotFoundError();
1797  return func_ptr(node);
1798}
1799
1800extern __host__ cudaError_t CUDARTAPI cudaGraphInstantiate(
1801    cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphNode_t *pErrorNode,
1802    char *pLogBuffer, size_t bufferSize) {
1803  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphExec_t *, cudaGraph_t,
1804                                           cudaGraphNode_t *, char *, size_t);
1805  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphInstantiate");
1806  if (!func_ptr) return GetSymbolNotFoundError();
1807  return func_ptr(pGraphExec, graph, pErrorNode, pLogBuffer, bufferSize);
1808}
1809
1810extern __host__ cudaError_t CUDARTAPI cudaGraphExecKernelNodeSetParams(
1811    cudaGraphExec_t hGraphExec, cudaGraphNode_t node,
1812    const struct cudaKernelNodeParams *pNodeParams) {
1813  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphExec_t, cudaGraphNode_t,
1814                                           const struct cudaKernelNodeParams *);
1815  static auto func_ptr =
1816      LoadSymbol<FuncPtr>("cudaGraphExecKernelNodeSetParams");
1817  if (!func_ptr) return GetSymbolNotFoundError();
1818  return func_ptr(hGraphExec, node, pNodeParams);
1819}
1820
1821extern __host__ cudaError_t CUDARTAPI cudaGraphExecMemcpyNodeSetParams(
1822    cudaGraphExec_t hGraphExec, cudaGraphNode_t node,
1823    const struct cudaMemcpy3DParms *pNodeParams) {
1824  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphExec_t, cudaGraphNode_t,
1825                                           const struct cudaMemcpy3DParms *);
1826  static auto func_ptr =
1827      LoadSymbol<FuncPtr>("cudaGraphExecMemcpyNodeSetParams");
1828  if (!func_ptr) return GetSymbolNotFoundError();
1829  return func_ptr(hGraphExec, node, pNodeParams);
1830}
1831
1832extern __host__ cudaError_t CUDARTAPI cudaGraphExecMemsetNodeSetParams(
1833    cudaGraphExec_t hGraphExec, cudaGraphNode_t node,
1834    const struct cudaMemsetParams *pNodeParams) {
1835  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphExec_t, cudaGraphNode_t,
1836                                           const struct cudaMemsetParams *);
1837  static auto func_ptr =
1838      LoadSymbol<FuncPtr>("cudaGraphExecMemsetNodeSetParams");
1839  if (!func_ptr) return GetSymbolNotFoundError();
1840  return func_ptr(hGraphExec, node, pNodeParams);
1841}
1842
1843extern __host__ cudaError_t CUDARTAPI
1844cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node,
1845                               const struct cudaHostNodeParams *pNodeParams) {
1846  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphExec_t, cudaGraphNode_t,
1847                                           const struct cudaHostNodeParams *);
1848  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphExecHostNodeSetParams");
1849  if (!func_ptr) return GetSymbolNotFoundError();
1850  return func_ptr(hGraphExec, node, pNodeParams);
1851}
1852
1853extern __host__ cudaError_t CUDARTAPI
1854cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph,
1855                    cudaGraphNode_t *hErrorNode_out,
1856                    enum cudaGraphExecUpdateResult *updateResult_out) {
1857  using FuncPtr =
1858      cudaError_t(CUDARTAPI *)(cudaGraphExec_t, cudaGraph_t, cudaGraphNode_t *,
1859                               enum cudaGraphExecUpdateResult *);
1860  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphExecUpdate");
1861  if (!func_ptr) return GetSymbolNotFoundError();
1862  return func_ptr(hGraphExec, hGraph, hErrorNode_out, updateResult_out);
1863}
1864
1865extern __host__ cudaError_t CUDARTAPI cudaGraphLaunch(cudaGraphExec_t graphExec,
1866                                                      cudaStream_t stream) {
1867  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphExec_t, cudaStream_t);
1868  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphLaunch");
1869  if (!func_ptr) return GetSymbolNotFoundError();
1870  return func_ptr(graphExec, stream);
1871}
1872
1873extern __host__ cudaError_t CUDARTAPI
1874cudaGraphExecDestroy(cudaGraphExec_t graphExec) {
1875  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphExec_t);
1876  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphExecDestroy");
1877  if (!func_ptr) return GetSymbolNotFoundError();
1878  return func_ptr(graphExec);
1879}
1880
1881extern __host__ cudaError_t CUDARTAPI cudaGraphDestroy(cudaGraph_t graph) {
1882  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraph_t);
1883  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphDestroy");
1884  if (!func_ptr) return GetSymbolNotFoundError();
1885  return func_ptr(graph);
1886}
1887
1888extern __host__ cudaError_t CUDARTAPI cudaGetExportTable(
1889    const void **ppExportTable, const cudaUUID_t *pExportTableId) {
1890  using FuncPtr = cudaError_t(CUDARTAPI *)(const void **, const cudaUUID_t *);
1891  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetExportTable");
1892  if (!func_ptr) return GetSymbolNotFoundError();
1893  return func_ptr(ppExportTable, pExportTableId);
1894}
1895
1896}  // extern "C"
1897