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