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