1#![allow(non_camel_case_types)]
6#![allow(non_snake_case)]
7#![allow(non_upper_case_globals)]
8
9pub const CUBLAS_VER_MAJOR: u32 = 11;
10pub const CUBLAS_VER_MINOR: u32 = 5;
11pub const CUBLAS_VER_PATCH: u32 = 2;
12pub const CUBLAS_VER_BUILD: u32 = 43;
13pub const CUBLAS_VERSION: u32 = 11502;
14#[repr(C)]
15#[repr(align(8))]
16#[derive(Debug, Copy, Clone)]
17pub struct float2 {
18 pub x: f32,
19 pub y: f32,
20}
21#[test]
22fn bindgen_test_layout_float2() {
23 assert_eq!(
24 ::std::mem::size_of::<float2>(),
25 8usize,
26 concat!("Size of: ", stringify!(float2))
27 );
28 assert_eq!(
29 ::std::mem::align_of::<float2>(),
30 8usize,
31 concat!("Alignment of ", stringify!(float2))
32 );
33 assert_eq!(
34 unsafe { &(*(::std::ptr::null::<float2>())).x as *const _ as usize },
35 0usize,
36 concat!("Offset of field: ", stringify!(float2), "::", stringify!(x))
37 );
38 assert_eq!(
39 unsafe { &(*(::std::ptr::null::<float2>())).y as *const _ as usize },
40 4usize,
41 concat!("Offset of field: ", stringify!(float2), "::", stringify!(y))
42 );
43}
44#[repr(C)]
45#[repr(align(16))]
46#[derive(Debug, Copy, Clone)]
47pub struct double2 {
48 pub x: f64,
49 pub y: f64,
50}
51#[test]
52fn bindgen_test_layout_double2() {
53 assert_eq!(
54 ::std::mem::size_of::<double2>(),
55 16usize,
56 concat!("Size of: ", stringify!(double2))
57 );
58 assert_eq!(
59 ::std::mem::align_of::<double2>(),
60 16usize,
61 concat!("Alignment of ", stringify!(double2))
62 );
63 assert_eq!(
64 unsafe { &(*(::std::ptr::null::<double2>())).x as *const _ as usize },
65 0usize,
66 concat!(
67 "Offset of field: ",
68 stringify!(double2),
69 "::",
70 stringify!(x)
71 )
72 );
73 assert_eq!(
74 unsafe { &(*(::std::ptr::null::<double2>())).y as *const _ as usize },
75 8usize,
76 concat!(
77 "Offset of field: ",
78 stringify!(double2),
79 "::",
80 stringify!(y)
81 )
82 );
83}
84#[doc = " *"]
85#[doc = " *"]
86#[doc = " *"]
87#[repr(C)]
88#[derive(Debug, Copy, Clone)]
89pub struct dim3 {
90 pub x: ::libc::c_uint,
91 pub y: ::libc::c_uint,
92 pub z: ::libc::c_uint,
93}
94#[test]
95fn bindgen_test_layout_dim3() {
96 assert_eq!(
97 ::std::mem::size_of::<dim3>(),
98 12usize,
99 concat!("Size of: ", stringify!(dim3))
100 );
101 assert_eq!(
102 ::std::mem::align_of::<dim3>(),
103 4usize,
104 concat!("Alignment of ", stringify!(dim3))
105 );
106 assert_eq!(
107 unsafe { &(*(::std::ptr::null::<dim3>())).x as *const _ as usize },
108 0usize,
109 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(x))
110 );
111 assert_eq!(
112 unsafe { &(*(::std::ptr::null::<dim3>())).y as *const _ as usize },
113 4usize,
114 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(y))
115 );
116 assert_eq!(
117 unsafe { &(*(::std::ptr::null::<dim3>())).z as *const _ as usize },
118 8usize,
119 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(z))
120 );
121}
122#[repr(u32)]
123#[non_exhaustive]
124#[doc = " CUDA error types"]
125#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
126pub enum cudaError {
127 #[doc = " The API call returned with no errors. In the case of query calls, this"]
128 #[doc = " also means that the operation being queried is complete (see"]
129 #[doc = " ::cudaEventQuery() and ::cudaStreamQuery())."]
130 cudaSuccess = 0,
131 #[doc = " This indicates that one or more of the parameters passed to the API call"]
132 #[doc = " is not within an acceptable range of values."]
133 cudaErrorInvalidValue = 1,
134 #[doc = " The API call failed because it was unable to allocate enough memory to"]
135 #[doc = " perform the requested operation."]
136 cudaErrorMemoryAllocation = 2,
137 #[doc = " The API call failed because the CUDA driver and runtime could not be"]
138 #[doc = " initialized."]
139 cudaErrorInitializationError = 3,
140 #[doc = " This indicates that a CUDA Runtime API call cannot be executed because"]
141 #[doc = " it is being called during process shut down, at a point in time after"]
142 #[doc = " CUDA driver has been unloaded."]
143 cudaErrorCudartUnloading = 4,
144 #[doc = " This indicates profiler is not initialized for this run. This can"]
145 #[doc = " happen when the application is running with external profiling tools"]
146 #[doc = " like visual profiler."]
147 cudaErrorProfilerDisabled = 5,
148 #[doc = " \\deprecated"]
149 #[doc = " This error return is deprecated as of CUDA 5.0. It is no longer an error"]
150 #[doc = " to attempt to enable/disable the profiling via ::cudaProfilerStart or"]
151 #[doc = " ::cudaProfilerStop without initialization."]
152 cudaErrorProfilerNotInitialized = 6,
153 #[doc = " \\deprecated"]
154 #[doc = " This error return is deprecated as of CUDA 5.0. It is no longer an error"]
155 #[doc = " to call cudaProfilerStart() when profiling is already enabled."]
156 cudaErrorProfilerAlreadyStarted = 7,
157 #[doc = " \\deprecated"]
158 #[doc = " This error return is deprecated as of CUDA 5.0. It is no longer an error"]
159 #[doc = " to call cudaProfilerStop() when profiling is already disabled."]
160 cudaErrorProfilerAlreadyStopped = 8,
161 #[doc = " This indicates that a kernel launch is requesting resources that can"]
162 #[doc = " never be satisfied by the current device. Requesting more shared memory"]
163 #[doc = " per block than the device supports will trigger this error, as will"]
164 #[doc = " requesting too many threads or blocks. See ::cudaDeviceProp for more"]
165 #[doc = " device limitations."]
166 cudaErrorInvalidConfiguration = 9,
167 #[doc = " This indicates that one or more of the pitch-related parameters passed"]
168 #[doc = " to the API call is not within the acceptable range for pitch."]
169 cudaErrorInvalidPitchValue = 12,
170 #[doc = " This indicates that the symbol name/identifier passed to the API call"]
171 #[doc = " is not a valid name or identifier."]
172 cudaErrorInvalidSymbol = 13,
173 #[doc = " This indicates that at least one host pointer passed to the API call is"]
174 #[doc = " not a valid host pointer."]
175 #[doc = " \\deprecated"]
176 #[doc = " This error return is deprecated as of CUDA 10.1."]
177 cudaErrorInvalidHostPointer = 16,
178 #[doc = " This indicates that at least one device pointer passed to the API call is"]
179 #[doc = " not a valid device pointer."]
180 #[doc = " \\deprecated"]
181 #[doc = " This error return is deprecated as of CUDA 10.1."]
182 cudaErrorInvalidDevicePointer = 17,
183 #[doc = " This indicates that the texture passed to the API call is not a valid"]
184 #[doc = " texture."]
185 cudaErrorInvalidTexture = 18,
186 #[doc = " This indicates that the texture binding is not valid. This occurs if you"]
187 #[doc = " call ::cudaGetTextureAlignmentOffset() with an unbound texture."]
188 cudaErrorInvalidTextureBinding = 19,
189 #[doc = " This indicates that the channel descriptor passed to the API call is not"]
190 #[doc = " valid. This occurs if the format is not one of the formats specified by"]
191 #[doc = " ::cudaChannelFormatKind, or if one of the dimensions is invalid."]
192 cudaErrorInvalidChannelDescriptor = 20,
193 #[doc = " This indicates that the direction of the memcpy passed to the API call is"]
194 #[doc = " not one of the types specified by ::cudaMemcpyKind."]
195 cudaErrorInvalidMemcpyDirection = 21,
196 #[doc = " This indicated that the user has taken the address of a constant variable,"]
197 #[doc = " which was forbidden up until the CUDA 3.1 release."]
198 #[doc = " \\deprecated"]
199 #[doc = " This error return is deprecated as of CUDA 3.1. Variables in constant"]
200 #[doc = " memory may now have their address taken by the runtime via"]
201 #[doc = " ::cudaGetSymbolAddress()."]
202 cudaErrorAddressOfConstant = 22,
203 #[doc = " This indicated that a texture fetch was not able to be performed."]
204 #[doc = " This was previously used for device emulation of texture operations."]
205 #[doc = " \\deprecated"]
206 #[doc = " This error return is deprecated as of CUDA 3.1. Device emulation mode was"]
207 #[doc = " removed with the CUDA 3.1 release."]
208 cudaErrorTextureFetchFailed = 23,
209 #[doc = " This indicated that a texture was not bound for access."]
210 #[doc = " This was previously used for device emulation of texture operations."]
211 #[doc = " \\deprecated"]
212 #[doc = " This error return is deprecated as of CUDA 3.1. Device emulation mode was"]
213 #[doc = " removed with the CUDA 3.1 release."]
214 cudaErrorTextureNotBound = 24,
215 #[doc = " This indicated that a synchronization operation had failed."]
216 #[doc = " This was previously used for some device emulation functions."]
217 #[doc = " \\deprecated"]
218 #[doc = " This error return is deprecated as of CUDA 3.1. Device emulation mode was"]
219 #[doc = " removed with the CUDA 3.1 release."]
220 cudaErrorSynchronizationError = 25,
221 #[doc = " This indicates that a non-float texture was being accessed with linear"]
222 #[doc = " filtering. This is not supported by CUDA."]
223 cudaErrorInvalidFilterSetting = 26,
224 #[doc = " This indicates that an attempt was made to read a non-float texture as a"]
225 #[doc = " normalized float. This is not supported by CUDA."]
226 cudaErrorInvalidNormSetting = 27,
227 #[doc = " Mixing of device and device emulation code was not allowed."]
228 #[doc = " \\deprecated"]
229 #[doc = " This error return is deprecated as of CUDA 3.1. Device emulation mode was"]
230 #[doc = " removed with the CUDA 3.1 release."]
231 cudaErrorMixedDeviceExecution = 28,
232 #[doc = " This indicates that the API call is not yet implemented. Production"]
233 #[doc = " releases of CUDA will never return this error."]
234 #[doc = " \\deprecated"]
235 #[doc = " This error return is deprecated as of CUDA 4.1."]
236 cudaErrorNotYetImplemented = 31,
237 #[doc = " This indicated that an emulated device pointer exceeded the 32-bit address"]
238 #[doc = " range."]
239 #[doc = " \\deprecated"]
240 #[doc = " This error return is deprecated as of CUDA 3.1. Device emulation mode was"]
241 #[doc = " removed with the CUDA 3.1 release."]
242 cudaErrorMemoryValueTooLarge = 32,
243 #[doc = " This indicates that the CUDA driver that the application has loaded is a"]
244 #[doc = " stub library. Applications that run with the stub rather than a real"]
245 #[doc = " driver loaded will result in CUDA API returning this error."]
246 cudaErrorStubLibrary = 34,
247 #[doc = " This indicates that the installed NVIDIA CUDA driver is older than the"]
248 #[doc = " CUDA runtime library. This is not a supported configuration. Users should"]
249 #[doc = " install an updated NVIDIA display driver to allow the application to run."]
250 cudaErrorInsufficientDriver = 35,
251 #[doc = " This indicates that the API call requires a newer CUDA driver than the one"]
252 #[doc = " currently installed. Users should install an updated NVIDIA CUDA driver"]
253 #[doc = " to allow the API call to succeed."]
254 cudaErrorCallRequiresNewerDriver = 36,
255 #[doc = " This indicates that the surface passed to the API call is not a valid"]
256 #[doc = " surface."]
257 cudaErrorInvalidSurface = 37,
258 #[doc = " This indicates that multiple global or constant variables (across separate"]
259 #[doc = " CUDA source files in the application) share the same string name."]
260 cudaErrorDuplicateVariableName = 43,
261 #[doc = " This indicates that multiple textures (across separate CUDA source"]
262 #[doc = " files in the application) share the same string name."]
263 cudaErrorDuplicateTextureName = 44,
264 #[doc = " This indicates that multiple surfaces (across separate CUDA source"]
265 #[doc = " files in the application) share the same string name."]
266 cudaErrorDuplicateSurfaceName = 45,
267 #[doc = " This indicates that all CUDA devices are busy or unavailable at the current"]
268 #[doc = " time. Devices are often busy/unavailable due to use of"]
269 #[doc = " ::cudaComputeModeExclusive, ::cudaComputeModeProhibited or when long"]
270 #[doc = " running CUDA kernels have filled up the GPU and are blocking new work"]
271 #[doc = " from starting. They can also be unavailable due to memory constraints"]
272 #[doc = " on a device that already has active CUDA work being performed."]
273 cudaErrorDevicesUnavailable = 46,
274 #[doc = " This indicates that the current context is not compatible with this"]
275 #[doc = " the CUDA Runtime. This can only occur if you are using CUDA"]
276 #[doc = " Runtime/Driver interoperability and have created an existing Driver"]
277 #[doc = " context using the driver API. The Driver context may be incompatible"]
278 #[doc = " either because the Driver context was created using an older version"]
279 #[doc = " of the API, because the Runtime API call expects a primary driver"]
280 #[doc = " context and the Driver context is not primary, or because the Driver"]
281 #[doc = " context has been destroyed. Please see \\ref CUDART_DRIVER \"Interactions"]
282 #[doc = " with the CUDA Driver API\" for more information."]
283 cudaErrorIncompatibleDriverContext = 49,
284 #[doc = " The device function being invoked (usually via ::cudaLaunchKernel()) was not"]
285 #[doc = " previously configured via the ::cudaConfigureCall() function."]
286 cudaErrorMissingConfiguration = 52,
287 #[doc = " This indicated that a previous kernel launch failed. This was previously"]
288 #[doc = " used for device emulation of kernel launches."]
289 #[doc = " \\deprecated"]
290 #[doc = " This error return is deprecated as of CUDA 3.1. Device emulation mode was"]
291 #[doc = " removed with the CUDA 3.1 release."]
292 cudaErrorPriorLaunchFailure = 53,
293 #[doc = " This error indicates that a device runtime grid launch did not occur"]
294 #[doc = " because the depth of the child grid would exceed the maximum supported"]
295 #[doc = " number of nested grid launches."]
296 cudaErrorLaunchMaxDepthExceeded = 65,
297 #[doc = " This error indicates that a grid launch did not occur because the kernel"]
298 #[doc = " uses file-scoped textures which are unsupported by the device runtime."]
299 #[doc = " Kernels launched via the device runtime only support textures created with"]
300 #[doc = " the Texture Object API's."]
301 cudaErrorLaunchFileScopedTex = 66,
302 #[doc = " This error indicates that a grid launch did not occur because the kernel"]
303 #[doc = " uses file-scoped surfaces which are unsupported by the device runtime."]
304 #[doc = " Kernels launched via the device runtime only support surfaces created with"]
305 #[doc = " the Surface Object API's."]
306 cudaErrorLaunchFileScopedSurf = 67,
307 #[doc = " This error indicates that a call to ::cudaDeviceSynchronize made from"]
308 #[doc = " the device runtime failed because the call was made at grid depth greater"]
309 #[doc = " than than either the default (2 levels of grids) or user specified device"]
310 #[doc = " limit ::cudaLimitDevRuntimeSyncDepth. To be able to synchronize on"]
311 #[doc = " launched grids at a greater depth successfully, the maximum nested"]
312 #[doc = " depth at which ::cudaDeviceSynchronize will be called must be specified"]
313 #[doc = " with the ::cudaLimitDevRuntimeSyncDepth limit to the ::cudaDeviceSetLimit"]
314 #[doc = " api before the host-side launch of a kernel using the device runtime."]
315 #[doc = " Keep in mind that additional levels of sync depth require the runtime"]
316 #[doc = " to reserve large amounts of device memory that cannot be used for"]
317 #[doc = " user allocations."]
318 cudaErrorSyncDepthExceeded = 68,
319 #[doc = " This error indicates that a device runtime grid launch failed because"]
320 #[doc = " the launch would exceed the limit ::cudaLimitDevRuntimePendingLaunchCount."]
321 #[doc = " For this launch to proceed successfully, ::cudaDeviceSetLimit must be"]
322 #[doc = " called to set the ::cudaLimitDevRuntimePendingLaunchCount to be higher"]
323 #[doc = " than the upper bound of outstanding launches that can be issued to the"]
324 #[doc = " device runtime. Keep in mind that raising the limit of pending device"]
325 #[doc = " runtime launches will require the runtime to reserve device memory that"]
326 #[doc = " cannot be used for user allocations."]
327 cudaErrorLaunchPendingCountExceeded = 69,
328 #[doc = " The requested device function does not exist or is not compiled for the"]
329 #[doc = " proper device architecture."]
330 cudaErrorInvalidDeviceFunction = 98,
331 #[doc = " This indicates that no CUDA-capable devices were detected by the installed"]
332 #[doc = " CUDA driver."]
333 cudaErrorNoDevice = 100,
334 #[doc = " This indicates that the device ordinal supplied by the user does not"]
335 #[doc = " correspond to a valid CUDA device or that the action requested is"]
336 #[doc = " invalid for the specified device."]
337 cudaErrorInvalidDevice = 101,
338 #[doc = " This indicates that the device doesn't have a valid Grid License."]
339 cudaErrorDeviceNotLicensed = 102,
340 #[doc = " By default, the CUDA runtime may perform a minimal set of self-tests,"]
341 #[doc = " as well as CUDA driver tests, to establish the validity of both."]
342 #[doc = " Introduced in CUDA 11.2, this error return indicates that at least one"]
343 #[doc = " of these tests has failed and the validity of either the runtime"]
344 #[doc = " or the driver could not be established."]
345 cudaErrorSoftwareValidityNotEstablished = 103,
346 #[doc = " This indicates an internal startup failure in the CUDA runtime."]
347 cudaErrorStartupFailure = 127,
348 #[doc = " This indicates that the device kernel image is invalid."]
349 cudaErrorInvalidKernelImage = 200,
350 #[doc = " This most frequently indicates that there is no context bound to the"]
351 #[doc = " current thread. This can also be returned if the context passed to an"]
352 #[doc = " API call is not a valid handle (such as a context that has had"]
353 #[doc = " ::cuCtxDestroy() invoked on it). This can also be returned if a user"]
354 #[doc = " mixes different API versions (i.e. 3010 context with 3020 API calls)."]
355 #[doc = " See ::cuCtxGetApiVersion() for more details."]
356 cudaErrorDeviceUninitialized = 201,
357 #[doc = " This indicates that the buffer object could not be mapped."]
358 cudaErrorMapBufferObjectFailed = 205,
359 #[doc = " This indicates that the buffer object could not be unmapped."]
360 cudaErrorUnmapBufferObjectFailed = 206,
361 #[doc = " This indicates that the specified array is currently mapped and thus"]
362 #[doc = " cannot be destroyed."]
363 cudaErrorArrayIsMapped = 207,
364 #[doc = " This indicates that the resource is already mapped."]
365 cudaErrorAlreadyMapped = 208,
366 #[doc = " This indicates that there is no kernel image available that is suitable"]
367 #[doc = " for the device. This can occur when a user specifies code generation"]
368 #[doc = " options for a particular CUDA source file that do not include the"]
369 #[doc = " corresponding device configuration."]
370 cudaErrorNoKernelImageForDevice = 209,
371 #[doc = " This indicates that a resource has already been acquired."]
372 cudaErrorAlreadyAcquired = 210,
373 #[doc = " This indicates that a resource is not mapped."]
374 cudaErrorNotMapped = 211,
375 #[doc = " This indicates that a mapped resource is not available for access as an"]
376 #[doc = " array."]
377 cudaErrorNotMappedAsArray = 212,
378 #[doc = " This indicates that a mapped resource is not available for access as a"]
379 #[doc = " pointer."]
380 cudaErrorNotMappedAsPointer = 213,
381 #[doc = " This indicates that an uncorrectable ECC error was detected during"]
382 #[doc = " execution."]
383 cudaErrorECCUncorrectable = 214,
384 #[doc = " This indicates that the ::cudaLimit passed to the API call is not"]
385 #[doc = " supported by the active device."]
386 cudaErrorUnsupportedLimit = 215,
387 #[doc = " This indicates that a call tried to access an exclusive-thread device that"]
388 #[doc = " is already in use by a different thread."]
389 cudaErrorDeviceAlreadyInUse = 216,
390 #[doc = " This error indicates that P2P access is not supported across the given"]
391 #[doc = " devices."]
392 cudaErrorPeerAccessUnsupported = 217,
393 #[doc = " A PTX compilation failed. The runtime may fall back to compiling PTX if"]
394 #[doc = " an application does not contain a suitable binary for the current device."]
395 cudaErrorInvalidPtx = 218,
396 #[doc = " This indicates an error with the OpenGL or DirectX context."]
397 cudaErrorInvalidGraphicsContext = 219,
398 #[doc = " This indicates that an uncorrectable NVLink error was detected during the"]
399 #[doc = " execution."]
400 cudaErrorNvlinkUncorrectable = 220,
401 #[doc = " This indicates that the PTX JIT compiler library was not found. The JIT Compiler"]
402 #[doc = " library is used for PTX compilation. The runtime may fall back to compiling PTX"]
403 #[doc = " if an application does not contain a suitable binary for the current device."]
404 cudaErrorJitCompilerNotFound = 221,
405 #[doc = " This indicates that the provided PTX was compiled with an unsupported toolchain."]
406 #[doc = " The most common reason for this, is the PTX was generated by a compiler newer"]
407 #[doc = " than what is supported by the CUDA driver and PTX JIT compiler."]
408 cudaErrorUnsupportedPtxVersion = 222,
409 #[doc = " This indicates that the JIT compilation was disabled. The JIT compilation compiles"]
410 #[doc = " PTX. The runtime may fall back to compiling PTX if an application does not contain"]
411 #[doc = " a suitable binary for the current device."]
412 cudaErrorJitCompilationDisabled = 223,
413 #[doc = " This indicates that the provided execution affinity is not supported by the device."]
414 cudaErrorUnsupportedExecAffinity = 224,
415 #[doc = " This indicates that the device kernel source is invalid."]
416 cudaErrorInvalidSource = 300,
417 #[doc = " This indicates that the file specified was not found."]
418 cudaErrorFileNotFound = 301,
419 #[doc = " This indicates that a link to a shared object failed to resolve."]
420 cudaErrorSharedObjectSymbolNotFound = 302,
421 #[doc = " This indicates that initialization of a shared object failed."]
422 cudaErrorSharedObjectInitFailed = 303,
423 #[doc = " This error indicates that an OS call failed."]
424 cudaErrorOperatingSystem = 304,
425 #[doc = " This indicates that a resource handle passed to the API call was not"]
426 #[doc = " valid. Resource handles are opaque types like ::cudaStream_t and"]
427 #[doc = " ::cudaEvent_t."]
428 cudaErrorInvalidResourceHandle = 400,
429 #[doc = " This indicates that a resource required by the API call is not in a"]
430 #[doc = " valid state to perform the requested operation."]
431 cudaErrorIllegalState = 401,
432 #[doc = " This indicates that a named symbol was not found. Examples of symbols"]
433 #[doc = " are global/constant variable names, driver function names, texture names,"]
434 #[doc = " and surface names."]
435 cudaErrorSymbolNotFound = 500,
436 #[doc = " This indicates that asynchronous operations issued previously have not"]
437 #[doc = " completed yet. This result is not actually an error, but must be indicated"]
438 #[doc = " differently than ::cudaSuccess (which indicates completion). Calls that"]
439 #[doc = " may return this value include ::cudaEventQuery() and ::cudaStreamQuery()."]
440 cudaErrorNotReady = 600,
441 #[doc = " The device encountered a load or store instruction on an invalid memory address."]
442 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
443 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
444 #[doc = " and relaunched."]
445 cudaErrorIllegalAddress = 700,
446 #[doc = " This indicates that a launch did not occur because it did not have"]
447 #[doc = " appropriate resources. Although this error is similar to"]
448 #[doc = " ::cudaErrorInvalidConfiguration, this error usually indicates that the"]
449 #[doc = " user has attempted to pass too many arguments to the device kernel, or the"]
450 #[doc = " kernel launch specifies too many threads for the kernel's register count."]
451 cudaErrorLaunchOutOfResources = 701,
452 #[doc = " This indicates that the device kernel took too long to execute. This can"]
453 #[doc = " only occur if timeouts are enabled - see the device property"]
454 #[doc = " \\ref ::cudaDeviceProp::kernelExecTimeoutEnabled \"kernelExecTimeoutEnabled\""]
455 #[doc = " for more information."]
456 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
457 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
458 #[doc = " and relaunched."]
459 cudaErrorLaunchTimeout = 702,
460 #[doc = " This error indicates a kernel launch that uses an incompatible texturing"]
461 #[doc = " mode."]
462 cudaErrorLaunchIncompatibleTexturing = 703,
463 #[doc = " This error indicates that a call to ::cudaDeviceEnablePeerAccess() is"]
464 #[doc = " trying to re-enable peer addressing on from a context which has already"]
465 #[doc = " had peer addressing enabled."]
466 cudaErrorPeerAccessAlreadyEnabled = 704,
467 #[doc = " This error indicates that ::cudaDeviceDisablePeerAccess() is trying to"]
468 #[doc = " disable peer addressing which has not been enabled yet via"]
469 #[doc = " ::cudaDeviceEnablePeerAccess()."]
470 cudaErrorPeerAccessNotEnabled = 705,
471 #[doc = " This indicates that the user has called ::cudaSetValidDevices(),"]
472 #[doc = " ::cudaSetDeviceFlags(), ::cudaD3D9SetDirect3DDevice(),"]
473 #[doc = " ::cudaD3D10SetDirect3DDevice, ::cudaD3D11SetDirect3DDevice(), or"]
474 #[doc = " ::cudaVDPAUSetVDPAUDevice() after initializing the CUDA runtime by"]
475 #[doc = " calling non-device management operations (allocating memory and"]
476 #[doc = " launching kernels are examples of non-device management operations)."]
477 #[doc = " This error can also be returned if using runtime/driver"]
478 #[doc = " interoperability and there is an existing ::CUcontext active on the"]
479 #[doc = " host thread."]
480 cudaErrorSetOnActiveProcess = 708,
481 #[doc = " This error indicates that the context current to the calling thread"]
482 #[doc = " has been destroyed using ::cuCtxDestroy, or is a primary context which"]
483 #[doc = " has not yet been initialized."]
484 cudaErrorContextIsDestroyed = 709,
485 #[doc = " An assert triggered in device code during kernel execution. The device"]
486 #[doc = " cannot be used again. All existing allocations are invalid. To continue"]
487 #[doc = " using CUDA, the process must be terminated and relaunched."]
488 cudaErrorAssert = 710,
489 #[doc = " This error indicates that the hardware resources required to enable"]
490 #[doc = " peer access have been exhausted for one or more of the devices"]
491 #[doc = " passed to ::cudaEnablePeerAccess()."]
492 cudaErrorTooManyPeers = 711,
493 #[doc = " This error indicates that the memory range passed to ::cudaHostRegister()"]
494 #[doc = " has already been registered."]
495 cudaErrorHostMemoryAlreadyRegistered = 712,
496 #[doc = " This error indicates that the pointer passed to ::cudaHostUnregister()"]
497 #[doc = " does not correspond to any currently registered memory region."]
498 cudaErrorHostMemoryNotRegistered = 713,
499 #[doc = " Device encountered an error in the call stack during kernel execution,"]
500 #[doc = " possibly due to stack corruption or exceeding the stack size limit."]
501 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
502 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
503 #[doc = " and relaunched."]
504 cudaErrorHardwareStackError = 714,
505 #[doc = " The device encountered an illegal instruction during kernel execution"]
506 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
507 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
508 #[doc = " and relaunched."]
509 cudaErrorIllegalInstruction = 715,
510 #[doc = " The device encountered a load or store instruction"]
511 #[doc = " on a memory address which is not aligned."]
512 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
513 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
514 #[doc = " and relaunched."]
515 cudaErrorMisalignedAddress = 716,
516 #[doc = " While executing a kernel, the device encountered an instruction"]
517 #[doc = " which can only operate on memory locations in certain address spaces"]
518 #[doc = " (global, shared, or local), but was supplied a memory address not"]
519 #[doc = " belonging to an allowed address space."]
520 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
521 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
522 #[doc = " and relaunched."]
523 cudaErrorInvalidAddressSpace = 717,
524 #[doc = " The device encountered an invalid program counter."]
525 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
526 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
527 #[doc = " and relaunched."]
528 cudaErrorInvalidPc = 718,
529 #[doc = " An exception occurred on the device while executing a kernel. Common"]
530 #[doc = " causes include dereferencing an invalid device pointer and accessing"]
531 #[doc = " out of bounds shared memory. Less common cases can be system specific - more"]
532 #[doc = " information about these cases can be found in the system specific user guide."]
533 #[doc = " This leaves the process in an inconsistent state and any further CUDA work"]
534 #[doc = " will return the same error. To continue using CUDA, the process must be terminated"]
535 #[doc = " and relaunched."]
536 cudaErrorLaunchFailure = 719,
537 #[doc = " This error indicates that the number of blocks launched per grid for a kernel that was"]
538 #[doc = " launched via either ::cudaLaunchCooperativeKernel or ::cudaLaunchCooperativeKernelMultiDevice"]
539 #[doc = " exceeds the maximum number of blocks as allowed by ::cudaOccupancyMaxActiveBlocksPerMultiprocessor"]
540 #[doc = " or ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags times the number of multiprocessors"]
541 #[doc = " as specified by the device attribute ::cudaDevAttrMultiProcessorCount."]
542 cudaErrorCooperativeLaunchTooLarge = 720,
543 #[doc = " This error indicates the attempted operation is not permitted."]
544 cudaErrorNotPermitted = 800,
545 #[doc = " This error indicates the attempted operation is not supported"]
546 #[doc = " on the current system or device."]
547 cudaErrorNotSupported = 801,
548 #[doc = " This error indicates that the system is not yet ready to start any CUDA"]
549 #[doc = " work. To continue using CUDA, verify the system configuration is in a"]
550 #[doc = " valid state and all required driver daemons are actively running."]
551 #[doc = " More information about this error can be found in the system specific"]
552 #[doc = " user guide."]
553 cudaErrorSystemNotReady = 802,
554 #[doc = " This error indicates that there is a mismatch between the versions of"]
555 #[doc = " the display driver and the CUDA driver. Refer to the compatibility documentation"]
556 #[doc = " for supported versions."]
557 cudaErrorSystemDriverMismatch = 803,
558 #[doc = " This error indicates that the system was upgraded to run with forward compatibility"]
559 #[doc = " but the visible hardware detected by CUDA does not support this configuration."]
560 #[doc = " Refer to the compatibility documentation for the supported hardware matrix or ensure"]
561 #[doc = " that only supported hardware is visible during initialization via the CUDA_VISIBLE_DEVICES"]
562 #[doc = " environment variable."]
563 cudaErrorCompatNotSupportedOnDevice = 804,
564 #[doc = " This error indicates that the MPS client failed to connect to the MPS control daemon or the MPS server."]
565 cudaErrorMpsConnectionFailed = 805,
566 #[doc = " This error indicates that the remote procedural call between the MPS server and the MPS client failed."]
567 cudaErrorMpsRpcFailure = 806,
568 #[doc = " This error indicates that the MPS server is not ready to accept new MPS client requests."]
569 #[doc = " This error can be returned when the MPS server is in the process of recovering from a fatal failure."]
570 cudaErrorMpsServerNotReady = 807,
571 #[doc = " This error indicates that the hardware resources required to create MPS client have been exhausted."]
572 cudaErrorMpsMaxClientsReached = 808,
573 #[doc = " This error indicates the the hardware resources required to device connections have been exhausted."]
574 cudaErrorMpsMaxConnectionsReached = 809,
575 #[doc = " The operation is not permitted when the stream is capturing."]
576 cudaErrorStreamCaptureUnsupported = 900,
577 #[doc = " The current capture sequence on the stream has been invalidated due to"]
578 #[doc = " a previous error."]
579 cudaErrorStreamCaptureInvalidated = 901,
580 #[doc = " The operation would have resulted in a merge of two independent capture"]
581 #[doc = " sequences."]
582 cudaErrorStreamCaptureMerge = 902,
583 #[doc = " The capture was not initiated in this stream."]
584 cudaErrorStreamCaptureUnmatched = 903,
585 #[doc = " The capture sequence contains a fork that was not joined to the primary"]
586 #[doc = " stream."]
587 cudaErrorStreamCaptureUnjoined = 904,
588 #[doc = " A dependency would have been created which crosses the capture sequence"]
589 #[doc = " boundary. Only implicit in-stream ordering dependencies are allowed to"]
590 #[doc = " cross the boundary."]
591 cudaErrorStreamCaptureIsolation = 905,
592 #[doc = " The operation would have resulted in a disallowed implicit dependency on"]
593 #[doc = " a current capture sequence from cudaStreamLegacy."]
594 cudaErrorStreamCaptureImplicit = 906,
595 #[doc = " The operation is not permitted on an event which was last recorded in a"]
596 #[doc = " capturing stream."]
597 cudaErrorCapturedEvent = 907,
598 #[doc = " A stream capture sequence not initiated with the ::cudaStreamCaptureModeRelaxed"]
599 #[doc = " argument to ::cudaStreamBeginCapture was passed to ::cudaStreamEndCapture in a"]
600 #[doc = " different thread."]
601 cudaErrorStreamCaptureWrongThread = 908,
602 #[doc = " This indicates that the wait operation has timed out."]
603 cudaErrorTimeout = 909,
604 #[doc = " This error indicates that the graph update was not performed because it included"]
605 #[doc = " changes which violated constraints specific to instantiated graph update."]
606 cudaErrorGraphExecUpdateFailure = 910,
607 #[doc = " This indicates that an unknown internal error has occurred."]
608 cudaErrorUnknown = 999,
609 #[doc = " Any unhandled CUDA driver error is added to this value and returned via"]
610 #[doc = " the runtime. Production releases of CUDA should not return such errors."]
611 #[doc = " \\deprecated"]
612 #[doc = " This error return is deprecated as of CUDA 4.1."]
613 cudaErrorApiFailureBase = 10000,
614}
615#[repr(u32)]
616#[non_exhaustive]
617#[doc = " Channel format kind"]
618#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
619pub enum cudaChannelFormatKind {
620 #[doc = "< Signed channel format"]
621 cudaChannelFormatKindSigned = 0,
622 #[doc = "< Unsigned channel format"]
623 cudaChannelFormatKindUnsigned = 1,
624 #[doc = "< Float channel format"]
625 cudaChannelFormatKindFloat = 2,
626 #[doc = "< No channel format"]
627 cudaChannelFormatKindNone = 3,
628 cudaChannelFormatKindNV12 = 4,
629}
630#[doc = " CUDA Channel format descriptor"]
631#[repr(C)]
632#[derive(Debug, Copy, Clone)]
633pub struct cudaChannelFormatDesc {
634 #[doc = "< x"]
635 pub x: ::libc::c_int,
636 #[doc = "< y"]
637 pub y: ::libc::c_int,
638 #[doc = "< z"]
639 pub z: ::libc::c_int,
640 #[doc = "< w"]
641 pub w: ::libc::c_int,
642 #[doc = "< Channel format kind"]
643 pub f: cudaChannelFormatKind,
644}
645#[test]
646fn bindgen_test_layout_cudaChannelFormatDesc() {
647 assert_eq!(
648 ::std::mem::size_of::<cudaChannelFormatDesc>(),
649 20usize,
650 concat!("Size of: ", stringify!(cudaChannelFormatDesc))
651 );
652 assert_eq!(
653 ::std::mem::align_of::<cudaChannelFormatDesc>(),
654 4usize,
655 concat!("Alignment of ", stringify!(cudaChannelFormatDesc))
656 );
657 assert_eq!(
658 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).x as *const _ as usize },
659 0usize,
660 concat!(
661 "Offset of field: ",
662 stringify!(cudaChannelFormatDesc),
663 "::",
664 stringify!(x)
665 )
666 );
667 assert_eq!(
668 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).y as *const _ as usize },
669 4usize,
670 concat!(
671 "Offset of field: ",
672 stringify!(cudaChannelFormatDesc),
673 "::",
674 stringify!(y)
675 )
676 );
677 assert_eq!(
678 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).z as *const _ as usize },
679 8usize,
680 concat!(
681 "Offset of field: ",
682 stringify!(cudaChannelFormatDesc),
683 "::",
684 stringify!(z)
685 )
686 );
687 assert_eq!(
688 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).w as *const _ as usize },
689 12usize,
690 concat!(
691 "Offset of field: ",
692 stringify!(cudaChannelFormatDesc),
693 "::",
694 stringify!(w)
695 )
696 );
697 assert_eq!(
698 unsafe { &(*(::std::ptr::null::<cudaChannelFormatDesc>())).f as *const _ as usize },
699 16usize,
700 concat!(
701 "Offset of field: ",
702 stringify!(cudaChannelFormatDesc),
703 "::",
704 stringify!(f)
705 )
706 );
707}
708#[repr(C)]
709#[derive(Debug, Copy, Clone)]
710pub struct cudaArray {
711 _unused: [u8; 0],
712}
713#[doc = " CUDA array"]
714pub type cudaArray_t = *mut cudaArray;
715#[doc = " CUDA array (as source copy argument)"]
716pub type cudaArray_const_t = *const cudaArray;
717#[repr(C)]
718#[derive(Debug, Copy, Clone)]
719pub struct cudaMipmappedArray {
720 _unused: [u8; 0],
721}
722#[doc = " CUDA mipmapped array"]
723pub type cudaMipmappedArray_t = *mut cudaMipmappedArray;
724#[doc = " CUDA mipmapped array (as source argument)"]
725pub type cudaMipmappedArray_const_t = *const cudaMipmappedArray;
726#[doc = " Sparse CUDA array and CUDA mipmapped array properties"]
727#[repr(C)]
728#[derive(Debug, Copy, Clone)]
729pub struct cudaArraySparseProperties {
730 pub tileExtent: cudaArraySparseProperties__bindgen_ty_1,
731 #[doc = "< First mip level at which the mip tail begins"]
732 pub miptailFirstLevel: ::libc::c_uint,
733 #[doc = "< Total size of the mip tail."]
734 pub miptailSize: ::libc::c_ulonglong,
735 #[doc = "< Flags will either be zero or ::cudaArraySparsePropertiesSingleMipTail"]
736 pub flags: ::libc::c_uint,
737 pub reserved: [::libc::c_uint; 4usize],
738}
739#[repr(C)]
740#[derive(Debug, Copy, Clone)]
741pub struct cudaArraySparseProperties__bindgen_ty_1 {
742 #[doc = "< Tile width in elements"]
743 pub width: ::libc::c_uint,
744 #[doc = "< Tile height in elements"]
745 pub height: ::libc::c_uint,
746 #[doc = "< Tile depth in elements"]
747 pub depth: ::libc::c_uint,
748}
749#[test]
750fn bindgen_test_layout_cudaArraySparseProperties__bindgen_ty_1() {
751 assert_eq!(
752 ::std::mem::size_of::<cudaArraySparseProperties__bindgen_ty_1>(),
753 12usize,
754 concat!(
755 "Size of: ",
756 stringify!(cudaArraySparseProperties__bindgen_ty_1)
757 )
758 );
759 assert_eq!(
760 ::std::mem::align_of::<cudaArraySparseProperties__bindgen_ty_1>(),
761 4usize,
762 concat!(
763 "Alignment of ",
764 stringify!(cudaArraySparseProperties__bindgen_ty_1)
765 )
766 );
767 assert_eq!(
768 unsafe {
769 &(*(::std::ptr::null::<cudaArraySparseProperties__bindgen_ty_1>())).width as *const _
770 as usize
771 },
772 0usize,
773 concat!(
774 "Offset of field: ",
775 stringify!(cudaArraySparseProperties__bindgen_ty_1),
776 "::",
777 stringify!(width)
778 )
779 );
780 assert_eq!(
781 unsafe {
782 &(*(::std::ptr::null::<cudaArraySparseProperties__bindgen_ty_1>())).height as *const _
783 as usize
784 },
785 4usize,
786 concat!(
787 "Offset of field: ",
788 stringify!(cudaArraySparseProperties__bindgen_ty_1),
789 "::",
790 stringify!(height)
791 )
792 );
793 assert_eq!(
794 unsafe {
795 &(*(::std::ptr::null::<cudaArraySparseProperties__bindgen_ty_1>())).depth as *const _
796 as usize
797 },
798 8usize,
799 concat!(
800 "Offset of field: ",
801 stringify!(cudaArraySparseProperties__bindgen_ty_1),
802 "::",
803 stringify!(depth)
804 )
805 );
806}
807#[test]
808fn bindgen_test_layout_cudaArraySparseProperties() {
809 assert_eq!(
810 ::std::mem::size_of::<cudaArraySparseProperties>(),
811 48usize,
812 concat!("Size of: ", stringify!(cudaArraySparseProperties))
813 );
814 assert_eq!(
815 ::std::mem::align_of::<cudaArraySparseProperties>(),
816 8usize,
817 concat!("Alignment of ", stringify!(cudaArraySparseProperties))
818 );
819 assert_eq!(
820 unsafe {
821 &(*(::std::ptr::null::<cudaArraySparseProperties>())).tileExtent as *const _ as usize
822 },
823 0usize,
824 concat!(
825 "Offset of field: ",
826 stringify!(cudaArraySparseProperties),
827 "::",
828 stringify!(tileExtent)
829 )
830 );
831 assert_eq!(
832 unsafe {
833 &(*(::std::ptr::null::<cudaArraySparseProperties>())).miptailFirstLevel as *const _
834 as usize
835 },
836 12usize,
837 concat!(
838 "Offset of field: ",
839 stringify!(cudaArraySparseProperties),
840 "::",
841 stringify!(miptailFirstLevel)
842 )
843 );
844 assert_eq!(
845 unsafe {
846 &(*(::std::ptr::null::<cudaArraySparseProperties>())).miptailSize as *const _ as usize
847 },
848 16usize,
849 concat!(
850 "Offset of field: ",
851 stringify!(cudaArraySparseProperties),
852 "::",
853 stringify!(miptailSize)
854 )
855 );
856 assert_eq!(
857 unsafe { &(*(::std::ptr::null::<cudaArraySparseProperties>())).flags as *const _ as usize },
858 24usize,
859 concat!(
860 "Offset of field: ",
861 stringify!(cudaArraySparseProperties),
862 "::",
863 stringify!(flags)
864 )
865 );
866 assert_eq!(
867 unsafe {
868 &(*(::std::ptr::null::<cudaArraySparseProperties>())).reserved as *const _ as usize
869 },
870 28usize,
871 concat!(
872 "Offset of field: ",
873 stringify!(cudaArraySparseProperties),
874 "::",
875 stringify!(reserved)
876 )
877 );
878}
879#[repr(u32)]
880#[non_exhaustive]
881#[doc = " CUDA memory types"]
882#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
883pub enum cudaMemoryType {
884 #[doc = "< Unregistered memory"]
885 cudaMemoryTypeUnregistered = 0,
886 #[doc = "< Host memory"]
887 cudaMemoryTypeHost = 1,
888 #[doc = "< Device memory"]
889 cudaMemoryTypeDevice = 2,
890 #[doc = "< Managed memory"]
891 cudaMemoryTypeManaged = 3,
892}
893#[repr(u32)]
894#[non_exhaustive]
895#[doc = " CUDA memory copy types"]
896#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
897pub enum cudaMemcpyKind {
898 #[doc = "< Host -> Host"]
899 cudaMemcpyHostToHost = 0,
900 #[doc = "< Host -> Device"]
901 cudaMemcpyHostToDevice = 1,
902 #[doc = "< Device -> Host"]
903 cudaMemcpyDeviceToHost = 2,
904 #[doc = "< Device -> Device"]
905 cudaMemcpyDeviceToDevice = 3,
906 #[doc = "< Direction of the transfer is inferred from the pointer values. Requires unified virtual addressing"]
907 cudaMemcpyDefault = 4,
908}
909#[doc = " CUDA Pitched memory pointer"]
910#[doc = ""]
911#[doc = " \\sa ::make_cudaPitchedPtr"]
912#[repr(C)]
913#[derive(Debug, Copy, Clone)]
914pub struct cudaPitchedPtr {
915 #[doc = "< Pointer to allocated memory"]
916 pub ptr: *mut ::libc::c_void,
917 #[doc = "< Pitch of allocated memory in bytes"]
918 pub pitch: usize,
919 #[doc = "< Logical width of allocation in elements"]
920 pub xsize: usize,
921 #[doc = "< Logical height of allocation in elements"]
922 pub ysize: usize,
923}
924#[test]
925fn bindgen_test_layout_cudaPitchedPtr() {
926 assert_eq!(
927 ::std::mem::size_of::<cudaPitchedPtr>(),
928 32usize,
929 concat!("Size of: ", stringify!(cudaPitchedPtr))
930 );
931 assert_eq!(
932 ::std::mem::align_of::<cudaPitchedPtr>(),
933 8usize,
934 concat!("Alignment of ", stringify!(cudaPitchedPtr))
935 );
936 assert_eq!(
937 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).ptr as *const _ as usize },
938 0usize,
939 concat!(
940 "Offset of field: ",
941 stringify!(cudaPitchedPtr),
942 "::",
943 stringify!(ptr)
944 )
945 );
946 assert_eq!(
947 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).pitch as *const _ as usize },
948 8usize,
949 concat!(
950 "Offset of field: ",
951 stringify!(cudaPitchedPtr),
952 "::",
953 stringify!(pitch)
954 )
955 );
956 assert_eq!(
957 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).xsize as *const _ as usize },
958 16usize,
959 concat!(
960 "Offset of field: ",
961 stringify!(cudaPitchedPtr),
962 "::",
963 stringify!(xsize)
964 )
965 );
966 assert_eq!(
967 unsafe { &(*(::std::ptr::null::<cudaPitchedPtr>())).ysize as *const _ as usize },
968 24usize,
969 concat!(
970 "Offset of field: ",
971 stringify!(cudaPitchedPtr),
972 "::",
973 stringify!(ysize)
974 )
975 );
976}
977#[doc = " CUDA extent"]
978#[doc = ""]
979#[doc = " \\sa ::make_cudaExtent"]
980#[repr(C)]
981#[derive(Debug, Copy, Clone)]
982pub struct cudaExtent {
983 #[doc = "< Width in elements when referring to array memory, in bytes when referring to linear memory"]
984 pub width: usize,
985 #[doc = "< Height in elements"]
986 pub height: usize,
987 #[doc = "< Depth in elements"]
988 pub depth: usize,
989}
990#[test]
991fn bindgen_test_layout_cudaExtent() {
992 assert_eq!(
993 ::std::mem::size_of::<cudaExtent>(),
994 24usize,
995 concat!("Size of: ", stringify!(cudaExtent))
996 );
997 assert_eq!(
998 ::std::mem::align_of::<cudaExtent>(),
999 8usize,
1000 concat!("Alignment of ", stringify!(cudaExtent))
1001 );
1002 assert_eq!(
1003 unsafe { &(*(::std::ptr::null::<cudaExtent>())).width as *const _ as usize },
1004 0usize,
1005 concat!(
1006 "Offset of field: ",
1007 stringify!(cudaExtent),
1008 "::",
1009 stringify!(width)
1010 )
1011 );
1012 assert_eq!(
1013 unsafe { &(*(::std::ptr::null::<cudaExtent>())).height as *const _ as usize },
1014 8usize,
1015 concat!(
1016 "Offset of field: ",
1017 stringify!(cudaExtent),
1018 "::",
1019 stringify!(height)
1020 )
1021 );
1022 assert_eq!(
1023 unsafe { &(*(::std::ptr::null::<cudaExtent>())).depth as *const _ as usize },
1024 16usize,
1025 concat!(
1026 "Offset of field: ",
1027 stringify!(cudaExtent),
1028 "::",
1029 stringify!(depth)
1030 )
1031 );
1032}
1033#[doc = " CUDA 3D position"]
1034#[doc = ""]
1035#[doc = " \\sa ::make_cudaPos"]
1036#[repr(C)]
1037#[derive(Debug, Copy, Clone)]
1038pub struct cudaPos {
1039 #[doc = "< x"]
1040 pub x: usize,
1041 #[doc = "< y"]
1042 pub y: usize,
1043 #[doc = "< z"]
1044 pub z: usize,
1045}
1046#[test]
1047fn bindgen_test_layout_cudaPos() {
1048 assert_eq!(
1049 ::std::mem::size_of::<cudaPos>(),
1050 24usize,
1051 concat!("Size of: ", stringify!(cudaPos))
1052 );
1053 assert_eq!(
1054 ::std::mem::align_of::<cudaPos>(),
1055 8usize,
1056 concat!("Alignment of ", stringify!(cudaPos))
1057 );
1058 assert_eq!(
1059 unsafe { &(*(::std::ptr::null::<cudaPos>())).x as *const _ as usize },
1060 0usize,
1061 concat!(
1062 "Offset of field: ",
1063 stringify!(cudaPos),
1064 "::",
1065 stringify!(x)
1066 )
1067 );
1068 assert_eq!(
1069 unsafe { &(*(::std::ptr::null::<cudaPos>())).y as *const _ as usize },
1070 8usize,
1071 concat!(
1072 "Offset of field: ",
1073 stringify!(cudaPos),
1074 "::",
1075 stringify!(y)
1076 )
1077 );
1078 assert_eq!(
1079 unsafe { &(*(::std::ptr::null::<cudaPos>())).z as *const _ as usize },
1080 16usize,
1081 concat!(
1082 "Offset of field: ",
1083 stringify!(cudaPos),
1084 "::",
1085 stringify!(z)
1086 )
1087 );
1088}
1089#[doc = " CUDA 3D memory copying parameters"]
1090#[repr(C)]
1091#[derive(Debug, Copy, Clone)]
1092pub struct cudaMemcpy3DParms {
1093 #[doc = "< Source memory address"]
1094 pub srcArray: cudaArray_t,
1095 #[doc = "< Source position offset"]
1096 pub srcPos: cudaPos,
1097 #[doc = "< Pitched source memory address"]
1098 pub srcPtr: cudaPitchedPtr,
1099 #[doc = "< Destination memory address"]
1100 pub dstArray: cudaArray_t,
1101 #[doc = "< Destination position offset"]
1102 pub dstPos: cudaPos,
1103 #[doc = "< Pitched destination memory address"]
1104 pub dstPtr: cudaPitchedPtr,
1105 #[doc = "< Requested memory copy size"]
1106 pub extent: cudaExtent,
1107 #[doc = "< Type of transfer"]
1108 pub kind: cudaMemcpyKind,
1109}
1110#[test]
1111fn bindgen_test_layout_cudaMemcpy3DParms() {
1112 assert_eq!(
1113 ::std::mem::size_of::<cudaMemcpy3DParms>(),
1114 160usize,
1115 concat!("Size of: ", stringify!(cudaMemcpy3DParms))
1116 );
1117 assert_eq!(
1118 ::std::mem::align_of::<cudaMemcpy3DParms>(),
1119 8usize,
1120 concat!("Alignment of ", stringify!(cudaMemcpy3DParms))
1121 );
1122 assert_eq!(
1123 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).srcArray as *const _ as usize },
1124 0usize,
1125 concat!(
1126 "Offset of field: ",
1127 stringify!(cudaMemcpy3DParms),
1128 "::",
1129 stringify!(srcArray)
1130 )
1131 );
1132 assert_eq!(
1133 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).srcPos as *const _ as usize },
1134 8usize,
1135 concat!(
1136 "Offset of field: ",
1137 stringify!(cudaMemcpy3DParms),
1138 "::",
1139 stringify!(srcPos)
1140 )
1141 );
1142 assert_eq!(
1143 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).srcPtr as *const _ as usize },
1144 32usize,
1145 concat!(
1146 "Offset of field: ",
1147 stringify!(cudaMemcpy3DParms),
1148 "::",
1149 stringify!(srcPtr)
1150 )
1151 );
1152 assert_eq!(
1153 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).dstArray as *const _ as usize },
1154 64usize,
1155 concat!(
1156 "Offset of field: ",
1157 stringify!(cudaMemcpy3DParms),
1158 "::",
1159 stringify!(dstArray)
1160 )
1161 );
1162 assert_eq!(
1163 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).dstPos as *const _ as usize },
1164 72usize,
1165 concat!(
1166 "Offset of field: ",
1167 stringify!(cudaMemcpy3DParms),
1168 "::",
1169 stringify!(dstPos)
1170 )
1171 );
1172 assert_eq!(
1173 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).dstPtr as *const _ as usize },
1174 96usize,
1175 concat!(
1176 "Offset of field: ",
1177 stringify!(cudaMemcpy3DParms),
1178 "::",
1179 stringify!(dstPtr)
1180 )
1181 );
1182 assert_eq!(
1183 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).extent as *const _ as usize },
1184 128usize,
1185 concat!(
1186 "Offset of field: ",
1187 stringify!(cudaMemcpy3DParms),
1188 "::",
1189 stringify!(extent)
1190 )
1191 );
1192 assert_eq!(
1193 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DParms>())).kind as *const _ as usize },
1194 152usize,
1195 concat!(
1196 "Offset of field: ",
1197 stringify!(cudaMemcpy3DParms),
1198 "::",
1199 stringify!(kind)
1200 )
1201 );
1202}
1203#[doc = " CUDA 3D cross-device memory copying parameters"]
1204#[repr(C)]
1205#[derive(Debug, Copy, Clone)]
1206pub struct cudaMemcpy3DPeerParms {
1207 #[doc = "< Source memory address"]
1208 pub srcArray: cudaArray_t,
1209 #[doc = "< Source position offset"]
1210 pub srcPos: cudaPos,
1211 #[doc = "< Pitched source memory address"]
1212 pub srcPtr: cudaPitchedPtr,
1213 #[doc = "< Source device"]
1214 pub srcDevice: ::libc::c_int,
1215 #[doc = "< Destination memory address"]
1216 pub dstArray: cudaArray_t,
1217 #[doc = "< Destination position offset"]
1218 pub dstPos: cudaPos,
1219 #[doc = "< Pitched destination memory address"]
1220 pub dstPtr: cudaPitchedPtr,
1221 #[doc = "< Destination device"]
1222 pub dstDevice: ::libc::c_int,
1223 #[doc = "< Requested memory copy size"]
1224 pub extent: cudaExtent,
1225}
1226#[test]
1227fn bindgen_test_layout_cudaMemcpy3DPeerParms() {
1228 assert_eq!(
1229 ::std::mem::size_of::<cudaMemcpy3DPeerParms>(),
1230 168usize,
1231 concat!("Size of: ", stringify!(cudaMemcpy3DPeerParms))
1232 );
1233 assert_eq!(
1234 ::std::mem::align_of::<cudaMemcpy3DPeerParms>(),
1235 8usize,
1236 concat!("Alignment of ", stringify!(cudaMemcpy3DPeerParms))
1237 );
1238 assert_eq!(
1239 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcArray as *const _ as usize },
1240 0usize,
1241 concat!(
1242 "Offset of field: ",
1243 stringify!(cudaMemcpy3DPeerParms),
1244 "::",
1245 stringify!(srcArray)
1246 )
1247 );
1248 assert_eq!(
1249 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcPos as *const _ as usize },
1250 8usize,
1251 concat!(
1252 "Offset of field: ",
1253 stringify!(cudaMemcpy3DPeerParms),
1254 "::",
1255 stringify!(srcPos)
1256 )
1257 );
1258 assert_eq!(
1259 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcPtr as *const _ as usize },
1260 32usize,
1261 concat!(
1262 "Offset of field: ",
1263 stringify!(cudaMemcpy3DPeerParms),
1264 "::",
1265 stringify!(srcPtr)
1266 )
1267 );
1268 assert_eq!(
1269 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).srcDevice as *const _ as usize },
1270 64usize,
1271 concat!(
1272 "Offset of field: ",
1273 stringify!(cudaMemcpy3DPeerParms),
1274 "::",
1275 stringify!(srcDevice)
1276 )
1277 );
1278 assert_eq!(
1279 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstArray as *const _ as usize },
1280 72usize,
1281 concat!(
1282 "Offset of field: ",
1283 stringify!(cudaMemcpy3DPeerParms),
1284 "::",
1285 stringify!(dstArray)
1286 )
1287 );
1288 assert_eq!(
1289 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstPos as *const _ as usize },
1290 80usize,
1291 concat!(
1292 "Offset of field: ",
1293 stringify!(cudaMemcpy3DPeerParms),
1294 "::",
1295 stringify!(dstPos)
1296 )
1297 );
1298 assert_eq!(
1299 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstPtr as *const _ as usize },
1300 104usize,
1301 concat!(
1302 "Offset of field: ",
1303 stringify!(cudaMemcpy3DPeerParms),
1304 "::",
1305 stringify!(dstPtr)
1306 )
1307 );
1308 assert_eq!(
1309 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).dstDevice as *const _ as usize },
1310 136usize,
1311 concat!(
1312 "Offset of field: ",
1313 stringify!(cudaMemcpy3DPeerParms),
1314 "::",
1315 stringify!(dstDevice)
1316 )
1317 );
1318 assert_eq!(
1319 unsafe { &(*(::std::ptr::null::<cudaMemcpy3DPeerParms>())).extent as *const _ as usize },
1320 144usize,
1321 concat!(
1322 "Offset of field: ",
1323 stringify!(cudaMemcpy3DPeerParms),
1324 "::",
1325 stringify!(extent)
1326 )
1327 );
1328}
1329#[doc = " CUDA Memset node parameters"]
1330#[repr(C)]
1331#[derive(Debug, Copy, Clone)]
1332pub struct cudaMemsetParams {
1333 #[doc = "< Destination device pointer"]
1334 pub dst: *mut ::libc::c_void,
1335 #[doc = "< Pitch of destination device pointer. Unused if height is 1"]
1336 pub pitch: usize,
1337 #[doc = "< Value to be set"]
1338 pub value: ::libc::c_uint,
1339 #[doc = "< Size of each element in bytes. Must be 1, 2, or 4."]
1340 pub elementSize: ::libc::c_uint,
1341 #[doc = "< Width of the row in elements"]
1342 pub width: usize,
1343 #[doc = "< Number of rows"]
1344 pub height: usize,
1345}
1346#[test]
1347fn bindgen_test_layout_cudaMemsetParams() {
1348 assert_eq!(
1349 ::std::mem::size_of::<cudaMemsetParams>(),
1350 40usize,
1351 concat!("Size of: ", stringify!(cudaMemsetParams))
1352 );
1353 assert_eq!(
1354 ::std::mem::align_of::<cudaMemsetParams>(),
1355 8usize,
1356 concat!("Alignment of ", stringify!(cudaMemsetParams))
1357 );
1358 assert_eq!(
1359 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).dst as *const _ as usize },
1360 0usize,
1361 concat!(
1362 "Offset of field: ",
1363 stringify!(cudaMemsetParams),
1364 "::",
1365 stringify!(dst)
1366 )
1367 );
1368 assert_eq!(
1369 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).pitch as *const _ as usize },
1370 8usize,
1371 concat!(
1372 "Offset of field: ",
1373 stringify!(cudaMemsetParams),
1374 "::",
1375 stringify!(pitch)
1376 )
1377 );
1378 assert_eq!(
1379 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).value as *const _ as usize },
1380 16usize,
1381 concat!(
1382 "Offset of field: ",
1383 stringify!(cudaMemsetParams),
1384 "::",
1385 stringify!(value)
1386 )
1387 );
1388 assert_eq!(
1389 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).elementSize as *const _ as usize },
1390 20usize,
1391 concat!(
1392 "Offset of field: ",
1393 stringify!(cudaMemsetParams),
1394 "::",
1395 stringify!(elementSize)
1396 )
1397 );
1398 assert_eq!(
1399 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).width as *const _ as usize },
1400 24usize,
1401 concat!(
1402 "Offset of field: ",
1403 stringify!(cudaMemsetParams),
1404 "::",
1405 stringify!(width)
1406 )
1407 );
1408 assert_eq!(
1409 unsafe { &(*(::std::ptr::null::<cudaMemsetParams>())).height as *const _ as usize },
1410 32usize,
1411 concat!(
1412 "Offset of field: ",
1413 stringify!(cudaMemsetParams),
1414 "::",
1415 stringify!(height)
1416 )
1417 );
1418}
1419#[repr(u32)]
1420#[non_exhaustive]
1421#[doc = " Specifies performance hint with ::cudaAccessPolicyWindow for hitProp and missProp members."]
1422#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1423pub enum cudaAccessProperty {
1424 #[doc = "< Normal cache persistence."]
1425 cudaAccessPropertyNormal = 0,
1426 #[doc = "< Streaming access is less likely to persit from cache."]
1427 cudaAccessPropertyStreaming = 1,
1428 #[doc = "< Persisting access is more likely to persist in cache."]
1429 cudaAccessPropertyPersisting = 2,
1430}
1431#[doc = " Specifies an access policy for a window, a contiguous extent of memory"]
1432#[doc = " beginning at base_ptr and ending at base_ptr + num_bytes."]
1433#[doc = " Partition into many segments and assign segments such that."]
1434#[doc = " sum of \"hit segments\" / window == approx. ratio."]
1435#[doc = " sum of \"miss segments\" / window == approx 1-ratio."]
1436#[doc = " Segments and ratio specifications are fitted to the capabilities of"]
1437#[doc = " the architecture."]
1438#[doc = " Accesses in a hit segment apply the hitProp access policy."]
1439#[doc = " Accesses in a miss segment apply the missProp access policy."]
1440#[repr(C)]
1441#[derive(Debug, Copy, Clone)]
1442pub struct cudaAccessPolicyWindow {
1443 #[doc = "< Starting address of the access policy window. CUDA driver may align it."]
1444 pub base_ptr: *mut ::libc::c_void,
1445 #[doc = "< Size in bytes of the window policy. CUDA driver may restrict the maximum size and alignment."]
1446 pub num_bytes: usize,
1447 #[doc = "< hitRatio specifies percentage of lines assigned hitProp, rest are assigned missProp."]
1448 pub hitRatio: f32,
1449 #[doc = "< ::CUaccessProperty set for hit."]
1450 pub hitProp: cudaAccessProperty,
1451 #[doc = "< ::CUaccessProperty set for miss. Must be either NORMAL or STREAMING."]
1452 pub missProp: cudaAccessProperty,
1453}
1454#[test]
1455fn bindgen_test_layout_cudaAccessPolicyWindow() {
1456 assert_eq!(
1457 ::std::mem::size_of::<cudaAccessPolicyWindow>(),
1458 32usize,
1459 concat!("Size of: ", stringify!(cudaAccessPolicyWindow))
1460 );
1461 assert_eq!(
1462 ::std::mem::align_of::<cudaAccessPolicyWindow>(),
1463 8usize,
1464 concat!("Alignment of ", stringify!(cudaAccessPolicyWindow))
1465 );
1466 assert_eq!(
1467 unsafe { &(*(::std::ptr::null::<cudaAccessPolicyWindow>())).base_ptr as *const _ as usize },
1468 0usize,
1469 concat!(
1470 "Offset of field: ",
1471 stringify!(cudaAccessPolicyWindow),
1472 "::",
1473 stringify!(base_ptr)
1474 )
1475 );
1476 assert_eq!(
1477 unsafe {
1478 &(*(::std::ptr::null::<cudaAccessPolicyWindow>())).num_bytes as *const _ as usize
1479 },
1480 8usize,
1481 concat!(
1482 "Offset of field: ",
1483 stringify!(cudaAccessPolicyWindow),
1484 "::",
1485 stringify!(num_bytes)
1486 )
1487 );
1488 assert_eq!(
1489 unsafe { &(*(::std::ptr::null::<cudaAccessPolicyWindow>())).hitRatio as *const _ as usize },
1490 16usize,
1491 concat!(
1492 "Offset of field: ",
1493 stringify!(cudaAccessPolicyWindow),
1494 "::",
1495 stringify!(hitRatio)
1496 )
1497 );
1498 assert_eq!(
1499 unsafe { &(*(::std::ptr::null::<cudaAccessPolicyWindow>())).hitProp as *const _ as usize },
1500 20usize,
1501 concat!(
1502 "Offset of field: ",
1503 stringify!(cudaAccessPolicyWindow),
1504 "::",
1505 stringify!(hitProp)
1506 )
1507 );
1508 assert_eq!(
1509 unsafe { &(*(::std::ptr::null::<cudaAccessPolicyWindow>())).missProp as *const _ as usize },
1510 24usize,
1511 concat!(
1512 "Offset of field: ",
1513 stringify!(cudaAccessPolicyWindow),
1514 "::",
1515 stringify!(missProp)
1516 )
1517 );
1518}
1519#[doc = " CUDA host function"]
1520#[doc = " \\param userData Argument value passed to the function"]
1521pub type cudaHostFn_t = ::std::option::Option<unsafe extern "C" fn(userData: *mut ::libc::c_void)>;
1522#[doc = " CUDA host node parameters"]
1523#[repr(C)]
1524#[derive(Debug, Copy, Clone)]
1525pub struct cudaHostNodeParams {
1526 #[doc = "< The function to call when the node executes"]
1527 pub fn_: cudaHostFn_t,
1528 #[doc = "< Argument to pass to the function"]
1529 pub userData: *mut ::libc::c_void,
1530}
1531#[test]
1532fn bindgen_test_layout_cudaHostNodeParams() {
1533 assert_eq!(
1534 ::std::mem::size_of::<cudaHostNodeParams>(),
1535 16usize,
1536 concat!("Size of: ", stringify!(cudaHostNodeParams))
1537 );
1538 assert_eq!(
1539 ::std::mem::align_of::<cudaHostNodeParams>(),
1540 8usize,
1541 concat!("Alignment of ", stringify!(cudaHostNodeParams))
1542 );
1543 assert_eq!(
1544 unsafe { &(*(::std::ptr::null::<cudaHostNodeParams>())).fn_ as *const _ as usize },
1545 0usize,
1546 concat!(
1547 "Offset of field: ",
1548 stringify!(cudaHostNodeParams),
1549 "::",
1550 stringify!(fn_)
1551 )
1552 );
1553 assert_eq!(
1554 unsafe { &(*(::std::ptr::null::<cudaHostNodeParams>())).userData as *const _ as usize },
1555 8usize,
1556 concat!(
1557 "Offset of field: ",
1558 stringify!(cudaHostNodeParams),
1559 "::",
1560 stringify!(userData)
1561 )
1562 );
1563}
1564#[repr(u32)]
1565#[non_exhaustive]
1566#[doc = " Possible stream capture statuses returned by ::cudaStreamIsCapturing"]
1567#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1568pub enum cudaStreamCaptureStatus {
1569 #[doc = "< Stream is not capturing"]
1570 cudaStreamCaptureStatusNone = 0,
1571 #[doc = "< Stream is actively capturing"]
1572 cudaStreamCaptureStatusActive = 1,
1573 #[doc = "< Stream is part of a capture sequence that"]
1574 #[doc = "has been invalidated, but not terminated"]
1575 cudaStreamCaptureStatusInvalidated = 2,
1576}
1577#[repr(u32)]
1578#[non_exhaustive]
1579#[doc = " Possible modes for stream capture thread interactions. For more details see"]
1580#[doc = " ::cudaStreamBeginCapture and ::cudaThreadExchangeStreamCaptureMode"]
1581#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1582pub enum cudaStreamCaptureMode {
1583 cudaStreamCaptureModeGlobal = 0,
1584 cudaStreamCaptureModeThreadLocal = 1,
1585 cudaStreamCaptureModeRelaxed = 2,
1586}
1587#[repr(u32)]
1588#[non_exhaustive]
1589#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1590pub enum cudaSynchronizationPolicy {
1591 cudaSyncPolicyAuto = 1,
1592 cudaSyncPolicySpin = 2,
1593 cudaSyncPolicyYield = 3,
1594 cudaSyncPolicyBlockingSync = 4,
1595}
1596#[repr(u32)]
1597#[non_exhaustive]
1598#[doc = " Stream Attributes"]
1599#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1600pub enum cudaStreamAttrID {
1601 #[doc = "< Identifier for ::cudaStreamAttrValue::accessPolicyWindow."]
1602 cudaStreamAttributeAccessPolicyWindow = 1,
1603 #[doc = "< ::cudaSynchronizationPolicy for work queued up in this stream"]
1604 cudaStreamAttributeSynchronizationPolicy = 3,
1605}
1606#[doc = " Stream attributes union used with ::cudaStreamSetAttribute/::cudaStreamGetAttribute"]
1607#[repr(C)]
1608#[derive(Copy, Clone)]
1609pub union cudaStreamAttrValue {
1610 pub accessPolicyWindow: cudaAccessPolicyWindow,
1611 pub syncPolicy: cudaSynchronizationPolicy,
1612}
1613#[test]
1614fn bindgen_test_layout_cudaStreamAttrValue() {
1615 assert_eq!(
1616 ::std::mem::size_of::<cudaStreamAttrValue>(),
1617 32usize,
1618 concat!("Size of: ", stringify!(cudaStreamAttrValue))
1619 );
1620 assert_eq!(
1621 ::std::mem::align_of::<cudaStreamAttrValue>(),
1622 8usize,
1623 concat!("Alignment of ", stringify!(cudaStreamAttrValue))
1624 );
1625 assert_eq!(
1626 unsafe {
1627 &(*(::std::ptr::null::<cudaStreamAttrValue>())).accessPolicyWindow as *const _ as usize
1628 },
1629 0usize,
1630 concat!(
1631 "Offset of field: ",
1632 stringify!(cudaStreamAttrValue),
1633 "::",
1634 stringify!(accessPolicyWindow)
1635 )
1636 );
1637 assert_eq!(
1638 unsafe { &(*(::std::ptr::null::<cudaStreamAttrValue>())).syncPolicy as *const _ as usize },
1639 0usize,
1640 concat!(
1641 "Offset of field: ",
1642 stringify!(cudaStreamAttrValue),
1643 "::",
1644 stringify!(syncPolicy)
1645 )
1646 );
1647}
1648#[repr(u32)]
1649#[non_exhaustive]
1650#[doc = " Flags for ::cudaStreamUpdateCaptureDependencies"]
1651#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1652pub enum cudaStreamUpdateCaptureDependenciesFlags {
1653 #[doc = "< Add new nodes to the dependency set"]
1654 cudaStreamAddCaptureDependencies = 0,
1655 #[doc = "< Replace the dependency set with the new nodes"]
1656 cudaStreamSetCaptureDependencies = 1,
1657}
1658#[repr(u32)]
1659#[non_exhaustive]
1660#[doc = " Flags for user objects for graphs"]
1661#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1662pub enum cudaUserObjectFlags {
1663 #[doc = "< Indicates the destructor execution is not synchronized by any CUDA handle."]
1664 cudaUserObjectNoDestructorSync = 1,
1665}
1666#[repr(u32)]
1667#[non_exhaustive]
1668#[doc = " Flags for retaining user object references for graphs"]
1669#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1670pub enum cudaUserObjectRetainFlags {
1671 #[doc = "< Transfer references from the caller rather than creating new references."]
1672 cudaGraphUserObjectMove = 1,
1673}
1674#[doc = " CUDA graphics interop resource"]
1675#[repr(C)]
1676#[derive(Debug, Copy, Clone)]
1677pub struct cudaGraphicsResource {
1678 _unused: [u8; 0],
1679}
1680#[repr(u32)]
1681#[non_exhaustive]
1682#[doc = " CUDA graphics interop register flags"]
1683#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1684pub enum cudaGraphicsRegisterFlags {
1685 #[doc = "< Default"]
1686 cudaGraphicsRegisterFlagsNone = 0,
1687 #[doc = "< CUDA will not write to this resource"]
1688 cudaGraphicsRegisterFlagsReadOnly = 1,
1689 #[doc = "< CUDA will only write to and will not read from this resource"]
1690 cudaGraphicsRegisterFlagsWriteDiscard = 2,
1691 #[doc = "< CUDA will bind this resource to a surface reference"]
1692 cudaGraphicsRegisterFlagsSurfaceLoadStore = 4,
1693 #[doc = "< CUDA will perform texture gather operations on this resource"]
1694 cudaGraphicsRegisterFlagsTextureGather = 8,
1695}
1696#[repr(u32)]
1697#[non_exhaustive]
1698#[doc = " CUDA graphics interop map flags"]
1699#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1700pub enum cudaGraphicsMapFlags {
1701 #[doc = "< Default; Assume resource can be read/written"]
1702 cudaGraphicsMapFlagsNone = 0,
1703 #[doc = "< CUDA will not write to this resource"]
1704 cudaGraphicsMapFlagsReadOnly = 1,
1705 #[doc = "< CUDA will only write to and will not read from this resource"]
1706 cudaGraphicsMapFlagsWriteDiscard = 2,
1707}
1708#[repr(u32)]
1709#[non_exhaustive]
1710#[doc = " CUDA graphics interop array indices for cube maps"]
1711#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1712pub enum cudaGraphicsCubeFace {
1713 #[doc = "< Positive X face of cubemap"]
1714 cudaGraphicsCubeFacePositiveX = 0,
1715 #[doc = "< Negative X face of cubemap"]
1716 cudaGraphicsCubeFaceNegativeX = 1,
1717 #[doc = "< Positive Y face of cubemap"]
1718 cudaGraphicsCubeFacePositiveY = 2,
1719 #[doc = "< Negative Y face of cubemap"]
1720 cudaGraphicsCubeFaceNegativeY = 3,
1721 #[doc = "< Positive Z face of cubemap"]
1722 cudaGraphicsCubeFacePositiveZ = 4,
1723 #[doc = "< Negative Z face of cubemap"]
1724 cudaGraphicsCubeFaceNegativeZ = 5,
1725}
1726#[repr(u32)]
1727#[non_exhaustive]
1728#[doc = " Graph kernel node Attributes"]
1729#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1730pub enum cudaKernelNodeAttrID {
1731 #[doc = "< Identifier for ::cudaKernelNodeAttrValue::accessPolicyWindow."]
1732 cudaKernelNodeAttributeAccessPolicyWindow = 1,
1733 #[doc = "< Allows a kernel node to be cooperative (see ::cudaLaunchCooperativeKernel)."]
1734 cudaKernelNodeAttributeCooperative = 2,
1735}
1736#[doc = " Graph kernel node attributes union, used with ::cudaGraphKernelNodeSetAttribute/::cudaGraphKernelNodeGetAttribute"]
1737#[repr(C)]
1738#[derive(Copy, Clone)]
1739pub union cudaKernelNodeAttrValue {
1740 #[doc = "< Attribute ::CUaccessPolicyWindow."]
1741 pub accessPolicyWindow: cudaAccessPolicyWindow,
1742 pub cooperative: ::libc::c_int,
1743}
1744#[test]
1745fn bindgen_test_layout_cudaKernelNodeAttrValue() {
1746 assert_eq!(
1747 ::std::mem::size_of::<cudaKernelNodeAttrValue>(),
1748 32usize,
1749 concat!("Size of: ", stringify!(cudaKernelNodeAttrValue))
1750 );
1751 assert_eq!(
1752 ::std::mem::align_of::<cudaKernelNodeAttrValue>(),
1753 8usize,
1754 concat!("Alignment of ", stringify!(cudaKernelNodeAttrValue))
1755 );
1756 assert_eq!(
1757 unsafe {
1758 &(*(::std::ptr::null::<cudaKernelNodeAttrValue>())).accessPolicyWindow as *const _
1759 as usize
1760 },
1761 0usize,
1762 concat!(
1763 "Offset of field: ",
1764 stringify!(cudaKernelNodeAttrValue),
1765 "::",
1766 stringify!(accessPolicyWindow)
1767 )
1768 );
1769 assert_eq!(
1770 unsafe {
1771 &(*(::std::ptr::null::<cudaKernelNodeAttrValue>())).cooperative as *const _ as usize
1772 },
1773 0usize,
1774 concat!(
1775 "Offset of field: ",
1776 stringify!(cudaKernelNodeAttrValue),
1777 "::",
1778 stringify!(cooperative)
1779 )
1780 );
1781}
1782#[repr(u32)]
1783#[non_exhaustive]
1784#[doc = " CUDA resource types"]
1785#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1786pub enum cudaResourceType {
1787 #[doc = "< Array resource"]
1788 cudaResourceTypeArray = 0,
1789 #[doc = "< Mipmapped array resource"]
1790 cudaResourceTypeMipmappedArray = 1,
1791 #[doc = "< Linear resource"]
1792 cudaResourceTypeLinear = 2,
1793 #[doc = "< Pitch 2D resource"]
1794 cudaResourceTypePitch2D = 3,
1795}
1796#[repr(u32)]
1797#[non_exhaustive]
1798#[doc = " CUDA texture resource view formats"]
1799#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1800pub enum cudaResourceViewFormat {
1801 #[doc = "< No resource view format (use underlying resource format)"]
1802 cudaResViewFormatNone = 0,
1803 #[doc = "< 1 channel unsigned 8-bit integers"]
1804 cudaResViewFormatUnsignedChar1 = 1,
1805 #[doc = "< 2 channel unsigned 8-bit integers"]
1806 cudaResViewFormatUnsignedChar2 = 2,
1807 #[doc = "< 4 channel unsigned 8-bit integers"]
1808 cudaResViewFormatUnsignedChar4 = 3,
1809 #[doc = "< 1 channel signed 8-bit integers"]
1810 cudaResViewFormatSignedChar1 = 4,
1811 #[doc = "< 2 channel signed 8-bit integers"]
1812 cudaResViewFormatSignedChar2 = 5,
1813 #[doc = "< 4 channel signed 8-bit integers"]
1814 cudaResViewFormatSignedChar4 = 6,
1815 #[doc = "< 1 channel unsigned 16-bit integers"]
1816 cudaResViewFormatUnsignedShort1 = 7,
1817 #[doc = "< 2 channel unsigned 16-bit integers"]
1818 cudaResViewFormatUnsignedShort2 = 8,
1819 #[doc = "< 4 channel unsigned 16-bit integers"]
1820 cudaResViewFormatUnsignedShort4 = 9,
1821 #[doc = "< 1 channel signed 16-bit integers"]
1822 cudaResViewFormatSignedShort1 = 10,
1823 #[doc = "< 2 channel signed 16-bit integers"]
1824 cudaResViewFormatSignedShort2 = 11,
1825 #[doc = "< 4 channel signed 16-bit integers"]
1826 cudaResViewFormatSignedShort4 = 12,
1827 #[doc = "< 1 channel unsigned 32-bit integers"]
1828 cudaResViewFormatUnsignedInt1 = 13,
1829 #[doc = "< 2 channel unsigned 32-bit integers"]
1830 cudaResViewFormatUnsignedInt2 = 14,
1831 #[doc = "< 4 channel unsigned 32-bit integers"]
1832 cudaResViewFormatUnsignedInt4 = 15,
1833 #[doc = "< 1 channel signed 32-bit integers"]
1834 cudaResViewFormatSignedInt1 = 16,
1835 #[doc = "< 2 channel signed 32-bit integers"]
1836 cudaResViewFormatSignedInt2 = 17,
1837 #[doc = "< 4 channel signed 32-bit integers"]
1838 cudaResViewFormatSignedInt4 = 18,
1839 #[doc = "< 1 channel 16-bit floating point"]
1840 cudaResViewFormatHalf1 = 19,
1841 #[doc = "< 2 channel 16-bit floating point"]
1842 cudaResViewFormatHalf2 = 20,
1843 #[doc = "< 4 channel 16-bit floating point"]
1844 cudaResViewFormatHalf4 = 21,
1845 #[doc = "< 1 channel 32-bit floating point"]
1846 cudaResViewFormatFloat1 = 22,
1847 #[doc = "< 2 channel 32-bit floating point"]
1848 cudaResViewFormatFloat2 = 23,
1849 #[doc = "< 4 channel 32-bit floating point"]
1850 cudaResViewFormatFloat4 = 24,
1851 #[doc = "< Block compressed 1"]
1852 cudaResViewFormatUnsignedBlockCompressed1 = 25,
1853 #[doc = "< Block compressed 2"]
1854 cudaResViewFormatUnsignedBlockCompressed2 = 26,
1855 #[doc = "< Block compressed 3"]
1856 cudaResViewFormatUnsignedBlockCompressed3 = 27,
1857 #[doc = "< Block compressed 4 unsigned"]
1858 cudaResViewFormatUnsignedBlockCompressed4 = 28,
1859 #[doc = "< Block compressed 4 signed"]
1860 cudaResViewFormatSignedBlockCompressed4 = 29,
1861 #[doc = "< Block compressed 5 unsigned"]
1862 cudaResViewFormatUnsignedBlockCompressed5 = 30,
1863 #[doc = "< Block compressed 5 signed"]
1864 cudaResViewFormatSignedBlockCompressed5 = 31,
1865 #[doc = "< Block compressed 6 unsigned half-float"]
1866 cudaResViewFormatUnsignedBlockCompressed6H = 32,
1867 #[doc = "< Block compressed 6 signed half-float"]
1868 cudaResViewFormatSignedBlockCompressed6H = 33,
1869 #[doc = "< Block compressed 7"]
1870 cudaResViewFormatUnsignedBlockCompressed7 = 34,
1871}
1872#[doc = " CUDA resource descriptor"]
1873#[repr(C)]
1874#[derive(Copy, Clone)]
1875pub struct cudaResourceDesc {
1876 #[doc = "< Resource type"]
1877 pub resType: cudaResourceType,
1878 pub res: cudaResourceDesc__bindgen_ty_1,
1879}
1880#[repr(C)]
1881#[derive(Copy, Clone)]
1882pub union cudaResourceDesc__bindgen_ty_1 {
1883 pub array: cudaResourceDesc__bindgen_ty_1__bindgen_ty_1,
1884 pub mipmap: cudaResourceDesc__bindgen_ty_1__bindgen_ty_2,
1885 pub linear: cudaResourceDesc__bindgen_ty_1__bindgen_ty_3,
1886 pub pitch2D: cudaResourceDesc__bindgen_ty_1__bindgen_ty_4,
1887}
1888#[repr(C)]
1889#[derive(Debug, Copy, Clone)]
1890pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_1 {
1891 #[doc = "< CUDA array"]
1892 pub array: cudaArray_t,
1893}
1894#[test]
1895fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_1() {
1896 assert_eq!(
1897 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_1>(),
1898 8usize,
1899 concat!(
1900 "Size of: ",
1901 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_1)
1902 )
1903 );
1904 assert_eq!(
1905 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_1>(),
1906 8usize,
1907 concat!(
1908 "Alignment of ",
1909 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_1)
1910 )
1911 );
1912 assert_eq!(
1913 unsafe {
1914 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_1>())).array
1915 as *const _ as usize
1916 },
1917 0usize,
1918 concat!(
1919 "Offset of field: ",
1920 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_1),
1921 "::",
1922 stringify!(array)
1923 )
1924 );
1925}
1926#[repr(C)]
1927#[derive(Debug, Copy, Clone)]
1928pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_2 {
1929 #[doc = "< CUDA mipmapped array"]
1930 pub mipmap: cudaMipmappedArray_t,
1931}
1932#[test]
1933fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_2() {
1934 assert_eq!(
1935 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_2>(),
1936 8usize,
1937 concat!(
1938 "Size of: ",
1939 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_2)
1940 )
1941 );
1942 assert_eq!(
1943 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_2>(),
1944 8usize,
1945 concat!(
1946 "Alignment of ",
1947 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_2)
1948 )
1949 );
1950 assert_eq!(
1951 unsafe {
1952 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_2>())).mipmap
1953 as *const _ as usize
1954 },
1955 0usize,
1956 concat!(
1957 "Offset of field: ",
1958 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_2),
1959 "::",
1960 stringify!(mipmap)
1961 )
1962 );
1963}
1964#[repr(C)]
1965#[derive(Debug, Copy, Clone)]
1966pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_3 {
1967 #[doc = "< Device pointer"]
1968 pub devPtr: *mut ::libc::c_void,
1969 #[doc = "< Channel descriptor"]
1970 pub desc: cudaChannelFormatDesc,
1971 #[doc = "< Size in bytes"]
1972 pub sizeInBytes: usize,
1973}
1974#[test]
1975fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_3() {
1976 assert_eq!(
1977 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>(),
1978 40usize,
1979 concat!(
1980 "Size of: ",
1981 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3)
1982 )
1983 );
1984 assert_eq!(
1985 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>(),
1986 8usize,
1987 concat!(
1988 "Alignment of ",
1989 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3)
1990 )
1991 );
1992 assert_eq!(
1993 unsafe {
1994 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>())).devPtr
1995 as *const _ as usize
1996 },
1997 0usize,
1998 concat!(
1999 "Offset of field: ",
2000 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3),
2001 "::",
2002 stringify!(devPtr)
2003 )
2004 );
2005 assert_eq!(
2006 unsafe {
2007 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>())).desc
2008 as *const _ as usize
2009 },
2010 8usize,
2011 concat!(
2012 "Offset of field: ",
2013 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3),
2014 "::",
2015 stringify!(desc)
2016 )
2017 );
2018 assert_eq!(
2019 unsafe {
2020 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_3>())).sizeInBytes
2021 as *const _ as usize
2022 },
2023 32usize,
2024 concat!(
2025 "Offset of field: ",
2026 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_3),
2027 "::",
2028 stringify!(sizeInBytes)
2029 )
2030 );
2031}
2032#[repr(C)]
2033#[derive(Debug, Copy, Clone)]
2034pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_4 {
2035 #[doc = "< Device pointer"]
2036 pub devPtr: *mut ::libc::c_void,
2037 #[doc = "< Channel descriptor"]
2038 pub desc: cudaChannelFormatDesc,
2039 #[doc = "< Width of the array in elements"]
2040 pub width: usize,
2041 #[doc = "< Height of the array in elements"]
2042 pub height: usize,
2043 #[doc = "< Pitch between two rows in bytes"]
2044 pub pitchInBytes: usize,
2045}
2046#[test]
2047fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1__bindgen_ty_4() {
2048 assert_eq!(
2049 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>(),
2050 56usize,
2051 concat!(
2052 "Size of: ",
2053 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4)
2054 )
2055 );
2056 assert_eq!(
2057 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>(),
2058 8usize,
2059 concat!(
2060 "Alignment of ",
2061 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4)
2062 )
2063 );
2064 assert_eq!(
2065 unsafe {
2066 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).devPtr
2067 as *const _ as usize
2068 },
2069 0usize,
2070 concat!(
2071 "Offset of field: ",
2072 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
2073 "::",
2074 stringify!(devPtr)
2075 )
2076 );
2077 assert_eq!(
2078 unsafe {
2079 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).desc
2080 as *const _ as usize
2081 },
2082 8usize,
2083 concat!(
2084 "Offset of field: ",
2085 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
2086 "::",
2087 stringify!(desc)
2088 )
2089 );
2090 assert_eq!(
2091 unsafe {
2092 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).width
2093 as *const _ as usize
2094 },
2095 32usize,
2096 concat!(
2097 "Offset of field: ",
2098 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
2099 "::",
2100 stringify!(width)
2101 )
2102 );
2103 assert_eq!(
2104 unsafe {
2105 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).height
2106 as *const _ as usize
2107 },
2108 40usize,
2109 concat!(
2110 "Offset of field: ",
2111 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
2112 "::",
2113 stringify!(height)
2114 )
2115 );
2116 assert_eq!(
2117 unsafe {
2118 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1__bindgen_ty_4>())).pitchInBytes
2119 as *const _ as usize
2120 },
2121 48usize,
2122 concat!(
2123 "Offset of field: ",
2124 stringify!(cudaResourceDesc__bindgen_ty_1__bindgen_ty_4),
2125 "::",
2126 stringify!(pitchInBytes)
2127 )
2128 );
2129}
2130#[test]
2131fn bindgen_test_layout_cudaResourceDesc__bindgen_ty_1() {
2132 assert_eq!(
2133 ::std::mem::size_of::<cudaResourceDesc__bindgen_ty_1>(),
2134 56usize,
2135 concat!("Size of: ", stringify!(cudaResourceDesc__bindgen_ty_1))
2136 );
2137 assert_eq!(
2138 ::std::mem::align_of::<cudaResourceDesc__bindgen_ty_1>(),
2139 8usize,
2140 concat!("Alignment of ", stringify!(cudaResourceDesc__bindgen_ty_1))
2141 );
2142 assert_eq!(
2143 unsafe {
2144 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).array as *const _ as usize
2145 },
2146 0usize,
2147 concat!(
2148 "Offset of field: ",
2149 stringify!(cudaResourceDesc__bindgen_ty_1),
2150 "::",
2151 stringify!(array)
2152 )
2153 );
2154 assert_eq!(
2155 unsafe {
2156 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).mipmap as *const _ as usize
2157 },
2158 0usize,
2159 concat!(
2160 "Offset of field: ",
2161 stringify!(cudaResourceDesc__bindgen_ty_1),
2162 "::",
2163 stringify!(mipmap)
2164 )
2165 );
2166 assert_eq!(
2167 unsafe {
2168 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).linear as *const _ as usize
2169 },
2170 0usize,
2171 concat!(
2172 "Offset of field: ",
2173 stringify!(cudaResourceDesc__bindgen_ty_1),
2174 "::",
2175 stringify!(linear)
2176 )
2177 );
2178 assert_eq!(
2179 unsafe {
2180 &(*(::std::ptr::null::<cudaResourceDesc__bindgen_ty_1>())).pitch2D as *const _ as usize
2181 },
2182 0usize,
2183 concat!(
2184 "Offset of field: ",
2185 stringify!(cudaResourceDesc__bindgen_ty_1),
2186 "::",
2187 stringify!(pitch2D)
2188 )
2189 );
2190}
2191#[test]
2192fn bindgen_test_layout_cudaResourceDesc() {
2193 assert_eq!(
2194 ::std::mem::size_of::<cudaResourceDesc>(),
2195 64usize,
2196 concat!("Size of: ", stringify!(cudaResourceDesc))
2197 );
2198 assert_eq!(
2199 ::std::mem::align_of::<cudaResourceDesc>(),
2200 8usize,
2201 concat!("Alignment of ", stringify!(cudaResourceDesc))
2202 );
2203 assert_eq!(
2204 unsafe { &(*(::std::ptr::null::<cudaResourceDesc>())).resType as *const _ as usize },
2205 0usize,
2206 concat!(
2207 "Offset of field: ",
2208 stringify!(cudaResourceDesc),
2209 "::",
2210 stringify!(resType)
2211 )
2212 );
2213 assert_eq!(
2214 unsafe { &(*(::std::ptr::null::<cudaResourceDesc>())).res as *const _ as usize },
2215 8usize,
2216 concat!(
2217 "Offset of field: ",
2218 stringify!(cudaResourceDesc),
2219 "::",
2220 stringify!(res)
2221 )
2222 );
2223}
2224#[doc = " CUDA resource view descriptor"]
2225#[repr(C)]
2226#[derive(Debug, Copy, Clone)]
2227pub struct cudaResourceViewDesc {
2228 #[doc = "< Resource view format"]
2229 pub format: cudaResourceViewFormat,
2230 #[doc = "< Width of the resource view"]
2231 pub width: usize,
2232 #[doc = "< Height of the resource view"]
2233 pub height: usize,
2234 #[doc = "< Depth of the resource view"]
2235 pub depth: usize,
2236 #[doc = "< First defined mipmap level"]
2237 pub firstMipmapLevel: ::libc::c_uint,
2238 #[doc = "< Last defined mipmap level"]
2239 pub lastMipmapLevel: ::libc::c_uint,
2240 #[doc = "< First layer index"]
2241 pub firstLayer: ::libc::c_uint,
2242 #[doc = "< Last layer index"]
2243 pub lastLayer: ::libc::c_uint,
2244}
2245#[test]
2246fn bindgen_test_layout_cudaResourceViewDesc() {
2247 assert_eq!(
2248 ::std::mem::size_of::<cudaResourceViewDesc>(),
2249 48usize,
2250 concat!("Size of: ", stringify!(cudaResourceViewDesc))
2251 );
2252 assert_eq!(
2253 ::std::mem::align_of::<cudaResourceViewDesc>(),
2254 8usize,
2255 concat!("Alignment of ", stringify!(cudaResourceViewDesc))
2256 );
2257 assert_eq!(
2258 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).format as *const _ as usize },
2259 0usize,
2260 concat!(
2261 "Offset of field: ",
2262 stringify!(cudaResourceViewDesc),
2263 "::",
2264 stringify!(format)
2265 )
2266 );
2267 assert_eq!(
2268 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).width as *const _ as usize },
2269 8usize,
2270 concat!(
2271 "Offset of field: ",
2272 stringify!(cudaResourceViewDesc),
2273 "::",
2274 stringify!(width)
2275 )
2276 );
2277 assert_eq!(
2278 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).height as *const _ as usize },
2279 16usize,
2280 concat!(
2281 "Offset of field: ",
2282 stringify!(cudaResourceViewDesc),
2283 "::",
2284 stringify!(height)
2285 )
2286 );
2287 assert_eq!(
2288 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).depth as *const _ as usize },
2289 24usize,
2290 concat!(
2291 "Offset of field: ",
2292 stringify!(cudaResourceViewDesc),
2293 "::",
2294 stringify!(depth)
2295 )
2296 );
2297 assert_eq!(
2298 unsafe {
2299 &(*(::std::ptr::null::<cudaResourceViewDesc>())).firstMipmapLevel as *const _ as usize
2300 },
2301 32usize,
2302 concat!(
2303 "Offset of field: ",
2304 stringify!(cudaResourceViewDesc),
2305 "::",
2306 stringify!(firstMipmapLevel)
2307 )
2308 );
2309 assert_eq!(
2310 unsafe {
2311 &(*(::std::ptr::null::<cudaResourceViewDesc>())).lastMipmapLevel as *const _ as usize
2312 },
2313 36usize,
2314 concat!(
2315 "Offset of field: ",
2316 stringify!(cudaResourceViewDesc),
2317 "::",
2318 stringify!(lastMipmapLevel)
2319 )
2320 );
2321 assert_eq!(
2322 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).firstLayer as *const _ as usize },
2323 40usize,
2324 concat!(
2325 "Offset of field: ",
2326 stringify!(cudaResourceViewDesc),
2327 "::",
2328 stringify!(firstLayer)
2329 )
2330 );
2331 assert_eq!(
2332 unsafe { &(*(::std::ptr::null::<cudaResourceViewDesc>())).lastLayer as *const _ as usize },
2333 44usize,
2334 concat!(
2335 "Offset of field: ",
2336 stringify!(cudaResourceViewDesc),
2337 "::",
2338 stringify!(lastLayer)
2339 )
2340 );
2341}
2342#[doc = " CUDA pointer attributes"]
2343#[repr(C)]
2344#[derive(Debug, Copy, Clone)]
2345pub struct cudaPointerAttributes {
2346 #[doc = " The type of memory - ::cudaMemoryTypeUnregistered, ::cudaMemoryTypeHost,"]
2347 #[doc = " ::cudaMemoryTypeDevice or ::cudaMemoryTypeManaged."]
2348 pub type_: cudaMemoryType,
2349 #[doc = " The device against which the memory was allocated or registered."]
2350 #[doc = " If the memory type is ::cudaMemoryTypeDevice then this identifies"]
2351 #[doc = " the device on which the memory referred physically resides. If"]
2352 #[doc = " the memory type is ::cudaMemoryTypeHost or::cudaMemoryTypeManaged then"]
2353 #[doc = " this identifies the device which was current when the memory was allocated"]
2354 #[doc = " or registered (and if that device is deinitialized then this allocation"]
2355 #[doc = " will vanish with that device's state)."]
2356 pub device: ::libc::c_int,
2357 #[doc = " The address which may be dereferenced on the current device to access"]
2358 #[doc = " the memory or NULL if no such address exists."]
2359 pub devicePointer: *mut ::libc::c_void,
2360 #[doc = " The address which may be dereferenced on the host to access the"]
2361 #[doc = " memory or NULL if no such address exists."]
2362 #[doc = ""]
2363 #[doc = " \\note CUDA doesn't check if unregistered memory is allocated so this field"]
2364 #[doc = " may contain invalid pointer if an invalid pointer has been passed to CUDA."]
2365 pub hostPointer: *mut ::libc::c_void,
2366}
2367#[test]
2368fn bindgen_test_layout_cudaPointerAttributes() {
2369 assert_eq!(
2370 ::std::mem::size_of::<cudaPointerAttributes>(),
2371 24usize,
2372 concat!("Size of: ", stringify!(cudaPointerAttributes))
2373 );
2374 assert_eq!(
2375 ::std::mem::align_of::<cudaPointerAttributes>(),
2376 8usize,
2377 concat!("Alignment of ", stringify!(cudaPointerAttributes))
2378 );
2379 assert_eq!(
2380 unsafe { &(*(::std::ptr::null::<cudaPointerAttributes>())).type_ as *const _ as usize },
2381 0usize,
2382 concat!(
2383 "Offset of field: ",
2384 stringify!(cudaPointerAttributes),
2385 "::",
2386 stringify!(type_)
2387 )
2388 );
2389 assert_eq!(
2390 unsafe { &(*(::std::ptr::null::<cudaPointerAttributes>())).device as *const _ as usize },
2391 4usize,
2392 concat!(
2393 "Offset of field: ",
2394 stringify!(cudaPointerAttributes),
2395 "::",
2396 stringify!(device)
2397 )
2398 );
2399 assert_eq!(
2400 unsafe {
2401 &(*(::std::ptr::null::<cudaPointerAttributes>())).devicePointer as *const _ as usize
2402 },
2403 8usize,
2404 concat!(
2405 "Offset of field: ",
2406 stringify!(cudaPointerAttributes),
2407 "::",
2408 stringify!(devicePointer)
2409 )
2410 );
2411 assert_eq!(
2412 unsafe {
2413 &(*(::std::ptr::null::<cudaPointerAttributes>())).hostPointer as *const _ as usize
2414 },
2415 16usize,
2416 concat!(
2417 "Offset of field: ",
2418 stringify!(cudaPointerAttributes),
2419 "::",
2420 stringify!(hostPointer)
2421 )
2422 );
2423}
2424#[doc = " CUDA function attributes"]
2425#[repr(C)]
2426#[derive(Debug, Copy, Clone)]
2427pub struct cudaFuncAttributes {
2428 #[doc = " The size in bytes of statically-allocated shared memory per block"]
2429 #[doc = " required by this function. This does not include dynamically-allocated"]
2430 #[doc = " shared memory requested by the user at runtime."]
2431 pub sharedSizeBytes: usize,
2432 #[doc = " The size in bytes of user-allocated constant memory required by this"]
2433 #[doc = " function."]
2434 pub constSizeBytes: usize,
2435 #[doc = " The size in bytes of local memory used by each thread of this function."]
2436 pub localSizeBytes: usize,
2437 #[doc = " The maximum number of threads per block, beyond which a launch of the"]
2438 #[doc = " function would fail. This number depends on both the function and the"]
2439 #[doc = " device on which the function is currently loaded."]
2440 pub maxThreadsPerBlock: ::libc::c_int,
2441 #[doc = " The number of registers used by each thread of this function."]
2442 pub numRegs: ::libc::c_int,
2443 #[doc = " The PTX virtual architecture version for which the function was"]
2444 #[doc = " compiled. This value is the major PTX version * 10 + the minor PTX"]
2445 #[doc = " version, so a PTX version 1.3 function would return the value 13."]
2446 pub ptxVersion: ::libc::c_int,
2447 #[doc = " The binary architecture version for which the function was compiled."]
2448 #[doc = " This value is the major binary version * 10 + the minor binary version,"]
2449 #[doc = " so a binary version 1.3 function would return the value 13."]
2450 pub binaryVersion: ::libc::c_int,
2451 #[doc = " The attribute to indicate whether the function has been compiled with"]
2452 #[doc = " user specified option \"-Xptxas --dlcm=ca\" set."]
2453 pub cacheModeCA: ::libc::c_int,
2454 #[doc = " The maximum size in bytes of dynamic shared memory per block for"]
2455 #[doc = " this function. Any launch must have a dynamic shared memory size"]
2456 #[doc = " smaller than this value."]
2457 pub maxDynamicSharedSizeBytes: ::libc::c_int,
2458 #[doc = " On devices where the L1 cache and shared memory use the same hardware resources,"]
2459 #[doc = " this sets the shared memory carveout preference, in percent of the maximum shared memory."]
2460 #[doc = " Refer to ::cudaDevAttrMaxSharedMemoryPerMultiprocessor."]
2461 #[doc = " This is only a hint, and the driver can choose a different ratio if required to execute the function."]
2462 #[doc = " See ::cudaFuncSetAttribute"]
2463 pub preferredShmemCarveout: ::libc::c_int,
2464}
2465#[test]
2466fn bindgen_test_layout_cudaFuncAttributes() {
2467 assert_eq!(
2468 ::std::mem::size_of::<cudaFuncAttributes>(),
2469 56usize,
2470 concat!("Size of: ", stringify!(cudaFuncAttributes))
2471 );
2472 assert_eq!(
2473 ::std::mem::align_of::<cudaFuncAttributes>(),
2474 8usize,
2475 concat!("Alignment of ", stringify!(cudaFuncAttributes))
2476 );
2477 assert_eq!(
2478 unsafe {
2479 &(*(::std::ptr::null::<cudaFuncAttributes>())).sharedSizeBytes as *const _ as usize
2480 },
2481 0usize,
2482 concat!(
2483 "Offset of field: ",
2484 stringify!(cudaFuncAttributes),
2485 "::",
2486 stringify!(sharedSizeBytes)
2487 )
2488 );
2489 assert_eq!(
2490 unsafe {
2491 &(*(::std::ptr::null::<cudaFuncAttributes>())).constSizeBytes as *const _ as usize
2492 },
2493 8usize,
2494 concat!(
2495 "Offset of field: ",
2496 stringify!(cudaFuncAttributes),
2497 "::",
2498 stringify!(constSizeBytes)
2499 )
2500 );
2501 assert_eq!(
2502 unsafe {
2503 &(*(::std::ptr::null::<cudaFuncAttributes>())).localSizeBytes as *const _ as usize
2504 },
2505 16usize,
2506 concat!(
2507 "Offset of field: ",
2508 stringify!(cudaFuncAttributes),
2509 "::",
2510 stringify!(localSizeBytes)
2511 )
2512 );
2513 assert_eq!(
2514 unsafe {
2515 &(*(::std::ptr::null::<cudaFuncAttributes>())).maxThreadsPerBlock as *const _ as usize
2516 },
2517 24usize,
2518 concat!(
2519 "Offset of field: ",
2520 stringify!(cudaFuncAttributes),
2521 "::",
2522 stringify!(maxThreadsPerBlock)
2523 )
2524 );
2525 assert_eq!(
2526 unsafe { &(*(::std::ptr::null::<cudaFuncAttributes>())).numRegs as *const _ as usize },
2527 28usize,
2528 concat!(
2529 "Offset of field: ",
2530 stringify!(cudaFuncAttributes),
2531 "::",
2532 stringify!(numRegs)
2533 )
2534 );
2535 assert_eq!(
2536 unsafe { &(*(::std::ptr::null::<cudaFuncAttributes>())).ptxVersion as *const _ as usize },
2537 32usize,
2538 concat!(
2539 "Offset of field: ",
2540 stringify!(cudaFuncAttributes),
2541 "::",
2542 stringify!(ptxVersion)
2543 )
2544 );
2545 assert_eq!(
2546 unsafe {
2547 &(*(::std::ptr::null::<cudaFuncAttributes>())).binaryVersion as *const _ as usize
2548 },
2549 36usize,
2550 concat!(
2551 "Offset of field: ",
2552 stringify!(cudaFuncAttributes),
2553 "::",
2554 stringify!(binaryVersion)
2555 )
2556 );
2557 assert_eq!(
2558 unsafe { &(*(::std::ptr::null::<cudaFuncAttributes>())).cacheModeCA as *const _ as usize },
2559 40usize,
2560 concat!(
2561 "Offset of field: ",
2562 stringify!(cudaFuncAttributes),
2563 "::",
2564 stringify!(cacheModeCA)
2565 )
2566 );
2567 assert_eq!(
2568 unsafe {
2569 &(*(::std::ptr::null::<cudaFuncAttributes>())).maxDynamicSharedSizeBytes as *const _
2570 as usize
2571 },
2572 44usize,
2573 concat!(
2574 "Offset of field: ",
2575 stringify!(cudaFuncAttributes),
2576 "::",
2577 stringify!(maxDynamicSharedSizeBytes)
2578 )
2579 );
2580 assert_eq!(
2581 unsafe {
2582 &(*(::std::ptr::null::<cudaFuncAttributes>())).preferredShmemCarveout as *const _
2583 as usize
2584 },
2585 48usize,
2586 concat!(
2587 "Offset of field: ",
2588 stringify!(cudaFuncAttributes),
2589 "::",
2590 stringify!(preferredShmemCarveout)
2591 )
2592 );
2593}
2594#[repr(u32)]
2595#[non_exhaustive]
2596#[doc = " CUDA function attributes that can be set using ::cudaFuncSetAttribute"]
2597#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2598pub enum cudaFuncAttribute {
2599 #[doc = "< Maximum dynamic shared memory size"]
2600 cudaFuncAttributeMaxDynamicSharedMemorySize = 8,
2601 #[doc = "< Preferred shared memory-L1 cache split"]
2602 cudaFuncAttributePreferredSharedMemoryCarveout = 9,
2603 cudaFuncAttributeMax = 10,
2604}
2605#[repr(u32)]
2606#[non_exhaustive]
2607#[doc = " CUDA function cache configurations"]
2608#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2609pub enum cudaFuncCache {
2610 #[doc = "< Default function cache configuration, no preference"]
2611 cudaFuncCachePreferNone = 0,
2612 #[doc = "< Prefer larger shared memory and smaller L1 cache"]
2613 cudaFuncCachePreferShared = 1,
2614 #[doc = "< Prefer larger L1 cache and smaller shared memory"]
2615 cudaFuncCachePreferL1 = 2,
2616 #[doc = "< Prefer equal size L1 cache and shared memory"]
2617 cudaFuncCachePreferEqual = 3,
2618}
2619#[repr(u32)]
2620#[non_exhaustive]
2621#[doc = " CUDA shared memory configuration"]
2622#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2623pub enum cudaSharedMemConfig {
2624 cudaSharedMemBankSizeDefault = 0,
2625 cudaSharedMemBankSizeFourByte = 1,
2626 cudaSharedMemBankSizeEightByte = 2,
2627}
2628#[repr(i32)]
2629#[non_exhaustive]
2630#[doc = " Shared memory carveout configurations. These may be passed to cudaFuncSetAttribute"]
2631#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2632pub enum cudaSharedCarveout {
2633 #[doc = "< No preference for shared memory or L1 (default)"]
2634 cudaSharedmemCarveoutDefault = -1,
2635 #[doc = "< Prefer maximum available shared memory, minimum L1 cache"]
2636 cudaSharedmemCarveoutMaxShared = 100,
2637 #[doc = "< Prefer maximum available L1 cache, minimum shared memory"]
2638 cudaSharedmemCarveoutMaxL1 = 0,
2639}
2640#[repr(u32)]
2641#[non_exhaustive]
2642#[doc = " CUDA device compute modes"]
2643#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2644pub enum cudaComputeMode {
2645 #[doc = "< Default compute mode (Multiple threads can use ::cudaSetDevice() with this device)"]
2646 cudaComputeModeDefault = 0,
2647 #[doc = "< Compute-exclusive-thread mode (Only one thread in one process will be able to use ::cudaSetDevice() with this device)"]
2648 cudaComputeModeExclusive = 1,
2649 #[doc = "< Compute-prohibited mode (No threads can use ::cudaSetDevice() with this device)"]
2650 cudaComputeModeProhibited = 2,
2651 #[doc = "< Compute-exclusive-process mode (Many threads in one process will be able to use ::cudaSetDevice() with this device)"]
2652 cudaComputeModeExclusiveProcess = 3,
2653}
2654#[repr(u32)]
2655#[non_exhaustive]
2656#[doc = " CUDA Limits"]
2657#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2658pub enum cudaLimit {
2659 #[doc = "< GPU thread stack size"]
2660 cudaLimitStackSize = 0,
2661 #[doc = "< GPU printf FIFO size"]
2662 cudaLimitPrintfFifoSize = 1,
2663 #[doc = "< GPU malloc heap size"]
2664 cudaLimitMallocHeapSize = 2,
2665 #[doc = "< GPU device runtime synchronize depth"]
2666 cudaLimitDevRuntimeSyncDepth = 3,
2667 #[doc = "< GPU device runtime pending launch count"]
2668 cudaLimitDevRuntimePendingLaunchCount = 4,
2669 #[doc = "< A value between 0 and 128 that indicates the maximum fetch granularity of L2 (in Bytes). This is a hint"]
2670 cudaLimitMaxL2FetchGranularity = 5,
2671 #[doc = "< A size in bytes for L2 persisting lines cache size"]
2672 cudaLimitPersistingL2CacheSize = 6,
2673}
2674#[repr(u32)]
2675#[non_exhaustive]
2676#[doc = " CUDA Memory Advise values"]
2677#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2678pub enum cudaMemoryAdvise {
2679 #[doc = "< Data will mostly be read and only occassionally be written to"]
2680 cudaMemAdviseSetReadMostly = 1,
2681 #[doc = "< Undo the effect of ::cudaMemAdviseSetReadMostly"]
2682 cudaMemAdviseUnsetReadMostly = 2,
2683 #[doc = "< Set the preferred location for the data as the specified device"]
2684 cudaMemAdviseSetPreferredLocation = 3,
2685 #[doc = "< Clear the preferred location for the data"]
2686 cudaMemAdviseUnsetPreferredLocation = 4,
2687 #[doc = "< Data will be accessed by the specified device, so prevent page faults as much as possible"]
2688 cudaMemAdviseSetAccessedBy = 5,
2689 #[doc = "< Let the Unified Memory subsystem decide on the page faulting policy for the specified device"]
2690 cudaMemAdviseUnsetAccessedBy = 6,
2691}
2692#[repr(u32)]
2693#[non_exhaustive]
2694#[doc = " CUDA range attributes"]
2695#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2696pub enum cudaMemRangeAttribute {
2697 #[doc = "< Whether the range will mostly be read and only occassionally be written to"]
2698 cudaMemRangeAttributeReadMostly = 1,
2699 #[doc = "< The preferred location of the range"]
2700 cudaMemRangeAttributePreferredLocation = 2,
2701 #[doc = "< Memory range has ::cudaMemAdviseSetAccessedBy set for specified device"]
2702 cudaMemRangeAttributeAccessedBy = 3,
2703 #[doc = "< The last location to which the range was prefetched"]
2704 cudaMemRangeAttributeLastPrefetchLocation = 4,
2705}
2706#[repr(u32)]
2707#[non_exhaustive]
2708#[doc = " CUDA Profiler Output modes"]
2709#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2710pub enum cudaOutputMode {
2711 #[doc = "< Output mode Key-Value pair format."]
2712 cudaKeyValuePair = 0,
2713 #[doc = "< Output mode Comma separated values format."]
2714 cudaCSV = 1,
2715}
2716#[repr(u32)]
2717#[non_exhaustive]
2718#[doc = " CUDA GPUDirect RDMA flush writes APIs supported on the device"]
2719#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2720pub enum cudaFlushGPUDirectRDMAWritesOptions {
2721 #[doc = "< ::cudaDeviceFlushGPUDirectRDMAWrites() and its CUDA Driver API counterpart are supported on the device."]
2722 cudaFlushGPUDirectRDMAWritesOptionHost = 1,
2723 #[doc = "< The ::CU_STREAM_WAIT_VALUE_FLUSH flag and the ::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES MemOp are supported on the CUDA device."]
2724 cudaFlushGPUDirectRDMAWritesOptionMemOps = 2,
2725}
2726#[repr(u32)]
2727#[non_exhaustive]
2728#[doc = " CUDA GPUDirect RDMA flush writes ordering features of the device"]
2729#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2730pub enum cudaGPUDirectRDMAWritesOrdering {
2731 #[doc = "< The device does not natively support ordering of GPUDirect RDMA writes. ::cudaFlushGPUDirectRDMAWrites() can be leveraged if supported."]
2732 cudaGPUDirectRDMAWritesOrderingNone = 0,
2733 #[doc = "< Natively, the device can consistently consume GPUDirect RDMA writes, although other CUDA devices may not."]
2734 cudaGPUDirectRDMAWritesOrderingOwner = 100,
2735 #[doc = "< Any CUDA device in the system can consistently consume GPUDirect RDMA writes to this device."]
2736 cudaGPUDirectRDMAWritesOrderingAllDevices = 200,
2737}
2738#[repr(u32)]
2739#[non_exhaustive]
2740#[doc = " CUDA GPUDirect RDMA flush writes scopes"]
2741#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2742pub enum cudaFlushGPUDirectRDMAWritesScope {
2743 #[doc = "< Blocks until remote writes are visible to the CUDA device context owning the data."]
2744 cudaFlushGPUDirectRDMAWritesToOwner = 100,
2745 #[doc = "< Blocks until remote writes are visible to all CUDA device contexts."]
2746 cudaFlushGPUDirectRDMAWritesToAllDevices = 200,
2747}
2748#[repr(u32)]
2749#[non_exhaustive]
2750#[doc = " CUDA GPUDirect RDMA flush writes targets"]
2751#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2752pub enum cudaFlushGPUDirectRDMAWritesTarget {
2753 #[doc = "< Sets the target for ::cudaDeviceFlushGPUDirectRDMAWrites() to the currently active CUDA device context."]
2754 cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = 0,
2755}
2756#[repr(u32)]
2757#[non_exhaustive]
2758#[doc = " CUDA device attributes"]
2759#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2760pub enum cudaDeviceAttr {
2761 #[doc = "< Maximum number of threads per block"]
2762 cudaDevAttrMaxThreadsPerBlock = 1,
2763 #[doc = "< Maximum block dimension X"]
2764 cudaDevAttrMaxBlockDimX = 2,
2765 #[doc = "< Maximum block dimension Y"]
2766 cudaDevAttrMaxBlockDimY = 3,
2767 #[doc = "< Maximum block dimension Z"]
2768 cudaDevAttrMaxBlockDimZ = 4,
2769 #[doc = "< Maximum grid dimension X"]
2770 cudaDevAttrMaxGridDimX = 5,
2771 #[doc = "< Maximum grid dimension Y"]
2772 cudaDevAttrMaxGridDimY = 6,
2773 #[doc = "< Maximum grid dimension Z"]
2774 cudaDevAttrMaxGridDimZ = 7,
2775 #[doc = "< Maximum shared memory available per block in bytes"]
2776 cudaDevAttrMaxSharedMemoryPerBlock = 8,
2777 #[doc = "< Memory available on device for __constant__ variables in a CUDA C kernel in bytes"]
2778 cudaDevAttrTotalConstantMemory = 9,
2779 #[doc = "< Warp size in threads"]
2780 cudaDevAttrWarpSize = 10,
2781 #[doc = "< Maximum pitch in bytes allowed by memory copies"]
2782 cudaDevAttrMaxPitch = 11,
2783 #[doc = "< Maximum number of 32-bit registers available per block"]
2784 cudaDevAttrMaxRegistersPerBlock = 12,
2785 #[doc = "< Peak clock frequency in kilohertz"]
2786 cudaDevAttrClockRate = 13,
2787 #[doc = "< Alignment requirement for textures"]
2788 cudaDevAttrTextureAlignment = 14,
2789 #[doc = "< Device can possibly copy memory and execute a kernel concurrently"]
2790 cudaDevAttrGpuOverlap = 15,
2791 #[doc = "< Number of multiprocessors on device"]
2792 cudaDevAttrMultiProcessorCount = 16,
2793 #[doc = "< Specifies whether there is a run time limit on kernels"]
2794 cudaDevAttrKernelExecTimeout = 17,
2795 #[doc = "< Device is integrated with host memory"]
2796 cudaDevAttrIntegrated = 18,
2797 #[doc = "< Device can map host memory into CUDA address space"]
2798 cudaDevAttrCanMapHostMemory = 19,
2799 #[doc = "< Compute mode (See ::cudaComputeMode for details)"]
2800 cudaDevAttrComputeMode = 20,
2801 #[doc = "< Maximum 1D texture width"]
2802 cudaDevAttrMaxTexture1DWidth = 21,
2803 #[doc = "< Maximum 2D texture width"]
2804 cudaDevAttrMaxTexture2DWidth = 22,
2805 #[doc = "< Maximum 2D texture height"]
2806 cudaDevAttrMaxTexture2DHeight = 23,
2807 #[doc = "< Maximum 3D texture width"]
2808 cudaDevAttrMaxTexture3DWidth = 24,
2809 #[doc = "< Maximum 3D texture height"]
2810 cudaDevAttrMaxTexture3DHeight = 25,
2811 #[doc = "< Maximum 3D texture depth"]
2812 cudaDevAttrMaxTexture3DDepth = 26,
2813 #[doc = "< Maximum 2D layered texture width"]
2814 cudaDevAttrMaxTexture2DLayeredWidth = 27,
2815 #[doc = "< Maximum 2D layered texture height"]
2816 cudaDevAttrMaxTexture2DLayeredHeight = 28,
2817 #[doc = "< Maximum layers in a 2D layered texture"]
2818 cudaDevAttrMaxTexture2DLayeredLayers = 29,
2819 #[doc = "< Alignment requirement for surfaces"]
2820 cudaDevAttrSurfaceAlignment = 30,
2821 #[doc = "< Device can possibly execute multiple kernels concurrently"]
2822 cudaDevAttrConcurrentKernels = 31,
2823 #[doc = "< Device has ECC support enabled"]
2824 cudaDevAttrEccEnabled = 32,
2825 #[doc = "< PCI bus ID of the device"]
2826 cudaDevAttrPciBusId = 33,
2827 #[doc = "< PCI device ID of the device"]
2828 cudaDevAttrPciDeviceId = 34,
2829 #[doc = "< Device is using TCC driver model"]
2830 cudaDevAttrTccDriver = 35,
2831 #[doc = "< Peak memory clock frequency in kilohertz"]
2832 cudaDevAttrMemoryClockRate = 36,
2833 #[doc = "< Global memory bus width in bits"]
2834 cudaDevAttrGlobalMemoryBusWidth = 37,
2835 #[doc = "< Size of L2 cache in bytes"]
2836 cudaDevAttrL2CacheSize = 38,
2837 #[doc = "< Maximum resident threads per multiprocessor"]
2838 cudaDevAttrMaxThreadsPerMultiProcessor = 39,
2839 #[doc = "< Number of asynchronous engines"]
2840 cudaDevAttrAsyncEngineCount = 40,
2841 #[doc = "< Device shares a unified address space with the host"]
2842 cudaDevAttrUnifiedAddressing = 41,
2843 #[doc = "< Maximum 1D layered texture width"]
2844 cudaDevAttrMaxTexture1DLayeredWidth = 42,
2845 #[doc = "< Maximum layers in a 1D layered texture"]
2846 cudaDevAttrMaxTexture1DLayeredLayers = 43,
2847 #[doc = "< Maximum 2D texture width if cudaArrayTextureGather is set"]
2848 cudaDevAttrMaxTexture2DGatherWidth = 45,
2849 #[doc = "< Maximum 2D texture height if cudaArrayTextureGather is set"]
2850 cudaDevAttrMaxTexture2DGatherHeight = 46,
2851 #[doc = "< Alternate maximum 3D texture width"]
2852 cudaDevAttrMaxTexture3DWidthAlt = 47,
2853 #[doc = "< Alternate maximum 3D texture height"]
2854 cudaDevAttrMaxTexture3DHeightAlt = 48,
2855 #[doc = "< Alternate maximum 3D texture depth"]
2856 cudaDevAttrMaxTexture3DDepthAlt = 49,
2857 #[doc = "< PCI domain ID of the device"]
2858 cudaDevAttrPciDomainId = 50,
2859 #[doc = "< Pitch alignment requirement for textures"]
2860 cudaDevAttrTexturePitchAlignment = 51,
2861 #[doc = "< Maximum cubemap texture width/height"]
2862 cudaDevAttrMaxTextureCubemapWidth = 52,
2863 #[doc = "< Maximum cubemap layered texture width/height"]
2864 cudaDevAttrMaxTextureCubemapLayeredWidth = 53,
2865 #[doc = "< Maximum layers in a cubemap layered texture"]
2866 cudaDevAttrMaxTextureCubemapLayeredLayers = 54,
2867 #[doc = "< Maximum 1D surface width"]
2868 cudaDevAttrMaxSurface1DWidth = 55,
2869 #[doc = "< Maximum 2D surface width"]
2870 cudaDevAttrMaxSurface2DWidth = 56,
2871 #[doc = "< Maximum 2D surface height"]
2872 cudaDevAttrMaxSurface2DHeight = 57,
2873 #[doc = "< Maximum 3D surface width"]
2874 cudaDevAttrMaxSurface3DWidth = 58,
2875 #[doc = "< Maximum 3D surface height"]
2876 cudaDevAttrMaxSurface3DHeight = 59,
2877 #[doc = "< Maximum 3D surface depth"]
2878 cudaDevAttrMaxSurface3DDepth = 60,
2879 #[doc = "< Maximum 1D layered surface width"]
2880 cudaDevAttrMaxSurface1DLayeredWidth = 61,
2881 #[doc = "< Maximum layers in a 1D layered surface"]
2882 cudaDevAttrMaxSurface1DLayeredLayers = 62,
2883 #[doc = "< Maximum 2D layered surface width"]
2884 cudaDevAttrMaxSurface2DLayeredWidth = 63,
2885 #[doc = "< Maximum 2D layered surface height"]
2886 cudaDevAttrMaxSurface2DLayeredHeight = 64,
2887 #[doc = "< Maximum layers in a 2D layered surface"]
2888 cudaDevAttrMaxSurface2DLayeredLayers = 65,
2889 #[doc = "< Maximum cubemap surface width"]
2890 cudaDevAttrMaxSurfaceCubemapWidth = 66,
2891 #[doc = "< Maximum cubemap layered surface width"]
2892 cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67,
2893 #[doc = "< Maximum layers in a cubemap layered surface"]
2894 cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68,
2895 #[doc = "< Maximum 1D linear texture width"]
2896 cudaDevAttrMaxTexture1DLinearWidth = 69,
2897 #[doc = "< Maximum 2D linear texture width"]
2898 cudaDevAttrMaxTexture2DLinearWidth = 70,
2899 #[doc = "< Maximum 2D linear texture height"]
2900 cudaDevAttrMaxTexture2DLinearHeight = 71,
2901 #[doc = "< Maximum 2D linear texture pitch in bytes"]
2902 cudaDevAttrMaxTexture2DLinearPitch = 72,
2903 #[doc = "< Maximum mipmapped 2D texture width"]
2904 cudaDevAttrMaxTexture2DMipmappedWidth = 73,
2905 #[doc = "< Maximum mipmapped 2D texture height"]
2906 cudaDevAttrMaxTexture2DMipmappedHeight = 74,
2907 #[doc = "< Major compute capability version number"]
2908 cudaDevAttrComputeCapabilityMajor = 75,
2909 #[doc = "< Minor compute capability version number"]
2910 cudaDevAttrComputeCapabilityMinor = 76,
2911 #[doc = "< Maximum mipmapped 1D texture width"]
2912 cudaDevAttrMaxTexture1DMipmappedWidth = 77,
2913 #[doc = "< Device supports stream priorities"]
2914 cudaDevAttrStreamPrioritiesSupported = 78,
2915 #[doc = "< Device supports caching globals in L1"]
2916 cudaDevAttrGlobalL1CacheSupported = 79,
2917 #[doc = "< Device supports caching locals in L1"]
2918 cudaDevAttrLocalL1CacheSupported = 80,
2919 #[doc = "< Maximum shared memory available per multiprocessor in bytes"]
2920 cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81,
2921 #[doc = "< Maximum number of 32-bit registers available per multiprocessor"]
2922 cudaDevAttrMaxRegistersPerMultiprocessor = 82,
2923 #[doc = "< Device can allocate managed memory on this system"]
2924 cudaDevAttrManagedMemory = 83,
2925 #[doc = "< Device is on a multi-GPU board"]
2926 cudaDevAttrIsMultiGpuBoard = 84,
2927 #[doc = "< Unique identifier for a group of devices on the same multi-GPU board"]
2928 cudaDevAttrMultiGpuBoardGroupID = 85,
2929 #[doc = "< Link between the device and the host supports native atomic operations"]
2930 cudaDevAttrHostNativeAtomicSupported = 86,
2931 #[doc = "< Ratio of single precision performance (in floating-point operations per second) to double precision performance"]
2932 cudaDevAttrSingleToDoublePrecisionPerfRatio = 87,
2933 #[doc = "< Device supports coherently accessing pageable memory without calling cudaHostRegister on it"]
2934 cudaDevAttrPageableMemoryAccess = 88,
2935 #[doc = "< Device can coherently access managed memory concurrently with the CPU"]
2936 cudaDevAttrConcurrentManagedAccess = 89,
2937 #[doc = "< Device supports Compute Preemption"]
2938 cudaDevAttrComputePreemptionSupported = 90,
2939 #[doc = "< Device can access host registered memory at the same virtual address as the CPU"]
2940 cudaDevAttrCanUseHostPointerForRegisteredMem = 91,
2941 cudaDevAttrReserved92 = 92,
2942 cudaDevAttrReserved93 = 93,
2943 cudaDevAttrReserved94 = 94,
2944 #[doc = "< Device supports launching cooperative kernels via ::cudaLaunchCooperativeKernel"]
2945 cudaDevAttrCooperativeLaunch = 95,
2946 #[doc = "< Deprecated, cudaLaunchCooperativeKernelMultiDevice is deprecated."]
2947 cudaDevAttrCooperativeMultiDeviceLaunch = 96,
2948 #[doc = "< The maximum optin shared memory per block. This value may vary by chip. See ::cudaFuncSetAttribute"]
2949 cudaDevAttrMaxSharedMemoryPerBlockOptin = 97,
2950 #[doc = "< Device supports flushing of outstanding remote writes."]
2951 cudaDevAttrCanFlushRemoteWrites = 98,
2952 #[doc = "< Device supports host memory registration via ::cudaHostRegister."]
2953 cudaDevAttrHostRegisterSupported = 99,
2954 #[doc = "< Device accesses pageable memory via the host's page tables."]
2955 cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100,
2956 #[doc = "< Host can directly access managed memory on the device without migration."]
2957 cudaDevAttrDirectManagedMemAccessFromHost = 101,
2958 #[doc = "< Maximum number of blocks per multiprocessor"]
2959 cudaDevAttrMaxBlocksPerMultiprocessor = 106,
2960 #[doc = "< Maximum L2 persisting lines capacity setting in bytes."]
2961 cudaDevAttrMaxPersistingL2CacheSize = 108,
2962 #[doc = "< Maximum value of cudaAccessPolicyWindow::num_bytes."]
2963 cudaDevAttrMaxAccessPolicyWindowSize = 109,
2964 #[doc = "< Shared memory reserved by CUDA driver per block in bytes"]
2965 cudaDevAttrReservedSharedMemoryPerBlock = 111,
2966 #[doc = "< Device supports sparse CUDA arrays and sparse CUDA mipmapped arrays"]
2967 cudaDevAttrSparseCudaArraySupported = 112,
2968 #[doc = "< Device supports using the ::cudaHostRegister flag cudaHostRegisterReadOnly to register memory that must be mapped as read-only to the GPU"]
2969 cudaDevAttrHostRegisterReadOnlySupported = 113,
2970 #[doc = "< External timeline semaphore interop is supported on the device"]
2971 cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114,
2972 #[doc = "< Device supports using the ::cudaMallocAsync and ::cudaMemPool family of APIs"]
2973 cudaDevAttrMemoryPoolsSupported = 115,
2974 #[doc = "< Device supports GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see https://docs.nvidia.com/cuda/gpudirect-rdma for more information)"]
2975 cudaDevAttrGPUDirectRDMASupported = 116,
2976 #[doc = "< The returned attribute shall be interpreted as a bitmask, where the individual bits are listed in the ::cudaFlushGPUDirectRDMAWritesOptions enum"]
2977 cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117,
2978 #[doc = "< GPUDirect RDMA writes to the device do not need to be flushed for consumers within the scope indicated by the returned attribute. See ::cudaGPUDirectRDMAWritesOrdering for the numerical values returned here."]
2979 cudaDevAttrGPUDirectRDMAWritesOrdering = 118,
2980 #[doc = "< Handle types supported with mempool based IPC"]
2981 cudaDevAttrMemoryPoolSupportedHandleTypes = 119,
2982 cudaDevAttrMax = 120,
2983}
2984#[repr(u32)]
2985#[non_exhaustive]
2986#[doc = " CUDA memory pool attributes"]
2987#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2988pub enum cudaMemPoolAttr {
2989 #[doc = " (value type = int)"]
2990 #[doc = " Allow cuMemAllocAsync to use memory asynchronously freed"]
2991 #[doc = " in another streams as long as a stream ordering dependency"]
2992 #[doc = " of the allocating stream on the free action exists."]
2993 #[doc = " Cuda events and null stream interactions can create the required"]
2994 #[doc = " stream ordered dependencies. (default enabled)"]
2995 cudaMemPoolReuseFollowEventDependencies = 1,
2996 #[doc = " (value type = int)"]
2997 #[doc = " Allow reuse of already completed frees when there is no dependency"]
2998 #[doc = " between the free and allocation. (default enabled)"]
2999 cudaMemPoolReuseAllowOpportunistic = 2,
3000 #[doc = " (value type = int)"]
3001 #[doc = " Allow cuMemAllocAsync to insert new stream dependencies"]
3002 #[doc = " in order to establish the stream ordering required to reuse"]
3003 #[doc = " a piece of memory released by cuFreeAsync (default enabled)."]
3004 cudaMemPoolReuseAllowInternalDependencies = 3,
3005 #[doc = " (value type = cuuint64_t)"]
3006 #[doc = " Amount of reserved memory in bytes to hold onto before trying"]
3007 #[doc = " to release memory back to the OS. When more than the release"]
3008 #[doc = " threshold bytes of memory are held by the memory pool, the"]
3009 #[doc = " allocator will try to release memory back to the OS on the"]
3010 #[doc = " next call to stream, event or context synchronize. (default 0)"]
3011 cudaMemPoolAttrReleaseThreshold = 4,
3012 #[doc = " (value type = cuuint64_t)"]
3013 #[doc = " Amount of backing memory currently allocated for the mempool."]
3014 cudaMemPoolAttrReservedMemCurrent = 5,
3015 #[doc = " (value type = cuuint64_t)"]
3016 #[doc = " High watermark of backing memory allocated for the mempool since the"]
3017 #[doc = " last time it was reset. High watermark can only be reset to zero."]
3018 cudaMemPoolAttrReservedMemHigh = 6,
3019 #[doc = " (value type = cuuint64_t)"]
3020 #[doc = " Amount of memory from the pool that is currently in use by the application."]
3021 cudaMemPoolAttrUsedMemCurrent = 7,
3022 #[doc = " (value type = cuuint64_t)"]
3023 #[doc = " High watermark of the amount of memory from the pool that was in use by the application since"]
3024 #[doc = " the last time it was reset. High watermark can only be reset to zero."]
3025 cudaMemPoolAttrUsedMemHigh = 8,
3026}
3027#[repr(u32)]
3028#[non_exhaustive]
3029#[doc = " Specifies the type of location"]
3030#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3031pub enum cudaMemLocationType {
3032 cudaMemLocationTypeInvalid = 0,
3033 #[doc = "< Location is a device location, thus id is a device ordinal"]
3034 cudaMemLocationTypeDevice = 1,
3035}
3036#[doc = " Specifies a memory location."]
3037#[doc = ""]
3038#[doc = " To specify a gpu, set type = ::cudaMemLocationTypeDevice and set id = the gpu's device ordinal."]
3039#[repr(C)]
3040#[derive(Debug, Copy, Clone)]
3041pub struct cudaMemLocation {
3042 #[doc = "< Specifies the location type, which modifies the meaning of id."]
3043 pub type_: cudaMemLocationType,
3044 #[doc = "< identifier for a given this location's ::CUmemLocationType."]
3045 pub id: ::libc::c_int,
3046}
3047#[test]
3048fn bindgen_test_layout_cudaMemLocation() {
3049 assert_eq!(
3050 ::std::mem::size_of::<cudaMemLocation>(),
3051 8usize,
3052 concat!("Size of: ", stringify!(cudaMemLocation))
3053 );
3054 assert_eq!(
3055 ::std::mem::align_of::<cudaMemLocation>(),
3056 4usize,
3057 concat!("Alignment of ", stringify!(cudaMemLocation))
3058 );
3059 assert_eq!(
3060 unsafe { &(*(::std::ptr::null::<cudaMemLocation>())).type_ as *const _ as usize },
3061 0usize,
3062 concat!(
3063 "Offset of field: ",
3064 stringify!(cudaMemLocation),
3065 "::",
3066 stringify!(type_)
3067 )
3068 );
3069 assert_eq!(
3070 unsafe { &(*(::std::ptr::null::<cudaMemLocation>())).id as *const _ as usize },
3071 4usize,
3072 concat!(
3073 "Offset of field: ",
3074 stringify!(cudaMemLocation),
3075 "::",
3076 stringify!(id)
3077 )
3078 );
3079}
3080#[repr(u32)]
3081#[non_exhaustive]
3082#[doc = " Specifies the memory protection flags for mapping."]
3083#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3084pub enum cudaMemAccessFlags {
3085 #[doc = "< Default, make the address range not accessible"]
3086 cudaMemAccessFlagsProtNone = 0,
3087 #[doc = "< Make the address range read accessible"]
3088 cudaMemAccessFlagsProtRead = 1,
3089 #[doc = "< Make the address range read-write accessible"]
3090 cudaMemAccessFlagsProtReadWrite = 3,
3091}
3092#[doc = " Memory access descriptor"]
3093#[repr(C)]
3094#[derive(Debug, Copy, Clone)]
3095pub struct cudaMemAccessDesc {
3096 #[doc = "< Location on which the request is to change it's accessibility"]
3097 pub location: cudaMemLocation,
3098 #[doc = "< ::CUmemProt accessibility flags to set on the request"]
3099 pub flags: cudaMemAccessFlags,
3100}
3101#[test]
3102fn bindgen_test_layout_cudaMemAccessDesc() {
3103 assert_eq!(
3104 ::std::mem::size_of::<cudaMemAccessDesc>(),
3105 12usize,
3106 concat!("Size of: ", stringify!(cudaMemAccessDesc))
3107 );
3108 assert_eq!(
3109 ::std::mem::align_of::<cudaMemAccessDesc>(),
3110 4usize,
3111 concat!("Alignment of ", stringify!(cudaMemAccessDesc))
3112 );
3113 assert_eq!(
3114 unsafe { &(*(::std::ptr::null::<cudaMemAccessDesc>())).location as *const _ as usize },
3115 0usize,
3116 concat!(
3117 "Offset of field: ",
3118 stringify!(cudaMemAccessDesc),
3119 "::",
3120 stringify!(location)
3121 )
3122 );
3123 assert_eq!(
3124 unsafe { &(*(::std::ptr::null::<cudaMemAccessDesc>())).flags as *const _ as usize },
3125 8usize,
3126 concat!(
3127 "Offset of field: ",
3128 stringify!(cudaMemAccessDesc),
3129 "::",
3130 stringify!(flags)
3131 )
3132 );
3133}
3134#[repr(u32)]
3135#[non_exhaustive]
3136#[doc = " Defines the allocation types available"]
3137#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3138pub enum cudaMemAllocationType {
3139 cudaMemAllocationTypeInvalid = 0,
3140 #[doc = " This allocation type is 'pinned', i.e. cannot migrate from its current"]
3141 #[doc = " location while the application is actively using it"]
3142 cudaMemAllocationTypePinned = 1,
3143 #[doc = " This allocation type is 'pinned', i.e. cannot migrate from its current"]
3144 #[doc = " location while the application is actively using it"]
3145 cudaMemAllocationTypeMax = 2147483647,
3146}
3147#[repr(u32)]
3148#[non_exhaustive]
3149#[doc = " Flags for specifying particular handle types"]
3150#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3151pub enum cudaMemAllocationHandleType {
3152 #[doc = "< Does not allow any export mechanism. >"]
3153 cudaMemHandleTypeNone = 0,
3154 #[doc = "< Allows a file descriptor to be used for exporting. Permitted only on POSIX systems. (int)"]
3155 cudaMemHandleTypePosixFileDescriptor = 1,
3156 #[doc = "< Allows a Win32 NT handle to be used for exporting. (HANDLE)"]
3157 cudaMemHandleTypeWin32 = 2,
3158 #[doc = "< Allows a Win32 KMT handle to be used for exporting. (D3DKMT_HANDLE)"]
3159 cudaMemHandleTypeWin32Kmt = 4,
3160}
3161#[doc = " Specifies the properties of allocations made from the pool."]
3162#[repr(C)]
3163#[derive(Copy, Clone)]
3164pub struct cudaMemPoolProps {
3165 #[doc = "< Allocation type. Currently must be specified as cudaMemAllocationTypePinned"]
3166 pub allocType: cudaMemAllocationType,
3167 #[doc = "< Handle types that will be supported by allocations from the pool."]
3168 pub handleTypes: cudaMemAllocationHandleType,
3169 #[doc = "< Location allocations should reside."]
3170 pub location: cudaMemLocation,
3171 #[doc = " Windows-specific LPSECURITYATTRIBUTES required when"]
3172 #[doc = " ::cudaMemHandleTypeWin32 is specified. This security attribute defines"]
3173 #[doc = " the scope of which exported allocations may be tranferred to other"]
3174 #[doc = " processes. In all other cases, this field is required to be zero."]
3175 pub win32SecurityAttributes: *mut ::libc::c_void,
3176 #[doc = "< reserved for future use, must be 0"]
3177 pub reserved: [::libc::c_uchar; 64usize],
3178}
3179#[test]
3180fn bindgen_test_layout_cudaMemPoolProps() {
3181 assert_eq!(
3182 ::std::mem::size_of::<cudaMemPoolProps>(),
3183 88usize,
3184 concat!("Size of: ", stringify!(cudaMemPoolProps))
3185 );
3186 assert_eq!(
3187 ::std::mem::align_of::<cudaMemPoolProps>(),
3188 8usize,
3189 concat!("Alignment of ", stringify!(cudaMemPoolProps))
3190 );
3191 assert_eq!(
3192 unsafe { &(*(::std::ptr::null::<cudaMemPoolProps>())).allocType as *const _ as usize },
3193 0usize,
3194 concat!(
3195 "Offset of field: ",
3196 stringify!(cudaMemPoolProps),
3197 "::",
3198 stringify!(allocType)
3199 )
3200 );
3201 assert_eq!(
3202 unsafe { &(*(::std::ptr::null::<cudaMemPoolProps>())).handleTypes as *const _ as usize },
3203 4usize,
3204 concat!(
3205 "Offset of field: ",
3206 stringify!(cudaMemPoolProps),
3207 "::",
3208 stringify!(handleTypes)
3209 )
3210 );
3211 assert_eq!(
3212 unsafe { &(*(::std::ptr::null::<cudaMemPoolProps>())).location as *const _ as usize },
3213 8usize,
3214 concat!(
3215 "Offset of field: ",
3216 stringify!(cudaMemPoolProps),
3217 "::",
3218 stringify!(location)
3219 )
3220 );
3221 assert_eq!(
3222 unsafe {
3223 &(*(::std::ptr::null::<cudaMemPoolProps>())).win32SecurityAttributes as *const _
3224 as usize
3225 },
3226 16usize,
3227 concat!(
3228 "Offset of field: ",
3229 stringify!(cudaMemPoolProps),
3230 "::",
3231 stringify!(win32SecurityAttributes)
3232 )
3233 );
3234 assert_eq!(
3235 unsafe { &(*(::std::ptr::null::<cudaMemPoolProps>())).reserved as *const _ as usize },
3236 24usize,
3237 concat!(
3238 "Offset of field: ",
3239 stringify!(cudaMemPoolProps),
3240 "::",
3241 stringify!(reserved)
3242 )
3243 );
3244}
3245#[doc = " Opaque data for exporting a pool allocation"]
3246#[repr(C)]
3247#[derive(Copy, Clone)]
3248pub struct cudaMemPoolPtrExportData {
3249 pub reserved: [::libc::c_uchar; 64usize],
3250}
3251#[test]
3252fn bindgen_test_layout_cudaMemPoolPtrExportData() {
3253 assert_eq!(
3254 ::std::mem::size_of::<cudaMemPoolPtrExportData>(),
3255 64usize,
3256 concat!("Size of: ", stringify!(cudaMemPoolPtrExportData))
3257 );
3258 assert_eq!(
3259 ::std::mem::align_of::<cudaMemPoolPtrExportData>(),
3260 1usize,
3261 concat!("Alignment of ", stringify!(cudaMemPoolPtrExportData))
3262 );
3263 assert_eq!(
3264 unsafe {
3265 &(*(::std::ptr::null::<cudaMemPoolPtrExportData>())).reserved as *const _ as usize
3266 },
3267 0usize,
3268 concat!(
3269 "Offset of field: ",
3270 stringify!(cudaMemPoolPtrExportData),
3271 "::",
3272 stringify!(reserved)
3273 )
3274 );
3275}
3276#[doc = " Memory allocation node parameters"]
3277#[repr(C)]
3278#[derive(Copy, Clone)]
3279pub struct cudaMemAllocNodeParams {
3280 #[doc = "< in: array of memory access descriptors. Used to describe peer GPU access"]
3281 pub poolProps: cudaMemPoolProps,
3282 #[doc = "< in: number of memory access descriptors. Must not exceed the number of GPUs."]
3283 pub accessDescs: *const cudaMemAccessDesc,
3284 #[doc = "< in: Number of `accessDescs`s"]
3285 pub accessDescCount: usize,
3286 #[doc = "< in: size in bytes of the requested allocation"]
3287 pub bytesize: usize,
3288 #[doc = "< out: address of the allocation returned by CUDA"]
3289 pub dptr: *mut ::libc::c_void,
3290}
3291#[test]
3292fn bindgen_test_layout_cudaMemAllocNodeParams() {
3293 assert_eq!(
3294 ::std::mem::size_of::<cudaMemAllocNodeParams>(),
3295 120usize,
3296 concat!("Size of: ", stringify!(cudaMemAllocNodeParams))
3297 );
3298 assert_eq!(
3299 ::std::mem::align_of::<cudaMemAllocNodeParams>(),
3300 8usize,
3301 concat!("Alignment of ", stringify!(cudaMemAllocNodeParams))
3302 );
3303 assert_eq!(
3304 unsafe {
3305 &(*(::std::ptr::null::<cudaMemAllocNodeParams>())).poolProps as *const _ as usize
3306 },
3307 0usize,
3308 concat!(
3309 "Offset of field: ",
3310 stringify!(cudaMemAllocNodeParams),
3311 "::",
3312 stringify!(poolProps)
3313 )
3314 );
3315 assert_eq!(
3316 unsafe {
3317 &(*(::std::ptr::null::<cudaMemAllocNodeParams>())).accessDescs as *const _ as usize
3318 },
3319 88usize,
3320 concat!(
3321 "Offset of field: ",
3322 stringify!(cudaMemAllocNodeParams),
3323 "::",
3324 stringify!(accessDescs)
3325 )
3326 );
3327 assert_eq!(
3328 unsafe {
3329 &(*(::std::ptr::null::<cudaMemAllocNodeParams>())).accessDescCount as *const _ as usize
3330 },
3331 96usize,
3332 concat!(
3333 "Offset of field: ",
3334 stringify!(cudaMemAllocNodeParams),
3335 "::",
3336 stringify!(accessDescCount)
3337 )
3338 );
3339 assert_eq!(
3340 unsafe { &(*(::std::ptr::null::<cudaMemAllocNodeParams>())).bytesize as *const _ as usize },
3341 104usize,
3342 concat!(
3343 "Offset of field: ",
3344 stringify!(cudaMemAllocNodeParams),
3345 "::",
3346 stringify!(bytesize)
3347 )
3348 );
3349 assert_eq!(
3350 unsafe { &(*(::std::ptr::null::<cudaMemAllocNodeParams>())).dptr as *const _ as usize },
3351 112usize,
3352 concat!(
3353 "Offset of field: ",
3354 stringify!(cudaMemAllocNodeParams),
3355 "::",
3356 stringify!(dptr)
3357 )
3358 );
3359}
3360#[repr(u32)]
3361#[non_exhaustive]
3362#[doc = " Graph memory attributes"]
3363#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3364pub enum cudaGraphMemAttributeType {
3365 #[doc = " (value type = cuuint64_t)"]
3366 #[doc = " Amount of memory, in bytes, currently associated with graphs."]
3367 cudaGraphMemAttrUsedMemCurrent = 1,
3368 #[doc = " (value type = cuuint64_t)"]
3369 #[doc = " High watermark of memory, in bytes, associated with graphs since the"]
3370 #[doc = " last time it was reset. High watermark can only be reset to zero."]
3371 cudaGraphMemAttrUsedMemHigh = 2,
3372 #[doc = " (value type = cuuint64_t)"]
3373 #[doc = " Amount of memory, in bytes, currently allocated for use by"]
3374 #[doc = " the CUDA graphs asynchronous allocator."]
3375 cudaGraphMemAttrReservedMemCurrent = 3,
3376 #[doc = " (value type = cuuint64_t)"]
3377 #[doc = " High watermark of memory, in bytes, currently allocated for use by"]
3378 #[doc = " the CUDA graphs asynchronous allocator."]
3379 cudaGraphMemAttrReservedMemHigh = 4,
3380}
3381#[repr(u32)]
3382#[non_exhaustive]
3383#[doc = " CUDA device P2P attributes"]
3384#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3385pub enum cudaDeviceP2PAttr {
3386 #[doc = "< A relative value indicating the performance of the link between two devices"]
3387 cudaDevP2PAttrPerformanceRank = 1,
3388 #[doc = "< Peer access is enabled"]
3389 cudaDevP2PAttrAccessSupported = 2,
3390 #[doc = "< Native atomic operation over the link supported"]
3391 cudaDevP2PAttrNativeAtomicSupported = 3,
3392 #[doc = "< Accessing CUDA arrays over the link supported"]
3393 cudaDevP2PAttrCudaArrayAccessSupported = 4,
3394}
3395#[repr(C)]
3396#[derive(Debug, Copy, Clone)]
3397pub struct CUuuid_st {
3398 pub bytes: [::libc::c_char; 16usize],
3399}
3400#[test]
3401fn bindgen_test_layout_CUuuid_st() {
3402 assert_eq!(
3403 ::std::mem::size_of::<CUuuid_st>(),
3404 16usize,
3405 concat!("Size of: ", stringify!(CUuuid_st))
3406 );
3407 assert_eq!(
3408 ::std::mem::align_of::<CUuuid_st>(),
3409 1usize,
3410 concat!("Alignment of ", stringify!(CUuuid_st))
3411 );
3412 assert_eq!(
3413 unsafe { &(*(::std::ptr::null::<CUuuid_st>())).bytes as *const _ as usize },
3414 0usize,
3415 concat!(
3416 "Offset of field: ",
3417 stringify!(CUuuid_st),
3418 "::",
3419 stringify!(bytes)
3420 )
3421 );
3422}
3423pub type CUuuid = CUuuid_st;
3424pub type cudaUUID_t = CUuuid_st;
3425#[doc = " CUDA device properties"]
3426#[repr(C)]
3427#[derive(Copy, Clone)]
3428pub struct cudaDeviceProp {
3429 #[doc = "< ASCII string identifying device"]
3430 pub name: [::libc::c_char; 256usize],
3431 #[doc = "< 16-byte unique identifier"]
3432 pub uuid: cudaUUID_t,
3433 #[doc = "< 8-byte locally unique identifier. Value is undefined on TCC and non-Windows platforms"]
3434 pub luid: [::libc::c_char; 8usize],
3435 #[doc = "< LUID device node mask. Value is undefined on TCC and non-Windows platforms"]
3436 pub luidDeviceNodeMask: ::libc::c_uint,
3437 #[doc = "< Global memory available on device in bytes"]
3438 pub totalGlobalMem: usize,
3439 #[doc = "< Shared memory available per block in bytes"]
3440 pub sharedMemPerBlock: usize,
3441 #[doc = "< 32-bit registers available per block"]
3442 pub regsPerBlock: ::libc::c_int,
3443 #[doc = "< Warp size in threads"]
3444 pub warpSize: ::libc::c_int,
3445 #[doc = "< Maximum pitch in bytes allowed by memory copies"]
3446 pub memPitch: usize,
3447 #[doc = "< Maximum number of threads per block"]
3448 pub maxThreadsPerBlock: ::libc::c_int,
3449 #[doc = "< Maximum size of each dimension of a block"]
3450 pub maxThreadsDim: [::libc::c_int; 3usize],
3451 #[doc = "< Maximum size of each dimension of a grid"]
3452 pub maxGridSize: [::libc::c_int; 3usize],
3453 #[doc = "< Clock frequency in kilohertz"]
3454 pub clockRate: ::libc::c_int,
3455 #[doc = "< Constant memory available on device in bytes"]
3456 pub totalConstMem: usize,
3457 #[doc = "< Major compute capability"]
3458 pub major: ::libc::c_int,
3459 #[doc = "< Minor compute capability"]
3460 pub minor: ::libc::c_int,
3461 #[doc = "< Alignment requirement for textures"]
3462 pub textureAlignment: usize,
3463 #[doc = "< Pitch alignment requirement for texture references bound to pitched memory"]
3464 pub texturePitchAlignment: usize,
3465 #[doc = "< Device can concurrently copy memory and execute a kernel. Deprecated. Use instead asyncEngineCount."]
3466 pub deviceOverlap: ::libc::c_int,
3467 #[doc = "< Number of multiprocessors on device"]
3468 pub multiProcessorCount: ::libc::c_int,
3469 #[doc = "< Specified whether there is a run time limit on kernels"]
3470 pub kernelExecTimeoutEnabled: ::libc::c_int,
3471 #[doc = "< Device is integrated as opposed to discrete"]
3472 pub integrated: ::libc::c_int,
3473 #[doc = "< Device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer"]
3474 pub canMapHostMemory: ::libc::c_int,
3475 #[doc = "< Compute mode (See ::cudaComputeMode)"]
3476 pub computeMode: ::libc::c_int,
3477 #[doc = "< Maximum 1D texture size"]
3478 pub maxTexture1D: ::libc::c_int,
3479 #[doc = "< Maximum 1D mipmapped texture size"]
3480 pub maxTexture1DMipmap: ::libc::c_int,
3481 #[doc = "< Deprecated, do not use. Use cudaDeviceGetTexture1DLinearMaxWidth() or cuDeviceGetTexture1DLinearMaxWidth() instead."]
3482 pub maxTexture1DLinear: ::libc::c_int,
3483 #[doc = "< Maximum 2D texture dimensions"]
3484 pub maxTexture2D: [::libc::c_int; 2usize],
3485 #[doc = "< Maximum 2D mipmapped texture dimensions"]
3486 pub maxTexture2DMipmap: [::libc::c_int; 2usize],
3487 #[doc = "< Maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory"]
3488 pub maxTexture2DLinear: [::libc::c_int; 3usize],
3489 #[doc = "< Maximum 2D texture dimensions if texture gather operations have to be performed"]
3490 pub maxTexture2DGather: [::libc::c_int; 2usize],
3491 #[doc = "< Maximum 3D texture dimensions"]
3492 pub maxTexture3D: [::libc::c_int; 3usize],
3493 #[doc = "< Maximum alternate 3D texture dimensions"]
3494 pub maxTexture3DAlt: [::libc::c_int; 3usize],
3495 #[doc = "< Maximum Cubemap texture dimensions"]
3496 pub maxTextureCubemap: ::libc::c_int,
3497 #[doc = "< Maximum 1D layered texture dimensions"]
3498 pub maxTexture1DLayered: [::libc::c_int; 2usize],
3499 #[doc = "< Maximum 2D layered texture dimensions"]
3500 pub maxTexture2DLayered: [::libc::c_int; 3usize],
3501 #[doc = "< Maximum Cubemap layered texture dimensions"]
3502 pub maxTextureCubemapLayered: [::libc::c_int; 2usize],
3503 #[doc = "< Maximum 1D surface size"]
3504 pub maxSurface1D: ::libc::c_int,
3505 #[doc = "< Maximum 2D surface dimensions"]
3506 pub maxSurface2D: [::libc::c_int; 2usize],
3507 #[doc = "< Maximum 3D surface dimensions"]
3508 pub maxSurface3D: [::libc::c_int; 3usize],
3509 #[doc = "< Maximum 1D layered surface dimensions"]
3510 pub maxSurface1DLayered: [::libc::c_int; 2usize],
3511 #[doc = "< Maximum 2D layered surface dimensions"]
3512 pub maxSurface2DLayered: [::libc::c_int; 3usize],
3513 #[doc = "< Maximum Cubemap surface dimensions"]
3514 pub maxSurfaceCubemap: ::libc::c_int,
3515 #[doc = "< Maximum Cubemap layered surface dimensions"]
3516 pub maxSurfaceCubemapLayered: [::libc::c_int; 2usize],
3517 #[doc = "< Alignment requirements for surfaces"]
3518 pub surfaceAlignment: usize,
3519 #[doc = "< Device can possibly execute multiple kernels concurrently"]
3520 pub concurrentKernels: ::libc::c_int,
3521 #[doc = "< Device has ECC support enabled"]
3522 pub ECCEnabled: ::libc::c_int,
3523 #[doc = "< PCI bus ID of the device"]
3524 pub pciBusID: ::libc::c_int,
3525 #[doc = "< PCI device ID of the device"]
3526 pub pciDeviceID: ::libc::c_int,
3527 #[doc = "< PCI domain ID of the device"]
3528 pub pciDomainID: ::libc::c_int,
3529 #[doc = "< 1 if device is a Tesla device using TCC driver, 0 otherwise"]
3530 pub tccDriver: ::libc::c_int,
3531 #[doc = "< Number of asynchronous engines"]
3532 pub asyncEngineCount: ::libc::c_int,
3533 #[doc = "< Device shares a unified address space with the host"]
3534 pub unifiedAddressing: ::libc::c_int,
3535 #[doc = "< Peak memory clock frequency in kilohertz"]
3536 pub memoryClockRate: ::libc::c_int,
3537 #[doc = "< Global memory bus width in bits"]
3538 pub memoryBusWidth: ::libc::c_int,
3539 #[doc = "< Size of L2 cache in bytes"]
3540 pub l2CacheSize: ::libc::c_int,
3541 #[doc = "< Device's maximum l2 persisting lines capacity setting in bytes"]
3542 pub persistingL2CacheMaxSize: ::libc::c_int,
3543 #[doc = "< Maximum resident threads per multiprocessor"]
3544 pub maxThreadsPerMultiProcessor: ::libc::c_int,
3545 #[doc = "< Device supports stream priorities"]
3546 pub streamPrioritiesSupported: ::libc::c_int,
3547 #[doc = "< Device supports caching globals in L1"]
3548 pub globalL1CacheSupported: ::libc::c_int,
3549 #[doc = "< Device supports caching locals in L1"]
3550 pub localL1CacheSupported: ::libc::c_int,
3551 #[doc = "< Shared memory available per multiprocessor in bytes"]
3552 pub sharedMemPerMultiprocessor: usize,
3553 #[doc = "< 32-bit registers available per multiprocessor"]
3554 pub regsPerMultiprocessor: ::libc::c_int,
3555 #[doc = "< Device supports allocating managed memory on this system"]
3556 pub managedMemory: ::libc::c_int,
3557 #[doc = "< Device is on a multi-GPU board"]
3558 pub isMultiGpuBoard: ::libc::c_int,
3559 #[doc = "< Unique identifier for a group of devices on the same multi-GPU board"]
3560 pub multiGpuBoardGroupID: ::libc::c_int,
3561 #[doc = "< Link between the device and the host supports native atomic operations"]
3562 pub hostNativeAtomicSupported: ::libc::c_int,
3563 #[doc = "< Ratio of single precision performance (in floating-point operations per second) to double precision performance"]
3564 pub singleToDoublePrecisionPerfRatio: ::libc::c_int,
3565 #[doc = "< Device supports coherently accessing pageable memory without calling cudaHostRegister on it"]
3566 pub pageableMemoryAccess: ::libc::c_int,
3567 #[doc = "< Device can coherently access managed memory concurrently with the CPU"]
3568 pub concurrentManagedAccess: ::libc::c_int,
3569 #[doc = "< Device supports Compute Preemption"]
3570 pub computePreemptionSupported: ::libc::c_int,
3571 #[doc = "< Device can access host registered memory at the same virtual address as the CPU"]
3572 pub canUseHostPointerForRegisteredMem: ::libc::c_int,
3573 #[doc = "< Device supports launching cooperative kernels via ::cudaLaunchCooperativeKernel"]
3574 pub cooperativeLaunch: ::libc::c_int,
3575 #[doc = "< Deprecated, cudaLaunchCooperativeKernelMultiDevice is deprecated."]
3576 pub cooperativeMultiDeviceLaunch: ::libc::c_int,
3577 #[doc = "< Per device maximum shared memory per block usable by special opt in"]
3578 pub sharedMemPerBlockOptin: usize,
3579 #[doc = "< Device accesses pageable memory via the host's page tables"]
3580 pub pageableMemoryAccessUsesHostPageTables: ::libc::c_int,
3581 #[doc = "< Host can directly access managed memory on the device without migration."]
3582 pub directManagedMemAccessFromHost: ::libc::c_int,
3583 #[doc = "< Maximum number of resident blocks per multiprocessor"]
3584 pub maxBlocksPerMultiProcessor: ::libc::c_int,
3585 #[doc = "< The maximum value of ::cudaAccessPolicyWindow::num_bytes."]
3586 pub accessPolicyMaxWindowSize: ::libc::c_int,
3587 #[doc = "< Shared memory reserved by CUDA driver per block in bytes"]
3588 pub reservedSharedMemPerBlock: usize,
3589}
3590#[test]
3591fn bindgen_test_layout_cudaDeviceProp() {
3592 assert_eq!(
3593 ::std::mem::size_of::<cudaDeviceProp>(),
3594 728usize,
3595 concat!("Size of: ", stringify!(cudaDeviceProp))
3596 );
3597 assert_eq!(
3598 ::std::mem::align_of::<cudaDeviceProp>(),
3599 8usize,
3600 concat!("Alignment of ", stringify!(cudaDeviceProp))
3601 );
3602 assert_eq!(
3603 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).name as *const _ as usize },
3604 0usize,
3605 concat!(
3606 "Offset of field: ",
3607 stringify!(cudaDeviceProp),
3608 "::",
3609 stringify!(name)
3610 )
3611 );
3612 assert_eq!(
3613 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).uuid as *const _ as usize },
3614 256usize,
3615 concat!(
3616 "Offset of field: ",
3617 stringify!(cudaDeviceProp),
3618 "::",
3619 stringify!(uuid)
3620 )
3621 );
3622 assert_eq!(
3623 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).luid as *const _ as usize },
3624 272usize,
3625 concat!(
3626 "Offset of field: ",
3627 stringify!(cudaDeviceProp),
3628 "::",
3629 stringify!(luid)
3630 )
3631 );
3632 assert_eq!(
3633 unsafe {
3634 &(*(::std::ptr::null::<cudaDeviceProp>())).luidDeviceNodeMask as *const _ as usize
3635 },
3636 280usize,
3637 concat!(
3638 "Offset of field: ",
3639 stringify!(cudaDeviceProp),
3640 "::",
3641 stringify!(luidDeviceNodeMask)
3642 )
3643 );
3644 assert_eq!(
3645 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).totalGlobalMem as *const _ as usize },
3646 288usize,
3647 concat!(
3648 "Offset of field: ",
3649 stringify!(cudaDeviceProp),
3650 "::",
3651 stringify!(totalGlobalMem)
3652 )
3653 );
3654 assert_eq!(
3655 unsafe {
3656 &(*(::std::ptr::null::<cudaDeviceProp>())).sharedMemPerBlock as *const _ as usize
3657 },
3658 296usize,
3659 concat!(
3660 "Offset of field: ",
3661 stringify!(cudaDeviceProp),
3662 "::",
3663 stringify!(sharedMemPerBlock)
3664 )
3665 );
3666 assert_eq!(
3667 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).regsPerBlock as *const _ as usize },
3668 304usize,
3669 concat!(
3670 "Offset of field: ",
3671 stringify!(cudaDeviceProp),
3672 "::",
3673 stringify!(regsPerBlock)
3674 )
3675 );
3676 assert_eq!(
3677 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).warpSize as *const _ as usize },
3678 308usize,
3679 concat!(
3680 "Offset of field: ",
3681 stringify!(cudaDeviceProp),
3682 "::",
3683 stringify!(warpSize)
3684 )
3685 );
3686 assert_eq!(
3687 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).memPitch as *const _ as usize },
3688 312usize,
3689 concat!(
3690 "Offset of field: ",
3691 stringify!(cudaDeviceProp),
3692 "::",
3693 stringify!(memPitch)
3694 )
3695 );
3696 assert_eq!(
3697 unsafe {
3698 &(*(::std::ptr::null::<cudaDeviceProp>())).maxThreadsPerBlock as *const _ as usize
3699 },
3700 320usize,
3701 concat!(
3702 "Offset of field: ",
3703 stringify!(cudaDeviceProp),
3704 "::",
3705 stringify!(maxThreadsPerBlock)
3706 )
3707 );
3708 assert_eq!(
3709 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxThreadsDim as *const _ as usize },
3710 324usize,
3711 concat!(
3712 "Offset of field: ",
3713 stringify!(cudaDeviceProp),
3714 "::",
3715 stringify!(maxThreadsDim)
3716 )
3717 );
3718 assert_eq!(
3719 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxGridSize as *const _ as usize },
3720 336usize,
3721 concat!(
3722 "Offset of field: ",
3723 stringify!(cudaDeviceProp),
3724 "::",
3725 stringify!(maxGridSize)
3726 )
3727 );
3728 assert_eq!(
3729 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).clockRate as *const _ as usize },
3730 348usize,
3731 concat!(
3732 "Offset of field: ",
3733 stringify!(cudaDeviceProp),
3734 "::",
3735 stringify!(clockRate)
3736 )
3737 );
3738 assert_eq!(
3739 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).totalConstMem as *const _ as usize },
3740 352usize,
3741 concat!(
3742 "Offset of field: ",
3743 stringify!(cudaDeviceProp),
3744 "::",
3745 stringify!(totalConstMem)
3746 )
3747 );
3748 assert_eq!(
3749 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).major as *const _ as usize },
3750 360usize,
3751 concat!(
3752 "Offset of field: ",
3753 stringify!(cudaDeviceProp),
3754 "::",
3755 stringify!(major)
3756 )
3757 );
3758 assert_eq!(
3759 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).minor as *const _ as usize },
3760 364usize,
3761 concat!(
3762 "Offset of field: ",
3763 stringify!(cudaDeviceProp),
3764 "::",
3765 stringify!(minor)
3766 )
3767 );
3768 assert_eq!(
3769 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).textureAlignment as *const _ as usize },
3770 368usize,
3771 concat!(
3772 "Offset of field: ",
3773 stringify!(cudaDeviceProp),
3774 "::",
3775 stringify!(textureAlignment)
3776 )
3777 );
3778 assert_eq!(
3779 unsafe {
3780 &(*(::std::ptr::null::<cudaDeviceProp>())).texturePitchAlignment as *const _ as usize
3781 },
3782 376usize,
3783 concat!(
3784 "Offset of field: ",
3785 stringify!(cudaDeviceProp),
3786 "::",
3787 stringify!(texturePitchAlignment)
3788 )
3789 );
3790 assert_eq!(
3791 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).deviceOverlap as *const _ as usize },
3792 384usize,
3793 concat!(
3794 "Offset of field: ",
3795 stringify!(cudaDeviceProp),
3796 "::",
3797 stringify!(deviceOverlap)
3798 )
3799 );
3800 assert_eq!(
3801 unsafe {
3802 &(*(::std::ptr::null::<cudaDeviceProp>())).multiProcessorCount as *const _ as usize
3803 },
3804 388usize,
3805 concat!(
3806 "Offset of field: ",
3807 stringify!(cudaDeviceProp),
3808 "::",
3809 stringify!(multiProcessorCount)
3810 )
3811 );
3812 assert_eq!(
3813 unsafe {
3814 &(*(::std::ptr::null::<cudaDeviceProp>())).kernelExecTimeoutEnabled as *const _ as usize
3815 },
3816 392usize,
3817 concat!(
3818 "Offset of field: ",
3819 stringify!(cudaDeviceProp),
3820 "::",
3821 stringify!(kernelExecTimeoutEnabled)
3822 )
3823 );
3824 assert_eq!(
3825 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).integrated as *const _ as usize },
3826 396usize,
3827 concat!(
3828 "Offset of field: ",
3829 stringify!(cudaDeviceProp),
3830 "::",
3831 stringify!(integrated)
3832 )
3833 );
3834 assert_eq!(
3835 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).canMapHostMemory as *const _ as usize },
3836 400usize,
3837 concat!(
3838 "Offset of field: ",
3839 stringify!(cudaDeviceProp),
3840 "::",
3841 stringify!(canMapHostMemory)
3842 )
3843 );
3844 assert_eq!(
3845 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).computeMode as *const _ as usize },
3846 404usize,
3847 concat!(
3848 "Offset of field: ",
3849 stringify!(cudaDeviceProp),
3850 "::",
3851 stringify!(computeMode)
3852 )
3853 );
3854 assert_eq!(
3855 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1D as *const _ as usize },
3856 408usize,
3857 concat!(
3858 "Offset of field: ",
3859 stringify!(cudaDeviceProp),
3860 "::",
3861 stringify!(maxTexture1D)
3862 )
3863 );
3864 assert_eq!(
3865 unsafe {
3866 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1DMipmap as *const _ as usize
3867 },
3868 412usize,
3869 concat!(
3870 "Offset of field: ",
3871 stringify!(cudaDeviceProp),
3872 "::",
3873 stringify!(maxTexture1DMipmap)
3874 )
3875 );
3876 assert_eq!(
3877 unsafe {
3878 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1DLinear as *const _ as usize
3879 },
3880 416usize,
3881 concat!(
3882 "Offset of field: ",
3883 stringify!(cudaDeviceProp),
3884 "::",
3885 stringify!(maxTexture1DLinear)
3886 )
3887 );
3888 assert_eq!(
3889 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2D as *const _ as usize },
3890 420usize,
3891 concat!(
3892 "Offset of field: ",
3893 stringify!(cudaDeviceProp),
3894 "::",
3895 stringify!(maxTexture2D)
3896 )
3897 );
3898 assert_eq!(
3899 unsafe {
3900 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DMipmap as *const _ as usize
3901 },
3902 428usize,
3903 concat!(
3904 "Offset of field: ",
3905 stringify!(cudaDeviceProp),
3906 "::",
3907 stringify!(maxTexture2DMipmap)
3908 )
3909 );
3910 assert_eq!(
3911 unsafe {
3912 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DLinear as *const _ as usize
3913 },
3914 436usize,
3915 concat!(
3916 "Offset of field: ",
3917 stringify!(cudaDeviceProp),
3918 "::",
3919 stringify!(maxTexture2DLinear)
3920 )
3921 );
3922 assert_eq!(
3923 unsafe {
3924 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DGather as *const _ as usize
3925 },
3926 448usize,
3927 concat!(
3928 "Offset of field: ",
3929 stringify!(cudaDeviceProp),
3930 "::",
3931 stringify!(maxTexture2DGather)
3932 )
3933 );
3934 assert_eq!(
3935 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture3D as *const _ as usize },
3936 456usize,
3937 concat!(
3938 "Offset of field: ",
3939 stringify!(cudaDeviceProp),
3940 "::",
3941 stringify!(maxTexture3D)
3942 )
3943 );
3944 assert_eq!(
3945 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture3DAlt as *const _ as usize },
3946 468usize,
3947 concat!(
3948 "Offset of field: ",
3949 stringify!(cudaDeviceProp),
3950 "::",
3951 stringify!(maxTexture3DAlt)
3952 )
3953 );
3954 assert_eq!(
3955 unsafe {
3956 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTextureCubemap as *const _ as usize
3957 },
3958 480usize,
3959 concat!(
3960 "Offset of field: ",
3961 stringify!(cudaDeviceProp),
3962 "::",
3963 stringify!(maxTextureCubemap)
3964 )
3965 );
3966 assert_eq!(
3967 unsafe {
3968 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture1DLayered as *const _ as usize
3969 },
3970 484usize,
3971 concat!(
3972 "Offset of field: ",
3973 stringify!(cudaDeviceProp),
3974 "::",
3975 stringify!(maxTexture1DLayered)
3976 )
3977 );
3978 assert_eq!(
3979 unsafe {
3980 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTexture2DLayered as *const _ as usize
3981 },
3982 492usize,
3983 concat!(
3984 "Offset of field: ",
3985 stringify!(cudaDeviceProp),
3986 "::",
3987 stringify!(maxTexture2DLayered)
3988 )
3989 );
3990 assert_eq!(
3991 unsafe {
3992 &(*(::std::ptr::null::<cudaDeviceProp>())).maxTextureCubemapLayered as *const _ as usize
3993 },
3994 504usize,
3995 concat!(
3996 "Offset of field: ",
3997 stringify!(cudaDeviceProp),
3998 "::",
3999 stringify!(maxTextureCubemapLayered)
4000 )
4001 );
4002 assert_eq!(
4003 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface1D as *const _ as usize },
4004 512usize,
4005 concat!(
4006 "Offset of field: ",
4007 stringify!(cudaDeviceProp),
4008 "::",
4009 stringify!(maxSurface1D)
4010 )
4011 );
4012 assert_eq!(
4013 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface2D as *const _ as usize },
4014 516usize,
4015 concat!(
4016 "Offset of field: ",
4017 stringify!(cudaDeviceProp),
4018 "::",
4019 stringify!(maxSurface2D)
4020 )
4021 );
4022 assert_eq!(
4023 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface3D as *const _ as usize },
4024 524usize,
4025 concat!(
4026 "Offset of field: ",
4027 stringify!(cudaDeviceProp),
4028 "::",
4029 stringify!(maxSurface3D)
4030 )
4031 );
4032 assert_eq!(
4033 unsafe {
4034 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface1DLayered as *const _ as usize
4035 },
4036 536usize,
4037 concat!(
4038 "Offset of field: ",
4039 stringify!(cudaDeviceProp),
4040 "::",
4041 stringify!(maxSurface1DLayered)
4042 )
4043 );
4044 assert_eq!(
4045 unsafe {
4046 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurface2DLayered as *const _ as usize
4047 },
4048 544usize,
4049 concat!(
4050 "Offset of field: ",
4051 stringify!(cudaDeviceProp),
4052 "::",
4053 stringify!(maxSurface2DLayered)
4054 )
4055 );
4056 assert_eq!(
4057 unsafe {
4058 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurfaceCubemap as *const _ as usize
4059 },
4060 556usize,
4061 concat!(
4062 "Offset of field: ",
4063 stringify!(cudaDeviceProp),
4064 "::",
4065 stringify!(maxSurfaceCubemap)
4066 )
4067 );
4068 assert_eq!(
4069 unsafe {
4070 &(*(::std::ptr::null::<cudaDeviceProp>())).maxSurfaceCubemapLayered as *const _ as usize
4071 },
4072 560usize,
4073 concat!(
4074 "Offset of field: ",
4075 stringify!(cudaDeviceProp),
4076 "::",
4077 stringify!(maxSurfaceCubemapLayered)
4078 )
4079 );
4080 assert_eq!(
4081 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).surfaceAlignment as *const _ as usize },
4082 568usize,
4083 concat!(
4084 "Offset of field: ",
4085 stringify!(cudaDeviceProp),
4086 "::",
4087 stringify!(surfaceAlignment)
4088 )
4089 );
4090 assert_eq!(
4091 unsafe {
4092 &(*(::std::ptr::null::<cudaDeviceProp>())).concurrentKernels as *const _ as usize
4093 },
4094 576usize,
4095 concat!(
4096 "Offset of field: ",
4097 stringify!(cudaDeviceProp),
4098 "::",
4099 stringify!(concurrentKernels)
4100 )
4101 );
4102 assert_eq!(
4103 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).ECCEnabled as *const _ as usize },
4104 580usize,
4105 concat!(
4106 "Offset of field: ",
4107 stringify!(cudaDeviceProp),
4108 "::",
4109 stringify!(ECCEnabled)
4110 )
4111 );
4112 assert_eq!(
4113 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).pciBusID as *const _ as usize },
4114 584usize,
4115 concat!(
4116 "Offset of field: ",
4117 stringify!(cudaDeviceProp),
4118 "::",
4119 stringify!(pciBusID)
4120 )
4121 );
4122 assert_eq!(
4123 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).pciDeviceID as *const _ as usize },
4124 588usize,
4125 concat!(
4126 "Offset of field: ",
4127 stringify!(cudaDeviceProp),
4128 "::",
4129 stringify!(pciDeviceID)
4130 )
4131 );
4132 assert_eq!(
4133 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).pciDomainID as *const _ as usize },
4134 592usize,
4135 concat!(
4136 "Offset of field: ",
4137 stringify!(cudaDeviceProp),
4138 "::",
4139 stringify!(pciDomainID)
4140 )
4141 );
4142 assert_eq!(
4143 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).tccDriver as *const _ as usize },
4144 596usize,
4145 concat!(
4146 "Offset of field: ",
4147 stringify!(cudaDeviceProp),
4148 "::",
4149 stringify!(tccDriver)
4150 )
4151 );
4152 assert_eq!(
4153 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).asyncEngineCount as *const _ as usize },
4154 600usize,
4155 concat!(
4156 "Offset of field: ",
4157 stringify!(cudaDeviceProp),
4158 "::",
4159 stringify!(asyncEngineCount)
4160 )
4161 );
4162 assert_eq!(
4163 unsafe {
4164 &(*(::std::ptr::null::<cudaDeviceProp>())).unifiedAddressing as *const _ as usize
4165 },
4166 604usize,
4167 concat!(
4168 "Offset of field: ",
4169 stringify!(cudaDeviceProp),
4170 "::",
4171 stringify!(unifiedAddressing)
4172 )
4173 );
4174 assert_eq!(
4175 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).memoryClockRate as *const _ as usize },
4176 608usize,
4177 concat!(
4178 "Offset of field: ",
4179 stringify!(cudaDeviceProp),
4180 "::",
4181 stringify!(memoryClockRate)
4182 )
4183 );
4184 assert_eq!(
4185 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).memoryBusWidth as *const _ as usize },
4186 612usize,
4187 concat!(
4188 "Offset of field: ",
4189 stringify!(cudaDeviceProp),
4190 "::",
4191 stringify!(memoryBusWidth)
4192 )
4193 );
4194 assert_eq!(
4195 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).l2CacheSize as *const _ as usize },
4196 616usize,
4197 concat!(
4198 "Offset of field: ",
4199 stringify!(cudaDeviceProp),
4200 "::",
4201 stringify!(l2CacheSize)
4202 )
4203 );
4204 assert_eq!(
4205 unsafe {
4206 &(*(::std::ptr::null::<cudaDeviceProp>())).persistingL2CacheMaxSize as *const _ as usize
4207 },
4208 620usize,
4209 concat!(
4210 "Offset of field: ",
4211 stringify!(cudaDeviceProp),
4212 "::",
4213 stringify!(persistingL2CacheMaxSize)
4214 )
4215 );
4216 assert_eq!(
4217 unsafe {
4218 &(*(::std::ptr::null::<cudaDeviceProp>())).maxThreadsPerMultiProcessor as *const _
4219 as usize
4220 },
4221 624usize,
4222 concat!(
4223 "Offset of field: ",
4224 stringify!(cudaDeviceProp),
4225 "::",
4226 stringify!(maxThreadsPerMultiProcessor)
4227 )
4228 );
4229 assert_eq!(
4230 unsafe {
4231 &(*(::std::ptr::null::<cudaDeviceProp>())).streamPrioritiesSupported as *const _
4232 as usize
4233 },
4234 628usize,
4235 concat!(
4236 "Offset of field: ",
4237 stringify!(cudaDeviceProp),
4238 "::",
4239 stringify!(streamPrioritiesSupported)
4240 )
4241 );
4242 assert_eq!(
4243 unsafe {
4244 &(*(::std::ptr::null::<cudaDeviceProp>())).globalL1CacheSupported as *const _ as usize
4245 },
4246 632usize,
4247 concat!(
4248 "Offset of field: ",
4249 stringify!(cudaDeviceProp),
4250 "::",
4251 stringify!(globalL1CacheSupported)
4252 )
4253 );
4254 assert_eq!(
4255 unsafe {
4256 &(*(::std::ptr::null::<cudaDeviceProp>())).localL1CacheSupported as *const _ as usize
4257 },
4258 636usize,
4259 concat!(
4260 "Offset of field: ",
4261 stringify!(cudaDeviceProp),
4262 "::",
4263 stringify!(localL1CacheSupported)
4264 )
4265 );
4266 assert_eq!(
4267 unsafe {
4268 &(*(::std::ptr::null::<cudaDeviceProp>())).sharedMemPerMultiprocessor as *const _
4269 as usize
4270 },
4271 640usize,
4272 concat!(
4273 "Offset of field: ",
4274 stringify!(cudaDeviceProp),
4275 "::",
4276 stringify!(sharedMemPerMultiprocessor)
4277 )
4278 );
4279 assert_eq!(
4280 unsafe {
4281 &(*(::std::ptr::null::<cudaDeviceProp>())).regsPerMultiprocessor as *const _ as usize
4282 },
4283 648usize,
4284 concat!(
4285 "Offset of field: ",
4286 stringify!(cudaDeviceProp),
4287 "::",
4288 stringify!(regsPerMultiprocessor)
4289 )
4290 );
4291 assert_eq!(
4292 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).managedMemory as *const _ as usize },
4293 652usize,
4294 concat!(
4295 "Offset of field: ",
4296 stringify!(cudaDeviceProp),
4297 "::",
4298 stringify!(managedMemory)
4299 )
4300 );
4301 assert_eq!(
4302 unsafe { &(*(::std::ptr::null::<cudaDeviceProp>())).isMultiGpuBoard as *const _ as usize },
4303 656usize,
4304 concat!(
4305 "Offset of field: ",
4306 stringify!(cudaDeviceProp),
4307 "::",
4308 stringify!(isMultiGpuBoard)
4309 )
4310 );
4311 assert_eq!(
4312 unsafe {
4313 &(*(::std::ptr::null::<cudaDeviceProp>())).multiGpuBoardGroupID as *const _ as usize
4314 },
4315 660usize,
4316 concat!(
4317 "Offset of field: ",
4318 stringify!(cudaDeviceProp),
4319 "::",
4320 stringify!(multiGpuBoardGroupID)
4321 )
4322 );
4323 assert_eq!(
4324 unsafe {
4325 &(*(::std::ptr::null::<cudaDeviceProp>())).hostNativeAtomicSupported as *const _
4326 as usize
4327 },
4328 664usize,
4329 concat!(
4330 "Offset of field: ",
4331 stringify!(cudaDeviceProp),
4332 "::",
4333 stringify!(hostNativeAtomicSupported)
4334 )
4335 );
4336 assert_eq!(
4337 unsafe {
4338 &(*(::std::ptr::null::<cudaDeviceProp>())).singleToDoublePrecisionPerfRatio as *const _
4339 as usize
4340 },
4341 668usize,
4342 concat!(
4343 "Offset of field: ",
4344 stringify!(cudaDeviceProp),
4345 "::",
4346 stringify!(singleToDoublePrecisionPerfRatio)
4347 )
4348 );
4349 assert_eq!(
4350 unsafe {
4351 &(*(::std::ptr::null::<cudaDeviceProp>())).pageableMemoryAccess as *const _ as usize
4352 },
4353 672usize,
4354 concat!(
4355 "Offset of field: ",
4356 stringify!(cudaDeviceProp),
4357 "::",
4358 stringify!(pageableMemoryAccess)
4359 )
4360 );
4361 assert_eq!(
4362 unsafe {
4363 &(*(::std::ptr::null::<cudaDeviceProp>())).concurrentManagedAccess as *const _ as usize
4364 },
4365 676usize,
4366 concat!(
4367 "Offset of field: ",
4368 stringify!(cudaDeviceProp),
4369 "::",
4370 stringify!(concurrentManagedAccess)
4371 )
4372 );
4373 assert_eq!(
4374 unsafe {
4375 &(*(::std::ptr::null::<cudaDeviceProp>())).computePreemptionSupported as *const _
4376 as usize
4377 },
4378 680usize,
4379 concat!(
4380 "Offset of field: ",
4381 stringify!(cudaDeviceProp),
4382 "::",
4383 stringify!(computePreemptionSupported)
4384 )
4385 );
4386 assert_eq!(
4387 unsafe {
4388 &(*(::std::ptr::null::<cudaDeviceProp>())).canUseHostPointerForRegisteredMem as *const _
4389 as usize
4390 },
4391 684usize,
4392 concat!(
4393 "Offset of field: ",
4394 stringify!(cudaDeviceProp),
4395 "::",
4396 stringify!(canUseHostPointerForRegisteredMem)
4397 )
4398 );
4399 assert_eq!(
4400 unsafe {
4401 &(*(::std::ptr::null::<cudaDeviceProp>())).cooperativeLaunch as *const _ as usize
4402 },
4403 688usize,
4404 concat!(
4405 "Offset of field: ",
4406 stringify!(cudaDeviceProp),
4407 "::",
4408 stringify!(cooperativeLaunch)
4409 )
4410 );
4411 assert_eq!(
4412 unsafe {
4413 &(*(::std::ptr::null::<cudaDeviceProp>())).cooperativeMultiDeviceLaunch as *const _
4414 as usize
4415 },
4416 692usize,
4417 concat!(
4418 "Offset of field: ",
4419 stringify!(cudaDeviceProp),
4420 "::",
4421 stringify!(cooperativeMultiDeviceLaunch)
4422 )
4423 );
4424 assert_eq!(
4425 unsafe {
4426 &(*(::std::ptr::null::<cudaDeviceProp>())).sharedMemPerBlockOptin as *const _ as usize
4427 },
4428 696usize,
4429 concat!(
4430 "Offset of field: ",
4431 stringify!(cudaDeviceProp),
4432 "::",
4433 stringify!(sharedMemPerBlockOptin)
4434 )
4435 );
4436 assert_eq!(
4437 unsafe {
4438 &(*(::std::ptr::null::<cudaDeviceProp>())).pageableMemoryAccessUsesHostPageTables
4439 as *const _ as usize
4440 },
4441 704usize,
4442 concat!(
4443 "Offset of field: ",
4444 stringify!(cudaDeviceProp),
4445 "::",
4446 stringify!(pageableMemoryAccessUsesHostPageTables)
4447 )
4448 );
4449 assert_eq!(
4450 unsafe {
4451 &(*(::std::ptr::null::<cudaDeviceProp>())).directManagedMemAccessFromHost as *const _
4452 as usize
4453 },
4454 708usize,
4455 concat!(
4456 "Offset of field: ",
4457 stringify!(cudaDeviceProp),
4458 "::",
4459 stringify!(directManagedMemAccessFromHost)
4460 )
4461 );
4462 assert_eq!(
4463 unsafe {
4464 &(*(::std::ptr::null::<cudaDeviceProp>())).maxBlocksPerMultiProcessor as *const _
4465 as usize
4466 },
4467 712usize,
4468 concat!(
4469 "Offset of field: ",
4470 stringify!(cudaDeviceProp),
4471 "::",
4472 stringify!(maxBlocksPerMultiProcessor)
4473 )
4474 );
4475 assert_eq!(
4476 unsafe {
4477 &(*(::std::ptr::null::<cudaDeviceProp>())).accessPolicyMaxWindowSize as *const _
4478 as usize
4479 },
4480 716usize,
4481 concat!(
4482 "Offset of field: ",
4483 stringify!(cudaDeviceProp),
4484 "::",
4485 stringify!(accessPolicyMaxWindowSize)
4486 )
4487 );
4488 assert_eq!(
4489 unsafe {
4490 &(*(::std::ptr::null::<cudaDeviceProp>())).reservedSharedMemPerBlock as *const _
4491 as usize
4492 },
4493 720usize,
4494 concat!(
4495 "Offset of field: ",
4496 stringify!(cudaDeviceProp),
4497 "::",
4498 stringify!(reservedSharedMemPerBlock)
4499 )
4500 );
4501}
4502#[doc = " CUDA IPC event handle"]
4503#[repr(C)]
4504#[derive(Copy, Clone)]
4505pub struct cudaIpcEventHandle_st {
4506 pub reserved: [::libc::c_char; 64usize],
4507}
4508#[test]
4509fn bindgen_test_layout_cudaIpcEventHandle_st() {
4510 assert_eq!(
4511 ::std::mem::size_of::<cudaIpcEventHandle_st>(),
4512 64usize,
4513 concat!("Size of: ", stringify!(cudaIpcEventHandle_st))
4514 );
4515 assert_eq!(
4516 ::std::mem::align_of::<cudaIpcEventHandle_st>(),
4517 1usize,
4518 concat!("Alignment of ", stringify!(cudaIpcEventHandle_st))
4519 );
4520 assert_eq!(
4521 unsafe { &(*(::std::ptr::null::<cudaIpcEventHandle_st>())).reserved as *const _ as usize },
4522 0usize,
4523 concat!(
4524 "Offset of field: ",
4525 stringify!(cudaIpcEventHandle_st),
4526 "::",
4527 stringify!(reserved)
4528 )
4529 );
4530}
4531#[doc = " CUDA IPC event handle"]
4532pub type cudaIpcEventHandle_t = cudaIpcEventHandle_st;
4533#[doc = " CUDA IPC memory handle"]
4534#[repr(C)]
4535#[derive(Copy, Clone)]
4536pub struct cudaIpcMemHandle_st {
4537 pub reserved: [::libc::c_char; 64usize],
4538}
4539#[test]
4540fn bindgen_test_layout_cudaIpcMemHandle_st() {
4541 assert_eq!(
4542 ::std::mem::size_of::<cudaIpcMemHandle_st>(),
4543 64usize,
4544 concat!("Size of: ", stringify!(cudaIpcMemHandle_st))
4545 );
4546 assert_eq!(
4547 ::std::mem::align_of::<cudaIpcMemHandle_st>(),
4548 1usize,
4549 concat!("Alignment of ", stringify!(cudaIpcMemHandle_st))
4550 );
4551 assert_eq!(
4552 unsafe { &(*(::std::ptr::null::<cudaIpcMemHandle_st>())).reserved as *const _ as usize },
4553 0usize,
4554 concat!(
4555 "Offset of field: ",
4556 stringify!(cudaIpcMemHandle_st),
4557 "::",
4558 stringify!(reserved)
4559 )
4560 );
4561}
4562#[doc = " CUDA IPC memory handle"]
4563pub type cudaIpcMemHandle_t = cudaIpcMemHandle_st;
4564#[repr(u32)]
4565#[non_exhaustive]
4566#[doc = " External memory handle types"]
4567#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4568pub enum cudaExternalMemoryHandleType {
4569 #[doc = " Handle is an opaque file descriptor"]
4570 cudaExternalMemoryHandleTypeOpaqueFd = 1,
4571 #[doc = " Handle is an opaque shared NT handle"]
4572 cudaExternalMemoryHandleTypeOpaqueWin32 = 2,
4573 #[doc = " Handle is an opaque, globally shared handle"]
4574 cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3,
4575 #[doc = " Handle is a D3D12 heap object"]
4576 cudaExternalMemoryHandleTypeD3D12Heap = 4,
4577 #[doc = " Handle is a D3D12 committed resource"]
4578 cudaExternalMemoryHandleTypeD3D12Resource = 5,
4579 #[doc = " Handle is a shared NT handle to a D3D11 resource"]
4580 cudaExternalMemoryHandleTypeD3D11Resource = 6,
4581 #[doc = " Handle is a globally shared handle to a D3D11 resource"]
4582 cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7,
4583 #[doc = " Handle is an NvSciBuf object"]
4584 cudaExternalMemoryHandleTypeNvSciBuf = 8,
4585}
4586#[doc = " External memory handle descriptor"]
4587#[repr(C)]
4588#[derive(Copy, Clone)]
4589pub struct cudaExternalMemoryHandleDesc {
4590 #[doc = " Type of the handle"]
4591 pub type_: cudaExternalMemoryHandleType,
4592 pub handle: cudaExternalMemoryHandleDesc__bindgen_ty_1,
4593 #[doc = " Size of the memory allocation"]
4594 pub size: ::libc::c_ulonglong,
4595 #[doc = " Flags must either be zero or ::cudaExternalMemoryDedicated"]
4596 pub flags: ::libc::c_uint,
4597}
4598#[repr(C)]
4599#[derive(Copy, Clone)]
4600pub union cudaExternalMemoryHandleDesc__bindgen_ty_1 {
4601 #[doc = " File descriptor referencing the memory object. Valid"]
4602 #[doc = " when type is"]
4603 #[doc = " ::cudaExternalMemoryHandleTypeOpaqueFd"]
4604 pub fd: ::libc::c_int,
4605 pub win32: cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1,
4606 #[doc = " A handle representing NvSciBuf Object. Valid when type"]
4607 #[doc = " is ::cudaExternalMemoryHandleTypeNvSciBuf"]
4608 pub nvSciBufObject: *const ::libc::c_void,
4609}
4610#[doc = " Win32 handle referencing the semaphore object. Valid when"]
4611#[doc = " type is one of the following:"]
4612#[doc = " - ::cudaExternalMemoryHandleTypeOpaqueWin32"]
4613#[doc = " - ::cudaExternalMemoryHandleTypeOpaqueWin32Kmt"]
4614#[doc = " - ::cudaExternalMemoryHandleTypeD3D12Heap"]
4615#[doc = " - ::cudaExternalMemoryHandleTypeD3D12Resource"]
4616#[doc = " - ::cudaExternalMemoryHandleTypeD3D11Resource"]
4617#[doc = " - ::cudaExternalMemoryHandleTypeD3D11ResourceKmt"]
4618#[doc = " Exactly one of 'handle' and 'name' must be non-NULL. If"]
4619#[doc = " type is one of the following:"]
4620#[doc = " ::cudaExternalMemoryHandleTypeOpaqueWin32Kmt"]
4621#[doc = " ::cudaExternalMemoryHandleTypeD3D11ResourceKmt"]
4622#[doc = " then 'name' must be NULL."]
4623#[repr(C)]
4624#[derive(Debug, Copy, Clone)]
4625pub struct cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1 {
4626 #[doc = " Valid NT handle. Must be NULL if 'name' is non-NULL"]
4627 pub handle: *mut ::libc::c_void,
4628 #[doc = " Name of a valid memory object."]
4629 #[doc = " Must be NULL if 'handle' is non-NULL."]
4630 pub name: *const ::libc::c_void,
4631}
4632#[test]
4633fn bindgen_test_layout_cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1() {
4634 assert_eq!(
4635 ::std::mem::size_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
4636 16usize,
4637 concat!(
4638 "Size of: ",
4639 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1)
4640 )
4641 );
4642 assert_eq!(
4643 ::std::mem::align_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
4644 8usize,
4645 concat!(
4646 "Alignment of ",
4647 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1)
4648 )
4649 );
4650 assert_eq!(
4651 unsafe {
4652 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
4653 .handle as *const _ as usize
4654 },
4655 0usize,
4656 concat!(
4657 "Offset of field: ",
4658 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1),
4659 "::",
4660 stringify!(handle)
4661 )
4662 );
4663 assert_eq!(
4664 unsafe {
4665 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
4666 .name as *const _ as usize
4667 },
4668 8usize,
4669 concat!(
4670 "Offset of field: ",
4671 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1__bindgen_ty_1),
4672 "::",
4673 stringify!(name)
4674 )
4675 );
4676}
4677#[test]
4678fn bindgen_test_layout_cudaExternalMemoryHandleDesc__bindgen_ty_1() {
4679 assert_eq!(
4680 ::std::mem::size_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1>(),
4681 16usize,
4682 concat!(
4683 "Size of: ",
4684 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1)
4685 )
4686 );
4687 assert_eq!(
4688 ::std::mem::align_of::<cudaExternalMemoryHandleDesc__bindgen_ty_1>(),
4689 8usize,
4690 concat!(
4691 "Alignment of ",
4692 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1)
4693 )
4694 );
4695 assert_eq!(
4696 unsafe {
4697 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1>())).fd as *const _
4698 as usize
4699 },
4700 0usize,
4701 concat!(
4702 "Offset of field: ",
4703 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1),
4704 "::",
4705 stringify!(fd)
4706 )
4707 );
4708 assert_eq!(
4709 unsafe {
4710 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1>())).win32 as *const _
4711 as usize
4712 },
4713 0usize,
4714 concat!(
4715 "Offset of field: ",
4716 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1),
4717 "::",
4718 stringify!(win32)
4719 )
4720 );
4721 assert_eq!(
4722 unsafe {
4723 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc__bindgen_ty_1>())).nvSciBufObject
4724 as *const _ as usize
4725 },
4726 0usize,
4727 concat!(
4728 "Offset of field: ",
4729 stringify!(cudaExternalMemoryHandleDesc__bindgen_ty_1),
4730 "::",
4731 stringify!(nvSciBufObject)
4732 )
4733 );
4734}
4735#[test]
4736fn bindgen_test_layout_cudaExternalMemoryHandleDesc() {
4737 assert_eq!(
4738 ::std::mem::size_of::<cudaExternalMemoryHandleDesc>(),
4739 40usize,
4740 concat!("Size of: ", stringify!(cudaExternalMemoryHandleDesc))
4741 );
4742 assert_eq!(
4743 ::std::mem::align_of::<cudaExternalMemoryHandleDesc>(),
4744 8usize,
4745 concat!("Alignment of ", stringify!(cudaExternalMemoryHandleDesc))
4746 );
4747 assert_eq!(
4748 unsafe {
4749 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).type_ as *const _ as usize
4750 },
4751 0usize,
4752 concat!(
4753 "Offset of field: ",
4754 stringify!(cudaExternalMemoryHandleDesc),
4755 "::",
4756 stringify!(type_)
4757 )
4758 );
4759 assert_eq!(
4760 unsafe {
4761 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).handle as *const _ as usize
4762 },
4763 8usize,
4764 concat!(
4765 "Offset of field: ",
4766 stringify!(cudaExternalMemoryHandleDesc),
4767 "::",
4768 stringify!(handle)
4769 )
4770 );
4771 assert_eq!(
4772 unsafe {
4773 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).size as *const _ as usize
4774 },
4775 24usize,
4776 concat!(
4777 "Offset of field: ",
4778 stringify!(cudaExternalMemoryHandleDesc),
4779 "::",
4780 stringify!(size)
4781 )
4782 );
4783 assert_eq!(
4784 unsafe {
4785 &(*(::std::ptr::null::<cudaExternalMemoryHandleDesc>())).flags as *const _ as usize
4786 },
4787 32usize,
4788 concat!(
4789 "Offset of field: ",
4790 stringify!(cudaExternalMemoryHandleDesc),
4791 "::",
4792 stringify!(flags)
4793 )
4794 );
4795}
4796#[doc = " External memory buffer descriptor"]
4797#[repr(C)]
4798#[derive(Debug, Copy, Clone)]
4799pub struct cudaExternalMemoryBufferDesc {
4800 #[doc = " Offset into the memory object where the buffer's base is"]
4801 pub offset: ::libc::c_ulonglong,
4802 #[doc = " Size of the buffer"]
4803 pub size: ::libc::c_ulonglong,
4804 #[doc = " Flags reserved for future use. Must be zero."]
4805 pub flags: ::libc::c_uint,
4806}
4807#[test]
4808fn bindgen_test_layout_cudaExternalMemoryBufferDesc() {
4809 assert_eq!(
4810 ::std::mem::size_of::<cudaExternalMemoryBufferDesc>(),
4811 24usize,
4812 concat!("Size of: ", stringify!(cudaExternalMemoryBufferDesc))
4813 );
4814 assert_eq!(
4815 ::std::mem::align_of::<cudaExternalMemoryBufferDesc>(),
4816 8usize,
4817 concat!("Alignment of ", stringify!(cudaExternalMemoryBufferDesc))
4818 );
4819 assert_eq!(
4820 unsafe {
4821 &(*(::std::ptr::null::<cudaExternalMemoryBufferDesc>())).offset as *const _ as usize
4822 },
4823 0usize,
4824 concat!(
4825 "Offset of field: ",
4826 stringify!(cudaExternalMemoryBufferDesc),
4827 "::",
4828 stringify!(offset)
4829 )
4830 );
4831 assert_eq!(
4832 unsafe {
4833 &(*(::std::ptr::null::<cudaExternalMemoryBufferDesc>())).size as *const _ as usize
4834 },
4835 8usize,
4836 concat!(
4837 "Offset of field: ",
4838 stringify!(cudaExternalMemoryBufferDesc),
4839 "::",
4840 stringify!(size)
4841 )
4842 );
4843 assert_eq!(
4844 unsafe {
4845 &(*(::std::ptr::null::<cudaExternalMemoryBufferDesc>())).flags as *const _ as usize
4846 },
4847 16usize,
4848 concat!(
4849 "Offset of field: ",
4850 stringify!(cudaExternalMemoryBufferDesc),
4851 "::",
4852 stringify!(flags)
4853 )
4854 );
4855}
4856#[doc = " External memory mipmap descriptor"]
4857#[repr(C)]
4858#[derive(Debug, Copy, Clone)]
4859pub struct cudaExternalMemoryMipmappedArrayDesc {
4860 #[doc = " Offset into the memory object where the base level of the"]
4861 #[doc = " mipmap chain is."]
4862 pub offset: ::libc::c_ulonglong,
4863 #[doc = " Format of base level of the mipmap chain"]
4864 pub formatDesc: cudaChannelFormatDesc,
4865 #[doc = " Dimensions of base level of the mipmap chain"]
4866 pub extent: cudaExtent,
4867 #[doc = " Flags associated with CUDA mipmapped arrays."]
4868 #[doc = " See ::cudaMallocMipmappedArray"]
4869 pub flags: ::libc::c_uint,
4870 #[doc = " Total number of levels in the mipmap chain"]
4871 pub numLevels: ::libc::c_uint,
4872}
4873#[test]
4874fn bindgen_test_layout_cudaExternalMemoryMipmappedArrayDesc() {
4875 assert_eq!(
4876 ::std::mem::size_of::<cudaExternalMemoryMipmappedArrayDesc>(),
4877 64usize,
4878 concat!(
4879 "Size of: ",
4880 stringify!(cudaExternalMemoryMipmappedArrayDesc)
4881 )
4882 );
4883 assert_eq!(
4884 ::std::mem::align_of::<cudaExternalMemoryMipmappedArrayDesc>(),
4885 8usize,
4886 concat!(
4887 "Alignment of ",
4888 stringify!(cudaExternalMemoryMipmappedArrayDesc)
4889 )
4890 );
4891 assert_eq!(
4892 unsafe {
4893 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).offset as *const _
4894 as usize
4895 },
4896 0usize,
4897 concat!(
4898 "Offset of field: ",
4899 stringify!(cudaExternalMemoryMipmappedArrayDesc),
4900 "::",
4901 stringify!(offset)
4902 )
4903 );
4904 assert_eq!(
4905 unsafe {
4906 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).formatDesc as *const _
4907 as usize
4908 },
4909 8usize,
4910 concat!(
4911 "Offset of field: ",
4912 stringify!(cudaExternalMemoryMipmappedArrayDesc),
4913 "::",
4914 stringify!(formatDesc)
4915 )
4916 );
4917 assert_eq!(
4918 unsafe {
4919 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).extent as *const _
4920 as usize
4921 },
4922 32usize,
4923 concat!(
4924 "Offset of field: ",
4925 stringify!(cudaExternalMemoryMipmappedArrayDesc),
4926 "::",
4927 stringify!(extent)
4928 )
4929 );
4930 assert_eq!(
4931 unsafe {
4932 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).flags as *const _
4933 as usize
4934 },
4935 56usize,
4936 concat!(
4937 "Offset of field: ",
4938 stringify!(cudaExternalMemoryMipmappedArrayDesc),
4939 "::",
4940 stringify!(flags)
4941 )
4942 );
4943 assert_eq!(
4944 unsafe {
4945 &(*(::std::ptr::null::<cudaExternalMemoryMipmappedArrayDesc>())).numLevels as *const _
4946 as usize
4947 },
4948 60usize,
4949 concat!(
4950 "Offset of field: ",
4951 stringify!(cudaExternalMemoryMipmappedArrayDesc),
4952 "::",
4953 stringify!(numLevels)
4954 )
4955 );
4956}
4957#[repr(u32)]
4958#[non_exhaustive]
4959#[doc = " External semaphore handle types"]
4960#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4961pub enum cudaExternalSemaphoreHandleType {
4962 #[doc = " Handle is an opaque file descriptor"]
4963 cudaExternalSemaphoreHandleTypeOpaqueFd = 1,
4964 #[doc = " Handle is an opaque shared NT handle"]
4965 cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2,
4966 #[doc = " Handle is an opaque, globally shared handle"]
4967 cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,
4968 #[doc = " Handle is a shared NT handle referencing a D3D12 fence object"]
4969 cudaExternalSemaphoreHandleTypeD3D12Fence = 4,
4970 #[doc = " Handle is a shared NT handle referencing a D3D11 fence object"]
4971 cudaExternalSemaphoreHandleTypeD3D11Fence = 5,
4972 #[doc = " Opaque handle to NvSciSync Object"]
4973 cudaExternalSemaphoreHandleTypeNvSciSync = 6,
4974 #[doc = " Handle is a shared NT handle referencing a D3D11 keyed mutex object"]
4975 cudaExternalSemaphoreHandleTypeKeyedMutex = 7,
4976 #[doc = " Handle is a shared KMT handle referencing a D3D11 keyed mutex object"]
4977 cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8,
4978 #[doc = " Handle is an opaque handle file descriptor referencing a timeline semaphore"]
4979 cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,
4980 #[doc = " Handle is an opaque handle file descriptor referencing a timeline semaphore"]
4981 cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10,
4982}
4983#[doc = " External semaphore handle descriptor"]
4984#[repr(C)]
4985#[derive(Copy, Clone)]
4986pub struct cudaExternalSemaphoreHandleDesc {
4987 #[doc = " Type of the handle"]
4988 pub type_: cudaExternalSemaphoreHandleType,
4989 pub handle: cudaExternalSemaphoreHandleDesc__bindgen_ty_1,
4990 #[doc = " Flags reserved for the future. Must be zero."]
4991 pub flags: ::libc::c_uint,
4992}
4993#[repr(C)]
4994#[derive(Copy, Clone)]
4995pub union cudaExternalSemaphoreHandleDesc__bindgen_ty_1 {
4996 #[doc = " File descriptor referencing the semaphore object. Valid when"]
4997 #[doc = " type is one of the following:"]
4998 #[doc = " - ::cudaExternalSemaphoreHandleTypeOpaqueFd"]
4999 #[doc = " - ::cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd"]
5000 pub fd: ::libc::c_int,
5001 pub win32: cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1,
5002 #[doc = " Valid NvSciSyncObj. Must be non NULL"]
5003 pub nvSciSyncObj: *const ::libc::c_void,
5004}
5005#[doc = " Win32 handle referencing the semaphore object. Valid when"]
5006#[doc = " type is one of the following:"]
5007#[doc = " - ::cudaExternalSemaphoreHandleTypeOpaqueWin32"]
5008#[doc = " - ::cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt"]
5009#[doc = " - ::cudaExternalSemaphoreHandleTypeD3D12Fence"]
5010#[doc = " - ::cudaExternalSemaphoreHandleTypeD3D11Fence"]
5011#[doc = " - ::cudaExternalSemaphoreHandleTypeKeyedMutex"]
5012#[doc = " - ::cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32"]
5013#[doc = " Exactly one of 'handle' and 'name' must be non-NULL. If"]
5014#[doc = " type is one of the following:"]
5015#[doc = " ::cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt"]
5016#[doc = " ::cudaExternalSemaphoreHandleTypeKeyedMutexKmt"]
5017#[doc = " then 'name' must be NULL."]
5018#[repr(C)]
5019#[derive(Debug, Copy, Clone)]
5020pub struct cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1 {
5021 #[doc = " Valid NT handle. Must be NULL if 'name' is non-NULL"]
5022 pub handle: *mut ::libc::c_void,
5023 #[doc = " Name of a valid synchronization primitive."]
5024 #[doc = " Must be NULL if 'handle' is non-NULL."]
5025 pub name: *const ::libc::c_void,
5026}
5027#[test]
5028fn bindgen_test_layout_cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1() {
5029 assert_eq!(
5030 ::std::mem::size_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
5031 16usize,
5032 concat!(
5033 "Size of: ",
5034 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1)
5035 )
5036 );
5037 assert_eq!(
5038 ::std::mem::align_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>(),
5039 8usize,
5040 concat!(
5041 "Alignment of ",
5042 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1)
5043 )
5044 );
5045 assert_eq!(
5046 unsafe {
5047 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
5048 .handle as *const _ as usize
5049 },
5050 0usize,
5051 concat!(
5052 "Offset of field: ",
5053 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1),
5054 "::",
5055 stringify!(handle)
5056 )
5057 );
5058 assert_eq!(
5059 unsafe {
5060 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1>()))
5061 .name as *const _ as usize
5062 },
5063 8usize,
5064 concat!(
5065 "Offset of field: ",
5066 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1__bindgen_ty_1),
5067 "::",
5068 stringify!(name)
5069 )
5070 );
5071}
5072#[test]
5073fn bindgen_test_layout_cudaExternalSemaphoreHandleDesc__bindgen_ty_1() {
5074 assert_eq!(
5075 ::std::mem::size_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>(),
5076 16usize,
5077 concat!(
5078 "Size of: ",
5079 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1)
5080 )
5081 );
5082 assert_eq!(
5083 ::std::mem::align_of::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>(),
5084 8usize,
5085 concat!(
5086 "Alignment of ",
5087 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1)
5088 )
5089 );
5090 assert_eq!(
5091 unsafe {
5092 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>())).fd as *const _
5093 as usize
5094 },
5095 0usize,
5096 concat!(
5097 "Offset of field: ",
5098 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1),
5099 "::",
5100 stringify!(fd)
5101 )
5102 );
5103 assert_eq!(
5104 unsafe {
5105 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>())).win32
5106 as *const _ as usize
5107 },
5108 0usize,
5109 concat!(
5110 "Offset of field: ",
5111 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1),
5112 "::",
5113 stringify!(win32)
5114 )
5115 );
5116 assert_eq!(
5117 unsafe {
5118 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc__bindgen_ty_1>())).nvSciSyncObj
5119 as *const _ as usize
5120 },
5121 0usize,
5122 concat!(
5123 "Offset of field: ",
5124 stringify!(cudaExternalSemaphoreHandleDesc__bindgen_ty_1),
5125 "::",
5126 stringify!(nvSciSyncObj)
5127 )
5128 );
5129}
5130#[test]
5131fn bindgen_test_layout_cudaExternalSemaphoreHandleDesc() {
5132 assert_eq!(
5133 ::std::mem::size_of::<cudaExternalSemaphoreHandleDesc>(),
5134 32usize,
5135 concat!("Size of: ", stringify!(cudaExternalSemaphoreHandleDesc))
5136 );
5137 assert_eq!(
5138 ::std::mem::align_of::<cudaExternalSemaphoreHandleDesc>(),
5139 8usize,
5140 concat!("Alignment of ", stringify!(cudaExternalSemaphoreHandleDesc))
5141 );
5142 assert_eq!(
5143 unsafe {
5144 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc>())).type_ as *const _ as usize
5145 },
5146 0usize,
5147 concat!(
5148 "Offset of field: ",
5149 stringify!(cudaExternalSemaphoreHandleDesc),
5150 "::",
5151 stringify!(type_)
5152 )
5153 );
5154 assert_eq!(
5155 unsafe {
5156 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc>())).handle as *const _ as usize
5157 },
5158 8usize,
5159 concat!(
5160 "Offset of field: ",
5161 stringify!(cudaExternalSemaphoreHandleDesc),
5162 "::",
5163 stringify!(handle)
5164 )
5165 );
5166 assert_eq!(
5167 unsafe {
5168 &(*(::std::ptr::null::<cudaExternalSemaphoreHandleDesc>())).flags as *const _ as usize
5169 },
5170 24usize,
5171 concat!(
5172 "Offset of field: ",
5173 stringify!(cudaExternalSemaphoreHandleDesc),
5174 "::",
5175 stringify!(flags)
5176 )
5177 );
5178}
5179#[doc = " External semaphore signal parameters, compatible with driver type"]
5180#[repr(C)]
5181#[derive(Copy, Clone)]
5182pub struct cudaExternalSemaphoreSignalParams {
5183 pub params: cudaExternalSemaphoreSignalParams__bindgen_ty_1,
5184 #[doc = " Only when ::cudaExternalSemaphoreSignalParams is used to"]
5185 #[doc = " signal a ::cudaExternalSemaphore_t of type"]
5186 #[doc = " ::cudaExternalSemaphoreHandleTypeNvSciSync, the valid flag is"]
5187 #[doc = " ::cudaExternalSemaphoreSignalSkipNvSciBufMemSync: which indicates"]
5188 #[doc = " that while signaling the ::cudaExternalSemaphore_t, no memory"]
5189 #[doc = " synchronization operations should be performed for any external memory"]
5190 #[doc = " object imported as ::cudaExternalMemoryHandleTypeNvSciBuf."]
5191 #[doc = " For all other types of ::cudaExternalSemaphore_t, flags must be zero."]
5192 pub flags: ::libc::c_uint,
5193 pub reserved: [::libc::c_uint; 16usize],
5194}
5195#[repr(C)]
5196#[derive(Copy, Clone)]
5197pub struct cudaExternalSemaphoreSignalParams__bindgen_ty_1 {
5198 pub fence: cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1,
5199 pub nvSciSync: cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2,
5200 pub keyedMutex: cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3,
5201 pub reserved: [::libc::c_uint; 12usize],
5202}
5203#[doc = " Parameters for fence objects"]
5204#[repr(C)]
5205#[derive(Debug, Copy, Clone)]
5206pub struct cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1 {
5207 #[doc = " Value of fence to be signaled"]
5208 pub value: ::libc::c_ulonglong,
5209}
5210#[test]
5211fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1() {
5212 assert_eq!(
5213 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1>(),
5214 8usize,
5215 concat!(
5216 "Size of: ",
5217 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1)
5218 )
5219 );
5220 assert_eq!(
5221 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1>(),
5222 8usize,
5223 concat!(
5224 "Alignment of ",
5225 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1)
5226 )
5227 );
5228 assert_eq!(
5229 unsafe {
5230 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1>(
5231 )))
5232 .value as *const _ as usize
5233 },
5234 0usize,
5235 concat!(
5236 "Offset of field: ",
5237 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_1),
5238 "::",
5239 stringify!(value)
5240 )
5241 );
5242}
5243#[repr(C)]
5244#[derive(Copy, Clone)]
5245pub union cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2 {
5246 #[doc = " Pointer to NvSciSyncFence. Valid if ::cudaExternalSemaphoreHandleType"]
5247 #[doc = " is of type ::cudaExternalSemaphoreHandleTypeNvSciSync."]
5248 pub fence: *mut ::libc::c_void,
5249 pub reserved: ::libc::c_ulonglong,
5250}
5251#[test]
5252fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2() {
5253 assert_eq!(
5254 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(),
5255 8usize,
5256 concat!(
5257 "Size of: ",
5258 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2)
5259 )
5260 );
5261 assert_eq!(
5262 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(),
5263 8usize,
5264 concat!(
5265 "Alignment of ",
5266 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2)
5267 )
5268 );
5269 assert_eq!(
5270 unsafe {
5271 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(
5272 )))
5273 .fence as *const _ as usize
5274 },
5275 0usize,
5276 concat!(
5277 "Offset of field: ",
5278 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2),
5279 "::",
5280 stringify!(fence)
5281 )
5282 );
5283 assert_eq!(
5284 unsafe {
5285 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2>(
5286 )))
5287 .reserved as *const _ as usize
5288 },
5289 0usize,
5290 concat!(
5291 "Offset of field: ",
5292 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_2),
5293 "::",
5294 stringify!(reserved)
5295 )
5296 );
5297}
5298#[doc = " Parameters for keyed mutex objects"]
5299#[repr(C)]
5300#[derive(Debug, Copy, Clone)]
5301pub struct cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3 {
5302 pub key: ::libc::c_ulonglong,
5303}
5304#[test]
5305fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3() {
5306 assert_eq!(
5307 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3>(),
5308 8usize,
5309 concat!(
5310 "Size of: ",
5311 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3)
5312 )
5313 );
5314 assert_eq!(
5315 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3>(),
5316 8usize,
5317 concat!(
5318 "Alignment of ",
5319 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3)
5320 )
5321 );
5322 assert_eq!(
5323 unsafe {
5324 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3>(
5325 )))
5326 .key as *const _ as usize
5327 },
5328 0usize,
5329 concat!(
5330 "Offset of field: ",
5331 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1__bindgen_ty_3),
5332 "::",
5333 stringify!(key)
5334 )
5335 );
5336}
5337#[test]
5338fn bindgen_test_layout_cudaExternalSemaphoreSignalParams__bindgen_ty_1() {
5339 assert_eq!(
5340 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>(),
5341 72usize,
5342 concat!(
5343 "Size of: ",
5344 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1)
5345 )
5346 );
5347 assert_eq!(
5348 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>(),
5349 8usize,
5350 concat!(
5351 "Alignment of ",
5352 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1)
5353 )
5354 );
5355 assert_eq!(
5356 unsafe {
5357 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>())).fence
5358 as *const _ as usize
5359 },
5360 0usize,
5361 concat!(
5362 "Offset of field: ",
5363 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1),
5364 "::",
5365 stringify!(fence)
5366 )
5367 );
5368 assert_eq!(
5369 unsafe {
5370 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>())).nvSciSync
5371 as *const _ as usize
5372 },
5373 8usize,
5374 concat!(
5375 "Offset of field: ",
5376 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1),
5377 "::",
5378 stringify!(nvSciSync)
5379 )
5380 );
5381 assert_eq!(
5382 unsafe {
5383 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>())).keyedMutex
5384 as *const _ as usize
5385 },
5386 16usize,
5387 concat!(
5388 "Offset of field: ",
5389 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1),
5390 "::",
5391 stringify!(keyedMutex)
5392 )
5393 );
5394 assert_eq!(
5395 unsafe {
5396 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams__bindgen_ty_1>())).reserved
5397 as *const _ as usize
5398 },
5399 24usize,
5400 concat!(
5401 "Offset of field: ",
5402 stringify!(cudaExternalSemaphoreSignalParams__bindgen_ty_1),
5403 "::",
5404 stringify!(reserved)
5405 )
5406 );
5407}
5408#[test]
5409fn bindgen_test_layout_cudaExternalSemaphoreSignalParams() {
5410 assert_eq!(
5411 ::std::mem::size_of::<cudaExternalSemaphoreSignalParams>(),
5412 144usize,
5413 concat!("Size of: ", stringify!(cudaExternalSemaphoreSignalParams))
5414 );
5415 assert_eq!(
5416 ::std::mem::align_of::<cudaExternalSemaphoreSignalParams>(),
5417 8usize,
5418 concat!(
5419 "Alignment of ",
5420 stringify!(cudaExternalSemaphoreSignalParams)
5421 )
5422 );
5423 assert_eq!(
5424 unsafe {
5425 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams>())).params as *const _
5426 as usize
5427 },
5428 0usize,
5429 concat!(
5430 "Offset of field: ",
5431 stringify!(cudaExternalSemaphoreSignalParams),
5432 "::",
5433 stringify!(params)
5434 )
5435 );
5436 assert_eq!(
5437 unsafe {
5438 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams>())).flags as *const _ as usize
5439 },
5440 72usize,
5441 concat!(
5442 "Offset of field: ",
5443 stringify!(cudaExternalSemaphoreSignalParams),
5444 "::",
5445 stringify!(flags)
5446 )
5447 );
5448 assert_eq!(
5449 unsafe {
5450 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalParams>())).reserved as *const _
5451 as usize
5452 },
5453 76usize,
5454 concat!(
5455 "Offset of field: ",
5456 stringify!(cudaExternalSemaphoreSignalParams),
5457 "::",
5458 stringify!(reserved)
5459 )
5460 );
5461}
5462#[doc = " External semaphore wait parameters, compatible with driver type"]
5463#[repr(C)]
5464#[derive(Copy, Clone)]
5465pub struct cudaExternalSemaphoreWaitParams {
5466 pub params: cudaExternalSemaphoreWaitParams__bindgen_ty_1,
5467 #[doc = " Only when ::cudaExternalSemaphoreSignalParams is used to"]
5468 #[doc = " signal a ::cudaExternalSemaphore_t of type"]
5469 #[doc = " ::cudaExternalSemaphoreHandleTypeNvSciSync, the valid flag is"]
5470 #[doc = " ::cudaExternalSemaphoreSignalSkipNvSciBufMemSync: which indicates"]
5471 #[doc = " that while waiting for the ::cudaExternalSemaphore_t, no memory"]
5472 #[doc = " synchronization operations should be performed for any external memory"]
5473 #[doc = " object imported as ::cudaExternalMemoryHandleTypeNvSciBuf."]
5474 #[doc = " For all other types of ::cudaExternalSemaphore_t, flags must be zero."]
5475 pub flags: ::libc::c_uint,
5476 pub reserved: [::libc::c_uint; 16usize],
5477}
5478#[repr(C)]
5479#[derive(Copy, Clone)]
5480pub struct cudaExternalSemaphoreWaitParams__bindgen_ty_1 {
5481 pub fence: cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1,
5482 pub nvSciSync: cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2,
5483 pub keyedMutex: cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3,
5484 pub reserved: [::libc::c_uint; 10usize],
5485}
5486#[doc = " Parameters for fence objects"]
5487#[repr(C)]
5488#[derive(Debug, Copy, Clone)]
5489pub struct cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1 {
5490 #[doc = " Value of fence to be waited on"]
5491 pub value: ::libc::c_ulonglong,
5492}
5493#[test]
5494fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1() {
5495 assert_eq!(
5496 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1>(),
5497 8usize,
5498 concat!(
5499 "Size of: ",
5500 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1)
5501 )
5502 );
5503 assert_eq!(
5504 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1>(),
5505 8usize,
5506 concat!(
5507 "Alignment of ",
5508 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1)
5509 )
5510 );
5511 assert_eq!(
5512 unsafe {
5513 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1>()))
5514 .value as *const _ as usize
5515 },
5516 0usize,
5517 concat!(
5518 "Offset of field: ",
5519 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_1),
5520 "::",
5521 stringify!(value)
5522 )
5523 );
5524}
5525#[repr(C)]
5526#[derive(Copy, Clone)]
5527pub union cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2 {
5528 #[doc = " Pointer to NvSciSyncFence. Valid if ::cudaExternalSemaphoreHandleType"]
5529 #[doc = " is of type ::cudaExternalSemaphoreHandleTypeNvSciSync."]
5530 pub fence: *mut ::libc::c_void,
5531 pub reserved: ::libc::c_ulonglong,
5532}
5533#[test]
5534fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2() {
5535 assert_eq!(
5536 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>(),
5537 8usize,
5538 concat!(
5539 "Size of: ",
5540 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2)
5541 )
5542 );
5543 assert_eq!(
5544 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>(),
5545 8usize,
5546 concat!(
5547 "Alignment of ",
5548 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2)
5549 )
5550 );
5551 assert_eq!(
5552 unsafe {
5553 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>()))
5554 .fence as *const _ as usize
5555 },
5556 0usize,
5557 concat!(
5558 "Offset of field: ",
5559 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2),
5560 "::",
5561 stringify!(fence)
5562 )
5563 );
5564 assert_eq!(
5565 unsafe {
5566 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2>()))
5567 .reserved as *const _ as usize
5568 },
5569 0usize,
5570 concat!(
5571 "Offset of field: ",
5572 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_2),
5573 "::",
5574 stringify!(reserved)
5575 )
5576 );
5577}
5578#[doc = " Parameters for keyed mutex objects"]
5579#[repr(C)]
5580#[derive(Debug, Copy, Clone)]
5581pub struct cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3 {
5582 #[doc = " Value of key to acquire the mutex with"]
5583 pub key: ::libc::c_ulonglong,
5584 #[doc = " Timeout in milliseconds to wait to acquire the mutex"]
5585 pub timeoutMs: ::libc::c_uint,
5586}
5587#[test]
5588fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3() {
5589 assert_eq!(
5590 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>(),
5591 16usize,
5592 concat!(
5593 "Size of: ",
5594 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3)
5595 )
5596 );
5597 assert_eq!(
5598 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>(),
5599 8usize,
5600 concat!(
5601 "Alignment of ",
5602 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3)
5603 )
5604 );
5605 assert_eq!(
5606 unsafe {
5607 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>()))
5608 .key as *const _ as usize
5609 },
5610 0usize,
5611 concat!(
5612 "Offset of field: ",
5613 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3),
5614 "::",
5615 stringify!(key)
5616 )
5617 );
5618 assert_eq!(
5619 unsafe {
5620 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3>()))
5621 .timeoutMs as *const _ as usize
5622 },
5623 8usize,
5624 concat!(
5625 "Offset of field: ",
5626 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1__bindgen_ty_3),
5627 "::",
5628 stringify!(timeoutMs)
5629 )
5630 );
5631}
5632#[test]
5633fn bindgen_test_layout_cudaExternalSemaphoreWaitParams__bindgen_ty_1() {
5634 assert_eq!(
5635 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>(),
5636 72usize,
5637 concat!(
5638 "Size of: ",
5639 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1)
5640 )
5641 );
5642 assert_eq!(
5643 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>(),
5644 8usize,
5645 concat!(
5646 "Alignment of ",
5647 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1)
5648 )
5649 );
5650 assert_eq!(
5651 unsafe {
5652 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>())).fence
5653 as *const _ as usize
5654 },
5655 0usize,
5656 concat!(
5657 "Offset of field: ",
5658 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1),
5659 "::",
5660 stringify!(fence)
5661 )
5662 );
5663 assert_eq!(
5664 unsafe {
5665 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>())).nvSciSync
5666 as *const _ as usize
5667 },
5668 8usize,
5669 concat!(
5670 "Offset of field: ",
5671 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1),
5672 "::",
5673 stringify!(nvSciSync)
5674 )
5675 );
5676 assert_eq!(
5677 unsafe {
5678 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>())).keyedMutex
5679 as *const _ as usize
5680 },
5681 16usize,
5682 concat!(
5683 "Offset of field: ",
5684 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1),
5685 "::",
5686 stringify!(keyedMutex)
5687 )
5688 );
5689 assert_eq!(
5690 unsafe {
5691 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams__bindgen_ty_1>())).reserved
5692 as *const _ as usize
5693 },
5694 32usize,
5695 concat!(
5696 "Offset of field: ",
5697 stringify!(cudaExternalSemaphoreWaitParams__bindgen_ty_1),
5698 "::",
5699 stringify!(reserved)
5700 )
5701 );
5702}
5703#[test]
5704fn bindgen_test_layout_cudaExternalSemaphoreWaitParams() {
5705 assert_eq!(
5706 ::std::mem::size_of::<cudaExternalSemaphoreWaitParams>(),
5707 144usize,
5708 concat!("Size of: ", stringify!(cudaExternalSemaphoreWaitParams))
5709 );
5710 assert_eq!(
5711 ::std::mem::align_of::<cudaExternalSemaphoreWaitParams>(),
5712 8usize,
5713 concat!("Alignment of ", stringify!(cudaExternalSemaphoreWaitParams))
5714 );
5715 assert_eq!(
5716 unsafe {
5717 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams>())).params as *const _ as usize
5718 },
5719 0usize,
5720 concat!(
5721 "Offset of field: ",
5722 stringify!(cudaExternalSemaphoreWaitParams),
5723 "::",
5724 stringify!(params)
5725 )
5726 );
5727 assert_eq!(
5728 unsafe {
5729 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams>())).flags as *const _ as usize
5730 },
5731 72usize,
5732 concat!(
5733 "Offset of field: ",
5734 stringify!(cudaExternalSemaphoreWaitParams),
5735 "::",
5736 stringify!(flags)
5737 )
5738 );
5739 assert_eq!(
5740 unsafe {
5741 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitParams>())).reserved as *const _
5742 as usize
5743 },
5744 76usize,
5745 concat!(
5746 "Offset of field: ",
5747 stringify!(cudaExternalSemaphoreWaitParams),
5748 "::",
5749 stringify!(reserved)
5750 )
5751 );
5752}
5753#[doc = " CUDA Error types"]
5754pub use self::cudaError as cudaError_t;
5755#[repr(C)]
5756#[derive(Debug, Copy, Clone)]
5757pub struct CUstream_st {
5758 _unused: [u8; 0],
5759}
5760#[doc = " CUDA stream"]
5761pub type cudaStream_t = *mut CUstream_st;
5762#[repr(C)]
5763#[derive(Debug, Copy, Clone)]
5764pub struct CUevent_st {
5765 _unused: [u8; 0],
5766}
5767#[doc = " CUDA event types"]
5768pub type cudaEvent_t = *mut CUevent_st;
5769#[doc = " CUDA graphics resource types"]
5770pub type cudaGraphicsResource_t = *mut cudaGraphicsResource;
5771#[doc = " CUDA output file modes"]
5772pub use self::cudaOutputMode as cudaOutputMode_t;
5773#[repr(C)]
5774#[derive(Debug, Copy, Clone)]
5775pub struct CUexternalMemory_st {
5776 _unused: [u8; 0],
5777}
5778#[doc = " CUDA external memory"]
5779pub type cudaExternalMemory_t = *mut CUexternalMemory_st;
5780#[repr(C)]
5781#[derive(Debug, Copy, Clone)]
5782pub struct CUexternalSemaphore_st {
5783 _unused: [u8; 0],
5784}
5785#[doc = " CUDA external semaphore"]
5786pub type cudaExternalSemaphore_t = *mut CUexternalSemaphore_st;
5787#[repr(C)]
5788#[derive(Debug, Copy, Clone)]
5789pub struct CUgraph_st {
5790 _unused: [u8; 0],
5791}
5792#[doc = " CUDA graph"]
5793pub type cudaGraph_t = *mut CUgraph_st;
5794#[repr(C)]
5795#[derive(Debug, Copy, Clone)]
5796pub struct CUgraphNode_st {
5797 _unused: [u8; 0],
5798}
5799#[doc = " CUDA graph node."]
5800pub type cudaGraphNode_t = *mut CUgraphNode_st;
5801#[repr(C)]
5802#[derive(Debug, Copy, Clone)]
5803pub struct CUuserObject_st {
5804 _unused: [u8; 0],
5805}
5806#[doc = " CUDA user object for graphs"]
5807pub type cudaUserObject_t = *mut CUuserObject_st;
5808#[repr(C)]
5809#[derive(Debug, Copy, Clone)]
5810pub struct CUfunc_st {
5811 _unused: [u8; 0],
5812}
5813#[doc = " CUDA function"]
5814pub type cudaFunction_t = *mut CUfunc_st;
5815#[repr(C)]
5816#[derive(Debug, Copy, Clone)]
5817pub struct CUmemPoolHandle_st {
5818 _unused: [u8; 0],
5819}
5820#[doc = " CUDA memory pool"]
5821pub type cudaMemPool_t = *mut CUmemPoolHandle_st;
5822#[repr(u32)]
5823#[non_exhaustive]
5824#[doc = " CUDA cooperative group scope"]
5825#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5826pub enum cudaCGScope {
5827 #[doc = "< Invalid cooperative group scope"]
5828 cudaCGScopeInvalid = 0,
5829 #[doc = "< Scope represented by a grid_group"]
5830 cudaCGScopeGrid = 1,
5831 #[doc = "< Scope represented by a multi_grid_group"]
5832 cudaCGScopeMultiGrid = 2,
5833}
5834#[doc = " CUDA launch parameters"]
5835#[repr(C)]
5836#[derive(Debug, Copy, Clone)]
5837pub struct cudaLaunchParams {
5838 #[doc = "< Device function symbol"]
5839 pub func: *mut ::libc::c_void,
5840 #[doc = "< Grid dimentions"]
5841 pub gridDim: dim3,
5842 #[doc = "< Block dimentions"]
5843 pub blockDim: dim3,
5844 #[doc = "< Arguments"]
5845 pub args: *mut *mut ::libc::c_void,
5846 #[doc = "< Shared memory"]
5847 pub sharedMem: usize,
5848 #[doc = "< Stream identifier"]
5849 pub stream: cudaStream_t,
5850}
5851#[test]
5852fn bindgen_test_layout_cudaLaunchParams() {
5853 assert_eq!(
5854 ::std::mem::size_of::<cudaLaunchParams>(),
5855 56usize,
5856 concat!("Size of: ", stringify!(cudaLaunchParams))
5857 );
5858 assert_eq!(
5859 ::std::mem::align_of::<cudaLaunchParams>(),
5860 8usize,
5861 concat!("Alignment of ", stringify!(cudaLaunchParams))
5862 );
5863 assert_eq!(
5864 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).func as *const _ as usize },
5865 0usize,
5866 concat!(
5867 "Offset of field: ",
5868 stringify!(cudaLaunchParams),
5869 "::",
5870 stringify!(func)
5871 )
5872 );
5873 assert_eq!(
5874 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).gridDim as *const _ as usize },
5875 8usize,
5876 concat!(
5877 "Offset of field: ",
5878 stringify!(cudaLaunchParams),
5879 "::",
5880 stringify!(gridDim)
5881 )
5882 );
5883 assert_eq!(
5884 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).blockDim as *const _ as usize },
5885 20usize,
5886 concat!(
5887 "Offset of field: ",
5888 stringify!(cudaLaunchParams),
5889 "::",
5890 stringify!(blockDim)
5891 )
5892 );
5893 assert_eq!(
5894 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).args as *const _ as usize },
5895 32usize,
5896 concat!(
5897 "Offset of field: ",
5898 stringify!(cudaLaunchParams),
5899 "::",
5900 stringify!(args)
5901 )
5902 );
5903 assert_eq!(
5904 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).sharedMem as *const _ as usize },
5905 40usize,
5906 concat!(
5907 "Offset of field: ",
5908 stringify!(cudaLaunchParams),
5909 "::",
5910 stringify!(sharedMem)
5911 )
5912 );
5913 assert_eq!(
5914 unsafe { &(*(::std::ptr::null::<cudaLaunchParams>())).stream as *const _ as usize },
5915 48usize,
5916 concat!(
5917 "Offset of field: ",
5918 stringify!(cudaLaunchParams),
5919 "::",
5920 stringify!(stream)
5921 )
5922 );
5923}
5924#[doc = " CUDA GPU kernel node parameters"]
5925#[repr(C)]
5926#[derive(Debug, Copy, Clone)]
5927pub struct cudaKernelNodeParams {
5928 #[doc = "< Kernel to launch"]
5929 pub func: *mut ::libc::c_void,
5930 #[doc = "< Grid dimensions"]
5931 pub gridDim: dim3,
5932 #[doc = "< Block dimensions"]
5933 pub blockDim: dim3,
5934 #[doc = "< Dynamic shared-memory size per thread block in bytes"]
5935 pub sharedMemBytes: ::libc::c_uint,
5936 #[doc = "< Array of pointers to individual kernel arguments"]
5937 pub kernelParams: *mut *mut ::libc::c_void,
5938 #[doc = "< Pointer to kernel arguments in the \"extra\" format"]
5939 pub extra: *mut *mut ::libc::c_void,
5940}
5941#[test]
5942fn bindgen_test_layout_cudaKernelNodeParams() {
5943 assert_eq!(
5944 ::std::mem::size_of::<cudaKernelNodeParams>(),
5945 56usize,
5946 concat!("Size of: ", stringify!(cudaKernelNodeParams))
5947 );
5948 assert_eq!(
5949 ::std::mem::align_of::<cudaKernelNodeParams>(),
5950 8usize,
5951 concat!("Alignment of ", stringify!(cudaKernelNodeParams))
5952 );
5953 assert_eq!(
5954 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).func as *const _ as usize },
5955 0usize,
5956 concat!(
5957 "Offset of field: ",
5958 stringify!(cudaKernelNodeParams),
5959 "::",
5960 stringify!(func)
5961 )
5962 );
5963 assert_eq!(
5964 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).gridDim as *const _ as usize },
5965 8usize,
5966 concat!(
5967 "Offset of field: ",
5968 stringify!(cudaKernelNodeParams),
5969 "::",
5970 stringify!(gridDim)
5971 )
5972 );
5973 assert_eq!(
5974 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).blockDim as *const _ as usize },
5975 20usize,
5976 concat!(
5977 "Offset of field: ",
5978 stringify!(cudaKernelNodeParams),
5979 "::",
5980 stringify!(blockDim)
5981 )
5982 );
5983 assert_eq!(
5984 unsafe {
5985 &(*(::std::ptr::null::<cudaKernelNodeParams>())).sharedMemBytes as *const _ as usize
5986 },
5987 32usize,
5988 concat!(
5989 "Offset of field: ",
5990 stringify!(cudaKernelNodeParams),
5991 "::",
5992 stringify!(sharedMemBytes)
5993 )
5994 );
5995 assert_eq!(
5996 unsafe {
5997 &(*(::std::ptr::null::<cudaKernelNodeParams>())).kernelParams as *const _ as usize
5998 },
5999 40usize,
6000 concat!(
6001 "Offset of field: ",
6002 stringify!(cudaKernelNodeParams),
6003 "::",
6004 stringify!(kernelParams)
6005 )
6006 );
6007 assert_eq!(
6008 unsafe { &(*(::std::ptr::null::<cudaKernelNodeParams>())).extra as *const _ as usize },
6009 48usize,
6010 concat!(
6011 "Offset of field: ",
6012 stringify!(cudaKernelNodeParams),
6013 "::",
6014 stringify!(extra)
6015 )
6016 );
6017}
6018#[doc = " External semaphore signal node parameters"]
6019#[repr(C)]
6020#[derive(Debug, Copy, Clone)]
6021pub struct cudaExternalSemaphoreSignalNodeParams {
6022 #[doc = "< Array of external semaphore handles."]
6023 pub extSemArray: *mut cudaExternalSemaphore_t,
6024 #[doc = "< Array of external semaphore signal parameters."]
6025 pub paramsArray: *const cudaExternalSemaphoreSignalParams,
6026 #[doc = "< Number of handles and parameters supplied in extSemArray and paramsArray."]
6027 pub numExtSems: ::libc::c_uint,
6028}
6029#[test]
6030fn bindgen_test_layout_cudaExternalSemaphoreSignalNodeParams() {
6031 assert_eq!(
6032 ::std::mem::size_of::<cudaExternalSemaphoreSignalNodeParams>(),
6033 24usize,
6034 concat!(
6035 "Size of: ",
6036 stringify!(cudaExternalSemaphoreSignalNodeParams)
6037 )
6038 );
6039 assert_eq!(
6040 ::std::mem::align_of::<cudaExternalSemaphoreSignalNodeParams>(),
6041 8usize,
6042 concat!(
6043 "Alignment of ",
6044 stringify!(cudaExternalSemaphoreSignalNodeParams)
6045 )
6046 );
6047 assert_eq!(
6048 unsafe {
6049 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalNodeParams>())).extSemArray
6050 as *const _ as usize
6051 },
6052 0usize,
6053 concat!(
6054 "Offset of field: ",
6055 stringify!(cudaExternalSemaphoreSignalNodeParams),
6056 "::",
6057 stringify!(extSemArray)
6058 )
6059 );
6060 assert_eq!(
6061 unsafe {
6062 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalNodeParams>())).paramsArray
6063 as *const _ as usize
6064 },
6065 8usize,
6066 concat!(
6067 "Offset of field: ",
6068 stringify!(cudaExternalSemaphoreSignalNodeParams),
6069 "::",
6070 stringify!(paramsArray)
6071 )
6072 );
6073 assert_eq!(
6074 unsafe {
6075 &(*(::std::ptr::null::<cudaExternalSemaphoreSignalNodeParams>())).numExtSems as *const _
6076 as usize
6077 },
6078 16usize,
6079 concat!(
6080 "Offset of field: ",
6081 stringify!(cudaExternalSemaphoreSignalNodeParams),
6082 "::",
6083 stringify!(numExtSems)
6084 )
6085 );
6086}
6087#[doc = " External semaphore wait node parameters"]
6088#[repr(C)]
6089#[derive(Debug, Copy, Clone)]
6090pub struct cudaExternalSemaphoreWaitNodeParams {
6091 #[doc = "< Array of external semaphore handles."]
6092 pub extSemArray: *mut cudaExternalSemaphore_t,
6093 #[doc = "< Array of external semaphore wait parameters."]
6094 pub paramsArray: *const cudaExternalSemaphoreWaitParams,
6095 #[doc = "< Number of handles and parameters supplied in extSemArray and paramsArray."]
6096 pub numExtSems: ::libc::c_uint,
6097}
6098#[test]
6099fn bindgen_test_layout_cudaExternalSemaphoreWaitNodeParams() {
6100 assert_eq!(
6101 ::std::mem::size_of::<cudaExternalSemaphoreWaitNodeParams>(),
6102 24usize,
6103 concat!("Size of: ", stringify!(cudaExternalSemaphoreWaitNodeParams))
6104 );
6105 assert_eq!(
6106 ::std::mem::align_of::<cudaExternalSemaphoreWaitNodeParams>(),
6107 8usize,
6108 concat!(
6109 "Alignment of ",
6110 stringify!(cudaExternalSemaphoreWaitNodeParams)
6111 )
6112 );
6113 assert_eq!(
6114 unsafe {
6115 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitNodeParams>())).extSemArray as *const _
6116 as usize
6117 },
6118 0usize,
6119 concat!(
6120 "Offset of field: ",
6121 stringify!(cudaExternalSemaphoreWaitNodeParams),
6122 "::",
6123 stringify!(extSemArray)
6124 )
6125 );
6126 assert_eq!(
6127 unsafe {
6128 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitNodeParams>())).paramsArray as *const _
6129 as usize
6130 },
6131 8usize,
6132 concat!(
6133 "Offset of field: ",
6134 stringify!(cudaExternalSemaphoreWaitNodeParams),
6135 "::",
6136 stringify!(paramsArray)
6137 )
6138 );
6139 assert_eq!(
6140 unsafe {
6141 &(*(::std::ptr::null::<cudaExternalSemaphoreWaitNodeParams>())).numExtSems as *const _
6142 as usize
6143 },
6144 16usize,
6145 concat!(
6146 "Offset of field: ",
6147 stringify!(cudaExternalSemaphoreWaitNodeParams),
6148 "::",
6149 stringify!(numExtSems)
6150 )
6151 );
6152}
6153#[repr(u32)]
6154#[non_exhaustive]
6155#[doc = " CUDA Graph node types"]
6156#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6157pub enum cudaGraphNodeType {
6158 #[doc = "< GPU kernel node"]
6159 cudaGraphNodeTypeKernel = 0,
6160 #[doc = "< Memcpy node"]
6161 cudaGraphNodeTypeMemcpy = 1,
6162 #[doc = "< Memset node"]
6163 cudaGraphNodeTypeMemset = 2,
6164 #[doc = "< Host (executable) node"]
6165 cudaGraphNodeTypeHost = 3,
6166 #[doc = "< Node which executes an embedded graph"]
6167 cudaGraphNodeTypeGraph = 4,
6168 #[doc = "< Empty (no-op) node"]
6169 cudaGraphNodeTypeEmpty = 5,
6170 #[doc = "< External event wait node"]
6171 cudaGraphNodeTypeWaitEvent = 6,
6172 #[doc = "< External event record node"]
6173 cudaGraphNodeTypeEventRecord = 7,
6174 #[doc = "< External semaphore signal node"]
6175 cudaGraphNodeTypeExtSemaphoreSignal = 8,
6176 #[doc = "< External semaphore wait node"]
6177 cudaGraphNodeTypeExtSemaphoreWait = 9,
6178 #[doc = "< Memory allocation node"]
6179 cudaGraphNodeTypeMemAlloc = 10,
6180 #[doc = "< Memory free node"]
6181 cudaGraphNodeTypeMemFree = 11,
6182 cudaGraphNodeTypeCount = 12,
6183}
6184#[repr(C)]
6185#[derive(Debug, Copy, Clone)]
6186pub struct CUgraphExec_st {
6187 _unused: [u8; 0],
6188}
6189#[doc = " CUDA executable (launchable) graph"]
6190pub type cudaGraphExec_t = *mut CUgraphExec_st;
6191#[repr(u32)]
6192#[non_exhaustive]
6193#[doc = " CUDA Graph Update error types"]
6194#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6195pub enum cudaGraphExecUpdateResult {
6196 #[doc = "< The update succeeded"]
6197 cudaGraphExecUpdateSuccess = 0,
6198 #[doc = "< The update failed for an unexpected reason which is described in the return value of the function"]
6199 cudaGraphExecUpdateError = 1,
6200 #[doc = "< The update failed because the topology changed"]
6201 cudaGraphExecUpdateErrorTopologyChanged = 2,
6202 #[doc = "< The update failed because a node type changed"]
6203 cudaGraphExecUpdateErrorNodeTypeChanged = 3,
6204 #[doc = "< The update failed because the function of a kernel node changed (CUDA driver < 11.2)"]
6205 cudaGraphExecUpdateErrorFunctionChanged = 4,
6206 #[doc = "< The update failed because the parameters changed in a way that is not supported"]
6207 cudaGraphExecUpdateErrorParametersChanged = 5,
6208 #[doc = "< The update failed because something about the node is not supported"]
6209 cudaGraphExecUpdateErrorNotSupported = 6,
6210 #[doc = "< The update failed because the function of a kernel node changed in an unsupported way"]
6211 cudaGraphExecUpdateErrorUnsupportedFunctionChange = 7,
6212}
6213#[repr(u32)]
6214#[non_exhaustive]
6215#[doc = " Flags to specify search options to be used with ::cudaGetDriverEntryPoint"]
6216#[doc = " For more details see ::cuGetProcAddress"]
6217#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6218pub enum cudaGetDriverEntryPointFlags {
6219 #[doc = "< Default search mode for driver symbols."]
6220 cudaEnableDefault = 0,
6221 #[doc = "< Search for legacy versions of driver symbols."]
6222 cudaEnableLegacyStream = 1,
6223 #[doc = "< Search for per-thread versions of driver symbols."]
6224 cudaEnablePerThreadDefaultStream = 2,
6225}
6226#[repr(u32)]
6227#[non_exhaustive]
6228#[doc = " CUDA Graph debug write options"]
6229#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6230pub enum cudaGraphDebugDotFlags {
6231 cudaGraphDebugDotFlagsVerbose = 1,
6232 #[doc = " Output all debug data as if every debug flag is enabled"]
6233 cudaGraphDebugDotFlagsKernelNodeParams = 4,
6234 #[doc = " Adds cudaKernelNodeParams to output"]
6235 cudaGraphDebugDotFlagsMemcpyNodeParams = 8,
6236 #[doc = " Adds cudaMemcpy3DParms to output"]
6237 cudaGraphDebugDotFlagsMemsetNodeParams = 16,
6238 #[doc = " Adds cudaMemsetParams to output"]
6239 cudaGraphDebugDotFlagsHostNodeParams = 32,
6240 #[doc = " Adds cudaHostNodeParams to output"]
6241 cudaGraphDebugDotFlagsEventNodeParams = 64,
6242 #[doc = " Adds cudaEvent_t handle from record and wait nodes to output"]
6243 cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 128,
6244 #[doc = " Adds cudaExternalSemaphoreSignalNodeParams values to output"]
6245 cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 256,
6246 #[doc = " Adds cudaExternalSemaphoreWaitNodeParams to output"]
6247 cudaGraphDebugDotFlagsKernelNodeAttributes = 512,
6248 #[doc = " Adds cudaKernelNodeAttrID values to output"]
6249 cudaGraphDebugDotFlagsHandles = 1024,
6250}
6251#[repr(u32)]
6252#[non_exhaustive]
6253#[doc = " Flags for instantiating a graph"]
6254#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6255pub enum cudaGraphInstantiateFlags {
6256 #[doc = "< Automatically free memory allocated in a graph before relaunching."]
6257 cudaGraphInstantiateFlagAutoFreeOnLaunch = 1,
6258}
6259pub type cuFloatComplex = float2;
6260pub type cuDoubleComplex = double2;
6261pub type cuComplex = cuFloatComplex;
6262#[repr(u32)]
6263#[non_exhaustive]
6264#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6265pub enum cudaDataType_t {
6266 CUDA_R_16F = 2,
6267 CUDA_C_16F = 6,
6268 CUDA_R_16BF = 14,
6269 CUDA_C_16BF = 15,
6270 CUDA_R_32F = 0,
6271 CUDA_C_32F = 4,
6272 CUDA_R_64F = 1,
6273 CUDA_C_64F = 5,
6274 CUDA_R_4I = 16,
6275 CUDA_C_4I = 17,
6276 CUDA_R_4U = 18,
6277 CUDA_C_4U = 19,
6278 CUDA_R_8I = 3,
6279 CUDA_C_8I = 7,
6280 CUDA_R_8U = 8,
6281 CUDA_C_8U = 9,
6282 CUDA_R_16I = 20,
6283 CUDA_C_16I = 21,
6284 CUDA_R_16U = 22,
6285 CUDA_C_16U = 23,
6286 CUDA_R_32I = 10,
6287 CUDA_C_32I = 11,
6288 CUDA_R_32U = 12,
6289 CUDA_C_32U = 13,
6290 CUDA_R_64I = 24,
6291 CUDA_C_64I = 25,
6292 CUDA_R_64U = 26,
6293 CUDA_C_64U = 27,
6294}
6295pub use self::cudaDataType_t as cudaDataType;
6296pub const libraryPropertyType_t_MAJOR_VERSION: libraryPropertyType_t = 0;
6297pub const libraryPropertyType_t_MINOR_VERSION: libraryPropertyType_t = 1;
6298pub const libraryPropertyType_t_PATCH_LEVEL: libraryPropertyType_t = 2;
6299pub type libraryPropertyType_t = ::libc::c_uint;
6300pub use self::libraryPropertyType_t as libraryPropertyType;
6301#[repr(u32)]
6302#[non_exhaustive]
6303#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6304pub enum cublasStatus_t {
6305 CUBLAS_STATUS_SUCCESS = 0,
6306 CUBLAS_STATUS_NOT_INITIALIZED = 1,
6307 CUBLAS_STATUS_ALLOC_FAILED = 3,
6308 CUBLAS_STATUS_INVALID_VALUE = 7,
6309 CUBLAS_STATUS_ARCH_MISMATCH = 8,
6310 CUBLAS_STATUS_MAPPING_ERROR = 11,
6311 CUBLAS_STATUS_EXECUTION_FAILED = 13,
6312 CUBLAS_STATUS_INTERNAL_ERROR = 14,
6313 CUBLAS_STATUS_NOT_SUPPORTED = 15,
6314 CUBLAS_STATUS_LICENSE_ERROR = 16,
6315}
6316#[repr(u32)]
6317#[non_exhaustive]
6318#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6319pub enum cublasFillMode_t {
6320 CUBLAS_FILL_MODE_LOWER = 0,
6321 CUBLAS_FILL_MODE_UPPER = 1,
6322 CUBLAS_FILL_MODE_FULL = 2,
6323}
6324#[repr(u32)]
6325#[non_exhaustive]
6326#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6327pub enum cublasDiagType_t {
6328 CUBLAS_DIAG_NON_UNIT = 0,
6329 CUBLAS_DIAG_UNIT = 1,
6330}
6331#[repr(u32)]
6332#[non_exhaustive]
6333#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6334pub enum cublasSideMode_t {
6335 CUBLAS_SIDE_LEFT = 0,
6336 CUBLAS_SIDE_RIGHT = 1,
6337}
6338impl cublasOperation_t {
6339 pub const CUBLAS_OP_HERMITAN: cublasOperation_t = cublasOperation_t::CUBLAS_OP_C;
6340}
6341#[repr(u32)]
6342#[non_exhaustive]
6343#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6344pub enum cublasOperation_t {
6345 CUBLAS_OP_N = 0,
6346 CUBLAS_OP_T = 1,
6347 CUBLAS_OP_C = 2,
6348 CUBLAS_OP_CONJG = 3,
6349}
6350#[repr(u32)]
6351#[non_exhaustive]
6352#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6353pub enum cublasPointerMode_t {
6354 CUBLAS_POINTER_MODE_HOST = 0,
6355 CUBLAS_POINTER_MODE_DEVICE = 1,
6356}
6357#[repr(u32)]
6358#[non_exhaustive]
6359#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6360pub enum cublasAtomicsMode_t {
6361 CUBLAS_ATOMICS_NOT_ALLOWED = 0,
6362 CUBLAS_ATOMICS_ALLOWED = 1,
6363}
6364impl cublasGemmAlgo_t {
6365 pub const CUBLAS_GEMM_DEFAULT: cublasGemmAlgo_t = cublasGemmAlgo_t::CUBLAS_GEMM_DFALT;
6366}
6367impl cublasGemmAlgo_t {
6368 pub const CUBLAS_GEMM_DFALT_TENSOR_OP: cublasGemmAlgo_t =
6369 cublasGemmAlgo_t::CUBLAS_GEMM_DEFAULT_TENSOR_OP;
6370}
6371#[repr(i32)]
6372#[non_exhaustive]
6373#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6374pub enum cublasGemmAlgo_t {
6375 CUBLAS_GEMM_DFALT = -1,
6376 CUBLAS_GEMM_ALGO0 = 0,
6377 CUBLAS_GEMM_ALGO1 = 1,
6378 CUBLAS_GEMM_ALGO2 = 2,
6379 CUBLAS_GEMM_ALGO3 = 3,
6380 CUBLAS_GEMM_ALGO4 = 4,
6381 CUBLAS_GEMM_ALGO5 = 5,
6382 CUBLAS_GEMM_ALGO6 = 6,
6383 CUBLAS_GEMM_ALGO7 = 7,
6384 CUBLAS_GEMM_ALGO8 = 8,
6385 CUBLAS_GEMM_ALGO9 = 9,
6386 CUBLAS_GEMM_ALGO10 = 10,
6387 CUBLAS_GEMM_ALGO11 = 11,
6388 CUBLAS_GEMM_ALGO12 = 12,
6389 CUBLAS_GEMM_ALGO13 = 13,
6390 CUBLAS_GEMM_ALGO14 = 14,
6391 CUBLAS_GEMM_ALGO15 = 15,
6392 CUBLAS_GEMM_ALGO16 = 16,
6393 CUBLAS_GEMM_ALGO17 = 17,
6394 CUBLAS_GEMM_ALGO18 = 18,
6395 CUBLAS_GEMM_ALGO19 = 19,
6396 CUBLAS_GEMM_ALGO20 = 20,
6397 CUBLAS_GEMM_ALGO21 = 21,
6398 CUBLAS_GEMM_ALGO22 = 22,
6399 CUBLAS_GEMM_ALGO23 = 23,
6400 CUBLAS_GEMM_DEFAULT_TENSOR_OP = 99,
6401 CUBLAS_GEMM_ALGO0_TENSOR_OP = 100,
6402 CUBLAS_GEMM_ALGO1_TENSOR_OP = 101,
6403 CUBLAS_GEMM_ALGO2_TENSOR_OP = 102,
6404 CUBLAS_GEMM_ALGO3_TENSOR_OP = 103,
6405 CUBLAS_GEMM_ALGO4_TENSOR_OP = 104,
6406 CUBLAS_GEMM_ALGO5_TENSOR_OP = 105,
6407 CUBLAS_GEMM_ALGO6_TENSOR_OP = 106,
6408 CUBLAS_GEMM_ALGO7_TENSOR_OP = 107,
6409 CUBLAS_GEMM_ALGO8_TENSOR_OP = 108,
6410 CUBLAS_GEMM_ALGO9_TENSOR_OP = 109,
6411 CUBLAS_GEMM_ALGO10_TENSOR_OP = 110,
6412 CUBLAS_GEMM_ALGO11_TENSOR_OP = 111,
6413 CUBLAS_GEMM_ALGO12_TENSOR_OP = 112,
6414 CUBLAS_GEMM_ALGO13_TENSOR_OP = 113,
6415 CUBLAS_GEMM_ALGO14_TENSOR_OP = 114,
6416 CUBLAS_GEMM_ALGO15_TENSOR_OP = 115,
6417}
6418#[repr(u32)]
6419#[non_exhaustive]
6420#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6421pub enum cublasMath_t {
6422 CUBLAS_DEFAULT_MATH = 0,
6423 CUBLAS_TENSOR_OP_MATH = 1,
6424 CUBLAS_PEDANTIC_MATH = 2,
6425 CUBLAS_TF32_TENSOR_OP_MATH = 3,
6426 CUBLAS_MATH_DISALLOW_REDUCED_PRECISION_REDUCTION = 16,
6427}
6428pub use self::cudaDataType as cublasDataType_t;
6429#[repr(u32)]
6430#[non_exhaustive]
6431#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6432pub enum cublasComputeType_t {
6433 CUBLAS_COMPUTE_16F = 64,
6434 CUBLAS_COMPUTE_16F_PEDANTIC = 65,
6435 CUBLAS_COMPUTE_32F = 68,
6436 CUBLAS_COMPUTE_32F_PEDANTIC = 69,
6437 CUBLAS_COMPUTE_32F_FAST_16F = 74,
6438 CUBLAS_COMPUTE_32F_FAST_16BF = 75,
6439 CUBLAS_COMPUTE_32F_FAST_TF32 = 77,
6440 CUBLAS_COMPUTE_64F = 70,
6441 CUBLAS_COMPUTE_64F_PEDANTIC = 71,
6442 CUBLAS_COMPUTE_32I = 72,
6443 CUBLAS_COMPUTE_32I_PEDANTIC = 73,
6444}
6445#[repr(C)]
6446#[derive(Debug, Copy, Clone)]
6447pub struct cublasContext {
6448 _unused: [u8; 0],
6449}
6450pub type cublasHandle_t = *mut cublasContext;
6451extern "C" {
6452 pub fn cublasCreate_v2(handle: *mut cublasHandle_t) -> cublasStatus_t;
6453}
6454extern "C" {
6455 pub fn cublasDestroy_v2(handle: cublasHandle_t) -> cublasStatus_t;
6456}
6457extern "C" {
6458 pub fn cublasGetVersion_v2(
6459 handle: cublasHandle_t,
6460 version: *mut ::libc::c_int,
6461 ) -> cublasStatus_t;
6462}
6463extern "C" {
6464 pub fn cublasGetProperty(
6465 type_: libraryPropertyType,
6466 value: *mut ::libc::c_int,
6467 ) -> cublasStatus_t;
6468}
6469extern "C" {
6470 pub fn cublasGetCudartVersion() -> usize;
6471}
6472extern "C" {
6473 pub fn cublasSetWorkspace_v2(
6474 handle: cublasHandle_t,
6475 workspace: *mut ::libc::c_void,
6476 workspaceSizeInBytes: usize,
6477 ) -> cublasStatus_t;
6478}
6479extern "C" {
6480 pub fn cublasSetStream_v2(handle: cublasHandle_t, streamId: cudaStream_t) -> cublasStatus_t;
6481}
6482extern "C" {
6483 pub fn cublasGetStream_v2(
6484 handle: cublasHandle_t,
6485 streamId: *mut cudaStream_t,
6486 ) -> cublasStatus_t;
6487}
6488extern "C" {
6489 pub fn cublasGetPointerMode_v2(
6490 handle: cublasHandle_t,
6491 mode: *mut cublasPointerMode_t,
6492 ) -> cublasStatus_t;
6493}
6494extern "C" {
6495 pub fn cublasSetPointerMode_v2(
6496 handle: cublasHandle_t,
6497 mode: cublasPointerMode_t,
6498 ) -> cublasStatus_t;
6499}
6500extern "C" {
6501 pub fn cublasGetAtomicsMode(
6502 handle: cublasHandle_t,
6503 mode: *mut cublasAtomicsMode_t,
6504 ) -> cublasStatus_t;
6505}
6506extern "C" {
6507 pub fn cublasSetAtomicsMode(
6508 handle: cublasHandle_t,
6509 mode: cublasAtomicsMode_t,
6510 ) -> cublasStatus_t;
6511}
6512extern "C" {
6513 pub fn cublasGetMathMode(handle: cublasHandle_t, mode: *mut cublasMath_t) -> cublasStatus_t;
6514}
6515extern "C" {
6516 pub fn cublasSetMathMode(handle: cublasHandle_t, mode: cublasMath_t) -> cublasStatus_t;
6517}
6518extern "C" {
6519 pub fn cublasGetSmCountTarget(
6520 handle: cublasHandle_t,
6521 smCountTarget: *mut ::libc::c_int,
6522 ) -> cublasStatus_t;
6523}
6524extern "C" {
6525 pub fn cublasSetSmCountTarget(
6526 handle: cublasHandle_t,
6527 smCountTarget: ::libc::c_int,
6528 ) -> cublasStatus_t;
6529}
6530pub type cublasLogCallback =
6531 ::std::option::Option<unsafe extern "C" fn(msg: *const ::libc::c_char)>;
6532extern "C" {
6533 pub fn cublasLoggerConfigure(
6534 logIsOn: ::libc::c_int,
6535 logToStdOut: ::libc::c_int,
6536 logToStdErr: ::libc::c_int,
6537 logFileName: *const ::libc::c_char,
6538 ) -> cublasStatus_t;
6539}
6540extern "C" {
6541 pub fn cublasSetLoggerCallback(userCallback: cublasLogCallback) -> cublasStatus_t;
6542}
6543extern "C" {
6544 pub fn cublasGetLoggerCallback(userCallback: *mut cublasLogCallback) -> cublasStatus_t;
6545}
6546extern "C" {
6547 pub fn cublasSetVector(
6548 n: ::libc::c_int,
6549 elemSize: ::libc::c_int,
6550 x: *const ::libc::c_void,
6551 incx: ::libc::c_int,
6552 devicePtr: *mut ::libc::c_void,
6553 incy: ::libc::c_int,
6554 ) -> cublasStatus_t;
6555}
6556extern "C" {
6557 pub fn cublasGetVector(
6558 n: ::libc::c_int,
6559 elemSize: ::libc::c_int,
6560 x: *const ::libc::c_void,
6561 incx: ::libc::c_int,
6562 y: *mut ::libc::c_void,
6563 incy: ::libc::c_int,
6564 ) -> cublasStatus_t;
6565}
6566extern "C" {
6567 pub fn cublasSetMatrix(
6568 rows: ::libc::c_int,
6569 cols: ::libc::c_int,
6570 elemSize: ::libc::c_int,
6571 A: *const ::libc::c_void,
6572 lda: ::libc::c_int,
6573 B: *mut ::libc::c_void,
6574 ldb: ::libc::c_int,
6575 ) -> cublasStatus_t;
6576}
6577extern "C" {
6578 pub fn cublasGetMatrix(
6579 rows: ::libc::c_int,
6580 cols: ::libc::c_int,
6581 elemSize: ::libc::c_int,
6582 A: *const ::libc::c_void,
6583 lda: ::libc::c_int,
6584 B: *mut ::libc::c_void,
6585 ldb: ::libc::c_int,
6586 ) -> cublasStatus_t;
6587}
6588extern "C" {
6589 pub fn cublasSetVectorAsync(
6590 n: ::libc::c_int,
6591 elemSize: ::libc::c_int,
6592 hostPtr: *const ::libc::c_void,
6593 incx: ::libc::c_int,
6594 devicePtr: *mut ::libc::c_void,
6595 incy: ::libc::c_int,
6596 stream: cudaStream_t,
6597 ) -> cublasStatus_t;
6598}
6599extern "C" {
6600 pub fn cublasGetVectorAsync(
6601 n: ::libc::c_int,
6602 elemSize: ::libc::c_int,
6603 devicePtr: *const ::libc::c_void,
6604 incx: ::libc::c_int,
6605 hostPtr: *mut ::libc::c_void,
6606 incy: ::libc::c_int,
6607 stream: cudaStream_t,
6608 ) -> cublasStatus_t;
6609}
6610extern "C" {
6611 pub fn cublasSetMatrixAsync(
6612 rows: ::libc::c_int,
6613 cols: ::libc::c_int,
6614 elemSize: ::libc::c_int,
6615 A: *const ::libc::c_void,
6616 lda: ::libc::c_int,
6617 B: *mut ::libc::c_void,
6618 ldb: ::libc::c_int,
6619 stream: cudaStream_t,
6620 ) -> cublasStatus_t;
6621}
6622extern "C" {
6623 pub fn cublasGetMatrixAsync(
6624 rows: ::libc::c_int,
6625 cols: ::libc::c_int,
6626 elemSize: ::libc::c_int,
6627 A: *const ::libc::c_void,
6628 lda: ::libc::c_int,
6629 B: *mut ::libc::c_void,
6630 ldb: ::libc::c_int,
6631 stream: cudaStream_t,
6632 ) -> cublasStatus_t;
6633}
6634extern "C" {
6635 pub fn cublasXerbla(srName: *const ::libc::c_char, info: ::libc::c_int);
6636}
6637extern "C" {
6638 pub fn cublasNrm2Ex(
6639 handle: cublasHandle_t,
6640 n: ::libc::c_int,
6641 x: *const ::libc::c_void,
6642 xType: cudaDataType,
6643 incx: ::libc::c_int,
6644 result: *mut ::libc::c_void,
6645 resultType: cudaDataType,
6646 executionType: cudaDataType,
6647 ) -> cublasStatus_t;
6648}
6649extern "C" {
6650 pub fn cublasSnrm2_v2(
6651 handle: cublasHandle_t,
6652 n: ::libc::c_int,
6653 x: *const f32,
6654 incx: ::libc::c_int,
6655 result: *mut f32,
6656 ) -> cublasStatus_t;
6657}
6658extern "C" {
6659 pub fn cublasDnrm2_v2(
6660 handle: cublasHandle_t,
6661 n: ::libc::c_int,
6662 x: *const f64,
6663 incx: ::libc::c_int,
6664 result: *mut f64,
6665 ) -> cublasStatus_t;
6666}
6667extern "C" {
6668 pub fn cublasScnrm2_v2(
6669 handle: cublasHandle_t,
6670 n: ::libc::c_int,
6671 x: *const cuComplex,
6672 incx: ::libc::c_int,
6673 result: *mut f32,
6674 ) -> cublasStatus_t;
6675}
6676extern "C" {
6677 pub fn cublasDznrm2_v2(
6678 handle: cublasHandle_t,
6679 n: ::libc::c_int,
6680 x: *const cuDoubleComplex,
6681 incx: ::libc::c_int,
6682 result: *mut f64,
6683 ) -> cublasStatus_t;
6684}
6685extern "C" {
6686 pub fn cublasDotEx(
6687 handle: cublasHandle_t,
6688 n: ::libc::c_int,
6689 x: *const ::libc::c_void,
6690 xType: cudaDataType,
6691 incx: ::libc::c_int,
6692 y: *const ::libc::c_void,
6693 yType: cudaDataType,
6694 incy: ::libc::c_int,
6695 result: *mut ::libc::c_void,
6696 resultType: cudaDataType,
6697 executionType: cudaDataType,
6698 ) -> cublasStatus_t;
6699}
6700extern "C" {
6701 pub fn cublasDotcEx(
6702 handle: cublasHandle_t,
6703 n: ::libc::c_int,
6704 x: *const ::libc::c_void,
6705 xType: cudaDataType,
6706 incx: ::libc::c_int,
6707 y: *const ::libc::c_void,
6708 yType: cudaDataType,
6709 incy: ::libc::c_int,
6710 result: *mut ::libc::c_void,
6711 resultType: cudaDataType,
6712 executionType: cudaDataType,
6713 ) -> cublasStatus_t;
6714}
6715extern "C" {
6716 pub fn cublasSdot_v2(
6717 handle: cublasHandle_t,
6718 n: ::libc::c_int,
6719 x: *const f32,
6720 incx: ::libc::c_int,
6721 y: *const f32,
6722 incy: ::libc::c_int,
6723 result: *mut f32,
6724 ) -> cublasStatus_t;
6725}
6726extern "C" {
6727 pub fn cublasDdot_v2(
6728 handle: cublasHandle_t,
6729 n: ::libc::c_int,
6730 x: *const f64,
6731 incx: ::libc::c_int,
6732 y: *const f64,
6733 incy: ::libc::c_int,
6734 result: *mut f64,
6735 ) -> cublasStatus_t;
6736}
6737extern "C" {
6738 pub fn cublasCdotu_v2(
6739 handle: cublasHandle_t,
6740 n: ::libc::c_int,
6741 x: *const cuComplex,
6742 incx: ::libc::c_int,
6743 y: *const cuComplex,
6744 incy: ::libc::c_int,
6745 result: *mut cuComplex,
6746 ) -> cublasStatus_t;
6747}
6748extern "C" {
6749 pub fn cublasCdotc_v2(
6750 handle: cublasHandle_t,
6751 n: ::libc::c_int,
6752 x: *const cuComplex,
6753 incx: ::libc::c_int,
6754 y: *const cuComplex,
6755 incy: ::libc::c_int,
6756 result: *mut cuComplex,
6757 ) -> cublasStatus_t;
6758}
6759extern "C" {
6760 pub fn cublasZdotu_v2(
6761 handle: cublasHandle_t,
6762 n: ::libc::c_int,
6763 x: *const cuDoubleComplex,
6764 incx: ::libc::c_int,
6765 y: *const cuDoubleComplex,
6766 incy: ::libc::c_int,
6767 result: *mut cuDoubleComplex,
6768 ) -> cublasStatus_t;
6769}
6770extern "C" {
6771 pub fn cublasZdotc_v2(
6772 handle: cublasHandle_t,
6773 n: ::libc::c_int,
6774 x: *const cuDoubleComplex,
6775 incx: ::libc::c_int,
6776 y: *const cuDoubleComplex,
6777 incy: ::libc::c_int,
6778 result: *mut cuDoubleComplex,
6779 ) -> cublasStatus_t;
6780}
6781extern "C" {
6782 pub fn cublasScalEx(
6783 handle: cublasHandle_t,
6784 n: ::libc::c_int,
6785 alpha: *const ::libc::c_void,
6786 alphaType: cudaDataType,
6787 x: *mut ::libc::c_void,
6788 xType: cudaDataType,
6789 incx: ::libc::c_int,
6790 executionType: cudaDataType,
6791 ) -> cublasStatus_t;
6792}
6793extern "C" {
6794 pub fn cublasSscal_v2(
6795 handle: cublasHandle_t,
6796 n: ::libc::c_int,
6797 alpha: *const f32,
6798 x: *mut f32,
6799 incx: ::libc::c_int,
6800 ) -> cublasStatus_t;
6801}
6802extern "C" {
6803 pub fn cublasDscal_v2(
6804 handle: cublasHandle_t,
6805 n: ::libc::c_int,
6806 alpha: *const f64,
6807 x: *mut f64,
6808 incx: ::libc::c_int,
6809 ) -> cublasStatus_t;
6810}
6811extern "C" {
6812 pub fn cublasCscal_v2(
6813 handle: cublasHandle_t,
6814 n: ::libc::c_int,
6815 alpha: *const cuComplex,
6816 x: *mut cuComplex,
6817 incx: ::libc::c_int,
6818 ) -> cublasStatus_t;
6819}
6820extern "C" {
6821 pub fn cublasCsscal_v2(
6822 handle: cublasHandle_t,
6823 n: ::libc::c_int,
6824 alpha: *const f32,
6825 x: *mut cuComplex,
6826 incx: ::libc::c_int,
6827 ) -> cublasStatus_t;
6828}
6829extern "C" {
6830 pub fn cublasZscal_v2(
6831 handle: cublasHandle_t,
6832 n: ::libc::c_int,
6833 alpha: *const cuDoubleComplex,
6834 x: *mut cuDoubleComplex,
6835 incx: ::libc::c_int,
6836 ) -> cublasStatus_t;
6837}
6838extern "C" {
6839 pub fn cublasZdscal_v2(
6840 handle: cublasHandle_t,
6841 n: ::libc::c_int,
6842 alpha: *const f64,
6843 x: *mut cuDoubleComplex,
6844 incx: ::libc::c_int,
6845 ) -> cublasStatus_t;
6846}
6847extern "C" {
6848 pub fn cublasAxpyEx(
6849 handle: cublasHandle_t,
6850 n: ::libc::c_int,
6851 alpha: *const ::libc::c_void,
6852 alphaType: cudaDataType,
6853 x: *const ::libc::c_void,
6854 xType: cudaDataType,
6855 incx: ::libc::c_int,
6856 y: *mut ::libc::c_void,
6857 yType: cudaDataType,
6858 incy: ::libc::c_int,
6859 executiontype: cudaDataType,
6860 ) -> cublasStatus_t;
6861}
6862extern "C" {
6863 pub fn cublasSaxpy_v2(
6864 handle: cublasHandle_t,
6865 n: ::libc::c_int,
6866 alpha: *const f32,
6867 x: *const f32,
6868 incx: ::libc::c_int,
6869 y: *mut f32,
6870 incy: ::libc::c_int,
6871 ) -> cublasStatus_t;
6872}
6873extern "C" {
6874 pub fn cublasDaxpy_v2(
6875 handle: cublasHandle_t,
6876 n: ::libc::c_int,
6877 alpha: *const f64,
6878 x: *const f64,
6879 incx: ::libc::c_int,
6880 y: *mut f64,
6881 incy: ::libc::c_int,
6882 ) -> cublasStatus_t;
6883}
6884extern "C" {
6885 pub fn cublasCaxpy_v2(
6886 handle: cublasHandle_t,
6887 n: ::libc::c_int,
6888 alpha: *const cuComplex,
6889 x: *const cuComplex,
6890 incx: ::libc::c_int,
6891 y: *mut cuComplex,
6892 incy: ::libc::c_int,
6893 ) -> cublasStatus_t;
6894}
6895extern "C" {
6896 pub fn cublasZaxpy_v2(
6897 handle: cublasHandle_t,
6898 n: ::libc::c_int,
6899 alpha: *const cuDoubleComplex,
6900 x: *const cuDoubleComplex,
6901 incx: ::libc::c_int,
6902 y: *mut cuDoubleComplex,
6903 incy: ::libc::c_int,
6904 ) -> cublasStatus_t;
6905}
6906extern "C" {
6907 pub fn cublasCopyEx(
6908 handle: cublasHandle_t,
6909 n: ::libc::c_int,
6910 x: *const ::libc::c_void,
6911 xType: cudaDataType,
6912 incx: ::libc::c_int,
6913 y: *mut ::libc::c_void,
6914 yType: cudaDataType,
6915 incy: ::libc::c_int,
6916 ) -> cublasStatus_t;
6917}
6918extern "C" {
6919 pub fn cublasScopy_v2(
6920 handle: cublasHandle_t,
6921 n: ::libc::c_int,
6922 x: *const f32,
6923 incx: ::libc::c_int,
6924 y: *mut f32,
6925 incy: ::libc::c_int,
6926 ) -> cublasStatus_t;
6927}
6928extern "C" {
6929 pub fn cublasDcopy_v2(
6930 handle: cublasHandle_t,
6931 n: ::libc::c_int,
6932 x: *const f64,
6933 incx: ::libc::c_int,
6934 y: *mut f64,
6935 incy: ::libc::c_int,
6936 ) -> cublasStatus_t;
6937}
6938extern "C" {
6939 pub fn cublasCcopy_v2(
6940 handle: cublasHandle_t,
6941 n: ::libc::c_int,
6942 x: *const cuComplex,
6943 incx: ::libc::c_int,
6944 y: *mut cuComplex,
6945 incy: ::libc::c_int,
6946 ) -> cublasStatus_t;
6947}
6948extern "C" {
6949 pub fn cublasZcopy_v2(
6950 handle: cublasHandle_t,
6951 n: ::libc::c_int,
6952 x: *const cuDoubleComplex,
6953 incx: ::libc::c_int,
6954 y: *mut cuDoubleComplex,
6955 incy: ::libc::c_int,
6956 ) -> cublasStatus_t;
6957}
6958extern "C" {
6959 pub fn cublasSswap_v2(
6960 handle: cublasHandle_t,
6961 n: ::libc::c_int,
6962 x: *mut f32,
6963 incx: ::libc::c_int,
6964 y: *mut f32,
6965 incy: ::libc::c_int,
6966 ) -> cublasStatus_t;
6967}
6968extern "C" {
6969 pub fn cublasDswap_v2(
6970 handle: cublasHandle_t,
6971 n: ::libc::c_int,
6972 x: *mut f64,
6973 incx: ::libc::c_int,
6974 y: *mut f64,
6975 incy: ::libc::c_int,
6976 ) -> cublasStatus_t;
6977}
6978extern "C" {
6979 pub fn cublasCswap_v2(
6980 handle: cublasHandle_t,
6981 n: ::libc::c_int,
6982 x: *mut cuComplex,
6983 incx: ::libc::c_int,
6984 y: *mut cuComplex,
6985 incy: ::libc::c_int,
6986 ) -> cublasStatus_t;
6987}
6988extern "C" {
6989 pub fn cublasZswap_v2(
6990 handle: cublasHandle_t,
6991 n: ::libc::c_int,
6992 x: *mut cuDoubleComplex,
6993 incx: ::libc::c_int,
6994 y: *mut cuDoubleComplex,
6995 incy: ::libc::c_int,
6996 ) -> cublasStatus_t;
6997}
6998extern "C" {
6999 pub fn cublasSwapEx(
7000 handle: cublasHandle_t,
7001 n: ::libc::c_int,
7002 x: *mut ::libc::c_void,
7003 xType: cudaDataType,
7004 incx: ::libc::c_int,
7005 y: *mut ::libc::c_void,
7006 yType: cudaDataType,
7007 incy: ::libc::c_int,
7008 ) -> cublasStatus_t;
7009}
7010extern "C" {
7011 pub fn cublasIsamax_v2(
7012 handle: cublasHandle_t,
7013 n: ::libc::c_int,
7014 x: *const f32,
7015 incx: ::libc::c_int,
7016 result: *mut ::libc::c_int,
7017 ) -> cublasStatus_t;
7018}
7019extern "C" {
7020 pub fn cublasIdamax_v2(
7021 handle: cublasHandle_t,
7022 n: ::libc::c_int,
7023 x: *const f64,
7024 incx: ::libc::c_int,
7025 result: *mut ::libc::c_int,
7026 ) -> cublasStatus_t;
7027}
7028extern "C" {
7029 pub fn cublasIcamax_v2(
7030 handle: cublasHandle_t,
7031 n: ::libc::c_int,
7032 x: *const cuComplex,
7033 incx: ::libc::c_int,
7034 result: *mut ::libc::c_int,
7035 ) -> cublasStatus_t;
7036}
7037extern "C" {
7038 pub fn cublasIzamax_v2(
7039 handle: cublasHandle_t,
7040 n: ::libc::c_int,
7041 x: *const cuDoubleComplex,
7042 incx: ::libc::c_int,
7043 result: *mut ::libc::c_int,
7044 ) -> cublasStatus_t;
7045}
7046extern "C" {
7047 pub fn cublasIamaxEx(
7048 handle: cublasHandle_t,
7049 n: ::libc::c_int,
7050 x: *const ::libc::c_void,
7051 xType: cudaDataType,
7052 incx: ::libc::c_int,
7053 result: *mut ::libc::c_int,
7054 ) -> cublasStatus_t;
7055}
7056extern "C" {
7057 pub fn cublasIsamin_v2(
7058 handle: cublasHandle_t,
7059 n: ::libc::c_int,
7060 x: *const f32,
7061 incx: ::libc::c_int,
7062 result: *mut ::libc::c_int,
7063 ) -> cublasStatus_t;
7064}
7065extern "C" {
7066 pub fn cublasIdamin_v2(
7067 handle: cublasHandle_t,
7068 n: ::libc::c_int,
7069 x: *const f64,
7070 incx: ::libc::c_int,
7071 result: *mut ::libc::c_int,
7072 ) -> cublasStatus_t;
7073}
7074extern "C" {
7075 pub fn cublasIcamin_v2(
7076 handle: cublasHandle_t,
7077 n: ::libc::c_int,
7078 x: *const cuComplex,
7079 incx: ::libc::c_int,
7080 result: *mut ::libc::c_int,
7081 ) -> cublasStatus_t;
7082}
7083extern "C" {
7084 pub fn cublasIzamin_v2(
7085 handle: cublasHandle_t,
7086 n: ::libc::c_int,
7087 x: *const cuDoubleComplex,
7088 incx: ::libc::c_int,
7089 result: *mut ::libc::c_int,
7090 ) -> cublasStatus_t;
7091}
7092extern "C" {
7093 pub fn cublasIaminEx(
7094 handle: cublasHandle_t,
7095 n: ::libc::c_int,
7096 x: *const ::libc::c_void,
7097 xType: cudaDataType,
7098 incx: ::libc::c_int,
7099 result: *mut ::libc::c_int,
7100 ) -> cublasStatus_t;
7101}
7102extern "C" {
7103 pub fn cublasAsumEx(
7104 handle: cublasHandle_t,
7105 n: ::libc::c_int,
7106 x: *const ::libc::c_void,
7107 xType: cudaDataType,
7108 incx: ::libc::c_int,
7109 result: *mut ::libc::c_void,
7110 resultType: cudaDataType,
7111 executiontype: cudaDataType,
7112 ) -> cublasStatus_t;
7113}
7114extern "C" {
7115 pub fn cublasSasum_v2(
7116 handle: cublasHandle_t,
7117 n: ::libc::c_int,
7118 x: *const f32,
7119 incx: ::libc::c_int,
7120 result: *mut f32,
7121 ) -> cublasStatus_t;
7122}
7123extern "C" {
7124 pub fn cublasDasum_v2(
7125 handle: cublasHandle_t,
7126 n: ::libc::c_int,
7127 x: *const f64,
7128 incx: ::libc::c_int,
7129 result: *mut f64,
7130 ) -> cublasStatus_t;
7131}
7132extern "C" {
7133 pub fn cublasScasum_v2(
7134 handle: cublasHandle_t,
7135 n: ::libc::c_int,
7136 x: *const cuComplex,
7137 incx: ::libc::c_int,
7138 result: *mut f32,
7139 ) -> cublasStatus_t;
7140}
7141extern "C" {
7142 pub fn cublasDzasum_v2(
7143 handle: cublasHandle_t,
7144 n: ::libc::c_int,
7145 x: *const cuDoubleComplex,
7146 incx: ::libc::c_int,
7147 result: *mut f64,
7148 ) -> cublasStatus_t;
7149}
7150extern "C" {
7151 pub fn cublasSrot_v2(
7152 handle: cublasHandle_t,
7153 n: ::libc::c_int,
7154 x: *mut f32,
7155 incx: ::libc::c_int,
7156 y: *mut f32,
7157 incy: ::libc::c_int,
7158 c: *const f32,
7159 s: *const f32,
7160 ) -> cublasStatus_t;
7161}
7162extern "C" {
7163 pub fn cublasDrot_v2(
7164 handle: cublasHandle_t,
7165 n: ::libc::c_int,
7166 x: *mut f64,
7167 incx: ::libc::c_int,
7168 y: *mut f64,
7169 incy: ::libc::c_int,
7170 c: *const f64,
7171 s: *const f64,
7172 ) -> cublasStatus_t;
7173}
7174extern "C" {
7175 pub fn cublasCrot_v2(
7176 handle: cublasHandle_t,
7177 n: ::libc::c_int,
7178 x: *mut cuComplex,
7179 incx: ::libc::c_int,
7180 y: *mut cuComplex,
7181 incy: ::libc::c_int,
7182 c: *const f32,
7183 s: *const cuComplex,
7184 ) -> cublasStatus_t;
7185}
7186extern "C" {
7187 pub fn cublasCsrot_v2(
7188 handle: cublasHandle_t,
7189 n: ::libc::c_int,
7190 x: *mut cuComplex,
7191 incx: ::libc::c_int,
7192 y: *mut cuComplex,
7193 incy: ::libc::c_int,
7194 c: *const f32,
7195 s: *const f32,
7196 ) -> cublasStatus_t;
7197}
7198extern "C" {
7199 pub fn cublasZrot_v2(
7200 handle: cublasHandle_t,
7201 n: ::libc::c_int,
7202 x: *mut cuDoubleComplex,
7203 incx: ::libc::c_int,
7204 y: *mut cuDoubleComplex,
7205 incy: ::libc::c_int,
7206 c: *const f64,
7207 s: *const cuDoubleComplex,
7208 ) -> cublasStatus_t;
7209}
7210extern "C" {
7211 pub fn cublasZdrot_v2(
7212 handle: cublasHandle_t,
7213 n: ::libc::c_int,
7214 x: *mut cuDoubleComplex,
7215 incx: ::libc::c_int,
7216 y: *mut cuDoubleComplex,
7217 incy: ::libc::c_int,
7218 c: *const f64,
7219 s: *const f64,
7220 ) -> cublasStatus_t;
7221}
7222extern "C" {
7223 pub fn cublasRotEx(
7224 handle: cublasHandle_t,
7225 n: ::libc::c_int,
7226 x: *mut ::libc::c_void,
7227 xType: cudaDataType,
7228 incx: ::libc::c_int,
7229 y: *mut ::libc::c_void,
7230 yType: cudaDataType,
7231 incy: ::libc::c_int,
7232 c: *const ::libc::c_void,
7233 s: *const ::libc::c_void,
7234 csType: cudaDataType,
7235 executiontype: cudaDataType,
7236 ) -> cublasStatus_t;
7237}
7238extern "C" {
7239 pub fn cublasSrotg_v2(
7240 handle: cublasHandle_t,
7241 a: *mut f32,
7242 b: *mut f32,
7243 c: *mut f32,
7244 s: *mut f32,
7245 ) -> cublasStatus_t;
7246}
7247extern "C" {
7248 pub fn cublasDrotg_v2(
7249 handle: cublasHandle_t,
7250 a: *mut f64,
7251 b: *mut f64,
7252 c: *mut f64,
7253 s: *mut f64,
7254 ) -> cublasStatus_t;
7255}
7256extern "C" {
7257 pub fn cublasCrotg_v2(
7258 handle: cublasHandle_t,
7259 a: *mut cuComplex,
7260 b: *mut cuComplex,
7261 c: *mut f32,
7262 s: *mut cuComplex,
7263 ) -> cublasStatus_t;
7264}
7265extern "C" {
7266 pub fn cublasZrotg_v2(
7267 handle: cublasHandle_t,
7268 a: *mut cuDoubleComplex,
7269 b: *mut cuDoubleComplex,
7270 c: *mut f64,
7271 s: *mut cuDoubleComplex,
7272 ) -> cublasStatus_t;
7273}
7274extern "C" {
7275 pub fn cublasRotgEx(
7276 handle: cublasHandle_t,
7277 a: *mut ::libc::c_void,
7278 b: *mut ::libc::c_void,
7279 abType: cudaDataType,
7280 c: *mut ::libc::c_void,
7281 s: *mut ::libc::c_void,
7282 csType: cudaDataType,
7283 executiontype: cudaDataType,
7284 ) -> cublasStatus_t;
7285}
7286extern "C" {
7287 pub fn cublasSrotm_v2(
7288 handle: cublasHandle_t,
7289 n: ::libc::c_int,
7290 x: *mut f32,
7291 incx: ::libc::c_int,
7292 y: *mut f32,
7293 incy: ::libc::c_int,
7294 param: *const f32,
7295 ) -> cublasStatus_t;
7296}
7297extern "C" {
7298 pub fn cublasDrotm_v2(
7299 handle: cublasHandle_t,
7300 n: ::libc::c_int,
7301 x: *mut f64,
7302 incx: ::libc::c_int,
7303 y: *mut f64,
7304 incy: ::libc::c_int,
7305 param: *const f64,
7306 ) -> cublasStatus_t;
7307}
7308extern "C" {
7309 pub fn cublasRotmEx(
7310 handle: cublasHandle_t,
7311 n: ::libc::c_int,
7312 x: *mut ::libc::c_void,
7313 xType: cudaDataType,
7314 incx: ::libc::c_int,
7315 y: *mut ::libc::c_void,
7316 yType: cudaDataType,
7317 incy: ::libc::c_int,
7318 param: *const ::libc::c_void,
7319 paramType: cudaDataType,
7320 executiontype: cudaDataType,
7321 ) -> cublasStatus_t;
7322}
7323extern "C" {
7324 pub fn cublasSrotmg_v2(
7325 handle: cublasHandle_t,
7326 d1: *mut f32,
7327 d2: *mut f32,
7328 x1: *mut f32,
7329 y1: *const f32,
7330 param: *mut f32,
7331 ) -> cublasStatus_t;
7332}
7333extern "C" {
7334 pub fn cublasDrotmg_v2(
7335 handle: cublasHandle_t,
7336 d1: *mut f64,
7337 d2: *mut f64,
7338 x1: *mut f64,
7339 y1: *const f64,
7340 param: *mut f64,
7341 ) -> cublasStatus_t;
7342}
7343extern "C" {
7344 pub fn cublasRotmgEx(
7345 handle: cublasHandle_t,
7346 d1: *mut ::libc::c_void,
7347 d1Type: cudaDataType,
7348 d2: *mut ::libc::c_void,
7349 d2Type: cudaDataType,
7350 x1: *mut ::libc::c_void,
7351 x1Type: cudaDataType,
7352 y1: *const ::libc::c_void,
7353 y1Type: cudaDataType,
7354 param: *mut ::libc::c_void,
7355 paramType: cudaDataType,
7356 executiontype: cudaDataType,
7357 ) -> cublasStatus_t;
7358}
7359extern "C" {
7360 pub fn cublasSgemv_v2(
7361 handle: cublasHandle_t,
7362 trans: cublasOperation_t,
7363 m: ::libc::c_int,
7364 n: ::libc::c_int,
7365 alpha: *const f32,
7366 A: *const f32,
7367 lda: ::libc::c_int,
7368 x: *const f32,
7369 incx: ::libc::c_int,
7370 beta: *const f32,
7371 y: *mut f32,
7372 incy: ::libc::c_int,
7373 ) -> cublasStatus_t;
7374}
7375extern "C" {
7376 pub fn cublasDgemv_v2(
7377 handle: cublasHandle_t,
7378 trans: cublasOperation_t,
7379 m: ::libc::c_int,
7380 n: ::libc::c_int,
7381 alpha: *const f64,
7382 A: *const f64,
7383 lda: ::libc::c_int,
7384 x: *const f64,
7385 incx: ::libc::c_int,
7386 beta: *const f64,
7387 y: *mut f64,
7388 incy: ::libc::c_int,
7389 ) -> cublasStatus_t;
7390}
7391extern "C" {
7392 pub fn cublasCgemv_v2(
7393 handle: cublasHandle_t,
7394 trans: cublasOperation_t,
7395 m: ::libc::c_int,
7396 n: ::libc::c_int,
7397 alpha: *const cuComplex,
7398 A: *const cuComplex,
7399 lda: ::libc::c_int,
7400 x: *const cuComplex,
7401 incx: ::libc::c_int,
7402 beta: *const cuComplex,
7403 y: *mut cuComplex,
7404 incy: ::libc::c_int,
7405 ) -> cublasStatus_t;
7406}
7407extern "C" {
7408 pub fn cublasZgemv_v2(
7409 handle: cublasHandle_t,
7410 trans: cublasOperation_t,
7411 m: ::libc::c_int,
7412 n: ::libc::c_int,
7413 alpha: *const cuDoubleComplex,
7414 A: *const cuDoubleComplex,
7415 lda: ::libc::c_int,
7416 x: *const cuDoubleComplex,
7417 incx: ::libc::c_int,
7418 beta: *const cuDoubleComplex,
7419 y: *mut cuDoubleComplex,
7420 incy: ::libc::c_int,
7421 ) -> cublasStatus_t;
7422}
7423extern "C" {
7424 pub fn cublasSgbmv_v2(
7425 handle: cublasHandle_t,
7426 trans: cublasOperation_t,
7427 m: ::libc::c_int,
7428 n: ::libc::c_int,
7429 kl: ::libc::c_int,
7430 ku: ::libc::c_int,
7431 alpha: *const f32,
7432 A: *const f32,
7433 lda: ::libc::c_int,
7434 x: *const f32,
7435 incx: ::libc::c_int,
7436 beta: *const f32,
7437 y: *mut f32,
7438 incy: ::libc::c_int,
7439 ) -> cublasStatus_t;
7440}
7441extern "C" {
7442 pub fn cublasDgbmv_v2(
7443 handle: cublasHandle_t,
7444 trans: cublasOperation_t,
7445 m: ::libc::c_int,
7446 n: ::libc::c_int,
7447 kl: ::libc::c_int,
7448 ku: ::libc::c_int,
7449 alpha: *const f64,
7450 A: *const f64,
7451 lda: ::libc::c_int,
7452 x: *const f64,
7453 incx: ::libc::c_int,
7454 beta: *const f64,
7455 y: *mut f64,
7456 incy: ::libc::c_int,
7457 ) -> cublasStatus_t;
7458}
7459extern "C" {
7460 pub fn cublasCgbmv_v2(
7461 handle: cublasHandle_t,
7462 trans: cublasOperation_t,
7463 m: ::libc::c_int,
7464 n: ::libc::c_int,
7465 kl: ::libc::c_int,
7466 ku: ::libc::c_int,
7467 alpha: *const cuComplex,
7468 A: *const cuComplex,
7469 lda: ::libc::c_int,
7470 x: *const cuComplex,
7471 incx: ::libc::c_int,
7472 beta: *const cuComplex,
7473 y: *mut cuComplex,
7474 incy: ::libc::c_int,
7475 ) -> cublasStatus_t;
7476}
7477extern "C" {
7478 pub fn cublasZgbmv_v2(
7479 handle: cublasHandle_t,
7480 trans: cublasOperation_t,
7481 m: ::libc::c_int,
7482 n: ::libc::c_int,
7483 kl: ::libc::c_int,
7484 ku: ::libc::c_int,
7485 alpha: *const cuDoubleComplex,
7486 A: *const cuDoubleComplex,
7487 lda: ::libc::c_int,
7488 x: *const cuDoubleComplex,
7489 incx: ::libc::c_int,
7490 beta: *const cuDoubleComplex,
7491 y: *mut cuDoubleComplex,
7492 incy: ::libc::c_int,
7493 ) -> cublasStatus_t;
7494}
7495extern "C" {
7496 pub fn cublasStrmv_v2(
7497 handle: cublasHandle_t,
7498 uplo: cublasFillMode_t,
7499 trans: cublasOperation_t,
7500 diag: cublasDiagType_t,
7501 n: ::libc::c_int,
7502 A: *const f32,
7503 lda: ::libc::c_int,
7504 x: *mut f32,
7505 incx: ::libc::c_int,
7506 ) -> cublasStatus_t;
7507}
7508extern "C" {
7509 pub fn cublasDtrmv_v2(
7510 handle: cublasHandle_t,
7511 uplo: cublasFillMode_t,
7512 trans: cublasOperation_t,
7513 diag: cublasDiagType_t,
7514 n: ::libc::c_int,
7515 A: *const f64,
7516 lda: ::libc::c_int,
7517 x: *mut f64,
7518 incx: ::libc::c_int,
7519 ) -> cublasStatus_t;
7520}
7521extern "C" {
7522 pub fn cublasCtrmv_v2(
7523 handle: cublasHandle_t,
7524 uplo: cublasFillMode_t,
7525 trans: cublasOperation_t,
7526 diag: cublasDiagType_t,
7527 n: ::libc::c_int,
7528 A: *const cuComplex,
7529 lda: ::libc::c_int,
7530 x: *mut cuComplex,
7531 incx: ::libc::c_int,
7532 ) -> cublasStatus_t;
7533}
7534extern "C" {
7535 pub fn cublasZtrmv_v2(
7536 handle: cublasHandle_t,
7537 uplo: cublasFillMode_t,
7538 trans: cublasOperation_t,
7539 diag: cublasDiagType_t,
7540 n: ::libc::c_int,
7541 A: *const cuDoubleComplex,
7542 lda: ::libc::c_int,
7543 x: *mut cuDoubleComplex,
7544 incx: ::libc::c_int,
7545 ) -> cublasStatus_t;
7546}
7547extern "C" {
7548 pub fn cublasStbmv_v2(
7549 handle: cublasHandle_t,
7550 uplo: cublasFillMode_t,
7551 trans: cublasOperation_t,
7552 diag: cublasDiagType_t,
7553 n: ::libc::c_int,
7554 k: ::libc::c_int,
7555 A: *const f32,
7556 lda: ::libc::c_int,
7557 x: *mut f32,
7558 incx: ::libc::c_int,
7559 ) -> cublasStatus_t;
7560}
7561extern "C" {
7562 pub fn cublasDtbmv_v2(
7563 handle: cublasHandle_t,
7564 uplo: cublasFillMode_t,
7565 trans: cublasOperation_t,
7566 diag: cublasDiagType_t,
7567 n: ::libc::c_int,
7568 k: ::libc::c_int,
7569 A: *const f64,
7570 lda: ::libc::c_int,
7571 x: *mut f64,
7572 incx: ::libc::c_int,
7573 ) -> cublasStatus_t;
7574}
7575extern "C" {
7576 pub fn cublasCtbmv_v2(
7577 handle: cublasHandle_t,
7578 uplo: cublasFillMode_t,
7579 trans: cublasOperation_t,
7580 diag: cublasDiagType_t,
7581 n: ::libc::c_int,
7582 k: ::libc::c_int,
7583 A: *const cuComplex,
7584 lda: ::libc::c_int,
7585 x: *mut cuComplex,
7586 incx: ::libc::c_int,
7587 ) -> cublasStatus_t;
7588}
7589extern "C" {
7590 pub fn cublasZtbmv_v2(
7591 handle: cublasHandle_t,
7592 uplo: cublasFillMode_t,
7593 trans: cublasOperation_t,
7594 diag: cublasDiagType_t,
7595 n: ::libc::c_int,
7596 k: ::libc::c_int,
7597 A: *const cuDoubleComplex,
7598 lda: ::libc::c_int,
7599 x: *mut cuDoubleComplex,
7600 incx: ::libc::c_int,
7601 ) -> cublasStatus_t;
7602}
7603extern "C" {
7604 pub fn cublasStpmv_v2(
7605 handle: cublasHandle_t,
7606 uplo: cublasFillMode_t,
7607 trans: cublasOperation_t,
7608 diag: cublasDiagType_t,
7609 n: ::libc::c_int,
7610 AP: *const f32,
7611 x: *mut f32,
7612 incx: ::libc::c_int,
7613 ) -> cublasStatus_t;
7614}
7615extern "C" {
7616 pub fn cublasDtpmv_v2(
7617 handle: cublasHandle_t,
7618 uplo: cublasFillMode_t,
7619 trans: cublasOperation_t,
7620 diag: cublasDiagType_t,
7621 n: ::libc::c_int,
7622 AP: *const f64,
7623 x: *mut f64,
7624 incx: ::libc::c_int,
7625 ) -> cublasStatus_t;
7626}
7627extern "C" {
7628 pub fn cublasCtpmv_v2(
7629 handle: cublasHandle_t,
7630 uplo: cublasFillMode_t,
7631 trans: cublasOperation_t,
7632 diag: cublasDiagType_t,
7633 n: ::libc::c_int,
7634 AP: *const cuComplex,
7635 x: *mut cuComplex,
7636 incx: ::libc::c_int,
7637 ) -> cublasStatus_t;
7638}
7639extern "C" {
7640 pub fn cublasZtpmv_v2(
7641 handle: cublasHandle_t,
7642 uplo: cublasFillMode_t,
7643 trans: cublasOperation_t,
7644 diag: cublasDiagType_t,
7645 n: ::libc::c_int,
7646 AP: *const cuDoubleComplex,
7647 x: *mut cuDoubleComplex,
7648 incx: ::libc::c_int,
7649 ) -> cublasStatus_t;
7650}
7651extern "C" {
7652 pub fn cublasStrsv_v2(
7653 handle: cublasHandle_t,
7654 uplo: cublasFillMode_t,
7655 trans: cublasOperation_t,
7656 diag: cublasDiagType_t,
7657 n: ::libc::c_int,
7658 A: *const f32,
7659 lda: ::libc::c_int,
7660 x: *mut f32,
7661 incx: ::libc::c_int,
7662 ) -> cublasStatus_t;
7663}
7664extern "C" {
7665 pub fn cublasDtrsv_v2(
7666 handle: cublasHandle_t,
7667 uplo: cublasFillMode_t,
7668 trans: cublasOperation_t,
7669 diag: cublasDiagType_t,
7670 n: ::libc::c_int,
7671 A: *const f64,
7672 lda: ::libc::c_int,
7673 x: *mut f64,
7674 incx: ::libc::c_int,
7675 ) -> cublasStatus_t;
7676}
7677extern "C" {
7678 pub fn cublasCtrsv_v2(
7679 handle: cublasHandle_t,
7680 uplo: cublasFillMode_t,
7681 trans: cublasOperation_t,
7682 diag: cublasDiagType_t,
7683 n: ::libc::c_int,
7684 A: *const cuComplex,
7685 lda: ::libc::c_int,
7686 x: *mut cuComplex,
7687 incx: ::libc::c_int,
7688 ) -> cublasStatus_t;
7689}
7690extern "C" {
7691 pub fn cublasZtrsv_v2(
7692 handle: cublasHandle_t,
7693 uplo: cublasFillMode_t,
7694 trans: cublasOperation_t,
7695 diag: cublasDiagType_t,
7696 n: ::libc::c_int,
7697 A: *const cuDoubleComplex,
7698 lda: ::libc::c_int,
7699 x: *mut cuDoubleComplex,
7700 incx: ::libc::c_int,
7701 ) -> cublasStatus_t;
7702}
7703extern "C" {
7704 pub fn cublasStpsv_v2(
7705 handle: cublasHandle_t,
7706 uplo: cublasFillMode_t,
7707 trans: cublasOperation_t,
7708 diag: cublasDiagType_t,
7709 n: ::libc::c_int,
7710 AP: *const f32,
7711 x: *mut f32,
7712 incx: ::libc::c_int,
7713 ) -> cublasStatus_t;
7714}
7715extern "C" {
7716 pub fn cublasDtpsv_v2(
7717 handle: cublasHandle_t,
7718 uplo: cublasFillMode_t,
7719 trans: cublasOperation_t,
7720 diag: cublasDiagType_t,
7721 n: ::libc::c_int,
7722 AP: *const f64,
7723 x: *mut f64,
7724 incx: ::libc::c_int,
7725 ) -> cublasStatus_t;
7726}
7727extern "C" {
7728 pub fn cublasCtpsv_v2(
7729 handle: cublasHandle_t,
7730 uplo: cublasFillMode_t,
7731 trans: cublasOperation_t,
7732 diag: cublasDiagType_t,
7733 n: ::libc::c_int,
7734 AP: *const cuComplex,
7735 x: *mut cuComplex,
7736 incx: ::libc::c_int,
7737 ) -> cublasStatus_t;
7738}
7739extern "C" {
7740 pub fn cublasZtpsv_v2(
7741 handle: cublasHandle_t,
7742 uplo: cublasFillMode_t,
7743 trans: cublasOperation_t,
7744 diag: cublasDiagType_t,
7745 n: ::libc::c_int,
7746 AP: *const cuDoubleComplex,
7747 x: *mut cuDoubleComplex,
7748 incx: ::libc::c_int,
7749 ) -> cublasStatus_t;
7750}
7751extern "C" {
7752 pub fn cublasStbsv_v2(
7753 handle: cublasHandle_t,
7754 uplo: cublasFillMode_t,
7755 trans: cublasOperation_t,
7756 diag: cublasDiagType_t,
7757 n: ::libc::c_int,
7758 k: ::libc::c_int,
7759 A: *const f32,
7760 lda: ::libc::c_int,
7761 x: *mut f32,
7762 incx: ::libc::c_int,
7763 ) -> cublasStatus_t;
7764}
7765extern "C" {
7766 pub fn cublasDtbsv_v2(
7767 handle: cublasHandle_t,
7768 uplo: cublasFillMode_t,
7769 trans: cublasOperation_t,
7770 diag: cublasDiagType_t,
7771 n: ::libc::c_int,
7772 k: ::libc::c_int,
7773 A: *const f64,
7774 lda: ::libc::c_int,
7775 x: *mut f64,
7776 incx: ::libc::c_int,
7777 ) -> cublasStatus_t;
7778}
7779extern "C" {
7780 pub fn cublasCtbsv_v2(
7781 handle: cublasHandle_t,
7782 uplo: cublasFillMode_t,
7783 trans: cublasOperation_t,
7784 diag: cublasDiagType_t,
7785 n: ::libc::c_int,
7786 k: ::libc::c_int,
7787 A: *const cuComplex,
7788 lda: ::libc::c_int,
7789 x: *mut cuComplex,
7790 incx: ::libc::c_int,
7791 ) -> cublasStatus_t;
7792}
7793extern "C" {
7794 pub fn cublasZtbsv_v2(
7795 handle: cublasHandle_t,
7796 uplo: cublasFillMode_t,
7797 trans: cublasOperation_t,
7798 diag: cublasDiagType_t,
7799 n: ::libc::c_int,
7800 k: ::libc::c_int,
7801 A: *const cuDoubleComplex,
7802 lda: ::libc::c_int,
7803 x: *mut cuDoubleComplex,
7804 incx: ::libc::c_int,
7805 ) -> cublasStatus_t;
7806}
7807extern "C" {
7808 pub fn cublasSsymv_v2(
7809 handle: cublasHandle_t,
7810 uplo: cublasFillMode_t,
7811 n: ::libc::c_int,
7812 alpha: *const f32,
7813 A: *const f32,
7814 lda: ::libc::c_int,
7815 x: *const f32,
7816 incx: ::libc::c_int,
7817 beta: *const f32,
7818 y: *mut f32,
7819 incy: ::libc::c_int,
7820 ) -> cublasStatus_t;
7821}
7822extern "C" {
7823 pub fn cublasDsymv_v2(
7824 handle: cublasHandle_t,
7825 uplo: cublasFillMode_t,
7826 n: ::libc::c_int,
7827 alpha: *const f64,
7828 A: *const f64,
7829 lda: ::libc::c_int,
7830 x: *const f64,
7831 incx: ::libc::c_int,
7832 beta: *const f64,
7833 y: *mut f64,
7834 incy: ::libc::c_int,
7835 ) -> cublasStatus_t;
7836}
7837extern "C" {
7838 pub fn cublasCsymv_v2(
7839 handle: cublasHandle_t,
7840 uplo: cublasFillMode_t,
7841 n: ::libc::c_int,
7842 alpha: *const cuComplex,
7843 A: *const cuComplex,
7844 lda: ::libc::c_int,
7845 x: *const cuComplex,
7846 incx: ::libc::c_int,
7847 beta: *const cuComplex,
7848 y: *mut cuComplex,
7849 incy: ::libc::c_int,
7850 ) -> cublasStatus_t;
7851}
7852extern "C" {
7853 pub fn cublasZsymv_v2(
7854 handle: cublasHandle_t,
7855 uplo: cublasFillMode_t,
7856 n: ::libc::c_int,
7857 alpha: *const cuDoubleComplex,
7858 A: *const cuDoubleComplex,
7859 lda: ::libc::c_int,
7860 x: *const cuDoubleComplex,
7861 incx: ::libc::c_int,
7862 beta: *const cuDoubleComplex,
7863 y: *mut cuDoubleComplex,
7864 incy: ::libc::c_int,
7865 ) -> cublasStatus_t;
7866}
7867extern "C" {
7868 pub fn cublasChemv_v2(
7869 handle: cublasHandle_t,
7870 uplo: cublasFillMode_t,
7871 n: ::libc::c_int,
7872 alpha: *const cuComplex,
7873 A: *const cuComplex,
7874 lda: ::libc::c_int,
7875 x: *const cuComplex,
7876 incx: ::libc::c_int,
7877 beta: *const cuComplex,
7878 y: *mut cuComplex,
7879 incy: ::libc::c_int,
7880 ) -> cublasStatus_t;
7881}
7882extern "C" {
7883 pub fn cublasZhemv_v2(
7884 handle: cublasHandle_t,
7885 uplo: cublasFillMode_t,
7886 n: ::libc::c_int,
7887 alpha: *const cuDoubleComplex,
7888 A: *const cuDoubleComplex,
7889 lda: ::libc::c_int,
7890 x: *const cuDoubleComplex,
7891 incx: ::libc::c_int,
7892 beta: *const cuDoubleComplex,
7893 y: *mut cuDoubleComplex,
7894 incy: ::libc::c_int,
7895 ) -> cublasStatus_t;
7896}
7897extern "C" {
7898 pub fn cublasSsbmv_v2(
7899 handle: cublasHandle_t,
7900 uplo: cublasFillMode_t,
7901 n: ::libc::c_int,
7902 k: ::libc::c_int,
7903 alpha: *const f32,
7904 A: *const f32,
7905 lda: ::libc::c_int,
7906 x: *const f32,
7907 incx: ::libc::c_int,
7908 beta: *const f32,
7909 y: *mut f32,
7910 incy: ::libc::c_int,
7911 ) -> cublasStatus_t;
7912}
7913extern "C" {
7914 pub fn cublasDsbmv_v2(
7915 handle: cublasHandle_t,
7916 uplo: cublasFillMode_t,
7917 n: ::libc::c_int,
7918 k: ::libc::c_int,
7919 alpha: *const f64,
7920 A: *const f64,
7921 lda: ::libc::c_int,
7922 x: *const f64,
7923 incx: ::libc::c_int,
7924 beta: *const f64,
7925 y: *mut f64,
7926 incy: ::libc::c_int,
7927 ) -> cublasStatus_t;
7928}
7929extern "C" {
7930 pub fn cublasChbmv_v2(
7931 handle: cublasHandle_t,
7932 uplo: cublasFillMode_t,
7933 n: ::libc::c_int,
7934 k: ::libc::c_int,
7935 alpha: *const cuComplex,
7936 A: *const cuComplex,
7937 lda: ::libc::c_int,
7938 x: *const cuComplex,
7939 incx: ::libc::c_int,
7940 beta: *const cuComplex,
7941 y: *mut cuComplex,
7942 incy: ::libc::c_int,
7943 ) -> cublasStatus_t;
7944}
7945extern "C" {
7946 pub fn cublasZhbmv_v2(
7947 handle: cublasHandle_t,
7948 uplo: cublasFillMode_t,
7949 n: ::libc::c_int,
7950 k: ::libc::c_int,
7951 alpha: *const cuDoubleComplex,
7952 A: *const cuDoubleComplex,
7953 lda: ::libc::c_int,
7954 x: *const cuDoubleComplex,
7955 incx: ::libc::c_int,
7956 beta: *const cuDoubleComplex,
7957 y: *mut cuDoubleComplex,
7958 incy: ::libc::c_int,
7959 ) -> cublasStatus_t;
7960}
7961extern "C" {
7962 pub fn cublasSspmv_v2(
7963 handle: cublasHandle_t,
7964 uplo: cublasFillMode_t,
7965 n: ::libc::c_int,
7966 alpha: *const f32,
7967 AP: *const f32,
7968 x: *const f32,
7969 incx: ::libc::c_int,
7970 beta: *const f32,
7971 y: *mut f32,
7972 incy: ::libc::c_int,
7973 ) -> cublasStatus_t;
7974}
7975extern "C" {
7976 pub fn cublasDspmv_v2(
7977 handle: cublasHandle_t,
7978 uplo: cublasFillMode_t,
7979 n: ::libc::c_int,
7980 alpha: *const f64,
7981 AP: *const f64,
7982 x: *const f64,
7983 incx: ::libc::c_int,
7984 beta: *const f64,
7985 y: *mut f64,
7986 incy: ::libc::c_int,
7987 ) -> cublasStatus_t;
7988}
7989extern "C" {
7990 pub fn cublasChpmv_v2(
7991 handle: cublasHandle_t,
7992 uplo: cublasFillMode_t,
7993 n: ::libc::c_int,
7994 alpha: *const cuComplex,
7995 AP: *const cuComplex,
7996 x: *const cuComplex,
7997 incx: ::libc::c_int,
7998 beta: *const cuComplex,
7999 y: *mut cuComplex,
8000 incy: ::libc::c_int,
8001 ) -> cublasStatus_t;
8002}
8003extern "C" {
8004 pub fn cublasZhpmv_v2(
8005 handle: cublasHandle_t,
8006 uplo: cublasFillMode_t,
8007 n: ::libc::c_int,
8008 alpha: *const cuDoubleComplex,
8009 AP: *const cuDoubleComplex,
8010 x: *const cuDoubleComplex,
8011 incx: ::libc::c_int,
8012 beta: *const cuDoubleComplex,
8013 y: *mut cuDoubleComplex,
8014 incy: ::libc::c_int,
8015 ) -> cublasStatus_t;
8016}
8017extern "C" {
8018 pub fn cublasSger_v2(
8019 handle: cublasHandle_t,
8020 m: ::libc::c_int,
8021 n: ::libc::c_int,
8022 alpha: *const f32,
8023 x: *const f32,
8024 incx: ::libc::c_int,
8025 y: *const f32,
8026 incy: ::libc::c_int,
8027 A: *mut f32,
8028 lda: ::libc::c_int,
8029 ) -> cublasStatus_t;
8030}
8031extern "C" {
8032 pub fn cublasDger_v2(
8033 handle: cublasHandle_t,
8034 m: ::libc::c_int,
8035 n: ::libc::c_int,
8036 alpha: *const f64,
8037 x: *const f64,
8038 incx: ::libc::c_int,
8039 y: *const f64,
8040 incy: ::libc::c_int,
8041 A: *mut f64,
8042 lda: ::libc::c_int,
8043 ) -> cublasStatus_t;
8044}
8045extern "C" {
8046 pub fn cublasCgeru_v2(
8047 handle: cublasHandle_t,
8048 m: ::libc::c_int,
8049 n: ::libc::c_int,
8050 alpha: *const cuComplex,
8051 x: *const cuComplex,
8052 incx: ::libc::c_int,
8053 y: *const cuComplex,
8054 incy: ::libc::c_int,
8055 A: *mut cuComplex,
8056 lda: ::libc::c_int,
8057 ) -> cublasStatus_t;
8058}
8059extern "C" {
8060 pub fn cublasCgerc_v2(
8061 handle: cublasHandle_t,
8062 m: ::libc::c_int,
8063 n: ::libc::c_int,
8064 alpha: *const cuComplex,
8065 x: *const cuComplex,
8066 incx: ::libc::c_int,
8067 y: *const cuComplex,
8068 incy: ::libc::c_int,
8069 A: *mut cuComplex,
8070 lda: ::libc::c_int,
8071 ) -> cublasStatus_t;
8072}
8073extern "C" {
8074 pub fn cublasZgeru_v2(
8075 handle: cublasHandle_t,
8076 m: ::libc::c_int,
8077 n: ::libc::c_int,
8078 alpha: *const cuDoubleComplex,
8079 x: *const cuDoubleComplex,
8080 incx: ::libc::c_int,
8081 y: *const cuDoubleComplex,
8082 incy: ::libc::c_int,
8083 A: *mut cuDoubleComplex,
8084 lda: ::libc::c_int,
8085 ) -> cublasStatus_t;
8086}
8087extern "C" {
8088 pub fn cublasZgerc_v2(
8089 handle: cublasHandle_t,
8090 m: ::libc::c_int,
8091 n: ::libc::c_int,
8092 alpha: *const cuDoubleComplex,
8093 x: *const cuDoubleComplex,
8094 incx: ::libc::c_int,
8095 y: *const cuDoubleComplex,
8096 incy: ::libc::c_int,
8097 A: *mut cuDoubleComplex,
8098 lda: ::libc::c_int,
8099 ) -> cublasStatus_t;
8100}
8101extern "C" {
8102 pub fn cublasSsyr_v2(
8103 handle: cublasHandle_t,
8104 uplo: cublasFillMode_t,
8105 n: ::libc::c_int,
8106 alpha: *const f32,
8107 x: *const f32,
8108 incx: ::libc::c_int,
8109 A: *mut f32,
8110 lda: ::libc::c_int,
8111 ) -> cublasStatus_t;
8112}
8113extern "C" {
8114 pub fn cublasDsyr_v2(
8115 handle: cublasHandle_t,
8116 uplo: cublasFillMode_t,
8117 n: ::libc::c_int,
8118 alpha: *const f64,
8119 x: *const f64,
8120 incx: ::libc::c_int,
8121 A: *mut f64,
8122 lda: ::libc::c_int,
8123 ) -> cublasStatus_t;
8124}
8125extern "C" {
8126 pub fn cublasCsyr_v2(
8127 handle: cublasHandle_t,
8128 uplo: cublasFillMode_t,
8129 n: ::libc::c_int,
8130 alpha: *const cuComplex,
8131 x: *const cuComplex,
8132 incx: ::libc::c_int,
8133 A: *mut cuComplex,
8134 lda: ::libc::c_int,
8135 ) -> cublasStatus_t;
8136}
8137extern "C" {
8138 pub fn cublasZsyr_v2(
8139 handle: cublasHandle_t,
8140 uplo: cublasFillMode_t,
8141 n: ::libc::c_int,
8142 alpha: *const cuDoubleComplex,
8143 x: *const cuDoubleComplex,
8144 incx: ::libc::c_int,
8145 A: *mut cuDoubleComplex,
8146 lda: ::libc::c_int,
8147 ) -> cublasStatus_t;
8148}
8149extern "C" {
8150 pub fn cublasCher_v2(
8151 handle: cublasHandle_t,
8152 uplo: cublasFillMode_t,
8153 n: ::libc::c_int,
8154 alpha: *const f32,
8155 x: *const cuComplex,
8156 incx: ::libc::c_int,
8157 A: *mut cuComplex,
8158 lda: ::libc::c_int,
8159 ) -> cublasStatus_t;
8160}
8161extern "C" {
8162 pub fn cublasZher_v2(
8163 handle: cublasHandle_t,
8164 uplo: cublasFillMode_t,
8165 n: ::libc::c_int,
8166 alpha: *const f64,
8167 x: *const cuDoubleComplex,
8168 incx: ::libc::c_int,
8169 A: *mut cuDoubleComplex,
8170 lda: ::libc::c_int,
8171 ) -> cublasStatus_t;
8172}
8173extern "C" {
8174 pub fn cublasSspr_v2(
8175 handle: cublasHandle_t,
8176 uplo: cublasFillMode_t,
8177 n: ::libc::c_int,
8178 alpha: *const f32,
8179 x: *const f32,
8180 incx: ::libc::c_int,
8181 AP: *mut f32,
8182 ) -> cublasStatus_t;
8183}
8184extern "C" {
8185 pub fn cublasDspr_v2(
8186 handle: cublasHandle_t,
8187 uplo: cublasFillMode_t,
8188 n: ::libc::c_int,
8189 alpha: *const f64,
8190 x: *const f64,
8191 incx: ::libc::c_int,
8192 AP: *mut f64,
8193 ) -> cublasStatus_t;
8194}
8195extern "C" {
8196 pub fn cublasChpr_v2(
8197 handle: cublasHandle_t,
8198 uplo: cublasFillMode_t,
8199 n: ::libc::c_int,
8200 alpha: *const f32,
8201 x: *const cuComplex,
8202 incx: ::libc::c_int,
8203 AP: *mut cuComplex,
8204 ) -> cublasStatus_t;
8205}
8206extern "C" {
8207 pub fn cublasZhpr_v2(
8208 handle: cublasHandle_t,
8209 uplo: cublasFillMode_t,
8210 n: ::libc::c_int,
8211 alpha: *const f64,
8212 x: *const cuDoubleComplex,
8213 incx: ::libc::c_int,
8214 AP: *mut cuDoubleComplex,
8215 ) -> cublasStatus_t;
8216}
8217extern "C" {
8218 pub fn cublasSsyr2_v2(
8219 handle: cublasHandle_t,
8220 uplo: cublasFillMode_t,
8221 n: ::libc::c_int,
8222 alpha: *const f32,
8223 x: *const f32,
8224 incx: ::libc::c_int,
8225 y: *const f32,
8226 incy: ::libc::c_int,
8227 A: *mut f32,
8228 lda: ::libc::c_int,
8229 ) -> cublasStatus_t;
8230}
8231extern "C" {
8232 pub fn cublasDsyr2_v2(
8233 handle: cublasHandle_t,
8234 uplo: cublasFillMode_t,
8235 n: ::libc::c_int,
8236 alpha: *const f64,
8237 x: *const f64,
8238 incx: ::libc::c_int,
8239 y: *const f64,
8240 incy: ::libc::c_int,
8241 A: *mut f64,
8242 lda: ::libc::c_int,
8243 ) -> cublasStatus_t;
8244}
8245extern "C" {
8246 pub fn cublasCsyr2_v2(
8247 handle: cublasHandle_t,
8248 uplo: cublasFillMode_t,
8249 n: ::libc::c_int,
8250 alpha: *const cuComplex,
8251 x: *const cuComplex,
8252 incx: ::libc::c_int,
8253 y: *const cuComplex,
8254 incy: ::libc::c_int,
8255 A: *mut cuComplex,
8256 lda: ::libc::c_int,
8257 ) -> cublasStatus_t;
8258}
8259extern "C" {
8260 pub fn cublasZsyr2_v2(
8261 handle: cublasHandle_t,
8262 uplo: cublasFillMode_t,
8263 n: ::libc::c_int,
8264 alpha: *const cuDoubleComplex,
8265 x: *const cuDoubleComplex,
8266 incx: ::libc::c_int,
8267 y: *const cuDoubleComplex,
8268 incy: ::libc::c_int,
8269 A: *mut cuDoubleComplex,
8270 lda: ::libc::c_int,
8271 ) -> cublasStatus_t;
8272}
8273extern "C" {
8274 pub fn cublasCher2_v2(
8275 handle: cublasHandle_t,
8276 uplo: cublasFillMode_t,
8277 n: ::libc::c_int,
8278 alpha: *const cuComplex,
8279 x: *const cuComplex,
8280 incx: ::libc::c_int,
8281 y: *const cuComplex,
8282 incy: ::libc::c_int,
8283 A: *mut cuComplex,
8284 lda: ::libc::c_int,
8285 ) -> cublasStatus_t;
8286}
8287extern "C" {
8288 pub fn cublasZher2_v2(
8289 handle: cublasHandle_t,
8290 uplo: cublasFillMode_t,
8291 n: ::libc::c_int,
8292 alpha: *const cuDoubleComplex,
8293 x: *const cuDoubleComplex,
8294 incx: ::libc::c_int,
8295 y: *const cuDoubleComplex,
8296 incy: ::libc::c_int,
8297 A: *mut cuDoubleComplex,
8298 lda: ::libc::c_int,
8299 ) -> cublasStatus_t;
8300}
8301extern "C" {
8302 pub fn cublasSspr2_v2(
8303 handle: cublasHandle_t,
8304 uplo: cublasFillMode_t,
8305 n: ::libc::c_int,
8306 alpha: *const f32,
8307 x: *const f32,
8308 incx: ::libc::c_int,
8309 y: *const f32,
8310 incy: ::libc::c_int,
8311 AP: *mut f32,
8312 ) -> cublasStatus_t;
8313}
8314extern "C" {
8315 pub fn cublasDspr2_v2(
8316 handle: cublasHandle_t,
8317 uplo: cublasFillMode_t,
8318 n: ::libc::c_int,
8319 alpha: *const f64,
8320 x: *const f64,
8321 incx: ::libc::c_int,
8322 y: *const f64,
8323 incy: ::libc::c_int,
8324 AP: *mut f64,
8325 ) -> cublasStatus_t;
8326}
8327extern "C" {
8328 pub fn cublasChpr2_v2(
8329 handle: cublasHandle_t,
8330 uplo: cublasFillMode_t,
8331 n: ::libc::c_int,
8332 alpha: *const cuComplex,
8333 x: *const cuComplex,
8334 incx: ::libc::c_int,
8335 y: *const cuComplex,
8336 incy: ::libc::c_int,
8337 AP: *mut cuComplex,
8338 ) -> cublasStatus_t;
8339}
8340extern "C" {
8341 pub fn cublasZhpr2_v2(
8342 handle: cublasHandle_t,
8343 uplo: cublasFillMode_t,
8344 n: ::libc::c_int,
8345 alpha: *const cuDoubleComplex,
8346 x: *const cuDoubleComplex,
8347 incx: ::libc::c_int,
8348 y: *const cuDoubleComplex,
8349 incy: ::libc::c_int,
8350 AP: *mut cuDoubleComplex,
8351 ) -> cublasStatus_t;
8352}
8353extern "C" {
8354 pub fn cublasSgemm_v2(
8355 handle: cublasHandle_t,
8356 transa: cublasOperation_t,
8357 transb: cublasOperation_t,
8358 m: ::libc::c_int,
8359 n: ::libc::c_int,
8360 k: ::libc::c_int,
8361 alpha: *const f32,
8362 A: *const f32,
8363 lda: ::libc::c_int,
8364 B: *const f32,
8365 ldb: ::libc::c_int,
8366 beta: *const f32,
8367 C: *mut f32,
8368 ldc: ::libc::c_int,
8369 ) -> cublasStatus_t;
8370}
8371extern "C" {
8372 pub fn cublasDgemm_v2(
8373 handle: cublasHandle_t,
8374 transa: cublasOperation_t,
8375 transb: cublasOperation_t,
8376 m: ::libc::c_int,
8377 n: ::libc::c_int,
8378 k: ::libc::c_int,
8379 alpha: *const f64,
8380 A: *const f64,
8381 lda: ::libc::c_int,
8382 B: *const f64,
8383 ldb: ::libc::c_int,
8384 beta: *const f64,
8385 C: *mut f64,
8386 ldc: ::libc::c_int,
8387 ) -> cublasStatus_t;
8388}
8389extern "C" {
8390 pub fn cublasCgemm_v2(
8391 handle: cublasHandle_t,
8392 transa: cublasOperation_t,
8393 transb: cublasOperation_t,
8394 m: ::libc::c_int,
8395 n: ::libc::c_int,
8396 k: ::libc::c_int,
8397 alpha: *const cuComplex,
8398 A: *const cuComplex,
8399 lda: ::libc::c_int,
8400 B: *const cuComplex,
8401 ldb: ::libc::c_int,
8402 beta: *const cuComplex,
8403 C: *mut cuComplex,
8404 ldc: ::libc::c_int,
8405 ) -> cublasStatus_t;
8406}
8407extern "C" {
8408 pub fn cublasCgemm3m(
8409 handle: cublasHandle_t,
8410 transa: cublasOperation_t,
8411 transb: cublasOperation_t,
8412 m: ::libc::c_int,
8413 n: ::libc::c_int,
8414 k: ::libc::c_int,
8415 alpha: *const cuComplex,
8416 A: *const cuComplex,
8417 lda: ::libc::c_int,
8418 B: *const cuComplex,
8419 ldb: ::libc::c_int,
8420 beta: *const cuComplex,
8421 C: *mut cuComplex,
8422 ldc: ::libc::c_int,
8423 ) -> cublasStatus_t;
8424}
8425extern "C" {
8426 pub fn cublasCgemm3mEx(
8427 handle: cublasHandle_t,
8428 transa: cublasOperation_t,
8429 transb: cublasOperation_t,
8430 m: ::libc::c_int,
8431 n: ::libc::c_int,
8432 k: ::libc::c_int,
8433 alpha: *const cuComplex,
8434 A: *const ::libc::c_void,
8435 Atype: cudaDataType,
8436 lda: ::libc::c_int,
8437 B: *const ::libc::c_void,
8438 Btype: cudaDataType,
8439 ldb: ::libc::c_int,
8440 beta: *const cuComplex,
8441 C: *mut ::libc::c_void,
8442 Ctype: cudaDataType,
8443 ldc: ::libc::c_int,
8444 ) -> cublasStatus_t;
8445}
8446extern "C" {
8447 pub fn cublasZgemm_v2(
8448 handle: cublasHandle_t,
8449 transa: cublasOperation_t,
8450 transb: cublasOperation_t,
8451 m: ::libc::c_int,
8452 n: ::libc::c_int,
8453 k: ::libc::c_int,
8454 alpha: *const cuDoubleComplex,
8455 A: *const cuDoubleComplex,
8456 lda: ::libc::c_int,
8457 B: *const cuDoubleComplex,
8458 ldb: ::libc::c_int,
8459 beta: *const cuDoubleComplex,
8460 C: *mut cuDoubleComplex,
8461 ldc: ::libc::c_int,
8462 ) -> cublasStatus_t;
8463}
8464extern "C" {
8465 pub fn cublasZgemm3m(
8466 handle: cublasHandle_t,
8467 transa: cublasOperation_t,
8468 transb: cublasOperation_t,
8469 m: ::libc::c_int,
8470 n: ::libc::c_int,
8471 k: ::libc::c_int,
8472 alpha: *const cuDoubleComplex,
8473 A: *const cuDoubleComplex,
8474 lda: ::libc::c_int,
8475 B: *const cuDoubleComplex,
8476 ldb: ::libc::c_int,
8477 beta: *const cuDoubleComplex,
8478 C: *mut cuDoubleComplex,
8479 ldc: ::libc::c_int,
8480 ) -> cublasStatus_t;
8481}
8482extern "C" {
8483 pub fn cublasSgemmEx(
8484 handle: cublasHandle_t,
8485 transa: cublasOperation_t,
8486 transb: cublasOperation_t,
8487 m: ::libc::c_int,
8488 n: ::libc::c_int,
8489 k: ::libc::c_int,
8490 alpha: *const f32,
8491 A: *const ::libc::c_void,
8492 Atype: cudaDataType,
8493 lda: ::libc::c_int,
8494 B: *const ::libc::c_void,
8495 Btype: cudaDataType,
8496 ldb: ::libc::c_int,
8497 beta: *const f32,
8498 C: *mut ::libc::c_void,
8499 Ctype: cudaDataType,
8500 ldc: ::libc::c_int,
8501 ) -> cublasStatus_t;
8502}
8503extern "C" {
8504 pub fn cublasGemmEx(
8505 handle: cublasHandle_t,
8506 transa: cublasOperation_t,
8507 transb: cublasOperation_t,
8508 m: ::libc::c_int,
8509 n: ::libc::c_int,
8510 k: ::libc::c_int,
8511 alpha: *const ::libc::c_void,
8512 A: *const ::libc::c_void,
8513 Atype: cudaDataType,
8514 lda: ::libc::c_int,
8515 B: *const ::libc::c_void,
8516 Btype: cudaDataType,
8517 ldb: ::libc::c_int,
8518 beta: *const ::libc::c_void,
8519 C: *mut ::libc::c_void,
8520 Ctype: cudaDataType,
8521 ldc: ::libc::c_int,
8522 computeType: cublasComputeType_t,
8523 algo: cublasGemmAlgo_t,
8524 ) -> cublasStatus_t;
8525}
8526extern "C" {
8527 pub fn cublasCgemmEx(
8528 handle: cublasHandle_t,
8529 transa: cublasOperation_t,
8530 transb: cublasOperation_t,
8531 m: ::libc::c_int,
8532 n: ::libc::c_int,
8533 k: ::libc::c_int,
8534 alpha: *const cuComplex,
8535 A: *const ::libc::c_void,
8536 Atype: cudaDataType,
8537 lda: ::libc::c_int,
8538 B: *const ::libc::c_void,
8539 Btype: cudaDataType,
8540 ldb: ::libc::c_int,
8541 beta: *const cuComplex,
8542 C: *mut ::libc::c_void,
8543 Ctype: cudaDataType,
8544 ldc: ::libc::c_int,
8545 ) -> cublasStatus_t;
8546}
8547extern "C" {
8548 pub fn cublasUint8gemmBias(
8549 handle: cublasHandle_t,
8550 transa: cublasOperation_t,
8551 transb: cublasOperation_t,
8552 transc: cublasOperation_t,
8553 m: ::libc::c_int,
8554 n: ::libc::c_int,
8555 k: ::libc::c_int,
8556 A: *const ::libc::c_uchar,
8557 A_bias: ::libc::c_int,
8558 lda: ::libc::c_int,
8559 B: *const ::libc::c_uchar,
8560 B_bias: ::libc::c_int,
8561 ldb: ::libc::c_int,
8562 C: *mut ::libc::c_uchar,
8563 C_bias: ::libc::c_int,
8564 ldc: ::libc::c_int,
8565 C_mult: ::libc::c_int,
8566 C_shift: ::libc::c_int,
8567 ) -> cublasStatus_t;
8568}
8569extern "C" {
8570 pub fn cublasSsyrk_v2(
8571 handle: cublasHandle_t,
8572 uplo: cublasFillMode_t,
8573 trans: cublasOperation_t,
8574 n: ::libc::c_int,
8575 k: ::libc::c_int,
8576 alpha: *const f32,
8577 A: *const f32,
8578 lda: ::libc::c_int,
8579 beta: *const f32,
8580 C: *mut f32,
8581 ldc: ::libc::c_int,
8582 ) -> cublasStatus_t;
8583}
8584extern "C" {
8585 pub fn cublasDsyrk_v2(
8586 handle: cublasHandle_t,
8587 uplo: cublasFillMode_t,
8588 trans: cublasOperation_t,
8589 n: ::libc::c_int,
8590 k: ::libc::c_int,
8591 alpha: *const f64,
8592 A: *const f64,
8593 lda: ::libc::c_int,
8594 beta: *const f64,
8595 C: *mut f64,
8596 ldc: ::libc::c_int,
8597 ) -> cublasStatus_t;
8598}
8599extern "C" {
8600 pub fn cublasCsyrk_v2(
8601 handle: cublasHandle_t,
8602 uplo: cublasFillMode_t,
8603 trans: cublasOperation_t,
8604 n: ::libc::c_int,
8605 k: ::libc::c_int,
8606 alpha: *const cuComplex,
8607 A: *const cuComplex,
8608 lda: ::libc::c_int,
8609 beta: *const cuComplex,
8610 C: *mut cuComplex,
8611 ldc: ::libc::c_int,
8612 ) -> cublasStatus_t;
8613}
8614extern "C" {
8615 pub fn cublasZsyrk_v2(
8616 handle: cublasHandle_t,
8617 uplo: cublasFillMode_t,
8618 trans: cublasOperation_t,
8619 n: ::libc::c_int,
8620 k: ::libc::c_int,
8621 alpha: *const cuDoubleComplex,
8622 A: *const cuDoubleComplex,
8623 lda: ::libc::c_int,
8624 beta: *const cuDoubleComplex,
8625 C: *mut cuDoubleComplex,
8626 ldc: ::libc::c_int,
8627 ) -> cublasStatus_t;
8628}
8629extern "C" {
8630 pub fn cublasCsyrkEx(
8631 handle: cublasHandle_t,
8632 uplo: cublasFillMode_t,
8633 trans: cublasOperation_t,
8634 n: ::libc::c_int,
8635 k: ::libc::c_int,
8636 alpha: *const cuComplex,
8637 A: *const ::libc::c_void,
8638 Atype: cudaDataType,
8639 lda: ::libc::c_int,
8640 beta: *const cuComplex,
8641 C: *mut ::libc::c_void,
8642 Ctype: cudaDataType,
8643 ldc: ::libc::c_int,
8644 ) -> cublasStatus_t;
8645}
8646extern "C" {
8647 pub fn cublasCsyrk3mEx(
8648 handle: cublasHandle_t,
8649 uplo: cublasFillMode_t,
8650 trans: cublasOperation_t,
8651 n: ::libc::c_int,
8652 k: ::libc::c_int,
8653 alpha: *const cuComplex,
8654 A: *const ::libc::c_void,
8655 Atype: cudaDataType,
8656 lda: ::libc::c_int,
8657 beta: *const cuComplex,
8658 C: *mut ::libc::c_void,
8659 Ctype: cudaDataType,
8660 ldc: ::libc::c_int,
8661 ) -> cublasStatus_t;
8662}
8663extern "C" {
8664 pub fn cublasCherk_v2(
8665 handle: cublasHandle_t,
8666 uplo: cublasFillMode_t,
8667 trans: cublasOperation_t,
8668 n: ::libc::c_int,
8669 k: ::libc::c_int,
8670 alpha: *const f32,
8671 A: *const cuComplex,
8672 lda: ::libc::c_int,
8673 beta: *const f32,
8674 C: *mut cuComplex,
8675 ldc: ::libc::c_int,
8676 ) -> cublasStatus_t;
8677}
8678extern "C" {
8679 pub fn cublasZherk_v2(
8680 handle: cublasHandle_t,
8681 uplo: cublasFillMode_t,
8682 trans: cublasOperation_t,
8683 n: ::libc::c_int,
8684 k: ::libc::c_int,
8685 alpha: *const f64,
8686 A: *const cuDoubleComplex,
8687 lda: ::libc::c_int,
8688 beta: *const f64,
8689 C: *mut cuDoubleComplex,
8690 ldc: ::libc::c_int,
8691 ) -> cublasStatus_t;
8692}
8693extern "C" {
8694 pub fn cublasCherkEx(
8695 handle: cublasHandle_t,
8696 uplo: cublasFillMode_t,
8697 trans: cublasOperation_t,
8698 n: ::libc::c_int,
8699 k: ::libc::c_int,
8700 alpha: *const f32,
8701 A: *const ::libc::c_void,
8702 Atype: cudaDataType,
8703 lda: ::libc::c_int,
8704 beta: *const f32,
8705 C: *mut ::libc::c_void,
8706 Ctype: cudaDataType,
8707 ldc: ::libc::c_int,
8708 ) -> cublasStatus_t;
8709}
8710extern "C" {
8711 pub fn cublasCherk3mEx(
8712 handle: cublasHandle_t,
8713 uplo: cublasFillMode_t,
8714 trans: cublasOperation_t,
8715 n: ::libc::c_int,
8716 k: ::libc::c_int,
8717 alpha: *const f32,
8718 A: *const ::libc::c_void,
8719 Atype: cudaDataType,
8720 lda: ::libc::c_int,
8721 beta: *const f32,
8722 C: *mut ::libc::c_void,
8723 Ctype: cudaDataType,
8724 ldc: ::libc::c_int,
8725 ) -> cublasStatus_t;
8726}
8727extern "C" {
8728 pub fn cublasSsyr2k_v2(
8729 handle: cublasHandle_t,
8730 uplo: cublasFillMode_t,
8731 trans: cublasOperation_t,
8732 n: ::libc::c_int,
8733 k: ::libc::c_int,
8734 alpha: *const f32,
8735 A: *const f32,
8736 lda: ::libc::c_int,
8737 B: *const f32,
8738 ldb: ::libc::c_int,
8739 beta: *const f32,
8740 C: *mut f32,
8741 ldc: ::libc::c_int,
8742 ) -> cublasStatus_t;
8743}
8744extern "C" {
8745 pub fn cublasDsyr2k_v2(
8746 handle: cublasHandle_t,
8747 uplo: cublasFillMode_t,
8748 trans: cublasOperation_t,
8749 n: ::libc::c_int,
8750 k: ::libc::c_int,
8751 alpha: *const f64,
8752 A: *const f64,
8753 lda: ::libc::c_int,
8754 B: *const f64,
8755 ldb: ::libc::c_int,
8756 beta: *const f64,
8757 C: *mut f64,
8758 ldc: ::libc::c_int,
8759 ) -> cublasStatus_t;
8760}
8761extern "C" {
8762 pub fn cublasCsyr2k_v2(
8763 handle: cublasHandle_t,
8764 uplo: cublasFillMode_t,
8765 trans: cublasOperation_t,
8766 n: ::libc::c_int,
8767 k: ::libc::c_int,
8768 alpha: *const cuComplex,
8769 A: *const cuComplex,
8770 lda: ::libc::c_int,
8771 B: *const cuComplex,
8772 ldb: ::libc::c_int,
8773 beta: *const cuComplex,
8774 C: *mut cuComplex,
8775 ldc: ::libc::c_int,
8776 ) -> cublasStatus_t;
8777}
8778extern "C" {
8779 pub fn cublasZsyr2k_v2(
8780 handle: cublasHandle_t,
8781 uplo: cublasFillMode_t,
8782 trans: cublasOperation_t,
8783 n: ::libc::c_int,
8784 k: ::libc::c_int,
8785 alpha: *const cuDoubleComplex,
8786 A: *const cuDoubleComplex,
8787 lda: ::libc::c_int,
8788 B: *const cuDoubleComplex,
8789 ldb: ::libc::c_int,
8790 beta: *const cuDoubleComplex,
8791 C: *mut cuDoubleComplex,
8792 ldc: ::libc::c_int,
8793 ) -> cublasStatus_t;
8794}
8795extern "C" {
8796 pub fn cublasCher2k_v2(
8797 handle: cublasHandle_t,
8798 uplo: cublasFillMode_t,
8799 trans: cublasOperation_t,
8800 n: ::libc::c_int,
8801 k: ::libc::c_int,
8802 alpha: *const cuComplex,
8803 A: *const cuComplex,
8804 lda: ::libc::c_int,
8805 B: *const cuComplex,
8806 ldb: ::libc::c_int,
8807 beta: *const f32,
8808 C: *mut cuComplex,
8809 ldc: ::libc::c_int,
8810 ) -> cublasStatus_t;
8811}
8812extern "C" {
8813 pub fn cublasZher2k_v2(
8814 handle: cublasHandle_t,
8815 uplo: cublasFillMode_t,
8816 trans: cublasOperation_t,
8817 n: ::libc::c_int,
8818 k: ::libc::c_int,
8819 alpha: *const cuDoubleComplex,
8820 A: *const cuDoubleComplex,
8821 lda: ::libc::c_int,
8822 B: *const cuDoubleComplex,
8823 ldb: ::libc::c_int,
8824 beta: *const f64,
8825 C: *mut cuDoubleComplex,
8826 ldc: ::libc::c_int,
8827 ) -> cublasStatus_t;
8828}
8829extern "C" {
8830 pub fn cublasSsyrkx(
8831 handle: cublasHandle_t,
8832 uplo: cublasFillMode_t,
8833 trans: cublasOperation_t,
8834 n: ::libc::c_int,
8835 k: ::libc::c_int,
8836 alpha: *const f32,
8837 A: *const f32,
8838 lda: ::libc::c_int,
8839 B: *const f32,
8840 ldb: ::libc::c_int,
8841 beta: *const f32,
8842 C: *mut f32,
8843 ldc: ::libc::c_int,
8844 ) -> cublasStatus_t;
8845}
8846extern "C" {
8847 pub fn cublasDsyrkx(
8848 handle: cublasHandle_t,
8849 uplo: cublasFillMode_t,
8850 trans: cublasOperation_t,
8851 n: ::libc::c_int,
8852 k: ::libc::c_int,
8853 alpha: *const f64,
8854 A: *const f64,
8855 lda: ::libc::c_int,
8856 B: *const f64,
8857 ldb: ::libc::c_int,
8858 beta: *const f64,
8859 C: *mut f64,
8860 ldc: ::libc::c_int,
8861 ) -> cublasStatus_t;
8862}
8863extern "C" {
8864 pub fn cublasCsyrkx(
8865 handle: cublasHandle_t,
8866 uplo: cublasFillMode_t,
8867 trans: cublasOperation_t,
8868 n: ::libc::c_int,
8869 k: ::libc::c_int,
8870 alpha: *const cuComplex,
8871 A: *const cuComplex,
8872 lda: ::libc::c_int,
8873 B: *const cuComplex,
8874 ldb: ::libc::c_int,
8875 beta: *const cuComplex,
8876 C: *mut cuComplex,
8877 ldc: ::libc::c_int,
8878 ) -> cublasStatus_t;
8879}
8880extern "C" {
8881 pub fn cublasZsyrkx(
8882 handle: cublasHandle_t,
8883 uplo: cublasFillMode_t,
8884 trans: cublasOperation_t,
8885 n: ::libc::c_int,
8886 k: ::libc::c_int,
8887 alpha: *const cuDoubleComplex,
8888 A: *const cuDoubleComplex,
8889 lda: ::libc::c_int,
8890 B: *const cuDoubleComplex,
8891 ldb: ::libc::c_int,
8892 beta: *const cuDoubleComplex,
8893 C: *mut cuDoubleComplex,
8894 ldc: ::libc::c_int,
8895 ) -> cublasStatus_t;
8896}
8897extern "C" {
8898 pub fn cublasCherkx(
8899 handle: cublasHandle_t,
8900 uplo: cublasFillMode_t,
8901 trans: cublasOperation_t,
8902 n: ::libc::c_int,
8903 k: ::libc::c_int,
8904 alpha: *const cuComplex,
8905 A: *const cuComplex,
8906 lda: ::libc::c_int,
8907 B: *const cuComplex,
8908 ldb: ::libc::c_int,
8909 beta: *const f32,
8910 C: *mut cuComplex,
8911 ldc: ::libc::c_int,
8912 ) -> cublasStatus_t;
8913}
8914extern "C" {
8915 pub fn cublasZherkx(
8916 handle: cublasHandle_t,
8917 uplo: cublasFillMode_t,
8918 trans: cublasOperation_t,
8919 n: ::libc::c_int,
8920 k: ::libc::c_int,
8921 alpha: *const cuDoubleComplex,
8922 A: *const cuDoubleComplex,
8923 lda: ::libc::c_int,
8924 B: *const cuDoubleComplex,
8925 ldb: ::libc::c_int,
8926 beta: *const f64,
8927 C: *mut cuDoubleComplex,
8928 ldc: ::libc::c_int,
8929 ) -> cublasStatus_t;
8930}
8931extern "C" {
8932 pub fn cublasSsymm_v2(
8933 handle: cublasHandle_t,
8934 side: cublasSideMode_t,
8935 uplo: cublasFillMode_t,
8936 m: ::libc::c_int,
8937 n: ::libc::c_int,
8938 alpha: *const f32,
8939 A: *const f32,
8940 lda: ::libc::c_int,
8941 B: *const f32,
8942 ldb: ::libc::c_int,
8943 beta: *const f32,
8944 C: *mut f32,
8945 ldc: ::libc::c_int,
8946 ) -> cublasStatus_t;
8947}
8948extern "C" {
8949 pub fn cublasDsymm_v2(
8950 handle: cublasHandle_t,
8951 side: cublasSideMode_t,
8952 uplo: cublasFillMode_t,
8953 m: ::libc::c_int,
8954 n: ::libc::c_int,
8955 alpha: *const f64,
8956 A: *const f64,
8957 lda: ::libc::c_int,
8958 B: *const f64,
8959 ldb: ::libc::c_int,
8960 beta: *const f64,
8961 C: *mut f64,
8962 ldc: ::libc::c_int,
8963 ) -> cublasStatus_t;
8964}
8965extern "C" {
8966 pub fn cublasCsymm_v2(
8967 handle: cublasHandle_t,
8968 side: cublasSideMode_t,
8969 uplo: cublasFillMode_t,
8970 m: ::libc::c_int,
8971 n: ::libc::c_int,
8972 alpha: *const cuComplex,
8973 A: *const cuComplex,
8974 lda: ::libc::c_int,
8975 B: *const cuComplex,
8976 ldb: ::libc::c_int,
8977 beta: *const cuComplex,
8978 C: *mut cuComplex,
8979 ldc: ::libc::c_int,
8980 ) -> cublasStatus_t;
8981}
8982extern "C" {
8983 pub fn cublasZsymm_v2(
8984 handle: cublasHandle_t,
8985 side: cublasSideMode_t,
8986 uplo: cublasFillMode_t,
8987 m: ::libc::c_int,
8988 n: ::libc::c_int,
8989 alpha: *const cuDoubleComplex,
8990 A: *const cuDoubleComplex,
8991 lda: ::libc::c_int,
8992 B: *const cuDoubleComplex,
8993 ldb: ::libc::c_int,
8994 beta: *const cuDoubleComplex,
8995 C: *mut cuDoubleComplex,
8996 ldc: ::libc::c_int,
8997 ) -> cublasStatus_t;
8998}
8999extern "C" {
9000 pub fn cublasChemm_v2(
9001 handle: cublasHandle_t,
9002 side: cublasSideMode_t,
9003 uplo: cublasFillMode_t,
9004 m: ::libc::c_int,
9005 n: ::libc::c_int,
9006 alpha: *const cuComplex,
9007 A: *const cuComplex,
9008 lda: ::libc::c_int,
9009 B: *const cuComplex,
9010 ldb: ::libc::c_int,
9011 beta: *const cuComplex,
9012 C: *mut cuComplex,
9013 ldc: ::libc::c_int,
9014 ) -> cublasStatus_t;
9015}
9016extern "C" {
9017 pub fn cublasZhemm_v2(
9018 handle: cublasHandle_t,
9019 side: cublasSideMode_t,
9020 uplo: cublasFillMode_t,
9021 m: ::libc::c_int,
9022 n: ::libc::c_int,
9023 alpha: *const cuDoubleComplex,
9024 A: *const cuDoubleComplex,
9025 lda: ::libc::c_int,
9026 B: *const cuDoubleComplex,
9027 ldb: ::libc::c_int,
9028 beta: *const cuDoubleComplex,
9029 C: *mut cuDoubleComplex,
9030 ldc: ::libc::c_int,
9031 ) -> cublasStatus_t;
9032}
9033extern "C" {
9034 pub fn cublasStrsm_v2(
9035 handle: cublasHandle_t,
9036 side: cublasSideMode_t,
9037 uplo: cublasFillMode_t,
9038 trans: cublasOperation_t,
9039 diag: cublasDiagType_t,
9040 m: ::libc::c_int,
9041 n: ::libc::c_int,
9042 alpha: *const f32,
9043 A: *const f32,
9044 lda: ::libc::c_int,
9045 B: *mut f32,
9046 ldb: ::libc::c_int,
9047 ) -> cublasStatus_t;
9048}
9049extern "C" {
9050 pub fn cublasDtrsm_v2(
9051 handle: cublasHandle_t,
9052 side: cublasSideMode_t,
9053 uplo: cublasFillMode_t,
9054 trans: cublasOperation_t,
9055 diag: cublasDiagType_t,
9056 m: ::libc::c_int,
9057 n: ::libc::c_int,
9058 alpha: *const f64,
9059 A: *const f64,
9060 lda: ::libc::c_int,
9061 B: *mut f64,
9062 ldb: ::libc::c_int,
9063 ) -> cublasStatus_t;
9064}
9065extern "C" {
9066 pub fn cublasCtrsm_v2(
9067 handle: cublasHandle_t,
9068 side: cublasSideMode_t,
9069 uplo: cublasFillMode_t,
9070 trans: cublasOperation_t,
9071 diag: cublasDiagType_t,
9072 m: ::libc::c_int,
9073 n: ::libc::c_int,
9074 alpha: *const cuComplex,
9075 A: *const cuComplex,
9076 lda: ::libc::c_int,
9077 B: *mut cuComplex,
9078 ldb: ::libc::c_int,
9079 ) -> cublasStatus_t;
9080}
9081extern "C" {
9082 pub fn cublasZtrsm_v2(
9083 handle: cublasHandle_t,
9084 side: cublasSideMode_t,
9085 uplo: cublasFillMode_t,
9086 trans: cublasOperation_t,
9087 diag: cublasDiagType_t,
9088 m: ::libc::c_int,
9089 n: ::libc::c_int,
9090 alpha: *const cuDoubleComplex,
9091 A: *const cuDoubleComplex,
9092 lda: ::libc::c_int,
9093 B: *mut cuDoubleComplex,
9094 ldb: ::libc::c_int,
9095 ) -> cublasStatus_t;
9096}
9097extern "C" {
9098 pub fn cublasStrmm_v2(
9099 handle: cublasHandle_t,
9100 side: cublasSideMode_t,
9101 uplo: cublasFillMode_t,
9102 trans: cublasOperation_t,
9103 diag: cublasDiagType_t,
9104 m: ::libc::c_int,
9105 n: ::libc::c_int,
9106 alpha: *const f32,
9107 A: *const f32,
9108 lda: ::libc::c_int,
9109 B: *const f32,
9110 ldb: ::libc::c_int,
9111 C: *mut f32,
9112 ldc: ::libc::c_int,
9113 ) -> cublasStatus_t;
9114}
9115extern "C" {
9116 pub fn cublasDtrmm_v2(
9117 handle: cublasHandle_t,
9118 side: cublasSideMode_t,
9119 uplo: cublasFillMode_t,
9120 trans: cublasOperation_t,
9121 diag: cublasDiagType_t,
9122 m: ::libc::c_int,
9123 n: ::libc::c_int,
9124 alpha: *const f64,
9125 A: *const f64,
9126 lda: ::libc::c_int,
9127 B: *const f64,
9128 ldb: ::libc::c_int,
9129 C: *mut f64,
9130 ldc: ::libc::c_int,
9131 ) -> cublasStatus_t;
9132}
9133extern "C" {
9134 pub fn cublasCtrmm_v2(
9135 handle: cublasHandle_t,
9136 side: cublasSideMode_t,
9137 uplo: cublasFillMode_t,
9138 trans: cublasOperation_t,
9139 diag: cublasDiagType_t,
9140 m: ::libc::c_int,
9141 n: ::libc::c_int,
9142 alpha: *const cuComplex,
9143 A: *const cuComplex,
9144 lda: ::libc::c_int,
9145 B: *const cuComplex,
9146 ldb: ::libc::c_int,
9147 C: *mut cuComplex,
9148 ldc: ::libc::c_int,
9149 ) -> cublasStatus_t;
9150}
9151extern "C" {
9152 pub fn cublasZtrmm_v2(
9153 handle: cublasHandle_t,
9154 side: cublasSideMode_t,
9155 uplo: cublasFillMode_t,
9156 trans: cublasOperation_t,
9157 diag: cublasDiagType_t,
9158 m: ::libc::c_int,
9159 n: ::libc::c_int,
9160 alpha: *const cuDoubleComplex,
9161 A: *const cuDoubleComplex,
9162 lda: ::libc::c_int,
9163 B: *const cuDoubleComplex,
9164 ldb: ::libc::c_int,
9165 C: *mut cuDoubleComplex,
9166 ldc: ::libc::c_int,
9167 ) -> cublasStatus_t;
9168}
9169extern "C" {
9170 pub fn cublasSgemmBatched(
9171 handle: cublasHandle_t,
9172 transa: cublasOperation_t,
9173 transb: cublasOperation_t,
9174 m: ::libc::c_int,
9175 n: ::libc::c_int,
9176 k: ::libc::c_int,
9177 alpha: *const f32,
9178 Aarray: *const *const f32,
9179 lda: ::libc::c_int,
9180 Barray: *const *const f32,
9181 ldb: ::libc::c_int,
9182 beta: *const f32,
9183 Carray: *const *mut f32,
9184 ldc: ::libc::c_int,
9185 batchCount: ::libc::c_int,
9186 ) -> cublasStatus_t;
9187}
9188extern "C" {
9189 pub fn cublasDgemmBatched(
9190 handle: cublasHandle_t,
9191 transa: cublasOperation_t,
9192 transb: cublasOperation_t,
9193 m: ::libc::c_int,
9194 n: ::libc::c_int,
9195 k: ::libc::c_int,
9196 alpha: *const f64,
9197 Aarray: *const *const f64,
9198 lda: ::libc::c_int,
9199 Barray: *const *const f64,
9200 ldb: ::libc::c_int,
9201 beta: *const f64,
9202 Carray: *const *mut f64,
9203 ldc: ::libc::c_int,
9204 batchCount: ::libc::c_int,
9205 ) -> cublasStatus_t;
9206}
9207extern "C" {
9208 pub fn cublasCgemmBatched(
9209 handle: cublasHandle_t,
9210 transa: cublasOperation_t,
9211 transb: cublasOperation_t,
9212 m: ::libc::c_int,
9213 n: ::libc::c_int,
9214 k: ::libc::c_int,
9215 alpha: *const cuComplex,
9216 Aarray: *const *const cuComplex,
9217 lda: ::libc::c_int,
9218 Barray: *const *const cuComplex,
9219 ldb: ::libc::c_int,
9220 beta: *const cuComplex,
9221 Carray: *const *mut cuComplex,
9222 ldc: ::libc::c_int,
9223 batchCount: ::libc::c_int,
9224 ) -> cublasStatus_t;
9225}
9226extern "C" {
9227 pub fn cublasCgemm3mBatched(
9228 handle: cublasHandle_t,
9229 transa: cublasOperation_t,
9230 transb: cublasOperation_t,
9231 m: ::libc::c_int,
9232 n: ::libc::c_int,
9233 k: ::libc::c_int,
9234 alpha: *const cuComplex,
9235 Aarray: *const *const cuComplex,
9236 lda: ::libc::c_int,
9237 Barray: *const *const cuComplex,
9238 ldb: ::libc::c_int,
9239 beta: *const cuComplex,
9240 Carray: *const *mut cuComplex,
9241 ldc: ::libc::c_int,
9242 batchCount: ::libc::c_int,
9243 ) -> cublasStatus_t;
9244}
9245extern "C" {
9246 pub fn cublasZgemmBatched(
9247 handle: cublasHandle_t,
9248 transa: cublasOperation_t,
9249 transb: cublasOperation_t,
9250 m: ::libc::c_int,
9251 n: ::libc::c_int,
9252 k: ::libc::c_int,
9253 alpha: *const cuDoubleComplex,
9254 Aarray: *const *const cuDoubleComplex,
9255 lda: ::libc::c_int,
9256 Barray: *const *const cuDoubleComplex,
9257 ldb: ::libc::c_int,
9258 beta: *const cuDoubleComplex,
9259 Carray: *const *mut cuDoubleComplex,
9260 ldc: ::libc::c_int,
9261 batchCount: ::libc::c_int,
9262 ) -> cublasStatus_t;
9263}
9264extern "C" {
9265 pub fn cublasGemmBatchedEx(
9266 handle: cublasHandle_t,
9267 transa: cublasOperation_t,
9268 transb: cublasOperation_t,
9269 m: ::libc::c_int,
9270 n: ::libc::c_int,
9271 k: ::libc::c_int,
9272 alpha: *const ::libc::c_void,
9273 Aarray: *const *const ::libc::c_void,
9274 Atype: cudaDataType,
9275 lda: ::libc::c_int,
9276 Barray: *const *const ::libc::c_void,
9277 Btype: cudaDataType,
9278 ldb: ::libc::c_int,
9279 beta: *const ::libc::c_void,
9280 Carray: *const *mut ::libc::c_void,
9281 Ctype: cudaDataType,
9282 ldc: ::libc::c_int,
9283 batchCount: ::libc::c_int,
9284 computeType: cublasComputeType_t,
9285 algo: cublasGemmAlgo_t,
9286 ) -> cublasStatus_t;
9287}
9288extern "C" {
9289 pub fn cublasGemmStridedBatchedEx(
9290 handle: cublasHandle_t,
9291 transa: cublasOperation_t,
9292 transb: cublasOperation_t,
9293 m: ::libc::c_int,
9294 n: ::libc::c_int,
9295 k: ::libc::c_int,
9296 alpha: *const ::libc::c_void,
9297 A: *const ::libc::c_void,
9298 Atype: cudaDataType,
9299 lda: ::libc::c_int,
9300 strideA: ::libc::c_longlong,
9301 B: *const ::libc::c_void,
9302 Btype: cudaDataType,
9303 ldb: ::libc::c_int,
9304 strideB: ::libc::c_longlong,
9305 beta: *const ::libc::c_void,
9306 C: *mut ::libc::c_void,
9307 Ctype: cudaDataType,
9308 ldc: ::libc::c_int,
9309 strideC: ::libc::c_longlong,
9310 batchCount: ::libc::c_int,
9311 computeType: cublasComputeType_t,
9312 algo: cublasGemmAlgo_t,
9313 ) -> cublasStatus_t;
9314}
9315extern "C" {
9316 pub fn cublasSgemmStridedBatched(
9317 handle: cublasHandle_t,
9318 transa: cublasOperation_t,
9319 transb: cublasOperation_t,
9320 m: ::libc::c_int,
9321 n: ::libc::c_int,
9322 k: ::libc::c_int,
9323 alpha: *const f32,
9324 A: *const f32,
9325 lda: ::libc::c_int,
9326 strideA: ::libc::c_longlong,
9327 B: *const f32,
9328 ldb: ::libc::c_int,
9329 strideB: ::libc::c_longlong,
9330 beta: *const f32,
9331 C: *mut f32,
9332 ldc: ::libc::c_int,
9333 strideC: ::libc::c_longlong,
9334 batchCount: ::libc::c_int,
9335 ) -> cublasStatus_t;
9336}
9337extern "C" {
9338 pub fn cublasDgemmStridedBatched(
9339 handle: cublasHandle_t,
9340 transa: cublasOperation_t,
9341 transb: cublasOperation_t,
9342 m: ::libc::c_int,
9343 n: ::libc::c_int,
9344 k: ::libc::c_int,
9345 alpha: *const f64,
9346 A: *const f64,
9347 lda: ::libc::c_int,
9348 strideA: ::libc::c_longlong,
9349 B: *const f64,
9350 ldb: ::libc::c_int,
9351 strideB: ::libc::c_longlong,
9352 beta: *const f64,
9353 C: *mut f64,
9354 ldc: ::libc::c_int,
9355 strideC: ::libc::c_longlong,
9356 batchCount: ::libc::c_int,
9357 ) -> cublasStatus_t;
9358}
9359extern "C" {
9360 pub fn cublasCgemmStridedBatched(
9361 handle: cublasHandle_t,
9362 transa: cublasOperation_t,
9363 transb: cublasOperation_t,
9364 m: ::libc::c_int,
9365 n: ::libc::c_int,
9366 k: ::libc::c_int,
9367 alpha: *const cuComplex,
9368 A: *const cuComplex,
9369 lda: ::libc::c_int,
9370 strideA: ::libc::c_longlong,
9371 B: *const cuComplex,
9372 ldb: ::libc::c_int,
9373 strideB: ::libc::c_longlong,
9374 beta: *const cuComplex,
9375 C: *mut cuComplex,
9376 ldc: ::libc::c_int,
9377 strideC: ::libc::c_longlong,
9378 batchCount: ::libc::c_int,
9379 ) -> cublasStatus_t;
9380}
9381extern "C" {
9382 pub fn cublasCgemm3mStridedBatched(
9383 handle: cublasHandle_t,
9384 transa: cublasOperation_t,
9385 transb: cublasOperation_t,
9386 m: ::libc::c_int,
9387 n: ::libc::c_int,
9388 k: ::libc::c_int,
9389 alpha: *const cuComplex,
9390 A: *const cuComplex,
9391 lda: ::libc::c_int,
9392 strideA: ::libc::c_longlong,
9393 B: *const cuComplex,
9394 ldb: ::libc::c_int,
9395 strideB: ::libc::c_longlong,
9396 beta: *const cuComplex,
9397 C: *mut cuComplex,
9398 ldc: ::libc::c_int,
9399 strideC: ::libc::c_longlong,
9400 batchCount: ::libc::c_int,
9401 ) -> cublasStatus_t;
9402}
9403extern "C" {
9404 pub fn cublasZgemmStridedBatched(
9405 handle: cublasHandle_t,
9406 transa: cublasOperation_t,
9407 transb: cublasOperation_t,
9408 m: ::libc::c_int,
9409 n: ::libc::c_int,
9410 k: ::libc::c_int,
9411 alpha: *const cuDoubleComplex,
9412 A: *const cuDoubleComplex,
9413 lda: ::libc::c_int,
9414 strideA: ::libc::c_longlong,
9415 B: *const cuDoubleComplex,
9416 ldb: ::libc::c_int,
9417 strideB: ::libc::c_longlong,
9418 beta: *const cuDoubleComplex,
9419 C: *mut cuDoubleComplex,
9420 ldc: ::libc::c_int,
9421 strideC: ::libc::c_longlong,
9422 batchCount: ::libc::c_int,
9423 ) -> cublasStatus_t;
9424}
9425extern "C" {
9426 pub fn cublasSgeam(
9427 handle: cublasHandle_t,
9428 transa: cublasOperation_t,
9429 transb: cublasOperation_t,
9430 m: ::libc::c_int,
9431 n: ::libc::c_int,
9432 alpha: *const f32,
9433 A: *const f32,
9434 lda: ::libc::c_int,
9435 beta: *const f32,
9436 B: *const f32,
9437 ldb: ::libc::c_int,
9438 C: *mut f32,
9439 ldc: ::libc::c_int,
9440 ) -> cublasStatus_t;
9441}
9442extern "C" {
9443 pub fn cublasDgeam(
9444 handle: cublasHandle_t,
9445 transa: cublasOperation_t,
9446 transb: cublasOperation_t,
9447 m: ::libc::c_int,
9448 n: ::libc::c_int,
9449 alpha: *const f64,
9450 A: *const f64,
9451 lda: ::libc::c_int,
9452 beta: *const f64,
9453 B: *const f64,
9454 ldb: ::libc::c_int,
9455 C: *mut f64,
9456 ldc: ::libc::c_int,
9457 ) -> cublasStatus_t;
9458}
9459extern "C" {
9460 pub fn cublasCgeam(
9461 handle: cublasHandle_t,
9462 transa: cublasOperation_t,
9463 transb: cublasOperation_t,
9464 m: ::libc::c_int,
9465 n: ::libc::c_int,
9466 alpha: *const cuComplex,
9467 A: *const cuComplex,
9468 lda: ::libc::c_int,
9469 beta: *const cuComplex,
9470 B: *const cuComplex,
9471 ldb: ::libc::c_int,
9472 C: *mut cuComplex,
9473 ldc: ::libc::c_int,
9474 ) -> cublasStatus_t;
9475}
9476extern "C" {
9477 pub fn cublasZgeam(
9478 handle: cublasHandle_t,
9479 transa: cublasOperation_t,
9480 transb: cublasOperation_t,
9481 m: ::libc::c_int,
9482 n: ::libc::c_int,
9483 alpha: *const cuDoubleComplex,
9484 A: *const cuDoubleComplex,
9485 lda: ::libc::c_int,
9486 beta: *const cuDoubleComplex,
9487 B: *const cuDoubleComplex,
9488 ldb: ::libc::c_int,
9489 C: *mut cuDoubleComplex,
9490 ldc: ::libc::c_int,
9491 ) -> cublasStatus_t;
9492}
9493extern "C" {
9494 pub fn cublasSgetrfBatched(
9495 handle: cublasHandle_t,
9496 n: ::libc::c_int,
9497 A: *const *mut f32,
9498 lda: ::libc::c_int,
9499 P: *mut ::libc::c_int,
9500 info: *mut ::libc::c_int,
9501 batchSize: ::libc::c_int,
9502 ) -> cublasStatus_t;
9503}
9504extern "C" {
9505 pub fn cublasDgetrfBatched(
9506 handle: cublasHandle_t,
9507 n: ::libc::c_int,
9508 A: *const *mut f64,
9509 lda: ::libc::c_int,
9510 P: *mut ::libc::c_int,
9511 info: *mut ::libc::c_int,
9512 batchSize: ::libc::c_int,
9513 ) -> cublasStatus_t;
9514}
9515extern "C" {
9516 pub fn cublasCgetrfBatched(
9517 handle: cublasHandle_t,
9518 n: ::libc::c_int,
9519 A: *const *mut cuComplex,
9520 lda: ::libc::c_int,
9521 P: *mut ::libc::c_int,
9522 info: *mut ::libc::c_int,
9523 batchSize: ::libc::c_int,
9524 ) -> cublasStatus_t;
9525}
9526extern "C" {
9527 pub fn cublasZgetrfBatched(
9528 handle: cublasHandle_t,
9529 n: ::libc::c_int,
9530 A: *const *mut cuDoubleComplex,
9531 lda: ::libc::c_int,
9532 P: *mut ::libc::c_int,
9533 info: *mut ::libc::c_int,
9534 batchSize: ::libc::c_int,
9535 ) -> cublasStatus_t;
9536}
9537extern "C" {
9538 pub fn cublasSgetriBatched(
9539 handle: cublasHandle_t,
9540 n: ::libc::c_int,
9541 A: *const *const f32,
9542 lda: ::libc::c_int,
9543 P: *const ::libc::c_int,
9544 C: *const *mut f32,
9545 ldc: ::libc::c_int,
9546 info: *mut ::libc::c_int,
9547 batchSize: ::libc::c_int,
9548 ) -> cublasStatus_t;
9549}
9550extern "C" {
9551 pub fn cublasDgetriBatched(
9552 handle: cublasHandle_t,
9553 n: ::libc::c_int,
9554 A: *const *const f64,
9555 lda: ::libc::c_int,
9556 P: *const ::libc::c_int,
9557 C: *const *mut f64,
9558 ldc: ::libc::c_int,
9559 info: *mut ::libc::c_int,
9560 batchSize: ::libc::c_int,
9561 ) -> cublasStatus_t;
9562}
9563extern "C" {
9564 pub fn cublasCgetriBatched(
9565 handle: cublasHandle_t,
9566 n: ::libc::c_int,
9567 A: *const *const cuComplex,
9568 lda: ::libc::c_int,
9569 P: *const ::libc::c_int,
9570 C: *const *mut cuComplex,
9571 ldc: ::libc::c_int,
9572 info: *mut ::libc::c_int,
9573 batchSize: ::libc::c_int,
9574 ) -> cublasStatus_t;
9575}
9576extern "C" {
9577 pub fn cublasZgetriBatched(
9578 handle: cublasHandle_t,
9579 n: ::libc::c_int,
9580 A: *const *const cuDoubleComplex,
9581 lda: ::libc::c_int,
9582 P: *const ::libc::c_int,
9583 C: *const *mut cuDoubleComplex,
9584 ldc: ::libc::c_int,
9585 info: *mut ::libc::c_int,
9586 batchSize: ::libc::c_int,
9587 ) -> cublasStatus_t;
9588}
9589extern "C" {
9590 pub fn cublasSgetrsBatched(
9591 handle: cublasHandle_t,
9592 trans: cublasOperation_t,
9593 n: ::libc::c_int,
9594 nrhs: ::libc::c_int,
9595 Aarray: *const *const f32,
9596 lda: ::libc::c_int,
9597 devIpiv: *const ::libc::c_int,
9598 Barray: *const *mut f32,
9599 ldb: ::libc::c_int,
9600 info: *mut ::libc::c_int,
9601 batchSize: ::libc::c_int,
9602 ) -> cublasStatus_t;
9603}
9604extern "C" {
9605 pub fn cublasDgetrsBatched(
9606 handle: cublasHandle_t,
9607 trans: cublasOperation_t,
9608 n: ::libc::c_int,
9609 nrhs: ::libc::c_int,
9610 Aarray: *const *const f64,
9611 lda: ::libc::c_int,
9612 devIpiv: *const ::libc::c_int,
9613 Barray: *const *mut f64,
9614 ldb: ::libc::c_int,
9615 info: *mut ::libc::c_int,
9616 batchSize: ::libc::c_int,
9617 ) -> cublasStatus_t;
9618}
9619extern "C" {
9620 pub fn cublasCgetrsBatched(
9621 handle: cublasHandle_t,
9622 trans: cublasOperation_t,
9623 n: ::libc::c_int,
9624 nrhs: ::libc::c_int,
9625 Aarray: *const *const cuComplex,
9626 lda: ::libc::c_int,
9627 devIpiv: *const ::libc::c_int,
9628 Barray: *const *mut cuComplex,
9629 ldb: ::libc::c_int,
9630 info: *mut ::libc::c_int,
9631 batchSize: ::libc::c_int,
9632 ) -> cublasStatus_t;
9633}
9634extern "C" {
9635 pub fn cublasZgetrsBatched(
9636 handle: cublasHandle_t,
9637 trans: cublasOperation_t,
9638 n: ::libc::c_int,
9639 nrhs: ::libc::c_int,
9640 Aarray: *const *const cuDoubleComplex,
9641 lda: ::libc::c_int,
9642 devIpiv: *const ::libc::c_int,
9643 Barray: *const *mut cuDoubleComplex,
9644 ldb: ::libc::c_int,
9645 info: *mut ::libc::c_int,
9646 batchSize: ::libc::c_int,
9647 ) -> cublasStatus_t;
9648}
9649extern "C" {
9650 pub fn cublasStrsmBatched(
9651 handle: cublasHandle_t,
9652 side: cublasSideMode_t,
9653 uplo: cublasFillMode_t,
9654 trans: cublasOperation_t,
9655 diag: cublasDiagType_t,
9656 m: ::libc::c_int,
9657 n: ::libc::c_int,
9658 alpha: *const f32,
9659 A: *const *const f32,
9660 lda: ::libc::c_int,
9661 B: *const *mut f32,
9662 ldb: ::libc::c_int,
9663 batchCount: ::libc::c_int,
9664 ) -> cublasStatus_t;
9665}
9666extern "C" {
9667 pub fn cublasDtrsmBatched(
9668 handle: cublasHandle_t,
9669 side: cublasSideMode_t,
9670 uplo: cublasFillMode_t,
9671 trans: cublasOperation_t,
9672 diag: cublasDiagType_t,
9673 m: ::libc::c_int,
9674 n: ::libc::c_int,
9675 alpha: *const f64,
9676 A: *const *const f64,
9677 lda: ::libc::c_int,
9678 B: *const *mut f64,
9679 ldb: ::libc::c_int,
9680 batchCount: ::libc::c_int,
9681 ) -> cublasStatus_t;
9682}
9683extern "C" {
9684 pub fn cublasCtrsmBatched(
9685 handle: cublasHandle_t,
9686 side: cublasSideMode_t,
9687 uplo: cublasFillMode_t,
9688 trans: cublasOperation_t,
9689 diag: cublasDiagType_t,
9690 m: ::libc::c_int,
9691 n: ::libc::c_int,
9692 alpha: *const cuComplex,
9693 A: *const *const cuComplex,
9694 lda: ::libc::c_int,
9695 B: *const *mut cuComplex,
9696 ldb: ::libc::c_int,
9697 batchCount: ::libc::c_int,
9698 ) -> cublasStatus_t;
9699}
9700extern "C" {
9701 pub fn cublasZtrsmBatched(
9702 handle: cublasHandle_t,
9703 side: cublasSideMode_t,
9704 uplo: cublasFillMode_t,
9705 trans: cublasOperation_t,
9706 diag: cublasDiagType_t,
9707 m: ::libc::c_int,
9708 n: ::libc::c_int,
9709 alpha: *const cuDoubleComplex,
9710 A: *const *const cuDoubleComplex,
9711 lda: ::libc::c_int,
9712 B: *const *mut cuDoubleComplex,
9713 ldb: ::libc::c_int,
9714 batchCount: ::libc::c_int,
9715 ) -> cublasStatus_t;
9716}
9717extern "C" {
9718 pub fn cublasSmatinvBatched(
9719 handle: cublasHandle_t,
9720 n: ::libc::c_int,
9721 A: *const *const f32,
9722 lda: ::libc::c_int,
9723 Ainv: *const *mut f32,
9724 lda_inv: ::libc::c_int,
9725 info: *mut ::libc::c_int,
9726 batchSize: ::libc::c_int,
9727 ) -> cublasStatus_t;
9728}
9729extern "C" {
9730 pub fn cublasDmatinvBatched(
9731 handle: cublasHandle_t,
9732 n: ::libc::c_int,
9733 A: *const *const f64,
9734 lda: ::libc::c_int,
9735 Ainv: *const *mut f64,
9736 lda_inv: ::libc::c_int,
9737 info: *mut ::libc::c_int,
9738 batchSize: ::libc::c_int,
9739 ) -> cublasStatus_t;
9740}
9741extern "C" {
9742 pub fn cublasCmatinvBatched(
9743 handle: cublasHandle_t,
9744 n: ::libc::c_int,
9745 A: *const *const cuComplex,
9746 lda: ::libc::c_int,
9747 Ainv: *const *mut cuComplex,
9748 lda_inv: ::libc::c_int,
9749 info: *mut ::libc::c_int,
9750 batchSize: ::libc::c_int,
9751 ) -> cublasStatus_t;
9752}
9753extern "C" {
9754 pub fn cublasZmatinvBatched(
9755 handle: cublasHandle_t,
9756 n: ::libc::c_int,
9757 A: *const *const cuDoubleComplex,
9758 lda: ::libc::c_int,
9759 Ainv: *const *mut cuDoubleComplex,
9760 lda_inv: ::libc::c_int,
9761 info: *mut ::libc::c_int,
9762 batchSize: ::libc::c_int,
9763 ) -> cublasStatus_t;
9764}
9765extern "C" {
9766 pub fn cublasSgeqrfBatched(
9767 handle: cublasHandle_t,
9768 m: ::libc::c_int,
9769 n: ::libc::c_int,
9770 Aarray: *const *mut f32,
9771 lda: ::libc::c_int,
9772 TauArray: *const *mut f32,
9773 info: *mut ::libc::c_int,
9774 batchSize: ::libc::c_int,
9775 ) -> cublasStatus_t;
9776}
9777extern "C" {
9778 pub fn cublasDgeqrfBatched(
9779 handle: cublasHandle_t,
9780 m: ::libc::c_int,
9781 n: ::libc::c_int,
9782 Aarray: *const *mut f64,
9783 lda: ::libc::c_int,
9784 TauArray: *const *mut f64,
9785 info: *mut ::libc::c_int,
9786 batchSize: ::libc::c_int,
9787 ) -> cublasStatus_t;
9788}
9789extern "C" {
9790 pub fn cublasCgeqrfBatched(
9791 handle: cublasHandle_t,
9792 m: ::libc::c_int,
9793 n: ::libc::c_int,
9794 Aarray: *const *mut cuComplex,
9795 lda: ::libc::c_int,
9796 TauArray: *const *mut cuComplex,
9797 info: *mut ::libc::c_int,
9798 batchSize: ::libc::c_int,
9799 ) -> cublasStatus_t;
9800}
9801extern "C" {
9802 pub fn cublasZgeqrfBatched(
9803 handle: cublasHandle_t,
9804 m: ::libc::c_int,
9805 n: ::libc::c_int,
9806 Aarray: *const *mut cuDoubleComplex,
9807 lda: ::libc::c_int,
9808 TauArray: *const *mut cuDoubleComplex,
9809 info: *mut ::libc::c_int,
9810 batchSize: ::libc::c_int,
9811 ) -> cublasStatus_t;
9812}
9813extern "C" {
9814 pub fn cublasSgelsBatched(
9815 handle: cublasHandle_t,
9816 trans: cublasOperation_t,
9817 m: ::libc::c_int,
9818 n: ::libc::c_int,
9819 nrhs: ::libc::c_int,
9820 Aarray: *const *mut f32,
9821 lda: ::libc::c_int,
9822 Carray: *const *mut f32,
9823 ldc: ::libc::c_int,
9824 info: *mut ::libc::c_int,
9825 devInfoArray: *mut ::libc::c_int,
9826 batchSize: ::libc::c_int,
9827 ) -> cublasStatus_t;
9828}
9829extern "C" {
9830 pub fn cublasDgelsBatched(
9831 handle: cublasHandle_t,
9832 trans: cublasOperation_t,
9833 m: ::libc::c_int,
9834 n: ::libc::c_int,
9835 nrhs: ::libc::c_int,
9836 Aarray: *const *mut f64,
9837 lda: ::libc::c_int,
9838 Carray: *const *mut f64,
9839 ldc: ::libc::c_int,
9840 info: *mut ::libc::c_int,
9841 devInfoArray: *mut ::libc::c_int,
9842 batchSize: ::libc::c_int,
9843 ) -> cublasStatus_t;
9844}
9845extern "C" {
9846 pub fn cublasCgelsBatched(
9847 handle: cublasHandle_t,
9848 trans: cublasOperation_t,
9849 m: ::libc::c_int,
9850 n: ::libc::c_int,
9851 nrhs: ::libc::c_int,
9852 Aarray: *const *mut cuComplex,
9853 lda: ::libc::c_int,
9854 Carray: *const *mut cuComplex,
9855 ldc: ::libc::c_int,
9856 info: *mut ::libc::c_int,
9857 devInfoArray: *mut ::libc::c_int,
9858 batchSize: ::libc::c_int,
9859 ) -> cublasStatus_t;
9860}
9861extern "C" {
9862 pub fn cublasZgelsBatched(
9863 handle: cublasHandle_t,
9864 trans: cublasOperation_t,
9865 m: ::libc::c_int,
9866 n: ::libc::c_int,
9867 nrhs: ::libc::c_int,
9868 Aarray: *const *mut cuDoubleComplex,
9869 lda: ::libc::c_int,
9870 Carray: *const *mut cuDoubleComplex,
9871 ldc: ::libc::c_int,
9872 info: *mut ::libc::c_int,
9873 devInfoArray: *mut ::libc::c_int,
9874 batchSize: ::libc::c_int,
9875 ) -> cublasStatus_t;
9876}
9877extern "C" {
9878 pub fn cublasSdgmm(
9879 handle: cublasHandle_t,
9880 mode: cublasSideMode_t,
9881 m: ::libc::c_int,
9882 n: ::libc::c_int,
9883 A: *const f32,
9884 lda: ::libc::c_int,
9885 x: *const f32,
9886 incx: ::libc::c_int,
9887 C: *mut f32,
9888 ldc: ::libc::c_int,
9889 ) -> cublasStatus_t;
9890}
9891extern "C" {
9892 pub fn cublasDdgmm(
9893 handle: cublasHandle_t,
9894 mode: cublasSideMode_t,
9895 m: ::libc::c_int,
9896 n: ::libc::c_int,
9897 A: *const f64,
9898 lda: ::libc::c_int,
9899 x: *const f64,
9900 incx: ::libc::c_int,
9901 C: *mut f64,
9902 ldc: ::libc::c_int,
9903 ) -> cublasStatus_t;
9904}
9905extern "C" {
9906 pub fn cublasCdgmm(
9907 handle: cublasHandle_t,
9908 mode: cublasSideMode_t,
9909 m: ::libc::c_int,
9910 n: ::libc::c_int,
9911 A: *const cuComplex,
9912 lda: ::libc::c_int,
9913 x: *const cuComplex,
9914 incx: ::libc::c_int,
9915 C: *mut cuComplex,
9916 ldc: ::libc::c_int,
9917 ) -> cublasStatus_t;
9918}
9919extern "C" {
9920 pub fn cublasZdgmm(
9921 handle: cublasHandle_t,
9922 mode: cublasSideMode_t,
9923 m: ::libc::c_int,
9924 n: ::libc::c_int,
9925 A: *const cuDoubleComplex,
9926 lda: ::libc::c_int,
9927 x: *const cuDoubleComplex,
9928 incx: ::libc::c_int,
9929 C: *mut cuDoubleComplex,
9930 ldc: ::libc::c_int,
9931 ) -> cublasStatus_t;
9932}
9933extern "C" {
9934 pub fn cublasStpttr(
9935 handle: cublasHandle_t,
9936 uplo: cublasFillMode_t,
9937 n: ::libc::c_int,
9938 AP: *const f32,
9939 A: *mut f32,
9940 lda: ::libc::c_int,
9941 ) -> cublasStatus_t;
9942}
9943extern "C" {
9944 pub fn cublasDtpttr(
9945 handle: cublasHandle_t,
9946 uplo: cublasFillMode_t,
9947 n: ::libc::c_int,
9948 AP: *const f64,
9949 A: *mut f64,
9950 lda: ::libc::c_int,
9951 ) -> cublasStatus_t;
9952}
9953extern "C" {
9954 pub fn cublasCtpttr(
9955 handle: cublasHandle_t,
9956 uplo: cublasFillMode_t,
9957 n: ::libc::c_int,
9958 AP: *const cuComplex,
9959 A: *mut cuComplex,
9960 lda: ::libc::c_int,
9961 ) -> cublasStatus_t;
9962}
9963extern "C" {
9964 pub fn cublasZtpttr(
9965 handle: cublasHandle_t,
9966 uplo: cublasFillMode_t,
9967 n: ::libc::c_int,
9968 AP: *const cuDoubleComplex,
9969 A: *mut cuDoubleComplex,
9970 lda: ::libc::c_int,
9971 ) -> cublasStatus_t;
9972}
9973extern "C" {
9974 pub fn cublasStrttp(
9975 handle: cublasHandle_t,
9976 uplo: cublasFillMode_t,
9977 n: ::libc::c_int,
9978 A: *const f32,
9979 lda: ::libc::c_int,
9980 AP: *mut f32,
9981 ) -> cublasStatus_t;
9982}
9983extern "C" {
9984 pub fn cublasDtrttp(
9985 handle: cublasHandle_t,
9986 uplo: cublasFillMode_t,
9987 n: ::libc::c_int,
9988 A: *const f64,
9989 lda: ::libc::c_int,
9990 AP: *mut f64,
9991 ) -> cublasStatus_t;
9992}
9993extern "C" {
9994 pub fn cublasCtrttp(
9995 handle: cublasHandle_t,
9996 uplo: cublasFillMode_t,
9997 n: ::libc::c_int,
9998 A: *const cuComplex,
9999 lda: ::libc::c_int,
10000 AP: *mut cuComplex,
10001 ) -> cublasStatus_t;
10002}
10003extern "C" {
10004 pub fn cublasZtrttp(
10005 handle: cublasHandle_t,
10006 uplo: cublasFillMode_t,
10007 n: ::libc::c_int,
10008 A: *const cuDoubleComplex,
10009 lda: ::libc::c_int,
10010 AP: *mut cuDoubleComplex,
10011 ) -> cublasStatus_t;
10012}