1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
2
3pub const __CUDA_API_VERSION: ::std::os::raw::c_uint = 8000;
4pub const CUDA_VERSION: ::std::os::raw::c_uint = 8000;
5pub const CU_IPC_HANDLE_SIZE: ::std::os::raw::c_uint = 64;
6pub const CU_MEMHOSTALLOC_PORTABLE: ::std::os::raw::c_uint = 1;
7pub const CU_MEMHOSTALLOC_DEVICEMAP: ::std::os::raw::c_uint = 2;
8pub const CU_MEMHOSTALLOC_WRITECOMBINED: ::std::os::raw::c_uint = 4;
9pub const CU_MEMHOSTREGISTER_PORTABLE: ::std::os::raw::c_uint = 1;
10pub const CU_MEMHOSTREGISTER_DEVICEMAP: ::std::os::raw::c_uint = 2;
11pub const CU_MEMHOSTREGISTER_IOMEMORY: ::std::os::raw::c_uint = 4;
12pub const CUDA_ARRAY3D_LAYERED: ::std::os::raw::c_uint = 1;
13pub const CUDA_ARRAY3D_2DARRAY: ::std::os::raw::c_uint = 1;
14pub const CUDA_ARRAY3D_SURFACE_LDST: ::std::os::raw::c_uint = 2;
15pub const CUDA_ARRAY3D_CUBEMAP: ::std::os::raw::c_uint = 4;
16pub const CUDA_ARRAY3D_TEXTURE_GATHER: ::std::os::raw::c_uint = 8;
17pub const CUDA_ARRAY3D_DEPTH_TEXTURE: ::std::os::raw::c_uint = 16;
18pub const CU_TRSA_OVERRIDE_FORMAT: ::std::os::raw::c_uint = 1;
19pub const CU_TRSF_READ_AS_INTEGER: ::std::os::raw::c_uint = 1;
20pub const CU_TRSF_NORMALIZED_COORDINATES: ::std::os::raw::c_uint = 2;
21pub const CU_TRSF_SRGB: ::std::os::raw::c_uint = 16;
22pub const CU_PARAM_TR_DEFAULT: ::std::os::raw::c_int = -1;
23
24pub type CUdeviceptr = ::std::os::raw::c_ulonglong;
25pub type CUdevice = ::std::os::raw::c_int;
26#[repr(C)]
27#[derive(Debug, Copy)]
28pub struct CUctx_st {
29 pub _address: u8,
30}
31impl Clone for CUctx_st {
32 fn clone(&self) -> Self {
33 *self
34 }
35}
36pub type CUcontext = *mut CUctx_st;
37#[repr(C)]
38#[derive(Debug, Copy)]
39pub struct CUmod_st {
40 pub _address: u8,
41}
42impl Clone for CUmod_st {
43 fn clone(&self) -> Self {
44 *self
45 }
46}
47pub type CUmodule = *mut CUmod_st;
48#[repr(C)]
49#[derive(Debug, Copy)]
50pub struct CUfunc_st {
51 pub _address: u8,
52}
53impl Clone for CUfunc_st {
54 fn clone(&self) -> Self {
55 *self
56 }
57}
58pub type CUfunction = *mut CUfunc_st;
59#[repr(C)]
60#[derive(Debug, Copy)]
61pub struct CUarray_st {
62 pub _address: u8,
63}
64impl Clone for CUarray_st {
65 fn clone(&self) -> Self {
66 *self
67 }
68}
69pub type CUarray = *mut CUarray_st;
70#[repr(C)]
71#[derive(Debug, Copy)]
72pub struct CUmipmappedArray_st {
73 pub _address: u8,
74}
75impl Clone for CUmipmappedArray_st {
76 fn clone(&self) -> Self {
77 *self
78 }
79}
80pub type CUmipmappedArray = *mut CUmipmappedArray_st;
81#[repr(C)]
82#[derive(Debug, Copy)]
83pub struct CUtexref_st {
84 pub _address: u8,
85}
86impl Clone for CUtexref_st {
87 fn clone(&self) -> Self {
88 *self
89 }
90}
91pub type CUtexref = *mut CUtexref_st;
92#[repr(C)]
93#[derive(Debug, Copy)]
94pub struct CUsurfref_st {
95 pub _address: u8,
96}
97impl Clone for CUsurfref_st {
98 fn clone(&self) -> Self {
99 *self
100 }
101}
102pub type CUsurfref = *mut CUsurfref_st;
103#[repr(C)]
104#[derive(Debug, Copy)]
105pub struct CUevent_st {
106 pub _address: u8,
107}
108impl Clone for CUevent_st {
109 fn clone(&self) -> Self {
110 *self
111 }
112}
113pub type CUevent = *mut CUevent_st;
114#[repr(C)]
115#[derive(Debug, Copy)]
116pub struct CUstream_st {
117 pub _address: u8,
118}
119impl Clone for CUstream_st {
120 fn clone(&self) -> Self {
121 *self
122 }
123}
124pub type CUstream = *mut CUstream_st;
125#[repr(C)]
126#[derive(Debug, Copy)]
127pub struct CUgraphicsResource_st {
128 pub _address: u8,
129}
130impl Clone for CUgraphicsResource_st {
131 fn clone(&self) -> Self {
132 *self
133 }
134}
135pub type CUgraphicsResource = *mut CUgraphicsResource_st;
136pub type CUtexObject = ::std::os::raw::c_ulonglong;
137pub type CUsurfObject = ::std::os::raw::c_ulonglong;
138#[repr(C)]
139#[derive(Debug, Copy)]
140pub struct CUuuid_st {
141 pub bytes: [::std::os::raw::c_char; 16usize],
142}
143impl Clone for CUuuid_st {
144 fn clone(&self) -> Self {
145 *self
146 }
147}
148pub type CUuuid = CUuuid_st;
149#[repr(C)]
150pub struct CUipcEventHandle_st {
151 pub reserved: [::std::os::raw::c_char; 64usize],
152}
153pub type CUipcEventHandle = CUipcEventHandle_st;
154#[repr(C)]
155pub struct CUipcMemHandle_st {
156 pub reserved: [::std::os::raw::c_char; 64usize],
157}
158pub type CUipcMemHandle = CUipcMemHandle_st;
159#[repr(u32)]
160#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
161pub enum CUipcMem_flags_enum {
162 CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = 1,
163}
164pub type CUipcMem_flags = CUipcMem_flags_enum;
165#[repr(u32)]
166#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
167pub enum CUmemAttach_flags_enum {
168 CU_MEM_ATTACH_GLOBAL = 1,
169 CU_MEM_ATTACH_HOST = 2,
170 CU_MEM_ATTACH_SINGLE = 4,
171}
172pub type CUmemAttach_flags = CUmemAttach_flags_enum;
173pub const CUctx_flags_enum_CU_CTX_BLOCKING_SYNC: CUctx_flags_enum = CUctx_flags_enum::CU_CTX_SCHED_BLOCKING_SYNC;
174#[repr(u32)]
175#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
176pub enum CUctx_flags_enum {
177 CU_CTX_SCHED_AUTO = 0,
178 CU_CTX_SCHED_SPIN = 1,
179 CU_CTX_SCHED_YIELD = 2,
180 CU_CTX_SCHED_BLOCKING_SYNC = 4,
181 CU_CTX_SCHED_MASK = 7,
182 CU_CTX_MAP_HOST = 8,
183 CU_CTX_LMEM_RESIZE_TO_MAX = 16,
184 CU_CTX_FLAGS_MASK = 31,
185}
186pub type CUctx_flags = CUctx_flags_enum;
187#[repr(u32)]
188#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
189pub enum CUstream_flags_enum {
190 CU_STREAM_DEFAULT = 0,
191 CU_STREAM_NON_BLOCKING = 1,
192}
193pub type CUstream_flags = CUstream_flags_enum;
194#[repr(u32)]
195#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
196pub enum CUevent_flags_enum {
197 CU_EVENT_DEFAULT = 0,
198 CU_EVENT_BLOCKING_SYNC = 1,
199 CU_EVENT_DISABLE_TIMING = 2,
200 CU_EVENT_INTERPROCESS = 4,
201}
202pub type CUevent_flags = CUevent_flags_enum;
203#[repr(u32)]
204#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
205pub enum CUstreamWaitValue_flags_enum {
206 CU_STREAM_WAIT_VALUE_GEQ = 0,
207 CU_STREAM_WAIT_VALUE_EQ = 1,
208 CU_STREAM_WAIT_VALUE_AND = 2,
209 CU_STREAM_WAIT_VALUE_FLUSH = 1073741824,
210}
211pub type CUstreamWaitValue_flags = CUstreamWaitValue_flags_enum;
212#[repr(u32)]
213#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
214pub enum CUstreamWriteValue_flags_enum {
215 CU_STREAM_WRITE_VALUE_DEFAULT = 0,
216 CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = 1,
217}
218pub type CUstreamWriteValue_flags = CUstreamWriteValue_flags_enum;
219#[repr(u32)]
220#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
221pub enum CUstreamBatchMemOpType_enum {
222 CU_STREAM_MEM_OP_WAIT_VALUE_32 = 1,
223 CU_STREAM_MEM_OP_WRITE_VALUE_32 = 2,
224 CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = 3,
225}
226pub type CUstreamBatchMemOpType = CUstreamBatchMemOpType_enum;
227#[repr(C)]
228#[derive(Copy)]
229pub union CUstreamBatchMemOpParams_union {
230 pub operation: CUstreamBatchMemOpType,
231 pub waitValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
232 pub writeValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
233 pub flushRemoteWrites: CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
234 pub pad: [u64; 6usize],
235}
236#[repr(C)]
237#[derive(Copy)]
238pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st {
239 pub operation: CUstreamBatchMemOpType,
240 pub address: CUdeviceptr,
241 pub __bindgen_anon_1: CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
242 pub flags: ::std::os::raw::c_uint,
243 pub alias: CUdeviceptr,
244}
245#[repr(C)]
246#[derive(Copy)]
247pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 {
248 pub value: u32,
249 pub pad: u64,
250}
251impl Clone for CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 {
252 fn clone(&self) -> Self {
253 *self
254 }
255}
256impl Clone for CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st {
257 fn clone(&self) -> Self {
258 *self
259 }
260}
261#[repr(C)]
262#[derive(Copy)]
263pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st {
264 pub operation: CUstreamBatchMemOpType,
265 pub address: CUdeviceptr,
266 pub __bindgen_anon_1: CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
267 pub flags: ::std::os::raw::c_uint,
268 pub alias: CUdeviceptr,
269}
270#[repr(C)]
271#[derive(Copy)]
272pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 {
273 pub value: u32,
274 pub pad: u64,
275}
276impl Clone for CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 {
277 fn clone(&self) -> Self {
278 *self
279 }
280}
281impl Clone for CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st {
282 fn clone(&self) -> Self {
283 *self
284 }
285}
286#[repr(C)]
287#[derive(Debug, Copy)]
288pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st {
289 pub operation: CUstreamBatchMemOpType,
290 pub flags: ::std::os::raw::c_uint,
291}
292impl Clone for CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st {
293 fn clone(&self) -> Self {
294 *self
295 }
296}
297impl Clone for CUstreamBatchMemOpParams_union {
298 fn clone(&self) -> Self {
299 *self
300 }
301}
302pub type CUstreamBatchMemOpParams = CUstreamBatchMemOpParams_union;
303#[repr(u32)]
304#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
305pub enum CUoccupancy_flags_enum {
306 CU_OCCUPANCY_DEFAULT = 0,
307 CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = 1,
308}
309pub type CUoccupancy_flags = CUoccupancy_flags_enum;
310#[repr(u32)]
311#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
312pub enum CUarray_format_enum {
313 CU_AD_FORMAT_UNSIGNED_INT8 = 1,
314 CU_AD_FORMAT_UNSIGNED_INT16 = 2,
315 CU_AD_FORMAT_UNSIGNED_INT32 = 3,
316 CU_AD_FORMAT_SIGNED_INT8 = 8,
317 CU_AD_FORMAT_SIGNED_INT16 = 9,
318 CU_AD_FORMAT_SIGNED_INT32 = 10,
319 CU_AD_FORMAT_HALF = 16,
320 CU_AD_FORMAT_FLOAT = 32,
321}
322pub type CUarray_format = CUarray_format_enum;
323#[repr(u32)]
324#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
325pub enum CUaddress_mode_enum {
326 CU_TR_ADDRESS_MODE_WRAP = 0,
327 CU_TR_ADDRESS_MODE_CLAMP = 1,
328 CU_TR_ADDRESS_MODE_MIRROR = 2,
329 CU_TR_ADDRESS_MODE_BORDER = 3,
330}
331pub type CUaddress_mode = CUaddress_mode_enum;
332#[repr(u32)]
333#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
334pub enum CUfilter_mode_enum {
335 CU_TR_FILTER_MODE_POINT = 0,
336 CU_TR_FILTER_MODE_LINEAR = 1,
337}
338pub type CUfilter_mode = CUfilter_mode_enum;
339pub const CUdevice_attribute_enum_CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum =
340 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK;
341pub const CUdevice_attribute_enum_CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK: CUdevice_attribute_enum =
342 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK;
343pub const CUdevice_attribute_enum_CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH: CUdevice_attribute_enum =
344 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH;
345pub const CUdevice_attribute_enum_CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT: CUdevice_attribute_enum =
346 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT;
347pub const CUdevice_attribute_enum_CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES: CUdevice_attribute_enum =
348 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS;
349#[repr(u32)]
350#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
351pub enum CUdevice_attribute_enum {
352 CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1,
353 CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2,
354 CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3,
355 CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4,
356 CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5,
357 CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6,
358 CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7,
359 CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8,
360 CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9,
361 CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10,
362 CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11,
363 CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12,
364 CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,
365 CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14,
366 CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15,
367 CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,
368 CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17,
369 CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,
370 CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,
371 CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,
372 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21,
373 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22,
374 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23,
375 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24,
376 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25,
377 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26,
378 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = 27,
379 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28,
380 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29,
381 CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30,
382 CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,
383 CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32,
384 CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33,
385 CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34,
386 CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35,
387 CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36,
388 CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37,
389 CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38,
390 CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = 39,
391 CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40,
392 CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41,
393 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = 42,
394 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = 43,
395 CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = 44,
396 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = 45,
397 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = 46,
398 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = 47,
399 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = 48,
400 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = 49,
401 CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50,
402 CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51,
403 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = 52,
404 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = 53,
405 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = 54,
406 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = 55,
407 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = 56,
408 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = 57,
409 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = 58,
410 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = 59,
411 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = 60,
412 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = 61,
413 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = 62,
414 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = 63,
415 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = 64,
416 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = 65,
417 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = 66,
418 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = 67,
419 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = 68,
420 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = 69,
421 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = 70,
422 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = 71,
423 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = 72,
424 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = 73,
425 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = 74,
426 CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75,
427 CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76,
428 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = 77,
429 CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = 78,
430 CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = 79,
431 CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = 80,
432 CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = 81,
433 CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82,
434 CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83,
435 CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = 84,
436 CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85,
437 CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = 86,
438 CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = 87,
439 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = 88,
440 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = 89,
441 CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = 90,
442 CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = 91,
443 CU_DEVICE_ATTRIBUTE_MAX = 92,
444}
445pub type CUdevice_attribute = CUdevice_attribute_enum;
446#[repr(C)]
447#[derive(Debug, Copy)]
448pub struct CUdevprop_st {
449 pub maxThreadsPerBlock: ::std::os::raw::c_int,
450 pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
451 pub maxGridSize: [::std::os::raw::c_int; 3usize],
452 pub sharedMemPerBlock: ::std::os::raw::c_int,
453 pub totalConstantMemory: ::std::os::raw::c_int,
454 pub SIMDWidth: ::std::os::raw::c_int,
455 pub memPitch: ::std::os::raw::c_int,
456 pub regsPerBlock: ::std::os::raw::c_int,
457 pub clockRate: ::std::os::raw::c_int,
458 pub textureAlign: ::std::os::raw::c_int,
459}
460impl Clone for CUdevprop_st {
461 fn clone(&self) -> Self {
462 *self
463 }
464}
465pub type CUdevprop = CUdevprop_st;
466#[repr(u32)]
467#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
468pub enum CUpointer_attribute_enum {
469 CU_POINTER_ATTRIBUTE_CONTEXT = 1,
470 CU_POINTER_ATTRIBUTE_MEMORY_TYPE = 2,
471 CU_POINTER_ATTRIBUTE_DEVICE_POINTER = 3,
472 CU_POINTER_ATTRIBUTE_HOST_POINTER = 4,
473 CU_POINTER_ATTRIBUTE_P2P_TOKENS = 5,
474 CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6,
475 CU_POINTER_ATTRIBUTE_BUFFER_ID = 7,
476 CU_POINTER_ATTRIBUTE_IS_MANAGED = 8,
477}
478pub type CUpointer_attribute = CUpointer_attribute_enum;
479#[repr(u32)]
480#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
481pub enum CUfunction_attribute_enum {
482 CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0,
483 CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1,
484 CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2,
485 CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3,
486 CU_FUNC_ATTRIBUTE_NUM_REGS = 4,
487 CU_FUNC_ATTRIBUTE_PTX_VERSION = 5,
488 CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6,
489 CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7,
490 CU_FUNC_ATTRIBUTE_MAX = 8,
491}
492pub type CUfunction_attribute = CUfunction_attribute_enum;
493#[repr(u32)]
494#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
495pub enum CUfunc_cache_enum {
496 CU_FUNC_CACHE_PREFER_NONE = 0,
497 CU_FUNC_CACHE_PREFER_SHARED = 1,
498 CU_FUNC_CACHE_PREFER_L1 = 2,
499 CU_FUNC_CACHE_PREFER_EQUAL = 3,
500}
501pub type CUfunc_cache = CUfunc_cache_enum;
502#[repr(u32)]
503#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
504pub enum CUsharedconfig_enum {
505 CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = 0,
506 CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = 1,
507 CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = 2,
508}
509pub type CUsharedconfig = CUsharedconfig_enum;
510#[repr(u32)]
511#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
512pub enum CUmemorytype_enum {
513 CU_MEMORYTYPE_HOST = 1,
514 CU_MEMORYTYPE_DEVICE = 2,
515 CU_MEMORYTYPE_ARRAY = 3,
516 CU_MEMORYTYPE_UNIFIED = 4,
517}
518pub type CUmemorytype = CUmemorytype_enum;
519#[repr(u32)]
520#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
521pub enum CUcomputemode_enum {
522 CU_COMPUTEMODE_DEFAULT = 0,
523 CU_COMPUTEMODE_PROHIBITED = 2,
524 CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3,
525}
526pub type CUcomputemode = CUcomputemode_enum;
527#[repr(u32)]
528#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
529pub enum CUmem_advise_enum {
530 CU_MEM_ADVISE_SET_READ_MOSTLY = 1,
531 CU_MEM_ADVISE_UNSET_READ_MOSTLY = 2,
532 CU_MEM_ADVISE_SET_PREFERRED_LOCATION = 3,
533 CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = 4,
534 CU_MEM_ADVISE_SET_ACCESSED_BY = 5,
535 CU_MEM_ADVISE_UNSET_ACCESSED_BY = 6,
536}
537pub type CUmem_advise = CUmem_advise_enum;
538#[repr(u32)]
539#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
540pub enum CUmem_range_attribute_enum {
541 CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = 1,
542 CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = 2,
543 CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = 3,
544 CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = 4,
545}
546pub type CUmem_range_attribute = CUmem_range_attribute_enum;
547#[repr(u32)]
548#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
549pub enum CUjit_option_enum {
550 CU_JIT_MAX_REGISTERS = 0,
551 CU_JIT_THREADS_PER_BLOCK = 1,
552 CU_JIT_WALL_TIME = 2,
553 CU_JIT_INFO_LOG_BUFFER = 3,
554 CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4,
555 CU_JIT_ERROR_LOG_BUFFER = 5,
556 CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6,
557 CU_JIT_OPTIMIZATION_LEVEL = 7,
558 CU_JIT_TARGET_FROM_CUCONTEXT = 8,
559 CU_JIT_TARGET = 9,
560 CU_JIT_FALLBACK_STRATEGY = 10,
561 CU_JIT_GENERATE_DEBUG_INFO = 11,
562 CU_JIT_LOG_VERBOSE = 12,
563 CU_JIT_GENERATE_LINE_INFO = 13,
564 CU_JIT_CACHE_MODE = 14,
565 CU_JIT_NEW_SM3X_OPT = 15,
566 CU_JIT_FAST_COMPILE = 16,
567 CU_JIT_NUM_OPTIONS = 17,
568}
569pub type CUjit_option = CUjit_option_enum;
570#[repr(u32)]
571#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
572pub enum CUjit_target_enum {
573 CU_TARGET_COMPUTE_10 = 10,
574 CU_TARGET_COMPUTE_11 = 11,
575 CU_TARGET_COMPUTE_12 = 12,
576 CU_TARGET_COMPUTE_13 = 13,
577 CU_TARGET_COMPUTE_20 = 20,
578 CU_TARGET_COMPUTE_21 = 21,
579 CU_TARGET_COMPUTE_30 = 30,
580 CU_TARGET_COMPUTE_32 = 32,
581 CU_TARGET_COMPUTE_35 = 35,
582 CU_TARGET_COMPUTE_37 = 37,
583 CU_TARGET_COMPUTE_50 = 50,
584 CU_TARGET_COMPUTE_52 = 52,
585 CU_TARGET_COMPUTE_53 = 53,
586 CU_TARGET_COMPUTE_60 = 60,
587 CU_TARGET_COMPUTE_61 = 61,
588 CU_TARGET_COMPUTE_62 = 62,
589}
590pub type CUjit_target = CUjit_target_enum;
591#[repr(u32)]
592#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
593pub enum CUjit_fallback_enum {
594 CU_PREFER_PTX = 0,
595 CU_PREFER_BINARY = 1,
596}
597pub type CUjit_fallback = CUjit_fallback_enum;
598#[repr(u32)]
599#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
600pub enum CUjit_cacheMode_enum {
601 CU_JIT_CACHE_OPTION_NONE = 0,
602 CU_JIT_CACHE_OPTION_CG = 1,
603 CU_JIT_CACHE_OPTION_CA = 2,
604}
605pub type CUjit_cacheMode = CUjit_cacheMode_enum;
606#[repr(u32)]
607#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
608pub enum CUjitInputType_enum {
609 CU_JIT_INPUT_CUBIN = 0,
610 CU_JIT_INPUT_PTX = 1,
611 CU_JIT_INPUT_FATBINARY = 2,
612 CU_JIT_INPUT_OBJECT = 3,
613 CU_JIT_INPUT_LIBRARY = 4,
614 CU_JIT_NUM_INPUT_TYPES = 5,
615}
616pub type CUjitInputType = CUjitInputType_enum;
617#[repr(C)]
618#[derive(Debug, Copy)]
619pub struct CUlinkState_st {
620 pub _address: u8,
621}
622impl Clone for CUlinkState_st {
623 fn clone(&self) -> Self {
624 *self
625 }
626}
627pub type CUlinkState = *mut CUlinkState_st;
628#[repr(u32)]
629#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
630pub enum CUgraphicsRegisterFlags_enum {
631 CU_GRAPHICS_REGISTER_FLAGS_NONE = 0,
632 CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = 1,
633 CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = 2,
634 CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = 4,
635 CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = 8,
636}
637pub type CUgraphicsRegisterFlags = CUgraphicsRegisterFlags_enum;
638#[repr(u32)]
639#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
640pub enum CUgraphicsMapResourceFlags_enum {
641 CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0,
642 CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 1,
643 CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 2,
644}
645pub type CUgraphicsMapResourceFlags = CUgraphicsMapResourceFlags_enum;
646#[repr(u32)]
647#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
648pub enum CUarray_cubemap_face_enum {
649 CU_CUBEMAP_FACE_POSITIVE_X = 0,
650 CU_CUBEMAP_FACE_NEGATIVE_X = 1,
651 CU_CUBEMAP_FACE_POSITIVE_Y = 2,
652 CU_CUBEMAP_FACE_NEGATIVE_Y = 3,
653 CU_CUBEMAP_FACE_POSITIVE_Z = 4,
654 CU_CUBEMAP_FACE_NEGATIVE_Z = 5,
655}
656pub type CUarray_cubemap_face = CUarray_cubemap_face_enum;
657#[repr(u32)]
658#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
659pub enum CUlimit_enum {
660 CU_LIMIT_STACK_SIZE = 0,
661 CU_LIMIT_PRINTF_FIFO_SIZE = 1,
662 CU_LIMIT_MALLOC_HEAP_SIZE = 2,
663 CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = 3,
664 CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = 4,
665 CU_LIMIT_MAX = 5,
666}
667pub type CUlimit = CUlimit_enum;
668#[repr(u32)]
669#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
670pub enum CUresourcetype_enum {
671 CU_RESOURCE_TYPE_ARRAY = 0,
672 CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 1,
673 CU_RESOURCE_TYPE_LINEAR = 2,
674 CU_RESOURCE_TYPE_PITCH2D = 3,
675}
676pub type CUresourcetype = CUresourcetype_enum;
677#[repr(u32)]
678#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
679pub enum cudaError_t {
680 CUDA_SUCCESS = 0,
681 CUDA_ERROR_INVALID_VALUE = 1,
682 CUDA_ERROR_OUT_OF_MEMORY = 2,
683 CUDA_ERROR_NOT_INITIALIZED = 3,
684 CUDA_ERROR_DEINITIALIZED = 4,
685 CUDA_ERROR_PROFILER_DISABLED = 5,
686 CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6,
687 CUDA_ERROR_PROFILER_ALREADY_STARTED = 7,
688 CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8,
689 CUDA_ERROR_NO_DEVICE = 100,
690 CUDA_ERROR_INVALID_DEVICE = 101,
691 CUDA_ERROR_INVALID_IMAGE = 200,
692 CUDA_ERROR_INVALID_CONTEXT = 201,
693 CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202,
694 CUDA_ERROR_MAP_FAILED = 205,
695 CUDA_ERROR_UNMAP_FAILED = 206,
696 CUDA_ERROR_ARRAY_IS_MAPPED = 207,
697 CUDA_ERROR_ALREADY_MAPPED = 208,
698 CUDA_ERROR_NO_BINARY_FOR_GPU = 209,
699 CUDA_ERROR_ALREADY_ACQUIRED = 210,
700 CUDA_ERROR_NOT_MAPPED = 211,
701 CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212,
702 CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213,
703 CUDA_ERROR_ECC_UNCORRECTABLE = 214,
704 CUDA_ERROR_UNSUPPORTED_LIMIT = 215,
705 CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216,
706 CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217,
707 CUDA_ERROR_INVALID_PTX = 218,
708 CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219,
709 CUDA_ERROR_NVLINK_UNCORRECTABLE = 220,
710 CUDA_ERROR_INVALID_SOURCE = 300,
711 CUDA_ERROR_FILE_NOT_FOUND = 301,
712 CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302,
713 CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303,
714 CUDA_ERROR_OPERATING_SYSTEM = 304,
715 CUDA_ERROR_INVALID_HANDLE = 400,
716 CUDA_ERROR_NOT_FOUND = 500,
717 CUDA_ERROR_NOT_READY = 600,
718 CUDA_ERROR_ILLEGAL_ADDRESS = 700,
719 CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701,
720 CUDA_ERROR_LAUNCH_TIMEOUT = 702,
721 CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703,
722 CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704,
723 CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705,
724 CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708,
725 CUDA_ERROR_CONTEXT_IS_DESTROYED = 709,
726 CUDA_ERROR_ASSERT = 710,
727 CUDA_ERROR_TOO_MANY_PEERS = 711,
728 CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712,
729 CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713,
730 CUDA_ERROR_HARDWARE_STACK_ERROR = 714,
731 CUDA_ERROR_ILLEGAL_INSTRUCTION = 715,
732 CUDA_ERROR_MISALIGNED_ADDRESS = 716,
733 CUDA_ERROR_INVALID_ADDRESS_SPACE = 717,
734 CUDA_ERROR_INVALID_PC = 718,
735 CUDA_ERROR_LAUNCH_FAILED = 719,
736 CUDA_ERROR_NOT_PERMITTED = 800,
737 CUDA_ERROR_NOT_SUPPORTED = 801,
738 CUDA_ERROR_UNKNOWN = 999,
739}
740pub type CUresult = cudaError_t;
741#[repr(u32)]
742#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
743pub enum CUdevice_P2PAttribute_enum {
744 CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = 1,
745 CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = 2,
746 CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = 3,
747}
748pub type CUdevice_P2PAttribute = CUdevice_P2PAttribute_enum;
749pub type CUstreamCallback = ::std::option::Option<
750 unsafe extern "C" fn(hStream: CUstream, status: CUresult, userData: *mut ::std::os::raw::c_void),
751>;
752pub type CUoccupancyB2DSize =
753 ::std::option::Option<unsafe extern "C" fn(blockSize: ::std::os::raw::c_int) -> ::std::os::raw::c_ulong>;
754#[repr(C)]
755#[derive(Debug, Copy)]
756pub struct CUDA_MEMCPY2D_st {
757 pub srcXInBytes: usize,
758 pub srcY: usize,
759 pub srcMemoryType: CUmemorytype,
760 pub srcHost: *const ::std::os::raw::c_void,
761 pub srcDevice: CUdeviceptr,
762 pub srcArray: CUarray,
763 pub srcPitch: usize,
764 pub dstXInBytes: usize,
765 pub dstY: usize,
766 pub dstMemoryType: CUmemorytype,
767 pub dstHost: *mut ::std::os::raw::c_void,
768 pub dstDevice: CUdeviceptr,
769 pub dstArray: CUarray,
770 pub dstPitch: usize,
771 pub WidthInBytes: usize,
772 pub Height: usize,
773}
774impl Clone for CUDA_MEMCPY2D_st {
775 fn clone(&self) -> Self {
776 *self
777 }
778}
779pub type CUDA_MEMCPY2D = CUDA_MEMCPY2D_st;
780#[repr(C)]
781#[derive(Debug, Copy)]
782pub struct CUDA_MEMCPY3D_st {
783 pub srcXInBytes: usize,
784 pub srcY: usize,
785 pub srcZ: usize,
786 pub srcLOD: usize,
787 pub srcMemoryType: CUmemorytype,
788 pub srcHost: *const ::std::os::raw::c_void,
789 pub srcDevice: CUdeviceptr,
790 pub srcArray: CUarray,
791 pub reserved0: *mut ::std::os::raw::c_void,
792 pub srcPitch: usize,
793 pub srcHeight: usize,
794 pub dstXInBytes: usize,
795 pub dstY: usize,
796 pub dstZ: usize,
797 pub dstLOD: usize,
798 pub dstMemoryType: CUmemorytype,
799 pub dstHost: *mut ::std::os::raw::c_void,
800 pub dstDevice: CUdeviceptr,
801 pub dstArray: CUarray,
802 pub reserved1: *mut ::std::os::raw::c_void,
803 pub dstPitch: usize,
804 pub dstHeight: usize,
805 pub WidthInBytes: usize,
806 pub Height: usize,
807 pub Depth: usize,
808}
809impl Clone for CUDA_MEMCPY3D_st {
810 fn clone(&self) -> Self {
811 *self
812 }
813}
814pub type CUDA_MEMCPY3D = CUDA_MEMCPY3D_st;
815#[repr(C)]
816#[derive(Debug, Copy)]
817pub struct CUDA_MEMCPY3D_PEER_st {
818 pub srcXInBytes: usize,
819 pub srcY: usize,
820 pub srcZ: usize,
821 pub srcLOD: usize,
822 pub srcMemoryType: CUmemorytype,
823 pub srcHost: *const ::std::os::raw::c_void,
824 pub srcDevice: CUdeviceptr,
825 pub srcArray: CUarray,
826 pub srcContext: CUcontext,
827 pub srcPitch: usize,
828 pub srcHeight: usize,
829 pub dstXInBytes: usize,
830 pub dstY: usize,
831 pub dstZ: usize,
832 pub dstLOD: usize,
833 pub dstMemoryType: CUmemorytype,
834 pub dstHost: *mut ::std::os::raw::c_void,
835 pub dstDevice: CUdeviceptr,
836 pub dstArray: CUarray,
837 pub dstContext: CUcontext,
838 pub dstPitch: usize,
839 pub dstHeight: usize,
840 pub WidthInBytes: usize,
841 pub Height: usize,
842 pub Depth: usize,
843}
844impl Clone for CUDA_MEMCPY3D_PEER_st {
845 fn clone(&self) -> Self {
846 *self
847 }
848}
849pub type CUDA_MEMCPY3D_PEER = CUDA_MEMCPY3D_PEER_st;
850#[repr(C)]
851#[derive(Debug, Copy)]
852pub struct CUDA_ARRAY_DESCRIPTOR_st {
853 pub Width: usize,
854 pub Height: usize,
855 pub Format: CUarray_format,
856 pub NumChannels: ::std::os::raw::c_uint,
857}
858impl Clone for CUDA_ARRAY_DESCRIPTOR_st {
859 fn clone(&self) -> Self {
860 *self
861 }
862}
863pub type CUDA_ARRAY_DESCRIPTOR = CUDA_ARRAY_DESCRIPTOR_st;
864#[repr(C)]
865#[derive(Debug, Copy)]
866pub struct CUDA_ARRAY3D_DESCRIPTOR_st {
867 pub Width: usize,
868 pub Height: usize,
869 pub Depth: usize,
870 pub Format: CUarray_format,
871 pub NumChannels: ::std::os::raw::c_uint,
872 pub Flags: ::std::os::raw::c_uint,
873}
874impl Clone for CUDA_ARRAY3D_DESCRIPTOR_st {
875 fn clone(&self) -> Self {
876 *self
877 }
878}
879pub type CUDA_ARRAY3D_DESCRIPTOR = CUDA_ARRAY3D_DESCRIPTOR_st;
880#[repr(C)]
881#[derive(Copy)]
882pub struct CUDA_RESOURCE_DESC_st {
883 pub resType: CUresourcetype,
884 pub res: CUDA_RESOURCE_DESC_st__bindgen_ty_1,
885 pub flags: ::std::os::raw::c_uint,
886}
887#[repr(C)]
888#[derive(Copy)]
889pub union CUDA_RESOURCE_DESC_st__bindgen_ty_1 {
890 pub array: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1,
891 pub mipmap: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2,
892 pub linear: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
893 pub pitch2D: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
894 pub reserved: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
895}
896#[repr(C)]
897#[derive(Debug, Copy)]
898pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
899 pub hArray: CUarray,
900}
901impl Clone for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
902 fn clone(&self) -> Self {
903 *self
904 }
905}
906#[repr(C)]
907#[derive(Debug, Copy)]
908pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
909 pub hMipmappedArray: CUmipmappedArray,
910}
911impl Clone for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
912 fn clone(&self) -> Self {
913 *self
914 }
915}
916#[repr(C)]
917#[derive(Debug, Copy)]
918pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
919 pub devPtr: CUdeviceptr,
920 pub format: CUarray_format,
921 pub numChannels: ::std::os::raw::c_uint,
922 pub sizeInBytes: usize,
923}
924impl Clone for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
925 fn clone(&self) -> Self {
926 *self
927 }
928}
929#[repr(C)]
930#[derive(Debug, Copy)]
931pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
932 pub devPtr: CUdeviceptr,
933 pub format: CUarray_format,
934 pub numChannels: ::std::os::raw::c_uint,
935 pub width: usize,
936 pub height: usize,
937 pub pitchInBytes: usize,
938}
939impl Clone for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
940 fn clone(&self) -> Self {
941 *self
942 }
943}
944#[repr(C)]
945#[derive(Debug, Copy)]
946pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
947 pub reserved: [::std::os::raw::c_int; 32usize],
948}
949impl Clone for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
950 fn clone(&self) -> Self {
951 *self
952 }
953}
954impl Clone for CUDA_RESOURCE_DESC_st__bindgen_ty_1 {
955 fn clone(&self) -> Self {
956 *self
957 }
958}
959impl Clone for CUDA_RESOURCE_DESC_st {
960 fn clone(&self) -> Self {
961 *self
962 }
963}
964pub type CUDA_RESOURCE_DESC = CUDA_RESOURCE_DESC_st;
965#[repr(C)]
966#[derive(Debug, Copy)]
967pub struct CUDA_TEXTURE_DESC_st {
968 pub addressMode: [CUaddress_mode; 3usize],
969 pub filterMode: CUfilter_mode,
970 pub flags: ::std::os::raw::c_uint,
971 pub maxAnisotropy: ::std::os::raw::c_uint,
972 pub mipmapFilterMode: CUfilter_mode,
973 pub mipmapLevelBias: f32,
974 pub minMipmapLevelClamp: f32,
975 pub maxMipmapLevelClamp: f32,
976 pub borderColor: [f32; 4usize],
977 pub reserved: [::std::os::raw::c_int; 12usize],
978}
979impl Clone for CUDA_TEXTURE_DESC_st {
980 fn clone(&self) -> Self {
981 *self
982 }
983}
984pub type CUDA_TEXTURE_DESC = CUDA_TEXTURE_DESC_st;
985#[repr(u32)]
986#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
987pub enum CUresourceViewFormat_enum {
988 CU_RES_VIEW_FORMAT_NONE = 0,
989 CU_RES_VIEW_FORMAT_UINT_1X8 = 1,
990 CU_RES_VIEW_FORMAT_UINT_2X8 = 2,
991 CU_RES_VIEW_FORMAT_UINT_4X8 = 3,
992 CU_RES_VIEW_FORMAT_SINT_1X8 = 4,
993 CU_RES_VIEW_FORMAT_SINT_2X8 = 5,
994 CU_RES_VIEW_FORMAT_SINT_4X8 = 6,
995 CU_RES_VIEW_FORMAT_UINT_1X16 = 7,
996 CU_RES_VIEW_FORMAT_UINT_2X16 = 8,
997 CU_RES_VIEW_FORMAT_UINT_4X16 = 9,
998 CU_RES_VIEW_FORMAT_SINT_1X16 = 10,
999 CU_RES_VIEW_FORMAT_SINT_2X16 = 11,
1000 CU_RES_VIEW_FORMAT_SINT_4X16 = 12,
1001 CU_RES_VIEW_FORMAT_UINT_1X32 = 13,
1002 CU_RES_VIEW_FORMAT_UINT_2X32 = 14,
1003 CU_RES_VIEW_FORMAT_UINT_4X32 = 15,
1004 CU_RES_VIEW_FORMAT_SINT_1X32 = 16,
1005 CU_RES_VIEW_FORMAT_SINT_2X32 = 17,
1006 CU_RES_VIEW_FORMAT_SINT_4X32 = 18,
1007 CU_RES_VIEW_FORMAT_FLOAT_1X16 = 19,
1008 CU_RES_VIEW_FORMAT_FLOAT_2X16 = 20,
1009 CU_RES_VIEW_FORMAT_FLOAT_4X16 = 21,
1010 CU_RES_VIEW_FORMAT_FLOAT_1X32 = 22,
1011 CU_RES_VIEW_FORMAT_FLOAT_2X32 = 23,
1012 CU_RES_VIEW_FORMAT_FLOAT_4X32 = 24,
1013 CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = 25,
1014 CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = 26,
1015 CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = 27,
1016 CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = 28,
1017 CU_RES_VIEW_FORMAT_SIGNED_BC4 = 29,
1018 CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = 30,
1019 CU_RES_VIEW_FORMAT_SIGNED_BC5 = 31,
1020 CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = 32,
1021 CU_RES_VIEW_FORMAT_SIGNED_BC6H = 33,
1022 CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = 34,
1023}
1024pub type CUresourceViewFormat = CUresourceViewFormat_enum;
1025#[repr(C)]
1026#[derive(Debug, Copy)]
1027pub struct CUDA_RESOURCE_VIEW_DESC_st {
1028 pub format: CUresourceViewFormat,
1029 pub width: usize,
1030 pub height: usize,
1031 pub depth: usize,
1032 pub firstMipmapLevel: ::std::os::raw::c_uint,
1033 pub lastMipmapLevel: ::std::os::raw::c_uint,
1034 pub firstLayer: ::std::os::raw::c_uint,
1035 pub lastLayer: ::std::os::raw::c_uint,
1036 pub reserved: [::std::os::raw::c_uint; 16usize],
1037}
1038impl Clone for CUDA_RESOURCE_VIEW_DESC_st {
1039 fn clone(&self) -> Self {
1040 *self
1041 }
1042}
1043pub type CUDA_RESOURCE_VIEW_DESC = CUDA_RESOURCE_VIEW_DESC_st;
1044#[repr(C)]
1045#[derive(Debug, Copy)]
1046pub struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st {
1047 pub p2pToken: ::std::os::raw::c_ulonglong,
1048 pub vaSpaceToken: ::std::os::raw::c_uint,
1049}
1050impl Clone for CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st {
1051 fn clone(&self) -> Self {
1052 *self
1053 }
1054}
1055pub type CUDA_POINTER_ATTRIBUTE_P2P_TOKENS = CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st;
1056extern "C" {
1057 pub fn cuGetErrorString(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult;
1058
1059 pub fn cuGetErrorName(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult;
1060
1061 pub fn cuInit(Flags: ::std::os::raw::c_uint) -> CUresult;
1062
1063 pub fn cuDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> CUresult;
1064
1065 pub fn cuDeviceGet(device: *mut CUdevice, ordinal: ::std::os::raw::c_int) -> CUresult;
1066
1067 pub fn cuDeviceGetCount(count: *mut ::std::os::raw::c_int) -> CUresult;
1068
1069 pub fn cuDeviceGetName(name: *mut ::std::os::raw::c_char, len: ::std::os::raw::c_int, dev: CUdevice) -> CUresult;
1070
1071 pub fn cuDeviceTotalMem_v2(bytes: *mut usize, dev: CUdevice) -> CUresult;
1072
1073 pub fn cuDeviceGetAttribute(pi: *mut ::std::os::raw::c_int, attrib: CUdevice_attribute, dev: CUdevice) -> CUresult;
1074
1075 pub fn cuDeviceGetProperties(prop: *mut CUdevprop, dev: CUdevice) -> CUresult;
1076
1077 pub fn cuDeviceComputeCapability(
1078 major: *mut ::std::os::raw::c_int,
1079 minor: *mut ::std::os::raw::c_int,
1080 dev: CUdevice,
1081 ) -> CUresult;
1082
1083 pub fn cuDevicePrimaryCtxRetain(pctx: *mut CUcontext, dev: CUdevice) -> CUresult;
1084
1085 pub fn cuDevicePrimaryCtxRelease(dev: CUdevice) -> CUresult;
1086
1087 pub fn cuDevicePrimaryCtxSetFlags(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult;
1088
1089 pub fn cuDevicePrimaryCtxGetState(
1090 dev: CUdevice,
1091 flags: *mut ::std::os::raw::c_uint,
1092 active: *mut ::std::os::raw::c_int,
1093 ) -> CUresult;
1094
1095 pub fn cuDevicePrimaryCtxReset(dev: CUdevice) -> CUresult;
1096
1097 pub fn cuCtxCreate_v2(pctx: *mut CUcontext, flags: ::std::os::raw::c_uint, dev: CUdevice) -> CUresult;
1098
1099 pub fn cuCtxDestroy_v2(ctx: CUcontext) -> CUresult;
1100
1101 pub fn cuCtxPushCurrent_v2(ctx: CUcontext) -> CUresult;
1102
1103 pub fn cuCtxPopCurrent_v2(pctx: *mut CUcontext) -> CUresult;
1104
1105 pub fn cuCtxSetCurrent(ctx: CUcontext) -> CUresult;
1106
1107 pub fn cuCtxGetCurrent(pctx: *mut CUcontext) -> CUresult;
1108
1109 pub fn cuCtxGetDevice(device: *mut CUdevice) -> CUresult;
1110
1111 pub fn cuCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> CUresult;
1112
1113 pub fn cuCtxSynchronize() -> CUresult;
1114
1115 pub fn cuCtxSetLimit(limit: CUlimit, value: usize) -> CUresult;
1116
1117 pub fn cuCtxGetLimit(pvalue: *mut usize, limit: CUlimit) -> CUresult;
1118
1119 pub fn cuCtxGetCacheConfig(pconfig: *mut CUfunc_cache) -> CUresult;
1120
1121 pub fn cuCtxSetCacheConfig(config: CUfunc_cache) -> CUresult;
1122
1123 pub fn cuCtxGetSharedMemConfig(pConfig: *mut CUsharedconfig) -> CUresult;
1124
1125 pub fn cuCtxSetSharedMemConfig(config: CUsharedconfig) -> CUresult;
1126
1127 pub fn cuCtxGetApiVersion(ctx: CUcontext, version: *mut ::std::os::raw::c_uint) -> CUresult;
1128
1129 pub fn cuCtxGetStreamPriorityRange(
1130 leastPriority: *mut ::std::os::raw::c_int,
1131 greatestPriority: *mut ::std::os::raw::c_int,
1132 ) -> CUresult;
1133
1134 pub fn cuCtxAttach(pctx: *mut CUcontext, flags: ::std::os::raw::c_uint) -> CUresult;
1135
1136 pub fn cuCtxDetach(ctx: CUcontext) -> CUresult;
1137
1138 pub fn cuModuleLoad(module: *mut CUmodule, fname: *const ::std::os::raw::c_char) -> CUresult;
1139
1140 pub fn cuModuleLoadData(module: *mut CUmodule, image: *const ::std::os::raw::c_void) -> CUresult;
1141
1142 pub fn cuModuleLoadDataEx(
1143 module: *mut CUmodule,
1144 image: *const ::std::os::raw::c_void,
1145 numOptions: ::std::os::raw::c_uint,
1146 options: *mut CUjit_option,
1147 optionValues: *mut *mut ::std::os::raw::c_void,
1148 ) -> CUresult;
1149
1150 pub fn cuModuleLoadFatBinary(module: *mut CUmodule, fatCubin: *const ::std::os::raw::c_void) -> CUresult;
1151
1152 pub fn cuModuleUnload(hmod: CUmodule) -> CUresult;
1153
1154 pub fn cuModuleGetFunction(hfunc: *mut CUfunction, hmod: CUmodule, name: *const ::std::os::raw::c_char)
1155 -> CUresult;
1156
1157 pub fn cuModuleGetGlobal_v2(
1158 dptr: *mut CUdeviceptr,
1159 bytes: *mut usize,
1160 hmod: CUmodule,
1161 name: *const ::std::os::raw::c_char,
1162 ) -> CUresult;
1163
1164 pub fn cuModuleGetTexRef(pTexRef: *mut CUtexref, hmod: CUmodule, name: *const ::std::os::raw::c_char) -> CUresult;
1165
1166 pub fn cuModuleGetSurfRef(
1167 pSurfRef: *mut CUsurfref,
1168 hmod: CUmodule,
1169 name: *const ::std::os::raw::c_char,
1170 ) -> CUresult;
1171
1172 pub fn cuLinkCreate_v2(
1173 numOptions: ::std::os::raw::c_uint,
1174 options: *mut CUjit_option,
1175 optionValues: *mut *mut ::std::os::raw::c_void,
1176 stateOut: *mut CUlinkState,
1177 ) -> CUresult;
1178
1179 pub fn cuLinkAddData_v2(
1180 state: CUlinkState,
1181 type_: CUjitInputType,
1182 data: *mut ::std::os::raw::c_void,
1183 size: usize,
1184 name: *const ::std::os::raw::c_char,
1185 numOptions: ::std::os::raw::c_uint,
1186 options: *mut CUjit_option,
1187 optionValues: *mut *mut ::std::os::raw::c_void,
1188 ) -> CUresult;
1189
1190 pub fn cuLinkAddFile_v2(
1191 state: CUlinkState,
1192 type_: CUjitInputType,
1193 path: *const ::std::os::raw::c_char,
1194 numOptions: ::std::os::raw::c_uint,
1195 options: *mut CUjit_option,
1196 optionValues: *mut *mut ::std::os::raw::c_void,
1197 ) -> CUresult;
1198
1199 pub fn cuLinkComplete(
1200 state: CUlinkState,
1201 cubinOut: *mut *mut ::std::os::raw::c_void,
1202 sizeOut: *mut usize,
1203 ) -> CUresult;
1204
1205 pub fn cuLinkDestroy(state: CUlinkState) -> CUresult;
1206
1207 pub fn cuMemGetInfo_v2(free: *mut usize, total: *mut usize) -> CUresult;
1208
1209 pub fn cuMemAlloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult;
1210
1211 pub fn cuMemAllocPitch_v2(
1212 dptr: *mut CUdeviceptr,
1213 pPitch: *mut usize,
1214 WidthInBytes: usize,
1215 Height: usize,
1216 ElementSizeBytes: ::std::os::raw::c_uint,
1217 ) -> CUresult;
1218
1219 pub fn cuMemFree_v2(dptr: CUdeviceptr) -> CUresult;
1220
1221 pub fn cuMemGetAddressRange_v2(pbase: *mut CUdeviceptr, psize: *mut usize, dptr: CUdeviceptr) -> CUresult;
1222
1223 pub fn cuMemAllocHost_v2(pp: *mut *mut ::std::os::raw::c_void, bytesize: usize) -> CUresult;
1224
1225 pub fn cuMemFreeHost(p: *mut ::std::os::raw::c_void) -> CUresult;
1226
1227 pub fn cuMemHostAlloc(
1228 pp: *mut *mut ::std::os::raw::c_void,
1229 bytesize: usize,
1230 Flags: ::std::os::raw::c_uint,
1231 ) -> CUresult;
1232
1233 pub fn cuMemHostGetDevicePointer_v2(
1234 pdptr: *mut CUdeviceptr,
1235 p: *mut ::std::os::raw::c_void,
1236 Flags: ::std::os::raw::c_uint,
1237 ) -> CUresult;
1238
1239 pub fn cuMemHostGetFlags(pFlags: *mut ::std::os::raw::c_uint, p: *mut ::std::os::raw::c_void) -> CUresult;
1240
1241 pub fn cuMemAllocManaged(dptr: *mut CUdeviceptr, bytesize: usize, flags: ::std::os::raw::c_uint) -> CUresult;
1242
1243 pub fn cuDeviceGetByPCIBusId(dev: *mut CUdevice, pciBusId: *const ::std::os::raw::c_char) -> CUresult;
1244
1245 pub fn cuDeviceGetPCIBusId(
1246 pciBusId: *mut ::std::os::raw::c_char,
1247 len: ::std::os::raw::c_int,
1248 dev: CUdevice,
1249 ) -> CUresult;
1250
1251 pub fn cuIpcGetEventHandle(pHandle: *mut CUipcEventHandle, event: CUevent) -> CUresult;
1252
1253 pub fn cuIpcOpenEventHandle(phEvent: *mut CUevent, handle: CUipcEventHandle) -> CUresult;
1254
1255 pub fn cuIpcGetMemHandle(pHandle: *mut CUipcMemHandle, dptr: CUdeviceptr) -> CUresult;
1256
1257 pub fn cuIpcOpenMemHandle(
1258 pdptr: *mut CUdeviceptr,
1259 handle: CUipcMemHandle,
1260 Flags: ::std::os::raw::c_uint,
1261 ) -> CUresult;
1262
1263 pub fn cuIpcCloseMemHandle(dptr: CUdeviceptr) -> CUresult;
1264
1265 pub fn cuMemHostRegister_v2(
1266 p: *mut ::std::os::raw::c_void,
1267 bytesize: usize,
1268 Flags: ::std::os::raw::c_uint,
1269 ) -> CUresult;
1270
1271 pub fn cuMemHostUnregister(p: *mut ::std::os::raw::c_void) -> CUresult;
1272
1273 pub fn cuMemcpy(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult;
1274
1275 pub fn cuMemcpyPeer(
1276 dstDevice: CUdeviceptr,
1277 dstContext: CUcontext,
1278 srcDevice: CUdeviceptr,
1279 srcContext: CUcontext,
1280 ByteCount: usize,
1281 ) -> CUresult;
1282
1283 pub fn cuMemcpyHtoD_v2(
1284 dstDevice: CUdeviceptr,
1285 srcHost: *const ::std::os::raw::c_void,
1286 ByteCount: usize,
1287 ) -> CUresult;
1288
1289 pub fn cuMemcpyDtoH_v2(dstHost: *mut ::std::os::raw::c_void, srcDevice: CUdeviceptr, ByteCount: usize) -> CUresult;
1290
1291 pub fn cuMemcpyDtoD_v2(dstDevice: CUdeviceptr, srcDevice: CUdeviceptr, ByteCount: usize) -> CUresult;
1292
1293 pub fn cuMemcpyDtoA_v2(dstArray: CUarray, dstOffset: usize, srcDevice: CUdeviceptr, ByteCount: usize) -> CUresult;
1294
1295 pub fn cuMemcpyAtoD_v2(dstDevice: CUdeviceptr, srcArray: CUarray, srcOffset: usize, ByteCount: usize) -> CUresult;
1296
1297 pub fn cuMemcpyHtoA_v2(
1298 dstArray: CUarray,
1299 dstOffset: usize,
1300 srcHost: *const ::std::os::raw::c_void,
1301 ByteCount: usize,
1302 ) -> CUresult;
1303
1304 pub fn cuMemcpyAtoH_v2(
1305 dstHost: *mut ::std::os::raw::c_void,
1306 srcArray: CUarray,
1307 srcOffset: usize,
1308 ByteCount: usize,
1309 ) -> CUresult;
1310
1311 pub fn cuMemcpyAtoA_v2(
1312 dstArray: CUarray,
1313 dstOffset: usize,
1314 srcArray: CUarray,
1315 srcOffset: usize,
1316 ByteCount: usize,
1317 ) -> CUresult;
1318
1319 pub fn cuMemcpy2D_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
1320
1321 pub fn cuMemcpy2DUnaligned_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
1322
1323 pub fn cuMemcpy3D_v2(pCopy: *const CUDA_MEMCPY3D) -> CUresult;
1324
1325 pub fn cuMemcpy3DPeer(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult;
1326
1327 pub fn cuMemcpyAsync(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize, hStream: CUstream) -> CUresult;
1328
1329 pub fn cuMemcpyPeerAsync(
1330 dstDevice: CUdeviceptr,
1331 dstContext: CUcontext,
1332 srcDevice: CUdeviceptr,
1333 srcContext: CUcontext,
1334 ByteCount: usize,
1335 hStream: CUstream,
1336 ) -> CUresult;
1337
1338 pub fn cuMemcpyHtoDAsync_v2(
1339 dstDevice: CUdeviceptr,
1340 srcHost: *const ::std::os::raw::c_void,
1341 ByteCount: usize,
1342 hStream: CUstream,
1343 ) -> CUresult;
1344
1345 pub fn cuMemcpyDtoHAsync_v2(
1346 dstHost: *mut ::std::os::raw::c_void,
1347 srcDevice: CUdeviceptr,
1348 ByteCount: usize,
1349 hStream: CUstream,
1350 ) -> CUresult;
1351
1352 pub fn cuMemcpyDtoDAsync_v2(
1353 dstDevice: CUdeviceptr,
1354 srcDevice: CUdeviceptr,
1355 ByteCount: usize,
1356 hStream: CUstream,
1357 ) -> CUresult;
1358
1359 pub fn cuMemcpyHtoAAsync_v2(
1360 dstArray: CUarray,
1361 dstOffset: usize,
1362 srcHost: *const ::std::os::raw::c_void,
1363 ByteCount: usize,
1364 hStream: CUstream,
1365 ) -> CUresult;
1366
1367 pub fn cuMemcpyAtoHAsync_v2(
1368 dstHost: *mut ::std::os::raw::c_void,
1369 srcArray: CUarray,
1370 srcOffset: usize,
1371 ByteCount: usize,
1372 hStream: CUstream,
1373 ) -> CUresult;
1374
1375 pub fn cuMemcpy2DAsync_v2(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult;
1376
1377 pub fn cuMemcpy3DAsync_v2(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult;
1378
1379 pub fn cuMemcpy3DPeerAsync(pCopy: *const CUDA_MEMCPY3D_PEER, hStream: CUstream) -> CUresult;
1380
1381 pub fn cuMemsetD8_v2(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize) -> CUresult;
1382
1383 pub fn cuMemsetD16_v2(dstDevice: CUdeviceptr, us: ::std::os::raw::c_ushort, N: usize) -> CUresult;
1384
1385 pub fn cuMemsetD32_v2(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize) -> CUresult;
1386
1387 pub fn cuMemsetD2D8_v2(
1388 dstDevice: CUdeviceptr,
1389 dstPitch: usize,
1390 uc: ::std::os::raw::c_uchar,
1391 Width: usize,
1392 Height: usize,
1393 ) -> CUresult;
1394
1395 pub fn cuMemsetD2D16_v2(
1396 dstDevice: CUdeviceptr,
1397 dstPitch: usize,
1398 us: ::std::os::raw::c_ushort,
1399 Width: usize,
1400 Height: usize,
1401 ) -> CUresult;
1402
1403 pub fn cuMemsetD2D32_v2(
1404 dstDevice: CUdeviceptr,
1405 dstPitch: usize,
1406 ui: ::std::os::raw::c_uint,
1407 Width: usize,
1408 Height: usize,
1409 ) -> CUresult;
1410
1411 pub fn cuMemsetD8Async(
1412 dstDevice: CUdeviceptr,
1413 uc: ::std::os::raw::c_uchar,
1414 N: usize,
1415 hStream: CUstream,
1416 ) -> CUresult;
1417
1418 pub fn cuMemsetD16Async(
1419 dstDevice: CUdeviceptr,
1420 us: ::std::os::raw::c_ushort,
1421 N: usize,
1422 hStream: CUstream,
1423 ) -> CUresult;
1424
1425 pub fn cuMemsetD32Async(
1426 dstDevice: CUdeviceptr,
1427 ui: ::std::os::raw::c_uint,
1428 N: usize,
1429 hStream: CUstream,
1430 ) -> CUresult;
1431
1432 pub fn cuMemsetD2D8Async(
1433 dstDevice: CUdeviceptr,
1434 dstPitch: usize,
1435 uc: ::std::os::raw::c_uchar,
1436 Width: usize,
1437 Height: usize,
1438 hStream: CUstream,
1439 ) -> CUresult;
1440
1441 pub fn cuMemsetD2D16Async(
1442 dstDevice: CUdeviceptr,
1443 dstPitch: usize,
1444 us: ::std::os::raw::c_ushort,
1445 Width: usize,
1446 Height: usize,
1447 hStream: CUstream,
1448 ) -> CUresult;
1449
1450 pub fn cuMemsetD2D32Async(
1451 dstDevice: CUdeviceptr,
1452 dstPitch: usize,
1453 ui: ::std::os::raw::c_uint,
1454 Width: usize,
1455 Height: usize,
1456 hStream: CUstream,
1457 ) -> CUresult;
1458
1459 pub fn cuArrayCreate_v2(pHandle: *mut CUarray, pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR) -> CUresult;
1460
1461 pub fn cuArrayGetDescriptor_v2(pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR, hArray: CUarray) -> CUresult;
1462
1463 pub fn cuArrayDestroy(hArray: CUarray) -> CUresult;
1464
1465 pub fn cuArray3DCreate_v2(pHandle: *mut CUarray, pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR) -> CUresult;
1466
1467 pub fn cuArray3DGetDescriptor_v2(pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR, hArray: CUarray) -> CUresult;
1468
1469 pub fn cuMipmappedArrayCreate(
1470 pHandle: *mut CUmipmappedArray,
1471 pMipmappedArrayDesc: *const CUDA_ARRAY3D_DESCRIPTOR,
1472 numMipmapLevels: ::std::os::raw::c_uint,
1473 ) -> CUresult;
1474
1475 pub fn cuMipmappedArrayGetLevel(
1476 pLevelArray: *mut CUarray,
1477 hMipmappedArray: CUmipmappedArray,
1478 level: ::std::os::raw::c_uint,
1479 ) -> CUresult;
1480
1481 pub fn cuMipmappedArrayDestroy(hMipmappedArray: CUmipmappedArray) -> CUresult;
1482
1483 pub fn cuPointerGetAttribute(
1484 data: *mut ::std::os::raw::c_void,
1485 attribute: CUpointer_attribute,
1486 ptr: CUdeviceptr,
1487 ) -> CUresult;
1488
1489 pub fn cuMemPrefetchAsync(devPtr: CUdeviceptr, count: usize, dstDevice: CUdevice, hStream: CUstream) -> CUresult;
1490
1491 pub fn cuMemAdvise(devPtr: CUdeviceptr, count: usize, advice: CUmem_advise, device: CUdevice) -> CUresult;
1492
1493 pub fn cuMemRangeGetAttribute(
1494 data: *mut ::std::os::raw::c_void,
1495 dataSize: usize,
1496 attribute: CUmem_range_attribute,
1497 devPtr: CUdeviceptr,
1498 count: usize,
1499 ) -> CUresult;
1500
1501 pub fn cuMemRangeGetAttributes(
1502 data: *mut *mut ::std::os::raw::c_void,
1503 dataSizes: *mut usize,
1504 attributes: *mut CUmem_range_attribute,
1505 numAttributes: usize,
1506 devPtr: CUdeviceptr,
1507 count: usize,
1508 ) -> CUresult;
1509
1510 pub fn cuPointerSetAttribute(
1511 value: *const ::std::os::raw::c_void,
1512 attribute: CUpointer_attribute,
1513 ptr: CUdeviceptr,
1514 ) -> CUresult;
1515
1516 pub fn cuPointerGetAttributes(
1517 numAttributes: ::std::os::raw::c_uint,
1518 attributes: *mut CUpointer_attribute,
1519 data: *mut *mut ::std::os::raw::c_void,
1520 ptr: CUdeviceptr,
1521 ) -> CUresult;
1522
1523 pub fn cuStreamCreate(phStream: *mut CUstream, Flags: ::std::os::raw::c_uint) -> CUresult;
1524
1525 pub fn cuStreamCreateWithPriority(
1526 phStream: *mut CUstream,
1527 flags: ::std::os::raw::c_uint,
1528 priority: ::std::os::raw::c_int,
1529 ) -> CUresult;
1530
1531 pub fn cuStreamGetPriority(hStream: CUstream, priority: *mut ::std::os::raw::c_int) -> CUresult;
1532
1533 pub fn cuStreamGetFlags(hStream: CUstream, flags: *mut ::std::os::raw::c_uint) -> CUresult;
1534
1535 pub fn cuStreamWaitEvent(hStream: CUstream, hEvent: CUevent, Flags: ::std::os::raw::c_uint) -> CUresult;
1536
1537 pub fn cuStreamAddCallback(
1538 hStream: CUstream,
1539 callback: CUstreamCallback,
1540 userData: *mut ::std::os::raw::c_void,
1541 flags: ::std::os::raw::c_uint,
1542 ) -> CUresult;
1543
1544 pub fn cuStreamAttachMemAsync(
1545 hStream: CUstream,
1546 dptr: CUdeviceptr,
1547 length: usize,
1548 flags: ::std::os::raw::c_uint,
1549 ) -> CUresult;
1550
1551 pub fn cuStreamQuery(hStream: CUstream) -> CUresult;
1552
1553 pub fn cuStreamSynchronize(hStream: CUstream) -> CUresult;
1554
1555 pub fn cuStreamDestroy_v2(hStream: CUstream) -> CUresult;
1556
1557 pub fn cuEventCreate(phEvent: *mut CUevent, Flags: ::std::os::raw::c_uint) -> CUresult;
1558
1559 pub fn cuEventRecord(hEvent: CUevent, hStream: CUstream) -> CUresult;
1560
1561 pub fn cuEventQuery(hEvent: CUevent) -> CUresult;
1562
1563 pub fn cuEventSynchronize(hEvent: CUevent) -> CUresult;
1564
1565 pub fn cuEventDestroy_v2(hEvent: CUevent) -> CUresult;
1566
1567 pub fn cuEventElapsedTime(pMilliseconds: *mut f32, hStart: CUevent, hEnd: CUevent) -> CUresult;
1568
1569 pub fn cuStreamWaitValue32(
1570 stream: CUstream,
1571 addr: CUdeviceptr,
1572 value: u32,
1573 flags: ::std::os::raw::c_uint,
1574 ) -> CUresult;
1575
1576 pub fn cuStreamWriteValue32(
1577 stream: CUstream,
1578 addr: CUdeviceptr,
1579 value: u32,
1580 flags: ::std::os::raw::c_uint,
1581 ) -> CUresult;
1582
1583 pub fn cuStreamBatchMemOp(
1584 stream: CUstream,
1585 count: ::std::os::raw::c_uint,
1586 paramArray: *mut CUstreamBatchMemOpParams,
1587 flags: ::std::os::raw::c_uint,
1588 ) -> CUresult;
1589
1590 pub fn cuFuncGetAttribute(
1591 pi: *mut ::std::os::raw::c_int,
1592 attrib: CUfunction_attribute,
1593 hfunc: CUfunction,
1594 ) -> CUresult;
1595
1596 pub fn cuFuncSetCacheConfig(hfunc: CUfunction, config: CUfunc_cache) -> CUresult;
1597
1598 pub fn cuFuncSetSharedMemConfig(hfunc: CUfunction, config: CUsharedconfig) -> CUresult;
1599
1600 pub fn cuLaunchKernel(
1601 f: CUfunction,
1602 gridDimX: ::std::os::raw::c_uint,
1603 gridDimY: ::std::os::raw::c_uint,
1604 gridDimZ: ::std::os::raw::c_uint,
1605 blockDimX: ::std::os::raw::c_uint,
1606 blockDimY: ::std::os::raw::c_uint,
1607 blockDimZ: ::std::os::raw::c_uint,
1608 sharedMemBytes: ::std::os::raw::c_uint,
1609 hStream: CUstream,
1610 kernelParams: *mut *mut ::std::os::raw::c_void,
1611 extra: *mut *mut ::std::os::raw::c_void,
1612 ) -> CUresult;
1613
1614 pub fn cuFuncSetBlockShape(
1615 hfunc: CUfunction,
1616 x: ::std::os::raw::c_int,
1617 y: ::std::os::raw::c_int,
1618 z: ::std::os::raw::c_int,
1619 ) -> CUresult;
1620
1621 pub fn cuFuncSetSharedSize(hfunc: CUfunction, bytes: ::std::os::raw::c_uint) -> CUresult;
1622
1623 pub fn cuParamSetSize(hfunc: CUfunction, numbytes: ::std::os::raw::c_uint) -> CUresult;
1624
1625 pub fn cuParamSeti(hfunc: CUfunction, offset: ::std::os::raw::c_int, value: ::std::os::raw::c_uint) -> CUresult;
1626
1627 pub fn cuParamSetf(hfunc: CUfunction, offset: ::std::os::raw::c_int, value: f32) -> CUresult;
1628
1629 pub fn cuParamSetv(
1630 hfunc: CUfunction,
1631 offset: ::std::os::raw::c_int,
1632 ptr: *mut ::std::os::raw::c_void,
1633 numbytes: ::std::os::raw::c_uint,
1634 ) -> CUresult;
1635
1636 pub fn cuLaunch(f: CUfunction) -> CUresult;
1637
1638 pub fn cuLaunchGrid(
1639 f: CUfunction,
1640 grid_width: ::std::os::raw::c_int,
1641 grid_height: ::std::os::raw::c_int,
1642 ) -> CUresult;
1643
1644 pub fn cuLaunchGridAsync(
1645 f: CUfunction,
1646 grid_width: ::std::os::raw::c_int,
1647 grid_height: ::std::os::raw::c_int,
1648 hStream: CUstream,
1649 ) -> CUresult;
1650
1651 pub fn cuParamSetTexRef(hfunc: CUfunction, texunit: ::std::os::raw::c_int, hTexRef: CUtexref) -> CUresult;
1652
1653 pub fn cuOccupancyMaxActiveBlocksPerMultiprocessor(
1654 numBlocks: *mut ::std::os::raw::c_int,
1655 func: CUfunction,
1656 blockSize: ::std::os::raw::c_int,
1657 dynamicSMemSize: usize,
1658 ) -> CUresult;
1659
1660 pub fn cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
1661 numBlocks: *mut ::std::os::raw::c_int,
1662 func: CUfunction,
1663 blockSize: ::std::os::raw::c_int,
1664 dynamicSMemSize: usize,
1665 flags: ::std::os::raw::c_uint,
1666 ) -> CUresult;
1667
1668 pub fn cuOccupancyMaxPotentialBlockSize(
1669 minGridSize: *mut ::std::os::raw::c_int,
1670 blockSize: *mut ::std::os::raw::c_int,
1671 func: CUfunction,
1672 blockSizeToDynamicSMemSize: CUoccupancyB2DSize,
1673 dynamicSMemSize: usize,
1674 blockSizeLimit: ::std::os::raw::c_int,
1675 ) -> CUresult;
1676
1677 pub fn cuOccupancyMaxPotentialBlockSizeWithFlags(
1678 minGridSize: *mut ::std::os::raw::c_int,
1679 blockSize: *mut ::std::os::raw::c_int,
1680 func: CUfunction,
1681 blockSizeToDynamicSMemSize: CUoccupancyB2DSize,
1682 dynamicSMemSize: usize,
1683 blockSizeLimit: ::std::os::raw::c_int,
1684 flags: ::std::os::raw::c_uint,
1685 ) -> CUresult;
1686
1687 pub fn cuTexRefSetArray(hTexRef: CUtexref, hArray: CUarray, Flags: ::std::os::raw::c_uint) -> CUresult;
1688
1689 pub fn cuTexRefSetMipmappedArray(
1690 hTexRef: CUtexref,
1691 hMipmappedArray: CUmipmappedArray,
1692 Flags: ::std::os::raw::c_uint,
1693 ) -> CUresult;
1694
1695 pub fn cuTexRefSetAddress_v2(
1696 ByteOffset: *mut usize,
1697 hTexRef: CUtexref,
1698 dptr: CUdeviceptr,
1699 bytes: usize,
1700 ) -> CUresult;
1701
1702 pub fn cuTexRefSetAddress2D_v3(
1703 hTexRef: CUtexref,
1704 desc: *const CUDA_ARRAY_DESCRIPTOR,
1705 dptr: CUdeviceptr,
1706 Pitch: usize,
1707 ) -> CUresult;
1708
1709 pub fn cuTexRefSetFormat(
1710 hTexRef: CUtexref,
1711 fmt: CUarray_format,
1712 NumPackedComponents: ::std::os::raw::c_int,
1713 ) -> CUresult;
1714
1715 pub fn cuTexRefSetAddressMode(hTexRef: CUtexref, dim: ::std::os::raw::c_int, am: CUaddress_mode) -> CUresult;
1716
1717 pub fn cuTexRefSetFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
1718
1719 pub fn cuTexRefSetMipmapFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
1720
1721 pub fn cuTexRefSetMipmapLevelBias(hTexRef: CUtexref, bias: f32) -> CUresult;
1722
1723 pub fn cuTexRefSetMipmapLevelClamp(
1724 hTexRef: CUtexref,
1725 minMipmapLevelClamp: f32,
1726 maxMipmapLevelClamp: f32,
1727 ) -> CUresult;
1728
1729 pub fn cuTexRefSetMaxAnisotropy(hTexRef: CUtexref, maxAniso: ::std::os::raw::c_uint) -> CUresult;
1730
1731 pub fn cuTexRefSetBorderColor(hTexRef: CUtexref, pBorderColor: *mut f32) -> CUresult;
1732
1733 pub fn cuTexRefSetFlags(hTexRef: CUtexref, Flags: ::std::os::raw::c_uint) -> CUresult;
1734
1735 pub fn cuTexRefGetAddress_v2(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult;
1736
1737 pub fn cuTexRefGetArray(phArray: *mut CUarray, hTexRef: CUtexref) -> CUresult;
1738
1739 pub fn cuTexRefGetMipmappedArray(phMipmappedArray: *mut CUmipmappedArray, hTexRef: CUtexref) -> CUresult;
1740
1741 pub fn cuTexRefGetAddressMode(pam: *mut CUaddress_mode, hTexRef: CUtexref, dim: ::std::os::raw::c_int) -> CUresult;
1742
1743 pub fn cuTexRefGetFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
1744
1745 pub fn cuTexRefGetFormat(
1746 pFormat: *mut CUarray_format,
1747 pNumChannels: *mut ::std::os::raw::c_int,
1748 hTexRef: CUtexref,
1749 ) -> CUresult;
1750
1751 pub fn cuTexRefGetMipmapFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
1752
1753 pub fn cuTexRefGetMipmapLevelBias(pbias: *mut f32, hTexRef: CUtexref) -> CUresult;
1754
1755 pub fn cuTexRefGetMipmapLevelClamp(
1756 pminMipmapLevelClamp: *mut f32,
1757 pmaxMipmapLevelClamp: *mut f32,
1758 hTexRef: CUtexref,
1759 ) -> CUresult;
1760
1761 pub fn cuTexRefGetMaxAnisotropy(pmaxAniso: *mut ::std::os::raw::c_int, hTexRef: CUtexref) -> CUresult;
1762
1763 pub fn cuTexRefGetBorderColor(pBorderColor: *mut f32, hTexRef: CUtexref) -> CUresult;
1764
1765 pub fn cuTexRefGetFlags(pFlags: *mut ::std::os::raw::c_uint, hTexRef: CUtexref) -> CUresult;
1766
1767 pub fn cuTexRefCreate(pTexRef: *mut CUtexref) -> CUresult;
1768
1769 pub fn cuTexRefDestroy(hTexRef: CUtexref) -> CUresult;
1770
1771 pub fn cuSurfRefSetArray(hSurfRef: CUsurfref, hArray: CUarray, Flags: ::std::os::raw::c_uint) -> CUresult;
1772
1773 pub fn cuSurfRefGetArray(phArray: *mut CUarray, hSurfRef: CUsurfref) -> CUresult;
1774
1775 pub fn cuTexObjectCreate(
1776 pTexObject: *mut CUtexObject,
1777 pResDesc: *const CUDA_RESOURCE_DESC,
1778 pTexDesc: *const CUDA_TEXTURE_DESC,
1779 pResViewDesc: *const CUDA_RESOURCE_VIEW_DESC,
1780 ) -> CUresult;
1781
1782 pub fn cuTexObjectDestroy(texObject: CUtexObject) -> CUresult;
1783
1784 pub fn cuTexObjectGetResourceDesc(pResDesc: *mut CUDA_RESOURCE_DESC, texObject: CUtexObject) -> CUresult;
1785
1786 pub fn cuTexObjectGetTextureDesc(pTexDesc: *mut CUDA_TEXTURE_DESC, texObject: CUtexObject) -> CUresult;
1787
1788 pub fn cuTexObjectGetResourceViewDesc(
1789 pResViewDesc: *mut CUDA_RESOURCE_VIEW_DESC,
1790 texObject: CUtexObject,
1791 ) -> CUresult;
1792
1793 pub fn cuSurfObjectCreate(pSurfObject: *mut CUsurfObject, pResDesc: *const CUDA_RESOURCE_DESC) -> CUresult;
1794
1795 pub fn cuSurfObjectDestroy(surfObject: CUsurfObject) -> CUresult;
1796
1797 pub fn cuSurfObjectGetResourceDesc(pResDesc: *mut CUDA_RESOURCE_DESC, surfObject: CUsurfObject) -> CUresult;
1798
1799 pub fn cuDeviceCanAccessPeer(
1800 canAccessPeer: *mut ::std::os::raw::c_int,
1801 dev: CUdevice,
1802 peerDev: CUdevice,
1803 ) -> CUresult;
1804
1805 pub fn cuDeviceGetP2PAttribute(
1806 value: *mut ::std::os::raw::c_int,
1807 attrib: CUdevice_P2PAttribute,
1808 srcDevice: CUdevice,
1809 dstDevice: CUdevice,
1810 ) -> CUresult;
1811
1812 pub fn cuCtxEnablePeerAccess(peerContext: CUcontext, Flags: ::std::os::raw::c_uint) -> CUresult;
1813
1814 pub fn cuCtxDisablePeerAccess(peerContext: CUcontext) -> CUresult;
1815
1816 pub fn cuGraphicsUnregisterResource(resource: CUgraphicsResource) -> CUresult;
1817
1818 pub fn cuGraphicsSubResourceGetMappedArray(
1819 pArray: *mut CUarray,
1820 resource: CUgraphicsResource,
1821 arrayIndex: ::std::os::raw::c_uint,
1822 mipLevel: ::std::os::raw::c_uint,
1823 ) -> CUresult;
1824
1825 pub fn cuGraphicsResourceGetMappedMipmappedArray(
1826 pMipmappedArray: *mut CUmipmappedArray,
1827 resource: CUgraphicsResource,
1828 ) -> CUresult;
1829
1830 pub fn cuGraphicsResourceGetMappedPointer_v2(
1831 pDevPtr: *mut CUdeviceptr,
1832 pSize: *mut usize,
1833 resource: CUgraphicsResource,
1834 ) -> CUresult;
1835
1836 pub fn cuGraphicsResourceSetMapFlags_v2(resource: CUgraphicsResource, flags: ::std::os::raw::c_uint) -> CUresult;
1837
1838 pub fn cuGraphicsMapResources(
1839 count: ::std::os::raw::c_uint,
1840 resources: *mut CUgraphicsResource,
1841 hStream: CUstream,
1842 ) -> CUresult;
1843
1844 pub fn cuGraphicsUnmapResources(
1845 count: ::std::os::raw::c_uint,
1846 resources: *mut CUgraphicsResource,
1847 hStream: CUstream,
1848 ) -> CUresult;
1849
1850 pub fn cuGetExportTable(
1851 ppExportTable: *mut *const ::std::os::raw::c_void,
1852 pExportTableId: *const CUuuid,
1853 ) -> CUresult;
1854}