1pub const CUDA_VERSION: u32 = 10020;
4pub const CU_IPC_HANDLE_SIZE: u32 = 64;
5pub const CU_MEMHOSTALLOC_PORTABLE: u32 = 1;
6pub const CU_MEMHOSTALLOC_DEVICEMAP: u32 = 2;
7pub const CU_MEMHOSTALLOC_WRITECOMBINED: u32 = 4;
8pub const CU_MEMHOSTREGISTER_PORTABLE: u32 = 1;
9pub const CU_MEMHOSTREGISTER_DEVICEMAP: u32 = 2;
10pub const CU_MEMHOSTREGISTER_IOMEMORY: u32 = 4;
11pub const CUDA_EXTERNAL_MEMORY_DEDICATED: u32 = 1;
12pub const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC: u32 = 1;
13pub const CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC: u32 = 2;
14pub const CUDA_NVSCISYNC_ATTR_SIGNAL: u32 = 1;
15pub const CUDA_NVSCISYNC_ATTR_WAIT: u32 = 2;
16pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC: u32 = 1;
17pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC: u32 = 2;
18pub const CUDA_ARRAY3D_LAYERED: u32 = 1;
19pub const CUDA_ARRAY3D_2DARRAY: u32 = 1;
20pub const CUDA_ARRAY3D_SURFACE_LDST: u32 = 2;
21pub const CUDA_ARRAY3D_CUBEMAP: u32 = 4;
22pub const CUDA_ARRAY3D_TEXTURE_GATHER: u32 = 8;
23pub const CUDA_ARRAY3D_DEPTH_TEXTURE: u32 = 16;
24pub const CUDA_ARRAY3D_COLOR_ATTACHMENT: u32 = 32;
25pub const CU_TRSA_OVERRIDE_FORMAT: u32 = 1;
26pub const CU_TRSF_READ_AS_INTEGER: u32 = 1;
27pub const CU_TRSF_NORMALIZED_COORDINATES: u32 = 2;
28pub const CU_TRSF_SRGB: u32 = 16;
29pub const CU_PARAM_TR_DEFAULT: i32 = -1;
30pub type __uint32_t = ::std::os::raw::c_uint;
31pub type __uint64_t = ::std::os::raw::c_ulong;
32#[repr(C)]
33#[repr(align(8))]
34#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
35pub struct float2 {
36 pub x: f32,
37 pub y: f32,
38}
39#[test]
40fn bindgen_test_layout_float2() {
41 assert_eq!(
42 ::std::mem::size_of::<float2>(),
43 8usize,
44 concat!("Size of: ", stringify!(float2))
45 );
46 assert_eq!(
47 ::std::mem::align_of::<float2>(),
48 8usize,
49 concat!("Alignment of ", stringify!(float2))
50 );
51 assert_eq!(
52 unsafe { &(*(::std::ptr::null::<float2>())).x as *const _ as usize },
53 0usize,
54 concat!("Offset of field: ", stringify!(float2), "::", stringify!(x))
55 );
56 assert_eq!(
57 unsafe { &(*(::std::ptr::null::<float2>())).y as *const _ as usize },
58 4usize,
59 concat!("Offset of field: ", stringify!(float2), "::", stringify!(y))
60 );
61}
62#[repr(C)]
63#[repr(align(16))]
64#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
65pub struct double2 {
66 pub x: f64,
67 pub y: f64,
68}
69#[test]
70fn bindgen_test_layout_double2() {
71 assert_eq!(
72 ::std::mem::size_of::<double2>(),
73 16usize,
74 concat!("Size of: ", stringify!(double2))
75 );
76 assert_eq!(
77 ::std::mem::align_of::<double2>(),
78 16usize,
79 concat!("Alignment of ", stringify!(double2))
80 );
81 assert_eq!(
82 unsafe { &(*(::std::ptr::null::<double2>())).x as *const _ as usize },
83 0usize,
84 concat!(
85 "Offset of field: ",
86 stringify!(double2),
87 "::",
88 stringify!(x)
89 )
90 );
91 assert_eq!(
92 unsafe { &(*(::std::ptr::null::<double2>())).y as *const _ as usize },
93 8usize,
94 concat!(
95 "Offset of field: ",
96 stringify!(double2),
97 "::",
98 stringify!(y)
99 )
100 );
101}
102pub type cuFloatComplex = float2;
103pub type cuDoubleComplex = double2;
104pub type cuComplex = cuFloatComplex;
105pub type cuuint32_t = u32;
106pub type cuuint64_t = u64;
107pub type CUdeviceptr = ::std::os::raw::c_ulonglong;
108pub type CUdevice = ::std::os::raw::c_int;
109#[repr(C)]
110#[derive(Debug, Copy, Clone)]
111pub struct CUctx_st {
112 _unused: [u8; 0],
113}
114pub type CUcontext = *mut CUctx_st;
115#[repr(C)]
116#[derive(Debug, Copy, Clone)]
117pub struct CUmod_st {
118 _unused: [u8; 0],
119}
120pub type CUmodule = *mut CUmod_st;
121#[repr(C)]
122#[derive(Debug, Copy, Clone)]
123pub struct CUfunc_st {
124 _unused: [u8; 0],
125}
126pub type CUfunction = *mut CUfunc_st;
127#[repr(C)]
128#[derive(Debug, Copy, Clone)]
129pub struct CUarray_st {
130 _unused: [u8; 0],
131}
132pub type CUarray = *mut CUarray_st;
133#[repr(C)]
134#[derive(Debug, Copy, Clone)]
135pub struct CUmipmappedArray_st {
136 _unused: [u8; 0],
137}
138pub type CUmipmappedArray = *mut CUmipmappedArray_st;
139#[repr(C)]
140#[derive(Debug, Copy, Clone)]
141pub struct CUtexref_st {
142 _unused: [u8; 0],
143}
144pub type CUtexref = *mut CUtexref_st;
145#[repr(C)]
146#[derive(Debug, Copy, Clone)]
147pub struct CUsurfref_st {
148 _unused: [u8; 0],
149}
150pub type CUsurfref = *mut CUsurfref_st;
151#[repr(C)]
152#[derive(Debug, Copy, Clone)]
153pub struct CUevent_st {
154 _unused: [u8; 0],
155}
156pub type CUevent = *mut CUevent_st;
157#[repr(C)]
158#[derive(Debug, Copy, Clone)]
159pub struct CUstream_st {
160 _unused: [u8; 0],
161}
162pub type CUstream = *mut CUstream_st;
163#[repr(C)]
164#[derive(Debug, Copy, Clone)]
165pub struct CUgraphicsResource_st {
166 _unused: [u8; 0],
167}
168pub type CUgraphicsResource = *mut CUgraphicsResource_st;
169pub type CUtexObject = ::std::os::raw::c_ulonglong;
170pub type CUsurfObject = ::std::os::raw::c_ulonglong;
171#[repr(C)]
172#[derive(Debug, Copy, Clone)]
173pub struct CUextMemory_st {
174 _unused: [u8; 0],
175}
176pub type CUexternalMemory = *mut CUextMemory_st;
177#[repr(C)]
178#[derive(Debug, Copy, Clone)]
179pub struct CUextSemaphore_st {
180 _unused: [u8; 0],
181}
182pub type CUexternalSemaphore = *mut CUextSemaphore_st;
183#[repr(C)]
184#[derive(Debug, Copy, Clone)]
185pub struct CUgraph_st {
186 _unused: [u8; 0],
187}
188pub type CUgraph = *mut CUgraph_st;
189#[repr(C)]
190#[derive(Debug, Copy, Clone)]
191pub struct CUgraphNode_st {
192 _unused: [u8; 0],
193}
194pub type CUgraphNode = *mut CUgraphNode_st;
195#[repr(C)]
196#[derive(Debug, Copy, Clone)]
197pub struct CUgraphExec_st {
198 _unused: [u8; 0],
199}
200pub type CUgraphExec = *mut CUgraphExec_st;
201#[repr(C)]
202#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
203pub struct CUuuid_st {
204 pub bytes: [::std::os::raw::c_char; 16usize],
205}
206#[test]
207fn bindgen_test_layout_CUuuid_st() {
208 assert_eq!(
209 ::std::mem::size_of::<CUuuid_st>(),
210 16usize,
211 concat!("Size of: ", stringify!(CUuuid_st))
212 );
213 assert_eq!(
214 ::std::mem::align_of::<CUuuid_st>(),
215 1usize,
216 concat!("Alignment of ", stringify!(CUuuid_st))
217 );
218 assert_eq!(
219 unsafe { &(*(::std::ptr::null::<CUuuid_st>())).bytes as *const _ as usize },
220 0usize,
221 concat!(
222 "Offset of field: ",
223 stringify!(CUuuid_st),
224 "::",
225 stringify!(bytes)
226 )
227 );
228}
229pub type CUuuid = CUuuid_st;
230#[repr(C)]
231#[derive(Copy, Clone)]
232pub struct CUipcEventHandle_st {
233 pub reserved: [::std::os::raw::c_char; 64usize],
234}
235#[test]
236fn bindgen_test_layout_CUipcEventHandle_st() {
237 assert_eq!(
238 ::std::mem::size_of::<CUipcEventHandle_st>(),
239 64usize,
240 concat!("Size of: ", stringify!(CUipcEventHandle_st))
241 );
242 assert_eq!(
243 ::std::mem::align_of::<CUipcEventHandle_st>(),
244 1usize,
245 concat!("Alignment of ", stringify!(CUipcEventHandle_st))
246 );
247 assert_eq!(
248 unsafe { &(*(::std::ptr::null::<CUipcEventHandle_st>())).reserved as *const _ as usize },
249 0usize,
250 concat!(
251 "Offset of field: ",
252 stringify!(CUipcEventHandle_st),
253 "::",
254 stringify!(reserved)
255 )
256 );
257}
258impl Default for CUipcEventHandle_st {
259 fn default() -> Self {
260 unsafe { ::std::mem::zeroed() }
261 }
262}
263pub type CUipcEventHandle = CUipcEventHandle_st;
264#[repr(C)]
265#[derive(Copy, Clone)]
266pub struct CUipcMemHandle_st {
267 pub reserved: [::std::os::raw::c_char; 64usize],
268}
269#[test]
270fn bindgen_test_layout_CUipcMemHandle_st() {
271 assert_eq!(
272 ::std::mem::size_of::<CUipcMemHandle_st>(),
273 64usize,
274 concat!("Size of: ", stringify!(CUipcMemHandle_st))
275 );
276 assert_eq!(
277 ::std::mem::align_of::<CUipcMemHandle_st>(),
278 1usize,
279 concat!("Alignment of ", stringify!(CUipcMemHandle_st))
280 );
281 assert_eq!(
282 unsafe { &(*(::std::ptr::null::<CUipcMemHandle_st>())).reserved as *const _ as usize },
283 0usize,
284 concat!(
285 "Offset of field: ",
286 stringify!(CUipcMemHandle_st),
287 "::",
288 stringify!(reserved)
289 )
290 );
291}
292impl Default for CUipcMemHandle_st {
293 fn default() -> Self {
294 unsafe { ::std::mem::zeroed() }
295 }
296}
297pub type CUipcMemHandle = CUipcMemHandle_st;
298#[repr(u32)]
299#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
300pub enum CUipcMem_flags_enum {
301 CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = 1,
302}
303pub use self::CUipcMem_flags_enum as CUipcMem_flags;
304#[repr(u32)]
305#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
306pub enum CUmemAttach_flags_enum {
307 CU_MEM_ATTACH_GLOBAL = 1,
308 CU_MEM_ATTACH_HOST = 2,
309 CU_MEM_ATTACH_SINGLE = 4,
310}
311pub use self::CUmemAttach_flags_enum as CUmemAttach_flags;
312impl CUctx_flags_enum {
313 pub const CU_CTX_BLOCKING_SYNC: CUctx_flags_enum = CUctx_flags_enum::CU_CTX_SCHED_BLOCKING_SYNC;
314}
315#[repr(u32)]
316#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
317pub enum CUctx_flags_enum {
318 CU_CTX_SCHED_AUTO = 0,
319 CU_CTX_SCHED_SPIN = 1,
320 CU_CTX_SCHED_YIELD = 2,
321 CU_CTX_SCHED_BLOCKING_SYNC = 4,
322 CU_CTX_SCHED_MASK = 7,
323 CU_CTX_MAP_HOST = 8,
324 CU_CTX_LMEM_RESIZE_TO_MAX = 16,
325 CU_CTX_FLAGS_MASK = 31,
326}
327pub use self::CUctx_flags_enum as CUctx_flags;
328#[repr(u32)]
329#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
330pub enum CUstream_flags_enum {
331 CU_STREAM_DEFAULT = 0,
332 CU_STREAM_NON_BLOCKING = 1,
333}
334pub use self::CUstream_flags_enum as CUstream_flags;
335#[repr(u32)]
336#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
337pub enum CUevent_flags_enum {
338 CU_EVENT_DEFAULT = 0,
339 CU_EVENT_BLOCKING_SYNC = 1,
340 CU_EVENT_DISABLE_TIMING = 2,
341 CU_EVENT_INTERPROCESS = 4,
342}
343pub use self::CUevent_flags_enum as CUevent_flags;
344#[repr(u32)]
345#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
346pub enum CUstreamWaitValue_flags_enum {
347 CU_STREAM_WAIT_VALUE_GEQ = 0,
348 CU_STREAM_WAIT_VALUE_EQ = 1,
349 CU_STREAM_WAIT_VALUE_AND = 2,
350 CU_STREAM_WAIT_VALUE_NOR = 3,
351 CU_STREAM_WAIT_VALUE_FLUSH = 1073741824,
352}
353pub use self::CUstreamWaitValue_flags_enum as CUstreamWaitValue_flags;
354#[repr(u32)]
355#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
356pub enum CUstreamWriteValue_flags_enum {
357 CU_STREAM_WRITE_VALUE_DEFAULT = 0,
358 CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = 1,
359}
360pub use self::CUstreamWriteValue_flags_enum as CUstreamWriteValue_flags;
361#[repr(u32)]
362#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
363pub enum CUstreamBatchMemOpType_enum {
364 CU_STREAM_MEM_OP_WAIT_VALUE_32 = 1,
365 CU_STREAM_MEM_OP_WRITE_VALUE_32 = 2,
366 CU_STREAM_MEM_OP_WAIT_VALUE_64 = 4,
367 CU_STREAM_MEM_OP_WRITE_VALUE_64 = 5,
368 CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = 3,
369}
370pub use self::CUstreamBatchMemOpType_enum as CUstreamBatchMemOpType;
371#[repr(C)]
372#[derive(Copy, Clone)]
373pub union CUstreamBatchMemOpParams_union {
374 pub operation: CUstreamBatchMemOpType,
375 pub waitValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
376 pub writeValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
377 pub flushRemoteWrites: CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
378 pub pad: [cuuint64_t; 6usize],
379 _bindgen_union_align: [u64; 6usize],
380}
381#[repr(C)]
382#[derive(Copy, Clone)]
383pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st {
384 pub operation: CUstreamBatchMemOpType,
385 pub address: CUdeviceptr,
386 pub __bindgen_anon_1:
387 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
388 pub flags: ::std::os::raw::c_uint,
389 pub alias: CUdeviceptr,
390}
391#[repr(C)]
392#[derive(Copy, Clone)]
393pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 {
394 pub value: cuuint32_t,
395 pub value64: cuuint64_t,
396 _bindgen_union_align: u64,
397}
398#[test]
399fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1(
400) {
401 assert_eq!(
402 ::std::mem::size_of::<
403 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
404 >(),
405 8usize,
406 concat!(
407 "Size of: ",
408 stringify!(
409 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
410 )
411 )
412 );
413 assert_eq!(
414 ::std::mem::align_of::<
415 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
416 >(),
417 8usize,
418 concat!(
419 "Alignment of ",
420 stringify!(
421 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
422 )
423 )
424 );
425 assert_eq!(
426 unsafe {
427 &(*(::std::ptr::null::<
428 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
429 >()))
430 .value as *const _ as usize
431 },
432 0usize,
433 concat!(
434 "Offset of field: ",
435 stringify!(
436 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
437 ),
438 "::",
439 stringify!(value)
440 )
441 );
442 assert_eq!(
443 unsafe {
444 &(*(::std::ptr::null::<
445 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
446 >()))
447 .value64 as *const _ as usize
448 },
449 0usize,
450 concat!(
451 "Offset of field: ",
452 stringify!(
453 CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
454 ),
455 "::",
456 stringify!(value64)
457 )
458 );
459}
460impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 {
461 fn default() -> Self {
462 unsafe { ::std::mem::zeroed() }
463 }
464}
465#[test]
466fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st() {
467 assert_eq!(
468 ::std::mem::size_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(),
469 40usize,
470 concat!(
471 "Size of: ",
472 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st)
473 )
474 );
475 assert_eq!(
476 ::std::mem::align_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(),
477 8usize,
478 concat!(
479 "Alignment of ",
480 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st)
481 )
482 );
483 assert_eq!(
484 unsafe {
485 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(
486 )))
487 .operation as *const _ as usize
488 },
489 0usize,
490 concat!(
491 "Offset of field: ",
492 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
493 "::",
494 stringify!(operation)
495 )
496 );
497 assert_eq!(
498 unsafe {
499 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(
500 )))
501 .address as *const _ as usize
502 },
503 8usize,
504 concat!(
505 "Offset of field: ",
506 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
507 "::",
508 stringify!(address)
509 )
510 );
511 assert_eq!(
512 unsafe {
513 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(
514 )))
515 .flags as *const _ as usize
516 },
517 24usize,
518 concat!(
519 "Offset of field: ",
520 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
521 "::",
522 stringify!(flags)
523 )
524 );
525 assert_eq!(
526 unsafe {
527 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(
528 )))
529 .alias as *const _ as usize
530 },
531 32usize,
532 concat!(
533 "Offset of field: ",
534 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
535 "::",
536 stringify!(alias)
537 )
538 );
539}
540impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st {
541 fn default() -> Self {
542 unsafe { ::std::mem::zeroed() }
543 }
544}
545#[repr(C)]
546#[derive(Copy, Clone)]
547pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st {
548 pub operation: CUstreamBatchMemOpType,
549 pub address: CUdeviceptr,
550 pub __bindgen_anon_1:
551 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
552 pub flags: ::std::os::raw::c_uint,
553 pub alias: CUdeviceptr,
554}
555#[repr(C)]
556#[derive(Copy, Clone)]
557pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 {
558 pub value: cuuint32_t,
559 pub value64: cuuint64_t,
560 _bindgen_union_align: u64,
561}
562#[test]
563fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1(
564) {
565 assert_eq!(
566 ::std::mem::size_of::<
567 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
568 >(),
569 8usize,
570 concat!(
571 "Size of: ",
572 stringify!(
573 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
574 )
575 )
576 );
577 assert_eq!(
578 ::std::mem::align_of::<
579 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
580 >(),
581 8usize,
582 concat!(
583 "Alignment of ",
584 stringify!(
585 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
586 )
587 )
588 );
589 assert_eq!(
590 unsafe {
591 &(*(::std::ptr::null::<
592 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
593 >()))
594 .value as *const _ as usize
595 },
596 0usize,
597 concat!(
598 "Offset of field: ",
599 stringify!(
600 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
601 ),
602 "::",
603 stringify!(value)
604 )
605 );
606 assert_eq!(
607 unsafe {
608 &(*(::std::ptr::null::<
609 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
610 >()))
611 .value64 as *const _ as usize
612 },
613 0usize,
614 concat!(
615 "Offset of field: ",
616 stringify!(
617 CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
618 ),
619 "::",
620 stringify!(value64)
621 )
622 );
623}
624impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 {
625 fn default() -> Self {
626 unsafe { ::std::mem::zeroed() }
627 }
628}
629#[test]
630fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st() {
631 assert_eq!(
632 ::std::mem::size_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(),
633 40usize,
634 concat!(
635 "Size of: ",
636 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st)
637 )
638 );
639 assert_eq!(
640 ::std::mem::align_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(),
641 8usize,
642 concat!(
643 "Alignment of ",
644 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st)
645 )
646 );
647 assert_eq!(
648 unsafe {
649 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(
650 )))
651 .operation as *const _ as usize
652 },
653 0usize,
654 concat!(
655 "Offset of field: ",
656 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
657 "::",
658 stringify!(operation)
659 )
660 );
661 assert_eq!(
662 unsafe {
663 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(
664 )))
665 .address as *const _ as usize
666 },
667 8usize,
668 concat!(
669 "Offset of field: ",
670 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
671 "::",
672 stringify!(address)
673 )
674 );
675 assert_eq!(
676 unsafe {
677 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(
678 )))
679 .flags as *const _ as usize
680 },
681 24usize,
682 concat!(
683 "Offset of field: ",
684 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
685 "::",
686 stringify!(flags)
687 )
688 );
689 assert_eq!(
690 unsafe {
691 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(
692 )))
693 .alias as *const _ as usize
694 },
695 32usize,
696 concat!(
697 "Offset of field: ",
698 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
699 "::",
700 stringify!(alias)
701 )
702 );
703}
704impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st {
705 fn default() -> Self {
706 unsafe { ::std::mem::zeroed() }
707 }
708}
709#[repr(C)]
710#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
711pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st {
712 pub operation: CUstreamBatchMemOpType,
713 pub flags: ::std::os::raw::c_uint,
714}
715#[test]
716fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st() {
717 assert_eq!(
718 ::std::mem::size_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st>(
719 ),
720 8usize,
721 concat!(
722 "Size of: ",
723 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st)
724 )
725 );
726 assert_eq!(
727 ::std::mem::align_of::<
728 CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
729 >(),
730 4usize,
731 concat!(
732 "Alignment of ",
733 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st)
734 )
735 );
736 assert_eq!(
737 unsafe {
738 &(*(::std::ptr::null::<
739 CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
740 >()))
741 .operation as *const _ as usize
742 },
743 0usize,
744 concat!(
745 "Offset of field: ",
746 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st),
747 "::",
748 stringify!(operation)
749 )
750 );
751 assert_eq!(
752 unsafe {
753 &(*(::std::ptr::null::<
754 CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
755 >()))
756 .flags as *const _ as usize
757 },
758 4usize,
759 concat!(
760 "Offset of field: ",
761 stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st),
762 "::",
763 stringify!(flags)
764 )
765 );
766}
767impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st {
768 fn default() -> Self {
769 unsafe { ::std::mem::zeroed() }
770 }
771}
772#[test]
773fn bindgen_test_layout_CUstreamBatchMemOpParams_union() {
774 assert_eq!(
775 ::std::mem::size_of::<CUstreamBatchMemOpParams_union>(),
776 48usize,
777 concat!("Size of: ", stringify!(CUstreamBatchMemOpParams_union))
778 );
779 assert_eq!(
780 ::std::mem::align_of::<CUstreamBatchMemOpParams_union>(),
781 8usize,
782 concat!("Alignment of ", stringify!(CUstreamBatchMemOpParams_union))
783 );
784 assert_eq!(
785 unsafe {
786 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union>())).operation as *const _
787 as usize
788 },
789 0usize,
790 concat!(
791 "Offset of field: ",
792 stringify!(CUstreamBatchMemOpParams_union),
793 "::",
794 stringify!(operation)
795 )
796 );
797 assert_eq!(
798 unsafe {
799 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union>())).waitValue as *const _
800 as usize
801 },
802 0usize,
803 concat!(
804 "Offset of field: ",
805 stringify!(CUstreamBatchMemOpParams_union),
806 "::",
807 stringify!(waitValue)
808 )
809 );
810 assert_eq!(
811 unsafe {
812 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union>())).writeValue as *const _
813 as usize
814 },
815 0usize,
816 concat!(
817 "Offset of field: ",
818 stringify!(CUstreamBatchMemOpParams_union),
819 "::",
820 stringify!(writeValue)
821 )
822 );
823 assert_eq!(
824 unsafe {
825 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union>())).flushRemoteWrites as *const _
826 as usize
827 },
828 0usize,
829 concat!(
830 "Offset of field: ",
831 stringify!(CUstreamBatchMemOpParams_union),
832 "::",
833 stringify!(flushRemoteWrites)
834 )
835 );
836 assert_eq!(
837 unsafe {
838 &(*(::std::ptr::null::<CUstreamBatchMemOpParams_union>())).pad as *const _ as usize
839 },
840 0usize,
841 concat!(
842 "Offset of field: ",
843 stringify!(CUstreamBatchMemOpParams_union),
844 "::",
845 stringify!(pad)
846 )
847 );
848}
849impl Default for CUstreamBatchMemOpParams_union {
850 fn default() -> Self {
851 unsafe { ::std::mem::zeroed() }
852 }
853}
854pub type CUstreamBatchMemOpParams = CUstreamBatchMemOpParams_union;
855#[repr(u32)]
856#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
857pub enum CUoccupancy_flags_enum {
858 CU_OCCUPANCY_DEFAULT = 0,
859 CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = 1,
860}
861pub use self::CUoccupancy_flags_enum as CUoccupancy_flags;
862#[repr(u32)]
863#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
864pub enum CUarray_format_enum {
865 CU_AD_FORMAT_UNSIGNED_INT8 = 1,
866 CU_AD_FORMAT_UNSIGNED_INT16 = 2,
867 CU_AD_FORMAT_UNSIGNED_INT32 = 3,
868 CU_AD_FORMAT_SIGNED_INT8 = 8,
869 CU_AD_FORMAT_SIGNED_INT16 = 9,
870 CU_AD_FORMAT_SIGNED_INT32 = 10,
871 CU_AD_FORMAT_HALF = 16,
872 CU_AD_FORMAT_FLOAT = 32,
873}
874pub use self::CUarray_format_enum as CUarray_format;
875#[repr(u32)]
876#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
877pub enum CUaddress_mode_enum {
878 CU_TR_ADDRESS_MODE_WRAP = 0,
879 CU_TR_ADDRESS_MODE_CLAMP = 1,
880 CU_TR_ADDRESS_MODE_MIRROR = 2,
881 CU_TR_ADDRESS_MODE_BORDER = 3,
882}
883pub use self::CUaddress_mode_enum as CUaddress_mode;
884#[repr(u32)]
885#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
886pub enum CUfilter_mode_enum {
887 CU_TR_FILTER_MODE_POINT = 0,
888 CU_TR_FILTER_MODE_LINEAR = 1,
889}
890pub use self::CUfilter_mode_enum as CUfilter_mode;
891impl CUdevice_attribute_enum {
892 pub const CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum =
893 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK;
894}
895impl CUdevice_attribute_enum {
896 pub const CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK: CUdevice_attribute_enum =
897 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK;
898}
899impl CUdevice_attribute_enum {
900 pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH: CUdevice_attribute_enum =
901 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH;
902}
903impl CUdevice_attribute_enum {
904 pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT: CUdevice_attribute_enum =
905 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT;
906}
907impl CUdevice_attribute_enum {
908 pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES: CUdevice_attribute_enum =
909 CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS;
910}
911#[repr(u32)]
912#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
913pub enum CUdevice_attribute_enum {
914 CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1,
915 CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2,
916 CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3,
917 CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4,
918 CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5,
919 CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6,
920 CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7,
921 CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8,
922 CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9,
923 CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10,
924 CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11,
925 CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12,
926 CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,
927 CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14,
928 CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15,
929 CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,
930 CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17,
931 CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,
932 CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,
933 CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,
934 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21,
935 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22,
936 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23,
937 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24,
938 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25,
939 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26,
940 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = 27,
941 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28,
942 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29,
943 CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30,
944 CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,
945 CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32,
946 CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33,
947 CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34,
948 CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35,
949 CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36,
950 CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37,
951 CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38,
952 CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = 39,
953 CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40,
954 CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41,
955 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = 42,
956 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = 43,
957 CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = 44,
958 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = 45,
959 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = 46,
960 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = 47,
961 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = 48,
962 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = 49,
963 CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50,
964 CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51,
965 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = 52,
966 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = 53,
967 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = 54,
968 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = 55,
969 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = 56,
970 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = 57,
971 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = 58,
972 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = 59,
973 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = 60,
974 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = 61,
975 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = 62,
976 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = 63,
977 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = 64,
978 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = 65,
979 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = 66,
980 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = 67,
981 CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = 68,
982 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = 69,
983 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = 70,
984 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = 71,
985 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = 72,
986 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = 73,
987 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = 74,
988 CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75,
989 CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76,
990 CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = 77,
991 CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = 78,
992 CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = 79,
993 CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = 80,
994 CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = 81,
995 CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82,
996 CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83,
997 CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = 84,
998 CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85,
999 CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = 86,
1000 CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = 87,
1001 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = 88,
1002 CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = 89,
1003 CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = 90,
1004 CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = 91,
1005 CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS = 92,
1006 CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS = 93,
1007 CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR = 94,
1008 CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = 95,
1009 CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH = 96,
1010 CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN = 97,
1011 CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES = 98,
1012 CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED = 99,
1013 CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES = 100,
1014 CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST = 101,
1015 CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED = 102,
1016 CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED = 103,
1017 CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED = 104,
1018 CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED = 105,
1019 CU_DEVICE_ATTRIBUTE_MAX = 106,
1020}
1021pub use self::CUdevice_attribute_enum as CUdevice_attribute;
1022#[repr(C)]
1023#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1024pub struct CUdevprop_st {
1025 pub maxThreadsPerBlock: ::std::os::raw::c_int,
1026 pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
1027 pub maxGridSize: [::std::os::raw::c_int; 3usize],
1028 pub sharedMemPerBlock: ::std::os::raw::c_int,
1029 pub totalConstantMemory: ::std::os::raw::c_int,
1030 pub SIMDWidth: ::std::os::raw::c_int,
1031 pub memPitch: ::std::os::raw::c_int,
1032 pub regsPerBlock: ::std::os::raw::c_int,
1033 pub clockRate: ::std::os::raw::c_int,
1034 pub textureAlign: ::std::os::raw::c_int,
1035}
1036#[test]
1037fn bindgen_test_layout_CUdevprop_st() {
1038 assert_eq!(
1039 ::std::mem::size_of::<CUdevprop_st>(),
1040 56usize,
1041 concat!("Size of: ", stringify!(CUdevprop_st))
1042 );
1043 assert_eq!(
1044 ::std::mem::align_of::<CUdevprop_st>(),
1045 4usize,
1046 concat!("Alignment of ", stringify!(CUdevprop_st))
1047 );
1048 assert_eq!(
1049 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).maxThreadsPerBlock as *const _ as usize },
1050 0usize,
1051 concat!(
1052 "Offset of field: ",
1053 stringify!(CUdevprop_st),
1054 "::",
1055 stringify!(maxThreadsPerBlock)
1056 )
1057 );
1058 assert_eq!(
1059 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).maxThreadsDim as *const _ as usize },
1060 4usize,
1061 concat!(
1062 "Offset of field: ",
1063 stringify!(CUdevprop_st),
1064 "::",
1065 stringify!(maxThreadsDim)
1066 )
1067 );
1068 assert_eq!(
1069 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).maxGridSize as *const _ as usize },
1070 16usize,
1071 concat!(
1072 "Offset of field: ",
1073 stringify!(CUdevprop_st),
1074 "::",
1075 stringify!(maxGridSize)
1076 )
1077 );
1078 assert_eq!(
1079 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).sharedMemPerBlock as *const _ as usize },
1080 28usize,
1081 concat!(
1082 "Offset of field: ",
1083 stringify!(CUdevprop_st),
1084 "::",
1085 stringify!(sharedMemPerBlock)
1086 )
1087 );
1088 assert_eq!(
1089 unsafe {
1090 &(*(::std::ptr::null::<CUdevprop_st>())).totalConstantMemory as *const _ as usize
1091 },
1092 32usize,
1093 concat!(
1094 "Offset of field: ",
1095 stringify!(CUdevprop_st),
1096 "::",
1097 stringify!(totalConstantMemory)
1098 )
1099 );
1100 assert_eq!(
1101 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).SIMDWidth as *const _ as usize },
1102 36usize,
1103 concat!(
1104 "Offset of field: ",
1105 stringify!(CUdevprop_st),
1106 "::",
1107 stringify!(SIMDWidth)
1108 )
1109 );
1110 assert_eq!(
1111 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).memPitch as *const _ as usize },
1112 40usize,
1113 concat!(
1114 "Offset of field: ",
1115 stringify!(CUdevprop_st),
1116 "::",
1117 stringify!(memPitch)
1118 )
1119 );
1120 assert_eq!(
1121 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).regsPerBlock as *const _ as usize },
1122 44usize,
1123 concat!(
1124 "Offset of field: ",
1125 stringify!(CUdevprop_st),
1126 "::",
1127 stringify!(regsPerBlock)
1128 )
1129 );
1130 assert_eq!(
1131 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).clockRate as *const _ as usize },
1132 48usize,
1133 concat!(
1134 "Offset of field: ",
1135 stringify!(CUdevprop_st),
1136 "::",
1137 stringify!(clockRate)
1138 )
1139 );
1140 assert_eq!(
1141 unsafe { &(*(::std::ptr::null::<CUdevprop_st>())).textureAlign as *const _ as usize },
1142 52usize,
1143 concat!(
1144 "Offset of field: ",
1145 stringify!(CUdevprop_st),
1146 "::",
1147 stringify!(textureAlign)
1148 )
1149 );
1150}
1151pub type CUdevprop = CUdevprop_st;
1152#[repr(u32)]
1153#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1154pub enum CUpointer_attribute_enum {
1155 CU_POINTER_ATTRIBUTE_CONTEXT = 1,
1156 CU_POINTER_ATTRIBUTE_MEMORY_TYPE = 2,
1157 CU_POINTER_ATTRIBUTE_DEVICE_POINTER = 3,
1158 CU_POINTER_ATTRIBUTE_HOST_POINTER = 4,
1159 CU_POINTER_ATTRIBUTE_P2P_TOKENS = 5,
1160 CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6,
1161 CU_POINTER_ATTRIBUTE_BUFFER_ID = 7,
1162 CU_POINTER_ATTRIBUTE_IS_MANAGED = 8,
1163 CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL = 9,
1164 CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE = 10,
1165 CU_POINTER_ATTRIBUTE_RANGE_START_ADDR = 11,
1166 CU_POINTER_ATTRIBUTE_RANGE_SIZE = 12,
1167 CU_POINTER_ATTRIBUTE_MAPPED = 13,
1168 CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = 14,
1169}
1170pub use self::CUpointer_attribute_enum as CUpointer_attribute;
1171#[repr(u32)]
1172#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1173pub enum CUfunction_attribute_enum {
1174 CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0,
1175 CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1,
1176 CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2,
1177 CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3,
1178 CU_FUNC_ATTRIBUTE_NUM_REGS = 4,
1179 CU_FUNC_ATTRIBUTE_PTX_VERSION = 5,
1180 CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6,
1181 CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7,
1182 CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8,
1183 CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9,
1184 CU_FUNC_ATTRIBUTE_MAX = 10,
1185}
1186pub use self::CUfunction_attribute_enum as CUfunction_attribute;
1187#[repr(u32)]
1188#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1189pub enum CUfunc_cache_enum {
1190 CU_FUNC_CACHE_PREFER_NONE = 0,
1191 CU_FUNC_CACHE_PREFER_SHARED = 1,
1192 CU_FUNC_CACHE_PREFER_L1 = 2,
1193 CU_FUNC_CACHE_PREFER_EQUAL = 3,
1194}
1195pub use self::CUfunc_cache_enum as CUfunc_cache;
1196#[repr(u32)]
1197#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1198pub enum CUsharedconfig_enum {
1199 CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = 0,
1200 CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = 1,
1201 CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = 2,
1202}
1203pub use self::CUsharedconfig_enum as CUsharedconfig;
1204#[repr(i32)]
1205#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1206pub enum CUshared_carveout_enum {
1207 CU_SHAREDMEM_CARVEOUT_DEFAULT = -1,
1208 CU_SHAREDMEM_CARVEOUT_MAX_SHARED = 100,
1209 CU_SHAREDMEM_CARVEOUT_MAX_L1 = 0,
1210}
1211pub use self::CUshared_carveout_enum as CUshared_carveout;
1212#[repr(u32)]
1213#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1214pub enum CUmemorytype_enum {
1215 CU_MEMORYTYPE_HOST = 1,
1216 CU_MEMORYTYPE_DEVICE = 2,
1217 CU_MEMORYTYPE_ARRAY = 3,
1218 CU_MEMORYTYPE_UNIFIED = 4,
1219}
1220pub use self::CUmemorytype_enum as CUmemorytype;
1221#[repr(u32)]
1222#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1223pub enum CUcomputemode_enum {
1224 CU_COMPUTEMODE_DEFAULT = 0,
1225 CU_COMPUTEMODE_PROHIBITED = 2,
1226 CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3,
1227}
1228pub use self::CUcomputemode_enum as CUcomputemode;
1229#[repr(u32)]
1230#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1231pub enum CUmem_advise_enum {
1232 CU_MEM_ADVISE_SET_READ_MOSTLY = 1,
1233 CU_MEM_ADVISE_UNSET_READ_MOSTLY = 2,
1234 CU_MEM_ADVISE_SET_PREFERRED_LOCATION = 3,
1235 CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = 4,
1236 CU_MEM_ADVISE_SET_ACCESSED_BY = 5,
1237 CU_MEM_ADVISE_UNSET_ACCESSED_BY = 6,
1238}
1239pub use self::CUmem_advise_enum as CUmem_advise;
1240#[repr(u32)]
1241#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1242pub enum CUmem_range_attribute_enum {
1243 CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = 1,
1244 CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = 2,
1245 CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = 3,
1246 CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = 4,
1247}
1248pub use self::CUmem_range_attribute_enum as CUmem_range_attribute;
1249#[repr(u32)]
1250#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1251pub enum CUjit_option_enum {
1252 CU_JIT_MAX_REGISTERS = 0,
1253 CU_JIT_THREADS_PER_BLOCK = 1,
1254 CU_JIT_WALL_TIME = 2,
1255 CU_JIT_INFO_LOG_BUFFER = 3,
1256 CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4,
1257 CU_JIT_ERROR_LOG_BUFFER = 5,
1258 CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6,
1259 CU_JIT_OPTIMIZATION_LEVEL = 7,
1260 CU_JIT_TARGET_FROM_CUCONTEXT = 8,
1261 CU_JIT_TARGET = 9,
1262 CU_JIT_FALLBACK_STRATEGY = 10,
1263 CU_JIT_GENERATE_DEBUG_INFO = 11,
1264 CU_JIT_LOG_VERBOSE = 12,
1265 CU_JIT_GENERATE_LINE_INFO = 13,
1266 CU_JIT_CACHE_MODE = 14,
1267 CU_JIT_NEW_SM3X_OPT = 15,
1268 CU_JIT_FAST_COMPILE = 16,
1269 CU_JIT_GLOBAL_SYMBOL_NAMES = 17,
1270 CU_JIT_GLOBAL_SYMBOL_ADDRESSES = 18,
1271 CU_JIT_GLOBAL_SYMBOL_COUNT = 19,
1272 CU_JIT_NUM_OPTIONS = 20,
1273}
1274pub use self::CUjit_option_enum as CUjit_option;
1275#[repr(u32)]
1276#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1277pub enum CUjit_target_enum {
1278 CU_TARGET_COMPUTE_20 = 20,
1279 CU_TARGET_COMPUTE_21 = 21,
1280 CU_TARGET_COMPUTE_30 = 30,
1281 CU_TARGET_COMPUTE_32 = 32,
1282 CU_TARGET_COMPUTE_35 = 35,
1283 CU_TARGET_COMPUTE_37 = 37,
1284 CU_TARGET_COMPUTE_50 = 50,
1285 CU_TARGET_COMPUTE_52 = 52,
1286 CU_TARGET_COMPUTE_53 = 53,
1287 CU_TARGET_COMPUTE_60 = 60,
1288 CU_TARGET_COMPUTE_61 = 61,
1289 CU_TARGET_COMPUTE_62 = 62,
1290 CU_TARGET_COMPUTE_70 = 70,
1291 CU_TARGET_COMPUTE_72 = 72,
1292 CU_TARGET_COMPUTE_75 = 75,
1293}
1294pub use self::CUjit_target_enum as CUjit_target;
1295#[repr(u32)]
1296#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1297pub enum CUjit_fallback_enum {
1298 CU_PREFER_PTX = 0,
1299 CU_PREFER_BINARY = 1,
1300}
1301pub use self::CUjit_fallback_enum as CUjit_fallback;
1302#[repr(u32)]
1303#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1304pub enum CUjit_cacheMode_enum {
1305 CU_JIT_CACHE_OPTION_NONE = 0,
1306 CU_JIT_CACHE_OPTION_CG = 1,
1307 CU_JIT_CACHE_OPTION_CA = 2,
1308}
1309pub use self::CUjit_cacheMode_enum as CUjit_cacheMode;
1310#[repr(u32)]
1311#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1312pub enum CUjitInputType_enum {
1313 CU_JIT_INPUT_CUBIN = 0,
1314 CU_JIT_INPUT_PTX = 1,
1315 CU_JIT_INPUT_FATBINARY = 2,
1316 CU_JIT_INPUT_OBJECT = 3,
1317 CU_JIT_INPUT_LIBRARY = 4,
1318 CU_JIT_NUM_INPUT_TYPES = 5,
1319}
1320pub use self::CUjitInputType_enum as CUjitInputType;
1321#[repr(C)]
1322#[derive(Debug, Copy, Clone)]
1323pub struct CUlinkState_st {
1324 _unused: [u8; 0],
1325}
1326pub type CUlinkState = *mut CUlinkState_st;
1327#[repr(u32)]
1328#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1329pub enum CUgraphicsRegisterFlags_enum {
1330 CU_GRAPHICS_REGISTER_FLAGS_NONE = 0,
1331 CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = 1,
1332 CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = 2,
1333 CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = 4,
1334 CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = 8,
1335}
1336pub use self::CUgraphicsRegisterFlags_enum as CUgraphicsRegisterFlags;
1337#[repr(u32)]
1338#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1339pub enum CUgraphicsMapResourceFlags_enum {
1340 CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0,
1341 CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 1,
1342 CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 2,
1343}
1344pub use self::CUgraphicsMapResourceFlags_enum as CUgraphicsMapResourceFlags;
1345#[repr(u32)]
1346#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1347pub enum CUarray_cubemap_face_enum {
1348 CU_CUBEMAP_FACE_POSITIVE_X = 0,
1349 CU_CUBEMAP_FACE_NEGATIVE_X = 1,
1350 CU_CUBEMAP_FACE_POSITIVE_Y = 2,
1351 CU_CUBEMAP_FACE_NEGATIVE_Y = 3,
1352 CU_CUBEMAP_FACE_POSITIVE_Z = 4,
1353 CU_CUBEMAP_FACE_NEGATIVE_Z = 5,
1354}
1355pub use self::CUarray_cubemap_face_enum as CUarray_cubemap_face;
1356#[repr(u32)]
1357#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1358pub enum CUlimit_enum {
1359 CU_LIMIT_STACK_SIZE = 0,
1360 CU_LIMIT_PRINTF_FIFO_SIZE = 1,
1361 CU_LIMIT_MALLOC_HEAP_SIZE = 2,
1362 CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = 3,
1363 CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = 4,
1364 CU_LIMIT_MAX_L2_FETCH_GRANULARITY = 5,
1365 CU_LIMIT_MAX = 6,
1366}
1367pub use self::CUlimit_enum as CUlimit;
1368#[repr(u32)]
1369#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1370pub enum CUresourcetype_enum {
1371 CU_RESOURCE_TYPE_ARRAY = 0,
1372 CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 1,
1373 CU_RESOURCE_TYPE_LINEAR = 2,
1374 CU_RESOURCE_TYPE_PITCH2D = 3,
1375}
1376pub use self::CUresourcetype_enum as CUresourcetype;
1377pub type CUhostFn =
1378 ::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void)>;
1379#[repr(C)]
1380#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1381pub struct CUDA_KERNEL_NODE_PARAMS_st {
1382 pub func: CUfunction,
1383 pub gridDimX: ::std::os::raw::c_uint,
1384 pub gridDimY: ::std::os::raw::c_uint,
1385 pub gridDimZ: ::std::os::raw::c_uint,
1386 pub blockDimX: ::std::os::raw::c_uint,
1387 pub blockDimY: ::std::os::raw::c_uint,
1388 pub blockDimZ: ::std::os::raw::c_uint,
1389 pub sharedMemBytes: ::std::os::raw::c_uint,
1390 pub kernelParams: *mut *mut ::std::os::raw::c_void,
1391 pub extra: *mut *mut ::std::os::raw::c_void,
1392}
1393#[test]
1394fn bindgen_test_layout_CUDA_KERNEL_NODE_PARAMS_st() {
1395 assert_eq!(
1396 ::std::mem::size_of::<CUDA_KERNEL_NODE_PARAMS_st>(),
1397 56usize,
1398 concat!("Size of: ", stringify!(CUDA_KERNEL_NODE_PARAMS_st))
1399 );
1400 assert_eq!(
1401 ::std::mem::align_of::<CUDA_KERNEL_NODE_PARAMS_st>(),
1402 8usize,
1403 concat!("Alignment of ", stringify!(CUDA_KERNEL_NODE_PARAMS_st))
1404 );
1405 assert_eq!(
1406 unsafe { &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).func as *const _ as usize },
1407 0usize,
1408 concat!(
1409 "Offset of field: ",
1410 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1411 "::",
1412 stringify!(func)
1413 )
1414 );
1415 assert_eq!(
1416 unsafe {
1417 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).gridDimX as *const _ as usize
1418 },
1419 8usize,
1420 concat!(
1421 "Offset of field: ",
1422 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1423 "::",
1424 stringify!(gridDimX)
1425 )
1426 );
1427 assert_eq!(
1428 unsafe {
1429 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).gridDimY as *const _ as usize
1430 },
1431 12usize,
1432 concat!(
1433 "Offset of field: ",
1434 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1435 "::",
1436 stringify!(gridDimY)
1437 )
1438 );
1439 assert_eq!(
1440 unsafe {
1441 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).gridDimZ as *const _ as usize
1442 },
1443 16usize,
1444 concat!(
1445 "Offset of field: ",
1446 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1447 "::",
1448 stringify!(gridDimZ)
1449 )
1450 );
1451 assert_eq!(
1452 unsafe {
1453 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).blockDimX as *const _ as usize
1454 },
1455 20usize,
1456 concat!(
1457 "Offset of field: ",
1458 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1459 "::",
1460 stringify!(blockDimX)
1461 )
1462 );
1463 assert_eq!(
1464 unsafe {
1465 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).blockDimY as *const _ as usize
1466 },
1467 24usize,
1468 concat!(
1469 "Offset of field: ",
1470 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1471 "::",
1472 stringify!(blockDimY)
1473 )
1474 );
1475 assert_eq!(
1476 unsafe {
1477 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).blockDimZ as *const _ as usize
1478 },
1479 28usize,
1480 concat!(
1481 "Offset of field: ",
1482 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1483 "::",
1484 stringify!(blockDimZ)
1485 )
1486 );
1487 assert_eq!(
1488 unsafe {
1489 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).sharedMemBytes as *const _
1490 as usize
1491 },
1492 32usize,
1493 concat!(
1494 "Offset of field: ",
1495 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1496 "::",
1497 stringify!(sharedMemBytes)
1498 )
1499 );
1500 assert_eq!(
1501 unsafe {
1502 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).kernelParams as *const _ as usize
1503 },
1504 40usize,
1505 concat!(
1506 "Offset of field: ",
1507 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1508 "::",
1509 stringify!(kernelParams)
1510 )
1511 );
1512 assert_eq!(
1513 unsafe {
1514 &(*(::std::ptr::null::<CUDA_KERNEL_NODE_PARAMS_st>())).extra as *const _ as usize
1515 },
1516 48usize,
1517 concat!(
1518 "Offset of field: ",
1519 stringify!(CUDA_KERNEL_NODE_PARAMS_st),
1520 "::",
1521 stringify!(extra)
1522 )
1523 );
1524}
1525impl Default for CUDA_KERNEL_NODE_PARAMS_st {
1526 fn default() -> Self {
1527 unsafe { ::std::mem::zeroed() }
1528 }
1529}
1530pub type CUDA_KERNEL_NODE_PARAMS = CUDA_KERNEL_NODE_PARAMS_st;
1531#[repr(C)]
1532#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1533pub struct CUDA_MEMSET_NODE_PARAMS_st {
1534 pub dst: CUdeviceptr,
1535 pub pitch: usize,
1536 pub value: ::std::os::raw::c_uint,
1537 pub elementSize: ::std::os::raw::c_uint,
1538 pub width: usize,
1539 pub height: usize,
1540}
1541#[test]
1542fn bindgen_test_layout_CUDA_MEMSET_NODE_PARAMS_st() {
1543 assert_eq!(
1544 ::std::mem::size_of::<CUDA_MEMSET_NODE_PARAMS_st>(),
1545 40usize,
1546 concat!("Size of: ", stringify!(CUDA_MEMSET_NODE_PARAMS_st))
1547 );
1548 assert_eq!(
1549 ::std::mem::align_of::<CUDA_MEMSET_NODE_PARAMS_st>(),
1550 8usize,
1551 concat!("Alignment of ", stringify!(CUDA_MEMSET_NODE_PARAMS_st))
1552 );
1553 assert_eq!(
1554 unsafe { &(*(::std::ptr::null::<CUDA_MEMSET_NODE_PARAMS_st>())).dst as *const _ as usize },
1555 0usize,
1556 concat!(
1557 "Offset of field: ",
1558 stringify!(CUDA_MEMSET_NODE_PARAMS_st),
1559 "::",
1560 stringify!(dst)
1561 )
1562 );
1563 assert_eq!(
1564 unsafe {
1565 &(*(::std::ptr::null::<CUDA_MEMSET_NODE_PARAMS_st>())).pitch as *const _ as usize
1566 },
1567 8usize,
1568 concat!(
1569 "Offset of field: ",
1570 stringify!(CUDA_MEMSET_NODE_PARAMS_st),
1571 "::",
1572 stringify!(pitch)
1573 )
1574 );
1575 assert_eq!(
1576 unsafe {
1577 &(*(::std::ptr::null::<CUDA_MEMSET_NODE_PARAMS_st>())).value as *const _ as usize
1578 },
1579 16usize,
1580 concat!(
1581 "Offset of field: ",
1582 stringify!(CUDA_MEMSET_NODE_PARAMS_st),
1583 "::",
1584 stringify!(value)
1585 )
1586 );
1587 assert_eq!(
1588 unsafe {
1589 &(*(::std::ptr::null::<CUDA_MEMSET_NODE_PARAMS_st>())).elementSize as *const _ as usize
1590 },
1591 20usize,
1592 concat!(
1593 "Offset of field: ",
1594 stringify!(CUDA_MEMSET_NODE_PARAMS_st),
1595 "::",
1596 stringify!(elementSize)
1597 )
1598 );
1599 assert_eq!(
1600 unsafe {
1601 &(*(::std::ptr::null::<CUDA_MEMSET_NODE_PARAMS_st>())).width as *const _ as usize
1602 },
1603 24usize,
1604 concat!(
1605 "Offset of field: ",
1606 stringify!(CUDA_MEMSET_NODE_PARAMS_st),
1607 "::",
1608 stringify!(width)
1609 )
1610 );
1611 assert_eq!(
1612 unsafe {
1613 &(*(::std::ptr::null::<CUDA_MEMSET_NODE_PARAMS_st>())).height as *const _ as usize
1614 },
1615 32usize,
1616 concat!(
1617 "Offset of field: ",
1618 stringify!(CUDA_MEMSET_NODE_PARAMS_st),
1619 "::",
1620 stringify!(height)
1621 )
1622 );
1623}
1624pub type CUDA_MEMSET_NODE_PARAMS = CUDA_MEMSET_NODE_PARAMS_st;
1625#[repr(C)]
1626#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1627pub struct CUDA_HOST_NODE_PARAMS_st {
1628 pub fn_: CUhostFn,
1629 pub userData: *mut ::std::os::raw::c_void,
1630}
1631#[test]
1632fn bindgen_test_layout_CUDA_HOST_NODE_PARAMS_st() {
1633 assert_eq!(
1634 ::std::mem::size_of::<CUDA_HOST_NODE_PARAMS_st>(),
1635 16usize,
1636 concat!("Size of: ", stringify!(CUDA_HOST_NODE_PARAMS_st))
1637 );
1638 assert_eq!(
1639 ::std::mem::align_of::<CUDA_HOST_NODE_PARAMS_st>(),
1640 8usize,
1641 concat!("Alignment of ", stringify!(CUDA_HOST_NODE_PARAMS_st))
1642 );
1643 assert_eq!(
1644 unsafe { &(*(::std::ptr::null::<CUDA_HOST_NODE_PARAMS_st>())).fn_ as *const _ as usize },
1645 0usize,
1646 concat!(
1647 "Offset of field: ",
1648 stringify!(CUDA_HOST_NODE_PARAMS_st),
1649 "::",
1650 stringify!(fn_)
1651 )
1652 );
1653 assert_eq!(
1654 unsafe {
1655 &(*(::std::ptr::null::<CUDA_HOST_NODE_PARAMS_st>())).userData as *const _ as usize
1656 },
1657 8usize,
1658 concat!(
1659 "Offset of field: ",
1660 stringify!(CUDA_HOST_NODE_PARAMS_st),
1661 "::",
1662 stringify!(userData)
1663 )
1664 );
1665}
1666impl Default for CUDA_HOST_NODE_PARAMS_st {
1667 fn default() -> Self {
1668 unsafe { ::std::mem::zeroed() }
1669 }
1670}
1671pub type CUDA_HOST_NODE_PARAMS = CUDA_HOST_NODE_PARAMS_st;
1672#[repr(u32)]
1673#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1674pub enum CUgraphNodeType_enum {
1675 CU_GRAPH_NODE_TYPE_KERNEL = 0,
1676 CU_GRAPH_NODE_TYPE_MEMCPY = 1,
1677 CU_GRAPH_NODE_TYPE_MEMSET = 2,
1678 CU_GRAPH_NODE_TYPE_HOST = 3,
1679 CU_GRAPH_NODE_TYPE_GRAPH = 4,
1680 CU_GRAPH_NODE_TYPE_EMPTY = 5,
1681 CU_GRAPH_NODE_TYPE_COUNT = 6,
1682}
1683pub use self::CUgraphNodeType_enum as CUgraphNodeType;
1684#[repr(u32)]
1685#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1686pub enum CUstreamCaptureStatus_enum {
1687 CU_STREAM_CAPTURE_STATUS_NONE = 0,
1688 CU_STREAM_CAPTURE_STATUS_ACTIVE = 1,
1689 CU_STREAM_CAPTURE_STATUS_INVALIDATED = 2,
1690}
1691pub use self::CUstreamCaptureStatus_enum as CUstreamCaptureStatus;
1692#[repr(u32)]
1693#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1694pub enum CUstreamCaptureMode_enum {
1695 CU_STREAM_CAPTURE_MODE_GLOBAL = 0,
1696 CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = 1,
1697 CU_STREAM_CAPTURE_MODE_RELAXED = 2,
1698}
1699pub use self::CUstreamCaptureMode_enum as CUstreamCaptureMode;
1700#[repr(u32)]
1701#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1702pub enum cudaError_enum {
1703 CUDA_SUCCESS = 0,
1704 CUDA_ERROR_INVALID_VALUE = 1,
1705 CUDA_ERROR_OUT_OF_MEMORY = 2,
1706 CUDA_ERROR_NOT_INITIALIZED = 3,
1707 CUDA_ERROR_DEINITIALIZED = 4,
1708 CUDA_ERROR_PROFILER_DISABLED = 5,
1709 CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6,
1710 CUDA_ERROR_PROFILER_ALREADY_STARTED = 7,
1711 CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8,
1712 CUDA_ERROR_NO_DEVICE = 100,
1713 CUDA_ERROR_INVALID_DEVICE = 101,
1714 CUDA_ERROR_INVALID_IMAGE = 200,
1715 CUDA_ERROR_INVALID_CONTEXT = 201,
1716 CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202,
1717 CUDA_ERROR_MAP_FAILED = 205,
1718 CUDA_ERROR_UNMAP_FAILED = 206,
1719 CUDA_ERROR_ARRAY_IS_MAPPED = 207,
1720 CUDA_ERROR_ALREADY_MAPPED = 208,
1721 CUDA_ERROR_NO_BINARY_FOR_GPU = 209,
1722 CUDA_ERROR_ALREADY_ACQUIRED = 210,
1723 CUDA_ERROR_NOT_MAPPED = 211,
1724 CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212,
1725 CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213,
1726 CUDA_ERROR_ECC_UNCORRECTABLE = 214,
1727 CUDA_ERROR_UNSUPPORTED_LIMIT = 215,
1728 CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216,
1729 CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217,
1730 CUDA_ERROR_INVALID_PTX = 218,
1731 CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219,
1732 CUDA_ERROR_NVLINK_UNCORRECTABLE = 220,
1733 CUDA_ERROR_JIT_COMPILER_NOT_FOUND = 221,
1734 CUDA_ERROR_INVALID_SOURCE = 300,
1735 CUDA_ERROR_FILE_NOT_FOUND = 301,
1736 CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302,
1737 CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303,
1738 CUDA_ERROR_OPERATING_SYSTEM = 304,
1739 CUDA_ERROR_INVALID_HANDLE = 400,
1740 CUDA_ERROR_ILLEGAL_STATE = 401,
1741 CUDA_ERROR_NOT_FOUND = 500,
1742 CUDA_ERROR_NOT_READY = 600,
1743 CUDA_ERROR_ILLEGAL_ADDRESS = 700,
1744 CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701,
1745 CUDA_ERROR_LAUNCH_TIMEOUT = 702,
1746 CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703,
1747 CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704,
1748 CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705,
1749 CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708,
1750 CUDA_ERROR_CONTEXT_IS_DESTROYED = 709,
1751 CUDA_ERROR_ASSERT = 710,
1752 CUDA_ERROR_TOO_MANY_PEERS = 711,
1753 CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712,
1754 CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713,
1755 CUDA_ERROR_HARDWARE_STACK_ERROR = 714,
1756 CUDA_ERROR_ILLEGAL_INSTRUCTION = 715,
1757 CUDA_ERROR_MISALIGNED_ADDRESS = 716,
1758 CUDA_ERROR_INVALID_ADDRESS_SPACE = 717,
1759 CUDA_ERROR_INVALID_PC = 718,
1760 CUDA_ERROR_LAUNCH_FAILED = 719,
1761 CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = 720,
1762 CUDA_ERROR_NOT_PERMITTED = 800,
1763 CUDA_ERROR_NOT_SUPPORTED = 801,
1764 CUDA_ERROR_SYSTEM_NOT_READY = 802,
1765 CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = 803,
1766 CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = 804,
1767 CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = 900,
1768 CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = 901,
1769 CUDA_ERROR_STREAM_CAPTURE_MERGE = 902,
1770 CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = 903,
1771 CUDA_ERROR_STREAM_CAPTURE_UNJOINED = 904,
1772 CUDA_ERROR_STREAM_CAPTURE_ISOLATION = 905,
1773 CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = 906,
1774 CUDA_ERROR_CAPTURED_EVENT = 907,
1775 CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = 908,
1776 CUDA_ERROR_TIMEOUT = 909,
1777 CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE = 910,
1778 CUDA_ERROR_UNKNOWN = 999,
1779}
1780pub use self::cudaError_enum as CUresult;
1781impl CUdevice_P2PAttribute_enum {
1782 pub const CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum =
1783 CUdevice_P2PAttribute_enum::CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED;
1784}
1785#[repr(u32)]
1786#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1787pub enum CUdevice_P2PAttribute_enum {
1788 CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = 1,
1789 CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = 2,
1790 CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = 3,
1791 CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED = 4,
1792}
1793pub use self::CUdevice_P2PAttribute_enum as CUdevice_P2PAttribute;
1794pub type CUstreamCallback = ::std::option::Option<
1795 unsafe extern "C" fn(
1796 hStream: CUstream,
1797 status: CUresult,
1798 userData: *mut ::std::os::raw::c_void,
1799 ),
1800>;
1801pub type CUoccupancyB2DSize =
1802 ::std::option::Option<unsafe extern "C" fn(blockSize: ::std::os::raw::c_int) -> usize>;
1803#[repr(C)]
1804#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1805pub struct CUDA_MEMCPY2D_st {
1806 pub srcXInBytes: usize,
1807 pub srcY: usize,
1808 pub srcMemoryType: CUmemorytype,
1809 pub srcHost: *const ::std::os::raw::c_void,
1810 pub srcDevice: CUdeviceptr,
1811 pub srcArray: CUarray,
1812 pub srcPitch: usize,
1813 pub dstXInBytes: usize,
1814 pub dstY: usize,
1815 pub dstMemoryType: CUmemorytype,
1816 pub dstHost: *mut ::std::os::raw::c_void,
1817 pub dstDevice: CUdeviceptr,
1818 pub dstArray: CUarray,
1819 pub dstPitch: usize,
1820 pub WidthInBytes: usize,
1821 pub Height: usize,
1822}
1823#[test]
1824fn bindgen_test_layout_CUDA_MEMCPY2D_st() {
1825 assert_eq!(
1826 ::std::mem::size_of::<CUDA_MEMCPY2D_st>(),
1827 128usize,
1828 concat!("Size of: ", stringify!(CUDA_MEMCPY2D_st))
1829 );
1830 assert_eq!(
1831 ::std::mem::align_of::<CUDA_MEMCPY2D_st>(),
1832 8usize,
1833 concat!("Alignment of ", stringify!(CUDA_MEMCPY2D_st))
1834 );
1835 assert_eq!(
1836 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).srcXInBytes as *const _ as usize },
1837 0usize,
1838 concat!(
1839 "Offset of field: ",
1840 stringify!(CUDA_MEMCPY2D_st),
1841 "::",
1842 stringify!(srcXInBytes)
1843 )
1844 );
1845 assert_eq!(
1846 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).srcY as *const _ as usize },
1847 8usize,
1848 concat!(
1849 "Offset of field: ",
1850 stringify!(CUDA_MEMCPY2D_st),
1851 "::",
1852 stringify!(srcY)
1853 )
1854 );
1855 assert_eq!(
1856 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).srcMemoryType as *const _ as usize },
1857 16usize,
1858 concat!(
1859 "Offset of field: ",
1860 stringify!(CUDA_MEMCPY2D_st),
1861 "::",
1862 stringify!(srcMemoryType)
1863 )
1864 );
1865 assert_eq!(
1866 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).srcHost as *const _ as usize },
1867 24usize,
1868 concat!(
1869 "Offset of field: ",
1870 stringify!(CUDA_MEMCPY2D_st),
1871 "::",
1872 stringify!(srcHost)
1873 )
1874 );
1875 assert_eq!(
1876 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).srcDevice as *const _ as usize },
1877 32usize,
1878 concat!(
1879 "Offset of field: ",
1880 stringify!(CUDA_MEMCPY2D_st),
1881 "::",
1882 stringify!(srcDevice)
1883 )
1884 );
1885 assert_eq!(
1886 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).srcArray as *const _ as usize },
1887 40usize,
1888 concat!(
1889 "Offset of field: ",
1890 stringify!(CUDA_MEMCPY2D_st),
1891 "::",
1892 stringify!(srcArray)
1893 )
1894 );
1895 assert_eq!(
1896 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).srcPitch as *const _ as usize },
1897 48usize,
1898 concat!(
1899 "Offset of field: ",
1900 stringify!(CUDA_MEMCPY2D_st),
1901 "::",
1902 stringify!(srcPitch)
1903 )
1904 );
1905 assert_eq!(
1906 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).dstXInBytes as *const _ as usize },
1907 56usize,
1908 concat!(
1909 "Offset of field: ",
1910 stringify!(CUDA_MEMCPY2D_st),
1911 "::",
1912 stringify!(dstXInBytes)
1913 )
1914 );
1915 assert_eq!(
1916 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).dstY as *const _ as usize },
1917 64usize,
1918 concat!(
1919 "Offset of field: ",
1920 stringify!(CUDA_MEMCPY2D_st),
1921 "::",
1922 stringify!(dstY)
1923 )
1924 );
1925 assert_eq!(
1926 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).dstMemoryType as *const _ as usize },
1927 72usize,
1928 concat!(
1929 "Offset of field: ",
1930 stringify!(CUDA_MEMCPY2D_st),
1931 "::",
1932 stringify!(dstMemoryType)
1933 )
1934 );
1935 assert_eq!(
1936 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).dstHost as *const _ as usize },
1937 80usize,
1938 concat!(
1939 "Offset of field: ",
1940 stringify!(CUDA_MEMCPY2D_st),
1941 "::",
1942 stringify!(dstHost)
1943 )
1944 );
1945 assert_eq!(
1946 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).dstDevice as *const _ as usize },
1947 88usize,
1948 concat!(
1949 "Offset of field: ",
1950 stringify!(CUDA_MEMCPY2D_st),
1951 "::",
1952 stringify!(dstDevice)
1953 )
1954 );
1955 assert_eq!(
1956 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).dstArray as *const _ as usize },
1957 96usize,
1958 concat!(
1959 "Offset of field: ",
1960 stringify!(CUDA_MEMCPY2D_st),
1961 "::",
1962 stringify!(dstArray)
1963 )
1964 );
1965 assert_eq!(
1966 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).dstPitch as *const _ as usize },
1967 104usize,
1968 concat!(
1969 "Offset of field: ",
1970 stringify!(CUDA_MEMCPY2D_st),
1971 "::",
1972 stringify!(dstPitch)
1973 )
1974 );
1975 assert_eq!(
1976 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).WidthInBytes as *const _ as usize },
1977 112usize,
1978 concat!(
1979 "Offset of field: ",
1980 stringify!(CUDA_MEMCPY2D_st),
1981 "::",
1982 stringify!(WidthInBytes)
1983 )
1984 );
1985 assert_eq!(
1986 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY2D_st>())).Height as *const _ as usize },
1987 120usize,
1988 concat!(
1989 "Offset of field: ",
1990 stringify!(CUDA_MEMCPY2D_st),
1991 "::",
1992 stringify!(Height)
1993 )
1994 );
1995}
1996impl Default for CUDA_MEMCPY2D_st {
1997 fn default() -> Self {
1998 unsafe { ::std::mem::zeroed() }
1999 }
2000}
2001pub type CUDA_MEMCPY2D = CUDA_MEMCPY2D_st;
2002#[repr(C)]
2003#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2004pub struct CUDA_MEMCPY3D_st {
2005 pub srcXInBytes: usize,
2006 pub srcY: usize,
2007 pub srcZ: usize,
2008 pub srcLOD: usize,
2009 pub srcMemoryType: CUmemorytype,
2010 pub srcHost: *const ::std::os::raw::c_void,
2011 pub srcDevice: CUdeviceptr,
2012 pub srcArray: CUarray,
2013 pub reserved0: *mut ::std::os::raw::c_void,
2014 pub srcPitch: usize,
2015 pub srcHeight: usize,
2016 pub dstXInBytes: usize,
2017 pub dstY: usize,
2018 pub dstZ: usize,
2019 pub dstLOD: usize,
2020 pub dstMemoryType: CUmemorytype,
2021 pub dstHost: *mut ::std::os::raw::c_void,
2022 pub dstDevice: CUdeviceptr,
2023 pub dstArray: CUarray,
2024 pub reserved1: *mut ::std::os::raw::c_void,
2025 pub dstPitch: usize,
2026 pub dstHeight: usize,
2027 pub WidthInBytes: usize,
2028 pub Height: usize,
2029 pub Depth: usize,
2030}
2031#[test]
2032fn bindgen_test_layout_CUDA_MEMCPY3D_st() {
2033 assert_eq!(
2034 ::std::mem::size_of::<CUDA_MEMCPY3D_st>(),
2035 200usize,
2036 concat!("Size of: ", stringify!(CUDA_MEMCPY3D_st))
2037 );
2038 assert_eq!(
2039 ::std::mem::align_of::<CUDA_MEMCPY3D_st>(),
2040 8usize,
2041 concat!("Alignment of ", stringify!(CUDA_MEMCPY3D_st))
2042 );
2043 assert_eq!(
2044 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcXInBytes as *const _ as usize },
2045 0usize,
2046 concat!(
2047 "Offset of field: ",
2048 stringify!(CUDA_MEMCPY3D_st),
2049 "::",
2050 stringify!(srcXInBytes)
2051 )
2052 );
2053 assert_eq!(
2054 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcY as *const _ as usize },
2055 8usize,
2056 concat!(
2057 "Offset of field: ",
2058 stringify!(CUDA_MEMCPY3D_st),
2059 "::",
2060 stringify!(srcY)
2061 )
2062 );
2063 assert_eq!(
2064 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcZ as *const _ as usize },
2065 16usize,
2066 concat!(
2067 "Offset of field: ",
2068 stringify!(CUDA_MEMCPY3D_st),
2069 "::",
2070 stringify!(srcZ)
2071 )
2072 );
2073 assert_eq!(
2074 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcLOD as *const _ as usize },
2075 24usize,
2076 concat!(
2077 "Offset of field: ",
2078 stringify!(CUDA_MEMCPY3D_st),
2079 "::",
2080 stringify!(srcLOD)
2081 )
2082 );
2083 assert_eq!(
2084 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcMemoryType as *const _ as usize },
2085 32usize,
2086 concat!(
2087 "Offset of field: ",
2088 stringify!(CUDA_MEMCPY3D_st),
2089 "::",
2090 stringify!(srcMemoryType)
2091 )
2092 );
2093 assert_eq!(
2094 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcHost as *const _ as usize },
2095 40usize,
2096 concat!(
2097 "Offset of field: ",
2098 stringify!(CUDA_MEMCPY3D_st),
2099 "::",
2100 stringify!(srcHost)
2101 )
2102 );
2103 assert_eq!(
2104 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcDevice as *const _ as usize },
2105 48usize,
2106 concat!(
2107 "Offset of field: ",
2108 stringify!(CUDA_MEMCPY3D_st),
2109 "::",
2110 stringify!(srcDevice)
2111 )
2112 );
2113 assert_eq!(
2114 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcArray as *const _ as usize },
2115 56usize,
2116 concat!(
2117 "Offset of field: ",
2118 stringify!(CUDA_MEMCPY3D_st),
2119 "::",
2120 stringify!(srcArray)
2121 )
2122 );
2123 assert_eq!(
2124 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).reserved0 as *const _ as usize },
2125 64usize,
2126 concat!(
2127 "Offset of field: ",
2128 stringify!(CUDA_MEMCPY3D_st),
2129 "::",
2130 stringify!(reserved0)
2131 )
2132 );
2133 assert_eq!(
2134 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcPitch as *const _ as usize },
2135 72usize,
2136 concat!(
2137 "Offset of field: ",
2138 stringify!(CUDA_MEMCPY3D_st),
2139 "::",
2140 stringify!(srcPitch)
2141 )
2142 );
2143 assert_eq!(
2144 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).srcHeight as *const _ as usize },
2145 80usize,
2146 concat!(
2147 "Offset of field: ",
2148 stringify!(CUDA_MEMCPY3D_st),
2149 "::",
2150 stringify!(srcHeight)
2151 )
2152 );
2153 assert_eq!(
2154 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstXInBytes as *const _ as usize },
2155 88usize,
2156 concat!(
2157 "Offset of field: ",
2158 stringify!(CUDA_MEMCPY3D_st),
2159 "::",
2160 stringify!(dstXInBytes)
2161 )
2162 );
2163 assert_eq!(
2164 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstY as *const _ as usize },
2165 96usize,
2166 concat!(
2167 "Offset of field: ",
2168 stringify!(CUDA_MEMCPY3D_st),
2169 "::",
2170 stringify!(dstY)
2171 )
2172 );
2173 assert_eq!(
2174 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstZ as *const _ as usize },
2175 104usize,
2176 concat!(
2177 "Offset of field: ",
2178 stringify!(CUDA_MEMCPY3D_st),
2179 "::",
2180 stringify!(dstZ)
2181 )
2182 );
2183 assert_eq!(
2184 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstLOD as *const _ as usize },
2185 112usize,
2186 concat!(
2187 "Offset of field: ",
2188 stringify!(CUDA_MEMCPY3D_st),
2189 "::",
2190 stringify!(dstLOD)
2191 )
2192 );
2193 assert_eq!(
2194 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstMemoryType as *const _ as usize },
2195 120usize,
2196 concat!(
2197 "Offset of field: ",
2198 stringify!(CUDA_MEMCPY3D_st),
2199 "::",
2200 stringify!(dstMemoryType)
2201 )
2202 );
2203 assert_eq!(
2204 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstHost as *const _ as usize },
2205 128usize,
2206 concat!(
2207 "Offset of field: ",
2208 stringify!(CUDA_MEMCPY3D_st),
2209 "::",
2210 stringify!(dstHost)
2211 )
2212 );
2213 assert_eq!(
2214 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstDevice as *const _ as usize },
2215 136usize,
2216 concat!(
2217 "Offset of field: ",
2218 stringify!(CUDA_MEMCPY3D_st),
2219 "::",
2220 stringify!(dstDevice)
2221 )
2222 );
2223 assert_eq!(
2224 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstArray as *const _ as usize },
2225 144usize,
2226 concat!(
2227 "Offset of field: ",
2228 stringify!(CUDA_MEMCPY3D_st),
2229 "::",
2230 stringify!(dstArray)
2231 )
2232 );
2233 assert_eq!(
2234 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).reserved1 as *const _ as usize },
2235 152usize,
2236 concat!(
2237 "Offset of field: ",
2238 stringify!(CUDA_MEMCPY3D_st),
2239 "::",
2240 stringify!(reserved1)
2241 )
2242 );
2243 assert_eq!(
2244 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstPitch as *const _ as usize },
2245 160usize,
2246 concat!(
2247 "Offset of field: ",
2248 stringify!(CUDA_MEMCPY3D_st),
2249 "::",
2250 stringify!(dstPitch)
2251 )
2252 );
2253 assert_eq!(
2254 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).dstHeight as *const _ as usize },
2255 168usize,
2256 concat!(
2257 "Offset of field: ",
2258 stringify!(CUDA_MEMCPY3D_st),
2259 "::",
2260 stringify!(dstHeight)
2261 )
2262 );
2263 assert_eq!(
2264 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).WidthInBytes as *const _ as usize },
2265 176usize,
2266 concat!(
2267 "Offset of field: ",
2268 stringify!(CUDA_MEMCPY3D_st),
2269 "::",
2270 stringify!(WidthInBytes)
2271 )
2272 );
2273 assert_eq!(
2274 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).Height as *const _ as usize },
2275 184usize,
2276 concat!(
2277 "Offset of field: ",
2278 stringify!(CUDA_MEMCPY3D_st),
2279 "::",
2280 stringify!(Height)
2281 )
2282 );
2283 assert_eq!(
2284 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_st>())).Depth as *const _ as usize },
2285 192usize,
2286 concat!(
2287 "Offset of field: ",
2288 stringify!(CUDA_MEMCPY3D_st),
2289 "::",
2290 stringify!(Depth)
2291 )
2292 );
2293}
2294impl Default for CUDA_MEMCPY3D_st {
2295 fn default() -> Self {
2296 unsafe { ::std::mem::zeroed() }
2297 }
2298}
2299pub type CUDA_MEMCPY3D = CUDA_MEMCPY3D_st;
2300#[repr(C)]
2301#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2302pub struct CUDA_MEMCPY3D_PEER_st {
2303 pub srcXInBytes: usize,
2304 pub srcY: usize,
2305 pub srcZ: usize,
2306 pub srcLOD: usize,
2307 pub srcMemoryType: CUmemorytype,
2308 pub srcHost: *const ::std::os::raw::c_void,
2309 pub srcDevice: CUdeviceptr,
2310 pub srcArray: CUarray,
2311 pub srcContext: CUcontext,
2312 pub srcPitch: usize,
2313 pub srcHeight: usize,
2314 pub dstXInBytes: usize,
2315 pub dstY: usize,
2316 pub dstZ: usize,
2317 pub dstLOD: usize,
2318 pub dstMemoryType: CUmemorytype,
2319 pub dstHost: *mut ::std::os::raw::c_void,
2320 pub dstDevice: CUdeviceptr,
2321 pub dstArray: CUarray,
2322 pub dstContext: CUcontext,
2323 pub dstPitch: usize,
2324 pub dstHeight: usize,
2325 pub WidthInBytes: usize,
2326 pub Height: usize,
2327 pub Depth: usize,
2328}
2329#[test]
2330fn bindgen_test_layout_CUDA_MEMCPY3D_PEER_st() {
2331 assert_eq!(
2332 ::std::mem::size_of::<CUDA_MEMCPY3D_PEER_st>(),
2333 200usize,
2334 concat!("Size of: ", stringify!(CUDA_MEMCPY3D_PEER_st))
2335 );
2336 assert_eq!(
2337 ::std::mem::align_of::<CUDA_MEMCPY3D_PEER_st>(),
2338 8usize,
2339 concat!("Alignment of ", stringify!(CUDA_MEMCPY3D_PEER_st))
2340 );
2341 assert_eq!(
2342 unsafe {
2343 &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcXInBytes as *const _ as usize
2344 },
2345 0usize,
2346 concat!(
2347 "Offset of field: ",
2348 stringify!(CUDA_MEMCPY3D_PEER_st),
2349 "::",
2350 stringify!(srcXInBytes)
2351 )
2352 );
2353 assert_eq!(
2354 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcY as *const _ as usize },
2355 8usize,
2356 concat!(
2357 "Offset of field: ",
2358 stringify!(CUDA_MEMCPY3D_PEER_st),
2359 "::",
2360 stringify!(srcY)
2361 )
2362 );
2363 assert_eq!(
2364 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcZ as *const _ as usize },
2365 16usize,
2366 concat!(
2367 "Offset of field: ",
2368 stringify!(CUDA_MEMCPY3D_PEER_st),
2369 "::",
2370 stringify!(srcZ)
2371 )
2372 );
2373 assert_eq!(
2374 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcLOD as *const _ as usize },
2375 24usize,
2376 concat!(
2377 "Offset of field: ",
2378 stringify!(CUDA_MEMCPY3D_PEER_st),
2379 "::",
2380 stringify!(srcLOD)
2381 )
2382 );
2383 assert_eq!(
2384 unsafe {
2385 &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcMemoryType as *const _ as usize
2386 },
2387 32usize,
2388 concat!(
2389 "Offset of field: ",
2390 stringify!(CUDA_MEMCPY3D_PEER_st),
2391 "::",
2392 stringify!(srcMemoryType)
2393 )
2394 );
2395 assert_eq!(
2396 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcHost as *const _ as usize },
2397 40usize,
2398 concat!(
2399 "Offset of field: ",
2400 stringify!(CUDA_MEMCPY3D_PEER_st),
2401 "::",
2402 stringify!(srcHost)
2403 )
2404 );
2405 assert_eq!(
2406 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcDevice as *const _ as usize },
2407 48usize,
2408 concat!(
2409 "Offset of field: ",
2410 stringify!(CUDA_MEMCPY3D_PEER_st),
2411 "::",
2412 stringify!(srcDevice)
2413 )
2414 );
2415 assert_eq!(
2416 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcArray as *const _ as usize },
2417 56usize,
2418 concat!(
2419 "Offset of field: ",
2420 stringify!(CUDA_MEMCPY3D_PEER_st),
2421 "::",
2422 stringify!(srcArray)
2423 )
2424 );
2425 assert_eq!(
2426 unsafe {
2427 &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcContext as *const _ as usize
2428 },
2429 64usize,
2430 concat!(
2431 "Offset of field: ",
2432 stringify!(CUDA_MEMCPY3D_PEER_st),
2433 "::",
2434 stringify!(srcContext)
2435 )
2436 );
2437 assert_eq!(
2438 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcPitch as *const _ as usize },
2439 72usize,
2440 concat!(
2441 "Offset of field: ",
2442 stringify!(CUDA_MEMCPY3D_PEER_st),
2443 "::",
2444 stringify!(srcPitch)
2445 )
2446 );
2447 assert_eq!(
2448 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).srcHeight as *const _ as usize },
2449 80usize,
2450 concat!(
2451 "Offset of field: ",
2452 stringify!(CUDA_MEMCPY3D_PEER_st),
2453 "::",
2454 stringify!(srcHeight)
2455 )
2456 );
2457 assert_eq!(
2458 unsafe {
2459 &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstXInBytes as *const _ as usize
2460 },
2461 88usize,
2462 concat!(
2463 "Offset of field: ",
2464 stringify!(CUDA_MEMCPY3D_PEER_st),
2465 "::",
2466 stringify!(dstXInBytes)
2467 )
2468 );
2469 assert_eq!(
2470 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstY as *const _ as usize },
2471 96usize,
2472 concat!(
2473 "Offset of field: ",
2474 stringify!(CUDA_MEMCPY3D_PEER_st),
2475 "::",
2476 stringify!(dstY)
2477 )
2478 );
2479 assert_eq!(
2480 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstZ as *const _ as usize },
2481 104usize,
2482 concat!(
2483 "Offset of field: ",
2484 stringify!(CUDA_MEMCPY3D_PEER_st),
2485 "::",
2486 stringify!(dstZ)
2487 )
2488 );
2489 assert_eq!(
2490 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstLOD as *const _ as usize },
2491 112usize,
2492 concat!(
2493 "Offset of field: ",
2494 stringify!(CUDA_MEMCPY3D_PEER_st),
2495 "::",
2496 stringify!(dstLOD)
2497 )
2498 );
2499 assert_eq!(
2500 unsafe {
2501 &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstMemoryType as *const _ as usize
2502 },
2503 120usize,
2504 concat!(
2505 "Offset of field: ",
2506 stringify!(CUDA_MEMCPY3D_PEER_st),
2507 "::",
2508 stringify!(dstMemoryType)
2509 )
2510 );
2511 assert_eq!(
2512 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstHost as *const _ as usize },
2513 128usize,
2514 concat!(
2515 "Offset of field: ",
2516 stringify!(CUDA_MEMCPY3D_PEER_st),
2517 "::",
2518 stringify!(dstHost)
2519 )
2520 );
2521 assert_eq!(
2522 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstDevice as *const _ as usize },
2523 136usize,
2524 concat!(
2525 "Offset of field: ",
2526 stringify!(CUDA_MEMCPY3D_PEER_st),
2527 "::",
2528 stringify!(dstDevice)
2529 )
2530 );
2531 assert_eq!(
2532 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstArray as *const _ as usize },
2533 144usize,
2534 concat!(
2535 "Offset of field: ",
2536 stringify!(CUDA_MEMCPY3D_PEER_st),
2537 "::",
2538 stringify!(dstArray)
2539 )
2540 );
2541 assert_eq!(
2542 unsafe {
2543 &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstContext as *const _ as usize
2544 },
2545 152usize,
2546 concat!(
2547 "Offset of field: ",
2548 stringify!(CUDA_MEMCPY3D_PEER_st),
2549 "::",
2550 stringify!(dstContext)
2551 )
2552 );
2553 assert_eq!(
2554 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstPitch as *const _ as usize },
2555 160usize,
2556 concat!(
2557 "Offset of field: ",
2558 stringify!(CUDA_MEMCPY3D_PEER_st),
2559 "::",
2560 stringify!(dstPitch)
2561 )
2562 );
2563 assert_eq!(
2564 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).dstHeight as *const _ as usize },
2565 168usize,
2566 concat!(
2567 "Offset of field: ",
2568 stringify!(CUDA_MEMCPY3D_PEER_st),
2569 "::",
2570 stringify!(dstHeight)
2571 )
2572 );
2573 assert_eq!(
2574 unsafe {
2575 &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).WidthInBytes as *const _ as usize
2576 },
2577 176usize,
2578 concat!(
2579 "Offset of field: ",
2580 stringify!(CUDA_MEMCPY3D_PEER_st),
2581 "::",
2582 stringify!(WidthInBytes)
2583 )
2584 );
2585 assert_eq!(
2586 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).Height as *const _ as usize },
2587 184usize,
2588 concat!(
2589 "Offset of field: ",
2590 stringify!(CUDA_MEMCPY3D_PEER_st),
2591 "::",
2592 stringify!(Height)
2593 )
2594 );
2595 assert_eq!(
2596 unsafe { &(*(::std::ptr::null::<CUDA_MEMCPY3D_PEER_st>())).Depth as *const _ as usize },
2597 192usize,
2598 concat!(
2599 "Offset of field: ",
2600 stringify!(CUDA_MEMCPY3D_PEER_st),
2601 "::",
2602 stringify!(Depth)
2603 )
2604 );
2605}
2606impl Default for CUDA_MEMCPY3D_PEER_st {
2607 fn default() -> Self {
2608 unsafe { ::std::mem::zeroed() }
2609 }
2610}
2611pub type CUDA_MEMCPY3D_PEER = CUDA_MEMCPY3D_PEER_st;
2612#[repr(C)]
2613#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2614pub struct CUDA_ARRAY_DESCRIPTOR_st {
2615 pub Width: usize,
2616 pub Height: usize,
2617 pub Format: CUarray_format,
2618 pub NumChannels: ::std::os::raw::c_uint,
2619}
2620#[test]
2621fn bindgen_test_layout_CUDA_ARRAY_DESCRIPTOR_st() {
2622 assert_eq!(
2623 ::std::mem::size_of::<CUDA_ARRAY_DESCRIPTOR_st>(),
2624 24usize,
2625 concat!("Size of: ", stringify!(CUDA_ARRAY_DESCRIPTOR_st))
2626 );
2627 assert_eq!(
2628 ::std::mem::align_of::<CUDA_ARRAY_DESCRIPTOR_st>(),
2629 8usize,
2630 concat!("Alignment of ", stringify!(CUDA_ARRAY_DESCRIPTOR_st))
2631 );
2632 assert_eq!(
2633 unsafe { &(*(::std::ptr::null::<CUDA_ARRAY_DESCRIPTOR_st>())).Width as *const _ as usize },
2634 0usize,
2635 concat!(
2636 "Offset of field: ",
2637 stringify!(CUDA_ARRAY_DESCRIPTOR_st),
2638 "::",
2639 stringify!(Width)
2640 )
2641 );
2642 assert_eq!(
2643 unsafe { &(*(::std::ptr::null::<CUDA_ARRAY_DESCRIPTOR_st>())).Height as *const _ as usize },
2644 8usize,
2645 concat!(
2646 "Offset of field: ",
2647 stringify!(CUDA_ARRAY_DESCRIPTOR_st),
2648 "::",
2649 stringify!(Height)
2650 )
2651 );
2652 assert_eq!(
2653 unsafe { &(*(::std::ptr::null::<CUDA_ARRAY_DESCRIPTOR_st>())).Format as *const _ as usize },
2654 16usize,
2655 concat!(
2656 "Offset of field: ",
2657 stringify!(CUDA_ARRAY_DESCRIPTOR_st),
2658 "::",
2659 stringify!(Format)
2660 )
2661 );
2662 assert_eq!(
2663 unsafe {
2664 &(*(::std::ptr::null::<CUDA_ARRAY_DESCRIPTOR_st>())).NumChannels as *const _ as usize
2665 },
2666 20usize,
2667 concat!(
2668 "Offset of field: ",
2669 stringify!(CUDA_ARRAY_DESCRIPTOR_st),
2670 "::",
2671 stringify!(NumChannels)
2672 )
2673 );
2674}
2675impl Default for CUDA_ARRAY_DESCRIPTOR_st {
2676 fn default() -> Self {
2677 unsafe { ::std::mem::zeroed() }
2678 }
2679}
2680pub type CUDA_ARRAY_DESCRIPTOR = CUDA_ARRAY_DESCRIPTOR_st;
2681#[repr(C)]
2682#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2683pub struct CUDA_ARRAY3D_DESCRIPTOR_st {
2684 pub Width: usize,
2685 pub Height: usize,
2686 pub Depth: usize,
2687 pub Format: CUarray_format,
2688 pub NumChannels: ::std::os::raw::c_uint,
2689 pub Flags: ::std::os::raw::c_uint,
2690}
2691#[test]
2692fn bindgen_test_layout_CUDA_ARRAY3D_DESCRIPTOR_st() {
2693 assert_eq!(
2694 ::std::mem::size_of::<CUDA_ARRAY3D_DESCRIPTOR_st>(),
2695 40usize,
2696 concat!("Size of: ", stringify!(CUDA_ARRAY3D_DESCRIPTOR_st))
2697 );
2698 assert_eq!(
2699 ::std::mem::align_of::<CUDA_ARRAY3D_DESCRIPTOR_st>(),
2700 8usize,
2701 concat!("Alignment of ", stringify!(CUDA_ARRAY3D_DESCRIPTOR_st))
2702 );
2703 assert_eq!(
2704 unsafe {
2705 &(*(::std::ptr::null::<CUDA_ARRAY3D_DESCRIPTOR_st>())).Width as *const _ as usize
2706 },
2707 0usize,
2708 concat!(
2709 "Offset of field: ",
2710 stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
2711 "::",
2712 stringify!(Width)
2713 )
2714 );
2715 assert_eq!(
2716 unsafe {
2717 &(*(::std::ptr::null::<CUDA_ARRAY3D_DESCRIPTOR_st>())).Height as *const _ as usize
2718 },
2719 8usize,
2720 concat!(
2721 "Offset of field: ",
2722 stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
2723 "::",
2724 stringify!(Height)
2725 )
2726 );
2727 assert_eq!(
2728 unsafe {
2729 &(*(::std::ptr::null::<CUDA_ARRAY3D_DESCRIPTOR_st>())).Depth as *const _ as usize
2730 },
2731 16usize,
2732 concat!(
2733 "Offset of field: ",
2734 stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
2735 "::",
2736 stringify!(Depth)
2737 )
2738 );
2739 assert_eq!(
2740 unsafe {
2741 &(*(::std::ptr::null::<CUDA_ARRAY3D_DESCRIPTOR_st>())).Format as *const _ as usize
2742 },
2743 24usize,
2744 concat!(
2745 "Offset of field: ",
2746 stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
2747 "::",
2748 stringify!(Format)
2749 )
2750 );
2751 assert_eq!(
2752 unsafe {
2753 &(*(::std::ptr::null::<CUDA_ARRAY3D_DESCRIPTOR_st>())).NumChannels as *const _ as usize
2754 },
2755 28usize,
2756 concat!(
2757 "Offset of field: ",
2758 stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
2759 "::",
2760 stringify!(NumChannels)
2761 )
2762 );
2763 assert_eq!(
2764 unsafe {
2765 &(*(::std::ptr::null::<CUDA_ARRAY3D_DESCRIPTOR_st>())).Flags as *const _ as usize
2766 },
2767 32usize,
2768 concat!(
2769 "Offset of field: ",
2770 stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
2771 "::",
2772 stringify!(Flags)
2773 )
2774 );
2775}
2776impl Default for CUDA_ARRAY3D_DESCRIPTOR_st {
2777 fn default() -> Self {
2778 unsafe { ::std::mem::zeroed() }
2779 }
2780}
2781pub type CUDA_ARRAY3D_DESCRIPTOR = CUDA_ARRAY3D_DESCRIPTOR_st;
2782#[repr(C)]
2783#[derive(Copy, Clone)]
2784pub struct CUDA_RESOURCE_DESC_st {
2785 pub resType: CUresourcetype,
2786 pub res: CUDA_RESOURCE_DESC_st__bindgen_ty_1,
2787 pub flags: ::std::os::raw::c_uint,
2788}
2789#[repr(C)]
2790#[derive(Copy, Clone)]
2791pub union CUDA_RESOURCE_DESC_st__bindgen_ty_1 {
2792 pub array: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1,
2793 pub mipmap: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2,
2794 pub linear: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
2795 pub pitch2D: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
2796 pub reserved: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
2797 _bindgen_union_align: [u64; 16usize],
2798}
2799#[repr(C)]
2800#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2801pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
2802 pub hArray: CUarray,
2803}
2804#[test]
2805fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1() {
2806 assert_eq!(
2807 ::std::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
2808 8usize,
2809 concat!(
2810 "Size of: ",
2811 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1)
2812 )
2813 );
2814 assert_eq!(
2815 ::std::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
2816 8usize,
2817 concat!(
2818 "Alignment of ",
2819 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1)
2820 )
2821 );
2822 assert_eq!(
2823 unsafe {
2824 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1>())).hArray
2825 as *const _ as usize
2826 },
2827 0usize,
2828 concat!(
2829 "Offset of field: ",
2830 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1),
2831 "::",
2832 stringify!(hArray)
2833 )
2834 );
2835}
2836impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
2837 fn default() -> Self {
2838 unsafe { ::std::mem::zeroed() }
2839 }
2840}
2841#[repr(C)]
2842#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2843pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
2844 pub hMipmappedArray: CUmipmappedArray,
2845}
2846#[test]
2847fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2() {
2848 assert_eq!(
2849 ::std::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2>(),
2850 8usize,
2851 concat!(
2852 "Size of: ",
2853 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2)
2854 )
2855 );
2856 assert_eq!(
2857 ::std::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2>(),
2858 8usize,
2859 concat!(
2860 "Alignment of ",
2861 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2)
2862 )
2863 );
2864 assert_eq!(
2865 unsafe {
2866 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2>()))
2867 .hMipmappedArray as *const _ as usize
2868 },
2869 0usize,
2870 concat!(
2871 "Offset of field: ",
2872 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2),
2873 "::",
2874 stringify!(hMipmappedArray)
2875 )
2876 );
2877}
2878impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
2879 fn default() -> Self {
2880 unsafe { ::std::mem::zeroed() }
2881 }
2882}
2883#[repr(C)]
2884#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2885pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
2886 pub devPtr: CUdeviceptr,
2887 pub format: CUarray_format,
2888 pub numChannels: ::std::os::raw::c_uint,
2889 pub sizeInBytes: usize,
2890}
2891#[test]
2892fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3() {
2893 assert_eq!(
2894 ::std::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>(),
2895 24usize,
2896 concat!(
2897 "Size of: ",
2898 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3)
2899 )
2900 );
2901 assert_eq!(
2902 ::std::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>(),
2903 8usize,
2904 concat!(
2905 "Alignment of ",
2906 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3)
2907 )
2908 );
2909 assert_eq!(
2910 unsafe {
2911 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>())).devPtr
2912 as *const _ as usize
2913 },
2914 0usize,
2915 concat!(
2916 "Offset of field: ",
2917 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
2918 "::",
2919 stringify!(devPtr)
2920 )
2921 );
2922 assert_eq!(
2923 unsafe {
2924 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>())).format
2925 as *const _ as usize
2926 },
2927 8usize,
2928 concat!(
2929 "Offset of field: ",
2930 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
2931 "::",
2932 stringify!(format)
2933 )
2934 );
2935 assert_eq!(
2936 unsafe {
2937 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>()))
2938 .numChannels as *const _ as usize
2939 },
2940 12usize,
2941 concat!(
2942 "Offset of field: ",
2943 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
2944 "::",
2945 stringify!(numChannels)
2946 )
2947 );
2948 assert_eq!(
2949 unsafe {
2950 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>()))
2951 .sizeInBytes as *const _ as usize
2952 },
2953 16usize,
2954 concat!(
2955 "Offset of field: ",
2956 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
2957 "::",
2958 stringify!(sizeInBytes)
2959 )
2960 );
2961}
2962impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
2963 fn default() -> Self {
2964 unsafe { ::std::mem::zeroed() }
2965 }
2966}
2967#[repr(C)]
2968#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2969pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
2970 pub devPtr: CUdeviceptr,
2971 pub format: CUarray_format,
2972 pub numChannels: ::std::os::raw::c_uint,
2973 pub width: usize,
2974 pub height: usize,
2975 pub pitchInBytes: usize,
2976}
2977#[test]
2978fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4() {
2979 assert_eq!(
2980 ::std::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>(),
2981 40usize,
2982 concat!(
2983 "Size of: ",
2984 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4)
2985 )
2986 );
2987 assert_eq!(
2988 ::std::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>(),
2989 8usize,
2990 concat!(
2991 "Alignment of ",
2992 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4)
2993 )
2994 );
2995 assert_eq!(
2996 unsafe {
2997 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>())).devPtr
2998 as *const _ as usize
2999 },
3000 0usize,
3001 concat!(
3002 "Offset of field: ",
3003 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
3004 "::",
3005 stringify!(devPtr)
3006 )
3007 );
3008 assert_eq!(
3009 unsafe {
3010 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>())).format
3011 as *const _ as usize
3012 },
3013 8usize,
3014 concat!(
3015 "Offset of field: ",
3016 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
3017 "::",
3018 stringify!(format)
3019 )
3020 );
3021 assert_eq!(
3022 unsafe {
3023 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>()))
3024 .numChannels as *const _ as usize
3025 },
3026 12usize,
3027 concat!(
3028 "Offset of field: ",
3029 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
3030 "::",
3031 stringify!(numChannels)
3032 )
3033 );
3034 assert_eq!(
3035 unsafe {
3036 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>())).width
3037 as *const _ as usize
3038 },
3039 16usize,
3040 concat!(
3041 "Offset of field: ",
3042 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
3043 "::",
3044 stringify!(width)
3045 )
3046 );
3047 assert_eq!(
3048 unsafe {
3049 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>())).height
3050 as *const _ as usize
3051 },
3052 24usize,
3053 concat!(
3054 "Offset of field: ",
3055 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
3056 "::",
3057 stringify!(height)
3058 )
3059 );
3060 assert_eq!(
3061 unsafe {
3062 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>()))
3063 .pitchInBytes as *const _ as usize
3064 },
3065 32usize,
3066 concat!(
3067 "Offset of field: ",
3068 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
3069 "::",
3070 stringify!(pitchInBytes)
3071 )
3072 );
3073}
3074impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
3075 fn default() -> Self {
3076 unsafe { ::std::mem::zeroed() }
3077 }
3078}
3079#[repr(C)]
3080#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3081pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
3082 pub reserved: [::std::os::raw::c_int; 32usize],
3083}
3084#[test]
3085fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5() {
3086 assert_eq!(
3087 ::std::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5>(),
3088 128usize,
3089 concat!(
3090 "Size of: ",
3091 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5)
3092 )
3093 );
3094 assert_eq!(
3095 ::std::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5>(),
3096 4usize,
3097 concat!(
3098 "Alignment of ",
3099 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5)
3100 )
3101 );
3102 assert_eq!(
3103 unsafe {
3104 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5>())).reserved
3105 as *const _ as usize
3106 },
3107 0usize,
3108 concat!(
3109 "Offset of field: ",
3110 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5),
3111 "::",
3112 stringify!(reserved)
3113 )
3114 );
3115}
3116#[test]
3117fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1() {
3118 assert_eq!(
3119 ::std::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>(),
3120 128usize,
3121 concat!("Size of: ", stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1))
3122 );
3123 assert_eq!(
3124 ::std::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>(),
3125 8usize,
3126 concat!(
3127 "Alignment of ",
3128 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1)
3129 )
3130 );
3131 assert_eq!(
3132 unsafe {
3133 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>())).array as *const _
3134 as usize
3135 },
3136 0usize,
3137 concat!(
3138 "Offset of field: ",
3139 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
3140 "::",
3141 stringify!(array)
3142 )
3143 );
3144 assert_eq!(
3145 unsafe {
3146 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>())).mipmap as *const _
3147 as usize
3148 },
3149 0usize,
3150 concat!(
3151 "Offset of field: ",
3152 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
3153 "::",
3154 stringify!(mipmap)
3155 )
3156 );
3157 assert_eq!(
3158 unsafe {
3159 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>())).linear as *const _
3160 as usize
3161 },
3162 0usize,
3163 concat!(
3164 "Offset of field: ",
3165 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
3166 "::",
3167 stringify!(linear)
3168 )
3169 );
3170 assert_eq!(
3171 unsafe {
3172 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>())).pitch2D as *const _
3173 as usize
3174 },
3175 0usize,
3176 concat!(
3177 "Offset of field: ",
3178 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
3179 "::",
3180 stringify!(pitch2D)
3181 )
3182 );
3183 assert_eq!(
3184 unsafe {
3185 &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>())).reserved as *const _
3186 as usize
3187 },
3188 0usize,
3189 concat!(
3190 "Offset of field: ",
3191 stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
3192 "::",
3193 stringify!(reserved)
3194 )
3195 );
3196}
3197impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1 {
3198 fn default() -> Self {
3199 unsafe { ::std::mem::zeroed() }
3200 }
3201}
3202#[test]
3203fn bindgen_test_layout_CUDA_RESOURCE_DESC_st() {
3204 assert_eq!(
3205 ::std::mem::size_of::<CUDA_RESOURCE_DESC_st>(),
3206 144usize,
3207 concat!("Size of: ", stringify!(CUDA_RESOURCE_DESC_st))
3208 );
3209 assert_eq!(
3210 ::std::mem::align_of::<CUDA_RESOURCE_DESC_st>(),
3211 8usize,
3212 concat!("Alignment of ", stringify!(CUDA_RESOURCE_DESC_st))
3213 );
3214 assert_eq!(
3215 unsafe { &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st>())).resType as *const _ as usize },
3216 0usize,
3217 concat!(
3218 "Offset of field: ",
3219 stringify!(CUDA_RESOURCE_DESC_st),
3220 "::",
3221 stringify!(resType)
3222 )
3223 );
3224 assert_eq!(
3225 unsafe { &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st>())).res as *const _ as usize },
3226 8usize,
3227 concat!(
3228 "Offset of field: ",
3229 stringify!(CUDA_RESOURCE_DESC_st),
3230 "::",
3231 stringify!(res)
3232 )
3233 );
3234 assert_eq!(
3235 unsafe { &(*(::std::ptr::null::<CUDA_RESOURCE_DESC_st>())).flags as *const _ as usize },
3236 136usize,
3237 concat!(
3238 "Offset of field: ",
3239 stringify!(CUDA_RESOURCE_DESC_st),
3240 "::",
3241 stringify!(flags)
3242 )
3243 );
3244}
3245impl Default for CUDA_RESOURCE_DESC_st {
3246 fn default() -> Self {
3247 unsafe { ::std::mem::zeroed() }
3248 }
3249}
3250pub type CUDA_RESOURCE_DESC = CUDA_RESOURCE_DESC_st;
3251#[repr(C)]
3252#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
3253pub struct CUDA_TEXTURE_DESC_st {
3254 pub addressMode: [CUaddress_mode; 3usize],
3255 pub filterMode: CUfilter_mode,
3256 pub flags: ::std::os::raw::c_uint,
3257 pub maxAnisotropy: ::std::os::raw::c_uint,
3258 pub mipmapFilterMode: CUfilter_mode,
3259 pub mipmapLevelBias: f32,
3260 pub minMipmapLevelClamp: f32,
3261 pub maxMipmapLevelClamp: f32,
3262 pub borderColor: [f32; 4usize],
3263 pub reserved: [::std::os::raw::c_int; 12usize],
3264}
3265#[test]
3266fn bindgen_test_layout_CUDA_TEXTURE_DESC_st() {
3267 assert_eq!(
3268 ::std::mem::size_of::<CUDA_TEXTURE_DESC_st>(),
3269 104usize,
3270 concat!("Size of: ", stringify!(CUDA_TEXTURE_DESC_st))
3271 );
3272 assert_eq!(
3273 ::std::mem::align_of::<CUDA_TEXTURE_DESC_st>(),
3274 4usize,
3275 concat!("Alignment of ", stringify!(CUDA_TEXTURE_DESC_st))
3276 );
3277 assert_eq!(
3278 unsafe {
3279 &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).addressMode as *const _ as usize
3280 },
3281 0usize,
3282 concat!(
3283 "Offset of field: ",
3284 stringify!(CUDA_TEXTURE_DESC_st),
3285 "::",
3286 stringify!(addressMode)
3287 )
3288 );
3289 assert_eq!(
3290 unsafe { &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).filterMode as *const _ as usize },
3291 12usize,
3292 concat!(
3293 "Offset of field: ",
3294 stringify!(CUDA_TEXTURE_DESC_st),
3295 "::",
3296 stringify!(filterMode)
3297 )
3298 );
3299 assert_eq!(
3300 unsafe { &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).flags as *const _ as usize },
3301 16usize,
3302 concat!(
3303 "Offset of field: ",
3304 stringify!(CUDA_TEXTURE_DESC_st),
3305 "::",
3306 stringify!(flags)
3307 )
3308 );
3309 assert_eq!(
3310 unsafe {
3311 &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).maxAnisotropy as *const _ as usize
3312 },
3313 20usize,
3314 concat!(
3315 "Offset of field: ",
3316 stringify!(CUDA_TEXTURE_DESC_st),
3317 "::",
3318 stringify!(maxAnisotropy)
3319 )
3320 );
3321 assert_eq!(
3322 unsafe {
3323 &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).mipmapFilterMode as *const _ as usize
3324 },
3325 24usize,
3326 concat!(
3327 "Offset of field: ",
3328 stringify!(CUDA_TEXTURE_DESC_st),
3329 "::",
3330 stringify!(mipmapFilterMode)
3331 )
3332 );
3333 assert_eq!(
3334 unsafe {
3335 &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).mipmapLevelBias as *const _ as usize
3336 },
3337 28usize,
3338 concat!(
3339 "Offset of field: ",
3340 stringify!(CUDA_TEXTURE_DESC_st),
3341 "::",
3342 stringify!(mipmapLevelBias)
3343 )
3344 );
3345 assert_eq!(
3346 unsafe {
3347 &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).minMipmapLevelClamp as *const _
3348 as usize
3349 },
3350 32usize,
3351 concat!(
3352 "Offset of field: ",
3353 stringify!(CUDA_TEXTURE_DESC_st),
3354 "::",
3355 stringify!(minMipmapLevelClamp)
3356 )
3357 );
3358 assert_eq!(
3359 unsafe {
3360 &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).maxMipmapLevelClamp as *const _
3361 as usize
3362 },
3363 36usize,
3364 concat!(
3365 "Offset of field: ",
3366 stringify!(CUDA_TEXTURE_DESC_st),
3367 "::",
3368 stringify!(maxMipmapLevelClamp)
3369 )
3370 );
3371 assert_eq!(
3372 unsafe {
3373 &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).borderColor as *const _ as usize
3374 },
3375 40usize,
3376 concat!(
3377 "Offset of field: ",
3378 stringify!(CUDA_TEXTURE_DESC_st),
3379 "::",
3380 stringify!(borderColor)
3381 )
3382 );
3383 assert_eq!(
3384 unsafe { &(*(::std::ptr::null::<CUDA_TEXTURE_DESC_st>())).reserved as *const _ as usize },
3385 56usize,
3386 concat!(
3387 "Offset of field: ",
3388 stringify!(CUDA_TEXTURE_DESC_st),
3389 "::",
3390 stringify!(reserved)
3391 )
3392 );
3393}
3394impl Default for CUDA_TEXTURE_DESC_st {
3395 fn default() -> Self {
3396 unsafe { ::std::mem::zeroed() }
3397 }
3398}
3399pub type CUDA_TEXTURE_DESC = CUDA_TEXTURE_DESC_st;
3400#[repr(u32)]
3401#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
3402pub enum CUresourceViewFormat_enum {
3403 CU_RES_VIEW_FORMAT_NONE = 0,
3404 CU_RES_VIEW_FORMAT_UINT_1X8 = 1,
3405 CU_RES_VIEW_FORMAT_UINT_2X8 = 2,
3406 CU_RES_VIEW_FORMAT_UINT_4X8 = 3,
3407 CU_RES_VIEW_FORMAT_SINT_1X8 = 4,
3408 CU_RES_VIEW_FORMAT_SINT_2X8 = 5,
3409 CU_RES_VIEW_FORMAT_SINT_4X8 = 6,
3410 CU_RES_VIEW_FORMAT_UINT_1X16 = 7,
3411 CU_RES_VIEW_FORMAT_UINT_2X16 = 8,
3412 CU_RES_VIEW_FORMAT_UINT_4X16 = 9,
3413 CU_RES_VIEW_FORMAT_SINT_1X16 = 10,
3414 CU_RES_VIEW_FORMAT_SINT_2X16 = 11,
3415 CU_RES_VIEW_FORMAT_SINT_4X16 = 12,
3416 CU_RES_VIEW_FORMAT_UINT_1X32 = 13,
3417 CU_RES_VIEW_FORMAT_UINT_2X32 = 14,
3418 CU_RES_VIEW_FORMAT_UINT_4X32 = 15,
3419 CU_RES_VIEW_FORMAT_SINT_1X32 = 16,
3420 CU_RES_VIEW_FORMAT_SINT_2X32 = 17,
3421 CU_RES_VIEW_FORMAT_SINT_4X32 = 18,
3422 CU_RES_VIEW_FORMAT_FLOAT_1X16 = 19,
3423 CU_RES_VIEW_FORMAT_FLOAT_2X16 = 20,
3424 CU_RES_VIEW_FORMAT_FLOAT_4X16 = 21,
3425 CU_RES_VIEW_FORMAT_FLOAT_1X32 = 22,
3426 CU_RES_VIEW_FORMAT_FLOAT_2X32 = 23,
3427 CU_RES_VIEW_FORMAT_FLOAT_4X32 = 24,
3428 CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = 25,
3429 CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = 26,
3430 CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = 27,
3431 CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = 28,
3432 CU_RES_VIEW_FORMAT_SIGNED_BC4 = 29,
3433 CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = 30,
3434 CU_RES_VIEW_FORMAT_SIGNED_BC5 = 31,
3435 CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = 32,
3436 CU_RES_VIEW_FORMAT_SIGNED_BC6H = 33,
3437 CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = 34,
3438}
3439pub use self::CUresourceViewFormat_enum as CUresourceViewFormat;
3440#[repr(C)]
3441#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3442pub struct CUDA_RESOURCE_VIEW_DESC_st {
3443 pub format: CUresourceViewFormat,
3444 pub width: usize,
3445 pub height: usize,
3446 pub depth: usize,
3447 pub firstMipmapLevel: ::std::os::raw::c_uint,
3448 pub lastMipmapLevel: ::std::os::raw::c_uint,
3449 pub firstLayer: ::std::os::raw::c_uint,
3450 pub lastLayer: ::std::os::raw::c_uint,
3451 pub reserved: [::std::os::raw::c_uint; 16usize],
3452}
3453#[test]
3454fn bindgen_test_layout_CUDA_RESOURCE_VIEW_DESC_st() {
3455 assert_eq!(
3456 ::std::mem::size_of::<CUDA_RESOURCE_VIEW_DESC_st>(),
3457 112usize,
3458 concat!("Size of: ", stringify!(CUDA_RESOURCE_VIEW_DESC_st))
3459 );
3460 assert_eq!(
3461 ::std::mem::align_of::<CUDA_RESOURCE_VIEW_DESC_st>(),
3462 8usize,
3463 concat!("Alignment of ", stringify!(CUDA_RESOURCE_VIEW_DESC_st))
3464 );
3465 assert_eq!(
3466 unsafe {
3467 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).format as *const _ as usize
3468 },
3469 0usize,
3470 concat!(
3471 "Offset of field: ",
3472 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3473 "::",
3474 stringify!(format)
3475 )
3476 );
3477 assert_eq!(
3478 unsafe {
3479 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).width as *const _ as usize
3480 },
3481 8usize,
3482 concat!(
3483 "Offset of field: ",
3484 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3485 "::",
3486 stringify!(width)
3487 )
3488 );
3489 assert_eq!(
3490 unsafe {
3491 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).height as *const _ as usize
3492 },
3493 16usize,
3494 concat!(
3495 "Offset of field: ",
3496 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3497 "::",
3498 stringify!(height)
3499 )
3500 );
3501 assert_eq!(
3502 unsafe {
3503 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).depth as *const _ as usize
3504 },
3505 24usize,
3506 concat!(
3507 "Offset of field: ",
3508 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3509 "::",
3510 stringify!(depth)
3511 )
3512 );
3513 assert_eq!(
3514 unsafe {
3515 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).firstMipmapLevel as *const _
3516 as usize
3517 },
3518 32usize,
3519 concat!(
3520 "Offset of field: ",
3521 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3522 "::",
3523 stringify!(firstMipmapLevel)
3524 )
3525 );
3526 assert_eq!(
3527 unsafe {
3528 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).lastMipmapLevel as *const _
3529 as usize
3530 },
3531 36usize,
3532 concat!(
3533 "Offset of field: ",
3534 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3535 "::",
3536 stringify!(lastMipmapLevel)
3537 )
3538 );
3539 assert_eq!(
3540 unsafe {
3541 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).firstLayer as *const _ as usize
3542 },
3543 40usize,
3544 concat!(
3545 "Offset of field: ",
3546 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3547 "::",
3548 stringify!(firstLayer)
3549 )
3550 );
3551 assert_eq!(
3552 unsafe {
3553 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).lastLayer as *const _ as usize
3554 },
3555 44usize,
3556 concat!(
3557 "Offset of field: ",
3558 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3559 "::",
3560 stringify!(lastLayer)
3561 )
3562 );
3563 assert_eq!(
3564 unsafe {
3565 &(*(::std::ptr::null::<CUDA_RESOURCE_VIEW_DESC_st>())).reserved as *const _ as usize
3566 },
3567 48usize,
3568 concat!(
3569 "Offset of field: ",
3570 stringify!(CUDA_RESOURCE_VIEW_DESC_st),
3571 "::",
3572 stringify!(reserved)
3573 )
3574 );
3575}
3576impl Default for CUDA_RESOURCE_VIEW_DESC_st {
3577 fn default() -> Self {
3578 unsafe { ::std::mem::zeroed() }
3579 }
3580}
3581pub type CUDA_RESOURCE_VIEW_DESC = CUDA_RESOURCE_VIEW_DESC_st;
3582#[repr(C)]
3583#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3584pub struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st {
3585 pub p2pToken: ::std::os::raw::c_ulonglong,
3586 pub vaSpaceToken: ::std::os::raw::c_uint,
3587}
3588#[test]
3589fn bindgen_test_layout_CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st() {
3590 assert_eq!(
3591 ::std::mem::size_of::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>(),
3592 16usize,
3593 concat!(
3594 "Size of: ",
3595 stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st)
3596 )
3597 );
3598 assert_eq!(
3599 ::std::mem::align_of::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>(),
3600 8usize,
3601 concat!(
3602 "Alignment of ",
3603 stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st)
3604 )
3605 );
3606 assert_eq!(
3607 unsafe {
3608 &(*(::std::ptr::null::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>())).p2pToken as *const _
3609 as usize
3610 },
3611 0usize,
3612 concat!(
3613 "Offset of field: ",
3614 stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st),
3615 "::",
3616 stringify!(p2pToken)
3617 )
3618 );
3619 assert_eq!(
3620 unsafe {
3621 &(*(::std::ptr::null::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>())).vaSpaceToken
3622 as *const _ as usize
3623 },
3624 8usize,
3625 concat!(
3626 "Offset of field: ",
3627 stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st),
3628 "::",
3629 stringify!(vaSpaceToken)
3630 )
3631 );
3632}
3633pub type CUDA_POINTER_ATTRIBUTE_P2P_TOKENS = CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st;
3634#[repr(C)]
3635#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3636pub struct CUDA_LAUNCH_PARAMS_st {
3637 pub function: CUfunction,
3638 pub gridDimX: ::std::os::raw::c_uint,
3639 pub gridDimY: ::std::os::raw::c_uint,
3640 pub gridDimZ: ::std::os::raw::c_uint,
3641 pub blockDimX: ::std::os::raw::c_uint,
3642 pub blockDimY: ::std::os::raw::c_uint,
3643 pub blockDimZ: ::std::os::raw::c_uint,
3644 pub sharedMemBytes: ::std::os::raw::c_uint,
3645 pub hStream: CUstream,
3646 pub kernelParams: *mut *mut ::std::os::raw::c_void,
3647}
3648#[test]
3649fn bindgen_test_layout_CUDA_LAUNCH_PARAMS_st() {
3650 assert_eq!(
3651 ::std::mem::size_of::<CUDA_LAUNCH_PARAMS_st>(),
3652 56usize,
3653 concat!("Size of: ", stringify!(CUDA_LAUNCH_PARAMS_st))
3654 );
3655 assert_eq!(
3656 ::std::mem::align_of::<CUDA_LAUNCH_PARAMS_st>(),
3657 8usize,
3658 concat!("Alignment of ", stringify!(CUDA_LAUNCH_PARAMS_st))
3659 );
3660 assert_eq!(
3661 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).function as *const _ as usize },
3662 0usize,
3663 concat!(
3664 "Offset of field: ",
3665 stringify!(CUDA_LAUNCH_PARAMS_st),
3666 "::",
3667 stringify!(function)
3668 )
3669 );
3670 assert_eq!(
3671 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).gridDimX as *const _ as usize },
3672 8usize,
3673 concat!(
3674 "Offset of field: ",
3675 stringify!(CUDA_LAUNCH_PARAMS_st),
3676 "::",
3677 stringify!(gridDimX)
3678 )
3679 );
3680 assert_eq!(
3681 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).gridDimY as *const _ as usize },
3682 12usize,
3683 concat!(
3684 "Offset of field: ",
3685 stringify!(CUDA_LAUNCH_PARAMS_st),
3686 "::",
3687 stringify!(gridDimY)
3688 )
3689 );
3690 assert_eq!(
3691 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).gridDimZ as *const _ as usize },
3692 16usize,
3693 concat!(
3694 "Offset of field: ",
3695 stringify!(CUDA_LAUNCH_PARAMS_st),
3696 "::",
3697 stringify!(gridDimZ)
3698 )
3699 );
3700 assert_eq!(
3701 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).blockDimX as *const _ as usize },
3702 20usize,
3703 concat!(
3704 "Offset of field: ",
3705 stringify!(CUDA_LAUNCH_PARAMS_st),
3706 "::",
3707 stringify!(blockDimX)
3708 )
3709 );
3710 assert_eq!(
3711 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).blockDimY as *const _ as usize },
3712 24usize,
3713 concat!(
3714 "Offset of field: ",
3715 stringify!(CUDA_LAUNCH_PARAMS_st),
3716 "::",
3717 stringify!(blockDimY)
3718 )
3719 );
3720 assert_eq!(
3721 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).blockDimZ as *const _ as usize },
3722 28usize,
3723 concat!(
3724 "Offset of field: ",
3725 stringify!(CUDA_LAUNCH_PARAMS_st),
3726 "::",
3727 stringify!(blockDimZ)
3728 )
3729 );
3730 assert_eq!(
3731 unsafe {
3732 &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).sharedMemBytes as *const _ as usize
3733 },
3734 32usize,
3735 concat!(
3736 "Offset of field: ",
3737 stringify!(CUDA_LAUNCH_PARAMS_st),
3738 "::",
3739 stringify!(sharedMemBytes)
3740 )
3741 );
3742 assert_eq!(
3743 unsafe { &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).hStream as *const _ as usize },
3744 40usize,
3745 concat!(
3746 "Offset of field: ",
3747 stringify!(CUDA_LAUNCH_PARAMS_st),
3748 "::",
3749 stringify!(hStream)
3750 )
3751 );
3752 assert_eq!(
3753 unsafe {
3754 &(*(::std::ptr::null::<CUDA_LAUNCH_PARAMS_st>())).kernelParams as *const _ as usize
3755 },
3756 48usize,
3757 concat!(
3758 "Offset of field: ",
3759 stringify!(CUDA_LAUNCH_PARAMS_st),
3760 "::",
3761 stringify!(kernelParams)
3762 )
3763 );
3764}
3765impl Default for CUDA_LAUNCH_PARAMS_st {
3766 fn default() -> Self {
3767 unsafe { ::std::mem::zeroed() }
3768 }
3769}
3770pub type CUDA_LAUNCH_PARAMS = CUDA_LAUNCH_PARAMS_st;
3771#[repr(u32)]
3772#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
3773pub enum CUexternalMemoryHandleType_enum {
3774 CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = 1,
3775 CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 = 2,
3776 CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
3777 CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP = 4,
3778 CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE = 5,
3779 CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE = 6,
3780 CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT = 7,
3781 CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF = 8,
3782}
3783pub use self::CUexternalMemoryHandleType_enum as CUexternalMemoryHandleType;
3784#[repr(C)]
3785#[derive(Copy, Clone)]
3786pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
3787 pub type_: CUexternalMemoryHandleType,
3788 pub handle: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1,
3789 pub size: ::std::os::raw::c_ulonglong,
3790 pub flags: ::std::os::raw::c_uint,
3791 pub reserved: [::std::os::raw::c_uint; 16usize],
3792}
3793#[repr(C)]
3794#[derive(Copy, Clone)]
3795pub union CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1 {
3796 pub fd: ::std::os::raw::c_int,
3797 pub win32: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
3798 pub nvSciBufObject: *const ::std::os::raw::c_void,
3799 _bindgen_union_align: [u64; 2usize],
3800}
3801#[repr(C)]
3802#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3803pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
3804 pub handle: *mut ::std::os::raw::c_void,
3805 pub name: *const ::std::os::raw::c_void,
3806}
3807#[test]
3808fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1() {
3809 assert_eq!(
3810 ::std::mem::size_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
3811 16usize,
3812 concat!(
3813 "Size of: ",
3814 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
3815 )
3816 );
3817 assert_eq!(
3818 ::std::mem::align_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
3819 8usize,
3820 concat!(
3821 "Alignment of ",
3822 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
3823 )
3824 );
3825 assert_eq!(
3826 unsafe {
3827 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(
3828 )))
3829 .handle as *const _ as usize
3830 },
3831 0usize,
3832 concat!(
3833 "Offset of field: ",
3834 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
3835 "::",
3836 stringify!(handle)
3837 )
3838 );
3839 assert_eq!(
3840 unsafe {
3841 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(
3842 )))
3843 .name as *const _ as usize
3844 },
3845 8usize,
3846 concat!(
3847 "Offset of field: ",
3848 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
3849 "::",
3850 stringify!(name)
3851 )
3852 );
3853}
3854impl Default for CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
3855 fn default() -> Self {
3856 unsafe { ::std::mem::zeroed() }
3857 }
3858}
3859#[test]
3860fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1() {
3861 assert_eq!(
3862 ::std::mem::size_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1>(),
3863 16usize,
3864 concat!(
3865 "Size of: ",
3866 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1)
3867 )
3868 );
3869 assert_eq!(
3870 ::std::mem::align_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1>(),
3871 8usize,
3872 concat!(
3873 "Alignment of ",
3874 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1)
3875 )
3876 );
3877 assert_eq!(
3878 unsafe {
3879 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1>())).fd
3880 as *const _ as usize
3881 },
3882 0usize,
3883 concat!(
3884 "Offset of field: ",
3885 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1),
3886 "::",
3887 stringify!(fd)
3888 )
3889 );
3890 assert_eq!(
3891 unsafe {
3892 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1>())).win32
3893 as *const _ as usize
3894 },
3895 0usize,
3896 concat!(
3897 "Offset of field: ",
3898 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1),
3899 "::",
3900 stringify!(win32)
3901 )
3902 );
3903 assert_eq!(
3904 unsafe {
3905 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1>()))
3906 .nvSciBufObject as *const _ as usize
3907 },
3908 0usize,
3909 concat!(
3910 "Offset of field: ",
3911 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1),
3912 "::",
3913 stringify!(nvSciBufObject)
3914 )
3915 );
3916}
3917impl Default for CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1 {
3918 fn default() -> Self {
3919 unsafe { ::std::mem::zeroed() }
3920 }
3921}
3922#[test]
3923fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st() {
3924 assert_eq!(
3925 ::std::mem::size_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>(),
3926 104usize,
3927 concat!("Size of: ", stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st))
3928 );
3929 assert_eq!(
3930 ::std::mem::align_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>(),
3931 8usize,
3932 concat!(
3933 "Alignment of ",
3934 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st)
3935 )
3936 );
3937 assert_eq!(
3938 unsafe {
3939 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>())).type_ as *const _
3940 as usize
3941 },
3942 0usize,
3943 concat!(
3944 "Offset of field: ",
3945 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
3946 "::",
3947 stringify!(type_)
3948 )
3949 );
3950 assert_eq!(
3951 unsafe {
3952 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>())).handle as *const _
3953 as usize
3954 },
3955 8usize,
3956 concat!(
3957 "Offset of field: ",
3958 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
3959 "::",
3960 stringify!(handle)
3961 )
3962 );
3963 assert_eq!(
3964 unsafe {
3965 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>())).size as *const _
3966 as usize
3967 },
3968 24usize,
3969 concat!(
3970 "Offset of field: ",
3971 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
3972 "::",
3973 stringify!(size)
3974 )
3975 );
3976 assert_eq!(
3977 unsafe {
3978 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>())).flags as *const _
3979 as usize
3980 },
3981 32usize,
3982 concat!(
3983 "Offset of field: ",
3984 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
3985 "::",
3986 stringify!(flags)
3987 )
3988 );
3989 assert_eq!(
3990 unsafe {
3991 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>())).reserved as *const _
3992 as usize
3993 },
3994 36usize,
3995 concat!(
3996 "Offset of field: ",
3997 stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
3998 "::",
3999 stringify!(reserved)
4000 )
4001 );
4002}
4003impl Default for CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
4004 fn default() -> Self {
4005 unsafe { ::std::mem::zeroed() }
4006 }
4007}
4008pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st;
4009#[repr(C)]
4010#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4011pub struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st {
4012 pub offset: ::std::os::raw::c_ulonglong,
4013 pub size: ::std::os::raw::c_ulonglong,
4014 pub flags: ::std::os::raw::c_uint,
4015 pub reserved: [::std::os::raw::c_uint; 16usize],
4016}
4017#[test]
4018fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st() {
4019 assert_eq!(
4020 ::std::mem::size_of::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>(),
4021 88usize,
4022 concat!("Size of: ", stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st))
4023 );
4024 assert_eq!(
4025 ::std::mem::align_of::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>(),
4026 8usize,
4027 concat!(
4028 "Alignment of ",
4029 stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st)
4030 )
4031 );
4032 assert_eq!(
4033 unsafe {
4034 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>())).offset as *const _
4035 as usize
4036 },
4037 0usize,
4038 concat!(
4039 "Offset of field: ",
4040 stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
4041 "::",
4042 stringify!(offset)
4043 )
4044 );
4045 assert_eq!(
4046 unsafe {
4047 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>())).size as *const _
4048 as usize
4049 },
4050 8usize,
4051 concat!(
4052 "Offset of field: ",
4053 stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
4054 "::",
4055 stringify!(size)
4056 )
4057 );
4058 assert_eq!(
4059 unsafe {
4060 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>())).flags as *const _
4061 as usize
4062 },
4063 16usize,
4064 concat!(
4065 "Offset of field: ",
4066 stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
4067 "::",
4068 stringify!(flags)
4069 )
4070 );
4071 assert_eq!(
4072 unsafe {
4073 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>())).reserved as *const _
4074 as usize
4075 },
4076 20usize,
4077 concat!(
4078 "Offset of field: ",
4079 stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
4080 "::",
4081 stringify!(reserved)
4082 )
4083 );
4084}
4085pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st;
4086#[repr(C)]
4087#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4088pub struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
4089 pub offset: ::std::os::raw::c_ulonglong,
4090 pub arrayDesc: CUDA_ARRAY3D_DESCRIPTOR,
4091 pub numLevels: ::std::os::raw::c_uint,
4092 pub reserved: [::std::os::raw::c_uint; 16usize],
4093}
4094#[test]
4095fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st() {
4096 assert_eq!(
4097 ::std::mem::size_of::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>(),
4098 120usize,
4099 concat!(
4100 "Size of: ",
4101 stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st)
4102 )
4103 );
4104 assert_eq!(
4105 ::std::mem::align_of::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>(),
4106 8usize,
4107 concat!(
4108 "Alignment of ",
4109 stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st)
4110 )
4111 );
4112 assert_eq!(
4113 unsafe {
4114 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>())).offset
4115 as *const _ as usize
4116 },
4117 0usize,
4118 concat!(
4119 "Offset of field: ",
4120 stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
4121 "::",
4122 stringify!(offset)
4123 )
4124 );
4125 assert_eq!(
4126 unsafe {
4127 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>())).arrayDesc
4128 as *const _ as usize
4129 },
4130 8usize,
4131 concat!(
4132 "Offset of field: ",
4133 stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
4134 "::",
4135 stringify!(arrayDesc)
4136 )
4137 );
4138 assert_eq!(
4139 unsafe {
4140 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>())).numLevels
4141 as *const _ as usize
4142 },
4143 48usize,
4144 concat!(
4145 "Offset of field: ",
4146 stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
4147 "::",
4148 stringify!(numLevels)
4149 )
4150 );
4151 assert_eq!(
4152 unsafe {
4153 &(*(::std::ptr::null::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>())).reserved
4154 as *const _ as usize
4155 },
4156 52usize,
4157 concat!(
4158 "Offset of field: ",
4159 stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
4160 "::",
4161 stringify!(reserved)
4162 )
4163 );
4164}
4165impl Default for CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
4166 fn default() -> Self {
4167 unsafe { ::std::mem::zeroed() }
4168 }
4169}
4170pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC = CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st;
4171#[repr(u32)]
4172#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4173pub enum CUexternalSemaphoreHandleType_enum {
4174 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = 1,
4175 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = 2,
4176 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
4177 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE = 4,
4178 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE = 5,
4179 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC = 6,
4180 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX = 7,
4181 CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT = 8,
4182}
4183pub use self::CUexternalSemaphoreHandleType_enum as CUexternalSemaphoreHandleType;
4184#[repr(C)]
4185#[derive(Copy, Clone)]
4186pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
4187 pub type_: CUexternalSemaphoreHandleType,
4188 pub handle: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1,
4189 pub flags: ::std::os::raw::c_uint,
4190 pub reserved: [::std::os::raw::c_uint; 16usize],
4191}
4192#[repr(C)]
4193#[derive(Copy, Clone)]
4194pub union CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1 {
4195 pub fd: ::std::os::raw::c_int,
4196 pub win32: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
4197 pub nvSciSyncObj: *const ::std::os::raw::c_void,
4198 _bindgen_union_align: [u64; 2usize],
4199}
4200#[repr(C)]
4201#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4202pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
4203 pub handle: *mut ::std::os::raw::c_void,
4204 pub name: *const ::std::os::raw::c_void,
4205}
4206#[test]
4207fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1() {
4208 assert_eq!(
4209 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
4210 16usize,
4211 concat!(
4212 "Size of: ",
4213 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
4214 )
4215 );
4216 assert_eq!(
4217 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(
4218 ),
4219 8usize,
4220 concat!(
4221 "Alignment of ",
4222 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
4223 )
4224 );
4225 assert_eq!(
4226 unsafe {
4227 &(*(::std::ptr::null::<
4228 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
4229 >()))
4230 .handle as *const _ as usize
4231 },
4232 0usize,
4233 concat!(
4234 "Offset of field: ",
4235 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
4236 "::",
4237 stringify!(handle)
4238 )
4239 );
4240 assert_eq!(
4241 unsafe {
4242 &(*(::std::ptr::null::<
4243 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
4244 >()))
4245 .name as *const _ as usize
4246 },
4247 8usize,
4248 concat!(
4249 "Offset of field: ",
4250 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
4251 "::",
4252 stringify!(name)
4253 )
4254 );
4255}
4256impl Default for CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
4257 fn default() -> Self {
4258 unsafe { ::std::mem::zeroed() }
4259 }
4260}
4261#[test]
4262fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1() {
4263 assert_eq!(
4264 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1>(),
4265 16usize,
4266 concat!(
4267 "Size of: ",
4268 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1)
4269 )
4270 );
4271 assert_eq!(
4272 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1>(),
4273 8usize,
4274 concat!(
4275 "Alignment of ",
4276 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1)
4277 )
4278 );
4279 assert_eq!(
4280 unsafe {
4281 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1>())).fd
4282 as *const _ as usize
4283 },
4284 0usize,
4285 concat!(
4286 "Offset of field: ",
4287 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1),
4288 "::",
4289 stringify!(fd)
4290 )
4291 );
4292 assert_eq!(
4293 unsafe {
4294 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1>())).win32
4295 as *const _ as usize
4296 },
4297 0usize,
4298 concat!(
4299 "Offset of field: ",
4300 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1),
4301 "::",
4302 stringify!(win32)
4303 )
4304 );
4305 assert_eq!(
4306 unsafe {
4307 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1>()))
4308 .nvSciSyncObj as *const _ as usize
4309 },
4310 0usize,
4311 concat!(
4312 "Offset of field: ",
4313 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1),
4314 "::",
4315 stringify!(nvSciSyncObj)
4316 )
4317 );
4318}
4319impl Default for CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1 {
4320 fn default() -> Self {
4321 unsafe { ::std::mem::zeroed() }
4322 }
4323}
4324#[test]
4325fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st() {
4326 assert_eq!(
4327 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>(),
4328 96usize,
4329 concat!(
4330 "Size of: ",
4331 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st)
4332 )
4333 );
4334 assert_eq!(
4335 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>(),
4336 8usize,
4337 concat!(
4338 "Alignment of ",
4339 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st)
4340 )
4341 );
4342 assert_eq!(
4343 unsafe {
4344 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>())).type_ as *const _
4345 as usize
4346 },
4347 0usize,
4348 concat!(
4349 "Offset of field: ",
4350 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
4351 "::",
4352 stringify!(type_)
4353 )
4354 );
4355 assert_eq!(
4356 unsafe {
4357 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>())).handle as *const _
4358 as usize
4359 },
4360 8usize,
4361 concat!(
4362 "Offset of field: ",
4363 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
4364 "::",
4365 stringify!(handle)
4366 )
4367 );
4368 assert_eq!(
4369 unsafe {
4370 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>())).flags as *const _
4371 as usize
4372 },
4373 24usize,
4374 concat!(
4375 "Offset of field: ",
4376 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
4377 "::",
4378 stringify!(flags)
4379 )
4380 );
4381 assert_eq!(
4382 unsafe {
4383 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>())).reserved as *const _
4384 as usize
4385 },
4386 28usize,
4387 concat!(
4388 "Offset of field: ",
4389 stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
4390 "::",
4391 stringify!(reserved)
4392 )
4393 );
4394}
4395impl Default for CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
4396 fn default() -> Self {
4397 unsafe { ::std::mem::zeroed() }
4398 }
4399}
4400pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st;
4401#[repr(C)]
4402#[derive(Copy, Clone)]
4403pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st {
4404 pub params: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1,
4405 pub flags: ::std::os::raw::c_uint,
4406 pub reserved: [::std::os::raw::c_uint; 16usize],
4407}
4408#[repr(C)]
4409#[derive(Copy, Clone)]
4410pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1 {
4411 pub fence: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
4412 pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
4413 pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
4414 pub reserved: [::std::os::raw::c_uint; 12usize],
4415}
4416#[repr(C)]
4417#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4418pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1 {
4419 pub value: ::std::os::raw::c_ulonglong,
4420}
4421#[test]
4422fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1() {
4423 assert_eq!(
4424 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(
4425 ),
4426 8usize,
4427 concat!(
4428 "Size of: ",
4429 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
4430 )
4431 );
4432 assert_eq!(
4433 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(
4434 ),
4435 8usize,
4436 concat!(
4437 "Alignment of ",
4438 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
4439 )
4440 );
4441 assert_eq!(
4442 unsafe {
4443 &(*(::std::ptr::null::<
4444 CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
4445 >()))
4446 .value as *const _ as usize
4447 },
4448 0usize,
4449 concat!(
4450 "Offset of field: ",
4451 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1),
4452 "::",
4453 stringify!(value)
4454 )
4455 );
4456}
4457#[repr(C)]
4458#[derive(Copy, Clone)]
4459pub union CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
4460 pub fence: *mut ::std::os::raw::c_void,
4461 pub reserved: ::std::os::raw::c_ulonglong,
4462 _bindgen_union_align: u64,
4463}
4464#[test]
4465fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2() {
4466 assert_eq!(
4467 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(
4468 ),
4469 8usize,
4470 concat!(
4471 "Size of: ",
4472 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
4473 )
4474 );
4475 assert_eq!(
4476 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(
4477 ),
4478 8usize,
4479 concat!(
4480 "Alignment of ",
4481 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
4482 )
4483 );
4484 assert_eq!(
4485 unsafe {
4486 &(*(::std::ptr::null::<
4487 CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
4488 >()))
4489 .fence as *const _ as usize
4490 },
4491 0usize,
4492 concat!(
4493 "Offset of field: ",
4494 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
4495 "::",
4496 stringify!(fence)
4497 )
4498 );
4499 assert_eq!(
4500 unsafe {
4501 &(*(::std::ptr::null::<
4502 CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
4503 >()))
4504 .reserved as *const _ as usize
4505 },
4506 0usize,
4507 concat!(
4508 "Offset of field: ",
4509 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
4510 "::",
4511 stringify!(reserved)
4512 )
4513 );
4514}
4515impl Default for CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
4516 fn default() -> Self {
4517 unsafe { ::std::mem::zeroed() }
4518 }
4519}
4520#[repr(C)]
4521#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4522pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3 {
4523 pub key: ::std::os::raw::c_ulonglong,
4524}
4525#[test]
4526fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3() {
4527 assert_eq!(
4528 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(
4529 ),
4530 8usize,
4531 concat!(
4532 "Size of: ",
4533 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
4534 )
4535 );
4536 assert_eq!(
4537 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(
4538 ),
4539 8usize,
4540 concat!(
4541 "Alignment of ",
4542 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
4543 )
4544 );
4545 assert_eq!(
4546 unsafe {
4547 &(*(::std::ptr::null::<
4548 CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
4549 >()))
4550 .key as *const _ as usize
4551 },
4552 0usize,
4553 concat!(
4554 "Offset of field: ",
4555 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3),
4556 "::",
4557 stringify!(key)
4558 )
4559 );
4560}
4561#[test]
4562fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1() {
4563 assert_eq!(
4564 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>(),
4565 72usize,
4566 concat!(
4567 "Size of: ",
4568 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1)
4569 )
4570 );
4571 assert_eq!(
4572 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>(),
4573 8usize,
4574 concat!(
4575 "Alignment of ",
4576 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1)
4577 )
4578 );
4579 assert_eq!(
4580 unsafe {
4581 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>())).fence
4582 as *const _ as usize
4583 },
4584 0usize,
4585 concat!(
4586 "Offset of field: ",
4587 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
4588 "::",
4589 stringify!(fence)
4590 )
4591 );
4592 assert_eq!(
4593 unsafe {
4594 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>()))
4595 .nvSciSync as *const _ as usize
4596 },
4597 8usize,
4598 concat!(
4599 "Offset of field: ",
4600 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
4601 "::",
4602 stringify!(nvSciSync)
4603 )
4604 );
4605 assert_eq!(
4606 unsafe {
4607 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>()))
4608 .keyedMutex as *const _ as usize
4609 },
4610 16usize,
4611 concat!(
4612 "Offset of field: ",
4613 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
4614 "::",
4615 stringify!(keyedMutex)
4616 )
4617 );
4618 assert_eq!(
4619 unsafe {
4620 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>()))
4621 .reserved as *const _ as usize
4622 },
4623 24usize,
4624 concat!(
4625 "Offset of field: ",
4626 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
4627 "::",
4628 stringify!(reserved)
4629 )
4630 );
4631}
4632impl Default for CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1 {
4633 fn default() -> Self {
4634 unsafe { ::std::mem::zeroed() }
4635 }
4636}
4637#[test]
4638fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st() {
4639 assert_eq!(
4640 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>(),
4641 144usize,
4642 concat!(
4643 "Size of: ",
4644 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st)
4645 )
4646 );
4647 assert_eq!(
4648 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>(),
4649 8usize,
4650 concat!(
4651 "Alignment of ",
4652 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st)
4653 )
4654 );
4655 assert_eq!(
4656 unsafe {
4657 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>())).params as *const _
4658 as usize
4659 },
4660 0usize,
4661 concat!(
4662 "Offset of field: ",
4663 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st),
4664 "::",
4665 stringify!(params)
4666 )
4667 );
4668 assert_eq!(
4669 unsafe {
4670 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>())).flags as *const _
4671 as usize
4672 },
4673 72usize,
4674 concat!(
4675 "Offset of field: ",
4676 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st),
4677 "::",
4678 stringify!(flags)
4679 )
4680 );
4681 assert_eq!(
4682 unsafe {
4683 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>())).reserved
4684 as *const _ as usize
4685 },
4686 76usize,
4687 concat!(
4688 "Offset of field: ",
4689 stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st),
4690 "::",
4691 stringify!(reserved)
4692 )
4693 );
4694}
4695impl Default for CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st {
4696 fn default() -> Self {
4697 unsafe { ::std::mem::zeroed() }
4698 }
4699}
4700pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st;
4701#[repr(C)]
4702#[derive(Copy, Clone)]
4703pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st {
4704 pub params: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1,
4705 pub flags: ::std::os::raw::c_uint,
4706 pub reserved: [::std::os::raw::c_uint; 16usize],
4707}
4708#[repr(C)]
4709#[derive(Copy, Clone)]
4710pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1 {
4711 pub fence: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
4712 pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
4713 pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
4714 pub reserved: [::std::os::raw::c_uint; 10usize],
4715}
4716#[repr(C)]
4717#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4718pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1 {
4719 pub value: ::std::os::raw::c_ulonglong,
4720}
4721#[test]
4722fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1() {
4723 assert_eq!(
4724 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(),
4725 8usize,
4726 concat!(
4727 "Size of: ",
4728 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
4729 )
4730 );
4731 assert_eq!(
4732 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(
4733 ),
4734 8usize,
4735 concat!(
4736 "Alignment of ",
4737 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
4738 )
4739 );
4740 assert_eq!(
4741 unsafe {
4742 &(*(::std::ptr::null::<
4743 CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
4744 >()))
4745 .value as *const _ as usize
4746 },
4747 0usize,
4748 concat!(
4749 "Offset of field: ",
4750 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1),
4751 "::",
4752 stringify!(value)
4753 )
4754 );
4755}
4756#[repr(C)]
4757#[derive(Copy, Clone)]
4758pub union CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
4759 pub fence: *mut ::std::os::raw::c_void,
4760 pub reserved: ::std::os::raw::c_ulonglong,
4761 _bindgen_union_align: u64,
4762}
4763#[test]
4764fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2() {
4765 assert_eq!(
4766 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(),
4767 8usize,
4768 concat!(
4769 "Size of: ",
4770 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
4771 )
4772 );
4773 assert_eq!(
4774 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(
4775 ),
4776 8usize,
4777 concat!(
4778 "Alignment of ",
4779 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
4780 )
4781 );
4782 assert_eq!(
4783 unsafe {
4784 &(*(::std::ptr::null::<
4785 CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
4786 >()))
4787 .fence as *const _ as usize
4788 },
4789 0usize,
4790 concat!(
4791 "Offset of field: ",
4792 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
4793 "::",
4794 stringify!(fence)
4795 )
4796 );
4797 assert_eq!(
4798 unsafe {
4799 &(*(::std::ptr::null::<
4800 CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
4801 >()))
4802 .reserved as *const _ as usize
4803 },
4804 0usize,
4805 concat!(
4806 "Offset of field: ",
4807 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
4808 "::",
4809 stringify!(reserved)
4810 )
4811 );
4812}
4813impl Default for CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
4814 fn default() -> Self {
4815 unsafe { ::std::mem::zeroed() }
4816 }
4817}
4818#[repr(C)]
4819#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4820pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3 {
4821 pub key: ::std::os::raw::c_ulonglong,
4822 pub timeoutMs: ::std::os::raw::c_uint,
4823}
4824#[test]
4825fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3() {
4826 assert_eq!(
4827 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(),
4828 16usize,
4829 concat!(
4830 "Size of: ",
4831 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
4832 )
4833 );
4834 assert_eq!(
4835 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(
4836 ),
4837 8usize,
4838 concat!(
4839 "Alignment of ",
4840 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
4841 )
4842 );
4843 assert_eq!(
4844 unsafe {
4845 &(*(::std::ptr::null::<
4846 CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
4847 >()))
4848 .key as *const _ as usize
4849 },
4850 0usize,
4851 concat!(
4852 "Offset of field: ",
4853 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3),
4854 "::",
4855 stringify!(key)
4856 )
4857 );
4858 assert_eq!(
4859 unsafe {
4860 &(*(::std::ptr::null::<
4861 CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
4862 >()))
4863 .timeoutMs as *const _ as usize
4864 },
4865 8usize,
4866 concat!(
4867 "Offset of field: ",
4868 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3),
4869 "::",
4870 stringify!(timeoutMs)
4871 )
4872 );
4873}
4874#[test]
4875fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1() {
4876 assert_eq!(
4877 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>(),
4878 72usize,
4879 concat!(
4880 "Size of: ",
4881 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1)
4882 )
4883 );
4884 assert_eq!(
4885 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>(),
4886 8usize,
4887 concat!(
4888 "Alignment of ",
4889 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1)
4890 )
4891 );
4892 assert_eq!(
4893 unsafe {
4894 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>())).fence
4895 as *const _ as usize
4896 },
4897 0usize,
4898 concat!(
4899 "Offset of field: ",
4900 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
4901 "::",
4902 stringify!(fence)
4903 )
4904 );
4905 assert_eq!(
4906 unsafe {
4907 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>()))
4908 .nvSciSync as *const _ as usize
4909 },
4910 8usize,
4911 concat!(
4912 "Offset of field: ",
4913 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
4914 "::",
4915 stringify!(nvSciSync)
4916 )
4917 );
4918 assert_eq!(
4919 unsafe {
4920 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>()))
4921 .keyedMutex as *const _ as usize
4922 },
4923 16usize,
4924 concat!(
4925 "Offset of field: ",
4926 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
4927 "::",
4928 stringify!(keyedMutex)
4929 )
4930 );
4931 assert_eq!(
4932 unsafe {
4933 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>()))
4934 .reserved as *const _ as usize
4935 },
4936 32usize,
4937 concat!(
4938 "Offset of field: ",
4939 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
4940 "::",
4941 stringify!(reserved)
4942 )
4943 );
4944}
4945impl Default for CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1 {
4946 fn default() -> Self {
4947 unsafe { ::std::mem::zeroed() }
4948 }
4949}
4950#[test]
4951fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st() {
4952 assert_eq!(
4953 ::std::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>(),
4954 144usize,
4955 concat!(
4956 "Size of: ",
4957 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st)
4958 )
4959 );
4960 assert_eq!(
4961 ::std::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>(),
4962 8usize,
4963 concat!(
4964 "Alignment of ",
4965 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st)
4966 )
4967 );
4968 assert_eq!(
4969 unsafe {
4970 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>())).params as *const _
4971 as usize
4972 },
4973 0usize,
4974 concat!(
4975 "Offset of field: ",
4976 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st),
4977 "::",
4978 stringify!(params)
4979 )
4980 );
4981 assert_eq!(
4982 unsafe {
4983 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>())).flags as *const _
4984 as usize
4985 },
4986 72usize,
4987 concat!(
4988 "Offset of field: ",
4989 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st),
4990 "::",
4991 stringify!(flags)
4992 )
4993 );
4994 assert_eq!(
4995 unsafe {
4996 &(*(::std::ptr::null::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>())).reserved as *const _
4997 as usize
4998 },
4999 76usize,
5000 concat!(
5001 "Offset of field: ",
5002 stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st),
5003 "::",
5004 stringify!(reserved)
5005 )
5006 );
5007}
5008impl Default for CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st {
5009 fn default() -> Self {
5010 unsafe { ::std::mem::zeroed() }
5011 }
5012}
5013pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st;
5014pub type CUmemGenericAllocationHandle = ::std::os::raw::c_ulonglong;
5015#[repr(u32)]
5016#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
5017pub enum CUmemAllocationHandleType_enum {
5018 CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR = 1,
5019 CU_MEM_HANDLE_TYPE_WIN32 = 2,
5020 CU_MEM_HANDLE_TYPE_WIN32_KMT = 4,
5021 CU_MEM_HANDLE_TYPE_MAX = 4294967295,
5022}
5023pub use self::CUmemAllocationHandleType_enum as CUmemAllocationHandleType;
5024#[repr(u32)]
5025#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
5026pub enum CUmemAccess_flags_enum {
5027 CU_MEM_ACCESS_FLAGS_PROT_NONE = 0,
5028 CU_MEM_ACCESS_FLAGS_PROT_READ = 1,
5029 CU_MEM_ACCESS_FLAGS_PROT_READWRITE = 3,
5030 CU_MEM_ACCESS_FLAGS_PROT_MAX = 4294967295,
5031}
5032pub use self::CUmemAccess_flags_enum as CUmemAccess_flags;
5033#[repr(u32)]
5034#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
5035pub enum CUmemLocationType_enum {
5036 CU_MEM_LOCATION_TYPE_INVALID = 0,
5037 CU_MEM_LOCATION_TYPE_DEVICE = 1,
5038 CU_MEM_LOCATION_TYPE_MAX = 4294967295,
5039}
5040pub use self::CUmemLocationType_enum as CUmemLocationType;
5041#[repr(u32)]
5042#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
5043pub enum CUmemAllocationType_enum {
5044 CU_MEM_ALLOCATION_TYPE_INVALID = 0,
5045 CU_MEM_ALLOCATION_TYPE_PINNED = 1,
5046 CU_MEM_ALLOCATION_TYPE_MAX = 4294967295,
5047}
5048pub use self::CUmemAllocationType_enum as CUmemAllocationType;
5049#[repr(u32)]
5050#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
5051pub enum CUmemAllocationGranularity_flags_enum {
5052 CU_MEM_ALLOC_GRANULARITY_MINIMUM = 0,
5053 CU_MEM_ALLOC_GRANULARITY_RECOMMENDED = 1,
5054}
5055pub use self::CUmemAllocationGranularity_flags_enum as CUmemAllocationGranularity_flags;
5056#[repr(C)]
5057#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5058pub struct CUmemLocation_st {
5059 pub type_: CUmemLocationType,
5060 pub id: ::std::os::raw::c_int,
5061}
5062#[test]
5063fn bindgen_test_layout_CUmemLocation_st() {
5064 assert_eq!(
5065 ::std::mem::size_of::<CUmemLocation_st>(),
5066 8usize,
5067 concat!("Size of: ", stringify!(CUmemLocation_st))
5068 );
5069 assert_eq!(
5070 ::std::mem::align_of::<CUmemLocation_st>(),
5071 4usize,
5072 concat!("Alignment of ", stringify!(CUmemLocation_st))
5073 );
5074 assert_eq!(
5075 unsafe { &(*(::std::ptr::null::<CUmemLocation_st>())).type_ as *const _ as usize },
5076 0usize,
5077 concat!(
5078 "Offset of field: ",
5079 stringify!(CUmemLocation_st),
5080 "::",
5081 stringify!(type_)
5082 )
5083 );
5084 assert_eq!(
5085 unsafe { &(*(::std::ptr::null::<CUmemLocation_st>())).id as *const _ as usize },
5086 4usize,
5087 concat!(
5088 "Offset of field: ",
5089 stringify!(CUmemLocation_st),
5090 "::",
5091 stringify!(id)
5092 )
5093 );
5094}
5095impl Default for CUmemLocation_st {
5096 fn default() -> Self {
5097 unsafe { ::std::mem::zeroed() }
5098 }
5099}
5100pub type CUmemLocation = CUmemLocation_st;
5101#[repr(C)]
5102#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5103pub struct CUmemAllocationProp_st {
5104 pub type_: CUmemAllocationType,
5105 pub requestedHandleTypes: CUmemAllocationHandleType,
5106 pub location: CUmemLocation,
5107 pub win32HandleMetaData: *mut ::std::os::raw::c_void,
5108 pub reserved: ::std::os::raw::c_ulonglong,
5109}
5110#[test]
5111fn bindgen_test_layout_CUmemAllocationProp_st() {
5112 assert_eq!(
5113 ::std::mem::size_of::<CUmemAllocationProp_st>(),
5114 32usize,
5115 concat!("Size of: ", stringify!(CUmemAllocationProp_st))
5116 );
5117 assert_eq!(
5118 ::std::mem::align_of::<CUmemAllocationProp_st>(),
5119 8usize,
5120 concat!("Alignment of ", stringify!(CUmemAllocationProp_st))
5121 );
5122 assert_eq!(
5123 unsafe { &(*(::std::ptr::null::<CUmemAllocationProp_st>())).type_ as *const _ as usize },
5124 0usize,
5125 concat!(
5126 "Offset of field: ",
5127 stringify!(CUmemAllocationProp_st),
5128 "::",
5129 stringify!(type_)
5130 )
5131 );
5132 assert_eq!(
5133 unsafe {
5134 &(*(::std::ptr::null::<CUmemAllocationProp_st>())).requestedHandleTypes as *const _
5135 as usize
5136 },
5137 4usize,
5138 concat!(
5139 "Offset of field: ",
5140 stringify!(CUmemAllocationProp_st),
5141 "::",
5142 stringify!(requestedHandleTypes)
5143 )
5144 );
5145 assert_eq!(
5146 unsafe { &(*(::std::ptr::null::<CUmemAllocationProp_st>())).location as *const _ as usize },
5147 8usize,
5148 concat!(
5149 "Offset of field: ",
5150 stringify!(CUmemAllocationProp_st),
5151 "::",
5152 stringify!(location)
5153 )
5154 );
5155 assert_eq!(
5156 unsafe {
5157 &(*(::std::ptr::null::<CUmemAllocationProp_st>())).win32HandleMetaData as *const _
5158 as usize
5159 },
5160 16usize,
5161 concat!(
5162 "Offset of field: ",
5163 stringify!(CUmemAllocationProp_st),
5164 "::",
5165 stringify!(win32HandleMetaData)
5166 )
5167 );
5168 assert_eq!(
5169 unsafe { &(*(::std::ptr::null::<CUmemAllocationProp_st>())).reserved as *const _ as usize },
5170 24usize,
5171 concat!(
5172 "Offset of field: ",
5173 stringify!(CUmemAllocationProp_st),
5174 "::",
5175 stringify!(reserved)
5176 )
5177 );
5178}
5179impl Default for CUmemAllocationProp_st {
5180 fn default() -> Self {
5181 unsafe { ::std::mem::zeroed() }
5182 }
5183}
5184pub type CUmemAllocationProp = CUmemAllocationProp_st;
5185#[repr(C)]
5186#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5187pub struct CUmemAccessDesc_st {
5188 pub location: CUmemLocation,
5189 pub flags: CUmemAccess_flags,
5190}
5191#[test]
5192fn bindgen_test_layout_CUmemAccessDesc_st() {
5193 assert_eq!(
5194 ::std::mem::size_of::<CUmemAccessDesc_st>(),
5195 12usize,
5196 concat!("Size of: ", stringify!(CUmemAccessDesc_st))
5197 );
5198 assert_eq!(
5199 ::std::mem::align_of::<CUmemAccessDesc_st>(),
5200 4usize,
5201 concat!("Alignment of ", stringify!(CUmemAccessDesc_st))
5202 );
5203 assert_eq!(
5204 unsafe { &(*(::std::ptr::null::<CUmemAccessDesc_st>())).location as *const _ as usize },
5205 0usize,
5206 concat!(
5207 "Offset of field: ",
5208 stringify!(CUmemAccessDesc_st),
5209 "::",
5210 stringify!(location)
5211 )
5212 );
5213 assert_eq!(
5214 unsafe { &(*(::std::ptr::null::<CUmemAccessDesc_st>())).flags as *const _ as usize },
5215 8usize,
5216 concat!(
5217 "Offset of field: ",
5218 stringify!(CUmemAccessDesc_st),
5219 "::",
5220 stringify!(flags)
5221 )
5222 );
5223}
5224impl Default for CUmemAccessDesc_st {
5225 fn default() -> Self {
5226 unsafe { ::std::mem::zeroed() }
5227 }
5228}
5229pub type CUmemAccessDesc = CUmemAccessDesc_st;
5230#[repr(u32)]
5231#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
5232pub enum CUgraphExecUpdateResult_enum {
5233 CU_GRAPH_EXEC_UPDATE_SUCCESS = 0,
5234 CU_GRAPH_EXEC_UPDATE_ERROR = 1,
5235 CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED = 2,
5236 CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED = 3,
5237 CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED = 4,
5238 CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED = 5,
5239 CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED = 6,
5240}
5241pub use self::CUgraphExecUpdateResult_enum as CUgraphExecUpdateResult;
5242extern "C" {
5243 pub fn cuGetErrorString(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult;
5244}
5245extern "C" {
5246 pub fn cuGetErrorName(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult;
5247}
5248extern "C" {
5249 pub fn cuInit(Flags: ::std::os::raw::c_uint) -> CUresult;
5250}
5251extern "C" {
5252 pub fn cuDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> CUresult;
5253}
5254extern "C" {
5255 pub fn cuDeviceGet(device: *mut CUdevice, ordinal: ::std::os::raw::c_int) -> CUresult;
5256}
5257extern "C" {
5258 pub fn cuDeviceGetCount(count: *mut ::std::os::raw::c_int) -> CUresult;
5259}
5260extern "C" {
5261 pub fn cuDeviceGetName(
5262 name: *mut ::std::os::raw::c_char,
5263 len: ::std::os::raw::c_int,
5264 dev: CUdevice,
5265 ) -> CUresult;
5266}
5267extern "C" {
5268 pub fn cuDeviceGetUuid(uuid: *mut CUuuid, dev: CUdevice) -> CUresult;
5269}
5270extern "C" {
5271 pub fn cuDeviceTotalMem_v2(bytes: *mut usize, dev: CUdevice) -> CUresult;
5272}
5273extern "C" {
5274 pub fn cuDeviceGetAttribute(
5275 pi: *mut ::std::os::raw::c_int,
5276 attrib: CUdevice_attribute,
5277 dev: CUdevice,
5278 ) -> CUresult;
5279}
5280extern "C" {
5281 pub fn cuDeviceGetNvSciSyncAttributes(
5282 nvSciSyncAttrList: *mut ::std::os::raw::c_void,
5283 dev: CUdevice,
5284 flags: ::std::os::raw::c_int,
5285 ) -> CUresult;
5286}
5287extern "C" {
5288 pub fn cuDeviceGetProperties(prop: *mut CUdevprop, dev: CUdevice) -> CUresult;
5289}
5290extern "C" {
5291 pub fn cuDeviceComputeCapability(
5292 major: *mut ::std::os::raw::c_int,
5293 minor: *mut ::std::os::raw::c_int,
5294 dev: CUdevice,
5295 ) -> CUresult;
5296}
5297extern "C" {
5298 pub fn cuDevicePrimaryCtxRetain(pctx: *mut CUcontext, dev: CUdevice) -> CUresult;
5299}
5300extern "C" {
5301 pub fn cuDevicePrimaryCtxRelease(dev: CUdevice) -> CUresult;
5302}
5303extern "C" {
5304 pub fn cuDevicePrimaryCtxSetFlags(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult;
5305}
5306extern "C" {
5307 pub fn cuDevicePrimaryCtxGetState(
5308 dev: CUdevice,
5309 flags: *mut ::std::os::raw::c_uint,
5310 active: *mut ::std::os::raw::c_int,
5311 ) -> CUresult;
5312}
5313extern "C" {
5314 pub fn cuDevicePrimaryCtxReset(dev: CUdevice) -> CUresult;
5315}
5316extern "C" {
5317 pub fn cuCtxCreate_v2(
5318 pctx: *mut CUcontext,
5319 flags: ::std::os::raw::c_uint,
5320 dev: CUdevice,
5321 ) -> CUresult;
5322}
5323extern "C" {
5324 pub fn cuCtxDestroy_v2(ctx: CUcontext) -> CUresult;
5325}
5326extern "C" {
5327 pub fn cuCtxPushCurrent_v2(ctx: CUcontext) -> CUresult;
5328}
5329extern "C" {
5330 pub fn cuCtxPopCurrent_v2(pctx: *mut CUcontext) -> CUresult;
5331}
5332extern "C" {
5333 pub fn cuCtxSetCurrent(ctx: CUcontext) -> CUresult;
5334}
5335extern "C" {
5336 pub fn cuCtxGetCurrent(pctx: *mut CUcontext) -> CUresult;
5337}
5338extern "C" {
5339 pub fn cuCtxGetDevice(device: *mut CUdevice) -> CUresult;
5340}
5341extern "C" {
5342 pub fn cuCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> CUresult;
5343}
5344extern "C" {
5345 pub fn cuCtxSynchronize() -> CUresult;
5346}
5347extern "C" {
5348 pub fn cuCtxSetLimit(limit: CUlimit, value: usize) -> CUresult;
5349}
5350extern "C" {
5351 pub fn cuCtxGetLimit(pvalue: *mut usize, limit: CUlimit) -> CUresult;
5352}
5353extern "C" {
5354 pub fn cuCtxGetCacheConfig(pconfig: *mut CUfunc_cache) -> CUresult;
5355}
5356extern "C" {
5357 pub fn cuCtxSetCacheConfig(config: CUfunc_cache) -> CUresult;
5358}
5359extern "C" {
5360 pub fn cuCtxGetSharedMemConfig(pConfig: *mut CUsharedconfig) -> CUresult;
5361}
5362extern "C" {
5363 pub fn cuCtxSetSharedMemConfig(config: CUsharedconfig) -> CUresult;
5364}
5365extern "C" {
5366 pub fn cuCtxGetApiVersion(ctx: CUcontext, version: *mut ::std::os::raw::c_uint) -> CUresult;
5367}
5368extern "C" {
5369 pub fn cuCtxGetStreamPriorityRange(
5370 leastPriority: *mut ::std::os::raw::c_int,
5371 greatestPriority: *mut ::std::os::raw::c_int,
5372 ) -> CUresult;
5373}
5374extern "C" {
5375 pub fn cuCtxAttach(pctx: *mut CUcontext, flags: ::std::os::raw::c_uint) -> CUresult;
5376}
5377extern "C" {
5378 pub fn cuCtxDetach(ctx: CUcontext) -> CUresult;
5379}
5380extern "C" {
5381 pub fn cuModuleLoad(module: *mut CUmodule, fname: *const ::std::os::raw::c_char) -> CUresult;
5382}
5383extern "C" {
5384 pub fn cuModuleLoadData(
5385 module: *mut CUmodule,
5386 image: *const ::std::os::raw::c_void,
5387 ) -> CUresult;
5388}
5389extern "C" {
5390 pub fn cuModuleLoadDataEx(
5391 module: *mut CUmodule,
5392 image: *const ::std::os::raw::c_void,
5393 numOptions: ::std::os::raw::c_uint,
5394 options: *mut CUjit_option,
5395 optionValues: *mut *mut ::std::os::raw::c_void,
5396 ) -> CUresult;
5397}
5398extern "C" {
5399 pub fn cuModuleLoadFatBinary(
5400 module: *mut CUmodule,
5401 fatCubin: *const ::std::os::raw::c_void,
5402 ) -> CUresult;
5403}
5404extern "C" {
5405 pub fn cuModuleUnload(hmod: CUmodule) -> CUresult;
5406}
5407extern "C" {
5408 pub fn cuModuleGetFunction(
5409 hfunc: *mut CUfunction,
5410 hmod: CUmodule,
5411 name: *const ::std::os::raw::c_char,
5412 ) -> CUresult;
5413}
5414extern "C" {
5415 pub fn cuModuleGetGlobal_v2(
5416 dptr: *mut CUdeviceptr,
5417 bytes: *mut usize,
5418 hmod: CUmodule,
5419 name: *const ::std::os::raw::c_char,
5420 ) -> CUresult;
5421}
5422extern "C" {
5423 pub fn cuModuleGetTexRef(
5424 pTexRef: *mut CUtexref,
5425 hmod: CUmodule,
5426 name: *const ::std::os::raw::c_char,
5427 ) -> CUresult;
5428}
5429extern "C" {
5430 pub fn cuModuleGetSurfRef(
5431 pSurfRef: *mut CUsurfref,
5432 hmod: CUmodule,
5433 name: *const ::std::os::raw::c_char,
5434 ) -> CUresult;
5435}
5436extern "C" {
5437 pub fn cuLinkCreate_v2(
5438 numOptions: ::std::os::raw::c_uint,
5439 options: *mut CUjit_option,
5440 optionValues: *mut *mut ::std::os::raw::c_void,
5441 stateOut: *mut CUlinkState,
5442 ) -> CUresult;
5443}
5444extern "C" {
5445 pub fn cuLinkAddData_v2(
5446 state: CUlinkState,
5447 type_: CUjitInputType,
5448 data: *mut ::std::os::raw::c_void,
5449 size: usize,
5450 name: *const ::std::os::raw::c_char,
5451 numOptions: ::std::os::raw::c_uint,
5452 options: *mut CUjit_option,
5453 optionValues: *mut *mut ::std::os::raw::c_void,
5454 ) -> CUresult;
5455}
5456extern "C" {
5457 pub fn cuLinkAddFile_v2(
5458 state: CUlinkState,
5459 type_: CUjitInputType,
5460 path: *const ::std::os::raw::c_char,
5461 numOptions: ::std::os::raw::c_uint,
5462 options: *mut CUjit_option,
5463 optionValues: *mut *mut ::std::os::raw::c_void,
5464 ) -> CUresult;
5465}
5466extern "C" {
5467 pub fn cuLinkComplete(
5468 state: CUlinkState,
5469 cubinOut: *mut *mut ::std::os::raw::c_void,
5470 sizeOut: *mut usize,
5471 ) -> CUresult;
5472}
5473extern "C" {
5474 pub fn cuLinkDestroy(state: CUlinkState) -> CUresult;
5475}
5476extern "C" {
5477 pub fn cuMemGetInfo_v2(free: *mut usize, total: *mut usize) -> CUresult;
5478}
5479extern "C" {
5480 pub fn cuMemAlloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult;
5481}
5482extern "C" {
5483 pub fn cuMemAllocPitch_v2(
5484 dptr: *mut CUdeviceptr,
5485 pPitch: *mut usize,
5486 WidthInBytes: usize,
5487 Height: usize,
5488 ElementSizeBytes: ::std::os::raw::c_uint,
5489 ) -> CUresult;
5490}
5491extern "C" {
5492 pub fn cuMemFree_v2(dptr: CUdeviceptr) -> CUresult;
5493}
5494extern "C" {
5495 pub fn cuMemGetAddressRange_v2(
5496 pbase: *mut CUdeviceptr,
5497 psize: *mut usize,
5498 dptr: CUdeviceptr,
5499 ) -> CUresult;
5500}
5501extern "C" {
5502 pub fn cuMemAllocHost_v2(pp: *mut *mut ::std::os::raw::c_void, bytesize: usize) -> CUresult;
5503}
5504extern "C" {
5505 pub fn cuMemFreeHost(p: *mut ::std::os::raw::c_void) -> CUresult;
5506}
5507extern "C" {
5508 pub fn cuMemHostAlloc(
5509 pp: *mut *mut ::std::os::raw::c_void,
5510 bytesize: usize,
5511 Flags: ::std::os::raw::c_uint,
5512 ) -> CUresult;
5513}
5514extern "C" {
5515 pub fn cuMemHostGetDevicePointer_v2(
5516 pdptr: *mut CUdeviceptr,
5517 p: *mut ::std::os::raw::c_void,
5518 Flags: ::std::os::raw::c_uint,
5519 ) -> CUresult;
5520}
5521extern "C" {
5522 pub fn cuMemHostGetFlags(
5523 pFlags: *mut ::std::os::raw::c_uint,
5524 p: *mut ::std::os::raw::c_void,
5525 ) -> CUresult;
5526}
5527extern "C" {
5528 pub fn cuMemAllocManaged(
5529 dptr: *mut CUdeviceptr,
5530 bytesize: usize,
5531 flags: ::std::os::raw::c_uint,
5532 ) -> CUresult;
5533}
5534extern "C" {
5535 pub fn cuDeviceGetByPCIBusId(
5536 dev: *mut CUdevice,
5537 pciBusId: *const ::std::os::raw::c_char,
5538 ) -> CUresult;
5539}
5540extern "C" {
5541 pub fn cuDeviceGetPCIBusId(
5542 pciBusId: *mut ::std::os::raw::c_char,
5543 len: ::std::os::raw::c_int,
5544 dev: CUdevice,
5545 ) -> CUresult;
5546}
5547extern "C" {
5548 pub fn cuIpcGetEventHandle(pHandle: *mut CUipcEventHandle, event: CUevent) -> CUresult;
5549}
5550extern "C" {
5551 pub fn cuIpcOpenEventHandle(phEvent: *mut CUevent, handle: CUipcEventHandle) -> CUresult;
5552}
5553extern "C" {
5554 pub fn cuIpcGetMemHandle(pHandle: *mut CUipcMemHandle, dptr: CUdeviceptr) -> CUresult;
5555}
5556extern "C" {
5557 pub fn cuIpcOpenMemHandle(
5558 pdptr: *mut CUdeviceptr,
5559 handle: CUipcMemHandle,
5560 Flags: ::std::os::raw::c_uint,
5561 ) -> CUresult;
5562}
5563extern "C" {
5564 pub fn cuIpcCloseMemHandle(dptr: CUdeviceptr) -> CUresult;
5565}
5566extern "C" {
5567 pub fn cuMemHostRegister_v2(
5568 p: *mut ::std::os::raw::c_void,
5569 bytesize: usize,
5570 Flags: ::std::os::raw::c_uint,
5571 ) -> CUresult;
5572}
5573extern "C" {
5574 pub fn cuMemHostUnregister(p: *mut ::std::os::raw::c_void) -> CUresult;
5575}
5576extern "C" {
5577 pub fn cuMemcpy(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult;
5578}
5579extern "C" {
5580 pub fn cuMemcpyPeer(
5581 dstDevice: CUdeviceptr,
5582 dstContext: CUcontext,
5583 srcDevice: CUdeviceptr,
5584 srcContext: CUcontext,
5585 ByteCount: usize,
5586 ) -> CUresult;
5587}
5588extern "C" {
5589 pub fn cuMemcpyHtoD_v2(
5590 dstDevice: CUdeviceptr,
5591 srcHost: *const ::std::os::raw::c_void,
5592 ByteCount: usize,
5593 ) -> CUresult;
5594}
5595extern "C" {
5596 pub fn cuMemcpyDtoH_v2(
5597 dstHost: *mut ::std::os::raw::c_void,
5598 srcDevice: CUdeviceptr,
5599 ByteCount: usize,
5600 ) -> CUresult;
5601}
5602extern "C" {
5603 pub fn cuMemcpyDtoD_v2(
5604 dstDevice: CUdeviceptr,
5605 srcDevice: CUdeviceptr,
5606 ByteCount: usize,
5607 ) -> CUresult;
5608}
5609extern "C" {
5610 pub fn cuMemcpyDtoA_v2(
5611 dstArray: CUarray,
5612 dstOffset: usize,
5613 srcDevice: CUdeviceptr,
5614 ByteCount: usize,
5615 ) -> CUresult;
5616}
5617extern "C" {
5618 pub fn cuMemcpyAtoD_v2(
5619 dstDevice: CUdeviceptr,
5620 srcArray: CUarray,
5621 srcOffset: usize,
5622 ByteCount: usize,
5623 ) -> CUresult;
5624}
5625extern "C" {
5626 pub fn cuMemcpyHtoA_v2(
5627 dstArray: CUarray,
5628 dstOffset: usize,
5629 srcHost: *const ::std::os::raw::c_void,
5630 ByteCount: usize,
5631 ) -> CUresult;
5632}
5633extern "C" {
5634 pub fn cuMemcpyAtoH_v2(
5635 dstHost: *mut ::std::os::raw::c_void,
5636 srcArray: CUarray,
5637 srcOffset: usize,
5638 ByteCount: usize,
5639 ) -> CUresult;
5640}
5641extern "C" {
5642 pub fn cuMemcpyAtoA_v2(
5643 dstArray: CUarray,
5644 dstOffset: usize,
5645 srcArray: CUarray,
5646 srcOffset: usize,
5647 ByteCount: usize,
5648 ) -> CUresult;
5649}
5650extern "C" {
5651 pub fn cuMemcpy2D_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
5652}
5653extern "C" {
5654 pub fn cuMemcpy2DUnaligned_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
5655}
5656extern "C" {
5657 pub fn cuMemcpy3D_v2(pCopy: *const CUDA_MEMCPY3D) -> CUresult;
5658}
5659extern "C" {
5660 pub fn cuMemcpy3DPeer(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult;
5661}
5662extern "C" {
5663 pub fn cuMemcpyAsync(
5664 dst: CUdeviceptr,
5665 src: CUdeviceptr,
5666 ByteCount: usize,
5667 hStream: CUstream,
5668 ) -> CUresult;
5669}
5670extern "C" {
5671 pub fn cuMemcpyPeerAsync(
5672 dstDevice: CUdeviceptr,
5673 dstContext: CUcontext,
5674 srcDevice: CUdeviceptr,
5675 srcContext: CUcontext,
5676 ByteCount: usize,
5677 hStream: CUstream,
5678 ) -> CUresult;
5679}
5680extern "C" {
5681 pub fn cuMemcpyHtoDAsync_v2(
5682 dstDevice: CUdeviceptr,
5683 srcHost: *const ::std::os::raw::c_void,
5684 ByteCount: usize,
5685 hStream: CUstream,
5686 ) -> CUresult;
5687}
5688extern "C" {
5689 pub fn cuMemcpyDtoHAsync_v2(
5690 dstHost: *mut ::std::os::raw::c_void,
5691 srcDevice: CUdeviceptr,
5692 ByteCount: usize,
5693 hStream: CUstream,
5694 ) -> CUresult;
5695}
5696extern "C" {
5697 pub fn cuMemcpyDtoDAsync_v2(
5698 dstDevice: CUdeviceptr,
5699 srcDevice: CUdeviceptr,
5700 ByteCount: usize,
5701 hStream: CUstream,
5702 ) -> CUresult;
5703}
5704extern "C" {
5705 pub fn cuMemcpyHtoAAsync_v2(
5706 dstArray: CUarray,
5707 dstOffset: usize,
5708 srcHost: *const ::std::os::raw::c_void,
5709 ByteCount: usize,
5710 hStream: CUstream,
5711 ) -> CUresult;
5712}
5713extern "C" {
5714 pub fn cuMemcpyAtoHAsync_v2(
5715 dstHost: *mut ::std::os::raw::c_void,
5716 srcArray: CUarray,
5717 srcOffset: usize,
5718 ByteCount: usize,
5719 hStream: CUstream,
5720 ) -> CUresult;
5721}
5722extern "C" {
5723 pub fn cuMemcpy2DAsync_v2(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult;
5724}
5725extern "C" {
5726 pub fn cuMemcpy3DAsync_v2(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult;
5727}
5728extern "C" {
5729 pub fn cuMemcpy3DPeerAsync(pCopy: *const CUDA_MEMCPY3D_PEER, hStream: CUstream) -> CUresult;
5730}
5731extern "C" {
5732 pub fn cuMemsetD8_v2(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize)
5733 -> CUresult;
5734}
5735extern "C" {
5736 pub fn cuMemsetD16_v2(
5737 dstDevice: CUdeviceptr,
5738 us: ::std::os::raw::c_ushort,
5739 N: usize,
5740 ) -> CUresult;
5741}
5742extern "C" {
5743 pub fn cuMemsetD32_v2(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize)
5744 -> CUresult;
5745}
5746extern "C" {
5747 pub fn cuMemsetD2D8_v2(
5748 dstDevice: CUdeviceptr,
5749 dstPitch: usize,
5750 uc: ::std::os::raw::c_uchar,
5751 Width: usize,
5752 Height: usize,
5753 ) -> CUresult;
5754}
5755extern "C" {
5756 pub fn cuMemsetD2D16_v2(
5757 dstDevice: CUdeviceptr,
5758 dstPitch: usize,
5759 us: ::std::os::raw::c_ushort,
5760 Width: usize,
5761 Height: usize,
5762 ) -> CUresult;
5763}
5764extern "C" {
5765 pub fn cuMemsetD2D32_v2(
5766 dstDevice: CUdeviceptr,
5767 dstPitch: usize,
5768 ui: ::std::os::raw::c_uint,
5769 Width: usize,
5770 Height: usize,
5771 ) -> CUresult;
5772}
5773extern "C" {
5774 pub fn cuMemsetD8Async(
5775 dstDevice: CUdeviceptr,
5776 uc: ::std::os::raw::c_uchar,
5777 N: usize,
5778 hStream: CUstream,
5779 ) -> CUresult;
5780}
5781extern "C" {
5782 pub fn cuMemsetD16Async(
5783 dstDevice: CUdeviceptr,
5784 us: ::std::os::raw::c_ushort,
5785 N: usize,
5786 hStream: CUstream,
5787 ) -> CUresult;
5788}
5789extern "C" {
5790 pub fn cuMemsetD32Async(
5791 dstDevice: CUdeviceptr,
5792 ui: ::std::os::raw::c_uint,
5793 N: usize,
5794 hStream: CUstream,
5795 ) -> CUresult;
5796}
5797extern "C" {
5798 pub fn cuMemsetD2D8Async(
5799 dstDevice: CUdeviceptr,
5800 dstPitch: usize,
5801 uc: ::std::os::raw::c_uchar,
5802 Width: usize,
5803 Height: usize,
5804 hStream: CUstream,
5805 ) -> CUresult;
5806}
5807extern "C" {
5808 pub fn cuMemsetD2D16Async(
5809 dstDevice: CUdeviceptr,
5810 dstPitch: usize,
5811 us: ::std::os::raw::c_ushort,
5812 Width: usize,
5813 Height: usize,
5814 hStream: CUstream,
5815 ) -> CUresult;
5816}
5817extern "C" {
5818 pub fn cuMemsetD2D32Async(
5819 dstDevice: CUdeviceptr,
5820 dstPitch: usize,
5821 ui: ::std::os::raw::c_uint,
5822 Width: usize,
5823 Height: usize,
5824 hStream: CUstream,
5825 ) -> CUresult;
5826}
5827extern "C" {
5828 pub fn cuArrayCreate_v2(
5829 pHandle: *mut CUarray,
5830 pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR,
5831 ) -> CUresult;
5832}
5833extern "C" {
5834 pub fn cuArrayGetDescriptor_v2(
5835 pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR,
5836 hArray: CUarray,
5837 ) -> CUresult;
5838}
5839extern "C" {
5840 pub fn cuArrayDestroy(hArray: CUarray) -> CUresult;
5841}
5842extern "C" {
5843 pub fn cuArray3DCreate_v2(
5844 pHandle: *mut CUarray,
5845 pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR,
5846 ) -> CUresult;
5847}
5848extern "C" {
5849 pub fn cuArray3DGetDescriptor_v2(
5850 pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR,
5851 hArray: CUarray,
5852 ) -> CUresult;
5853}
5854extern "C" {
5855 pub fn cuMipmappedArrayCreate(
5856 pHandle: *mut CUmipmappedArray,
5857 pMipmappedArrayDesc: *const CUDA_ARRAY3D_DESCRIPTOR,
5858 numMipmapLevels: ::std::os::raw::c_uint,
5859 ) -> CUresult;
5860}
5861extern "C" {
5862 pub fn cuMipmappedArrayGetLevel(
5863 pLevelArray: *mut CUarray,
5864 hMipmappedArray: CUmipmappedArray,
5865 level: ::std::os::raw::c_uint,
5866 ) -> CUresult;
5867}
5868extern "C" {
5869 pub fn cuMipmappedArrayDestroy(hMipmappedArray: CUmipmappedArray) -> CUresult;
5870}
5871extern "C" {
5872 pub fn cuMemAddressReserve(
5873 ptr: *mut CUdeviceptr,
5874 size: usize,
5875 alignment: usize,
5876 addr: CUdeviceptr,
5877 flags: ::std::os::raw::c_ulonglong,
5878 ) -> CUresult;
5879}
5880extern "C" {
5881 pub fn cuMemAddressFree(ptr: CUdeviceptr, size: usize) -> CUresult;
5882}
5883extern "C" {
5884 pub fn cuMemCreate(
5885 handle: *mut CUmemGenericAllocationHandle,
5886 size: usize,
5887 prop: *const CUmemAllocationProp,
5888 flags: ::std::os::raw::c_ulonglong,
5889 ) -> CUresult;
5890}
5891extern "C" {
5892 pub fn cuMemRelease(handle: CUmemGenericAllocationHandle) -> CUresult;
5893}
5894extern "C" {
5895 pub fn cuMemMap(
5896 ptr: CUdeviceptr,
5897 size: usize,
5898 offset: usize,
5899 handle: CUmemGenericAllocationHandle,
5900 flags: ::std::os::raw::c_ulonglong,
5901 ) -> CUresult;
5902}
5903extern "C" {
5904 pub fn cuMemUnmap(ptr: CUdeviceptr, size: usize) -> CUresult;
5905}
5906extern "C" {
5907 pub fn cuMemSetAccess(
5908 ptr: CUdeviceptr,
5909 size: usize,
5910 desc: *const CUmemAccessDesc,
5911 count: usize,
5912 ) -> CUresult;
5913}
5914extern "C" {
5915 pub fn cuMemGetAccess(
5916 flags: *mut ::std::os::raw::c_ulonglong,
5917 location: *const CUmemLocation,
5918 ptr: CUdeviceptr,
5919 ) -> CUresult;
5920}
5921extern "C" {
5922 pub fn cuMemExportToShareableHandle(
5923 shareableHandle: *mut ::std::os::raw::c_void,
5924 handle: CUmemGenericAllocationHandle,
5925 handleType: CUmemAllocationHandleType,
5926 flags: ::std::os::raw::c_ulonglong,
5927 ) -> CUresult;
5928}
5929extern "C" {
5930 pub fn cuMemImportFromShareableHandle(
5931 handle: *mut CUmemGenericAllocationHandle,
5932 osHandle: *mut ::std::os::raw::c_void,
5933 shHandleType: CUmemAllocationHandleType,
5934 ) -> CUresult;
5935}
5936extern "C" {
5937 pub fn cuMemGetAllocationGranularity(
5938 granularity: *mut usize,
5939 prop: *const CUmemAllocationProp,
5940 option: CUmemAllocationGranularity_flags,
5941 ) -> CUresult;
5942}
5943extern "C" {
5944 pub fn cuMemGetAllocationPropertiesFromHandle(
5945 prop: *mut CUmemAllocationProp,
5946 handle: CUmemGenericAllocationHandle,
5947 ) -> CUresult;
5948}
5949extern "C" {
5950 pub fn cuPointerGetAttribute(
5951 data: *mut ::std::os::raw::c_void,
5952 attribute: CUpointer_attribute,
5953 ptr: CUdeviceptr,
5954 ) -> CUresult;
5955}
5956extern "C" {
5957 pub fn cuMemPrefetchAsync(
5958 devPtr: CUdeviceptr,
5959 count: usize,
5960 dstDevice: CUdevice,
5961 hStream: CUstream,
5962 ) -> CUresult;
5963}
5964extern "C" {
5965 pub fn cuMemAdvise(
5966 devPtr: CUdeviceptr,
5967 count: usize,
5968 advice: CUmem_advise,
5969 device: CUdevice,
5970 ) -> CUresult;
5971}
5972extern "C" {
5973 pub fn cuMemRangeGetAttribute(
5974 data: *mut ::std::os::raw::c_void,
5975 dataSize: usize,
5976 attribute: CUmem_range_attribute,
5977 devPtr: CUdeviceptr,
5978 count: usize,
5979 ) -> CUresult;
5980}
5981extern "C" {
5982 pub fn cuMemRangeGetAttributes(
5983 data: *mut *mut ::std::os::raw::c_void,
5984 dataSizes: *mut usize,
5985 attributes: *mut CUmem_range_attribute,
5986 numAttributes: usize,
5987 devPtr: CUdeviceptr,
5988 count: usize,
5989 ) -> CUresult;
5990}
5991extern "C" {
5992 pub fn cuPointerSetAttribute(
5993 value: *const ::std::os::raw::c_void,
5994 attribute: CUpointer_attribute,
5995 ptr: CUdeviceptr,
5996 ) -> CUresult;
5997}
5998extern "C" {
5999 pub fn cuPointerGetAttributes(
6000 numAttributes: ::std::os::raw::c_uint,
6001 attributes: *mut CUpointer_attribute,
6002 data: *mut *mut ::std::os::raw::c_void,
6003 ptr: CUdeviceptr,
6004 ) -> CUresult;
6005}
6006extern "C" {
6007 pub fn cuStreamCreate(phStream: *mut CUstream, Flags: ::std::os::raw::c_uint) -> CUresult;
6008}
6009extern "C" {
6010 pub fn cuStreamCreateWithPriority(
6011 phStream: *mut CUstream,
6012 flags: ::std::os::raw::c_uint,
6013 priority: ::std::os::raw::c_int,
6014 ) -> CUresult;
6015}
6016extern "C" {
6017 pub fn cuStreamGetPriority(hStream: CUstream, priority: *mut ::std::os::raw::c_int)
6018 -> CUresult;
6019}
6020extern "C" {
6021 pub fn cuStreamGetFlags(hStream: CUstream, flags: *mut ::std::os::raw::c_uint) -> CUresult;
6022}
6023extern "C" {
6024 pub fn cuStreamGetCtx(hStream: CUstream, pctx: *mut CUcontext) -> CUresult;
6025}
6026extern "C" {
6027 pub fn cuStreamWaitEvent(
6028 hStream: CUstream,
6029 hEvent: CUevent,
6030 Flags: ::std::os::raw::c_uint,
6031 ) -> CUresult;
6032}
6033extern "C" {
6034 pub fn cuStreamAddCallback(
6035 hStream: CUstream,
6036 callback: CUstreamCallback,
6037 userData: *mut ::std::os::raw::c_void,
6038 flags: ::std::os::raw::c_uint,
6039 ) -> CUresult;
6040}
6041extern "C" {
6042 pub fn cuStreamBeginCapture_v2(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult;
6043}
6044extern "C" {
6045 pub fn cuThreadExchangeStreamCaptureMode(mode: *mut CUstreamCaptureMode) -> CUresult;
6046}
6047extern "C" {
6048 pub fn cuStreamEndCapture(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult;
6049}
6050extern "C" {
6051 pub fn cuStreamIsCapturing(
6052 hStream: CUstream,
6053 captureStatus: *mut CUstreamCaptureStatus,
6054 ) -> CUresult;
6055}
6056extern "C" {
6057 pub fn cuStreamGetCaptureInfo(
6058 hStream: CUstream,
6059 captureStatus: *mut CUstreamCaptureStatus,
6060 id: *mut cuuint64_t,
6061 ) -> CUresult;
6062}
6063extern "C" {
6064 pub fn cuStreamAttachMemAsync(
6065 hStream: CUstream,
6066 dptr: CUdeviceptr,
6067 length: usize,
6068 flags: ::std::os::raw::c_uint,
6069 ) -> CUresult;
6070}
6071extern "C" {
6072 pub fn cuStreamQuery(hStream: CUstream) -> CUresult;
6073}
6074extern "C" {
6075 pub fn cuStreamSynchronize(hStream: CUstream) -> CUresult;
6076}
6077extern "C" {
6078 pub fn cuStreamDestroy_v2(hStream: CUstream) -> CUresult;
6079}
6080extern "C" {
6081 pub fn cuEventCreate(phEvent: *mut CUevent, Flags: ::std::os::raw::c_uint) -> CUresult;
6082}
6083extern "C" {
6084 pub fn cuEventRecord(hEvent: CUevent, hStream: CUstream) -> CUresult;
6085}
6086extern "C" {
6087 pub fn cuEventQuery(hEvent: CUevent) -> CUresult;
6088}
6089extern "C" {
6090 pub fn cuEventSynchronize(hEvent: CUevent) -> CUresult;
6091}
6092extern "C" {
6093 pub fn cuEventDestroy_v2(hEvent: CUevent) -> CUresult;
6094}
6095extern "C" {
6096 pub fn cuEventElapsedTime(pMilliseconds: *mut f32, hStart: CUevent, hEnd: CUevent) -> CUresult;
6097}
6098extern "C" {
6099 pub fn cuImportExternalMemory(
6100 extMem_out: *mut CUexternalMemory,
6101 memHandleDesc: *const CUDA_EXTERNAL_MEMORY_HANDLE_DESC,
6102 ) -> CUresult;
6103}
6104extern "C" {
6105 pub fn cuExternalMemoryGetMappedBuffer(
6106 devPtr: *mut CUdeviceptr,
6107 extMem: CUexternalMemory,
6108 bufferDesc: *const CUDA_EXTERNAL_MEMORY_BUFFER_DESC,
6109 ) -> CUresult;
6110}
6111extern "C" {
6112 pub fn cuExternalMemoryGetMappedMipmappedArray(
6113 mipmap: *mut CUmipmappedArray,
6114 extMem: CUexternalMemory,
6115 mipmapDesc: *const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC,
6116 ) -> CUresult;
6117}
6118extern "C" {
6119 pub fn cuDestroyExternalMemory(extMem: CUexternalMemory) -> CUresult;
6120}
6121extern "C" {
6122 pub fn cuImportExternalSemaphore(
6123 extSem_out: *mut CUexternalSemaphore,
6124 semHandleDesc: *const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC,
6125 ) -> CUresult;
6126}
6127extern "C" {
6128 pub fn cuSignalExternalSemaphoresAsync(
6129 extSemArray: *const CUexternalSemaphore,
6130 paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,
6131 numExtSems: ::std::os::raw::c_uint,
6132 stream: CUstream,
6133 ) -> CUresult;
6134}
6135extern "C" {
6136 pub fn cuWaitExternalSemaphoresAsync(
6137 extSemArray: *const CUexternalSemaphore,
6138 paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,
6139 numExtSems: ::std::os::raw::c_uint,
6140 stream: CUstream,
6141 ) -> CUresult;
6142}
6143extern "C" {
6144 pub fn cuDestroyExternalSemaphore(extSem: CUexternalSemaphore) -> CUresult;
6145}
6146extern "C" {
6147 pub fn cuStreamWaitValue32(
6148 stream: CUstream,
6149 addr: CUdeviceptr,
6150 value: cuuint32_t,
6151 flags: ::std::os::raw::c_uint,
6152 ) -> CUresult;
6153}
6154extern "C" {
6155 pub fn cuStreamWaitValue64(
6156 stream: CUstream,
6157 addr: CUdeviceptr,
6158 value: cuuint64_t,
6159 flags: ::std::os::raw::c_uint,
6160 ) -> CUresult;
6161}
6162extern "C" {
6163 pub fn cuStreamWriteValue32(
6164 stream: CUstream,
6165 addr: CUdeviceptr,
6166 value: cuuint32_t,
6167 flags: ::std::os::raw::c_uint,
6168 ) -> CUresult;
6169}
6170extern "C" {
6171 pub fn cuStreamWriteValue64(
6172 stream: CUstream,
6173 addr: CUdeviceptr,
6174 value: cuuint64_t,
6175 flags: ::std::os::raw::c_uint,
6176 ) -> CUresult;
6177}
6178extern "C" {
6179 pub fn cuStreamBatchMemOp(
6180 stream: CUstream,
6181 count: ::std::os::raw::c_uint,
6182 paramArray: *mut CUstreamBatchMemOpParams,
6183 flags: ::std::os::raw::c_uint,
6184 ) -> CUresult;
6185}
6186extern "C" {
6187 pub fn cuFuncGetAttribute(
6188 pi: *mut ::std::os::raw::c_int,
6189 attrib: CUfunction_attribute,
6190 hfunc: CUfunction,
6191 ) -> CUresult;
6192}
6193extern "C" {
6194 pub fn cuFuncSetAttribute(
6195 hfunc: CUfunction,
6196 attrib: CUfunction_attribute,
6197 value: ::std::os::raw::c_int,
6198 ) -> CUresult;
6199}
6200extern "C" {
6201 pub fn cuFuncSetCacheConfig(hfunc: CUfunction, config: CUfunc_cache) -> CUresult;
6202}
6203extern "C" {
6204 pub fn cuFuncSetSharedMemConfig(hfunc: CUfunction, config: CUsharedconfig) -> CUresult;
6205}
6206extern "C" {
6207 pub fn cuLaunchKernel(
6208 f: CUfunction,
6209 gridDimX: ::std::os::raw::c_uint,
6210 gridDimY: ::std::os::raw::c_uint,
6211 gridDimZ: ::std::os::raw::c_uint,
6212 blockDimX: ::std::os::raw::c_uint,
6213 blockDimY: ::std::os::raw::c_uint,
6214 blockDimZ: ::std::os::raw::c_uint,
6215 sharedMemBytes: ::std::os::raw::c_uint,
6216 hStream: CUstream,
6217 kernelParams: *mut *mut ::std::os::raw::c_void,
6218 extra: *mut *mut ::std::os::raw::c_void,
6219 ) -> CUresult;
6220}
6221extern "C" {
6222 pub fn cuLaunchCooperativeKernel(
6223 f: CUfunction,
6224 gridDimX: ::std::os::raw::c_uint,
6225 gridDimY: ::std::os::raw::c_uint,
6226 gridDimZ: ::std::os::raw::c_uint,
6227 blockDimX: ::std::os::raw::c_uint,
6228 blockDimY: ::std::os::raw::c_uint,
6229 blockDimZ: ::std::os::raw::c_uint,
6230 sharedMemBytes: ::std::os::raw::c_uint,
6231 hStream: CUstream,
6232 kernelParams: *mut *mut ::std::os::raw::c_void,
6233 ) -> CUresult;
6234}
6235extern "C" {
6236 pub fn cuLaunchCooperativeKernelMultiDevice(
6237 launchParamsList: *mut CUDA_LAUNCH_PARAMS,
6238 numDevices: ::std::os::raw::c_uint,
6239 flags: ::std::os::raw::c_uint,
6240 ) -> CUresult;
6241}
6242extern "C" {
6243 pub fn cuLaunchHostFunc(
6244 hStream: CUstream,
6245 fn_: CUhostFn,
6246 userData: *mut ::std::os::raw::c_void,
6247 ) -> CUresult;
6248}
6249extern "C" {
6250 pub fn cuFuncSetBlockShape(
6251 hfunc: CUfunction,
6252 x: ::std::os::raw::c_int,
6253 y: ::std::os::raw::c_int,
6254 z: ::std::os::raw::c_int,
6255 ) -> CUresult;
6256}
6257extern "C" {
6258 pub fn cuFuncSetSharedSize(hfunc: CUfunction, bytes: ::std::os::raw::c_uint) -> CUresult;
6259}
6260extern "C" {
6261 pub fn cuParamSetSize(hfunc: CUfunction, numbytes: ::std::os::raw::c_uint) -> CUresult;
6262}
6263extern "C" {
6264 pub fn cuParamSeti(
6265 hfunc: CUfunction,
6266 offset: ::std::os::raw::c_int,
6267 value: ::std::os::raw::c_uint,
6268 ) -> CUresult;
6269}
6270extern "C" {
6271 pub fn cuParamSetf(hfunc: CUfunction, offset: ::std::os::raw::c_int, value: f32) -> CUresult;
6272}
6273extern "C" {
6274 pub fn cuParamSetv(
6275 hfunc: CUfunction,
6276 offset: ::std::os::raw::c_int,
6277 ptr: *mut ::std::os::raw::c_void,
6278 numbytes: ::std::os::raw::c_uint,
6279 ) -> CUresult;
6280}
6281extern "C" {
6282 pub fn cuLaunch(f: CUfunction) -> CUresult;
6283}
6284extern "C" {
6285 pub fn cuLaunchGrid(
6286 f: CUfunction,
6287 grid_width: ::std::os::raw::c_int,
6288 grid_height: ::std::os::raw::c_int,
6289 ) -> CUresult;
6290}
6291extern "C" {
6292 pub fn cuLaunchGridAsync(
6293 f: CUfunction,
6294 grid_width: ::std::os::raw::c_int,
6295 grid_height: ::std::os::raw::c_int,
6296 hStream: CUstream,
6297 ) -> CUresult;
6298}
6299extern "C" {
6300 pub fn cuParamSetTexRef(
6301 hfunc: CUfunction,
6302 texunit: ::std::os::raw::c_int,
6303 hTexRef: CUtexref,
6304 ) -> CUresult;
6305}
6306extern "C" {
6307 pub fn cuGraphCreate(phGraph: *mut CUgraph, flags: ::std::os::raw::c_uint) -> CUresult;
6308}
6309extern "C" {
6310 pub fn cuGraphAddKernelNode(
6311 phGraphNode: *mut CUgraphNode,
6312 hGraph: CUgraph,
6313 dependencies: *const CUgraphNode,
6314 numDependencies: usize,
6315 nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
6316 ) -> CUresult;
6317}
6318extern "C" {
6319 pub fn cuGraphKernelNodeGetParams(
6320 hNode: CUgraphNode,
6321 nodeParams: *mut CUDA_KERNEL_NODE_PARAMS,
6322 ) -> CUresult;
6323}
6324extern "C" {
6325 pub fn cuGraphKernelNodeSetParams(
6326 hNode: CUgraphNode,
6327 nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
6328 ) -> CUresult;
6329}
6330extern "C" {
6331 pub fn cuGraphAddMemcpyNode(
6332 phGraphNode: *mut CUgraphNode,
6333 hGraph: CUgraph,
6334 dependencies: *const CUgraphNode,
6335 numDependencies: usize,
6336 copyParams: *const CUDA_MEMCPY3D,
6337 ctx: CUcontext,
6338 ) -> CUresult;
6339}
6340extern "C" {
6341 pub fn cuGraphMemcpyNodeGetParams(
6342 hNode: CUgraphNode,
6343 nodeParams: *mut CUDA_MEMCPY3D,
6344 ) -> CUresult;
6345}
6346extern "C" {
6347 pub fn cuGraphMemcpyNodeSetParams(
6348 hNode: CUgraphNode,
6349 nodeParams: *const CUDA_MEMCPY3D,
6350 ) -> CUresult;
6351}
6352extern "C" {
6353 pub fn cuGraphAddMemsetNode(
6354 phGraphNode: *mut CUgraphNode,
6355 hGraph: CUgraph,
6356 dependencies: *const CUgraphNode,
6357 numDependencies: usize,
6358 memsetParams: *const CUDA_MEMSET_NODE_PARAMS,
6359 ctx: CUcontext,
6360 ) -> CUresult;
6361}
6362extern "C" {
6363 pub fn cuGraphMemsetNodeGetParams(
6364 hNode: CUgraphNode,
6365 nodeParams: *mut CUDA_MEMSET_NODE_PARAMS,
6366 ) -> CUresult;
6367}
6368extern "C" {
6369 pub fn cuGraphMemsetNodeSetParams(
6370 hNode: CUgraphNode,
6371 nodeParams: *const CUDA_MEMSET_NODE_PARAMS,
6372 ) -> CUresult;
6373}
6374extern "C" {
6375 pub fn cuGraphAddHostNode(
6376 phGraphNode: *mut CUgraphNode,
6377 hGraph: CUgraph,
6378 dependencies: *const CUgraphNode,
6379 numDependencies: usize,
6380 nodeParams: *const CUDA_HOST_NODE_PARAMS,
6381 ) -> CUresult;
6382}
6383extern "C" {
6384 pub fn cuGraphHostNodeGetParams(
6385 hNode: CUgraphNode,
6386 nodeParams: *mut CUDA_HOST_NODE_PARAMS,
6387 ) -> CUresult;
6388}
6389extern "C" {
6390 pub fn cuGraphHostNodeSetParams(
6391 hNode: CUgraphNode,
6392 nodeParams: *const CUDA_HOST_NODE_PARAMS,
6393 ) -> CUresult;
6394}
6395extern "C" {
6396 pub fn cuGraphAddChildGraphNode(
6397 phGraphNode: *mut CUgraphNode,
6398 hGraph: CUgraph,
6399 dependencies: *const CUgraphNode,
6400 numDependencies: usize,
6401 childGraph: CUgraph,
6402 ) -> CUresult;
6403}
6404extern "C" {
6405 pub fn cuGraphChildGraphNodeGetGraph(hNode: CUgraphNode, phGraph: *mut CUgraph) -> CUresult;
6406}
6407extern "C" {
6408 pub fn cuGraphAddEmptyNode(
6409 phGraphNode: *mut CUgraphNode,
6410 hGraph: CUgraph,
6411 dependencies: *const CUgraphNode,
6412 numDependencies: usize,
6413 ) -> CUresult;
6414}
6415extern "C" {
6416 pub fn cuGraphClone(phGraphClone: *mut CUgraph, originalGraph: CUgraph) -> CUresult;
6417}
6418extern "C" {
6419 pub fn cuGraphNodeFindInClone(
6420 phNode: *mut CUgraphNode,
6421 hOriginalNode: CUgraphNode,
6422 hClonedGraph: CUgraph,
6423 ) -> CUresult;
6424}
6425extern "C" {
6426 pub fn cuGraphNodeGetType(hNode: CUgraphNode, type_: *mut CUgraphNodeType) -> CUresult;
6427}
6428extern "C" {
6429 pub fn cuGraphGetNodes(
6430 hGraph: CUgraph,
6431 nodes: *mut CUgraphNode,
6432 numNodes: *mut usize,
6433 ) -> CUresult;
6434}
6435extern "C" {
6436 pub fn cuGraphGetRootNodes(
6437 hGraph: CUgraph,
6438 rootNodes: *mut CUgraphNode,
6439 numRootNodes: *mut usize,
6440 ) -> CUresult;
6441}
6442extern "C" {
6443 pub fn cuGraphGetEdges(
6444 hGraph: CUgraph,
6445 from: *mut CUgraphNode,
6446 to: *mut CUgraphNode,
6447 numEdges: *mut usize,
6448 ) -> CUresult;
6449}
6450extern "C" {
6451 pub fn cuGraphNodeGetDependencies(
6452 hNode: CUgraphNode,
6453 dependencies: *mut CUgraphNode,
6454 numDependencies: *mut usize,
6455 ) -> CUresult;
6456}
6457extern "C" {
6458 pub fn cuGraphNodeGetDependentNodes(
6459 hNode: CUgraphNode,
6460 dependentNodes: *mut CUgraphNode,
6461 numDependentNodes: *mut usize,
6462 ) -> CUresult;
6463}
6464extern "C" {
6465 pub fn cuGraphAddDependencies(
6466 hGraph: CUgraph,
6467 from: *const CUgraphNode,
6468 to: *const CUgraphNode,
6469 numDependencies: usize,
6470 ) -> CUresult;
6471}
6472extern "C" {
6473 pub fn cuGraphRemoveDependencies(
6474 hGraph: CUgraph,
6475 from: *const CUgraphNode,
6476 to: *const CUgraphNode,
6477 numDependencies: usize,
6478 ) -> CUresult;
6479}
6480extern "C" {
6481 pub fn cuGraphDestroyNode(hNode: CUgraphNode) -> CUresult;
6482}
6483extern "C" {
6484 pub fn cuGraphInstantiate(
6485 phGraphExec: *mut CUgraphExec,
6486 hGraph: CUgraph,
6487 phErrorNode: *mut CUgraphNode,
6488 logBuffer: *mut ::std::os::raw::c_char,
6489 bufferSize: usize,
6490 ) -> CUresult;
6491}
6492extern "C" {
6493 pub fn cuGraphExecKernelNodeSetParams(
6494 hGraphExec: CUgraphExec,
6495 hNode: CUgraphNode,
6496 nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
6497 ) -> CUresult;
6498}
6499extern "C" {
6500 pub fn cuGraphExecMemcpyNodeSetParams(
6501 hGraphExec: CUgraphExec,
6502 hNode: CUgraphNode,
6503 copyParams: *const CUDA_MEMCPY3D,
6504 ctx: CUcontext,
6505 ) -> CUresult;
6506}
6507extern "C" {
6508 pub fn cuGraphExecMemsetNodeSetParams(
6509 hGraphExec: CUgraphExec,
6510 hNode: CUgraphNode,
6511 memsetParams: *const CUDA_MEMSET_NODE_PARAMS,
6512 ctx: CUcontext,
6513 ) -> CUresult;
6514}
6515extern "C" {
6516 pub fn cuGraphExecHostNodeSetParams(
6517 hGraphExec: CUgraphExec,
6518 hNode: CUgraphNode,
6519 nodeParams: *const CUDA_HOST_NODE_PARAMS,
6520 ) -> CUresult;
6521}
6522extern "C" {
6523 pub fn cuGraphLaunch(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult;
6524}
6525extern "C" {
6526 pub fn cuGraphExecDestroy(hGraphExec: CUgraphExec) -> CUresult;
6527}
6528extern "C" {
6529 pub fn cuGraphDestroy(hGraph: CUgraph) -> CUresult;
6530}
6531extern "C" {
6532 pub fn cuGraphExecUpdate(
6533 hGraphExec: CUgraphExec,
6534 hGraph: CUgraph,
6535 hErrorNode_out: *mut CUgraphNode,
6536 updateResult_out: *mut CUgraphExecUpdateResult,
6537 ) -> CUresult;
6538}
6539extern "C" {
6540 pub fn cuOccupancyMaxActiveBlocksPerMultiprocessor(
6541 numBlocks: *mut ::std::os::raw::c_int,
6542 func: CUfunction,
6543 blockSize: ::std::os::raw::c_int,
6544 dynamicSMemSize: usize,
6545 ) -> CUresult;
6546}
6547extern "C" {
6548 pub fn cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
6549 numBlocks: *mut ::std::os::raw::c_int,
6550 func: CUfunction,
6551 blockSize: ::std::os::raw::c_int,
6552 dynamicSMemSize: usize,
6553 flags: ::std::os::raw::c_uint,
6554 ) -> CUresult;
6555}
6556extern "C" {
6557 pub fn cuOccupancyMaxPotentialBlockSize(
6558 minGridSize: *mut ::std::os::raw::c_int,
6559 blockSize: *mut ::std::os::raw::c_int,
6560 func: CUfunction,
6561 blockSizeToDynamicSMemSize: CUoccupancyB2DSize,
6562 dynamicSMemSize: usize,
6563 blockSizeLimit: ::std::os::raw::c_int,
6564 ) -> CUresult;
6565}
6566extern "C" {
6567 pub fn cuOccupancyMaxPotentialBlockSizeWithFlags(
6568 minGridSize: *mut ::std::os::raw::c_int,
6569 blockSize: *mut ::std::os::raw::c_int,
6570 func: CUfunction,
6571 blockSizeToDynamicSMemSize: CUoccupancyB2DSize,
6572 dynamicSMemSize: usize,
6573 blockSizeLimit: ::std::os::raw::c_int,
6574 flags: ::std::os::raw::c_uint,
6575 ) -> CUresult;
6576}
6577extern "C" {
6578 pub fn cuTexRefSetArray(
6579 hTexRef: CUtexref,
6580 hArray: CUarray,
6581 Flags: ::std::os::raw::c_uint,
6582 ) -> CUresult;
6583}
6584extern "C" {
6585 pub fn cuTexRefSetMipmappedArray(
6586 hTexRef: CUtexref,
6587 hMipmappedArray: CUmipmappedArray,
6588 Flags: ::std::os::raw::c_uint,
6589 ) -> CUresult;
6590}
6591extern "C" {
6592 pub fn cuTexRefSetAddress_v2(
6593 ByteOffset: *mut usize,
6594 hTexRef: CUtexref,
6595 dptr: CUdeviceptr,
6596 bytes: usize,
6597 ) -> CUresult;
6598}
6599extern "C" {
6600 pub fn cuTexRefSetAddress2D_v3(
6601 hTexRef: CUtexref,
6602 desc: *const CUDA_ARRAY_DESCRIPTOR,
6603 dptr: CUdeviceptr,
6604 Pitch: usize,
6605 ) -> CUresult;
6606}
6607extern "C" {
6608 pub fn cuTexRefSetFormat(
6609 hTexRef: CUtexref,
6610 fmt: CUarray_format,
6611 NumPackedComponents: ::std::os::raw::c_int,
6612 ) -> CUresult;
6613}
6614extern "C" {
6615 pub fn cuTexRefSetAddressMode(
6616 hTexRef: CUtexref,
6617 dim: ::std::os::raw::c_int,
6618 am: CUaddress_mode,
6619 ) -> CUresult;
6620}
6621extern "C" {
6622 pub fn cuTexRefSetFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
6623}
6624extern "C" {
6625 pub fn cuTexRefSetMipmapFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
6626}
6627extern "C" {
6628 pub fn cuTexRefSetMipmapLevelBias(hTexRef: CUtexref, bias: f32) -> CUresult;
6629}
6630extern "C" {
6631 pub fn cuTexRefSetMipmapLevelClamp(
6632 hTexRef: CUtexref,
6633 minMipmapLevelClamp: f32,
6634 maxMipmapLevelClamp: f32,
6635 ) -> CUresult;
6636}
6637extern "C" {
6638 pub fn cuTexRefSetMaxAnisotropy(
6639 hTexRef: CUtexref,
6640 maxAniso: ::std::os::raw::c_uint,
6641 ) -> CUresult;
6642}
6643extern "C" {
6644 pub fn cuTexRefSetBorderColor(hTexRef: CUtexref, pBorderColor: *mut f32) -> CUresult;
6645}
6646extern "C" {
6647 pub fn cuTexRefSetFlags(hTexRef: CUtexref, Flags: ::std::os::raw::c_uint) -> CUresult;
6648}
6649extern "C" {
6650 pub fn cuTexRefGetAddress_v2(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult;
6651}
6652extern "C" {
6653 pub fn cuTexRefGetArray(phArray: *mut CUarray, hTexRef: CUtexref) -> CUresult;
6654}
6655extern "C" {
6656 pub fn cuTexRefGetMipmappedArray(
6657 phMipmappedArray: *mut CUmipmappedArray,
6658 hTexRef: CUtexref,
6659 ) -> CUresult;
6660}
6661extern "C" {
6662 pub fn cuTexRefGetAddressMode(
6663 pam: *mut CUaddress_mode,
6664 hTexRef: CUtexref,
6665 dim: ::std::os::raw::c_int,
6666 ) -> CUresult;
6667}
6668extern "C" {
6669 pub fn cuTexRefGetFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
6670}
6671extern "C" {
6672 pub fn cuTexRefGetFormat(
6673 pFormat: *mut CUarray_format,
6674 pNumChannels: *mut ::std::os::raw::c_int,
6675 hTexRef: CUtexref,
6676 ) -> CUresult;
6677}
6678extern "C" {
6679 pub fn cuTexRefGetMipmapFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
6680}
6681extern "C" {
6682 pub fn cuTexRefGetMipmapLevelBias(pbias: *mut f32, hTexRef: CUtexref) -> CUresult;
6683}
6684extern "C" {
6685 pub fn cuTexRefGetMipmapLevelClamp(
6686 pminMipmapLevelClamp: *mut f32,
6687 pmaxMipmapLevelClamp: *mut f32,
6688 hTexRef: CUtexref,
6689 ) -> CUresult;
6690}
6691extern "C" {
6692 pub fn cuTexRefGetMaxAnisotropy(
6693 pmaxAniso: *mut ::std::os::raw::c_int,
6694 hTexRef: CUtexref,
6695 ) -> CUresult;
6696}
6697extern "C" {
6698 pub fn cuTexRefGetBorderColor(pBorderColor: *mut f32, hTexRef: CUtexref) -> CUresult;
6699}
6700extern "C" {
6701 pub fn cuTexRefGetFlags(pFlags: *mut ::std::os::raw::c_uint, hTexRef: CUtexref) -> CUresult;
6702}
6703extern "C" {
6704 pub fn cuTexRefCreate(pTexRef: *mut CUtexref) -> CUresult;
6705}
6706extern "C" {
6707 pub fn cuTexRefDestroy(hTexRef: CUtexref) -> CUresult;
6708}
6709extern "C" {
6710 pub fn cuSurfRefSetArray(
6711 hSurfRef: CUsurfref,
6712 hArray: CUarray,
6713 Flags: ::std::os::raw::c_uint,
6714 ) -> CUresult;
6715}
6716extern "C" {
6717 pub fn cuSurfRefGetArray(phArray: *mut CUarray, hSurfRef: CUsurfref) -> CUresult;
6718}
6719extern "C" {
6720 pub fn cuTexObjectCreate(
6721 pTexObject: *mut CUtexObject,
6722 pResDesc: *const CUDA_RESOURCE_DESC,
6723 pTexDesc: *const CUDA_TEXTURE_DESC,
6724 pResViewDesc: *const CUDA_RESOURCE_VIEW_DESC,
6725 ) -> CUresult;
6726}
6727extern "C" {
6728 pub fn cuTexObjectDestroy(texObject: CUtexObject) -> CUresult;
6729}
6730extern "C" {
6731 pub fn cuTexObjectGetResourceDesc(
6732 pResDesc: *mut CUDA_RESOURCE_DESC,
6733 texObject: CUtexObject,
6734 ) -> CUresult;
6735}
6736extern "C" {
6737 pub fn cuTexObjectGetTextureDesc(
6738 pTexDesc: *mut CUDA_TEXTURE_DESC,
6739 texObject: CUtexObject,
6740 ) -> CUresult;
6741}
6742extern "C" {
6743 pub fn cuTexObjectGetResourceViewDesc(
6744 pResViewDesc: *mut CUDA_RESOURCE_VIEW_DESC,
6745 texObject: CUtexObject,
6746 ) -> CUresult;
6747}
6748extern "C" {
6749 pub fn cuSurfObjectCreate(
6750 pSurfObject: *mut CUsurfObject,
6751 pResDesc: *const CUDA_RESOURCE_DESC,
6752 ) -> CUresult;
6753}
6754extern "C" {
6755 pub fn cuSurfObjectDestroy(surfObject: CUsurfObject) -> CUresult;
6756}
6757extern "C" {
6758 pub fn cuSurfObjectGetResourceDesc(
6759 pResDesc: *mut CUDA_RESOURCE_DESC,
6760 surfObject: CUsurfObject,
6761 ) -> CUresult;
6762}
6763extern "C" {
6764 pub fn cuDeviceCanAccessPeer(
6765 canAccessPeer: *mut ::std::os::raw::c_int,
6766 dev: CUdevice,
6767 peerDev: CUdevice,
6768 ) -> CUresult;
6769}
6770extern "C" {
6771 pub fn cuCtxEnablePeerAccess(peerContext: CUcontext, Flags: ::std::os::raw::c_uint)
6772 -> CUresult;
6773}
6774extern "C" {
6775 pub fn cuCtxDisablePeerAccess(peerContext: CUcontext) -> CUresult;
6776}
6777extern "C" {
6778 pub fn cuDeviceGetP2PAttribute(
6779 value: *mut ::std::os::raw::c_int,
6780 attrib: CUdevice_P2PAttribute,
6781 srcDevice: CUdevice,
6782 dstDevice: CUdevice,
6783 ) -> CUresult;
6784}
6785extern "C" {
6786 pub fn cuGraphicsUnregisterResource(resource: CUgraphicsResource) -> CUresult;
6787}
6788extern "C" {
6789 pub fn cuGraphicsSubResourceGetMappedArray(
6790 pArray: *mut CUarray,
6791 resource: CUgraphicsResource,
6792 arrayIndex: ::std::os::raw::c_uint,
6793 mipLevel: ::std::os::raw::c_uint,
6794 ) -> CUresult;
6795}
6796extern "C" {
6797 pub fn cuGraphicsResourceGetMappedMipmappedArray(
6798 pMipmappedArray: *mut CUmipmappedArray,
6799 resource: CUgraphicsResource,
6800 ) -> CUresult;
6801}
6802extern "C" {
6803 pub fn cuGraphicsResourceGetMappedPointer_v2(
6804 pDevPtr: *mut CUdeviceptr,
6805 pSize: *mut usize,
6806 resource: CUgraphicsResource,
6807 ) -> CUresult;
6808}
6809extern "C" {
6810 pub fn cuGraphicsResourceSetMapFlags_v2(
6811 resource: CUgraphicsResource,
6812 flags: ::std::os::raw::c_uint,
6813 ) -> CUresult;
6814}
6815extern "C" {
6816 pub fn cuGraphicsMapResources(
6817 count: ::std::os::raw::c_uint,
6818 resources: *mut CUgraphicsResource,
6819 hStream: CUstream,
6820 ) -> CUresult;
6821}
6822extern "C" {
6823 pub fn cuGraphicsUnmapResources(
6824 count: ::std::os::raw::c_uint,
6825 resources: *mut CUgraphicsResource,
6826 hStream: CUstream,
6827 ) -> CUresult;
6828}
6829extern "C" {
6830 pub fn cuGetExportTable(
6831 ppExportTable: *mut *const ::std::os::raw::c_void,
6832 pExportTableId: *const CUuuid,
6833 ) -> CUresult;
6834}
6835#[repr(u32)]
6836#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
6837pub enum CUoutput_mode_enum {
6838 CU_OUT_KEY_VALUE_PAIR = 0,
6839 CU_OUT_CSV = 1,
6840}
6841pub use self::CUoutput_mode_enum as CUoutput_mode;
6842extern "C" {
6843 pub fn cuProfilerInitialize(
6844 configFile: *const ::std::os::raw::c_char,
6845 outputFile: *const ::std::os::raw::c_char,
6846 outputMode: CUoutput_mode,
6847 ) -> CUresult;
6848}
6849extern "C" {
6850 pub fn cuProfilerStart() -> CUresult;
6851}
6852extern "C" {
6853 pub fn cuProfilerStop() -> CUresult;
6854}
6855#[repr(u32)]
6856#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
6857pub enum cudaDataType_t {
6858 CUDA_R_16F = 2,
6859 CUDA_C_16F = 6,
6860 CUDA_R_32F = 0,
6861 CUDA_C_32F = 4,
6862 CUDA_R_64F = 1,
6863 CUDA_C_64F = 5,
6864 CUDA_R_8I = 3,
6865 CUDA_C_8I = 7,
6866 CUDA_R_8U = 8,
6867 CUDA_C_8U = 9,
6868 CUDA_R_32I = 10,
6869 CUDA_C_32I = 11,
6870 CUDA_R_32U = 12,
6871 CUDA_C_32U = 13,
6872}
6873pub use self::cudaDataType_t as cudaDataType;
6874#[repr(u32)]
6875#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
6876pub enum libraryPropertyType_t {
6877 MAJOR_VERSION = 0,
6878 MINOR_VERSION = 1,
6879 PATCH_LEVEL = 2,
6880}
6881pub use self::libraryPropertyType_t as libraryPropertyType;