1pub const cudaHostAllocDefault: u32 = 0;
4pub const cudaHostAllocPortable: u32 = 1;
5pub const cudaHostAllocMapped: u32 = 2;
6pub const cudaHostAllocWriteCombined: u32 = 4;
7pub const cudaHostRegisterDefault: u32 = 0;
8pub const cudaHostRegisterPortable: u32 = 1;
9pub const cudaHostRegisterMapped: u32 = 2;
10pub const cudaHostRegisterIoMemory: u32 = 4;
11pub const cudaPeerAccessDefault: u32 = 0;
12pub const cudaStreamDefault: u32 = 0;
13pub const cudaStreamNonBlocking: u32 = 1;
14pub const cudaEventDefault: u32 = 0;
15pub const cudaEventBlockingSync: u32 = 1;
16pub const cudaEventDisableTiming: u32 = 2;
17pub const cudaEventInterprocess: u32 = 4;
18pub const cudaDeviceScheduleAuto: u32 = 0;
19pub const cudaDeviceScheduleSpin: u32 = 1;
20pub const cudaDeviceScheduleYield: u32 = 2;
21pub const cudaDeviceScheduleBlockingSync: u32 = 4;
22pub const cudaDeviceBlockingSync: u32 = 4;
23pub const cudaDeviceScheduleMask: u32 = 7;
24pub const cudaDeviceMapHost: u32 = 8;
25pub const cudaDeviceLmemResizeToMax: u32 = 16;
26pub const cudaDeviceMask: u32 = 31;
27pub const cudaArrayDefault: u32 = 0;
28pub const cudaArrayLayered: u32 = 1;
29pub const cudaArraySurfaceLoadStore: u32 = 2;
30pub const cudaArrayCubemap: u32 = 4;
31pub const cudaArrayTextureGather: u32 = 8;
32pub const cudaArrayColorAttachment: u32 = 32;
33pub const cudaIpcMemLazyEnablePeerAccess: u32 = 1;
34pub const cudaMemAttachGlobal: u32 = 1;
35pub const cudaMemAttachHost: u32 = 2;
36pub const cudaMemAttachSingle: u32 = 4;
37pub const cudaOccupancyDefault: u32 = 0;
38pub const cudaOccupancyDisableCachingOverride: u32 = 1;
39pub const cudaCooperativeLaunchMultiDeviceNoPreSync: u32 = 1;
40pub const cudaCooperativeLaunchMultiDeviceNoPostSync: u32 = 2;
41pub const cudaExternalMemoryDedicated: u32 = 1;
42pub const cudaExternalSemaphoreSignalSkipNvSciBufMemSync: u32 = 1;
43pub const cudaExternalSemaphoreWaitSkipNvSciBufMemSync: u32 = 2;
44pub const cudaNvSciSyncAttrSignal: u32 = 1;
45pub const cudaNvSciSyncAttrWait: u32 = 2;
46pub const cudaSurfaceType1D: u32 = 1;
47pub const cudaSurfaceType2D: u32 = 2;
48pub const cudaSurfaceType3D: u32 = 3;
49pub const cudaSurfaceTypeCubemap: u32 = 12;
50pub const cudaSurfaceType1DLayered: u32 = 241;
51pub const cudaSurfaceType2DLayered: u32 = 242;
52pub const cudaSurfaceTypeCubemapLayered: u32 = 252;
53pub const cudaTextureType1D: u32 = 1;
54pub const cudaTextureType2D: u32 = 2;
55pub const cudaTextureType3D: u32 = 3;
56pub const cudaTextureTypeCubemap: u32 = 12;
57pub const cudaTextureType1DLayered: u32 = 241;
58pub const cudaTextureType2DLayered: u32 = 242;
59pub const cudaTextureTypeCubemapLayered: u32 = 252;
60#[repr(u32)]
61#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
62pub enum cudaRoundMode {
63 cudaRoundNearest = 0,
64 cudaRoundZero = 1,
65 cudaRoundPosInf = 2,
66 cudaRoundMinInf = 3,
67}
68#[repr(C)]
69#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
70pub struct dim3 {
71 pub x: ::std::os::raw::c_uint,
72 pub y: ::std::os::raw::c_uint,
73 pub z: ::std::os::raw::c_uint,
74}
75#[test]
76fn bindgen_test_layout_dim3() {
77 assert_eq!(
78 ::std::mem::size_of::<dim3>(),
79 12usize,
80 concat!("Size of: ", stringify!(dim3))
81 );
82 assert_eq!(
83 ::std::mem::align_of::<dim3>(),
84 4usize,
85 concat!("Alignment of ", stringify!(dim3))
86 );
87 assert_eq!(
88 unsafe { &(*(::std::ptr::null::<dim3>())).x as *const _ as usize },
89 0usize,
90 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(x))
91 );
92 assert_eq!(
93 unsafe { &(*(::std::ptr::null::<dim3>())).y as *const _ as usize },
94 4usize,
95 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(y))
96 );
97 assert_eq!(
98 unsafe { &(*(::std::ptr::null::<dim3>())).z as *const _ as usize },
99 8usize,
100 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(z))
101 );
102}
103#[repr(u32)]
104#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
105pub enum cudaError {
106 cudaSuccess = 0,
107 cudaErrorInvalidValue = 1,
108 cudaErrorMemoryAllocation = 2,
109 cudaErrorInitializationError = 3,
110 cudaErrorCudartUnloading = 4,
111 cudaErrorProfilerDisabled = 5,
112 cudaErrorProfilerNotInitialized = 6,
113 cudaErrorProfilerAlreadyStarted = 7,
114 cudaErrorProfilerAlreadyStopped = 8,
115 cudaErrorInvalidConfiguration = 9,
116 cudaErrorInvalidPitchValue = 12,
117 cudaErrorInvalidSymbol = 13,
118 cudaErrorInvalidHostPointer = 16,
119 cudaErrorInvalidDevicePointer = 17,
120 cudaErrorInvalidTexture = 18,
121 cudaErrorInvalidTextureBinding = 19,
122 cudaErrorInvalidChannelDescriptor = 20,
123 cudaErrorInvalidMemcpyDirection = 21,
124 cudaErrorAddressOfConstant = 22,
125 cudaErrorTextureFetchFailed = 23,
126 cudaErrorTextureNotBound = 24,
127 cudaErrorSynchronizationError = 25,
128 cudaErrorInvalidFilterSetting = 26,
129 cudaErrorInvalidNormSetting = 27,
130 cudaErrorMixedDeviceExecution = 28,
131 cudaErrorNotYetImplemented = 31,
132 cudaErrorMemoryValueTooLarge = 32,
133 cudaErrorInsufficientDriver = 35,
134 cudaErrorInvalidSurface = 37,
135 cudaErrorDuplicateVariableName = 43,
136 cudaErrorDuplicateTextureName = 44,
137 cudaErrorDuplicateSurfaceName = 45,
138 cudaErrorDevicesUnavailable = 46,
139 cudaErrorIncompatibleDriverContext = 49,
140 cudaErrorMissingConfiguration = 52,
141 cudaErrorPriorLaunchFailure = 53,
142 cudaErrorLaunchMaxDepthExceeded = 65,
143 cudaErrorLaunchFileScopedTex = 66,
144 cudaErrorLaunchFileScopedSurf = 67,
145 cudaErrorSyncDepthExceeded = 68,
146 cudaErrorLaunchPendingCountExceeded = 69,
147 cudaErrorInvalidDeviceFunction = 98,
148 cudaErrorNoDevice = 100,
149 cudaErrorInvalidDevice = 101,
150 cudaErrorStartupFailure = 127,
151 cudaErrorInvalidKernelImage = 200,
152 cudaErrorDeviceUninitialized = 201,
153 cudaErrorMapBufferObjectFailed = 205,
154 cudaErrorUnmapBufferObjectFailed = 206,
155 cudaErrorArrayIsMapped = 207,
156 cudaErrorAlreadyMapped = 208,
157 cudaErrorNoKernelImageForDevice = 209,
158 cudaErrorAlreadyAcquired = 210,
159 cudaErrorNotMapped = 211,
160 cudaErrorNotMappedAsArray = 212,
161 cudaErrorNotMappedAsPointer = 213,
162 cudaErrorECCUncorrectable = 214,
163 cudaErrorUnsupportedLimit = 215,
164 cudaErrorDeviceAlreadyInUse = 216,
165 cudaErrorPeerAccessUnsupported = 217,
166 cudaErrorInvalidPtx = 218,
167 cudaErrorInvalidGraphicsContext = 219,
168 cudaErrorNvlinkUncorrectable = 220,
169 cudaErrorJitCompilerNotFound = 221,
170 cudaErrorInvalidSource = 300,
171 cudaErrorFileNotFound = 301,
172 cudaErrorSharedObjectSymbolNotFound = 302,
173 cudaErrorSharedObjectInitFailed = 303,
174 cudaErrorOperatingSystem = 304,
175 cudaErrorInvalidResourceHandle = 400,
176 cudaErrorIllegalState = 401,
177 cudaErrorSymbolNotFound = 500,
178 cudaErrorNotReady = 600,
179 cudaErrorIllegalAddress = 700,
180 cudaErrorLaunchOutOfResources = 701,
181 cudaErrorLaunchTimeout = 702,
182 cudaErrorLaunchIncompatibleTexturing = 703,
183 cudaErrorPeerAccessAlreadyEnabled = 704,
184 cudaErrorPeerAccessNotEnabled = 705,
185 cudaErrorSetOnActiveProcess = 708,
186 cudaErrorContextIsDestroyed = 709,
187 cudaErrorAssert = 710,
188 cudaErrorTooManyPeers = 711,
189 cudaErrorHostMemoryAlreadyRegistered = 712,
190 cudaErrorHostMemoryNotRegistered = 713,
191 cudaErrorHardwareStackError = 714,
192 cudaErrorIllegalInstruction = 715,
193 cudaErrorMisalignedAddress = 716,
194 cudaErrorInvalidAddressSpace = 717,
195 cudaErrorInvalidPc = 718,
196 cudaErrorLaunchFailure = 719,
197 cudaErrorCooperativeLaunchTooLarge = 720,
198 cudaErrorNotPermitted = 800,
199 cudaErrorNotSupported = 801,
200 cudaErrorSystemNotReady = 802,
201 cudaErrorSystemDriverMismatch = 803,
202 cudaErrorCompatNotSupportedOnDevice = 804,
203 cudaErrorStreamCaptureUnsupported = 900,
204 cudaErrorStreamCaptureInvalidated = 901,
205 cudaErrorStreamCaptureMerge = 902,
206 cudaErrorStreamCaptureUnmatched = 903,
207 cudaErrorStreamCaptureUnjoined = 904,
208 cudaErrorStreamCaptureIsolation = 905,
209 cudaErrorStreamCaptureImplicit = 906,
210 cudaErrorCapturedEvent = 907,
211 cudaErrorStreamCaptureWrongThread = 908,
212 cudaErrorTimeout = 909,
213 cudaErrorGraphExecUpdateFailure = 910,
214 cudaErrorUnknown = 999,
215 cudaErrorApiFailureBase = 10000,
216}
217#[repr(u32)]
218#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
219pub enum cudaChannelFormatKind {
220 cudaChannelFormatKindSigned = 0,
221 cudaChannelFormatKindUnsigned = 1,
222 cudaChannelFormatKindFloat = 2,
223 cudaChannelFormatKindNone = 3,
224}
225#[repr(C)]
226#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
227pub struct cudaChannelFormatDesc {
228 pub x: ::std::os::raw::c_int,
229 pub y: ::std::os::raw::c_int,
230 pub z: ::std::os::raw::c_int,
231 pub w: ::std::os::raw::c_int,
232 pub f: cudaChannelFormatKind,
233}
234#[test]
235fn bindgen_test_layout_cudaChannelFormatDesc() {
236 assert_eq!(
237 ::std::mem::size_of::<cudaChannelFormatDesc>(),
238 20usize,
239 concat!("Size of: ", stringify!(cudaChannelFormatDesc))
240 );
241 assert_eq!(
242 ::std::mem::align_of::<cudaChannelFormatDesc>(),
243 4usize,
244 concat!("Alignment of ", stringify!(cudaChannelFormatDesc))
245 );
246 assert_eq!(
247 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).x as *const _ as usize },
248 0usize,
249 concat!(
250 "Offset of field: ",
251 stringify!(cudaChannelFormatDesc),
252 "::",
253 stringify!(x)
254 )
255 );
256 assert_eq!(
257 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).y as *const _ as usize },
258 4usize,
259 concat!(
260 "Offset of field: ",
261 stringify!(cudaChannelFormatDesc),
262 "::",
263 stringify!(y)
264 )
265 );
266 assert_eq!(
267 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).z as *const _ as usize },
268 8usize,
269 concat!(
270 "Offset of field: ",
271 stringify!(cudaChannelFormatDesc),
272 "::",
273 stringify!(z)
274 )
275 );
276 assert_eq!(
277 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).w as *const _ as usize },
278 12usize,
279 concat!(
280 "Offset of field: ",
281 stringify!(cudaChannelFormatDesc),
282 "::",
283 stringify!(w)
284 )
285 );
286 assert_eq!(
287 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).f as *const _ as usize },
288 16usize,
289 concat!(
290 "Offset of field: ",
291 stringify!(cudaChannelFormatDesc),
292 "::",
293 stringify!(f)
294 )
295 );
296}
297impl Default for cudaChannelFormatDesc {
298 fn default() -> Self {
299 unsafe { ::std::mem::zeroed() }
300 }
301}
302#[repr(C)]
303#[derive(Debug, Copy, Clone)]
304pub struct cudaArray {
305 _unused: [u8; 0],
306}
307pub type cudaArray_t = *mut cudaArray;
308pub type cudaArray_const_t = *const cudaArray;
309#[repr(C)]
310#[derive(Debug, Copy, Clone)]
311pub struct cudaMipmappedArray {
312 _unused: [u8; 0],
313}
314pub type cudaMipmappedArray_t = *mut cudaMipmappedArray;
315pub type cudaMipmappedArray_const_t = *const cudaMipmappedArray;
316#[repr(u32)]
317#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
318pub enum cudaMemoryType {
319 cudaMemoryTypeUnregistered = 0,
320 cudaMemoryTypeHost = 1,
321 cudaMemoryTypeDevice = 2,
322 cudaMemoryTypeManaged = 3,
323}
324#[repr(u32)]
325#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
326pub enum cudaMemcpyKind {
327 cudaMemcpyHostToHost = 0,
328 cudaMemcpyHostToDevice = 1,
329 cudaMemcpyDeviceToHost = 2,
330 cudaMemcpyDeviceToDevice = 3,
331 cudaMemcpyDefault = 4,
332}
333#[repr(C)]
334#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
335pub struct cudaPitchedPtr {
336 pub ptr: *mut ::std::os::raw::c_void,
337 pub pitch: usize,
338 pub xsize: usize,
339 pub ysize: usize,
340}
341#[test]
342fn bindgen_test_layout_cudaPitchedPtr() {
343 assert_eq!(
344 ::std::mem::size_of::<cudaPitchedPtr>(),
345 32usize,
346 concat!("Size of: ", stringify!(cudaPitchedPtr))
347 );
348 assert_eq!(
349 ::std::mem::align_of::<cudaPitchedPtr>(),
350 8usize,
351 concat!("Alignment of ", stringify!(cudaPitchedPtr))
352 );
353 assert_eq!(
354 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).ptr as *const _ as usize },
355 0usize,
356 concat!(
357 "Offset of field: ",
358 stringify!(cudaPitchedPtr),
359 "::",
360 stringify!(ptr)
361 )
362 );
363 assert_eq!(
364 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).pitch as *const _ as usize },
365 8usize,
366 concat!(
367 "Offset of field: ",
368 stringify!(cudaPitchedPtr),
369 "::",
370 stringify!(pitch)
371 )
372 );
373 assert_eq!(
374 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).xsize as *const _ as usize },
375 16usize,
376 concat!(
377 "Offset of field: ",
378 stringify!(cudaPitchedPtr),
379 "::",
380 stringify!(xsize)
381 )
382 );
383 assert_eq!(
384 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).ysize as *const _ as usize },
385 24usize,
386 concat!(
387 "Offset of field: ",
388 stringify!(cudaPitchedPtr),
389 "::",
390 stringify!(ysize)
391 )
392 );
393}
394impl Default for cudaPitchedPtr {
395 fn default() -> Self {
396 unsafe { ::std::mem::zeroed() }
397 }
398}
399#[repr(C)]
400#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
401pub struct cudaExtent {
402 pub width: usize,
403 pub height: usize,
404 pub depth: usize,
405}
406#[test]
407fn bindgen_test_layout_cudaExtent() {
408 assert_eq!(
409 ::std::mem::size_of::<cudaExtent>(),
410 24usize,
411 concat!("Size of: ", stringify!(cudaExtent))
412 );
413 assert_eq!(
414 ::std::mem::align_of::<cudaExtent>(),
415 8usize,
416 concat!("Alignment of ", stringify!(cudaExtent))
417 );
418 assert_eq!(
419 unsafe { &(*(::std::ptr::null::<cudaExtent>())).width as *const _ as usize },
420 0usize,
421 concat!(
422 "Offset of field: ",
423 stringify!(cudaExtent),
424 "::",
425 stringify!(width)
426 )
427 );
428 assert_eq!(
429 unsafe { &(*(::std::ptr::null::<cudaExtent>())).height as *const _ as usize },
430 8usize,
431 concat!(
432 "Offset of field: ",
433 stringify!(cudaExtent),
434 "::",
435 stringify!(height)
436 )
437 );
438 assert_eq!(
439 unsafe { &(*(::std::ptr::null::<cudaExtent>())).depth as *const _ as usize },
440 16usize,
441 concat!(
442 "Offset of field: ",
443 stringify!(cudaExtent),
444 "::",
445 stringify!(depth)
446 )
447 );
448}
449#[repr(C)]
450#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
451pub struct cudaPos {
452 pub x: usize,
453 pub y: usize,
454 pub z: usize,
455}
456#[test]
457fn bindgen_test_layout_cudaPos() {
458 assert_eq!(
459 ::std::mem::size_of::<cudaPos>(),
460 24usize,
461 concat!("Size of: ", stringify!(cudaPos))
462 );
463 assert_eq!(
464 ::std::mem::align_of::<cudaPos>(),
465 8usize,
466 concat!("Alignment of ", stringify!(cudaPos))
467 );
468 assert_eq!(
469 unsafe { &(*(::std::ptr::null::<cudaPos>())).x as *const _ as usize },
470 0usize,
471 concat!(
472 "Offset of field: ",
473 stringify!(cudaPos),
474 "::",
475 stringify!(x)
476 )
477 );
478 assert_eq!(
479 unsafe { &(*(::std::ptr::null::<cudaPos>())).y as *const _ as usize },
480 8usize,
481 concat!(
482 "Offset of field: ",
483 stringify!(cudaPos),
484 "::",
485 stringify!(y)
486 )
487 );
488 assert_eq!(
489 unsafe { &(*(::std::ptr::null::<cudaPos>())).z as *const _ as usize },
490 16usize,
491 concat!(
492 "Offset of field: ",
493 stringify!(cudaPos),
494 "::",
495 stringify!(z)
496 )
497 );
498}
499#[repr(C)]
500#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
501pub struct cudaMemcpy3DParms {
502 pub srcArray: cudaArray_t,
503 pub srcPos: cudaPos,
504 pub srcPtr: cudaPitchedPtr,
505 pub dstArray: cudaArray_t,
506 pub dstPos: cudaPos,
507 pub dstPtr: cudaPitchedPtr,
508 pub extent: cudaExtent,
509 pub kind: cudaMemcpyKind,
510}
511#[test]
512fn bindgen_test_layout_cudaMemcpy3DParms() {
513 assert_eq!(
514 ::std::mem::size_of::<cudaMemcpy3DParms>(),
515 160usize,
516 concat!("Size of: ", stringify!(cudaMemcpy3DParms))
517 );
518 assert_eq!(
519 ::std::mem::align_of::<cudaMemcpy3DParms>(),
520 8usize,
521 concat!("Alignment of ", stringify!(cudaMemcpy3DParms))
522 );
523 assert_eq!(
524 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).srcArray as *const _ as usize },
525 0usize,
526 concat!(
527 "Offset of field: ",
528 stringify!(cudaMemcpy3DParms),
529 "::",
530 stringify!(srcArray)
531 )
532 );
533 assert_eq!(
534 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).srcPos as *const _ as usize },
535 8usize,
536 concat!(
537 "Offset of field: ",
538 stringify!(cudaMemcpy3DParms),
539 "::",
540 stringify!(srcPos)
541 )
542 );
543 assert_eq!(
544 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).srcPtr as *const _ as usize },
545 32usize,
546 concat!(
547 "Offset of field: ",
548 stringify!(cudaMemcpy3DParms),
549 "::",
550 stringify!(srcPtr)
551 )
552 );
553 assert_eq!(
554 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).dstArray as *const _ as usize },
555 64usize,
556 concat!(
557 "Offset of field: ",
558 stringify!(cudaMemcpy3DParms),
559 "::",
560 stringify!(dstArray)
561 )
562 );
563 assert_eq!(
564 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).dstPos as *const _ as usize },
565 72usize,
566 concat!(
567 "Offset of field: ",
568 stringify!(cudaMemcpy3DParms),
569 "::",
570 stringify!(dstPos)
571 )
572 );
573 assert_eq!(
574 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).dstPtr as *const _ as usize },
575 96usize,
576 concat!(
577 "Offset of field: ",
578 stringify!(cudaMemcpy3DParms),
579 "::",
580 stringify!(dstPtr)
581 )
582 );
583 assert_eq!(
584 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).extent as *const _ as usize },
585 128usize,
586 concat!(
587 "Offset of field: ",
588 stringify!(cudaMemcpy3DParms),
589 "::",
590 stringify!(extent)
591 )
592 );
593 assert_eq!(
594 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).kind as *const _ as usize },
595 152usize,
596 concat!(
597 "Offset of field: ",
598 stringify!(cudaMemcpy3DParms),
599 "::",
600 stringify!(kind)
601 )
602 );
603}
604impl Default for cudaMemcpy3DParms {
605 fn default() -> Self {
606 unsafe { ::std::mem::zeroed() }
607 }
608}
609#[repr(C)]
610#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
611pub struct cudaMemcpy3DPeerParms {
612 pub srcArray: cudaArray_t,
613 pub srcPos: cudaPos,
614 pub srcPtr: cudaPitchedPtr,
615 pub srcDevice: ::std::os::raw::c_int,
616 pub dstArray: cudaArray_t,
617 pub dstPos: cudaPos,
618 pub dstPtr: cudaPitchedPtr,
619 pub dstDevice: ::std::os::raw::c_int,
620 pub extent: cudaExtent,
621}
622#[test]
623fn bindgen_test_layout_cudaMemcpy3DPeerParms() {
624 assert_eq!(
625 ::std::mem::size_of::<cudaMemcpy3DPeerParms>(),
626 168usize,
627 concat!("Size of: ", stringify!(cudaMemcpy3DPeerParms))
628 );
629 assert_eq!(
630 ::std::mem::align_of::<cudaMemcpy3DPeerParms>(),
631 8usize,
632 concat!("Alignment of ", stringify!(cudaMemcpy3DPeerParms))
633 );
634 assert_eq!(
635 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcArray as *const _ as usize },
636 0usize,
637 concat!(
638 "Offset of field: ",
639 stringify!(cudaMemcpy3DPeerParms),
640 "::",
641 stringify!(srcArray)
642 )
643 );
644 assert_eq!(
645 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcPos as *const _ as usize },
646 8usize,
647 concat!(
648 "Offset of field: ",
649 stringify!(cudaMemcpy3DPeerParms),
650 "::",
651 stringify!(srcPos)
652 )
653 );
654 assert_eq!(
655 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcPtr as *const _ as usize },
656 32usize,
657 concat!(
658 "Offset of field: ",
659 stringify!(cudaMemcpy3DPeerParms),
660 "::",
661 stringify!(srcPtr)
662 )
663 );
664 assert_eq!(
665 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcDevice as *const _ as usize },
666 64usize,
667 concat!(
668 "Offset of field: ",
669 stringify!(cudaMemcpy3DPeerParms),
670 "::",
671 stringify!(srcDevice)
672 )
673 );
674 assert_eq!(
675 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstArray as *const _ as usize },
676 72usize,
677 concat!(
678 "Offset of field: ",
679 stringify!(cudaMemcpy3DPeerParms),
680 "::",
681 stringify!(dstArray)
682 )
683 );
684 assert_eq!(
685 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstPos as *const _ as usize },
686 80usize,
687 concat!(
688 "Offset of field: ",
689 stringify!(cudaMemcpy3DPeerParms),
690 "::",
691 stringify!(dstPos)
692 )
693 );
694 assert_eq!(
695 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstPtr as *const _ as usize },
696 104usize,
697 concat!(
698 "Offset of field: ",
699 stringify!(cudaMemcpy3DPeerParms),
700 "::",
701 stringify!(dstPtr)
702 )
703 );
704 assert_eq!(
705 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstDevice as *const _ as usize },
706 136usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(cudaMemcpy3DPeerParms),
710 "::",
711 stringify!(dstDevice)
712 )
713 );
714 assert_eq!(
715 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).extent as *const _ as usize },
716 144usize,
717 concat!(
718 "Offset of field: ",
719 stringify!(cudaMemcpy3DPeerParms),
720 "::",
721 stringify!(extent)
722 )
723 );
724}
725impl Default for cudaMemcpy3DPeerParms {
726 fn default() -> Self {
727 unsafe { ::std::mem::zeroed() }
728 }
729}
730#[repr(C)]
731#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
732pub struct cudaMemsetParams {
733 pub dst: *mut ::std::os::raw::c_void,
734 pub pitch: usize,
735 pub value: ::std::os::raw::c_uint,
736 pub elementSize: ::std::os::raw::c_uint,
737 pub width: usize,
738 pub height: usize,
739}
740#[test]
741fn bindgen_test_layout_cudaMemsetParams() {
742 assert_eq!(
743 ::std::mem::size_of::<cudaMemsetParams>(),
744 40usize,
745 concat!("Size of: ", stringify!(cudaMemsetParams))
746 );
747 assert_eq!(
748 ::std::mem::align_of::<cudaMemsetParams>(),
749 8usize,
750 concat!("Alignment of ", stringify!(cudaMemsetParams))
751 );
752 assert_eq!(
753 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).dst as *const _ as usize },
754 0usize,
755 concat!(
756 "Offset of field: ",
757 stringify!(cudaMemsetParams),
758 "::",
759 stringify!(dst)
760 )
761 );
762 assert_eq!(
763 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).pitch as *const _ as usize },
764 8usize,
765 concat!(
766 "Offset of field: ",
767 stringify!(cudaMemsetParams),
768 "::",
769 stringify!(pitch)
770 )
771 );
772 assert_eq!(
773 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).value as *const _ as usize },
774 16usize,
775 concat!(
776 "Offset of field: ",
777 stringify!(cudaMemsetParams),
778 "::",
779 stringify!(value)
780 )
781 );
782 assert_eq!(
783 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).elementSize as *const _ as usize },
784 20usize,
785 concat!(
786 "Offset of field: ",
787 stringify!(cudaMemsetParams),
788 "::",
789 stringify!(elementSize)
790 )
791 );
792 assert_eq!(
793 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).width as *const _ as usize },
794 24usize,
795 concat!(
796 "Offset of field: ",
797 stringify!(cudaMemsetParams),
798 "::",
799 stringify!(width)
800 )
801 );
802 assert_eq!(
803 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).height as *const _ as usize },
804 32usize,
805 concat!(
806 "Offset of field: ",
807 stringify!(cudaMemsetParams),
808 "::",
809 stringify!(height)
810 )
811 );
812}
813impl Default for cudaMemsetParams {
814 fn default() -> Self {
815 unsafe { ::std::mem::zeroed() }
816 }
817}
818pub type cudaHostFn_t =
819 ::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void)>;
820#[repr(C)]
821#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
822pub struct cudaHostNodeParams {
823 pub fn_: cudaHostFn_t,
824 pub userData: *mut ::std::os::raw::c_void,
825}
826#[test]
827fn bindgen_test_layout_cudaHostNodeParams() {
828 assert_eq!(
829 ::std::mem::size_of::<cudaHostNodeParams>(),
830 16usize,
831 concat!("Size of: ", stringify!(cudaHostNodeParams))
832 );
833 assert_eq!(
834 ::std::mem::align_of::<cudaHostNodeParams>(),
835 8usize,
836 concat!("Alignment of ", stringify!(cudaHostNodeParams))
837 );
838 assert_eq!(
839 unsafe { &(*(::std::ptr::null::<cudaHostNodeParams>())).fn_ as *const _ as usize },
840 0usize,
841 concat!(
842 "Offset of field: ",
843 stringify!(cudaHostNodeParams),
844 "::",
845 stringify!(fn_)
846 )
847 );
848 assert_eq!(
849 unsafe { &(*(::std::ptr::null::<cudaHostNodeParams>())).userData as *const _ as usize },
850 8usize,
851 concat!(
852 "Offset of field: ",
853 stringify!(cudaHostNodeParams),
854 "::",
855 stringify!(userData)
856 )
857 );
858}
859impl Default for cudaHostNodeParams {
860 fn default() -> Self {
861 unsafe { ::std::mem::zeroed() }
862 }
863}
864#[repr(u32)]
865#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
866pub enum cudaStreamCaptureStatus {
867 cudaStreamCaptureStatusNone = 0,
868 cudaStreamCaptureStatusActive = 1,
869 cudaStreamCaptureStatusInvalidated = 2,
870}
871#[repr(u32)]
872#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
873pub enum cudaStreamCaptureMode {
874 cudaStreamCaptureModeGlobal = 0,
875 cudaStreamCaptureModeThreadLocal = 1,
876 cudaStreamCaptureModeRelaxed = 2,
877}
878#[repr(C)]
879#[derive(Debug, Copy, Clone)]
880pub struct cudaGraphicsResource {
881 _unused: [u8; 0],
882}
883#[repr(u32)]
884#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
885pub enum cudaGraphicsRegisterFlags {
886 cudaGraphicsRegisterFlagsNone = 0,
887 cudaGraphicsRegisterFlagsReadOnly = 1,
888 cudaGraphicsRegisterFlagsWriteDiscard = 2,
889 cudaGraphicsRegisterFlagsSurfaceLoadStore = 4,
890 cudaGraphicsRegisterFlagsTextureGather = 8,
891}
892#[repr(u32)]
893#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
894pub enum cudaGraphicsMapFlags {
895 cudaGraphicsMapFlagsNone = 0,
896 cudaGraphicsMapFlagsReadOnly = 1,
897 cudaGraphicsMapFlagsWriteDiscard = 2,
898}
899#[repr(u32)]
900#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
901pub enum cudaGraphicsCubeFace {
902 cudaGraphicsCubeFacePositiveX = 0,
903 cudaGraphicsCubeFaceNegativeX = 1,
904 cudaGraphicsCubeFacePositiveY = 2,
905 cudaGraphicsCubeFaceNegativeY = 3,
906 cudaGraphicsCubeFacePositiveZ = 4,
907 cudaGraphicsCubeFaceNegativeZ = 5,
908}
909#[repr(u32)]
910#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
911pub enum cudaResourceType {
912 cudaResourceTypeArray = 0,
913 cudaResourceTypeMipmappedArray = 1,
914 cudaResourceTypeLinear = 2,
915 cudaResourceTypePitch2D = 3,
916}
917#[repr(u32)]
918#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
919pub enum cudaResourceViewFormat {
920 cudaResViewFormatNone = 0,
921 cudaResViewFormatUnsignedChar1 = 1,
922 cudaResViewFormatUnsignedChar2 = 2,
923 cudaResViewFormatUnsignedChar4 = 3,
924 cudaResViewFormatSignedChar1 = 4,
925 cudaResViewFormatSignedChar2 = 5,
926 cudaResViewFormatSignedChar4 = 6,
927 cudaResViewFormatUnsignedShort1 = 7,
928 cudaResViewFormatUnsignedShort2 = 8,
929 cudaResViewFormatUnsignedShort4 = 9,
930 cudaResViewFormatSignedShort1 = 10,
931 cudaResViewFormatSignedShort2 = 11,
932 cudaResViewFormatSignedShort4 = 12,
933 cudaResViewFormatUnsignedInt1 = 13,
934 cudaResViewFormatUnsignedInt2 = 14,
935 cudaResViewFormatUnsignedInt4 = 15,
936 cudaResViewFormatSignedInt1 = 16,
937 cudaResViewFormatSignedInt2 = 17,
938 cudaResViewFormatSignedInt4 = 18,
939 cudaResViewFormatHalf1 = 19,
940 cudaResViewFormatHalf2 = 20,
941 cudaResViewFormatHalf4 = 21,
942 cudaResViewFormatFloat1 = 22,
943 cudaResViewFormatFloat2 = 23,
944 cudaResViewFormatFloat4 = 24,
945 cudaResViewFormatUnsignedBlockCompressed1 = 25,
946 cudaResViewFormatUnsignedBlockCompressed2 = 26,
947 cudaResViewFormatUnsignedBlockCompressed3 = 27,
948 cudaResViewFormatUnsignedBlockCompressed4 = 28,
949 cudaResViewFormatSignedBlockCompressed4 = 29,
950 cudaResViewFormatUnsignedBlockCompressed5 = 30,
951 cudaResViewFormatSignedBlockCompressed5 = 31,
952 cudaResViewFormatUnsignedBlockCompressed6H = 32,
953 cudaResViewFormatSignedBlockCompressed6H = 33,
954 cudaResViewFormatUnsignedBlockCompressed7 = 34,
955}
956#[repr(C)]
957#[derive(Copy, Clone)]
958pub struct cudaResourceDesc {
959 pub resType: cudaResourceType,
960 pub res: cudaResourceDesc__bindgen_ty_1,
961}
962#[repr(C)]
963#[derive(Copy, Clone)]
964pub union cudaResourceDesc__bindgen_ty_1 {
965 pub array: cudaResourceDesc__bindgen_ty_1__bindgen_ty_1,
966 pub mipmap: cudaResourceDesc__bindgen_ty_1__bindgen_ty_2,
967 pub linear: cudaResourceDesc__bindgen_ty_1__bindgen_ty_3,
968 pub pitch2D: cudaResourceDesc__bindgen_ty_1__bindgen_ty_4,
969 _bindgen_union_align: [u64; 7usize],
970}
971#[repr(C)]
972#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
973pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_1 {
974 pub array: cudaArray_t,
975}
976#[test]
977fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_1() {
978 assert_eq!(
979 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_1>(),
980 8usize,
981 concat!(
982 "Size of: ",
983 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_1)
984 )
985 );
986 assert_eq!(
987 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_1>(),
988 8usize,
989 concat!(
990 "Alignment of ",
991 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_1)
992 )
993 );
994 assert_eq!(
995 unsafe {
996 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_1>())).array
997 as *const _ as usize
998 },
999 0usize,
1000 concat!(
1001 "Offset of field: ",
1002 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_1),
1003 "::",
1004 stringify!(array)
1005 )
1006 );
1007}
1008impl Default for cudaResourceDesc__bindgen_ty_1__bindgen_ty_1 {
1009 fn default() -> Self {
1010 unsafe { ::std::mem::zeroed() }
1011 }
1012}
1013#[repr(C)]
1014#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1015pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_2 {
1016 pub mipmap: cudaMipmappedArray_t,
1017}
1018#[test]
1019fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_2() {
1020 assert_eq!(
1021 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_2>(),
1022 8usize,
1023 concat!(
1024 "Size of: ",
1025 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_2)
1026 )
1027 );
1028 assert_eq!(
1029 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_2>(),
1030 8usize,
1031 concat!(
1032 "Alignment of ",
1033 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_2)
1034 )
1035 );
1036 assert_eq!(
1037 unsafe {
1038 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_2>())).mipmap
1039 as *const _ as usize
1040 },
1041 0usize,
1042 concat!(
1043 "Offset of field: ",
1044 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_2),
1045 "::",
1046 stringify!(mipmap)
1047 )
1048 );
1049}
1050impl Default for cudaResourceDesc__bindgen_ty_1__bindgen_ty_2 {
1051 fn default() -> Self {
1052 unsafe { ::std::mem::zeroed() }
1053 }
1054}
1055#[repr(C)]
1056#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1057pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_3 {
1058 pub devPtr: *mut ::std::os::raw::c_void,
1059 pub desc: cudaChannelFormatDesc,
1060 pub sizeInBytes: usize,
1061}
1062#[test]
1063fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_3() {
1064 assert_eq!(
1065 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>(),
1066 40usize,
1067 concat!(
1068 "Size of: ",
1069 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3)
1070 )
1071 );
1072 assert_eq!(
1073 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>(),
1074 8usize,
1075 concat!(
1076 "Alignment of ",
1077 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3)
1078 )
1079 );
1080 assert_eq!(
1081 unsafe {
1082 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>())).devPtr
1083 as *const _ as usize
1084 },
1085 0usize,
1086 concat!(
1087 "Offset of field: ",
1088 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3),
1089 "::",
1090 stringify!(devPtr)
1091 )
1092 );
1093 assert_eq!(
1094 unsafe {
1095 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>())).desc
1096 as *const _ as usize
1097 },
1098 8usize,
1099 concat!(
1100 "Offset of field: ",
1101 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3),
1102 "::",
1103 stringify!(desc)
1104 )
1105 );
1106 assert_eq!(
1107 unsafe {
1108 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>())).sizeInBytes
1109 as *const _ as usize
1110 },
1111 32usize,
1112 concat!(
1113 "Offset of field: ",
1114 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3),
1115 "::",
1116 stringify!(sizeInBytes)
1117 )
1118 );
1119}
1120impl Default for cudaResourceDesc__bindgen_ty_1__bindgen_ty_3 {
1121 fn default() -> Self {
1122 unsafe { ::std::mem::zeroed() }
1123 }
1124}
1125#[repr(C)]
1126#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1127pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_4 {
1128 pub devPtr: *mut ::std::os::raw::c_void,
1129 pub desc: cudaChannelFormatDesc,
1130 pub width: usize,
1131 pub height: usize,
1132 pub pitchInBytes: usize,
1133}
1134#[test]
1135fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_4() {
1136 assert_eq!(
1137 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>(),
1138 56usize,
1139 concat!(
1140 "Size of: ",
1141 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4)
1142 )
1143 );
1144 assert_eq!(
1145 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>(),
1146 8usize,
1147 concat!(
1148 "Alignment of ",
1149 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4)
1150 )
1151 );
1152 assert_eq!(
1153 unsafe {
1154 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).devPtr
1155 as *const _ as usize
1156 },
1157 0usize,
1158 concat!(
1159 "Offset of field: ",
1160 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
1161 "::",
1162 stringify!(devPtr)
1163 )
1164 );
1165 assert_eq!(
1166 unsafe {
1167 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).desc
1168 as *const _ as usize
1169 },
1170 8usize,
1171 concat!(
1172 "Offset of field: ",
1173 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
1174 "::",
1175 stringify!(desc)
1176 )
1177 );
1178 assert_eq!(
1179 unsafe {
1180 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).width
1181 as *const _ as usize
1182 },
1183 32usize,
1184 concat!(
1185 "Offset of field: ",
1186 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
1187 "::",
1188 stringify!(width)
1189 )
1190 );
1191 assert_eq!(
1192 unsafe {
1193 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).height
1194 as *const _ as usize
1195 },
1196 40usize,
1197 concat!(
1198 "Offset of field: ",
1199 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
1200 "::",
1201 stringify!(height)
1202 )
1203 );
1204 assert_eq!(
1205 unsafe {
1206 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).pitchInBytes
1207 as *const _ as usize
1208 },
1209 48usize,
1210 concat!(
1211 "Offset of field: ",
1212 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
1213 "::",
1214 stringify!(pitchInBytes)
1215 )
1216 );
1217}
1218impl Default for cudaResourceDesc__bindgen_ty_1__bindgen_ty_4 {
1219 fn default() -> Self {
1220 unsafe { ::std::mem::zeroed() }
1221 }
1222}
1223#[test]
1224fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1() {
1225 assert_eq!(
1226 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1>(),
1227 56usize,
1228 concat!("Size of: ", stringify!(cudaResourceDesc__bindgen_ty_1))
1229 );
1230 assert_eq!(
1231 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1>(),
1232 8usize,
1233 concat!("Alignment of ", stringify!(cudaResourceDesc__bindgen_ty_1))
1234 );
1235 assert_eq!(
1236 unsafe {
1237 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).array as *const _ as usize
1238 },
1239 0usize,
1240 concat!(
1241 "Offset of field: ",
1242 stringify!(cudaResourceDesc__bindgen_ty_1),
1243 "::",
1244 stringify!(array)
1245 )
1246 );
1247 assert_eq!(
1248 unsafe {
1249 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).mipmap as *const _ as usize
1250 },
1251 0usize,
1252 concat!(
1253 "Offset of field: ",
1254 stringify!(cudaResourceDesc__bindgen_ty_1),
1255 "::",
1256 stringify!(mipmap)
1257 )
1258 );
1259 assert_eq!(
1260 unsafe {
1261 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).linear as *const _ as usize
1262 },
1263 0usize,
1264 concat!(
1265 "Offset of field: ",
1266 stringify!(cudaResourceDesc__bindgen_ty_1),
1267 "::",
1268 stringify!(linear)
1269 )
1270 );
1271 assert_eq!(
1272 unsafe {
1273 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).pitch2D as *const _ as usize
1274 },
1275 0usize,
1276 concat!(
1277 "Offset of field: ",
1278 stringify!(cudaResourceDesc__bindgen_ty_1),
1279 "::",
1280 stringify!(pitch2D)
1281 )
1282 );
1283}
1284impl Default for cudaResourceDesc__bindgen_ty_1 {
1285 fn default() -> Self {
1286 unsafe { ::std::mem::zeroed() }
1287 }
1288}
1289#[test]
1290fn bindgen_test_layout_cudaResourceDesc() {
1291 assert_eq!(
1292 ::std::mem::size_of::<cudaResourceDesc>(),
1293 64usize,
1294 concat!("Size of: ", stringify!(cudaResourceDesc))
1295 );
1296 assert_eq!(
1297 ::std::mem::align_of::<cudaResourceDesc>(),
1298 8usize,
1299 concat!("Alignment of ", stringify!(cudaResourceDesc))
1300 );
1301 assert_eq!(
1302 unsafe { &(*(::std::ptr::null::<cudaResourceDesc>())).resType as *const _ as usize },
1303 0usize,
1304 concat!(
1305 "Offset of field: ",
1306 stringify!(cudaResourceDesc),
1307 "::",
1308 stringify!(resType)
1309 )
1310 );
1311 assert_eq!(
1312 unsafe { &(*(::std::ptr::null::<cudaResourceDesc>())).res as *const _ as usize },
1313 8usize,
1314 concat!(
1315 "Offset of field: ",
1316 stringify!(cudaResourceDesc),
1317 "::",
1318 stringify!(res)
1319 )
1320 );
1321}
1322impl Default for cudaResourceDesc {
1323 fn default() -> Self {
1324 unsafe { ::std::mem::zeroed() }
1325 }
1326}
1327#[repr(C)]
1328#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1329pub struct cudaResourceViewDesc {
1330 pub format: cudaResourceViewFormat,
1331 pub width: usize,
1332 pub height: usize,
1333 pub depth: usize,
1334 pub firstMipmapLevel: ::std::os::raw::c_uint,
1335 pub lastMipmapLevel: ::std::os::raw::c_uint,
1336 pub firstLayer: ::std::os::raw::c_uint,
1337 pub lastLayer: ::std::os::raw::c_uint,
1338}
1339#[test]
1340fn bindgen_test_layout_cudaResourceViewDesc() {
1341 assert_eq!(
1342 ::std::mem::size_of::<cudaResourceViewDesc>(),
1343 48usize,
1344 concat!("Size of: ", stringify!(cudaResourceViewDesc))
1345 );
1346 assert_eq!(
1347 ::std::mem::align_of::<cudaResourceViewDesc>(),
1348 8usize,
1349 concat!("Alignment of ", stringify!(cudaResourceViewDesc))
1350 );
1351 assert_eq!(
1352 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).format as *const _ as usize },
1353 0usize,
1354 concat!(
1355 "Offset of field: ",
1356 stringify!(cudaResourceViewDesc),
1357 "::",
1358 stringify!(format)
1359 )
1360 );
1361 assert_eq!(
1362 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).width as *const _ as usize },
1363 8usize,
1364 concat!(
1365 "Offset of field: ",
1366 stringify!(cudaResourceViewDesc),
1367 "::",
1368 stringify!(width)
1369 )
1370 );
1371 assert_eq!(
1372 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).height as *const _ as usize },
1373 16usize,
1374 concat!(
1375 "Offset of field: ",
1376 stringify!(cudaResourceViewDesc),
1377 "::",
1378 stringify!(height)
1379 )
1380 );
1381 assert_eq!(
1382 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).depth as *const _ as usize },
1383 24usize,
1384 concat!(
1385 "Offset of field: ",
1386 stringify!(cudaResourceViewDesc),
1387 "::",
1388 stringify!(depth)
1389 )
1390 );
1391 assert_eq!(
1392 unsafe {
1393 &(*(::std::ptr::null::<cudaResourceViewDesc>())).firstMipmapLevel as *const _ as usize
1394 },
1395 32usize,
1396 concat!(
1397 "Offset of field: ",
1398 stringify!(cudaResourceViewDesc),
1399 "::",
1400 stringify!(firstMipmapLevel)
1401 )
1402 );
1403 assert_eq!(
1404 unsafe {
1405 &(*(::std::ptr::null::<cudaResourceViewDesc>())).lastMipmapLevel as *const _ as usize
1406 },
1407 36usize,
1408 concat!(
1409 "Offset of field: ",
1410 stringify!(cudaResourceViewDesc),
1411 "::",
1412 stringify!(lastMipmapLevel)
1413 )
1414 );
1415 assert_eq!(
1416 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).firstLayer as *const _ as usize },
1417 40usize,
1418 concat!(
1419 "Offset of field: ",
1420 stringify!(cudaResourceViewDesc),
1421 "::",
1422 stringify!(firstLayer)
1423 )
1424 );
1425 assert_eq!(
1426 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).lastLayer as *const _ as usize },
1427 44usize,
1428 concat!(
1429 "Offset of field: ",
1430 stringify!(cudaResourceViewDesc),
1431 "::",
1432 stringify!(lastLayer)
1433 )
1434 );
1435}
1436impl Default for cudaResourceViewDesc {
1437 fn default() -> Self {
1438 unsafe { ::std::mem::zeroed() }
1439 }
1440}
1441#[repr(C)]
1442#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1443pub struct cudaPointerAttributes {
1444 pub memoryType: cudaMemoryType,
1445 pub type_: cudaMemoryType,
1446 pub device: ::std::os::raw::c_int,
1447 pub devicePointer: *mut ::std::os::raw::c_void,
1448 pub hostPointer: *mut ::std::os::raw::c_void,
1449 pub isManaged: ::std::os::raw::c_int,
1450}
1451#[test]
1452fn bindgen_test_layout_cudaPointerAttributes() {
1453 assert_eq!(
1454 ::std::mem::size_of::<cudaPointerAttributes>(),
1455 40usize,
1456 concat!("Size of: ", stringify!(cudaPointerAttributes))
1457 );
1458 assert_eq!(
1459 ::std::mem::align_of::<cudaPointerAttributes>(),
1460 8usize,
1461 concat!("Alignment of ", stringify!(cudaPointerAttributes))
1462 );
1463 assert_eq!(
1464 unsafe {
1465 &(*(::std::ptr::null::<cudaPointerAttributes>())).memoryType as *const _ as usize
1466 },
1467 0usize,
1468 concat!(
1469 "Offset of field: ",
1470 stringify!(cudaPointerAttributes),
1471 "::",
1472 stringify!(memoryType)
1473 )
1474 );
1475 assert_eq!(
1476 unsafe { &(*(::std::ptr::null::<cudaPointerAttributes>())).type_ as *const _ as usize },
1477 4usize,
1478 concat!(
1479 "Offset of field: ",
1480 stringify!(cudaPointerAttributes),
1481 "::",
1482 stringify!(type_)
1483 )
1484 );
1485 assert_eq!(
1486 unsafe { &(*(::std::ptr::null::<cudaPointerAttributes>())).device as *const _ as usize },
1487 8usize,
1488 concat!(
1489 "Offset of field: ",
1490 stringify!(cudaPointerAttributes),
1491 "::",
1492 stringify!(device)
1493 )
1494 );
1495 assert_eq!(
1496 unsafe {
1497 &(*(::std::ptr::null::<cudaPointerAttributes>())).devicePointer as *const _ as usize
1498 },
1499 16usize,
1500 concat!(
1501 "Offset of field: ",
1502 stringify!(cudaPointerAttributes),
1503 "::",
1504 stringify!(devicePointer)
1505 )
1506 );
1507 assert_eq!(
1508 unsafe {
1509 &(*(::std::ptr::null::<cudaPointerAttributes>())).hostPointer as *const _ as usize
1510 },
1511 24usize,
1512 concat!(
1513 "Offset of field: ",
1514 stringify!(cudaPointerAttributes),
1515 "::",
1516 stringify!(hostPointer)
1517 )
1518 );
1519 assert_eq!(
1520 unsafe { &(*(::std::ptr::null::<cudaPointerAttributes>())).isManaged as *const _ as usize },
1521 32usize,
1522 concat!(
1523 "Offset of field: ",
1524 stringify!(cudaPointerAttributes),
1525 "::",
1526 stringify!(isManaged)
1527 )
1528 );
1529}
1530impl Default for cudaPointerAttributes {
1531 fn default() -> Self {
1532 unsafe { ::std::mem::zeroed() }
1533 }
1534}
1535#[repr(C)]
1536#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1537pub struct cudaFuncAttributes {
1538 pub sharedSizeBytes: usize,
1539 pub constSizeBytes: usize,
1540 pub localSizeBytes: usize,
1541 pub maxThreadsPerBlock: ::std::os::raw::c_int,
1542 pub numRegs: ::std::os::raw::c_int,
1543 pub ptxVersion: ::std::os::raw::c_int,
1544 pub binaryVersion: ::std::os::raw::c_int,
1545 pub cacheModeCA: ::std::os::raw::c_int,
1546 pub maxDynamicSharedSizeBytes: ::std::os::raw::c_int,
1547 pub preferredShmemCarveout: ::std::os::raw::c_int,
1548}
1549#[test]
1550fn bindgen_test_layout_cudaFuncAttributes() {
1551 assert_eq!(
1552 ::std::mem::size_of::<cudaFuncAttributes>(),
1553 56usize,
1554 concat!("Size of: ", stringify!(cudaFuncAttributes))
1555 );
1556 assert_eq!(
1557 ::std::mem::align_of::<cudaFuncAttributes>(),
1558 8usize,
1559 concat!("Alignment of ", stringify!(cudaFuncAttributes))
1560 );
1561 assert_eq!(
1562 unsafe {
1563 &(*(::std::ptr::null::<cudaFuncAttributes>())).sharedSizeBytes as *const _ as usize
1564 },
1565 0usize,
1566 concat!(
1567 "Offset of field: ",
1568 stringify!(cudaFuncAttributes),
1569 "::",
1570 stringify!(sharedSizeBytes)
1571 )
1572 );
1573 assert_eq!(
1574 unsafe {
1575 &(*(::std::ptr::null::<cudaFuncAttributes>())).constSizeBytes as *const _ as usize
1576 },
1577 8usize,
1578 concat!(
1579 "Offset of field: ",
1580 stringify!(cudaFuncAttributes),
1581 "::",
1582 stringify!(constSizeBytes)
1583 )
1584 );
1585 assert_eq!(
1586 unsafe {
1587 &(*(::std::ptr::null::<cudaFuncAttributes>())).localSizeBytes as *const _ as usize
1588 },
1589 16usize,
1590 concat!(
1591 "Offset of field: ",
1592 stringify!(cudaFuncAttributes),
1593 "::",
1594 stringify!(localSizeBytes)
1595 )
1596 );
1597 assert_eq!(
1598 unsafe {
1599 &(*(::std::ptr::null::<cudaFuncAttributes>())).maxThreadsPerBlock as *const _ as usize
1600 },
1601 24usize,
1602 concat!(
1603 "Offset of field: ",
1604 stringify!(cudaFuncAttributes),
1605 "::",
1606 stringify!(maxThreadsPerBlock)
1607 )
1608 );
1609 assert_eq!(
1610 unsafe { &(*(::std::ptr::null::<cudaFuncAttributes>())).numRegs as *const _ as usize },
1611 28usize,
1612 concat!(
1613 "Offset of field: ",
1614 stringify!(cudaFuncAttributes),
1615 "::",
1616 stringify!(numRegs)
1617 )
1618 );
1619 assert_eq!(
1620 unsafe { &(*(::std::ptr::null::<cudaFuncAttributes>())).ptxVersion as *const _ as usize },
1621 32usize,
1622 concat!(
1623 "Offset of field: ",
1624 stringify!(cudaFuncAttributes),
1625 "::",
1626 stringify!(ptxVersion)
1627 )
1628 );
1629 assert_eq!(
1630 unsafe {
1631 &(*(::std::ptr::null::<cudaFuncAttributes>())).binaryVersion as *const _ as usize
1632 },
1633 36usize,
1634 concat!(
1635 "Offset of field: ",
1636 stringify!(cudaFuncAttributes),
1637 "::",
1638 stringify!(binaryVersion)
1639 )
1640 );
1641 assert_eq!(
1642 unsafe { &(*(::std::ptr::null::<cudaFuncAttributes>())).cacheModeCA as *const _ as usize },
1643 40usize,
1644 concat!(
1645 "Offset of field: ",
1646 stringify!(cudaFuncAttributes),
1647 "::",
1648 stringify!(cacheModeCA)
1649 )
1650 );
1651 assert_eq!(
1652 unsafe {
1653 &(*(::std::ptr::null::<cudaFuncAttributes>())).maxDynamicSharedSizeBytes as *const _
1654 as usize
1655 },
1656 44usize,
1657 concat!(
1658 "Offset of field: ",
1659 stringify!(cudaFuncAttributes),
1660 "::",
1661 stringify!(maxDynamicSharedSizeBytes)
1662 )
1663 );
1664 assert_eq!(
1665 unsafe {
1666 &(*(::std::ptr::null::<cudaFuncAttributes>())).preferredShmemCarveout as *const _
1667 as usize
1668 },
1669 48usize,
1670 concat!(
1671 "Offset of field: ",
1672 stringify!(cudaFuncAttributes),
1673 "::",
1674 stringify!(preferredShmemCarveout)
1675 )
1676 );
1677}
1678#[repr(u32)]
1679#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1680pub enum cudaFuncAttribute {
1681 cudaFuncAttributeMaxDynamicSharedMemorySize = 8,
1682 cudaFuncAttributePreferredSharedMemoryCarveout = 9,
1683 cudaFuncAttributeMax = 10,
1684}
1685#[repr(u32)]
1686#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1687pub enum cudaFuncCache {
1688 cudaFuncCachePreferNone = 0,
1689 cudaFuncCachePreferShared = 1,
1690 cudaFuncCachePreferL1 = 2,
1691 cudaFuncCachePreferEqual = 3,
1692}
1693#[repr(u32)]
1694#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1695pub enum cudaSharedMemConfig {
1696 cudaSharedMemBankSizeDefault = 0,
1697 cudaSharedMemBankSizeFourByte = 1,
1698 cudaSharedMemBankSizeEightByte = 2,
1699}
1700#[repr(i32)]
1701#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1702pub enum cudaSharedCarveout {
1703 cudaSharedmemCarveoutDefault = -1,
1704 cudaSharedmemCarveoutMaxShared = 100,
1705 cudaSharedmemCarveoutMaxL1 = 0,
1706}
1707#[repr(u32)]
1708#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1709pub enum cudaComputeMode {
1710 cudaComputeModeDefault = 0,
1711 cudaComputeModeExclusive = 1,
1712 cudaComputeModeProhibited = 2,
1713 cudaComputeModeExclusiveProcess = 3,
1714}
1715#[repr(u32)]
1716#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1717pub enum cudaLimit {
1718 cudaLimitStackSize = 0,
1719 cudaLimitPrintfFifoSize = 1,
1720 cudaLimitMallocHeapSize = 2,
1721 cudaLimitDevRuntimeSyncDepth = 3,
1722 cudaLimitDevRuntimePendingLaunchCount = 4,
1723 cudaLimitMaxL2FetchGranularity = 5,
1724}
1725#[repr(u32)]
1726#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1727pub enum cudaMemoryAdvise {
1728 cudaMemAdviseSetReadMostly = 1,
1729 cudaMemAdviseUnsetReadMostly = 2,
1730 cudaMemAdviseSetPreferredLocation = 3,
1731 cudaMemAdviseUnsetPreferredLocation = 4,
1732 cudaMemAdviseSetAccessedBy = 5,
1733 cudaMemAdviseUnsetAccessedBy = 6,
1734}
1735#[repr(u32)]
1736#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1737pub enum cudaMemRangeAttribute {
1738 cudaMemRangeAttributeReadMostly = 1,
1739 cudaMemRangeAttributePreferredLocation = 2,
1740 cudaMemRangeAttributeAccessedBy = 3,
1741 cudaMemRangeAttributeLastPrefetchLocation = 4,
1742}
1743#[repr(u32)]
1744#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1745pub enum cudaOutputMode {
1746 cudaKeyValuePair = 0,
1747 cudaCSV = 1,
1748}
1749#[repr(u32)]
1750#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1751pub enum cudaDeviceAttr {
1752 cudaDevAttrMaxThreadsPerBlock = 1,
1753 cudaDevAttrMaxBlockDimX = 2,
1754 cudaDevAttrMaxBlockDimY = 3,
1755 cudaDevAttrMaxBlockDimZ = 4,
1756 cudaDevAttrMaxGridDimX = 5,
1757 cudaDevAttrMaxGridDimY = 6,
1758 cudaDevAttrMaxGridDimZ = 7,
1759 cudaDevAttrMaxSharedMemoryPerBlock = 8,
1760 cudaDevAttrTotalConstantMemory = 9,
1761 cudaDevAttrWarpSize = 10,
1762 cudaDevAttrMaxPitch = 11,
1763 cudaDevAttrMaxRegistersPerBlock = 12,
1764 cudaDevAttrClockRate = 13,
1765 cudaDevAttrTextureAlignment = 14,
1766 cudaDevAttrGpuOverlap = 15,
1767 cudaDevAttrMultiProcessorCount = 16,
1768 cudaDevAttrKernelExecTimeout = 17,
1769 cudaDevAttrIntegrated = 18,
1770 cudaDevAttrCanMapHostMemory = 19,
1771 cudaDevAttrComputeMode = 20,
1772 cudaDevAttrMaxTexture1DWidth = 21,
1773 cudaDevAttrMaxTexture2DWidth = 22,
1774 cudaDevAttrMaxTexture2DHeight = 23,
1775 cudaDevAttrMaxTexture3DWidth = 24,
1776 cudaDevAttrMaxTexture3DHeight = 25,
1777 cudaDevAttrMaxTexture3DDepth = 26,
1778 cudaDevAttrMaxTexture2DLayeredWidth = 27,
1779 cudaDevAttrMaxTexture2DLayeredHeight = 28,
1780 cudaDevAttrMaxTexture2DLayeredLayers = 29,
1781 cudaDevAttrSurfaceAlignment = 30,
1782 cudaDevAttrConcurrentKernels = 31,
1783 cudaDevAttrEccEnabled = 32,
1784 cudaDevAttrPciBusId = 33,
1785 cudaDevAttrPciDeviceId = 34,
1786 cudaDevAttrTccDriver = 35,
1787 cudaDevAttrMemoryClockRate = 36,
1788 cudaDevAttrGlobalMemoryBusWidth = 37,
1789 cudaDevAttrL2CacheSize = 38,
1790 cudaDevAttrMaxThreadsPerMultiProcessor = 39,
1791 cudaDevAttrAsyncEngineCount = 40,
1792 cudaDevAttrUnifiedAddressing = 41,
1793 cudaDevAttrMaxTexture1DLayeredWidth = 42,
1794 cudaDevAttrMaxTexture1DLayeredLayers = 43,
1795 cudaDevAttrMaxTexture2DGatherWidth = 45,
1796 cudaDevAttrMaxTexture2DGatherHeight = 46,
1797 cudaDevAttrMaxTexture3DWidthAlt = 47,
1798 cudaDevAttrMaxTexture3DHeightAlt = 48,
1799 cudaDevAttrMaxTexture3DDepthAlt = 49,
1800 cudaDevAttrPciDomainId = 50,
1801 cudaDevAttrTexturePitchAlignment = 51,
1802 cudaDevAttrMaxTextureCubemapWidth = 52,
1803 cudaDevAttrMaxTextureCubemapLayeredWidth = 53,
1804 cudaDevAttrMaxTextureCubemapLayeredLayers = 54,
1805 cudaDevAttrMaxSurface1DWidth = 55,
1806 cudaDevAttrMaxSurface2DWidth = 56,
1807 cudaDevAttrMaxSurface2DHeight = 57,
1808 cudaDevAttrMaxSurface3DWidth = 58,
1809 cudaDevAttrMaxSurface3DHeight = 59,
1810 cudaDevAttrMaxSurface3DDepth = 60,
1811 cudaDevAttrMaxSurface1DLayeredWidth = 61,
1812 cudaDevAttrMaxSurface1DLayeredLayers = 62,
1813 cudaDevAttrMaxSurface2DLayeredWidth = 63,
1814 cudaDevAttrMaxSurface2DLayeredHeight = 64,
1815 cudaDevAttrMaxSurface2DLayeredLayers = 65,
1816 cudaDevAttrMaxSurfaceCubemapWidth = 66,
1817 cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67,
1818 cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68,
1819 cudaDevAttrMaxTexture1DLinearWidth = 69,
1820 cudaDevAttrMaxTexture2DLinearWidth = 70,
1821 cudaDevAttrMaxTexture2DLinearHeight = 71,
1822 cudaDevAttrMaxTexture2DLinearPitch = 72,
1823 cudaDevAttrMaxTexture2DMipmappedWidth = 73,
1824 cudaDevAttrMaxTexture2DMipmappedHeight = 74,
1825 cudaDevAttrComputeCapabilityMajor = 75,
1826 cudaDevAttrComputeCapabilityMinor = 76,
1827 cudaDevAttrMaxTexture1DMipmappedWidth = 77,
1828 cudaDevAttrStreamPrioritiesSupported = 78,
1829 cudaDevAttrGlobalL1CacheSupported = 79,
1830 cudaDevAttrLocalL1CacheSupported = 80,
1831 cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81,
1832 cudaDevAttrMaxRegistersPerMultiprocessor = 82,
1833 cudaDevAttrManagedMemory = 83,
1834 cudaDevAttrIsMultiGpuBoard = 84,
1835 cudaDevAttrMultiGpuBoardGroupID = 85,
1836 cudaDevAttrHostNativeAtomicSupported = 86,
1837 cudaDevAttrSingleToDoublePrecisionPerfRatio = 87,
1838 cudaDevAttrPageableMemoryAccess = 88,
1839 cudaDevAttrConcurrentManagedAccess = 89,
1840 cudaDevAttrComputePreemptionSupported = 90,
1841 cudaDevAttrCanUseHostPointerForRegisteredMem = 91,
1842 cudaDevAttrReserved92 = 92,
1843 cudaDevAttrReserved93 = 93,
1844 cudaDevAttrReserved94 = 94,
1845 cudaDevAttrCooperativeLaunch = 95,
1846 cudaDevAttrCooperativeMultiDeviceLaunch = 96,
1847 cudaDevAttrMaxSharedMemoryPerBlockOptin = 97,
1848 cudaDevAttrCanFlushRemoteWrites = 98,
1849 cudaDevAttrHostRegisterSupported = 99,
1850 cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100,
1851 cudaDevAttrDirectManagedMemAccessFromHost = 101,
1852}
1853#[repr(u32)]
1854#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
1855pub enum cudaDeviceP2PAttr {
1856 cudaDevP2PAttrPerformanceRank = 1,
1857 cudaDevP2PAttrAccessSupported = 2,
1858 cudaDevP2PAttrNativeAtomicSupported = 3,
1859 cudaDevP2PAttrCudaArrayAccessSupported = 4,
1860}
1861#[repr(C)]
1862#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1863pub struct CUuuid_st {
1864 pub bytes: [::std::os::raw::c_char; 16usize],
1865}
1866#[test]
1867fn bindgen_test_layout_CUuuid_st() {
1868 assert_eq!(
1869 ::std::mem::size_of::<CUuuid_st>(),
1870 16usize,
1871 concat!("Size of: ", stringify!(CUuuid_st))
1872 );
1873 assert_eq!(
1874 ::std::mem::align_of::<CUuuid_st>(),
1875 1usize,
1876 concat!("Alignment of ", stringify!(CUuuid_st))
1877 );
1878 assert_eq!(
1879 unsafe { &(*(::std::ptr::null::<CUuuid_st>())).bytes as *const _ as usize },
1880 0usize,
1881 concat!(
1882 "Offset of field: ",
1883 stringify!(CUuuid_st),
1884 "::",
1885 stringify!(bytes)
1886 )
1887 );
1888}
1889pub type cudaUUID_t = CUuuid_st;
1890#[repr(C)]
1891#[derive(Copy, Clone)]
1892pub struct cudaDeviceProp {
1893 pub name: [::std::os::raw::c_char; 256usize],
1894 pub uuid: cudaUUID_t,
1895 pub luid: [::std::os::raw::c_char; 8usize],
1896 pub luidDeviceNodeMask: ::std::os::raw::c_uint,
1897 pub totalGlobalMem: usize,
1898 pub sharedMemPerBlock: usize,
1899 pub regsPerBlock: ::std::os::raw::c_int,
1900 pub warpSize: ::std::os::raw::c_int,
1901 pub memPitch: usize,
1902 pub maxThreadsPerBlock: ::std::os::raw::c_int,
1903 pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
1904 pub maxGridSize: [::std::os::raw::c_int; 3usize],
1905 pub clockRate: ::std::os::raw::c_int,
1906 pub totalConstMem: usize,
1907 pub major: ::std::os::raw::c_int,
1908 pub minor: ::std::os::raw::c_int,
1909 pub textureAlignment: usize,
1910 pub texturePitchAlignment: usize,
1911 pub deviceOverlap: ::std::os::raw::c_int,
1912 pub multiProcessorCount: ::std::os::raw::c_int,
1913 pub kernelExecTimeoutEnabled: ::std::os::raw::c_int,
1914 pub integrated: ::std::os::raw::c_int,
1915 pub canMapHostMemory: ::std::os::raw::c_int,
1916 pub computeMode: ::std::os::raw::c_int,
1917 pub maxTexture1D: ::std::os::raw::c_int,
1918 pub maxTexture1DMipmap: ::std::os::raw::c_int,
1919 pub maxTexture1DLinear: ::std::os::raw::c_int,
1920 pub maxTexture2D: [::std::os::raw::c_int; 2usize],
1921 pub maxTexture2DMipmap: [::std::os::raw::c_int; 2usize],
1922 pub maxTexture2DLinear: [::std::os::raw::c_int; 3usize],
1923 pub maxTexture2DGather: [::std::os::raw::c_int; 2usize],
1924 pub maxTexture3D: [::std::os::raw::c_int; 3usize],
1925 pub maxTexture3DAlt: [::std::os::raw::c_int; 3usize],
1926 pub maxTextureCubemap: ::std::os::raw::c_int,
1927 pub maxTexture1DLayered: [::std::os::raw::c_int; 2usize],
1928 pub maxTexture2DLayered: [::std::os::raw::c_int; 3usize],
1929 pub maxTextureCubemapLayered: [::std::os::raw::c_int; 2usize],
1930 pub maxSurface1D: ::std::os::raw::c_int,
1931 pub maxSurface2D: [::std::os::raw::c_int; 2usize],
1932 pub maxSurface3D: [::std::os::raw::c_int; 3usize],
1933 pub maxSurface1DLayered: [::std::os::raw::c_int; 2usize],
1934 pub maxSurface2DLayered: [::std::os::raw::c_int; 3usize],
1935 pub maxSurfaceCubemap: ::std::os::raw::c_int,
1936 pub maxSurfaceCubemapLayered: [::std::os::raw::c_int; 2usize],
1937 pub surfaceAlignment: usize,
1938 pub concurrentKernels: ::std::os::raw::c_int,
1939 pub ECCEnabled: ::std::os::raw::c_int,
1940 pub pciBusID: ::std::os::raw::c_int,
1941 pub pciDeviceID: ::std::os::raw::c_int,
1942 pub pciDomainID: ::std::os::raw::c_int,
1943 pub tccDriver: ::std::os::raw::c_int,
1944 pub asyncEngineCount: ::std::os::raw::c_int,
1945 pub unifiedAddressing: ::std::os::raw::c_int,
1946 pub memoryClockRate: ::std::os::raw::c_int,
1947 pub memoryBusWidth: ::std::os::raw::c_int,
1948 pub l2CacheSize: ::std::os::raw::c_int,
1949 pub maxThreadsPerMultiProcessor: ::std::os::raw::c_int,
1950 pub streamPrioritiesSupported: ::std::os::raw::c_int,
1951 pub globalL1CacheSupported: ::std::os::raw::c_int,
1952 pub localL1CacheSupported: ::std::os::raw::c_int,
1953 pub sharedMemPerMultiprocessor: usize,
1954 pub regsPerMultiprocessor: ::std::os::raw::c_int,
1955 pub managedMemory: ::std::os::raw::c_int,
1956 pub isMultiGpuBoard: ::std::os::raw::c_int,
1957 pub multiGpuBoardGroupID: ::std::os::raw::c_int,
1958 pub hostNativeAtomicSupported: ::std::os::raw::c_int,
1959 pub singleToDoublePrecisionPerfRatio: ::std::os::raw::c_int,
1960 pub pageableMemoryAccess: ::std::os::raw::c_int,
1961 pub concurrentManagedAccess: ::std::os::raw::c_int,
1962 pub computePreemptionSupported: ::std::os::raw::c_int,
1963 pub canUseHostPointerForRegisteredMem: ::std::os::raw::c_int,
1964 pub cooperativeLaunch: ::std::os::raw::c_int,
1965 pub cooperativeMultiDeviceLaunch: ::std::os::raw::c_int,
1966 pub sharedMemPerBlockOptin: usize,
1967 pub pageableMemoryAccessUsesHostPageTables: ::std::os::raw::c_int,
1968 pub directManagedMemAccessFromHost: ::std::os::raw::c_int,
1969}
1970#[test]
1971fn bindgen_test_layout_cudaDeviceProp() {
1972 assert_eq!(
1973 ::std::mem::size_of::<cudaDeviceProp>(),
1974 712usize,
1975 concat!("Size of: ", stringify!(cudaDeviceProp))
1976 );
1977 assert_eq!(
1978 ::std::mem::align_of::<cudaDeviceProp>(),
1979 8usize,
1980 concat!("Alignment of ", stringify!(cudaDeviceProp))
1981 );
1982 assert_eq!(
1983 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).name as *const _ as usize },
1984 0usize,
1985 concat!(
1986 "Offset of field: ",
1987 stringify!(cudaDeviceProp),
1988 "::",
1989 stringify!(name)
1990 )
1991 );
1992 assert_eq!(
1993 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).uuid as *const _ as usize },
1994 256usize,
1995 concat!(
1996 "Offset of field: ",
1997 stringify!(cudaDeviceProp),
1998 "::",
1999 stringify!(uuid)
2000 )
2001 );
2002 assert_eq!(
2003 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).luid as *const _ as usize },
2004 272usize,
2005 concat!(
2006 "Offset of field: ",
2007 stringify!(cudaDeviceProp),
2008 "::",
2009 stringify!(luid)
2010 )
2011 );
2012 assert_eq!(
2013 unsafe {
2014 &(*(::std::ptr::null::<cudaDeviceProp>())).luidDeviceNodeMask as *const _ as usize
2015 },
2016 280usize,
2017 concat!(
2018 "Offset of field: ",
2019 stringify!(cudaDeviceProp),
2020 "::",
2021 stringify!(luidDeviceNodeMask)
2022 )
2023 );
2024 assert_eq!(
2025 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).totalGlobalMem as *const _ as usize },
2026 288usize,
2027 concat!(
2028 "Offset of field: ",
2029 stringify!(cudaDeviceProp),
2030 "::",
2031 stringify!(totalGlobalMem)
2032 )
2033 );
2034 assert_eq!(
2035 unsafe {
2036 &(*(::std::ptr::null::<cudaDeviceProp>())).sharedMemPerBlock as *const _ as usize
2037 },
2038 296usize,
2039 concat!(
2040 "Offset of field: ",
2041 stringify!(cudaDeviceProp),
2042 "::",
2043 stringify!(sharedMemPerBlock)
2044 )
2045 );
2046 assert_eq!(
2047 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).regsPerBlock as *const _ as usize },
2048 304usize,
2049 concat!(
2050 "Offset of field: ",
2051 stringify!(cudaDeviceProp),
2052 "::",
2053 stringify!(regsPerBlock)
2054 )
2055 );
2056 assert_eq!(
2057 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).warpSize as *const _ as usize },
2058 308usize,
2059 concat!(
2060 "Offset of field: ",
2061 stringify!(cudaDeviceProp),
2062 "::",
2063 stringify!(warpSize)
2064 )
2065 );
2066 assert_eq!(
2067 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).memPitch as *const _ as usize },
2068 312usize,
2069 concat!(
2070 "Offset of field: ",
2071 stringify!(cudaDeviceProp),
2072 "::",
2073 stringify!(memPitch)
2074 )
2075 );
2076 assert_eq!(
2077 unsafe {
2078 &(*(::std::ptr::null::<cudaDeviceProp>())).maxThreadsPerBlock as *const _ as usize
2079 },
2080 320usize,
2081 concat!(
2082 "Offset of field: ",
2083 stringify!(cudaDeviceProp),
2084 "::",
2085 stringify!(maxThreadsPerBlock)
2086 )
2087 );
2088 assert_eq!(
2089 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxThreadsDim as *const _ as usize },
2090 324usize,
2091 concat!(
2092 "Offset of field: ",
2093 stringify!(cudaDeviceProp),
2094 "::",
2095 stringify!(maxThreadsDim)
2096 )
2097 );
2098 assert_eq!(
2099 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxGridSize as *const _ as usize },
2100 336usize,
2101 concat!(
2102 "Offset of field: ",
2103 stringify!(cudaDeviceProp),
2104 "::",
2105 stringify!(maxGridSize)
2106 )
2107 );
2108 assert_eq!(
2109 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).clockRate as *const _ as usize },
2110 348usize,
2111 concat!(
2112 "Offset of field: ",
2113 stringify!(cudaDeviceProp),
2114 "::",
2115 stringify!(clockRate)
2116 )
2117 );
2118 assert_eq!(
2119 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).totalConstMem as *const _ as usize },
2120 352usize,
2121 concat!(
2122 "Offset of field: ",
2123 stringify!(cudaDeviceProp),
2124 "::",
2125 stringify!(totalConstMem)
2126 )
2127 );
2128 assert_eq!(
2129 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).major as *const _ as usize },
2130 360usize,
2131 concat!(
2132 "Offset of field: ",
2133 stringify!(cudaDeviceProp),
2134 "::",
2135 stringify!(major)
2136 )
2137 );
2138 assert_eq!(
2139 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).minor as *const _ as usize },
2140 364usize,
2141 concat!(
2142 "Offset of field: ",
2143 stringify!(cudaDeviceProp),
2144 "::",
2145 stringify!(minor)
2146 )
2147 );
2148 assert_eq!(
2149 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).textureAlignment as *const _ as usize },
2150 368usize,
2151 concat!(
2152 "Offset of field: ",
2153 stringify!(cudaDeviceProp),
2154 "::",
2155 stringify!(textureAlignment)
2156 )
2157 );
2158 assert_eq!(
2159 unsafe {
2160 &(*(::std::ptr::null::<cudaDeviceProp>())).texturePitchAlignment as *const _ as usize
2161 },
2162 376usize,
2163 concat!(
2164 "Offset of field: ",
2165 stringify!(cudaDeviceProp),
2166 "::",
2167 stringify!(texturePitchAlignment)
2168 )
2169 );
2170 assert_eq!(
2171 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).deviceOverlap as *const _ as usize },
2172 384usize,
2173 concat!(
2174 "Offset of field: ",
2175 stringify!(cudaDeviceProp),
2176 "::",
2177 stringify!(deviceOverlap)
2178 )
2179 );
2180 assert_eq!(
2181 unsafe {
2182 &(*(::std::ptr::null::<cudaDeviceProp>())).multiProcessorCount as *const _ as usize
2183 },
2184 388usize,
2185 concat!(
2186 "Offset of field: ",
2187 stringify!(cudaDeviceProp),
2188 "::",
2189 stringify!(multiProcessorCount)
2190 )
2191 );
2192 assert_eq!(
2193 unsafe {
2194 &(*(::std::ptr::null::<cudaDeviceProp>())).kernelExecTimeoutEnabled as *const _ as usize
2195 },
2196 392usize,
2197 concat!(
2198 "Offset of field: ",
2199 stringify!(cudaDeviceProp),
2200 "::",
2201 stringify!(kernelExecTimeoutEnabled)
2202 )
2203 );
2204 assert_eq!(
2205 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).integrated as *const _ as usize },
2206 396usize,
2207 concat!(
2208 "Offset of field: ",
2209 stringify!(cudaDeviceProp),
2210 "::",
2211 stringify!(integrated)
2212 )
2213 );
2214 assert_eq!(
2215 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).canMapHostMemory as *const _ as usize },
2216 400usize,
2217 concat!(
2218 "Offset of field: ",
2219 stringify!(cudaDeviceProp),
2220 "::",
2221 stringify!(canMapHostMemory)
2222 )
2223 );
2224 assert_eq!(
2225 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).computeMode as *const _ as usize },
2226 404usize,
2227 concat!(
2228 "Offset of field: ",
2229 stringify!(cudaDeviceProp),
2230 "::",
2231 stringify!(computeMode)
2232 )
2233 );
2234 assert_eq!(
2235 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1D as *const _ as usize },
2236 408usize,
2237 concat!(
2238 "Offset of field: ",
2239 stringify!(cudaDeviceProp),
2240 "::",
2241 stringify!(maxTexture1D)
2242 )
2243 );
2244 assert_eq!(
2245 unsafe {
2246 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1DMipmap as *const _ as usize
2247 },
2248 412usize,
2249 concat!(
2250 "Offset of field: ",
2251 stringify!(cudaDeviceProp),
2252 "::",
2253 stringify!(maxTexture1DMipmap)
2254 )
2255 );
2256 assert_eq!(
2257 unsafe {
2258 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1DLinear as *const _ as usize
2259 },
2260 416usize,
2261 concat!(
2262 "Offset of field: ",
2263 stringify!(cudaDeviceProp),
2264 "::",
2265 stringify!(maxTexture1DLinear)
2266 )
2267 );
2268 assert_eq!(
2269 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2D as *const _ as usize },
2270 420usize,
2271 concat!(
2272 "Offset of field: ",
2273 stringify!(cudaDeviceProp),
2274 "::",
2275 stringify!(maxTexture2D)
2276 )
2277 );
2278 assert_eq!(
2279 unsafe {
2280 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DMipmap as *const _ as usize
2281 },
2282 428usize,
2283 concat!(
2284 "Offset of field: ",
2285 stringify!(cudaDeviceProp),
2286 "::",
2287 stringify!(maxTexture2DMipmap)
2288 )
2289 );
2290 assert_eq!(
2291 unsafe {
2292 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DLinear as *const _ as usize
2293 },
2294 436usize,
2295 concat!(
2296 "Offset of field: ",
2297 stringify!(cudaDeviceProp),
2298 "::",
2299 stringify!(maxTexture2DLinear)
2300 )
2301 );
2302 assert_eq!(
2303 unsafe {
2304 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DGather as *const _ as usize
2305 },
2306 448usize,
2307 concat!(
2308 "Offset of field: ",
2309 stringify!(cudaDeviceProp),
2310 "::",
2311 stringify!(maxTexture2DGather)
2312 )
2313 );
2314 assert_eq!(
2315 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture3D as *const _ as usize },
2316 456usize,
2317 concat!(
2318 "Offset of field: ",
2319 stringify!(cudaDeviceProp),
2320 "::",
2321 stringify!(maxTexture3D)
2322 )
2323 );
2324 assert_eq!(
2325 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture3DAlt as *const _ as usize },
2326 468usize,
2327 concat!(
2328 "Offset of field: ",
2329 stringify!(cudaDeviceProp),
2330 "::",
2331 stringify!(maxTexture3DAlt)
2332 )
2333 );
2334 assert_eq!(
2335 unsafe {
2336 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTextureCubemap as *const _ as usize
2337 },
2338 480usize,
2339 concat!(
2340 "Offset of field: ",
2341 stringify!(cudaDeviceProp),
2342 "::",
2343 stringify!(maxTextureCubemap)
2344 )
2345 );
2346 assert_eq!(
2347 unsafe {
2348 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1DLayered as *const _ as usize
2349 },
2350 484usize,
2351 concat!(
2352 "Offset of field: ",
2353 stringify!(cudaDeviceProp),
2354 "::",
2355 stringify!(maxTexture1DLayered)
2356 )
2357 );
2358 assert_eq!(
2359 unsafe {
2360 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DLayered as *const _ as usize
2361 },
2362 492usize,
2363 concat!(
2364 "Offset of field: ",
2365 stringify!(cudaDeviceProp),
2366 "::",
2367 stringify!(maxTexture2DLayered)
2368 )
2369 );
2370 assert_eq!(
2371 unsafe {
2372 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTextureCubemapLayered as *const _ as usize
2373 },
2374 504usize,
2375 concat!(
2376 "Offset of field: ",
2377 stringify!(cudaDeviceProp),
2378 "::",
2379 stringify!(maxTextureCubemapLayered)
2380 )
2381 );
2382 assert_eq!(
2383 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface1D as *const _ as usize },
2384 512usize,
2385 concat!(
2386 "Offset of field: ",
2387 stringify!(cudaDeviceProp),
2388 "::",
2389 stringify!(maxSurface1D)
2390 )
2391 );
2392 assert_eq!(
2393 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface2D as *const _ as usize },
2394 516usize,
2395 concat!(
2396 "Offset of field: ",
2397 stringify!(cudaDeviceProp),
2398 "::",
2399 stringify!(maxSurface2D)
2400 )
2401 );
2402 assert_eq!(
2403 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface3D as *const _ as usize },
2404 524usize,
2405 concat!(
2406 "Offset of field: ",
2407 stringify!(cudaDeviceProp),
2408 "::",
2409 stringify!(maxSurface3D)
2410 )
2411 );
2412 assert_eq!(
2413 unsafe {
2414 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface1DLayered as *const _ as usize
2415 },
2416 536usize,
2417 concat!(
2418 "Offset of field: ",
2419 stringify!(cudaDeviceProp),
2420 "::",
2421 stringify!(maxSurface1DLayered)
2422 )
2423 );
2424 assert_eq!(
2425 unsafe {
2426 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface2DLayered as *const _ as usize
2427 },
2428 544usize,
2429 concat!(
2430 "Offset of field: ",
2431 stringify!(cudaDeviceProp),
2432 "::",
2433 stringify!(maxSurface2DLayered)
2434 )
2435 );
2436 assert_eq!(
2437 unsafe {
2438 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurfaceCubemap as *const _ as usize
2439 },
2440 556usize,
2441 concat!(
2442 "Offset of field: ",
2443 stringify!(cudaDeviceProp),
2444 "::",
2445 stringify!(maxSurfaceCubemap)
2446 )
2447 );
2448 assert_eq!(
2449 unsafe {
2450 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurfaceCubemapLayered as *const _ as usize
2451 },
2452 560usize,
2453 concat!(
2454 "Offset of field: ",
2455 stringify!(cudaDeviceProp),
2456 "::",
2457 stringify!(maxSurfaceCubemapLayered)
2458 )
2459 );
2460 assert_eq!(
2461 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).surfaceAlignment as *const _ as usize },
2462 568usize,
2463 concat!(
2464 "Offset of field: ",
2465 stringify!(cudaDeviceProp),
2466 "::",
2467 stringify!(surfaceAlignment)
2468 )
2469 );
2470 assert_eq!(
2471 unsafe {
2472 &(*(::std::ptr::null::<cudaDeviceProp>())).concurrentKernels as *const _ as usize
2473 },
2474 576usize,
2475 concat!(
2476 "Offset of field: ",
2477 stringify!(cudaDeviceProp),
2478 "::",
2479 stringify!(concurrentKernels)
2480 )
2481 );
2482 assert_eq!(
2483 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).ECCEnabled as *const _ as usize },
2484 580usize,
2485 concat!(
2486 "Offset of field: ",
2487 stringify!(cudaDeviceProp),
2488 "::",
2489 stringify!(ECCEnabled)
2490 )
2491 );
2492 assert_eq!(
2493 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).pciBusID as *const _ as usize },
2494 584usize,
2495 concat!(
2496 "Offset of field: ",
2497 stringify!(cudaDeviceProp),
2498 "::",
2499 stringify!(pciBusID)
2500 )
2501 );
2502 assert_eq!(
2503 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).pciDeviceID as *const _ as usize },
2504 588usize,
2505 concat!(
2506 "Offset of field: ",
2507 stringify!(cudaDeviceProp),
2508 "::",
2509 stringify!(pciDeviceID)
2510 )
2511 );
2512 assert_eq!(
2513 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).pciDomainID as *const _ as usize },
2514 592usize,
2515 concat!(
2516 "Offset of field: ",
2517 stringify!(cudaDeviceProp),
2518 "::",
2519 stringify!(pciDomainID)
2520 )
2521 );
2522 assert_eq!(
2523 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).tccDriver as *const _ as usize },
2524 596usize,
2525 concat!(
2526 "Offset of field: ",
2527 stringify!(cudaDeviceProp),
2528 "::",
2529 stringify!(tccDriver)
2530 )
2531 );
2532 assert_eq!(
2533 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).asyncEngineCount as *const _ as usize },
2534 600usize,
2535 concat!(
2536 "Offset of field: ",
2537 stringify!(cudaDeviceProp),
2538 "::",
2539 stringify!(asyncEngineCount)
2540 )
2541 );
2542 assert_eq!(
2543 unsafe {
2544 &(*(::std::ptr::null::<cudaDeviceProp>())).unifiedAddressing as *const _ as usize
2545 },
2546 604usize,
2547 concat!(
2548 "Offset of field: ",
2549 stringify!(cudaDeviceProp),
2550 "::",
2551 stringify!(unifiedAddressing)
2552 )
2553 );
2554 assert_eq!(
2555 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).memoryClockRate as *const _ as usize },
2556 608usize,
2557 concat!(
2558 "Offset of field: ",
2559 stringify!(cudaDeviceProp),
2560 "::",
2561 stringify!(memoryClockRate)
2562 )
2563 );
2564 assert_eq!(
2565 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).memoryBusWidth as *const _ as usize },
2566 612usize,
2567 concat!(
2568 "Offset of field: ",
2569 stringify!(cudaDeviceProp),
2570 "::",
2571 stringify!(memoryBusWidth)
2572 )
2573 );
2574 assert_eq!(
2575 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).l2CacheSize as *const _ as usize },
2576 616usize,
2577 concat!(
2578 "Offset of field: ",
2579 stringify!(cudaDeviceProp),
2580 "::",
2581 stringify!(l2CacheSize)
2582 )
2583 );
2584 assert_eq!(
2585 unsafe {
2586 &(*(::std::ptr::null::<cudaDeviceProp>())).maxThreadsPerMultiProcessor as *const _
2587 as usize
2588 },
2589 620usize,
2590 concat!(
2591 "Offset of field: ",
2592 stringify!(cudaDeviceProp),
2593 "::",
2594 stringify!(maxThreadsPerMultiProcessor)
2595 )
2596 );
2597 assert_eq!(
2598 unsafe {
2599 &(*(::std::ptr::null::<cudaDeviceProp>())).streamPrioritiesSupported as *const _
2600 as usize
2601 },
2602 624usize,
2603 concat!(
2604 "Offset of field: ",
2605 stringify!(cudaDeviceProp),
2606 "::",
2607 stringify!(streamPrioritiesSupported)
2608 )
2609 );
2610 assert_eq!(
2611 unsafe {
2612 &(*(::std::ptr::null::<cudaDeviceProp>())).globalL1CacheSupported as *const _ as usize
2613 },
2614 628usize,
2615 concat!(
2616 "Offset of field: ",
2617 stringify!(cudaDeviceProp),
2618 "::",
2619 stringify!(globalL1CacheSupported)
2620 )
2621 );
2622 assert_eq!(
2623 unsafe {
2624 &(*(::std::ptr::null::<cudaDeviceProp>())).localL1CacheSupported as *const _ as usize
2625 },
2626 632usize,
2627 concat!(
2628 "Offset of field: ",
2629 stringify!(cudaDeviceProp),
2630 "::",
2631 stringify!(localL1CacheSupported)
2632 )
2633 );
2634 assert_eq!(
2635 unsafe {
2636 &(*(::std::ptr::null::<cudaDeviceProp>())).sharedMemPerMultiprocessor as *const _
2637 as usize
2638 },
2639 640usize,
2640 concat!(
2641 "Offset of field: ",
2642 stringify!(cudaDeviceProp),
2643 "::",
2644 stringify!(sharedMemPerMultiprocessor)
2645 )
2646 );
2647 assert_eq!(
2648 unsafe {
2649 &(*(::std::ptr::null::<cudaDeviceProp>())).regsPerMultiprocessor as *const _ as usize
2650 },
2651 648usize,
2652 concat!(
2653 "Offset of field: ",
2654 stringify!(cudaDeviceProp),
2655 "::",
2656 stringify!(regsPerMultiprocessor)
2657 )
2658 );
2659 assert_eq!(
2660 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).managedMemory as *const _ as usize },
2661 652usize,
2662 concat!(
2663 "Offset of field: ",
2664 stringify!(cudaDeviceProp),
2665 "::",
2666 stringify!(managedMemory)
2667 )
2668 );
2669 assert_eq!(
2670 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).isMultiGpuBoard as *const _ as usize },
2671 656usize,
2672 concat!(
2673 "Offset of field: ",
2674 stringify!(cudaDeviceProp),
2675 "::",
2676 stringify!(isMultiGpuBoard)
2677 )
2678 );
2679 assert_eq!(
2680 unsafe {
2681 &(*(::std::ptr::null::<cudaDeviceProp>())).multiGpuBoardGroupID as *const _ as usize
2682 },
2683 660usize,
2684 concat!(
2685 "Offset of field: ",
2686 stringify!(cudaDeviceProp),
2687 "::",
2688 stringify!(multiGpuBoardGroupID)
2689 )
2690 );
2691 assert_eq!(
2692 unsafe {
2693 &(*(::std::ptr::null::<cudaDeviceProp>())).hostNativeAtomicSupported as *const _
2694 as usize
2695 },
2696 664usize,
2697 concat!(
2698 "Offset of field: ",
2699 stringify!(cudaDeviceProp),
2700 "::",
2701 stringify!(hostNativeAtomicSupported)
2702 )
2703 );
2704 assert_eq!(
2705 unsafe {
2706 &(*(::std::ptr::null::<cudaDeviceProp>())).singleToDoublePrecisionPerfRatio as *const _
2707 as usize
2708 },
2709 668usize,
2710 concat!(
2711 "Offset of field: ",
2712 stringify!(cudaDeviceProp),
2713 "::",
2714 stringify!(singleToDoublePrecisionPerfRatio)
2715 )
2716 );
2717 assert_eq!(
2718 unsafe {
2719 &(*(::std::ptr::null::<cudaDeviceProp>())).pageableMemoryAccess as *const _ as usize
2720 },
2721 672usize,
2722 concat!(
2723 "Offset of field: ",
2724 stringify!(cudaDeviceProp),
2725 "::",
2726 stringify!(pageableMemoryAccess)
2727 )
2728 );
2729 assert_eq!(
2730 unsafe {
2731 &(*(::std::ptr::null::<cudaDeviceProp>())).concurrentManagedAccess as *const _ as usize
2732 },
2733 676usize,
2734 concat!(
2735 "Offset of field: ",
2736 stringify!(cudaDeviceProp),
2737 "::",
2738 stringify!(concurrentManagedAccess)
2739 )
2740 );
2741 assert_eq!(
2742 unsafe {
2743 &(*(::std::ptr::null::<cudaDeviceProp>())).computePreemptionSupported as *const _
2744 as usize
2745 },
2746 680usize,
2747 concat!(
2748 "Offset of field: ",
2749 stringify!(cudaDeviceProp),
2750 "::",
2751 stringify!(computePreemptionSupported)
2752 )
2753 );
2754 assert_eq!(
2755 unsafe {
2756 &(*(::std::ptr::null::<cudaDeviceProp>())).canUseHostPointerForRegisteredMem as *const _
2757 as usize
2758 },
2759 684usize,
2760 concat!(
2761 "Offset of field: ",
2762 stringify!(cudaDeviceProp),
2763 "::",
2764 stringify!(canUseHostPointerForRegisteredMem)
2765 )
2766 );
2767 assert_eq!(
2768 unsafe {
2769 &(*(::std::ptr::null::<cudaDeviceProp>())).cooperativeLaunch as *const _ as usize
2770 },
2771 688usize,
2772 concat!(
2773 "Offset of field: ",
2774 stringify!(cudaDeviceProp),
2775 "::",
2776 stringify!(cooperativeLaunch)
2777 )
2778 );
2779 assert_eq!(
2780 unsafe {
2781 &(*(::std::ptr::null::<cudaDeviceProp>())).cooperativeMultiDeviceLaunch as *const _
2782 as usize
2783 },
2784 692usize,
2785 concat!(
2786 "Offset of field: ",
2787 stringify!(cudaDeviceProp),
2788 "::",
2789 stringify!(cooperativeMultiDeviceLaunch)
2790 )
2791 );
2792 assert_eq!(
2793 unsafe {
2794 &(*(::std::ptr::null::<cudaDeviceProp>())).sharedMemPerBlockOptin as *const _ as usize
2795 },
2796 696usize,
2797 concat!(
2798 "Offset of field: ",
2799 stringify!(cudaDeviceProp),
2800 "::",
2801 stringify!(sharedMemPerBlockOptin)
2802 )
2803 );
2804 assert_eq!(
2805 unsafe {
2806 &(*(::std::ptr::null::<cudaDeviceProp>())).pageableMemoryAccessUsesHostPageTables
2807 as *const _ as usize
2808 },
2809 704usize,
2810 concat!(
2811 "Offset of field: ",
2812 stringify!(cudaDeviceProp),
2813 "::",
2814 stringify!(pageableMemoryAccessUsesHostPageTables)
2815 )
2816 );
2817 assert_eq!(
2818 unsafe {
2819 &(*(::std::ptr::null::<cudaDeviceProp>())).directManagedMemAccessFromHost as *const _
2820 as usize
2821 },
2822 708usize,
2823 concat!(
2824 "Offset of field: ",
2825 stringify!(cudaDeviceProp),
2826 "::",
2827 stringify!(directManagedMemAccessFromHost)
2828 )
2829 );
2830}
2831impl Default for cudaDeviceProp {
2832 fn default() -> Self {
2833 unsafe { ::std::mem::zeroed() }
2834 }
2835}
2836#[repr(C)]
2837#[derive(Copy, Clone)]
2838pub struct cudaIpcEventHandle_st {
2839 pub reserved: [::std::os::raw::c_char; 64usize],
2840}
2841#[test]
2842fn bindgen_test_layout_cudaIpcEventHandle_st() {
2843 assert_eq!(
2844 ::std::mem::size_of::<cudaIpcEventHandle_st>(),
2845 64usize,
2846 concat!("Size of: ", stringify!(cudaIpcEventHandle_st))
2847 );
2848 assert_eq!(
2849 ::std::mem::align_of::<cudaIpcEventHandle_st>(),
2850 1usize,
2851 concat!("Alignment of ", stringify!(cudaIpcEventHandle_st))
2852 );
2853 assert_eq!(
2854 unsafe { &(*(::std::ptr::null::<cudaIpcEventHandle_st>())).reserved as *const _ as usize },
2855 0usize,
2856 concat!(
2857 "Offset of field: ",
2858 stringify!(cudaIpcEventHandle_st),
2859 "::",
2860 stringify!(reserved)
2861 )
2862 );
2863}
2864impl Default for cudaIpcEventHandle_st {
2865 fn default() -> Self {
2866 unsafe { ::std::mem::zeroed() }
2867 }
2868}
2869pub type cudaIpcEventHandle_t = cudaIpcEventHandle_st;
2870#[repr(C)]
2871#[derive(Copy, Clone)]
2872pub struct cudaIpcMemHandle_st {
2873 pub reserved: [::std::os::raw::c_char; 64usize],
2874}
2875#[test]
2876fn bindgen_test_layout_cudaIpcMemHandle_st() {
2877 assert_eq!(
2878 ::std::mem::size_of::<cudaIpcMemHandle_st>(),
2879 64usize,
2880 concat!("Size of: ", stringify!(cudaIpcMemHandle_st))
2881 );
2882 assert_eq!(
2883 ::std::mem::align_of::<cudaIpcMemHandle_st>(),
2884 1usize,
2885 concat!("Alignment of ", stringify!(cudaIpcMemHandle_st))
2886 );
2887 assert_eq!(
2888 unsafe { &(*(::std::ptr::null::<cudaIpcMemHandle_st>())).reserved as *const _ as usize },
2889 0usize,
2890 concat!(
2891 "Offset of field: ",
2892 stringify!(cudaIpcMemHandle_st),
2893 "::",
2894 stringify!(reserved)
2895 )
2896 );
2897}
2898impl Default for cudaIpcMemHandle_st {
2899 fn default() -> Self {
2900 unsafe { ::std::mem::zeroed() }
2901 }
2902}
2903pub type cudaIpcMemHandle_t = cudaIpcMemHandle_st;
2904#[repr(u32)]
2905#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
2906pub enum cudaExternalMemoryHandleType {
2907 cudaExternalMemoryHandleTypeOpaqueFd = 1,
2908 cudaExternalMemoryHandleTypeOpaqueWin32 = 2,
2909 cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3,
2910 cudaExternalMemoryHandleTypeD3D12Heap = 4,
2911 cudaExternalMemoryHandleTypeD3D12Resource = 5,
2912 cudaExternalMemoryHandleTypeD3D11Resource = 6,
2913 cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7,
2914 cudaExternalMemoryHandleTypeNvSciBuf = 8,
2915}
2916#[repr(C)]
2917#[derive(Copy, Clone)]
2918pub struct cudaExternalMemoryHandleDesc {
2919 pub type_: cudaExternalMemoryHandleType,
2920 pub handle: cudaExternalMemoryHandleDesc__bindgen_ty_1,
2921 pub size: ::std::os::raw::c_ulonglong,
2922 pub flags: ::std::os::raw::c_uint,
2923}
2924#[repr(C)]
2925#[derive(Copy, Clone)]
2926pub union cudaExternalMemoryHandleDesc__bindgen_ty_1 {
2927 pub fd: ::std::os::raw::c_int,
2928 pub win32: cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1,
2929 pub nvSciBufObject: *const ::std::os::raw::c_void,
2930 _bindgen_union_align: [u64; 2usize],
2931}
2932#[repr(C)]
2933#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2934pub struct cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1 {
2935 pub handle: *mut ::std::os::raw::c_void,
2936 pub name: *const ::std::os::raw::c_void,
2937}
2938#[test]
2939fn bindgen_test_layout_cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1() {
2940 assert_eq!(
2941 ::std::mem::size_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
2942 16usize,
2943 concat!(
2944 "Size of: ",
2945 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1)
2946 )
2947 );
2948 assert_eq!(
2949 ::std::mem::align_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
2950 8usize,
2951 concat!(
2952 "Alignment of ",
2953 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1)
2954 )
2955 );
2956 assert_eq!(
2957 unsafe {
2958 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
2959 .handle as *const _ as usize
2960 },
2961 0usize,
2962 concat!(
2963 "Offset of field: ",
2964 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1),
2965 "::",
2966 stringify!(handle)
2967 )
2968 );
2969 assert_eq!(
2970 unsafe {
2971 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
2972 .name as *const _ as usize
2973 },
2974 8usize,
2975 concat!(
2976 "Offset of field: ",
2977 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1),
2978 "::",
2979 stringify!(name)
2980 )
2981 );
2982}
2983impl Default for cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1 {
2984 fn default() -> Self {
2985 unsafe { ::std::mem::zeroed() }
2986 }
2987}
2988#[test]
2989fn bindgen_test_layout_cudaExternalMemoryHandleDesc__bindgen_ty_1() {
2990 assert_eq!(
2991 ::std::mem::size_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1>(),
2992 16usize,
2993 concat!(
2994 "Size of: ",
2995 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1)
2996 )
2997 );
2998 assert_eq!(
2999 ::std::mem::align_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1>(),
3000 8usize,
3001 concat!(
3002 "Alignment of ",
3003 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1)
3004 )
3005 );
3006 assert_eq!(
3007 unsafe {
3008 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1>())).fd as *const _
3009 as usize
3010 },
3011 0usize,
3012 concat!(
3013 "Offset of field: ",
3014 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1),
3015 "::",
3016 stringify!(fd)
3017 )
3018 );
3019 assert_eq!(
3020 unsafe {
3021 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1>())).win32 as *const _
3022 as usize
3023 },
3024 0usize,
3025 concat!(
3026 "Offset of field: ",
3027 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1),
3028 "::",
3029 stringify!(win32)
3030 )
3031 );
3032 assert_eq!(
3033 unsafe {
3034 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1>())).nvSciBufObject
3035 as *const _ as usize
3036 },
3037 0usize,
3038 concat!(
3039 "Offset of field: ",
3040 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1),
3041 "::",
3042 stringify!(nvSciBufObject)
3043 )
3044 );
3045}
3046impl Default for cudaExternalMemoryHandleDesc__bindgen_ty_1 {
3047 fn default() -> Self {
3048 unsafe { ::std::mem::zeroed() }
3049 }
3050}
3051#[test]
3052fn bindgen_test_layout_cudaExternalMemoryHandleDesc() {
3053 assert_eq!(
3054 ::std::mem::size_of::<cudaExternalMemoryHandleDesc>(),
3055 40usize,
3056 concat!("Size of: ", stringify!(cudaExternalMemoryHandleDesc))
3057 );
3058 assert_eq!(
3059 ::std::mem::align_of::<cudaExternalMemoryHandleDesc>(),
3060 8usize,
3061 concat!("Alignment of ", stringify!(cudaExternalMemoryHandleDesc))
3062 );
3063 assert_eq!(
3064 unsafe {
3065 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).type_ as *const _ as usize
3066 },
3067 0usize,
3068 concat!(
3069 "Offset of field: ",
3070 stringify!(cudaExternalMemoryHandleDesc),
3071 "::",
3072 stringify!(type_)
3073 )
3074 );
3075 assert_eq!(
3076 unsafe {
3077 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).handle as *const _ as usize
3078 },
3079 8usize,
3080 concat!(
3081 "Offset of field: ",
3082 stringify!(cudaExternalMemoryHandleDesc),
3083 "::",
3084 stringify!(handle)
3085 )
3086 );
3087 assert_eq!(
3088 unsafe {
3089 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).size as *const _ as usize
3090 },
3091 24usize,
3092 concat!(
3093 "Offset of field: ",
3094 stringify!(cudaExternalMemoryHandleDesc),
3095 "::",
3096 stringify!(size)
3097 )
3098 );
3099 assert_eq!(
3100 unsafe {
3101 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).flags as *const _ as usize
3102 },
3103 32usize,
3104 concat!(
3105 "Offset of field: ",
3106 stringify!(cudaExternalMemoryHandleDesc),
3107 "::",
3108 stringify!(flags)
3109 )
3110 );
3111}
3112impl Default for cudaExternalMemoryHandleDesc {
3113 fn default() -> Self {
3114 unsafe { ::std::mem::zeroed() }
3115 }
3116}
3117#[repr(C)]
3118#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3119pub struct cudaExternalMemoryBufferDesc {
3120 pub offset: ::std::os::raw::c_ulonglong,
3121 pub size: ::std::os::raw::c_ulonglong,
3122 pub flags: ::std::os::raw::c_uint,
3123}
3124#[test]
3125fn bindgen_test_layout_cudaExternalMemoryBufferDesc() {
3126 assert_eq!(
3127 ::std::mem::size_of::<cudaExternalMemoryBufferDesc>(),
3128 24usize,
3129 concat!("Size of: ", stringify!(cudaExternalMemoryBufferDesc))
3130 );
3131 assert_eq!(
3132 ::std::mem::align_of::<cudaExternalMemoryBufferDesc>(),
3133 8usize,
3134 concat!("Alignment of ", stringify!(cudaExternalMemoryBufferDesc))
3135 );
3136 assert_eq!(
3137 unsafe {
3138 &(*(::std::ptr::null::<cudaExternalMemoryBufferDesc>())).offset as *const _ as usize
3139 },
3140 0usize,
3141 concat!(
3142 "Offset of field: ",
3143 stringify!(cudaExternalMemoryBufferDesc),
3144 "::",
3145 stringify!(offset)
3146 )
3147 );
3148 assert_eq!(
3149 unsafe {
3150 &(*(::std::ptr::null::<cudaExternalMemoryBufferDesc>())).size as *const _ as usize
3151 },
3152 8usize,
3153 concat!(
3154 "Offset of field: ",
3155 stringify!(cudaExternalMemoryBufferDesc),
3156 "::",
3157 stringify!(size)
3158 )
3159 );
3160 assert_eq!(
3161 unsafe {
3162 &(*(::std::ptr::null::<cudaExternalMemoryBufferDesc>())).flags as *const _ as usize
3163 },
3164 16usize,
3165 concat!(
3166 "Offset of field: ",
3167 stringify!(cudaExternalMemoryBufferDesc),
3168 "::",
3169 stringify!(flags)
3170 )
3171 );
3172}
3173#[repr(C)]
3174#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3175pub struct cudaExternalMemoryMipmappedArrayDesc {
3176 pub offset: ::std::os::raw::c_ulonglong,
3177 pub formatDesc: cudaChannelFormatDesc,
3178 pub extent: cudaExtent,
3179 pub flags: ::std::os::raw::c_uint,
3180 pub numLevels: ::std::os::raw::c_uint,
3181}
3182#[test]
3183fn bindgen_test_layout_cudaExternalMemoryMipmappedArrayDesc() {
3184 assert_eq!(
3185 ::std::mem::size_of::<cudaExternalMemoryMipmappedArrayDesc>(),
3186 64usize,
3187 concat!(
3188 "Size of: ",
3189 stringify!(cudaExternalMemoryMipmappedArrayDesc)
3190 )
3191 );
3192 assert_eq!(
3193 ::std::mem::align_of::<cudaExternalMemoryMipmappedArrayDesc>(),
3194 8usize,
3195 concat!(
3196 "Alignment of ",
3197 stringify!(cudaExternalMemoryMipmappedArrayDesc)
3198 )
3199 );
3200 assert_eq!(
3201 unsafe {
3202 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).offset as *const _
3203 as usize
3204 },
3205 0usize,
3206 concat!(
3207 "Offset of field: ",
3208 stringify!(cudaExternalMemoryMipmappedArrayDesc),
3209 "::",
3210 stringify!(offset)
3211 )
3212 );
3213 assert_eq!(
3214 unsafe {
3215 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).formatDesc as *const _
3216 as usize
3217 },
3218 8usize,
3219 concat!(
3220 "Offset of field: ",
3221 stringify!(cudaExternalMemoryMipmappedArrayDesc),
3222 "::",
3223 stringify!(formatDesc)
3224 )
3225 );
3226 assert_eq!(
3227 unsafe {
3228 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).extent as *const _
3229 as usize
3230 },
3231 32usize,
3232 concat!(
3233 "Offset of field: ",
3234 stringify!(cudaExternalMemoryMipmappedArrayDesc),
3235 "::",
3236 stringify!(extent)
3237 )
3238 );
3239 assert_eq!(
3240 unsafe {
3241 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).flags as *const _
3242 as usize
3243 },
3244 56usize,
3245 concat!(
3246 "Offset of field: ",
3247 stringify!(cudaExternalMemoryMipmappedArrayDesc),
3248 "::",
3249 stringify!(flags)
3250 )
3251 );
3252 assert_eq!(
3253 unsafe {
3254 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).numLevels as *const _
3255 as usize
3256 },
3257 60usize,
3258 concat!(
3259 "Offset of field: ",
3260 stringify!(cudaExternalMemoryMipmappedArrayDesc),
3261 "::",
3262 stringify!(numLevels)
3263 )
3264 );
3265}
3266impl Default for cudaExternalMemoryMipmappedArrayDesc {
3267 fn default() -> Self {
3268 unsafe { ::std::mem::zeroed() }
3269 }
3270}
3271#[repr(u32)]
3272#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
3273pub enum cudaExternalSemaphoreHandleType {
3274 cudaExternalSemaphoreHandleTypeOpaqueFd = 1,
3275 cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2,
3276 cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,
3277 cudaExternalSemaphoreHandleTypeD3D12Fence = 4,
3278 cudaExternalSemaphoreHandleTypeD3D11Fence = 5,
3279 cudaExternalSemaphoreHandleTypeNvSciSync = 6,
3280 cudaExternalSemaphoreHandleTypeKeyedMutex = 7,
3281 cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8,
3282}
3283#[repr(C)]
3284#[derive(Copy, Clone)]
3285pub struct cudaExternalSemaphoreHandleDesc {
3286 pub type_: cudaExternalSemaphoreHandleType,
3287 pub handle: cudaExternalSemaphoreHandleDesc__bindgen_ty_1,
3288 pub flags: ::std::os::raw::c_uint,
3289}
3290#[repr(C)]
3291#[derive(Copy, Clone)]
3292pub union cudaExternalSemaphoreHandleDesc__bindgen_ty_1 {
3293 pub fd: ::std::os::raw::c_int,
3294 pub win32: cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1,
3295 pub nvSciSyncObj: *const ::std::os::raw::c_void,
3296 _bindgen_union_align: [u64; 2usize],
3297}
3298#[repr(C)]
3299#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3300pub struct cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1 {
3301 pub handle: *mut ::std::os::raw::c_void,
3302 pub name: *const ::std::os::raw::c_void,
3303}
3304#[test]
3305fn bindgen_test_layout_cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1() {
3306 assert_eq!(
3307 ::std::mem::size_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
3308 16usize,
3309 concat!(
3310 "Size of: ",
3311 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1)
3312 )
3313 );
3314 assert_eq!(
3315 ::std::mem::align_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
3316 8usize,
3317 concat!(
3318 "Alignment of ",
3319 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1)
3320 )
3321 );
3322 assert_eq!(
3323 unsafe {
3324 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
3325 .handle as *const _ as usize
3326 },
3327 0usize,
3328 concat!(
3329 "Offset of field: ",
3330 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1),
3331 "::",
3332 stringify!(handle)
3333 )
3334 );
3335 assert_eq!(
3336 unsafe {
3337 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
3338 .name as *const _ as usize
3339 },
3340 8usize,
3341 concat!(
3342 "Offset of field: ",
3343 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1),
3344 "::",
3345 stringify!(name)
3346 )
3347 );
3348}
3349impl Default for cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1 {
3350 fn default() -> Self {
3351 unsafe { ::std::mem::zeroed() }
3352 }
3353}
3354#[test]
3355fn bindgen_test_layout_cudaExternalSemaphoreHandleDesc__bindgen_ty_1() {
3356 assert_eq!(
3357 ::std::mem::size_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>(),
3358 16usize,
3359 concat!(
3360 "Size of: ",
3361 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1)
3362 )
3363 );
3364 assert_eq!(
3365 ::std::mem::align_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>(),
3366 8usize,
3367 concat!(
3368 "Alignment of ",
3369 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1)
3370 )
3371 );
3372 assert_eq!(
3373 unsafe {
3374 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>())).fd as *const _
3375 as usize
3376 },
3377 0usize,
3378 concat!(
3379 "Offset of field: ",
3380 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1),
3381 "::",
3382 stringify!(fd)
3383 )
3384 );
3385 assert_eq!(
3386 unsafe {
3387 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>())).win32
3388 as *const _ as usize
3389 },
3390 0usize,
3391 concat!(
3392 "Offset of field: ",
3393 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1),
3394 "::",
3395 stringify!(win32)
3396 )
3397 );
3398 assert_eq!(
3399 unsafe {
3400 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>())).nvSciSyncObj
3401 as *const _ as usize
3402 },
3403 0usize,
3404 concat!(
3405 "Offset of field: ",
3406 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1),
3407 "::",
3408 stringify!(nvSciSyncObj)
3409 )
3410 );
3411}
3412impl Default for cudaExternalSemaphoreHandleDesc__bindgen_ty_1 {
3413 fn default() -> Self {
3414 unsafe { ::std::mem::zeroed() }
3415 }
3416}
3417#[test]
3418fn bindgen_test_layout_cudaExternalSemaphoreHandleDesc() {
3419 assert_eq!(
3420 ::std::mem::size_of::<cudaExternalSemaphoreHandleDesc>(),
3421 32usize,
3422 concat!("Size of: ", stringify!(cudaExternalSemaphoreHandleDesc))
3423 );
3424 assert_eq!(
3425 ::std::mem::align_of::<cudaExternalSemaphoreHandleDesc>(),
3426 8usize,
3427 concat!("Alignment of ", stringify!(cudaExternalSemaphoreHandleDesc))
3428 );
3429 assert_eq!(
3430 unsafe {
3431 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc>())).type_ as *const _ as usize
3432 },
3433 0usize,
3434 concat!(
3435 "Offset of field: ",
3436 stringify!(cudaExternalSemaphoreHandleDesc),
3437 "::",
3438 stringify!(type_)
3439 )
3440 );
3441 assert_eq!(
3442 unsafe {
3443 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc>())).handle as *const _ as usize
3444 },
3445 8usize,
3446 concat!(
3447 "Offset of field: ",
3448 stringify!(cudaExternalSemaphoreHandleDesc),
3449 "::",
3450 stringify!(handle)
3451 )
3452 );
3453 assert_eq!(
3454 unsafe {
3455 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc>())).flags as *const _ as usize
3456 },
3457 24usize,
3458 concat!(
3459 "Offset of field: ",
3460 stringify!(cudaExternalSemaphoreHandleDesc),
3461 "::",
3462 stringify!(flags)
3463 )
3464 );
3465}
3466impl Default for cudaExternalSemaphoreHandleDesc {
3467 fn default() -> Self {
3468 unsafe { ::std::mem::zeroed() }
3469 }
3470}
3471#[repr(C)]
3472#[derive(Copy, Clone)]
3473pub struct cudaExternalSemaphoreSignalParams {
3474 pub params: cudaExternalSemaphoreSignalParams__bindgen_ty_1,
3475 pub flags: ::std::os::raw::c_uint,
3476}
3477#[repr(C)]
3478#[derive(Copy, Clone)]
3479pub struct cudaExternalSemaphoreSignalParams__bindgen_ty_1 {
3480 pub fence: cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1,
3481 pub nvSciSync: cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2,
3482 pub keyedMutex: cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3,
3483}
3484#[repr(C)]
3485#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3486pub struct cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1 {
3487 pub value: ::std::os::raw::c_ulonglong,
3488}
3489#[test]
3490fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1() {
3491 assert_eq!(
3492 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1>(),
3493 8usize,
3494 concat!(
3495 "Size of: ",
3496 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1)
3497 )
3498 );
3499 assert_eq!(
3500 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1>(),
3501 8usize,
3502 concat!(
3503 "Alignment of ",
3504 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1)
3505 )
3506 );
3507 assert_eq!(
3508 unsafe {
3509 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1>(
3510 )))
3511 .value as *const _ as usize
3512 },
3513 0usize,
3514 concat!(
3515 "Offset of field: ",
3516 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1),
3517 "::",
3518 stringify!(value)
3519 )
3520 );
3521}
3522#[repr(C)]
3523#[derive(Copy, Clone)]
3524pub union cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2 {
3525 pub fence: *mut ::std::os::raw::c_void,
3526 pub reserved: ::std::os::raw::c_ulonglong,
3527 _bindgen_union_align: u64,
3528}
3529#[test]
3530fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2() {
3531 assert_eq!(
3532 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(),
3533 8usize,
3534 concat!(
3535 "Size of: ",
3536 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2)
3537 )
3538 );
3539 assert_eq!(
3540 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(),
3541 8usize,
3542 concat!(
3543 "Alignment of ",
3544 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2)
3545 )
3546 );
3547 assert_eq!(
3548 unsafe {
3549 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(
3550 )))
3551 .fence as *const _ as usize
3552 },
3553 0usize,
3554 concat!(
3555 "Offset of field: ",
3556 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2),
3557 "::",
3558 stringify!(fence)
3559 )
3560 );
3561 assert_eq!(
3562 unsafe {
3563 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(
3564 )))
3565 .reserved as *const _ as usize
3566 },
3567 0usize,
3568 concat!(
3569 "Offset of field: ",
3570 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2),
3571 "::",
3572 stringify!(reserved)
3573 )
3574 );
3575}
3576impl Default for cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2 {
3577 fn default() -> Self {
3578 unsafe { ::std::mem::zeroed() }
3579 }
3580}
3581#[repr(C)]
3582#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3583pub struct cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3 {
3584 pub key: ::std::os::raw::c_ulonglong,
3585}
3586#[test]
3587fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3() {
3588 assert_eq!(
3589 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3>(),
3590 8usize,
3591 concat!(
3592 "Size of: ",
3593 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3)
3594 )
3595 );
3596 assert_eq!(
3597 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3>(),
3598 8usize,
3599 concat!(
3600 "Alignment of ",
3601 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3)
3602 )
3603 );
3604 assert_eq!(
3605 unsafe {
3606 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3>(
3607 )))
3608 .key as *const _ as usize
3609 },
3610 0usize,
3611 concat!(
3612 "Offset of field: ",
3613 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3),
3614 "::",
3615 stringify!(key)
3616 )
3617 );
3618}
3619#[test]
3620fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1() {
3621 assert_eq!(
3622 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>(),
3623 24usize,
3624 concat!(
3625 "Size of: ",
3626 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1)
3627 )
3628 );
3629 assert_eq!(
3630 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>(),
3631 8usize,
3632 concat!(
3633 "Alignment of ",
3634 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1)
3635 )
3636 );
3637 assert_eq!(
3638 unsafe {
3639 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>())).fence
3640 as *const _ as usize
3641 },
3642 0usize,
3643 concat!(
3644 "Offset of field: ",
3645 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1),
3646 "::",
3647 stringify!(fence)
3648 )
3649 );
3650 assert_eq!(
3651 unsafe {
3652 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>())).nvSciSync
3653 as *const _ as usize
3654 },
3655 8usize,
3656 concat!(
3657 "Offset of field: ",
3658 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1),
3659 "::",
3660 stringify!(nvSciSync)
3661 )
3662 );
3663 assert_eq!(
3664 unsafe {
3665 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>())).keyedMutex
3666 as *const _ as usize
3667 },
3668 16usize,
3669 concat!(
3670 "Offset of field: ",
3671 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1),
3672 "::",
3673 stringify!(keyedMutex)
3674 )
3675 );
3676}
3677impl Default for cudaExternalSemaphoreSignalParams__bindgen_ty_1 {
3678 fn default() -> Self {
3679 unsafe { ::std::mem::zeroed() }
3680 }
3681}
3682#[test]
3683fn bindgen_test_layout_cudaExternalSemaphoreSignalParams() {
3684 assert_eq!(
3685 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams>(),
3686 32usize,
3687 concat!("Size of: ", stringify!(cudaExternalSemaphoreSignalParams))
3688 );
3689 assert_eq!(
3690 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams>(),
3691 8usize,
3692 concat!(
3693 "Alignment of ",
3694 stringify!(cudaExternalSemaphoreSignalParams)
3695 )
3696 );
3697 assert_eq!(
3698 unsafe {
3699 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams>())).params as *const _
3700 as usize
3701 },
3702 0usize,
3703 concat!(
3704 "Offset of field: ",
3705 stringify!(cudaExternalSemaphoreSignalParams),
3706 "::",
3707 stringify!(params)
3708 )
3709 );
3710 assert_eq!(
3711 unsafe {
3712 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams>())).flags as *const _ as usize
3713 },
3714 24usize,
3715 concat!(
3716 "Offset of field: ",
3717 stringify!(cudaExternalSemaphoreSignalParams),
3718 "::",
3719 stringify!(flags)
3720 )
3721 );
3722}
3723impl Default for cudaExternalSemaphoreSignalParams {
3724 fn default() -> Self {
3725 unsafe { ::std::mem::zeroed() }
3726 }
3727}
3728#[repr(C)]
3729#[derive(Copy, Clone)]
3730pub struct cudaExternalSemaphoreWaitParams {
3731 pub params: cudaExternalSemaphoreWaitParams__bindgen_ty_1,
3732 pub flags: ::std::os::raw::c_uint,
3733}
3734#[repr(C)]
3735#[derive(Copy, Clone)]
3736pub struct cudaExternalSemaphoreWaitParams__bindgen_ty_1 {
3737 pub fence: cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1,
3738 pub nvSciSync: cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2,
3739 pub keyedMutex: cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3,
3740}
3741#[repr(C)]
3742#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3743pub struct cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1 {
3744 pub value: ::std::os::raw::c_ulonglong,
3745}
3746#[test]
3747fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1() {
3748 assert_eq!(
3749 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1>(),
3750 8usize,
3751 concat!(
3752 "Size of: ",
3753 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1)
3754 )
3755 );
3756 assert_eq!(
3757 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1>(),
3758 8usize,
3759 concat!(
3760 "Alignment of ",
3761 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1)
3762 )
3763 );
3764 assert_eq!(
3765 unsafe {
3766 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1>()))
3767 .value as *const _ as usize
3768 },
3769 0usize,
3770 concat!(
3771 "Offset of field: ",
3772 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1),
3773 "::",
3774 stringify!(value)
3775 )
3776 );
3777}
3778#[repr(C)]
3779#[derive(Copy, Clone)]
3780pub union cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2 {
3781 pub fence: *mut ::std::os::raw::c_void,
3782 pub reserved: ::std::os::raw::c_ulonglong,
3783 _bindgen_union_align: u64,
3784}
3785#[test]
3786fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2() {
3787 assert_eq!(
3788 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>(),
3789 8usize,
3790 concat!(
3791 "Size of: ",
3792 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2)
3793 )
3794 );
3795 assert_eq!(
3796 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>(),
3797 8usize,
3798 concat!(
3799 "Alignment of ",
3800 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2)
3801 )
3802 );
3803 assert_eq!(
3804 unsafe {
3805 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>()))
3806 .fence as *const _ as usize
3807 },
3808 0usize,
3809 concat!(
3810 "Offset of field: ",
3811 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2),
3812 "::",
3813 stringify!(fence)
3814 )
3815 );
3816 assert_eq!(
3817 unsafe {
3818 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>()))
3819 .reserved as *const _ as usize
3820 },
3821 0usize,
3822 concat!(
3823 "Offset of field: ",
3824 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2),
3825 "::",
3826 stringify!(reserved)
3827 )
3828 );
3829}
3830impl Default for cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2 {
3831 fn default() -> Self {
3832 unsafe { ::std::mem::zeroed() }
3833 }
3834}
3835#[repr(C)]
3836#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3837pub struct cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3 {
3838 pub key: ::std::os::raw::c_ulonglong,
3839 pub timeoutMs: ::std::os::raw::c_uint,
3840}
3841#[test]
3842fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3() {
3843 assert_eq!(
3844 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>(),
3845 16usize,
3846 concat!(
3847 "Size of: ",
3848 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3)
3849 )
3850 );
3851 assert_eq!(
3852 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>(),
3853 8usize,
3854 concat!(
3855 "Alignment of ",
3856 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3)
3857 )
3858 );
3859 assert_eq!(
3860 unsafe {
3861 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>()))
3862 .key as *const _ as usize
3863 },
3864 0usize,
3865 concat!(
3866 "Offset of field: ",
3867 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3),
3868 "::",
3869 stringify!(key)
3870 )
3871 );
3872 assert_eq!(
3873 unsafe {
3874 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>()))
3875 .timeoutMs as *const _ as usize
3876 },
3877 8usize,
3878 concat!(
3879 "Offset of field: ",
3880 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3),
3881 "::",
3882 stringify!(timeoutMs)
3883 )
3884 );
3885}
3886#[test]
3887fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1() {
3888 assert_eq!(
3889 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>(),
3890 32usize,
3891 concat!(
3892 "Size of: ",
3893 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1)
3894 )
3895 );
3896 assert_eq!(
3897 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>(),
3898 8usize,
3899 concat!(
3900 "Alignment of ",
3901 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1)
3902 )
3903 );
3904 assert_eq!(
3905 unsafe {
3906 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>())).fence
3907 as *const _ as usize
3908 },
3909 0usize,
3910 concat!(
3911 "Offset of field: ",
3912 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1),
3913 "::",
3914 stringify!(fence)
3915 )
3916 );
3917 assert_eq!(
3918 unsafe {
3919 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>())).nvSciSync
3920 as *const _ as usize
3921 },
3922 8usize,
3923 concat!(
3924 "Offset of field: ",
3925 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1),
3926 "::",
3927 stringify!(nvSciSync)
3928 )
3929 );
3930 assert_eq!(
3931 unsafe {
3932 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>())).keyedMutex
3933 as *const _ as usize
3934 },
3935 16usize,
3936 concat!(
3937 "Offset of field: ",
3938 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1),
3939 "::",
3940 stringify!(keyedMutex)
3941 )
3942 );
3943}
3944impl Default for cudaExternalSemaphoreWaitParams__bindgen_ty_1 {
3945 fn default() -> Self {
3946 unsafe { ::std::mem::zeroed() }
3947 }
3948}
3949#[test]
3950fn bindgen_test_layout_cudaExternalSemaphoreWaitParams() {
3951 assert_eq!(
3952 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams>(),
3953 40usize,
3954 concat!("Size of: ", stringify!(cudaExternalSemaphoreWaitParams))
3955 );
3956 assert_eq!(
3957 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams>(),
3958 8usize,
3959 concat!("Alignment of ", stringify!(cudaExternalSemaphoreWaitParams))
3960 );
3961 assert_eq!(
3962 unsafe {
3963 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams>())).params as *const _ as usize
3964 },
3965 0usize,
3966 concat!(
3967 "Offset of field: ",
3968 stringify!(cudaExternalSemaphoreWaitParams),
3969 "::",
3970 stringify!(params)
3971 )
3972 );
3973 assert_eq!(
3974 unsafe {
3975 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams>())).flags as *const _ as usize
3976 },
3977 32usize,
3978 concat!(
3979 "Offset of field: ",
3980 stringify!(cudaExternalSemaphoreWaitParams),
3981 "::",
3982 stringify!(flags)
3983 )
3984 );
3985}
3986impl Default for cudaExternalSemaphoreWaitParams {
3987 fn default() -> Self {
3988 unsafe { ::std::mem::zeroed() }
3989 }
3990}
3991pub use self::cudaError as cudaError_t;
3992#[repr(C)]
3993#[derive(Debug, Copy, Clone)]
3994pub struct CUstream_st {
3995 _unused: [u8; 0],
3996}
3997pub type cudaStream_t = *mut CUstream_st;
3998#[repr(C)]
3999#[derive(Debug, Copy, Clone)]
4000pub struct CUevent_st {
4001 _unused: [u8; 0],
4002}
4003pub type cudaEvent_t = *mut CUevent_st;
4004pub type cudaGraphicsResource_t = *mut cudaGraphicsResource;
4005pub use self::cudaOutputMode as cudaOutputMode_t;
4006#[repr(C)]
4007#[derive(Debug, Copy, Clone)]
4008pub struct CUexternalMemory_st {
4009 _unused: [u8; 0],
4010}
4011pub type cudaExternalMemory_t = *mut CUexternalMemory_st;
4012#[repr(C)]
4013#[derive(Debug, Copy, Clone)]
4014pub struct CUexternalSemaphore_st {
4015 _unused: [u8; 0],
4016}
4017pub type cudaExternalSemaphore_t = *mut CUexternalSemaphore_st;
4018#[repr(C)]
4019#[derive(Debug, Copy, Clone)]
4020pub struct CUgraph_st {
4021 _unused: [u8; 0],
4022}
4023pub type cudaGraph_t = *mut CUgraph_st;
4024#[repr(C)]
4025#[derive(Debug, Copy, Clone)]
4026pub struct CUgraphNode_st {
4027 _unused: [u8; 0],
4028}
4029pub type cudaGraphNode_t = *mut CUgraphNode_st;
4030#[repr(u32)]
4031#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4032pub enum cudaCGScope {
4033 cudaCGScopeInvalid = 0,
4034 cudaCGScopeGrid = 1,
4035 cudaCGScopeMultiGrid = 2,
4036}
4037#[repr(C)]
4038#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4039pub struct cudaLaunchParams {
4040 pub func: *mut ::std::os::raw::c_void,
4041 pub gridDim: dim3,
4042 pub blockDim: dim3,
4043 pub args: *mut *mut ::std::os::raw::c_void,
4044 pub sharedMem: usize,
4045 pub stream: cudaStream_t,
4046}
4047#[test]
4048fn bindgen_test_layout_cudaLaunchParams() {
4049 assert_eq!(
4050 ::std::mem::size_of::<cudaLaunchParams>(),
4051 56usize,
4052 concat!("Size of: ", stringify!(cudaLaunchParams))
4053 );
4054 assert_eq!(
4055 ::std::mem::align_of::<cudaLaunchParams>(),
4056 8usize,
4057 concat!("Alignment of ", stringify!(cudaLaunchParams))
4058 );
4059 assert_eq!(
4060 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).func as *const _ as usize },
4061 0usize,
4062 concat!(
4063 "Offset of field: ",
4064 stringify!(cudaLaunchParams),
4065 "::",
4066 stringify!(func)
4067 )
4068 );
4069 assert_eq!(
4070 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).gridDim as *const _ as usize },
4071 8usize,
4072 concat!(
4073 "Offset of field: ",
4074 stringify!(cudaLaunchParams),
4075 "::",
4076 stringify!(gridDim)
4077 )
4078 );
4079 assert_eq!(
4080 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).blockDim as *const _ as usize },
4081 20usize,
4082 concat!(
4083 "Offset of field: ",
4084 stringify!(cudaLaunchParams),
4085 "::",
4086 stringify!(blockDim)
4087 )
4088 );
4089 assert_eq!(
4090 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).args as *const _ as usize },
4091 32usize,
4092 concat!(
4093 "Offset of field: ",
4094 stringify!(cudaLaunchParams),
4095 "::",
4096 stringify!(args)
4097 )
4098 );
4099 assert_eq!(
4100 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).sharedMem as *const _ as usize },
4101 40usize,
4102 concat!(
4103 "Offset of field: ",
4104 stringify!(cudaLaunchParams),
4105 "::",
4106 stringify!(sharedMem)
4107 )
4108 );
4109 assert_eq!(
4110 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).stream as *const _ as usize },
4111 48usize,
4112 concat!(
4113 "Offset of field: ",
4114 stringify!(cudaLaunchParams),
4115 "::",
4116 stringify!(stream)
4117 )
4118 );
4119}
4120impl Default for cudaLaunchParams {
4121 fn default() -> Self {
4122 unsafe { ::std::mem::zeroed() }
4123 }
4124}
4125#[repr(C)]
4126#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4127pub struct cudaKernelNodeParams {
4128 pub func: *mut ::std::os::raw::c_void,
4129 pub gridDim: dim3,
4130 pub blockDim: dim3,
4131 pub sharedMemBytes: ::std::os::raw::c_uint,
4132 pub kernelParams: *mut *mut ::std::os::raw::c_void,
4133 pub extra: *mut *mut ::std::os::raw::c_void,
4134}
4135#[test]
4136fn bindgen_test_layout_cudaKernelNodeParams() {
4137 assert_eq!(
4138 ::std::mem::size_of::<cudaKernelNodeParams>(),
4139 56usize,
4140 concat!("Size of: ", stringify!(cudaKernelNodeParams))
4141 );
4142 assert_eq!(
4143 ::std::mem::align_of::<cudaKernelNodeParams>(),
4144 8usize,
4145 concat!("Alignment of ", stringify!(cudaKernelNodeParams))
4146 );
4147 assert_eq!(
4148 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).func as *const _ as usize },
4149 0usize,
4150 concat!(
4151 "Offset of field: ",
4152 stringify!(cudaKernelNodeParams),
4153 "::",
4154 stringify!(func)
4155 )
4156 );
4157 assert_eq!(
4158 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).gridDim as *const _ as usize },
4159 8usize,
4160 concat!(
4161 "Offset of field: ",
4162 stringify!(cudaKernelNodeParams),
4163 "::",
4164 stringify!(gridDim)
4165 )
4166 );
4167 assert_eq!(
4168 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).blockDim as *const _ as usize },
4169 20usize,
4170 concat!(
4171 "Offset of field: ",
4172 stringify!(cudaKernelNodeParams),
4173 "::",
4174 stringify!(blockDim)
4175 )
4176 );
4177 assert_eq!(
4178 unsafe {
4179 &(*(::std::ptr::null::<cudaKernelNodeParams>())).sharedMemBytes as *const _ as usize
4180 },
4181 32usize,
4182 concat!(
4183 "Offset of field: ",
4184 stringify!(cudaKernelNodeParams),
4185 "::",
4186 stringify!(sharedMemBytes)
4187 )
4188 );
4189 assert_eq!(
4190 unsafe {
4191 &(*(::std::ptr::null::<cudaKernelNodeParams>())).kernelParams as *const _ as usize
4192 },
4193 40usize,
4194 concat!(
4195 "Offset of field: ",
4196 stringify!(cudaKernelNodeParams),
4197 "::",
4198 stringify!(kernelParams)
4199 )
4200 );
4201 assert_eq!(
4202 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).extra as *const _ as usize },
4203 48usize,
4204 concat!(
4205 "Offset of field: ",
4206 stringify!(cudaKernelNodeParams),
4207 "::",
4208 stringify!(extra)
4209 )
4210 );
4211}
4212impl Default for cudaKernelNodeParams {
4213 fn default() -> Self {
4214 unsafe { ::std::mem::zeroed() }
4215 }
4216}
4217#[repr(u32)]
4218#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4219pub enum cudaGraphNodeType {
4220 cudaGraphNodeTypeKernel = 0,
4221 cudaGraphNodeTypeMemcpy = 1,
4222 cudaGraphNodeTypeMemset = 2,
4223 cudaGraphNodeTypeHost = 3,
4224 cudaGraphNodeTypeGraph = 4,
4225 cudaGraphNodeTypeEmpty = 5,
4226 cudaGraphNodeTypeCount = 6,
4227}
4228#[repr(C)]
4229#[derive(Debug, Copy, Clone)]
4230pub struct CUgraphExec_st {
4231 _unused: [u8; 0],
4232}
4233pub type cudaGraphExec_t = *mut CUgraphExec_st;
4234#[repr(u32)]
4235#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4236pub enum cudaGraphExecUpdateResult {
4237 cudaGraphExecUpdateSuccess = 0,
4238 cudaGraphExecUpdateError = 1,
4239 cudaGraphExecUpdateErrorTopologyChanged = 2,
4240 cudaGraphExecUpdateErrorNodeTypeChanged = 3,
4241 cudaGraphExecUpdateErrorFunctionChanged = 4,
4242 cudaGraphExecUpdateErrorParametersChanged = 5,
4243 cudaGraphExecUpdateErrorNotSupported = 6,
4244}
4245#[repr(u32)]
4246#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4247pub enum cudaSurfaceBoundaryMode {
4248 cudaBoundaryModeZero = 0,
4249 cudaBoundaryModeClamp = 1,
4250 cudaBoundaryModeTrap = 2,
4251}
4252#[repr(u32)]
4253#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4254pub enum cudaSurfaceFormatMode {
4255 cudaFormatModeForced = 0,
4256 cudaFormatModeAuto = 1,
4257}
4258#[repr(C)]
4259#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4260pub struct surfaceReference {
4261 pub channelDesc: cudaChannelFormatDesc,
4262}
4263#[test]
4264fn bindgen_test_layout_surfaceReference() {
4265 assert_eq!(
4266 ::std::mem::size_of::<surfaceReference>(),
4267 20usize,
4268 concat!("Size of: ", stringify!(surfaceReference))
4269 );
4270 assert_eq!(
4271 ::std::mem::align_of::<surfaceReference>(),
4272 4usize,
4273 concat!("Alignment of ", stringify!(surfaceReference))
4274 );
4275 assert_eq!(
4276 unsafe { &(*(::std::ptr::null::<surfaceReference>())).channelDesc as *const _ as usize },
4277 0usize,
4278 concat!(
4279 "Offset of field: ",
4280 stringify!(surfaceReference),
4281 "::",
4282 stringify!(channelDesc)
4283 )
4284 );
4285}
4286impl Default for surfaceReference {
4287 fn default() -> Self {
4288 unsafe { ::std::mem::zeroed() }
4289 }
4290}
4291pub type cudaSurfaceObject_t = ::std::os::raw::c_ulonglong;
4292#[repr(u32)]
4293#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4294pub enum cudaTextureAddressMode {
4295 cudaAddressModeWrap = 0,
4296 cudaAddressModeClamp = 1,
4297 cudaAddressModeMirror = 2,
4298 cudaAddressModeBorder = 3,
4299}
4300#[repr(u32)]
4301#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4302pub enum cudaTextureFilterMode {
4303 cudaFilterModePoint = 0,
4304 cudaFilterModeLinear = 1,
4305}
4306#[repr(u32)]
4307#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4308pub enum cudaTextureReadMode {
4309 cudaReadModeElementType = 0,
4310 cudaReadModeNormalizedFloat = 1,
4311}
4312#[repr(C)]
4313#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
4314pub struct textureReference {
4315 pub normalized: ::std::os::raw::c_int,
4316 pub filterMode: cudaTextureFilterMode,
4317 pub addressMode: [cudaTextureAddressMode; 3usize],
4318 pub channelDesc: cudaChannelFormatDesc,
4319 pub sRGB: ::std::os::raw::c_int,
4320 pub maxAnisotropy: ::std::os::raw::c_uint,
4321 pub mipmapFilterMode: cudaTextureFilterMode,
4322 pub mipmapLevelBias: f32,
4323 pub minMipmapLevelClamp: f32,
4324 pub maxMipmapLevelClamp: f32,
4325 pub __cudaReserved: [::std::os::raw::c_int; 15usize],
4326}
4327#[test]
4328fn bindgen_test_layout_textureReference() {
4329 assert_eq!(
4330 ::std::mem::size_of::<textureReference>(),
4331 124usize,
4332 concat!("Size of: ", stringify!(textureReference))
4333 );
4334 assert_eq!(
4335 ::std::mem::align_of::<textureReference>(),
4336 4usize,
4337 concat!("Alignment of ", stringify!(textureReference))
4338 );
4339 assert_eq!(
4340 unsafe { &(*(::std::ptr::null::<textureReference>())).normalized as *const _ as usize },
4341 0usize,
4342 concat!(
4343 "Offset of field: ",
4344 stringify!(textureReference),
4345 "::",
4346 stringify!(normalized)
4347 )
4348 );
4349 assert_eq!(
4350 unsafe { &(*(::std::ptr::null::<textureReference>())).filterMode as *const _ as usize },
4351 4usize,
4352 concat!(
4353 "Offset of field: ",
4354 stringify!(textureReference),
4355 "::",
4356 stringify!(filterMode)
4357 )
4358 );
4359 assert_eq!(
4360 unsafe { &(*(::std::ptr::null::<textureReference>())).addressMode as *const _ as usize },
4361 8usize,
4362 concat!(
4363 "Offset of field: ",
4364 stringify!(textureReference),
4365 "::",
4366 stringify!(addressMode)
4367 )
4368 );
4369 assert_eq!(
4370 unsafe { &(*(::std::ptr::null::<textureReference>())).channelDesc as *const _ as usize },
4371 20usize,
4372 concat!(
4373 "Offset of field: ",
4374 stringify!(textureReference),
4375 "::",
4376 stringify!(channelDesc)
4377 )
4378 );
4379 assert_eq!(
4380 unsafe { &(*(::std::ptr::null::<textureReference>())).sRGB as *const _ as usize },
4381 40usize,
4382 concat!(
4383 "Offset of field: ",
4384 stringify!(textureReference),
4385 "::",
4386 stringify!(sRGB)
4387 )
4388 );
4389 assert_eq!(
4390 unsafe { &(*(::std::ptr::null::<textureReference>())).maxAnisotropy as *const _ as usize },
4391 44usize,
4392 concat!(
4393 "Offset of field: ",
4394 stringify!(textureReference),
4395 "::",
4396 stringify!(maxAnisotropy)
4397 )
4398 );
4399 assert_eq!(
4400 unsafe {
4401 &(*(::std::ptr::null::<textureReference>())).mipmapFilterMode as *const _ as usize
4402 },
4403 48usize,
4404 concat!(
4405 "Offset of field: ",
4406 stringify!(textureReference),
4407 "::",
4408 stringify!(mipmapFilterMode)
4409 )
4410 );
4411 assert_eq!(
4412 unsafe {
4413 &(*(::std::ptr::null::<textureReference>())).mipmapLevelBias as *const _ as usize
4414 },
4415 52usize,
4416 concat!(
4417 "Offset of field: ",
4418 stringify!(textureReference),
4419 "::",
4420 stringify!(mipmapLevelBias)
4421 )
4422 );
4423 assert_eq!(
4424 unsafe {
4425 &(*(::std::ptr::null::<textureReference>())).minMipmapLevelClamp as *const _ as usize
4426 },
4427 56usize,
4428 concat!(
4429 "Offset of field: ",
4430 stringify!(textureReference),
4431 "::",
4432 stringify!(minMipmapLevelClamp)
4433 )
4434 );
4435 assert_eq!(
4436 unsafe {
4437 &(*(::std::ptr::null::<textureReference>())).maxMipmapLevelClamp as *const _ as usize
4438 },
4439 60usize,
4440 concat!(
4441 "Offset of field: ",
4442 stringify!(textureReference),
4443 "::",
4444 stringify!(maxMipmapLevelClamp)
4445 )
4446 );
4447 assert_eq!(
4448 unsafe { &(*(::std::ptr::null::<textureReference>())).__cudaReserved as *const _ as usize },
4449 64usize,
4450 concat!(
4451 "Offset of field: ",
4452 stringify!(textureReference),
4453 "::",
4454 stringify!(__cudaReserved)
4455 )
4456 );
4457}
4458impl Default for textureReference {
4459 fn default() -> Self {
4460 unsafe { ::std::mem::zeroed() }
4461 }
4462}
4463#[repr(C)]
4464#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
4465pub struct cudaTextureDesc {
4466 pub addressMode: [cudaTextureAddressMode; 3usize],
4467 pub filterMode: cudaTextureFilterMode,
4468 pub readMode: cudaTextureReadMode,
4469 pub sRGB: ::std::os::raw::c_int,
4470 pub borderColor: [f32; 4usize],
4471 pub normalizedCoords: ::std::os::raw::c_int,
4472 pub maxAnisotropy: ::std::os::raw::c_uint,
4473 pub mipmapFilterMode: cudaTextureFilterMode,
4474 pub mipmapLevelBias: f32,
4475 pub minMipmapLevelClamp: f32,
4476 pub maxMipmapLevelClamp: f32,
4477}
4478#[test]
4479fn bindgen_test_layout_cudaTextureDesc() {
4480 assert_eq!(
4481 ::std::mem::size_of::<cudaTextureDesc>(),
4482 64usize,
4483 concat!("Size of: ", stringify!(cudaTextureDesc))
4484 );
4485 assert_eq!(
4486 ::std::mem::align_of::<cudaTextureDesc>(),
4487 4usize,
4488 concat!("Alignment of ", stringify!(cudaTextureDesc))
4489 );
4490 assert_eq!(
4491 unsafe { &(*(::std::ptr::null::<cudaTextureDesc>())).addressMode as *const _ as usize },
4492 0usize,
4493 concat!(
4494 "Offset of field: ",
4495 stringify!(cudaTextureDesc),
4496 "::",
4497 stringify!(addressMode)
4498 )
4499 );
4500 assert_eq!(
4501 unsafe { &(*(::std::ptr::null::<cudaTextureDesc>())).filterMode as *const _ as usize },
4502 12usize,
4503 concat!(
4504 "Offset of field: ",
4505 stringify!(cudaTextureDesc),
4506 "::",
4507 stringify!(filterMode)
4508 )
4509 );
4510 assert_eq!(
4511 unsafe { &(*(::std::ptr::null::<cudaTextureDesc>())).readMode as *const _ as usize },
4512 16usize,
4513 concat!(
4514 "Offset of field: ",
4515 stringify!(cudaTextureDesc),
4516 "::",
4517 stringify!(readMode)
4518 )
4519 );
4520 assert_eq!(
4521 unsafe { &(*(::std::ptr::null::<cudaTextureDesc>())).sRGB as *const _ as usize },
4522 20usize,
4523 concat!(
4524 "Offset of field: ",
4525 stringify!(cudaTextureDesc),
4526 "::",
4527 stringify!(sRGB)
4528 )
4529 );
4530 assert_eq!(
4531 unsafe { &(*(::std::ptr::null::<cudaTextureDesc>())).borderColor as *const _ as usize },
4532 24usize,
4533 concat!(
4534 "Offset of field: ",
4535 stringify!(cudaTextureDesc),
4536 "::",
4537 stringify!(borderColor)
4538 )
4539 );
4540 assert_eq!(
4541 unsafe {
4542 &(*(::std::ptr::null::<cudaTextureDesc>())).normalizedCoords as *const _ as usize
4543 },
4544 40usize,
4545 concat!(
4546 "Offset of field: ",
4547 stringify!(cudaTextureDesc),
4548 "::",
4549 stringify!(normalizedCoords)
4550 )
4551 );
4552 assert_eq!(
4553 unsafe { &(*(::std::ptr::null::<cudaTextureDesc>())).maxAnisotropy as *const _ as usize },
4554 44usize,
4555 concat!(
4556 "Offset of field: ",
4557 stringify!(cudaTextureDesc),
4558 "::",
4559 stringify!(maxAnisotropy)
4560 )
4561 );
4562 assert_eq!(
4563 unsafe {
4564 &(*(::std::ptr::null::<cudaTextureDesc>())).mipmapFilterMode as *const _ as usize
4565 },
4566 48usize,
4567 concat!(
4568 "Offset of field: ",
4569 stringify!(cudaTextureDesc),
4570 "::",
4571 stringify!(mipmapFilterMode)
4572 )
4573 );
4574 assert_eq!(
4575 unsafe { &(*(::std::ptr::null::<cudaTextureDesc>())).mipmapLevelBias as *const _ as usize },
4576 52usize,
4577 concat!(
4578 "Offset of field: ",
4579 stringify!(cudaTextureDesc),
4580 "::",
4581 stringify!(mipmapLevelBias)
4582 )
4583 );
4584 assert_eq!(
4585 unsafe {
4586 &(*(::std::ptr::null::<cudaTextureDesc>())).minMipmapLevelClamp as *const _ as usize
4587 },
4588 56usize,
4589 concat!(
4590 "Offset of field: ",
4591 stringify!(cudaTextureDesc),
4592 "::",
4593 stringify!(minMipmapLevelClamp)
4594 )
4595 );
4596 assert_eq!(
4597 unsafe {
4598 &(*(::std::ptr::null::<cudaTextureDesc>())).maxMipmapLevelClamp as *const _ as usize
4599 },
4600 60usize,
4601 concat!(
4602 "Offset of field: ",
4603 stringify!(cudaTextureDesc),
4604 "::",
4605 stringify!(maxMipmapLevelClamp)
4606 )
4607 );
4608}
4609impl Default for cudaTextureDesc {
4610 fn default() -> Self {
4611 unsafe { ::std::mem::zeroed() }
4612 }
4613}
4614pub type cudaTextureObject_t = ::std::os::raw::c_ulonglong;
4615#[repr(u32)]
4616#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
4617pub enum cudaDataType_t {
4618 CUDA_R_16F = 2,
4619 CUDA_C_16F = 6,
4620 CUDA_R_32F = 0,
4621 CUDA_C_32F = 4,
4622 CUDA_R_64F = 1,
4623 CUDA_C_64F = 5,
4624 CUDA_R_8I = 3,
4625 CUDA_C_8I = 7,
4626 CUDA_R_8U = 8,
4627 CUDA_C_8U = 9,
4628 CUDA_R_32I = 10,
4629 CUDA_C_32I = 11,
4630 CUDA_R_32U = 12,
4631 CUDA_C_32U = 13,
4632}
4633pub use self::cudaDataType_t as cudaDataType;
4634extern "C" {
4635 pub fn cudaDeviceReset() -> cudaError_t;
4636}
4637extern "C" {
4638 pub fn cudaDeviceSynchronize() -> cudaError_t;
4639}
4640extern "C" {
4641 pub fn cudaDeviceSetLimit(limit: cudaLimit, value: usize) -> cudaError_t;
4642}
4643extern "C" {
4644 pub fn cudaDeviceGetLimit(pValue: *mut usize, limit: cudaLimit) -> cudaError_t;
4645}
4646extern "C" {
4647 pub fn cudaDeviceGetCacheConfig(pCacheConfig: *mut cudaFuncCache) -> cudaError_t;
4648}
4649extern "C" {
4650 pub fn cudaDeviceGetStreamPriorityRange(
4651 leastPriority: *mut ::std::os::raw::c_int,
4652 greatestPriority: *mut ::std::os::raw::c_int,
4653 ) -> cudaError_t;
4654}
4655extern "C" {
4656 pub fn cudaDeviceSetCacheConfig(cacheConfig: cudaFuncCache) -> cudaError_t;
4657}
4658extern "C" {
4659 pub fn cudaDeviceGetSharedMemConfig(pConfig: *mut cudaSharedMemConfig) -> cudaError_t;
4660}
4661extern "C" {
4662 pub fn cudaDeviceSetSharedMemConfig(config: cudaSharedMemConfig) -> cudaError_t;
4663}
4664extern "C" {
4665 pub fn cudaDeviceGetByPCIBusId(
4666 device: *mut ::std::os::raw::c_int,
4667 pciBusId: *const ::std::os::raw::c_char,
4668 ) -> cudaError_t;
4669}
4670extern "C" {
4671 pub fn cudaDeviceGetPCIBusId(
4672 pciBusId: *mut ::std::os::raw::c_char,
4673 len: ::std::os::raw::c_int,
4674 device: ::std::os::raw::c_int,
4675 ) -> cudaError_t;
4676}
4677extern "C" {
4678 pub fn cudaIpcGetEventHandle(
4679 handle: *mut cudaIpcEventHandle_t,
4680 event: cudaEvent_t,
4681 ) -> cudaError_t;
4682}
4683extern "C" {
4684 pub fn cudaIpcOpenEventHandle(
4685 event: *mut cudaEvent_t,
4686 handle: cudaIpcEventHandle_t,
4687 ) -> cudaError_t;
4688}
4689extern "C" {
4690 pub fn cudaIpcGetMemHandle(
4691 handle: *mut cudaIpcMemHandle_t,
4692 devPtr: *mut ::std::os::raw::c_void,
4693 ) -> cudaError_t;
4694}
4695extern "C" {
4696 pub fn cudaIpcOpenMemHandle(
4697 devPtr: *mut *mut ::std::os::raw::c_void,
4698 handle: cudaIpcMemHandle_t,
4699 flags: ::std::os::raw::c_uint,
4700 ) -> cudaError_t;
4701}
4702extern "C" {
4703 pub fn cudaIpcCloseMemHandle(devPtr: *mut ::std::os::raw::c_void) -> cudaError_t;
4704}
4705extern "C" {
4706 pub fn cudaThreadExit() -> cudaError_t;
4707}
4708extern "C" {
4709 pub fn cudaThreadSynchronize() -> cudaError_t;
4710}
4711extern "C" {
4712 pub fn cudaThreadSetLimit(limit: cudaLimit, value: usize) -> cudaError_t;
4713}
4714extern "C" {
4715 pub fn cudaThreadGetLimit(pValue: *mut usize, limit: cudaLimit) -> cudaError_t;
4716}
4717extern "C" {
4718 pub fn cudaThreadGetCacheConfig(pCacheConfig: *mut cudaFuncCache) -> cudaError_t;
4719}
4720extern "C" {
4721 pub fn cudaThreadSetCacheConfig(cacheConfig: cudaFuncCache) -> cudaError_t;
4722}
4723extern "C" {
4724 pub fn cudaGetLastError() -> cudaError_t;
4725}
4726extern "C" {
4727 pub fn cudaPeekAtLastError() -> cudaError_t;
4728}
4729extern "C" {
4730 pub fn cudaGetErrorName(error: cudaError_t) -> *const ::std::os::raw::c_char;
4731}
4732extern "C" {
4733 pub fn cudaGetErrorString(error: cudaError_t) -> *const ::std::os::raw::c_char;
4734}
4735extern "C" {
4736 pub fn cudaGetDeviceCount(count: *mut ::std::os::raw::c_int) -> cudaError_t;
4737}
4738extern "C" {
4739 pub fn cudaGetDeviceProperties(
4740 prop: *mut cudaDeviceProp,
4741 device: ::std::os::raw::c_int,
4742 ) -> cudaError_t;
4743}
4744extern "C" {
4745 pub fn cudaDeviceGetAttribute(
4746 value: *mut ::std::os::raw::c_int,
4747 attr: cudaDeviceAttr,
4748 device: ::std::os::raw::c_int,
4749 ) -> cudaError_t;
4750}
4751extern "C" {
4752 pub fn cudaDeviceGetNvSciSyncAttributes(
4753 nvSciSyncAttrList: *mut ::std::os::raw::c_void,
4754 device: ::std::os::raw::c_int,
4755 flags: ::std::os::raw::c_int,
4756 ) -> cudaError_t;
4757}
4758extern "C" {
4759 pub fn cudaDeviceGetP2PAttribute(
4760 value: *mut ::std::os::raw::c_int,
4761 attr: cudaDeviceP2PAttr,
4762 srcDevice: ::std::os::raw::c_int,
4763 dstDevice: ::std::os::raw::c_int,
4764 ) -> cudaError_t;
4765}
4766extern "C" {
4767 pub fn cudaChooseDevice(
4768 device: *mut ::std::os::raw::c_int,
4769 prop: *const cudaDeviceProp,
4770 ) -> cudaError_t;
4771}
4772extern "C" {
4773 pub fn cudaSetDevice(device: ::std::os::raw::c_int) -> cudaError_t;
4774}
4775extern "C" {
4776 pub fn cudaGetDevice(device: *mut ::std::os::raw::c_int) -> cudaError_t;
4777}
4778extern "C" {
4779 pub fn cudaSetValidDevices(
4780 device_arr: *mut ::std::os::raw::c_int,
4781 len: ::std::os::raw::c_int,
4782 ) -> cudaError_t;
4783}
4784extern "C" {
4785 pub fn cudaSetDeviceFlags(flags: ::std::os::raw::c_uint) -> cudaError_t;
4786}
4787extern "C" {
4788 pub fn cudaGetDeviceFlags(flags: *mut ::std::os::raw::c_uint) -> cudaError_t;
4789}
4790extern "C" {
4791 pub fn cudaStreamCreate(pStream: *mut cudaStream_t) -> cudaError_t;
4792}
4793extern "C" {
4794 pub fn cudaStreamCreateWithFlags(
4795 pStream: *mut cudaStream_t,
4796 flags: ::std::os::raw::c_uint,
4797 ) -> cudaError_t;
4798}
4799extern "C" {
4800 pub fn cudaStreamCreateWithPriority(
4801 pStream: *mut cudaStream_t,
4802 flags: ::std::os::raw::c_uint,
4803 priority: ::std::os::raw::c_int,
4804 ) -> cudaError_t;
4805}
4806extern "C" {
4807 pub fn cudaStreamGetPriority(
4808 hStream: cudaStream_t,
4809 priority: *mut ::std::os::raw::c_int,
4810 ) -> cudaError_t;
4811}
4812extern "C" {
4813 pub fn cudaStreamGetFlags(
4814 hStream: cudaStream_t,
4815 flags: *mut ::std::os::raw::c_uint,
4816 ) -> cudaError_t;
4817}
4818extern "C" {
4819 pub fn cudaStreamDestroy(stream: cudaStream_t) -> cudaError_t;
4820}
4821extern "C" {
4822 pub fn cudaStreamWaitEvent(
4823 stream: cudaStream_t,
4824 event: cudaEvent_t,
4825 flags: ::std::os::raw::c_uint,
4826 ) -> cudaError_t;
4827}
4828pub type cudaStreamCallback_t = ::std::option::Option<
4829 unsafe extern "C" fn(
4830 stream: cudaStream_t,
4831 status: cudaError_t,
4832 userData: *mut ::std::os::raw::c_void,
4833 ),
4834>;
4835extern "C" {
4836 pub fn cudaStreamAddCallback(
4837 stream: cudaStream_t,
4838 callback: cudaStreamCallback_t,
4839 userData: *mut ::std::os::raw::c_void,
4840 flags: ::std::os::raw::c_uint,
4841 ) -> cudaError_t;
4842}
4843extern "C" {
4844 pub fn cudaStreamSynchronize(stream: cudaStream_t) -> cudaError_t;
4845}
4846extern "C" {
4847 pub fn cudaStreamQuery(stream: cudaStream_t) -> cudaError_t;
4848}
4849extern "C" {
4850 pub fn cudaStreamAttachMemAsync(
4851 stream: cudaStream_t,
4852 devPtr: *mut ::std::os::raw::c_void,
4853 length: usize,
4854 flags: ::std::os::raw::c_uint,
4855 ) -> cudaError_t;
4856}
4857extern "C" {
4858 pub fn cudaStreamBeginCapture(stream: cudaStream_t, mode: cudaStreamCaptureMode)
4859 -> cudaError_t;
4860}
4861extern "C" {
4862 pub fn cudaThreadExchangeStreamCaptureMode(mode: *mut cudaStreamCaptureMode) -> cudaError_t;
4863}
4864extern "C" {
4865 pub fn cudaStreamEndCapture(stream: cudaStream_t, pGraph: *mut cudaGraph_t) -> cudaError_t;
4866}
4867extern "C" {
4868 pub fn cudaStreamIsCapturing(
4869 stream: cudaStream_t,
4870 pCaptureStatus: *mut cudaStreamCaptureStatus,
4871 ) -> cudaError_t;
4872}
4873extern "C" {
4874 pub fn cudaStreamGetCaptureInfo(
4875 stream: cudaStream_t,
4876 pCaptureStatus: *mut cudaStreamCaptureStatus,
4877 pId: *mut ::std::os::raw::c_ulonglong,
4878 ) -> cudaError_t;
4879}
4880extern "C" {
4881 pub fn cudaEventCreate(event: *mut cudaEvent_t) -> cudaError_t;
4882}
4883extern "C" {
4884 pub fn cudaEventCreateWithFlags(
4885 event: *mut cudaEvent_t,
4886 flags: ::std::os::raw::c_uint,
4887 ) -> cudaError_t;
4888}
4889extern "C" {
4890 pub fn cudaEventRecord(event: cudaEvent_t, stream: cudaStream_t) -> cudaError_t;
4891}
4892extern "C" {
4893 pub fn cudaEventQuery(event: cudaEvent_t) -> cudaError_t;
4894}
4895extern "C" {
4896 pub fn cudaEventSynchronize(event: cudaEvent_t) -> cudaError_t;
4897}
4898extern "C" {
4899 pub fn cudaEventDestroy(event: cudaEvent_t) -> cudaError_t;
4900}
4901extern "C" {
4902 pub fn cudaEventElapsedTime(ms: *mut f32, start: cudaEvent_t, end: cudaEvent_t) -> cudaError_t;
4903}
4904extern "C" {
4905 pub fn cudaImportExternalMemory(
4906 extMem_out: *mut cudaExternalMemory_t,
4907 memHandleDesc: *const cudaExternalMemoryHandleDesc,
4908 ) -> cudaError_t;
4909}
4910extern "C" {
4911 pub fn cudaExternalMemoryGetMappedBuffer(
4912 devPtr: *mut *mut ::std::os::raw::c_void,
4913 extMem: cudaExternalMemory_t,
4914 bufferDesc: *const cudaExternalMemoryBufferDesc,
4915 ) -> cudaError_t;
4916}
4917extern "C" {
4918 pub fn cudaExternalMemoryGetMappedMipmappedArray(
4919 mipmap: *mut cudaMipmappedArray_t,
4920 extMem: cudaExternalMemory_t,
4921 mipmapDesc: *const cudaExternalMemoryMipmappedArrayDesc,
4922 ) -> cudaError_t;
4923}
4924extern "C" {
4925 pub fn cudaDestroyExternalMemory(extMem: cudaExternalMemory_t) -> cudaError_t;
4926}
4927extern "C" {
4928 pub fn cudaImportExternalSemaphore(
4929 extSem_out: *mut cudaExternalSemaphore_t,
4930 semHandleDesc: *const cudaExternalSemaphoreHandleDesc,
4931 ) -> cudaError_t;
4932}
4933extern "C" {
4934 pub fn cudaSignalExternalSemaphoresAsync(
4935 extSemArray: *const cudaExternalSemaphore_t,
4936 paramsArray: *const cudaExternalSemaphoreSignalParams,
4937 numExtSems: ::std::os::raw::c_uint,
4938 stream: cudaStream_t,
4939 ) -> cudaError_t;
4940}
4941extern "C" {
4942 pub fn cudaWaitExternalSemaphoresAsync(
4943 extSemArray: *const cudaExternalSemaphore_t,
4944 paramsArray: *const cudaExternalSemaphoreWaitParams,
4945 numExtSems: ::std::os::raw::c_uint,
4946 stream: cudaStream_t,
4947 ) -> cudaError_t;
4948}
4949extern "C" {
4950 pub fn cudaDestroyExternalSemaphore(extSem: cudaExternalSemaphore_t) -> cudaError_t;
4951}
4952extern "C" {
4953 pub fn cudaLaunchKernel(
4954 func: *const ::std::os::raw::c_void,
4955 gridDim: dim3,
4956 blockDim: dim3,
4957 args: *mut *mut ::std::os::raw::c_void,
4958 sharedMem: usize,
4959 stream: cudaStream_t,
4960 ) -> cudaError_t;
4961}
4962extern "C" {
4963 pub fn cudaLaunchCooperativeKernel(
4964 func: *const ::std::os::raw::c_void,
4965 gridDim: dim3,
4966 blockDim: dim3,
4967 args: *mut *mut ::std::os::raw::c_void,
4968 sharedMem: usize,
4969 stream: cudaStream_t,
4970 ) -> cudaError_t;
4971}
4972extern "C" {
4973 pub fn cudaLaunchCooperativeKernelMultiDevice(
4974 launchParamsList: *mut cudaLaunchParams,
4975 numDevices: ::std::os::raw::c_uint,
4976 flags: ::std::os::raw::c_uint,
4977 ) -> cudaError_t;
4978}
4979extern "C" {
4980 pub fn cudaFuncSetCacheConfig(
4981 func: *const ::std::os::raw::c_void,
4982 cacheConfig: cudaFuncCache,
4983 ) -> cudaError_t;
4984}
4985extern "C" {
4986 pub fn cudaFuncSetSharedMemConfig(
4987 func: *const ::std::os::raw::c_void,
4988 config: cudaSharedMemConfig,
4989 ) -> cudaError_t;
4990}
4991extern "C" {
4992 pub fn cudaFuncGetAttributes(
4993 attr: *mut cudaFuncAttributes,
4994 func: *const ::std::os::raw::c_void,
4995 ) -> cudaError_t;
4996}
4997extern "C" {
4998 pub fn cudaFuncSetAttribute(
4999 func: *const ::std::os::raw::c_void,
5000 attr: cudaFuncAttribute,
5001 value: ::std::os::raw::c_int,
5002 ) -> cudaError_t;
5003}
5004extern "C" {
5005 pub fn cudaSetDoubleForDevice(d: *mut f64) -> cudaError_t;
5006}
5007extern "C" {
5008 pub fn cudaSetDoubleForHost(d: *mut f64) -> cudaError_t;
5009}
5010extern "C" {
5011 pub fn cudaLaunchHostFunc(
5012 stream: cudaStream_t,
5013 fn_: cudaHostFn_t,
5014 userData: *mut ::std::os::raw::c_void,
5015 ) -> cudaError_t;
5016}
5017extern "C" {
5018 pub fn cudaOccupancyMaxActiveBlocksPerMultiprocessor(
5019 numBlocks: *mut ::std::os::raw::c_int,
5020 func: *const ::std::os::raw::c_void,
5021 blockSize: ::std::os::raw::c_int,
5022 dynamicSMemSize: usize,
5023 ) -> cudaError_t;
5024}
5025extern "C" {
5026 pub fn cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
5027 numBlocks: *mut ::std::os::raw::c_int,
5028 func: *const ::std::os::raw::c_void,
5029 blockSize: ::std::os::raw::c_int,
5030 dynamicSMemSize: usize,
5031 flags: ::std::os::raw::c_uint,
5032 ) -> cudaError_t;
5033}
5034extern "C" {
5035 pub fn cudaMallocManaged(
5036 devPtr: *mut *mut ::std::os::raw::c_void,
5037 size: usize,
5038 flags: ::std::os::raw::c_uint,
5039 ) -> cudaError_t;
5040}
5041extern "C" {
5042 pub fn cudaMalloc(devPtr: *mut *mut ::std::os::raw::c_void, size: usize) -> cudaError_t;
5043}
5044extern "C" {
5045 pub fn cudaMallocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> cudaError_t;
5046}
5047extern "C" {
5048 pub fn cudaMallocPitch(
5049 devPtr: *mut *mut ::std::os::raw::c_void,
5050 pitch: *mut usize,
5051 width: usize,
5052 height: usize,
5053 ) -> cudaError_t;
5054}
5055extern "C" {
5056 pub fn cudaMallocArray(
5057 array: *mut cudaArray_t,
5058 desc: *const cudaChannelFormatDesc,
5059 width: usize,
5060 height: usize,
5061 flags: ::std::os::raw::c_uint,
5062 ) -> cudaError_t;
5063}
5064extern "C" {
5065 pub fn cudaFree(devPtr: *mut ::std::os::raw::c_void) -> cudaError_t;
5066}
5067extern "C" {
5068 pub fn cudaFreeHost(ptr: *mut ::std::os::raw::c_void) -> cudaError_t;
5069}
5070extern "C" {
5071 pub fn cudaFreeArray(array: cudaArray_t) -> cudaError_t;
5072}
5073extern "C" {
5074 pub fn cudaFreeMipmappedArray(mipmappedArray: cudaMipmappedArray_t) -> cudaError_t;
5075}
5076extern "C" {
5077 pub fn cudaHostAlloc(
5078 pHost: *mut *mut ::std::os::raw::c_void,
5079 size: usize,
5080 flags: ::std::os::raw::c_uint,
5081 ) -> cudaError_t;
5082}
5083extern "C" {
5084 pub fn cudaHostRegister(
5085 ptr: *mut ::std::os::raw::c_void,
5086 size: usize,
5087 flags: ::std::os::raw::c_uint,
5088 ) -> cudaError_t;
5089}
5090extern "C" {
5091 pub fn cudaHostUnregister(ptr: *mut ::std::os::raw::c_void) -> cudaError_t;
5092}
5093extern "C" {
5094 pub fn cudaHostGetDevicePointer(
5095 pDevice: *mut *mut ::std::os::raw::c_void,
5096 pHost: *mut ::std::os::raw::c_void,
5097 flags: ::std::os::raw::c_uint,
5098 ) -> cudaError_t;
5099}
5100extern "C" {
5101 pub fn cudaHostGetFlags(
5102 pFlags: *mut ::std::os::raw::c_uint,
5103 pHost: *mut ::std::os::raw::c_void,
5104 ) -> cudaError_t;
5105}
5106extern "C" {
5107 pub fn cudaMalloc3D(pitchedDevPtr: *mut cudaPitchedPtr, extent: cudaExtent) -> cudaError_t;
5108}
5109extern "C" {
5110 pub fn cudaMalloc3DArray(
5111 array: *mut cudaArray_t,
5112 desc: *const cudaChannelFormatDesc,
5113 extent: cudaExtent,
5114 flags: ::std::os::raw::c_uint,
5115 ) -> cudaError_t;
5116}
5117extern "C" {
5118 pub fn cudaMallocMipmappedArray(
5119 mipmappedArray: *mut cudaMipmappedArray_t,
5120 desc: *const cudaChannelFormatDesc,
5121 extent: cudaExtent,
5122 numLevels: ::std::os::raw::c_uint,
5123 flags: ::std::os::raw::c_uint,
5124 ) -> cudaError_t;
5125}
5126extern "C" {
5127 pub fn cudaGetMipmappedArrayLevel(
5128 levelArray: *mut cudaArray_t,
5129 mipmappedArray: cudaMipmappedArray_const_t,
5130 level: ::std::os::raw::c_uint,
5131 ) -> cudaError_t;
5132}
5133extern "C" {
5134 pub fn cudaMemcpy3D(p: *const cudaMemcpy3DParms) -> cudaError_t;
5135}
5136extern "C" {
5137 pub fn cudaMemcpy3DPeer(p: *const cudaMemcpy3DPeerParms) -> cudaError_t;
5138}
5139extern "C" {
5140 pub fn cudaMemcpy3DAsync(p: *const cudaMemcpy3DParms, stream: cudaStream_t) -> cudaError_t;
5141}
5142extern "C" {
5143 pub fn cudaMemcpy3DPeerAsync(
5144 p: *const cudaMemcpy3DPeerParms,
5145 stream: cudaStream_t,
5146 ) -> cudaError_t;
5147}
5148extern "C" {
5149 pub fn cudaMemGetInfo(free: *mut usize, total: *mut usize) -> cudaError_t;
5150}
5151extern "C" {
5152 pub fn cudaArrayGetInfo(
5153 desc: *mut cudaChannelFormatDesc,
5154 extent: *mut cudaExtent,
5155 flags: *mut ::std::os::raw::c_uint,
5156 array: cudaArray_t,
5157 ) -> cudaError_t;
5158}
5159extern "C" {
5160 pub fn cudaMemcpy(
5161 dst: *mut ::std::os::raw::c_void,
5162 src: *const ::std::os::raw::c_void,
5163 count: usize,
5164 kind: cudaMemcpyKind,
5165 ) -> cudaError_t;
5166}
5167extern "C" {
5168 pub fn cudaMemcpyPeer(
5169 dst: *mut ::std::os::raw::c_void,
5170 dstDevice: ::std::os::raw::c_int,
5171 src: *const ::std::os::raw::c_void,
5172 srcDevice: ::std::os::raw::c_int,
5173 count: usize,
5174 ) -> cudaError_t;
5175}
5176extern "C" {
5177 pub fn cudaMemcpy2D(
5178 dst: *mut ::std::os::raw::c_void,
5179 dpitch: usize,
5180 src: *const ::std::os::raw::c_void,
5181 spitch: usize,
5182 width: usize,
5183 height: usize,
5184 kind: cudaMemcpyKind,
5185 ) -> cudaError_t;
5186}
5187extern "C" {
5188 pub fn cudaMemcpy2DToArray(
5189 dst: cudaArray_t,
5190 wOffset: usize,
5191 hOffset: usize,
5192 src: *const ::std::os::raw::c_void,
5193 spitch: usize,
5194 width: usize,
5195 height: usize,
5196 kind: cudaMemcpyKind,
5197 ) -> cudaError_t;
5198}
5199extern "C" {
5200 pub fn cudaMemcpy2DFromArray(
5201 dst: *mut ::std::os::raw::c_void,
5202 dpitch: usize,
5203 src: cudaArray_const_t,
5204 wOffset: usize,
5205 hOffset: usize,
5206 width: usize,
5207 height: usize,
5208 kind: cudaMemcpyKind,
5209 ) -> cudaError_t;
5210}
5211extern "C" {
5212 pub fn cudaMemcpy2DArrayToArray(
5213 dst: cudaArray_t,
5214 wOffsetDst: usize,
5215 hOffsetDst: usize,
5216 src: cudaArray_const_t,
5217 wOffsetSrc: usize,
5218 hOffsetSrc: usize,
5219 width: usize,
5220 height: usize,
5221 kind: cudaMemcpyKind,
5222 ) -> cudaError_t;
5223}
5224extern "C" {
5225 pub fn cudaMemcpyToSymbol(
5226 symbol: *const ::std::os::raw::c_void,
5227 src: *const ::std::os::raw::c_void,
5228 count: usize,
5229 offset: usize,
5230 kind: cudaMemcpyKind,
5231 ) -> cudaError_t;
5232}
5233extern "C" {
5234 pub fn cudaMemcpyFromSymbol(
5235 dst: *mut ::std::os::raw::c_void,
5236 symbol: *const ::std::os::raw::c_void,
5237 count: usize,
5238 offset: usize,
5239 kind: cudaMemcpyKind,
5240 ) -> cudaError_t;
5241}
5242extern "C" {
5243 pub fn cudaMemcpyAsync(
5244 dst: *mut ::std::os::raw::c_void,
5245 src: *const ::std::os::raw::c_void,
5246 count: usize,
5247 kind: cudaMemcpyKind,
5248 stream: cudaStream_t,
5249 ) -> cudaError_t;
5250}
5251extern "C" {
5252 pub fn cudaMemcpyPeerAsync(
5253 dst: *mut ::std::os::raw::c_void,
5254 dstDevice: ::std::os::raw::c_int,
5255 src: *const ::std::os::raw::c_void,
5256 srcDevice: ::std::os::raw::c_int,
5257 count: usize,
5258 stream: cudaStream_t,
5259 ) -> cudaError_t;
5260}
5261extern "C" {
5262 pub fn cudaMemcpy2DAsync(
5263 dst: *mut ::std::os::raw::c_void,
5264 dpitch: usize,
5265 src: *const ::std::os::raw::c_void,
5266 spitch: usize,
5267 width: usize,
5268 height: usize,
5269 kind: cudaMemcpyKind,
5270 stream: cudaStream_t,
5271 ) -> cudaError_t;
5272}
5273extern "C" {
5274 pub fn cudaMemcpy2DToArrayAsync(
5275 dst: cudaArray_t,
5276 wOffset: usize,
5277 hOffset: usize,
5278 src: *const ::std::os::raw::c_void,
5279 spitch: usize,
5280 width: usize,
5281 height: usize,
5282 kind: cudaMemcpyKind,
5283 stream: cudaStream_t,
5284 ) -> cudaError_t;
5285}
5286extern "C" {
5287 pub fn cudaMemcpy2DFromArrayAsync(
5288 dst: *mut ::std::os::raw::c_void,
5289 dpitch: usize,
5290 src: cudaArray_const_t,
5291 wOffset: usize,
5292 hOffset: usize,
5293 width: usize,
5294 height: usize,
5295 kind: cudaMemcpyKind,
5296 stream: cudaStream_t,
5297 ) -> cudaError_t;
5298}
5299extern "C" {
5300 pub fn cudaMemcpyToSymbolAsync(
5301 symbol: *const ::std::os::raw::c_void,
5302 src: *const ::std::os::raw::c_void,
5303 count: usize,
5304 offset: usize,
5305 kind: cudaMemcpyKind,
5306 stream: cudaStream_t,
5307 ) -> cudaError_t;
5308}
5309extern "C" {
5310 pub fn cudaMemcpyFromSymbolAsync(
5311 dst: *mut ::std::os::raw::c_void,
5312 symbol: *const ::std::os::raw::c_void,
5313 count: usize,
5314 offset: usize,
5315 kind: cudaMemcpyKind,
5316 stream: cudaStream_t,
5317 ) -> cudaError_t;
5318}
5319extern "C" {
5320 pub fn cudaMemset(
5321 devPtr: *mut ::std::os::raw::c_void,
5322 value: ::std::os::raw::c_int,
5323 count: usize,
5324 ) -> cudaError_t;
5325}
5326extern "C" {
5327 pub fn cudaMemset2D(
5328 devPtr: *mut ::std::os::raw::c_void,
5329 pitch: usize,
5330 value: ::std::os::raw::c_int,
5331 width: usize,
5332 height: usize,
5333 ) -> cudaError_t;
5334}
5335extern "C" {
5336 pub fn cudaMemset3D(
5337 pitchedDevPtr: cudaPitchedPtr,
5338 value: ::std::os::raw::c_int,
5339 extent: cudaExtent,
5340 ) -> cudaError_t;
5341}
5342extern "C" {
5343 pub fn cudaMemsetAsync(
5344 devPtr: *mut ::std::os::raw::c_void,
5345 value: ::std::os::raw::c_int,
5346 count: usize,
5347 stream: cudaStream_t,
5348 ) -> cudaError_t;
5349}
5350extern "C" {
5351 pub fn cudaMemset2DAsync(
5352 devPtr: *mut ::std::os::raw::c_void,
5353 pitch: usize,
5354 value: ::std::os::raw::c_int,
5355 width: usize,
5356 height: usize,
5357 stream: cudaStream_t,
5358 ) -> cudaError_t;
5359}
5360extern "C" {
5361 pub fn cudaMemset3DAsync(
5362 pitchedDevPtr: cudaPitchedPtr,
5363 value: ::std::os::raw::c_int,
5364 extent: cudaExtent,
5365 stream: cudaStream_t,
5366 ) -> cudaError_t;
5367}
5368extern "C" {
5369 pub fn cudaGetSymbolAddress(
5370 devPtr: *mut *mut ::std::os::raw::c_void,
5371 symbol: *const ::std::os::raw::c_void,
5372 ) -> cudaError_t;
5373}
5374extern "C" {
5375 pub fn cudaGetSymbolSize(
5376 size: *mut usize,
5377 symbol: *const ::std::os::raw::c_void,
5378 ) -> cudaError_t;
5379}
5380extern "C" {
5381 pub fn cudaMemPrefetchAsync(
5382 devPtr: *const ::std::os::raw::c_void,
5383 count: usize,
5384 dstDevice: ::std::os::raw::c_int,
5385 stream: cudaStream_t,
5386 ) -> cudaError_t;
5387}
5388extern "C" {
5389 pub fn cudaMemAdvise(
5390 devPtr: *const ::std::os::raw::c_void,
5391 count: usize,
5392 advice: cudaMemoryAdvise,
5393 device: ::std::os::raw::c_int,
5394 ) -> cudaError_t;
5395}
5396extern "C" {
5397 pub fn cudaMemRangeGetAttribute(
5398 data: *mut ::std::os::raw::c_void,
5399 dataSize: usize,
5400 attribute: cudaMemRangeAttribute,
5401 devPtr: *const ::std::os::raw::c_void,
5402 count: usize,
5403 ) -> cudaError_t;
5404}
5405extern "C" {
5406 pub fn cudaMemRangeGetAttributes(
5407 data: *mut *mut ::std::os::raw::c_void,
5408 dataSizes: *mut usize,
5409 attributes: *mut cudaMemRangeAttribute,
5410 numAttributes: usize,
5411 devPtr: *const ::std::os::raw::c_void,
5412 count: usize,
5413 ) -> cudaError_t;
5414}
5415extern "C" {
5416 pub fn cudaMemcpyToArray(
5417 dst: cudaArray_t,
5418 wOffset: usize,
5419 hOffset: usize,
5420 src: *const ::std::os::raw::c_void,
5421 count: usize,
5422 kind: cudaMemcpyKind,
5423 ) -> cudaError_t;
5424}
5425extern "C" {
5426 pub fn cudaMemcpyFromArray(
5427 dst: *mut ::std::os::raw::c_void,
5428 src: cudaArray_const_t,
5429 wOffset: usize,
5430 hOffset: usize,
5431 count: usize,
5432 kind: cudaMemcpyKind,
5433 ) -> cudaError_t;
5434}
5435extern "C" {
5436 pub fn cudaMemcpyArrayToArray(
5437 dst: cudaArray_t,
5438 wOffsetDst: usize,
5439 hOffsetDst: usize,
5440 src: cudaArray_const_t,
5441 wOffsetSrc: usize,
5442 hOffsetSrc: usize,
5443 count: usize,
5444 kind: cudaMemcpyKind,
5445 ) -> cudaError_t;
5446}
5447extern "C" {
5448 pub fn cudaMemcpyToArrayAsync(
5449 dst: cudaArray_t,
5450 wOffset: usize,
5451 hOffset: usize,
5452 src: *const ::std::os::raw::c_void,
5453 count: usize,
5454 kind: cudaMemcpyKind,
5455 stream: cudaStream_t,
5456 ) -> cudaError_t;
5457}
5458extern "C" {
5459 pub fn cudaMemcpyFromArrayAsync(
5460 dst: *mut ::std::os::raw::c_void,
5461 src: cudaArray_const_t,
5462 wOffset: usize,
5463 hOffset: usize,
5464 count: usize,
5465 kind: cudaMemcpyKind,
5466 stream: cudaStream_t,
5467 ) -> cudaError_t;
5468}
5469extern "C" {
5470 pub fn cudaPointerGetAttributes(
5471 attributes: *mut cudaPointerAttributes,
5472 ptr: *const ::std::os::raw::c_void,
5473 ) -> cudaError_t;
5474}
5475extern "C" {
5476 pub fn cudaDeviceCanAccessPeer(
5477 canAccessPeer: *mut ::std::os::raw::c_int,
5478 device: ::std::os::raw::c_int,
5479 peerDevice: ::std::os::raw::c_int,
5480 ) -> cudaError_t;
5481}
5482extern "C" {
5483 pub fn cudaDeviceEnablePeerAccess(
5484 peerDevice: ::std::os::raw::c_int,
5485 flags: ::std::os::raw::c_uint,
5486 ) -> cudaError_t;
5487}
5488extern "C" {
5489 pub fn cudaDeviceDisablePeerAccess(peerDevice: ::std::os::raw::c_int) -> cudaError_t;
5490}
5491extern "C" {
5492 pub fn cudaGraphicsUnregisterResource(resource: cudaGraphicsResource_t) -> cudaError_t;
5493}
5494extern "C" {
5495 pub fn cudaGraphicsResourceSetMapFlags(
5496 resource: cudaGraphicsResource_t,
5497 flags: ::std::os::raw::c_uint,
5498 ) -> cudaError_t;
5499}
5500extern "C" {
5501 pub fn cudaGraphicsMapResources(
5502 count: ::std::os::raw::c_int,
5503 resources: *mut cudaGraphicsResource_t,
5504 stream: cudaStream_t,
5505 ) -> cudaError_t;
5506}
5507extern "C" {
5508 pub fn cudaGraphicsUnmapResources(
5509 count: ::std::os::raw::c_int,
5510 resources: *mut cudaGraphicsResource_t,
5511 stream: cudaStream_t,
5512 ) -> cudaError_t;
5513}
5514extern "C" {
5515 pub fn cudaGraphicsResourceGetMappedPointer(
5516 devPtr: *mut *mut ::std::os::raw::c_void,
5517 size: *mut usize,
5518 resource: cudaGraphicsResource_t,
5519 ) -> cudaError_t;
5520}
5521extern "C" {
5522 pub fn cudaGraphicsSubResourceGetMappedArray(
5523 array: *mut cudaArray_t,
5524 resource: cudaGraphicsResource_t,
5525 arrayIndex: ::std::os::raw::c_uint,
5526 mipLevel: ::std::os::raw::c_uint,
5527 ) -> cudaError_t;
5528}
5529extern "C" {
5530 pub fn cudaGraphicsResourceGetMappedMipmappedArray(
5531 mipmappedArray: *mut cudaMipmappedArray_t,
5532 resource: cudaGraphicsResource_t,
5533 ) -> cudaError_t;
5534}
5535extern "C" {
5536 pub fn cudaBindTexture(
5537 offset: *mut usize,
5538 texref: *const textureReference,
5539 devPtr: *const ::std::os::raw::c_void,
5540 desc: *const cudaChannelFormatDesc,
5541 size: usize,
5542 ) -> cudaError_t;
5543}
5544extern "C" {
5545 pub fn cudaBindTexture2D(
5546 offset: *mut usize,
5547 texref: *const textureReference,
5548 devPtr: *const ::std::os::raw::c_void,
5549 desc: *const cudaChannelFormatDesc,
5550 width: usize,
5551 height: usize,
5552 pitch: usize,
5553 ) -> cudaError_t;
5554}
5555extern "C" {
5556 pub fn cudaBindTextureToArray(
5557 texref: *const textureReference,
5558 array: cudaArray_const_t,
5559 desc: *const cudaChannelFormatDesc,
5560 ) -> cudaError_t;
5561}
5562extern "C" {
5563 pub fn cudaBindTextureToMipmappedArray(
5564 texref: *const textureReference,
5565 mipmappedArray: cudaMipmappedArray_const_t,
5566 desc: *const cudaChannelFormatDesc,
5567 ) -> cudaError_t;
5568}
5569extern "C" {
5570 pub fn cudaUnbindTexture(texref: *const textureReference) -> cudaError_t;
5571}
5572extern "C" {
5573 pub fn cudaGetTextureAlignmentOffset(
5574 offset: *mut usize,
5575 texref: *const textureReference,
5576 ) -> cudaError_t;
5577}
5578extern "C" {
5579 pub fn cudaGetTextureReference(
5580 texref: *mut *const textureReference,
5581 symbol: *const ::std::os::raw::c_void,
5582 ) -> cudaError_t;
5583}
5584extern "C" {
5585 pub fn cudaBindSurfaceToArray(
5586 surfref: *const surfaceReference,
5587 array: cudaArray_const_t,
5588 desc: *const cudaChannelFormatDesc,
5589 ) -> cudaError_t;
5590}
5591extern "C" {
5592 pub fn cudaGetSurfaceReference(
5593 surfref: *mut *const surfaceReference,
5594 symbol: *const ::std::os::raw::c_void,
5595 ) -> cudaError_t;
5596}
5597extern "C" {
5598 pub fn cudaGetChannelDesc(
5599 desc: *mut cudaChannelFormatDesc,
5600 array: cudaArray_const_t,
5601 ) -> cudaError_t;
5602}
5603extern "C" {
5604 pub fn cudaCreateChannelDesc(
5605 x: ::std::os::raw::c_int,
5606 y: ::std::os::raw::c_int,
5607 z: ::std::os::raw::c_int,
5608 w: ::std::os::raw::c_int,
5609 f: cudaChannelFormatKind,
5610 ) -> cudaChannelFormatDesc;
5611}
5612extern "C" {
5613 pub fn cudaCreateTextureObject(
5614 pTexObject: *mut cudaTextureObject_t,
5615 pResDesc: *const cudaResourceDesc,
5616 pTexDesc: *const cudaTextureDesc,
5617 pResViewDesc: *const cudaResourceViewDesc,
5618 ) -> cudaError_t;
5619}
5620extern "C" {
5621 pub fn cudaDestroyTextureObject(texObject: cudaTextureObject_t) -> cudaError_t;
5622}
5623extern "C" {
5624 pub fn cudaGetTextureObjectResourceDesc(
5625 pResDesc: *mut cudaResourceDesc,
5626 texObject: cudaTextureObject_t,
5627 ) -> cudaError_t;
5628}
5629extern "C" {
5630 pub fn cudaGetTextureObjectTextureDesc(
5631 pTexDesc: *mut cudaTextureDesc,
5632 texObject: cudaTextureObject_t,
5633 ) -> cudaError_t;
5634}
5635extern "C" {
5636 pub fn cudaGetTextureObjectResourceViewDesc(
5637 pResViewDesc: *mut cudaResourceViewDesc,
5638 texObject: cudaTextureObject_t,
5639 ) -> cudaError_t;
5640}
5641extern "C" {
5642 pub fn cudaCreateSurfaceObject(
5643 pSurfObject: *mut cudaSurfaceObject_t,
5644 pResDesc: *const cudaResourceDesc,
5645 ) -> cudaError_t;
5646}
5647extern "C" {
5648 pub fn cudaDestroySurfaceObject(surfObject: cudaSurfaceObject_t) -> cudaError_t;
5649}
5650extern "C" {
5651 pub fn cudaGetSurfaceObjectResourceDesc(
5652 pResDesc: *mut cudaResourceDesc,
5653 surfObject: cudaSurfaceObject_t,
5654 ) -> cudaError_t;
5655}
5656extern "C" {
5657 pub fn cudaDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> cudaError_t;
5658}
5659extern "C" {
5660 pub fn cudaRuntimeGetVersion(runtimeVersion: *mut ::std::os::raw::c_int) -> cudaError_t;
5661}
5662extern "C" {
5663 pub fn cudaGraphCreate(pGraph: *mut cudaGraph_t, flags: ::std::os::raw::c_uint) -> cudaError_t;
5664}
5665extern "C" {
5666 pub fn cudaGraphAddKernelNode(
5667 pGraphNode: *mut cudaGraphNode_t,
5668 graph: cudaGraph_t,
5669 pDependencies: *const cudaGraphNode_t,
5670 numDependencies: usize,
5671 pNodeParams: *const cudaKernelNodeParams,
5672 ) -> cudaError_t;
5673}
5674extern "C" {
5675 pub fn cudaGraphKernelNodeGetParams(
5676 node: cudaGraphNode_t,
5677 pNodeParams: *mut cudaKernelNodeParams,
5678 ) -> cudaError_t;
5679}
5680extern "C" {
5681 pub fn cudaGraphKernelNodeSetParams(
5682 node: cudaGraphNode_t,
5683 pNodeParams: *const cudaKernelNodeParams,
5684 ) -> cudaError_t;
5685}
5686extern "C" {
5687 pub fn cudaGraphAddMemcpyNode(
5688 pGraphNode: *mut cudaGraphNode_t,
5689 graph: cudaGraph_t,
5690 pDependencies: *const cudaGraphNode_t,
5691 numDependencies: usize,
5692 pCopyParams: *const cudaMemcpy3DParms,
5693 ) -> cudaError_t;
5694}
5695extern "C" {
5696 pub fn cudaGraphMemcpyNodeGetParams(
5697 node: cudaGraphNode_t,
5698 pNodeParams: *mut cudaMemcpy3DParms,
5699 ) -> cudaError_t;
5700}
5701extern "C" {
5702 pub fn cudaGraphMemcpyNodeSetParams(
5703 node: cudaGraphNode_t,
5704 pNodeParams: *const cudaMemcpy3DParms,
5705 ) -> cudaError_t;
5706}
5707extern "C" {
5708 pub fn cudaGraphAddMemsetNode(
5709 pGraphNode: *mut cudaGraphNode_t,
5710 graph: cudaGraph_t,
5711 pDependencies: *const cudaGraphNode_t,
5712 numDependencies: usize,
5713 pMemsetParams: *const cudaMemsetParams,
5714 ) -> cudaError_t;
5715}
5716extern "C" {
5717 pub fn cudaGraphMemsetNodeGetParams(
5718 node: cudaGraphNode_t,
5719 pNodeParams: *mut cudaMemsetParams,
5720 ) -> cudaError_t;
5721}
5722extern "C" {
5723 pub fn cudaGraphMemsetNodeSetParams(
5724 node: cudaGraphNode_t,
5725 pNodeParams: *const cudaMemsetParams,
5726 ) -> cudaError_t;
5727}
5728extern "C" {
5729 pub fn cudaGraphAddHostNode(
5730 pGraphNode: *mut cudaGraphNode_t,
5731 graph: cudaGraph_t,
5732 pDependencies: *const cudaGraphNode_t,
5733 numDependencies: usize,
5734 pNodeParams: *const cudaHostNodeParams,
5735 ) -> cudaError_t;
5736}
5737extern "C" {
5738 pub fn cudaGraphHostNodeGetParams(
5739 node: cudaGraphNode_t,
5740 pNodeParams: *mut cudaHostNodeParams,
5741 ) -> cudaError_t;
5742}
5743extern "C" {
5744 pub fn cudaGraphHostNodeSetParams(
5745 node: cudaGraphNode_t,
5746 pNodeParams: *const cudaHostNodeParams,
5747 ) -> cudaError_t;
5748}
5749extern "C" {
5750 pub fn cudaGraphAddChildGraphNode(
5751 pGraphNode: *mut cudaGraphNode_t,
5752 graph: cudaGraph_t,
5753 pDependencies: *const cudaGraphNode_t,
5754 numDependencies: usize,
5755 childGraph: cudaGraph_t,
5756 ) -> cudaError_t;
5757}
5758extern "C" {
5759 pub fn cudaGraphChildGraphNodeGetGraph(
5760 node: cudaGraphNode_t,
5761 pGraph: *mut cudaGraph_t,
5762 ) -> cudaError_t;
5763}
5764extern "C" {
5765 pub fn cudaGraphAddEmptyNode(
5766 pGraphNode: *mut cudaGraphNode_t,
5767 graph: cudaGraph_t,
5768 pDependencies: *const cudaGraphNode_t,
5769 numDependencies: usize,
5770 ) -> cudaError_t;
5771}
5772extern "C" {
5773 pub fn cudaGraphClone(pGraphClone: *mut cudaGraph_t, originalGraph: cudaGraph_t)
5774 -> cudaError_t;
5775}
5776extern "C" {
5777 pub fn cudaGraphNodeFindInClone(
5778 pNode: *mut cudaGraphNode_t,
5779 originalNode: cudaGraphNode_t,
5780 clonedGraph: cudaGraph_t,
5781 ) -> cudaError_t;
5782}
5783extern "C" {
5784 pub fn cudaGraphNodeGetType(
5785 node: cudaGraphNode_t,
5786 pType: *mut cudaGraphNodeType,
5787 ) -> cudaError_t;
5788}
5789extern "C" {
5790 pub fn cudaGraphGetNodes(
5791 graph: cudaGraph_t,
5792 nodes: *mut cudaGraphNode_t,
5793 numNodes: *mut usize,
5794 ) -> cudaError_t;
5795}
5796extern "C" {
5797 pub fn cudaGraphGetRootNodes(
5798 graph: cudaGraph_t,
5799 pRootNodes: *mut cudaGraphNode_t,
5800 pNumRootNodes: *mut usize,
5801 ) -> cudaError_t;
5802}
5803extern "C" {
5804 pub fn cudaGraphGetEdges(
5805 graph: cudaGraph_t,
5806 from: *mut cudaGraphNode_t,
5807 to: *mut cudaGraphNode_t,
5808 numEdges: *mut usize,
5809 ) -> cudaError_t;
5810}
5811extern "C" {
5812 pub fn cudaGraphNodeGetDependencies(
5813 node: cudaGraphNode_t,
5814 pDependencies: *mut cudaGraphNode_t,
5815 pNumDependencies: *mut usize,
5816 ) -> cudaError_t;
5817}
5818extern "C" {
5819 pub fn cudaGraphNodeGetDependentNodes(
5820 node: cudaGraphNode_t,
5821 pDependentNodes: *mut cudaGraphNode_t,
5822 pNumDependentNodes: *mut usize,
5823 ) -> cudaError_t;
5824}
5825extern "C" {
5826 pub fn cudaGraphAddDependencies(
5827 graph: cudaGraph_t,
5828 from: *const cudaGraphNode_t,
5829 to: *const cudaGraphNode_t,
5830 numDependencies: usize,
5831 ) -> cudaError_t;
5832}
5833extern "C" {
5834 pub fn cudaGraphRemoveDependencies(
5835 graph: cudaGraph_t,
5836 from: *const cudaGraphNode_t,
5837 to: *const cudaGraphNode_t,
5838 numDependencies: usize,
5839 ) -> cudaError_t;
5840}
5841extern "C" {
5842 pub fn cudaGraphDestroyNode(node: cudaGraphNode_t) -> cudaError_t;
5843}
5844extern "C" {
5845 pub fn cudaGraphInstantiate(
5846 pGraphExec: *mut cudaGraphExec_t,
5847 graph: cudaGraph_t,
5848 pErrorNode: *mut cudaGraphNode_t,
5849 pLogBuffer: *mut ::std::os::raw::c_char,
5850 bufferSize: usize,
5851 ) -> cudaError_t;
5852}
5853extern "C" {
5854 pub fn cudaGraphExecKernelNodeSetParams(
5855 hGraphExec: cudaGraphExec_t,
5856 node: cudaGraphNode_t,
5857 pNodeParams: *const cudaKernelNodeParams,
5858 ) -> cudaError_t;
5859}
5860extern "C" {
5861 pub fn cudaGraphExecMemcpyNodeSetParams(
5862 hGraphExec: cudaGraphExec_t,
5863 node: cudaGraphNode_t,
5864 pNodeParams: *const cudaMemcpy3DParms,
5865 ) -> cudaError_t;
5866}
5867extern "C" {
5868 pub fn cudaGraphExecMemsetNodeSetParams(
5869 hGraphExec: cudaGraphExec_t,
5870 node: cudaGraphNode_t,
5871 pNodeParams: *const cudaMemsetParams,
5872 ) -> cudaError_t;
5873}
5874extern "C" {
5875 pub fn cudaGraphExecHostNodeSetParams(
5876 hGraphExec: cudaGraphExec_t,
5877 node: cudaGraphNode_t,
5878 pNodeParams: *const cudaHostNodeParams,
5879 ) -> cudaError_t;
5880}
5881extern "C" {
5882 pub fn cudaGraphExecUpdate(
5883 hGraphExec: cudaGraphExec_t,
5884 hGraph: cudaGraph_t,
5885 hErrorNode_out: *mut cudaGraphNode_t,
5886 updateResult_out: *mut cudaGraphExecUpdateResult,
5887 ) -> cudaError_t;
5888}
5889extern "C" {
5890 pub fn cudaGraphLaunch(graphExec: cudaGraphExec_t, stream: cudaStream_t) -> cudaError_t;
5891}
5892extern "C" {
5893 pub fn cudaGraphExecDestroy(graphExec: cudaGraphExec_t) -> cudaError_t;
5894}
5895extern "C" {
5896 pub fn cudaGraphDestroy(graph: cudaGraph_t) -> cudaError_t;
5897}
5898extern "C" {
5899 pub fn cudaGetExportTable(
5900 ppExportTable: *mut *const ::std::os::raw::c_void,
5901 pExportTableId: *const cudaUUID_t,
5902 ) -> cudaError_t;
5903}