• 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 __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 __host__ cudaError_t CUDARTAPI cudaThreadSynchronize(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 __host__ cudaError_t CUDARTAPI cudaThreadSetLimit(enum cudaLimit limit,
149                                                         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 __host__ cudaError_t CUDARTAPI cudaThreadGetLimit(size_t *pValue,
157                                                         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 __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 __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__ __cudart_builtin__ cudaError_t CUDARTAPI
237cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr,
238                          int srcDevice, int dstDevice) {
239  using FuncPtr =
240      cudaError_t(CUDARTAPI *)(int *, enum cudaDeviceP2PAttr, int, int);
241  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceGetP2PAttribute");
242  if (!func_ptr) return GetSymbolNotFoundError();
243  return func_ptr(value, attr, srcDevice, dstDevice);
244}
245
246extern __host__ cudaError_t CUDARTAPI
247cudaChooseDevice(int *device, const struct cudaDeviceProp *prop) {
248  using FuncPtr =
249      cudaError_t(CUDARTAPI *)(int *, const struct cudaDeviceProp *);
250  static auto func_ptr = LoadSymbol<FuncPtr>("cudaChooseDevice");
251  if (!func_ptr) return GetSymbolNotFoundError();
252  return func_ptr(device, prop);
253}
254
255extern __host__ cudaError_t CUDARTAPI cudaSetDevice(int device) {
256  using FuncPtr = cudaError_t(CUDARTAPI *)(int);
257  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDevice");
258  if (!func_ptr) return GetSymbolNotFoundError();
259  return func_ptr(device);
260}
261
262extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
263cudaGetDevice(int *device) {
264  using FuncPtr = cudaError_t(CUDARTAPI *)(int *);
265  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetDevice");
266  if (!func_ptr) return GetSymbolNotFoundError();
267  return func_ptr(device);
268}
269
270extern __host__ cudaError_t CUDARTAPI cudaSetValidDevices(int *device_arr,
271                                                          int len) {
272  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, int);
273  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetValidDevices");
274  if (!func_ptr) return GetSymbolNotFoundError();
275  return func_ptr(device_arr, len);
276}
277
278extern __host__ cudaError_t CUDARTAPI cudaSetDeviceFlags(unsigned int flags) {
279  using FuncPtr = cudaError_t(CUDARTAPI *)(unsigned int);
280  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDeviceFlags");
281  if (!func_ptr) return GetSymbolNotFoundError();
282  return func_ptr(flags);
283}
284
285extern __host__ cudaError_t CUDARTAPI cudaGetDeviceFlags(unsigned int *flags) {
286  using FuncPtr = cudaError_t(CUDARTAPI *)(unsigned int *);
287  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetDeviceFlags");
288  if (!func_ptr) return GetSymbolNotFoundError();
289  return func_ptr(flags);
290}
291
292extern __host__ cudaError_t CUDARTAPI cudaStreamCreate(cudaStream_t *pStream) {
293  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t *);
294  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamCreate");
295  if (!func_ptr) return GetSymbolNotFoundError();
296  return func_ptr(pStream);
297}
298
299extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
300cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags) {
301  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t *, unsigned int);
302  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamCreateWithFlags");
303  if (!func_ptr) return GetSymbolNotFoundError();
304  return func_ptr(pStream, flags);
305}
306
307extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
308cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags,
309                             int priority) {
310  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t *, unsigned int, int);
311  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamCreateWithPriority");
312  if (!func_ptr) return GetSymbolNotFoundError();
313  return func_ptr(pStream, flags, priority);
314}
315
316extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
317cudaStreamGetPriority(cudaStream_t hStream, int *priority) {
318  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, int *);
319  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamGetPriority");
320  if (!func_ptr) return GetSymbolNotFoundError();
321  return func_ptr(hStream, priority);
322}
323
324extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
325cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags) {
326  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, unsigned int *);
327  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamGetFlags");
328  if (!func_ptr) return GetSymbolNotFoundError();
329  return func_ptr(hStream, flags);
330}
331
332extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
333cudaStreamDestroy(cudaStream_t stream) {
334  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t);
335  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamDestroy");
336  if (!func_ptr) return GetSymbolNotFoundError();
337  return func_ptr(stream);
338}
339
340extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaStreamWaitEvent(
341    cudaStream_t stream, cudaEvent_t event, unsigned int flags) {
342  using FuncPtr =
343      cudaError_t(CUDARTAPI *)(cudaStream_t, cudaEvent_t, unsigned int);
344  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamWaitEvent");
345  if (!func_ptr) return GetSymbolNotFoundError();
346  return func_ptr(stream, event, flags);
347}
348
349extern __host__ cudaError_t CUDARTAPI
350cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback,
351                      void *userData, unsigned int flags) {
352  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t, cudaStreamCallback_t,
353                                           void *, unsigned int);
354  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamAddCallback");
355  if (!func_ptr) return GetSymbolNotFoundError();
356  return func_ptr(stream, callback, userData, flags);
357}
358
359extern __host__ cudaError_t CUDARTAPI
360cudaStreamSynchronize(cudaStream_t stream) {
361  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t);
362  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamSynchronize");
363  if (!func_ptr) return GetSymbolNotFoundError();
364  return func_ptr(stream);
365}
366
367extern __host__ cudaError_t CUDARTAPI cudaStreamQuery(cudaStream_t stream) {
368  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaStream_t);
369  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamQuery");
370  if (!func_ptr) return GetSymbolNotFoundError();
371  return func_ptr(stream);
372}
373
374extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
375cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr,
376                         size_t length __dv(0),
377                         unsigned int flags __dv(cudaMemAttachSingle)) {
378  using FuncPtr =
379      cudaError_t(CUDARTAPI *)(cudaStream_t, void *, size_t, unsigned int);
380  static auto func_ptr = LoadSymbol<FuncPtr>("cudaStreamAttachMemAsync");
381  if (!func_ptr) return GetSymbolNotFoundError();
382  return func_ptr(stream, devPtr, length, flags);
383}
384
385extern __host__ cudaError_t CUDARTAPI cudaEventCreate(cudaEvent_t *event) {
386  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t *);
387  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventCreate");
388  if (!func_ptr) return GetSymbolNotFoundError();
389  return func_ptr(event);
390}
391
392extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
393cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags) {
394  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t *, unsigned int);
395  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventCreateWithFlags");
396  if (!func_ptr) return GetSymbolNotFoundError();
397  return func_ptr(event, flags);
398}
399
400extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
401cudaEventRecord(cudaEvent_t event, cudaStream_t stream __dv(0)) {
402  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t, cudaStream_t);
403  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventRecord");
404  if (!func_ptr) return GetSymbolNotFoundError();
405  return func_ptr(event, stream);
406}
407
408extern __host__ cudaError_t CUDARTAPI cudaEventQuery(cudaEvent_t event) {
409  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t);
410  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventQuery");
411  if (!func_ptr) return GetSymbolNotFoundError();
412  return func_ptr(event);
413}
414
415extern __host__ cudaError_t CUDARTAPI cudaEventSynchronize(cudaEvent_t event) {
416  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t);
417  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventSynchronize");
418  if (!func_ptr) return GetSymbolNotFoundError();
419  return func_ptr(event);
420}
421
422extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
423cudaEventDestroy(cudaEvent_t event) {
424  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaEvent_t);
425  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventDestroy");
426  if (!func_ptr) return GetSymbolNotFoundError();
427  return func_ptr(event);
428}
429
430extern __host__ cudaError_t CUDARTAPI cudaEventElapsedTime(float *ms,
431                                                           cudaEvent_t start,
432                                                           cudaEvent_t end) {
433  using FuncPtr = cudaError_t(CUDARTAPI *)(float *, cudaEvent_t, cudaEvent_t);
434  static auto func_ptr = LoadSymbol<FuncPtr>("cudaEventElapsedTime");
435  if (!func_ptr) return GetSymbolNotFoundError();
436  return func_ptr(ms, start, end);
437}
438
439extern __host__ cudaError_t CUDARTAPI
440cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args,
441                 size_t sharedMem, cudaStream_t stream) {
442  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, dim3, dim3, void **,
443                                           size_t, cudaStream_t);
444  static auto func_ptr = LoadSymbol<FuncPtr>("cudaLaunchKernel");
445  if (!func_ptr) return GetSymbolNotFoundError();
446  return func_ptr(func, gridDim, blockDim, args, sharedMem, stream);
447}
448
449extern __host__ cudaError_t CUDARTAPI cudaLaunchCooperativeKernel(
450    const void *func, dim3 gridDim, dim3 blockDim, void **args,
451    size_t sharedMem, cudaStream_t stream) {
452  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, dim3, dim3, void **,
453                                           size_t, cudaStream_t);
454  static auto func_ptr = LoadSymbol<FuncPtr>("cudaLaunchCooperativeKernel");
455  if (!func_ptr) return GetSymbolNotFoundError();
456  return func_ptr(func, gridDim, blockDim, args, sharedMem, stream);
457}
458
459extern __host__ cudaError_t CUDARTAPI cudaLaunchCooperativeKernelMultiDevice(
460    struct cudaLaunchParams *launchParamsList, unsigned int numDevices,
461    unsigned int flags __dv(0)) {
462  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaLaunchParams *,
463                                           unsigned int, unsigned int);
464  static auto func_ptr =
465      LoadSymbol<FuncPtr>("cudaLaunchCooperativeKernelMultiDevice");
466  if (!func_ptr) return GetSymbolNotFoundError();
467  return func_ptr(launchParamsList, numDevices, flags);
468}
469
470extern __host__ cudaError_t CUDARTAPI
471cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig) {
472  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, enum cudaFuncCache);
473  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncSetCacheConfig");
474  if (!func_ptr) return GetSymbolNotFoundError();
475  return func_ptr(func, cacheConfig);
476}
477
478extern __host__ cudaError_t CUDARTAPI
479cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config) {
480  using FuncPtr =
481      cudaError_t(CUDARTAPI *)(const void *, enum cudaSharedMemConfig);
482  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncSetSharedMemConfig");
483  if (!func_ptr) return GetSymbolNotFoundError();
484  return func_ptr(func, config);
485}
486
487extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
488cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func) {
489  using FuncPtr =
490      cudaError_t(CUDARTAPI *)(struct cudaFuncAttributes *, const void *);
491  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncGetAttributes");
492  if (!func_ptr) return GetSymbolNotFoundError();
493  return func_ptr(attr, func);
494}
495
496extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
497cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value) {
498  using FuncPtr =
499      cudaError_t(CUDARTAPI *)(const void *, enum cudaFuncAttribute, int);
500  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFuncSetAttribute");
501  if (!func_ptr) return GetSymbolNotFoundError();
502  return func_ptr(func, attr, value);
503}
504
505extern __host__ cudaError_t CUDARTAPI cudaSetDoubleForDevice(double *d) {
506  using FuncPtr = cudaError_t(CUDARTAPI *)(double *);
507  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDoubleForDevice");
508  if (!func_ptr) return GetSymbolNotFoundError();
509  return func_ptr(d);
510}
511
512extern __host__ cudaError_t CUDARTAPI cudaSetDoubleForHost(double *d) {
513  using FuncPtr = cudaError_t(CUDARTAPI *)(double *);
514  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetDoubleForHost");
515  if (!func_ptr) return GetSymbolNotFoundError();
516  return func_ptr(d);
517}
518
519extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
520cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func,
521                                              int blockSize,
522                                              size_t dynamicSMemSize) {
523  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, const void *, int, size_t);
524  static auto func_ptr =
525      LoadSymbol<FuncPtr>("cudaOccupancyMaxActiveBlocksPerMultiprocessor");
526  if (!func_ptr) return GetSymbolNotFoundError();
527  return func_ptr(numBlocks, func, blockSize, dynamicSMemSize);
528}
529
530extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
531cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks,
532                                                       const void *func,
533                                                       int blockSize,
534                                                       size_t dynamicSMemSize,
535                                                       unsigned int flags) {
536  using FuncPtr =
537      cudaError_t(CUDARTAPI *)(int *, const void *, int, size_t, unsigned int);
538  static auto func_ptr = LoadSymbol<FuncPtr>(
539      "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags");
540  if (!func_ptr) return GetSymbolNotFoundError();
541  return func_ptr(numBlocks, func, blockSize, dynamicSMemSize, flags);
542}
543
544extern __host__ cudaError_t CUDARTAPI
545cudaConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dv(0),
546                  cudaStream_t stream __dv(0)) {
547  using FuncPtr = cudaError_t(CUDARTAPI *)(dim3, dim3, size_t, cudaStream_t);
548  static auto func_ptr = LoadSymbol<FuncPtr>("cudaConfigureCall");
549  if (!func_ptr) return GetSymbolNotFoundError();
550  return func_ptr(gridDim, blockDim, sharedMem, stream);
551}
552
553extern __host__ cudaError_t CUDARTAPI cudaSetupArgument(const void *arg,
554                                                        size_t size,
555                                                        size_t offset) {
556  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, size_t, size_t);
557  static auto func_ptr = LoadSymbol<FuncPtr>("cudaSetupArgument");
558  if (!func_ptr) return GetSymbolNotFoundError();
559  return func_ptr(arg, size, offset);
560}
561
562extern __host__ cudaError_t CUDARTAPI cudaLaunch(const void *func) {
563  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *);
564  static auto func_ptr = LoadSymbol<FuncPtr>("cudaLaunch");
565  if (!func_ptr) return GetSymbolNotFoundError();
566  return func_ptr(func);
567}
568
569extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMallocManaged(
570    void **devPtr, size_t size, unsigned int flags __dv(cudaMemAttachGlobal)) {
571  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t, unsigned int);
572  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocManaged");
573  if (!func_ptr) return GetSymbolNotFoundError();
574  return func_ptr(devPtr, size, flags);
575}
576
577extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
578cudaMalloc(void **devPtr, size_t size) {
579  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t);
580  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMalloc");
581  if (!func_ptr) return GetSymbolNotFoundError();
582  return func_ptr(devPtr, size);
583}
584
585extern __host__ cudaError_t CUDARTAPI cudaMallocHost(void **ptr, size_t size) {
586  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t);
587  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocHost");
588  if (!func_ptr) return GetSymbolNotFoundError();
589  return func_ptr(ptr, size);
590}
591
592extern __host__ cudaError_t CUDARTAPI cudaMallocPitch(void **devPtr,
593                                                      size_t *pitch,
594                                                      size_t width,
595                                                      size_t height) {
596  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t *, size_t, size_t);
597  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocPitch");
598  if (!func_ptr) return GetSymbolNotFoundError();
599  return func_ptr(devPtr, pitch, width, height);
600}
601
602extern __host__ cudaError_t CUDARTAPI cudaMallocArray(
603    cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width,
604    size_t height __dv(0), unsigned int flags __dv(0)) {
605  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t *,
606                                           const struct cudaChannelFormatDesc *,
607                                           size_t, size_t, unsigned int);
608  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocArray");
609  if (!func_ptr) return GetSymbolNotFoundError();
610  return func_ptr(array, desc, width, height, flags);
611}
612
613extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
614cudaFree(void *devPtr) {
615  using FuncPtr = cudaError_t(CUDARTAPI *)(void *);
616  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFree");
617  if (!func_ptr) return GetSymbolNotFoundError();
618  return func_ptr(devPtr);
619}
620
621extern __host__ cudaError_t CUDARTAPI cudaFreeHost(void *ptr) {
622  using FuncPtr = cudaError_t(CUDARTAPI *)(void *);
623  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFreeHost");
624  if (!func_ptr) return GetSymbolNotFoundError();
625  return func_ptr(ptr);
626}
627
628extern __host__ cudaError_t CUDARTAPI cudaFreeArray(cudaArray_t array) {
629  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t);
630  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFreeArray");
631  if (!func_ptr) return GetSymbolNotFoundError();
632  return func_ptr(array);
633}
634
635extern __host__ cudaError_t CUDARTAPI
636cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) {
637  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaMipmappedArray_t);
638  static auto func_ptr = LoadSymbol<FuncPtr>("cudaFreeMipmappedArray");
639  if (!func_ptr) return GetSymbolNotFoundError();
640  return func_ptr(mipmappedArray);
641}
642
643extern __host__ cudaError_t CUDARTAPI cudaHostAlloc(void **pHost, size_t size,
644                                                    unsigned int flags) {
645  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, size_t, unsigned int);
646  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostAlloc");
647  if (!func_ptr) return GetSymbolNotFoundError();
648  return func_ptr(pHost, size, flags);
649}
650
651extern __host__ cudaError_t CUDARTAPI cudaHostRegister(void *ptr, size_t size,
652                                                       unsigned int flags) {
653  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, unsigned int);
654  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostRegister");
655  if (!func_ptr) return GetSymbolNotFoundError();
656  return func_ptr(ptr, size, flags);
657}
658
659extern __host__ cudaError_t CUDARTAPI cudaHostUnregister(void *ptr) {
660  using FuncPtr = cudaError_t(CUDARTAPI *)(void *);
661  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostUnregister");
662  if (!func_ptr) return GetSymbolNotFoundError();
663  return func_ptr(ptr);
664}
665
666extern __host__ cudaError_t CUDARTAPI
667cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags) {
668  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, void *, unsigned int);
669  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostGetDevicePointer");
670  if (!func_ptr) return GetSymbolNotFoundError();
671  return func_ptr(pDevice, pHost, flags);
672}
673
674extern __host__ cudaError_t CUDARTAPI cudaHostGetFlags(unsigned int *pFlags,
675                                                       void *pHost) {
676  using FuncPtr = cudaError_t(CUDARTAPI *)(unsigned int *, void *);
677  static auto func_ptr = LoadSymbol<FuncPtr>("cudaHostGetFlags");
678  if (!func_ptr) return GetSymbolNotFoundError();
679  return func_ptr(pFlags, pHost);
680}
681
682extern __host__ cudaError_t CUDARTAPI
683cudaMalloc3D(struct cudaPitchedPtr *pitchedDevPtr, struct cudaExtent extent) {
684  using FuncPtr =
685      cudaError_t(CUDARTAPI *)(struct cudaPitchedPtr *, struct cudaExtent);
686  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMalloc3D");
687  if (!func_ptr) return GetSymbolNotFoundError();
688  return func_ptr(pitchedDevPtr, extent);
689}
690
691extern __host__ cudaError_t CUDARTAPI
692cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc,
693                  struct cudaExtent extent, unsigned int flags __dv(0)) {
694  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t *,
695                                           const struct cudaChannelFormatDesc *,
696                                           struct cudaExtent, unsigned int);
697  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMalloc3DArray");
698  if (!func_ptr) return GetSymbolNotFoundError();
699  return func_ptr(array, desc, extent, flags);
700}
701
702extern __host__ cudaError_t CUDARTAPI cudaMallocMipmappedArray(
703    cudaMipmappedArray_t *mipmappedArray,
704    const struct cudaChannelFormatDesc *desc, struct cudaExtent extent,
705    unsigned int numLevels, unsigned int flags __dv(0)) {
706  using FuncPtr = cudaError_t(CUDARTAPI *)(
707      cudaMipmappedArray_t *, const struct cudaChannelFormatDesc *,
708      struct cudaExtent, unsigned int, unsigned int);
709  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMallocMipmappedArray");
710  if (!func_ptr) return GetSymbolNotFoundError();
711  return func_ptr(mipmappedArray, desc, extent, numLevels, flags);
712}
713
714extern __host__ cudaError_t CUDARTAPI cudaGetMipmappedArrayLevel(
715    cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray,
716    unsigned int level) {
717  using FuncPtr = cudaError_t(CUDARTAPI *)(
718      cudaArray_t *, cudaMipmappedArray_const_t, unsigned int);
719  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetMipmappedArrayLevel");
720  if (!func_ptr) return GetSymbolNotFoundError();
721  return func_ptr(levelArray, mipmappedArray, level);
722}
723
724extern __host__ cudaError_t CUDARTAPI
725cudaMemcpy3D(const struct cudaMemcpy3DParms *p) {
726  using FuncPtr = cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DParms *);
727  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3D");
728  if (!func_ptr) return GetSymbolNotFoundError();
729  return func_ptr(p);
730}
731
732extern __host__ cudaError_t CUDARTAPI
733cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p) {
734  using FuncPtr =
735      cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DPeerParms *);
736  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3DPeer");
737  if (!func_ptr) return GetSymbolNotFoundError();
738  return func_ptr(p);
739}
740
741extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMemcpy3DAsync(
742    const struct cudaMemcpy3DParms *p, cudaStream_t stream __dv(0)) {
743  using FuncPtr =
744      cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DParms *, cudaStream_t);
745  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3DAsync");
746  if (!func_ptr) return GetSymbolNotFoundError();
747  return func_ptr(p, stream);
748}
749
750extern __host__ cudaError_t CUDARTAPI cudaMemcpy3DPeerAsync(
751    const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream __dv(0)) {
752  using FuncPtr = cudaError_t(CUDARTAPI *)(const struct cudaMemcpy3DPeerParms *,
753                                           cudaStream_t);
754  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy3DPeerAsync");
755  if (!func_ptr) return GetSymbolNotFoundError();
756  return func_ptr(p, stream);
757}
758
759extern __host__ cudaError_t CUDARTAPI cudaMemGetInfo(size_t *free,
760                                                     size_t *total) {
761  using FuncPtr = cudaError_t(CUDARTAPI *)(size_t *, size_t *);
762  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemGetInfo");
763  if (!func_ptr) return GetSymbolNotFoundError();
764  return func_ptr(free, total);
765}
766
767extern __host__ cudaError_t CUDARTAPI
768cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent,
769                 unsigned int *flags, cudaArray_t array) {
770  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaChannelFormatDesc *,
771                                           struct cudaExtent *, unsigned int *,
772                                           cudaArray_t);
773  static auto func_ptr = LoadSymbol<FuncPtr>("cudaArrayGetInfo");
774  if (!func_ptr) return GetSymbolNotFoundError();
775  return func_ptr(desc, extent, flags, array);
776}
777
778extern __host__ cudaError_t CUDARTAPI cudaMemcpy(void *dst, const void *src,
779                                                 size_t count,
780                                                 enum cudaMemcpyKind kind) {
781  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t,
782                                           enum cudaMemcpyKind);
783  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy");
784  if (!func_ptr) return GetSymbolNotFoundError();
785  return func_ptr(dst, src, count, kind);
786}
787
788extern __host__ cudaError_t CUDARTAPI cudaMemcpyPeer(void *dst, int dstDevice,
789                                                     const void *src,
790                                                     int srcDevice,
791                                                     size_t count) {
792  using FuncPtr =
793      cudaError_t(CUDARTAPI *)(void *, int, const void *, int, size_t);
794  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyPeer");
795  if (!func_ptr) return GetSymbolNotFoundError();
796  return func_ptr(dst, dstDevice, src, srcDevice, count);
797}
798
799extern __host__ cudaError_t CUDARTAPI
800cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset,
801                  const void *src, size_t count, enum cudaMemcpyKind kind) {
802  using FuncPtr = cudaError_t(CUDARTAPI *)(
803      cudaArray_t, size_t, size_t, const void *, size_t, enum cudaMemcpyKind);
804  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToArray");
805  if (!func_ptr) return GetSymbolNotFoundError();
806  return func_ptr(dst, wOffset, hOffset, src, count, kind);
807}
808
809extern __host__ cudaError_t CUDARTAPI
810cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset,
811                    size_t hOffset, size_t count, enum cudaMemcpyKind kind) {
812  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, cudaArray_const_t, size_t,
813                                           size_t, size_t, enum cudaMemcpyKind);
814  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromArray");
815  if (!func_ptr) return GetSymbolNotFoundError();
816  return func_ptr(dst, src, wOffset, hOffset, count, kind);
817}
818
819extern __host__ cudaError_t CUDARTAPI cudaMemcpyArrayToArray(
820    cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst,
821    cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count,
822    enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) {
823  using FuncPtr =
824      cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t, cudaArray_const_t,
825                               size_t, size_t, size_t, enum cudaMemcpyKind);
826  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyArrayToArray");
827  if (!func_ptr) return GetSymbolNotFoundError();
828  return func_ptr(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc,
829                  count, kind);
830}
831
832extern __host__ cudaError_t CUDARTAPI cudaMemcpy2D(void *dst, size_t dpitch,
833                                                   const void *src,
834                                                   size_t spitch, size_t width,
835                                                   size_t height,
836                                                   enum cudaMemcpyKind kind) {
837  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, const void *, size_t,
838                                           size_t, size_t, enum cudaMemcpyKind);
839  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2D");
840  if (!func_ptr) return GetSymbolNotFoundError();
841  return func_ptr(dst, dpitch, src, spitch, width, height, kind);
842}
843
844extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DToArray(
845    cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src,
846    size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind) {
847  using FuncPtr =
848      cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t, const void *,
849                               size_t, size_t, size_t, enum cudaMemcpyKind);
850  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DToArray");
851  if (!func_ptr) return GetSymbolNotFoundError();
852  return func_ptr(dst, wOffset, hOffset, src, spitch, width, height, kind);
853}
854
855extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArray(
856    void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset,
857    size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind) {
858  using FuncPtr =
859      cudaError_t(CUDARTAPI *)(void *, size_t, cudaArray_const_t, size_t,
860                               size_t, size_t, size_t, enum cudaMemcpyKind);
861  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DFromArray");
862  if (!func_ptr) return GetSymbolNotFoundError();
863  return func_ptr(dst, dpitch, src, wOffset, hOffset, width, height, kind);
864}
865
866extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DArrayToArray(
867    cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst,
868    cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width,
869    size_t height, enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) {
870  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t,
871                                           cudaArray_const_t, size_t, size_t,
872                                           size_t, size_t, enum cudaMemcpyKind);
873  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DArrayToArray");
874  if (!func_ptr) return GetSymbolNotFoundError();
875  return func_ptr(dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc,
876                  width, height, kind);
877}
878
879extern __host__ cudaError_t CUDARTAPI cudaMemcpyToSymbol(
880    const void *symbol, const void *src, size_t count, size_t offset __dv(0),
881    enum cudaMemcpyKind kind __dv(cudaMemcpyHostToDevice)) {
882  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, const void *, size_t,
883                                           size_t, enum cudaMemcpyKind);
884  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToSymbol");
885  if (!func_ptr) return GetSymbolNotFoundError();
886  return func_ptr(symbol, src, count, offset, kind);
887}
888
889extern __host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbol(
890    void *dst, const void *symbol, size_t count, size_t offset __dv(0),
891    enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToHost)) {
892  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t, size_t,
893                                           enum cudaMemcpyKind);
894  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromSymbol");
895  if (!func_ptr) return GetSymbolNotFoundError();
896  return func_ptr(dst, symbol, count, offset, kind);
897}
898
899extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
900cudaMemcpyAsync(void *dst, const void *src, size_t count,
901                enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
902  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t,
903                                           enum cudaMemcpyKind, cudaStream_t);
904  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyAsync");
905  if (!func_ptr) return GetSymbolNotFoundError();
906  return func_ptr(dst, src, count, kind, stream);
907}
908
909extern __host__ cudaError_t CUDARTAPI
910cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice,
911                    size_t count, cudaStream_t stream __dv(0)) {
912  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, int, const void *, int,
913                                           size_t, cudaStream_t);
914  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyPeerAsync");
915  if (!func_ptr) return GetSymbolNotFoundError();
916  return func_ptr(dst, dstDevice, src, srcDevice, count, stream);
917}
918
919extern __host__ cudaError_t CUDARTAPI cudaMemcpyToArrayAsync(
920    cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src,
921    size_t count, enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
922  using FuncPtr =
923      cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t, const void *,
924                               size_t, enum cudaMemcpyKind, cudaStream_t);
925  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToArrayAsync");
926  if (!func_ptr) return GetSymbolNotFoundError();
927  return func_ptr(dst, wOffset, hOffset, src, count, kind, stream);
928}
929
930extern __host__ cudaError_t CUDARTAPI cudaMemcpyFromArrayAsync(
931    void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset,
932    size_t count, enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
933  using FuncPtr =
934      cudaError_t(CUDARTAPI *)(void *, cudaArray_const_t, size_t, size_t,
935                               size_t, enum cudaMemcpyKind, cudaStream_t);
936  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromArrayAsync");
937  if (!func_ptr) return GetSymbolNotFoundError();
938  return func_ptr(dst, src, wOffset, hOffset, count, kind, stream);
939}
940
941extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMemcpy2DAsync(
942    void *dst, size_t dpitch, const void *src, size_t spitch, size_t width,
943    size_t height, enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
944  using FuncPtr =
945      cudaError_t(CUDARTAPI *)(void *, size_t, const void *, size_t, size_t,
946                               size_t, enum cudaMemcpyKind, cudaStream_t);
947  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DAsync");
948  if (!func_ptr) return GetSymbolNotFoundError();
949  return func_ptr(dst, dpitch, src, spitch, width, height, kind, stream);
950}
951
952extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DToArrayAsync(
953    cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src,
954    size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind,
955    cudaStream_t stream __dv(0)) {
956  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaArray_t, size_t, size_t,
957                                           const void *, size_t, size_t, size_t,
958                                           enum cudaMemcpyKind, cudaStream_t);
959  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DToArrayAsync");
960  if (!func_ptr) return GetSymbolNotFoundError();
961  return func_ptr(dst, wOffset, hOffset, src, spitch, width, height, kind,
962                  stream);
963}
964
965extern __host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArrayAsync(
966    void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset,
967    size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind,
968    cudaStream_t stream __dv(0)) {
969  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, cudaArray_const_t,
970                                           size_t, size_t, size_t, size_t,
971                                           enum cudaMemcpyKind, cudaStream_t);
972  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpy2DFromArrayAsync");
973  if (!func_ptr) return GetSymbolNotFoundError();
974  return func_ptr(dst, dpitch, src, wOffset, hOffset, width, height, kind,
975                  stream);
976}
977
978extern __host__ cudaError_t CUDARTAPI cudaMemcpyToSymbolAsync(
979    const void *symbol, const void *src, size_t count, size_t offset,
980    enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
981  using FuncPtr =
982      cudaError_t(CUDARTAPI *)(const void *, const void *, size_t, size_t,
983                               enum cudaMemcpyKind, cudaStream_t);
984  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyToSymbolAsync");
985  if (!func_ptr) return GetSymbolNotFoundError();
986  return func_ptr(symbol, src, count, offset, kind, stream);
987}
988
989extern __host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbolAsync(
990    void *dst, const void *symbol, size_t count, size_t offset,
991    enum cudaMemcpyKind kind, cudaStream_t stream __dv(0)) {
992  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, const void *, size_t, size_t,
993                                           enum cudaMemcpyKind, cudaStream_t);
994  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemcpyFromSymbolAsync");
995  if (!func_ptr) return GetSymbolNotFoundError();
996  return func_ptr(dst, symbol, count, offset, kind, stream);
997}
998
999extern __host__ cudaError_t CUDARTAPI cudaMemset(void *devPtr, int value,
1000                                                 size_t count) {
1001  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, int, size_t);
1002  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset");
1003  if (!func_ptr) return GetSymbolNotFoundError();
1004  return func_ptr(devPtr, value, count);
1005}
1006
1007extern __host__ cudaError_t CUDARTAPI cudaMemset2D(void *devPtr, size_t pitch,
1008                                                   int value, size_t width,
1009                                                   size_t height) {
1010  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, int, size_t, size_t);
1011  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset2D");
1012  if (!func_ptr) return GetSymbolNotFoundError();
1013  return func_ptr(devPtr, pitch, value, width, height);
1014}
1015
1016extern __host__ cudaError_t CUDARTAPI cudaMemset3D(
1017    struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent) {
1018  using FuncPtr =
1019      cudaError_t(CUDARTAPI *)(struct cudaPitchedPtr, int, struct cudaExtent);
1020  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset3D");
1021  if (!func_ptr) return GetSymbolNotFoundError();
1022  return func_ptr(pitchedDevPtr, value, extent);
1023}
1024
1025extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMemsetAsync(
1026    void *devPtr, int value, size_t count, cudaStream_t stream __dv(0)) {
1027  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, int, size_t, cudaStream_t);
1028  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemsetAsync");
1029  if (!func_ptr) return GetSymbolNotFoundError();
1030  return func_ptr(devPtr, value, count, stream);
1031}
1032
1033extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
1034cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width,
1035                  size_t height, cudaStream_t stream __dv(0)) {
1036  using FuncPtr = cudaError_t(CUDARTAPI *)(void *, size_t, int, size_t, size_t,
1037                                           cudaStream_t);
1038  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset2DAsync");
1039  if (!func_ptr) return GetSymbolNotFoundError();
1040  return func_ptr(devPtr, pitch, value, width, height, stream);
1041}
1042
1043extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
1044cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value,
1045                  struct cudaExtent extent, cudaStream_t stream __dv(0)) {
1046  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaPitchedPtr, int,
1047                                           struct cudaExtent, cudaStream_t);
1048  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemset3DAsync");
1049  if (!func_ptr) return GetSymbolNotFoundError();
1050  return func_ptr(pitchedDevPtr, value, extent, stream);
1051}
1052
1053extern __host__ cudaError_t CUDARTAPI cudaGetSymbolAddress(void **devPtr,
1054                                                           const void *symbol) {
1055  using FuncPtr = cudaError_t(CUDARTAPI *)(void **, const void *);
1056  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetSymbolAddress");
1057  if (!func_ptr) return GetSymbolNotFoundError();
1058  return func_ptr(devPtr, symbol);
1059}
1060
1061extern __host__ cudaError_t CUDARTAPI cudaGetSymbolSize(size_t *size,
1062                                                        const void *symbol) {
1063  using FuncPtr = cudaError_t(CUDARTAPI *)(size_t *, const void *);
1064  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetSymbolSize");
1065  if (!func_ptr) return GetSymbolNotFoundError();
1066  return func_ptr(size, symbol);
1067}
1068
1069extern __host__ cudaError_t CUDARTAPI
1070cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice,
1071                     cudaStream_t stream __dv(0)) {
1072  using FuncPtr =
1073      cudaError_t(CUDARTAPI *)(const void *, size_t, int, cudaStream_t);
1074  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemPrefetchAsync");
1075  if (!func_ptr) return GetSymbolNotFoundError();
1076  return func_ptr(devPtr, count, dstDevice, stream);
1077}
1078
1079extern __host__ cudaError_t CUDARTAPI
1080cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice,
1081              int device) {
1082  using FuncPtr = cudaError_t(CUDARTAPI *)(const void *, size_t,
1083                                           enum cudaMemoryAdvise, int);
1084  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemAdvise");
1085  if (!func_ptr) return GetSymbolNotFoundError();
1086  return func_ptr(devPtr, count, advice, device);
1087}
1088
1089extern __host__ cudaError_t CUDARTAPI cudaMemRangeGetAttribute(
1090    void *data, size_t dataSize, enum cudaMemRangeAttribute attribute,
1091    const void *devPtr, size_t count) {
1092  using FuncPtr = cudaError_t(CUDARTAPI *)(
1093      void *, size_t, enum cudaMemRangeAttribute, const void *, size_t);
1094  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemRangeGetAttribute");
1095  if (!func_ptr) return GetSymbolNotFoundError();
1096  return func_ptr(data, dataSize, attribute, devPtr, count);
1097}
1098
1099extern __host__ cudaError_t CUDARTAPI cudaMemRangeGetAttributes(
1100    void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes,
1101    size_t numAttributes, const void *devPtr, size_t count) {
1102  using FuncPtr =
1103      cudaError_t(CUDARTAPI *)(void **, size_t *, enum cudaMemRangeAttribute *,
1104                               size_t, const void *, size_t);
1105  static auto func_ptr = LoadSymbol<FuncPtr>("cudaMemRangeGetAttributes");
1106  if (!func_ptr) return GetSymbolNotFoundError();
1107  return func_ptr(data, dataSizes, attributes, numAttributes, devPtr, count);
1108}
1109
1110extern __host__ cudaError_t CUDARTAPI cudaPointerGetAttributes(
1111    struct cudaPointerAttributes *attributes, const void *ptr) {
1112  using FuncPtr =
1113      cudaError_t(CUDARTAPI *)(struct cudaPointerAttributes *, const void *);
1114  static auto func_ptr = LoadSymbol<FuncPtr>("cudaPointerGetAttributes");
1115  if (!func_ptr) return GetSymbolNotFoundError();
1116  return func_ptr(attributes, ptr);
1117}
1118
1119extern __host__ cudaError_t CUDARTAPI
1120cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice) {
1121  using FuncPtr = cudaError_t(CUDARTAPI *)(int *, int, int);
1122  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceCanAccessPeer");
1123  if (!func_ptr) return GetSymbolNotFoundError();
1124  return func_ptr(canAccessPeer, device, peerDevice);
1125}
1126
1127extern __host__ cudaError_t CUDARTAPI
1128cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) {
1129  using FuncPtr = cudaError_t(CUDARTAPI *)(int, unsigned int);
1130  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceEnablePeerAccess");
1131  if (!func_ptr) return GetSymbolNotFoundError();
1132  return func_ptr(peerDevice, flags);
1133}
1134
1135extern __host__ cudaError_t CUDARTAPI
1136cudaDeviceDisablePeerAccess(int peerDevice) {
1137  using FuncPtr = cudaError_t(CUDARTAPI *)(int);
1138  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDeviceDisablePeerAccess");
1139  if (!func_ptr) return GetSymbolNotFoundError();
1140  return func_ptr(peerDevice);
1141}
1142
1143extern __host__ cudaError_t CUDARTAPI
1144cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) {
1145  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaGraphicsResource_t);
1146  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsUnregisterResource");
1147  if (!func_ptr) return GetSymbolNotFoundError();
1148  return func_ptr(resource);
1149}
1150
1151extern __host__ cudaError_t CUDARTAPI cudaGraphicsResourceSetMapFlags(
1152    cudaGraphicsResource_t resource, unsigned int flags) {
1153  using FuncPtr =
1154      cudaError_t(CUDARTAPI *)(cudaGraphicsResource_t, unsigned int);
1155  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsResourceSetMapFlags");
1156  if (!func_ptr) return GetSymbolNotFoundError();
1157  return func_ptr(resource, flags);
1158}
1159
1160extern __host__ cudaError_t CUDARTAPI cudaGraphicsMapResources(
1161    int count, cudaGraphicsResource_t *resources, cudaStream_t stream __dv(0)) {
1162  using FuncPtr =
1163      cudaError_t(CUDARTAPI *)(int, cudaGraphicsResource_t *, cudaStream_t);
1164  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsMapResources");
1165  if (!func_ptr) return GetSymbolNotFoundError();
1166  return func_ptr(count, resources, stream);
1167}
1168
1169extern __host__ cudaError_t CUDARTAPI cudaGraphicsUnmapResources(
1170    int count, cudaGraphicsResource_t *resources, cudaStream_t stream __dv(0)) {
1171  using FuncPtr =
1172      cudaError_t(CUDARTAPI *)(int, cudaGraphicsResource_t *, cudaStream_t);
1173  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGraphicsUnmapResources");
1174  if (!func_ptr) return GetSymbolNotFoundError();
1175  return func_ptr(count, resources, stream);
1176}
1177
1178extern __host__ cudaError_t CUDARTAPI cudaGraphicsResourceGetMappedPointer(
1179    void **devPtr, size_t *size, cudaGraphicsResource_t resource) {
1180  using FuncPtr =
1181      cudaError_t(CUDARTAPI *)(void **, size_t *, cudaGraphicsResource_t);
1182  static auto func_ptr =
1183      LoadSymbol<FuncPtr>("cudaGraphicsResourceGetMappedPointer");
1184  if (!func_ptr) return GetSymbolNotFoundError();
1185  return func_ptr(devPtr, size, resource);
1186}
1187
1188extern __host__ cudaError_t CUDARTAPI cudaGraphicsSubResourceGetMappedArray(
1189    cudaArray_t *array, cudaGraphicsResource_t resource,
1190    unsigned int arrayIndex, unsigned int mipLevel) {
1191  using FuncPtr = cudaError_t(CUDARTAPI *)(
1192      cudaArray_t *, cudaGraphicsResource_t, unsigned int, unsigned int);
1193  static auto func_ptr =
1194      LoadSymbol<FuncPtr>("cudaGraphicsSubResourceGetMappedArray");
1195  if (!func_ptr) return GetSymbolNotFoundError();
1196  return func_ptr(array, resource, arrayIndex, mipLevel);
1197}
1198
1199extern __host__ cudaError_t CUDARTAPI
1200cudaGraphicsResourceGetMappedMipmappedArray(
1201    cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource) {
1202  using FuncPtr =
1203      cudaError_t(CUDARTAPI *)(cudaMipmappedArray_t *, cudaGraphicsResource_t);
1204  static auto func_ptr =
1205      LoadSymbol<FuncPtr>("cudaGraphicsResourceGetMappedMipmappedArray");
1206  if (!func_ptr) return GetSymbolNotFoundError();
1207  return func_ptr(mipmappedArray, resource);
1208}
1209
1210extern __host__ cudaError_t CUDARTAPI cudaGetChannelDesc(
1211    struct cudaChannelFormatDesc *desc, cudaArray_const_t array) {
1212  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaChannelFormatDesc *,
1213                                           cudaArray_const_t);
1214  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetChannelDesc");
1215  if (!func_ptr) return GetSymbolNotFoundError();
1216  return func_ptr(desc, array);
1217}
1218
1219extern __host__ cudaError_t CUDARTAPI cudaBindTexture(
1220    size_t *offset, const struct textureReference *texref, const void *devPtr,
1221    const struct cudaChannelFormatDesc *desc, size_t size __dv(UINT_MAX)) {
1222  using FuncPtr = cudaError_t(CUDARTAPI *)(
1223      size_t *, const struct textureReference *, const void *,
1224      const struct cudaChannelFormatDesc *, size_t);
1225  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTexture");
1226  if (!func_ptr) return GetSymbolNotFoundError();
1227  return func_ptr(offset, texref, devPtr, desc, size);
1228}
1229
1230extern __host__ cudaError_t CUDARTAPI
1231cudaBindTexture2D(size_t *offset, const struct textureReference *texref,
1232                  const void *devPtr, const struct cudaChannelFormatDesc *desc,
1233                  size_t width, size_t height, size_t pitch) {
1234  using FuncPtr = cudaError_t(CUDARTAPI *)(
1235      size_t *, const struct textureReference *, const void *,
1236      const struct cudaChannelFormatDesc *, size_t, size_t, size_t);
1237  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTexture2D");
1238  if (!func_ptr) return GetSymbolNotFoundError();
1239  return func_ptr(offset, texref, devPtr, desc, width, height, pitch);
1240}
1241
1242extern __host__ cudaError_t CUDARTAPI cudaBindTextureToArray(
1243    const struct textureReference *texref, cudaArray_const_t array,
1244    const struct cudaChannelFormatDesc *desc) {
1245  using FuncPtr = cudaError_t(CUDARTAPI *)(
1246      const struct textureReference *, cudaArray_const_t,
1247      const struct cudaChannelFormatDesc *);
1248  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTextureToArray");
1249  if (!func_ptr) return GetSymbolNotFoundError();
1250  return func_ptr(texref, array, desc);
1251}
1252
1253extern __host__ cudaError_t CUDARTAPI
1254cudaBindTextureToMipmappedArray(const struct textureReference *texref,
1255                                cudaMipmappedArray_const_t mipmappedArray,
1256                                const struct cudaChannelFormatDesc *desc) {
1257  using FuncPtr = cudaError_t(CUDARTAPI *)(
1258      const struct textureReference *, cudaMipmappedArray_const_t,
1259      const struct cudaChannelFormatDesc *);
1260  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindTextureToMipmappedArray");
1261  if (!func_ptr) return GetSymbolNotFoundError();
1262  return func_ptr(texref, mipmappedArray, desc);
1263}
1264
1265extern __host__ cudaError_t CUDARTAPI
1266cudaUnbindTexture(const struct textureReference *texref) {
1267  using FuncPtr = cudaError_t(CUDARTAPI *)(const struct textureReference *);
1268  static auto func_ptr = LoadSymbol<FuncPtr>("cudaUnbindTexture");
1269  if (!func_ptr) return GetSymbolNotFoundError();
1270  return func_ptr(texref);
1271}
1272
1273extern __host__ cudaError_t CUDARTAPI cudaGetTextureAlignmentOffset(
1274    size_t *offset, const struct textureReference *texref) {
1275  using FuncPtr =
1276      cudaError_t(CUDARTAPI *)(size_t *, const struct textureReference *);
1277  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetTextureAlignmentOffset");
1278  if (!func_ptr) return GetSymbolNotFoundError();
1279  return func_ptr(offset, texref);
1280}
1281
1282extern __host__ cudaError_t CUDARTAPI cudaGetTextureReference(
1283    const struct textureReference **texref, const void *symbol) {
1284  using FuncPtr =
1285      cudaError_t(CUDARTAPI *)(const struct textureReference **, const void *);
1286  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetTextureReference");
1287  if (!func_ptr) return GetSymbolNotFoundError();
1288  return func_ptr(texref, symbol);
1289}
1290
1291extern __host__ cudaError_t CUDARTAPI cudaBindSurfaceToArray(
1292    const struct surfaceReference *surfref, cudaArray_const_t array,
1293    const struct cudaChannelFormatDesc *desc) {
1294  using FuncPtr = cudaError_t(CUDARTAPI *)(
1295      const struct surfaceReference *, cudaArray_const_t,
1296      const struct cudaChannelFormatDesc *);
1297  static auto func_ptr = LoadSymbol<FuncPtr>("cudaBindSurfaceToArray");
1298  if (!func_ptr) return GetSymbolNotFoundError();
1299  return func_ptr(surfref, array, desc);
1300}
1301
1302extern __host__ cudaError_t CUDARTAPI cudaGetSurfaceReference(
1303    const struct surfaceReference **surfref, const void *symbol) {
1304  using FuncPtr =
1305      cudaError_t(CUDARTAPI *)(const struct surfaceReference **, const void *);
1306  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetSurfaceReference");
1307  if (!func_ptr) return GetSymbolNotFoundError();
1308  return func_ptr(surfref, symbol);
1309}
1310
1311extern __host__ cudaError_t CUDARTAPI cudaCreateTextureObject(
1312    cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc,
1313    const struct cudaTextureDesc *pTexDesc,
1314    const struct cudaResourceViewDesc *pResViewDesc) {
1315  using FuncPtr = cudaError_t(CUDARTAPI *)(
1316      cudaTextureObject_t *, const struct cudaResourceDesc *,
1317      const struct cudaTextureDesc *, const struct cudaResourceViewDesc *);
1318  static auto func_ptr = LoadSymbol<FuncPtr>("cudaCreateTextureObject");
1319  if (!func_ptr) return GetSymbolNotFoundError();
1320  return func_ptr(pTexObject, pResDesc, pTexDesc, pResViewDesc);
1321}
1322
1323extern __host__ cudaError_t CUDARTAPI
1324cudaDestroyTextureObject(cudaTextureObject_t texObject) {
1325  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaTextureObject_t);
1326  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDestroyTextureObject");
1327  if (!func_ptr) return GetSymbolNotFoundError();
1328  return func_ptr(texObject);
1329}
1330
1331extern __host__ cudaError_t CUDARTAPI cudaGetTextureObjectResourceDesc(
1332    struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject) {
1333  using FuncPtr =
1334      cudaError_t(CUDARTAPI *)(struct cudaResourceDesc *, cudaTextureObject_t);
1335  static auto func_ptr =
1336      LoadSymbol<FuncPtr>("cudaGetTextureObjectResourceDesc");
1337  if (!func_ptr) return GetSymbolNotFoundError();
1338  return func_ptr(pResDesc, texObject);
1339}
1340
1341extern __host__ cudaError_t CUDARTAPI cudaGetTextureObjectTextureDesc(
1342    struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject) {
1343  using FuncPtr =
1344      cudaError_t(CUDARTAPI *)(struct cudaTextureDesc *, cudaTextureObject_t);
1345  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetTextureObjectTextureDesc");
1346  if (!func_ptr) return GetSymbolNotFoundError();
1347  return func_ptr(pTexDesc, texObject);
1348}
1349
1350extern __host__ cudaError_t CUDARTAPI cudaGetTextureObjectResourceViewDesc(
1351    struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject) {
1352  using FuncPtr = cudaError_t(CUDARTAPI *)(struct cudaResourceViewDesc *,
1353                                           cudaTextureObject_t);
1354  static auto func_ptr =
1355      LoadSymbol<FuncPtr>("cudaGetTextureObjectResourceViewDesc");
1356  if (!func_ptr) return GetSymbolNotFoundError();
1357  return func_ptr(pResViewDesc, texObject);
1358}
1359
1360extern __host__ cudaError_t CUDARTAPI cudaCreateSurfaceObject(
1361    cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc) {
1362  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaSurfaceObject_t *,
1363                                           const struct cudaResourceDesc *);
1364  static auto func_ptr = LoadSymbol<FuncPtr>("cudaCreateSurfaceObject");
1365  if (!func_ptr) return GetSymbolNotFoundError();
1366  return func_ptr(pSurfObject, pResDesc);
1367}
1368
1369extern __host__ cudaError_t CUDARTAPI
1370cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) {
1371  using FuncPtr = cudaError_t(CUDARTAPI *)(cudaSurfaceObject_t);
1372  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDestroySurfaceObject");
1373  if (!func_ptr) return GetSymbolNotFoundError();
1374  return func_ptr(surfObject);
1375}
1376
1377extern __host__ cudaError_t CUDARTAPI cudaGetSurfaceObjectResourceDesc(
1378    struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject) {
1379  using FuncPtr =
1380      cudaError_t(CUDARTAPI *)(struct cudaResourceDesc *, cudaSurfaceObject_t);
1381  static auto func_ptr =
1382      LoadSymbol<FuncPtr>("cudaGetSurfaceObjectResourceDesc");
1383  if (!func_ptr) return GetSymbolNotFoundError();
1384  return func_ptr(pResDesc, surfObject);
1385}
1386
1387extern __host__ cudaError_t CUDARTAPI cudaDriverGetVersion(int *driverVersion) {
1388  using FuncPtr = cudaError_t(CUDARTAPI *)(int *);
1389  static auto func_ptr = LoadSymbol<FuncPtr>("cudaDriverGetVersion");
1390  if (!func_ptr) return GetSymbolNotFoundError();
1391  return func_ptr(driverVersion);
1392}
1393
1394extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI
1395cudaRuntimeGetVersion(int *runtimeVersion) {
1396  using FuncPtr = cudaError_t(CUDARTAPI *)(int *);
1397  static auto func_ptr = LoadSymbol<FuncPtr>("cudaRuntimeGetVersion");
1398  if (!func_ptr) return GetSymbolNotFoundError();
1399  return func_ptr(runtimeVersion);
1400}
1401
1402extern __host__ cudaError_t CUDARTAPI cudaGetExportTable(
1403    const void **ppExportTable, const cudaUUID_t *pExportTableId) {
1404  using FuncPtr = cudaError_t(CUDARTAPI *)(const void **, const cudaUUID_t *);
1405  static auto func_ptr = LoadSymbol<FuncPtr>("cudaGetExportTable");
1406  if (!func_ptr) return GetSymbolNotFoundError();
1407  return func_ptr(ppExportTable, pExportTableId);
1408}
1409
1410}  // extern "C"
1411