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