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