1#![allow(non_camel_case_types)]
2#![allow(non_upper_case_globals)]
3#![allow(non_snake_case)]
4
5use vector_types::*;
6
7#[repr(u32)]
8#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
9pub enum cudaError_t {
10 Success = 0,
11 MissingConfiguration = 1,
12 MemoryAllocation = 2,
13 InitializationError = 3,
14 LaunchFailure = 4,
15 PriorLaunchFailure = 5,
16 LaunchTimeout = 6,
17 LaunchOutOfResources = 7,
18 InvalidDeviceFunction = 8,
19 InvalidConfiguration = 9,
20 InvalidDevice = 10,
21 InvalidValue = 11,
22 InvalidPitchValue = 12,
23 InvalidSymbol = 13,
24 MapBufferObjectFailed = 14,
25 UnmapBufferObjectFailed = 15,
26 InvalidHostPointer = 16,
27 InvalidDevicePointer = 17,
28 InvalidTexture = 18,
29 InvalidTextureBinding = 19,
30 InvalidChannelDescriptor = 20,
31 InvalidMemcpyDirection = 21,
32 AddressOfConstant = 22,
33 TextureFetchFailed = 23,
34 TextureNotBound = 24,
35 SynchronizationError = 25,
36 InvalidFilterSetting = 26,
37 InvalidNormSetting = 27,
38 MixedDeviceExecution = 28,
39 CudartUnloading = 29,
40 Unknown = 30,
41 NotYetImplemented = 31,
42 MemoryValueTooLarge = 32,
43 InvalidResourceHandle = 33,
44 NotReady = 34,
45 InsufficientDriver = 35,
46 SetOnActiveProcess = 36,
47 InvalidSurface = 37,
48 NoDevice = 38,
49 ECCUncorrectable = 39,
50 SharedObjectSymbolNotFound = 40,
51 SharedObjectInitFailed = 41,
52 UnsupportedLimit = 42,
53 DuplicateVariableName = 43,
54 DuplicateTextureName = 44,
55 DuplicateSurfaceName = 45,
56 DevicesUnavailable = 46,
57 InvalidKernelImage = 47,
58 NoKernelImageForDevice = 48,
59 IncompatibleDriverContext = 49,
60 PeerAccessAlreadyEnabled = 50,
61 PeerAccessNotEnabled = 51,
62 DeviceAlreadyInUse = 54,
63 ProfilerDisabled = 55,
64 ProfilerNotInitialized = 56,
65 ProfilerAlreadyStarted = 57,
66 ProfilerAlreadyStopped = 58,
67 Assert = 59,
68 TooManyPeers = 60,
69 HostMemoryAlreadyRegistered = 61,
70 HostMemoryNotRegistered = 62,
71 OperatingSystem = 63,
72 PeerAccessUnsupported = 64,
73 LaunchMaxDepthExceeded = 65,
74 LaunchFileScopedTex = 66,
75 LaunchFileScopedSurf = 67,
76 SyncDepthExceeded = 68,
77 LaunchPendingCountExceeded = 69,
78 NotPermitted = 70,
79 NotSupported = 71,
80 HardwareStackError = 72,
81 IllegalInstruction = 73,
82 MisalignedAddress = 74,
83 InvalidAddressSpace = 75,
84 InvalidPc = 76,
85 IllegalAddress = 77,
86 InvalidPtx = 78,
87 InvalidGraphicsContext = 79,
88 NvlinkUncorrectable = 80,
89 JitCompilerNotFound = 81,
90 CooperativeLaunchTooLarge = 82,
91 StartupFailure = 127,
92 ApiFailureBase = 10000,
93}
94
95pub const cudaHostAllocDefault: ::std::os::raw::c_uint = 0;
96pub const cudaHostAllocPortable: ::std::os::raw::c_uint = 1;
97pub const cudaHostAllocMapped: ::std::os::raw::c_uint = 2;
98pub const cudaHostAllocWriteCombined: ::std::os::raw::c_uint = 4;
99pub const cudaHostRegisterDefault: ::std::os::raw::c_uint = 0;
100pub const cudaHostRegisterPortable: ::std::os::raw::c_uint = 1;
101pub const cudaHostRegisterMapped: ::std::os::raw::c_uint = 2;
102pub const cudaHostRegisterIoMemory: ::std::os::raw::c_uint = 4;
103pub const cudaPeerAccessDefault: ::std::os::raw::c_uint = 0;
104pub const cudaStreamDefault: ::std::os::raw::c_uint = 0;
105pub const cudaStreamNonBlocking: ::std::os::raw::c_uint = 1;
106pub const cudaEventDefault: ::std::os::raw::c_uint = 0;
107pub const cudaEventBlockingSync: ::std::os::raw::c_uint = 1;
108pub const cudaEventDisableTiming: ::std::os::raw::c_uint = 2;
109pub const cudaEventInterprocess: ::std::os::raw::c_uint = 4;
110pub const cudaDeviceScheduleAuto: ::std::os::raw::c_uint = 0;
111pub const cudaDeviceScheduleSpin: ::std::os::raw::c_uint = 1;
112pub const cudaDeviceScheduleYield: ::std::os::raw::c_uint = 2;
113pub const cudaDeviceScheduleBlockingSync: ::std::os::raw::c_uint = 4;
114pub const cudaDeviceBlockingSync: ::std::os::raw::c_uint = 4;
115pub const cudaDeviceScheduleMask: ::std::os::raw::c_uint = 7;
116pub const cudaDeviceMapHost: ::std::os::raw::c_uint = 8;
117pub const cudaDeviceLmemResizeToMax: ::std::os::raw::c_uint = 16;
118pub const cudaDeviceMask: ::std::os::raw::c_uint = 31;
119pub const cudaArrayDefault: ::std::os::raw::c_uint = 0;
120pub const cudaArrayLayered: ::std::os::raw::c_uint = 1;
121pub const cudaArraySurfaceLoadStore: ::std::os::raw::c_uint = 2;
122pub const cudaArrayCubemap: ::std::os::raw::c_uint = 4;
123pub const cudaArrayTextureGather: ::std::os::raw::c_uint = 8;
124pub const cudaIpcMemLazyEnablePeerAccess: ::std::os::raw::c_uint = 1;
125pub const cudaMemAttachGlobal: ::std::os::raw::c_uint = 1;
126pub const cudaMemAttachHost: ::std::os::raw::c_uint = 2;
127pub const cudaMemAttachSingle: ::std::os::raw::c_uint = 4;
128pub const cudaOccupancyDefault: ::std::os::raw::c_uint = 0;
129pub const cudaOccupancyDisableCachingOverride: ::std::os::raw::c_uint = 1;
130pub const cudaCooperativeLaunchMultiDeviceNoPreSync: ::std::os::raw::c_uint = 1;
131pub const cudaCooperativeLaunchMultiDeviceNoPostSync: ::std::os::raw::c_uint = 2;
132pub const CUDA_IPC_HANDLE_SIZE: ::std::os::raw::c_uint = 64;
133pub const cudaSurfaceType1D: ::std::os::raw::c_uint = 1;
134pub const cudaSurfaceType2D: ::std::os::raw::c_uint = 2;
135pub const cudaSurfaceType3D: ::std::os::raw::c_uint = 3;
136pub const cudaSurfaceTypeCubemap: ::std::os::raw::c_uint = 12;
137pub const cudaSurfaceType1DLayered: ::std::os::raw::c_uint = 241;
138pub const cudaSurfaceType2DLayered: ::std::os::raw::c_uint = 242;
139pub const cudaSurfaceTypeCubemapLayered: ::std::os::raw::c_uint = 252;
140pub const cudaTextureType1D: ::std::os::raw::c_uint = 1;
141pub const cudaTextureType2D: ::std::os::raw::c_uint = 2;
142pub const cudaTextureType3D: ::std::os::raw::c_uint = 3;
143pub const cudaTextureTypeCubemap: ::std::os::raw::c_uint = 12;
144pub const cudaTextureType1DLayered: ::std::os::raw::c_uint = 241;
145pub const cudaTextureType2DLayered: ::std::os::raw::c_uint = 242;
146pub const cudaTextureTypeCubemapLayered: ::std::os::raw::c_uint = 252;
147pub const CUDART_VERSION: ::std::os::raw::c_uint = 9000;
148pub const cudaRoundMode_cudaRoundNearest: cudaRoundMode = 0;
149pub const cudaRoundMode_cudaRoundZero: cudaRoundMode = 1;
150pub const cudaRoundMode_cudaRoundPosInf: cudaRoundMode = 2;
151pub const cudaRoundMode_cudaRoundMinInf: cudaRoundMode = 3;
152pub type cudaRoundMode = ::std::os::raw::c_uint;
153pub const cudaChannelFormatKind_cudaChannelFormatKindSigned: cudaChannelFormatKind = 0;
154pub const cudaChannelFormatKind_cudaChannelFormatKindUnsigned: cudaChannelFormatKind = 1;
155pub const cudaChannelFormatKind_cudaChannelFormatKindFloat: cudaChannelFormatKind = 2;
156pub const cudaChannelFormatKind_cudaChannelFormatKindNone: cudaChannelFormatKind = 3;
157pub type cudaChannelFormatKind = ::std::os::raw::c_uint;
158#[repr(C)]
159#[derive(Debug, Copy, Clone)]
160pub struct cudaChannelFormatDesc {
161 pub x: ::std::os::raw::c_int,
162 pub y: ::std::os::raw::c_int,
163 pub z: ::std::os::raw::c_int,
164 pub w: ::std::os::raw::c_int,
165 pub f: cudaChannelFormatKind,
166}
167#[repr(C)]
168#[derive(Debug, Copy, Clone)]
169pub struct cudaArray {
170 _unused: [u8; 0],
171}
172pub type cudaArray_t = *mut cudaArray;
173pub type cudaArray_const_t = *const cudaArray;
174#[repr(C)]
175#[derive(Debug, Copy, Clone)]
176pub struct cudaMipmappedArray {
177 _unused: [u8; 0],
178}
179pub type cudaMipmappedArray_t = *mut cudaMipmappedArray;
180pub type cudaMipmappedArray_const_t = *const cudaMipmappedArray;
181pub const cudaMemoryType_cudaMemoryTypeHost: cudaMemoryType = 1;
182pub const cudaMemoryType_cudaMemoryTypeDevice: cudaMemoryType = 2;
183pub type cudaMemoryType = ::std::os::raw::c_uint;
184pub const cudaMemcpyKind_cudaMemcpyHostToHost: cudaMemcpyKind = 0;
185pub const cudaMemcpyKind_cudaMemcpyHostToDevice: cudaMemcpyKind = 1;
186pub const cudaMemcpyKind_cudaMemcpyDeviceToHost: cudaMemcpyKind = 2;
187pub const cudaMemcpyKind_cudaMemcpyDeviceToDevice: cudaMemcpyKind = 3;
188pub const cudaMemcpyKind_cudaMemcpyDefault: cudaMemcpyKind = 4;
189pub type cudaMemcpyKind = ::std::os::raw::c_uint;
190#[repr(C)]
191#[derive(Debug, Copy, Clone)]
192pub struct cudaPitchedPtr {
193 pub ptr: *mut ::std::os::raw::c_void,
194 pub pitch: usize,
195 pub xsize: usize,
196 pub ysize: usize,
197}
198#[repr(C)]
199#[derive(Debug, Copy, Clone)]
200pub struct cudaExtent {
201 pub width: usize,
202 pub height: usize,
203 pub depth: usize,
204}
205#[repr(C)]
206#[derive(Debug, Copy, Clone)]
207pub struct cudaPos {
208 pub x: usize,
209 pub y: usize,
210 pub z: usize,
211}
212#[repr(C)]
213#[derive(Debug, Copy, Clone)]
214pub struct cudaMemcpy3DParms {
215 pub srcArray: cudaArray_t,
216 pub srcPos: cudaPos,
217 pub srcPtr: cudaPitchedPtr,
218 pub dstArray: cudaArray_t,
219 pub dstPos: cudaPos,
220 pub dstPtr: cudaPitchedPtr,
221 pub extent: cudaExtent,
222 pub kind: cudaMemcpyKind,
223}
224#[repr(C)]
225#[derive(Debug, Copy, Clone)]
226pub struct cudaMemcpy3DPeerParms {
227 pub srcArray: cudaArray_t,
228 pub srcPos: cudaPos,
229 pub srcPtr: cudaPitchedPtr,
230 pub srcDevice: ::std::os::raw::c_int,
231 pub dstArray: cudaArray_t,
232 pub dstPos: cudaPos,
233 pub dstPtr: cudaPitchedPtr,
234 pub dstDevice: ::std::os::raw::c_int,
235 pub extent: cudaExtent,
236}
237#[repr(C)]
238#[derive(Debug, Copy, Clone)]
239pub struct cudaGraphicsResource {
240 _unused: [u8; 0],
241}
242pub const cudaGraphicsRegisterFlags_cudaGraphicsRegisterFlagsNone: cudaGraphicsRegisterFlags = 0;
243pub const cudaGraphicsRegisterFlags_cudaGraphicsRegisterFlagsReadOnly: cudaGraphicsRegisterFlags = 1;
244pub const cudaGraphicsRegisterFlags_cudaGraphicsRegisterFlagsWriteDiscard: cudaGraphicsRegisterFlags = 2;
245pub const cudaGraphicsRegisterFlags_cudaGraphicsRegisterFlagsSurfaceLoadStore: cudaGraphicsRegisterFlags = 4;
246pub const cudaGraphicsRegisterFlags_cudaGraphicsRegisterFlagsTextureGather: cudaGraphicsRegisterFlags = 8;
247pub type cudaGraphicsRegisterFlags = ::std::os::raw::c_uint;
248pub const cudaGraphicsMapFlags_cudaGraphicsMapFlagsNone: cudaGraphicsMapFlags = 0;
249pub const cudaGraphicsMapFlags_cudaGraphicsMapFlagsReadOnly: cudaGraphicsMapFlags = 1;
250pub const cudaGraphicsMapFlags_cudaGraphicsMapFlagsWriteDiscard: cudaGraphicsMapFlags = 2;
251pub type cudaGraphicsMapFlags = ::std::os::raw::c_uint;
252pub const cudaGraphicsCubeFace_cudaGraphicsCubeFacePositiveX: cudaGraphicsCubeFace = 0;
253pub const cudaGraphicsCubeFace_cudaGraphicsCubeFaceNegativeX: cudaGraphicsCubeFace = 1;
254pub const cudaGraphicsCubeFace_cudaGraphicsCubeFacePositiveY: cudaGraphicsCubeFace = 2;
255pub const cudaGraphicsCubeFace_cudaGraphicsCubeFaceNegativeY: cudaGraphicsCubeFace = 3;
256pub const cudaGraphicsCubeFace_cudaGraphicsCubeFacePositiveZ: cudaGraphicsCubeFace = 4;
257pub const cudaGraphicsCubeFace_cudaGraphicsCubeFaceNegativeZ: cudaGraphicsCubeFace = 5;
258pub type cudaGraphicsCubeFace = ::std::os::raw::c_uint;
259pub const cudaResourceType_cudaResourceTypeArray: cudaResourceType = 0;
260pub const cudaResourceType_cudaResourceTypeMipmappedArray: cudaResourceType = 1;
261pub const cudaResourceType_cudaResourceTypeLinear: cudaResourceType = 2;
262pub const cudaResourceType_cudaResourceTypePitch2D: cudaResourceType = 3;
263pub type cudaResourceType = ::std::os::raw::c_uint;
264pub const cudaResourceViewFormat_cudaResViewFormatNone: cudaResourceViewFormat = 0;
265pub const cudaResourceViewFormat_cudaResViewFormatUnsignedChar1: cudaResourceViewFormat = 1;
266pub const cudaResourceViewFormat_cudaResViewFormatUnsignedChar2: cudaResourceViewFormat = 2;
267pub const cudaResourceViewFormat_cudaResViewFormatUnsignedChar4: cudaResourceViewFormat = 3;
268pub const cudaResourceViewFormat_cudaResViewFormatSignedChar1: cudaResourceViewFormat = 4;
269pub const cudaResourceViewFormat_cudaResViewFormatSignedChar2: cudaResourceViewFormat = 5;
270pub const cudaResourceViewFormat_cudaResViewFormatSignedChar4: cudaResourceViewFormat = 6;
271pub const cudaResourceViewFormat_cudaResViewFormatUnsignedShort1: cudaResourceViewFormat = 7;
272pub const cudaResourceViewFormat_cudaResViewFormatUnsignedShort2: cudaResourceViewFormat = 8;
273pub const cudaResourceViewFormat_cudaResViewFormatUnsignedShort4: cudaResourceViewFormat = 9;
274pub const cudaResourceViewFormat_cudaResViewFormatSignedShort1: cudaResourceViewFormat = 10;
275pub const cudaResourceViewFormat_cudaResViewFormatSignedShort2: cudaResourceViewFormat = 11;
276pub const cudaResourceViewFormat_cudaResViewFormatSignedShort4: cudaResourceViewFormat = 12;
277pub const cudaResourceViewFormat_cudaResViewFormatUnsignedInt1: cudaResourceViewFormat = 13;
278pub const cudaResourceViewFormat_cudaResViewFormatUnsignedInt2: cudaResourceViewFormat = 14;
279pub const cudaResourceViewFormat_cudaResViewFormatUnsignedInt4: cudaResourceViewFormat = 15;
280pub const cudaResourceViewFormat_cudaResViewFormatSignedInt1: cudaResourceViewFormat = 16;
281pub const cudaResourceViewFormat_cudaResViewFormatSignedInt2: cudaResourceViewFormat = 17;
282pub const cudaResourceViewFormat_cudaResViewFormatSignedInt4: cudaResourceViewFormat = 18;
283pub const cudaResourceViewFormat_cudaResViewFormatHalf1: cudaResourceViewFormat = 19;
284pub const cudaResourceViewFormat_cudaResViewFormatHalf2: cudaResourceViewFormat = 20;
285pub const cudaResourceViewFormat_cudaResViewFormatHalf4: cudaResourceViewFormat = 21;
286pub const cudaResourceViewFormat_cudaResViewFormatFloat1: cudaResourceViewFormat = 22;
287pub const cudaResourceViewFormat_cudaResViewFormatFloat2: cudaResourceViewFormat = 23;
288pub const cudaResourceViewFormat_cudaResViewFormatFloat4: cudaResourceViewFormat = 24;
289pub const cudaResourceViewFormat_cudaResViewFormatUnsignedBlockCompressed1: cudaResourceViewFormat = 25;
290pub const cudaResourceViewFormat_cudaResViewFormatUnsignedBlockCompressed2: cudaResourceViewFormat = 26;
291pub const cudaResourceViewFormat_cudaResViewFormatUnsignedBlockCompressed3: cudaResourceViewFormat = 27;
292pub const cudaResourceViewFormat_cudaResViewFormatUnsignedBlockCompressed4: cudaResourceViewFormat = 28;
293pub const cudaResourceViewFormat_cudaResViewFormatSignedBlockCompressed4: cudaResourceViewFormat = 29;
294pub const cudaResourceViewFormat_cudaResViewFormatUnsignedBlockCompressed5: cudaResourceViewFormat = 30;
295pub const cudaResourceViewFormat_cudaResViewFormatSignedBlockCompressed5: cudaResourceViewFormat = 31;
296pub const cudaResourceViewFormat_cudaResViewFormatUnsignedBlockCompressed6H: cudaResourceViewFormat = 32;
297pub const cudaResourceViewFormat_cudaResViewFormatSignedBlockCompressed6H: cudaResourceViewFormat = 33;
298pub const cudaResourceViewFormat_cudaResViewFormatUnsignedBlockCompressed7: cudaResourceViewFormat = 34;
299pub type cudaResourceViewFormat = ::std::os::raw::c_uint;
300#[repr(C)]
301#[derive(Copy, Clone)]
302pub struct cudaResourceDesc {
303 pub resType: cudaResourceType,
304 pub res: cudaResourceDesc__bindgen_ty_1,
305}
306#[repr(C)]
307#[derive(Copy, Clone)]
308pub union cudaResourceDesc__bindgen_ty_1 {
309 pub array: cudaResourceDesc__bindgen_ty_1__bindgen_ty_1,
310 pub mipmap: cudaResourceDesc__bindgen_ty_1__bindgen_ty_2,
311 pub linear: cudaResourceDesc__bindgen_ty_1__bindgen_ty_3,
312 pub pitch2D: cudaResourceDesc__bindgen_ty_1__bindgen_ty_4,
313}
314#[repr(C)]
315#[derive(Debug, Copy, Clone)]
316pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_1 {
317 pub array: cudaArray_t,
318}
319#[repr(C)]
320#[derive(Debug, Copy, Clone)]
321pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_2 {
322 pub mipmap: cudaMipmappedArray_t,
323}
324#[repr(C)]
325#[derive(Debug, Copy, Clone)]
326pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_3 {
327 pub devPtr: *mut ::std::os::raw::c_void,
328 pub desc: cudaChannelFormatDesc,
329 pub sizeInBytes: usize,
330}
331#[repr(C)]
332#[derive(Debug, Copy, Clone)]
333pub struct cudaResourceDesc__bindgen_ty_1__bindgen_ty_4 {
334 pub devPtr: *mut ::std::os::raw::c_void,
335 pub desc: cudaChannelFormatDesc,
336 pub width: usize,
337 pub height: usize,
338 pub pitchInBytes: usize,
339}
340#[repr(C)]
341#[derive(Debug, Copy, Clone)]
342pub struct cudaResourceViewDesc {
343 pub format: cudaResourceViewFormat,
344 pub width: usize,
345 pub height: usize,
346 pub depth: usize,
347 pub firstMipmapLevel: ::std::os::raw::c_uint,
348 pub lastMipmapLevel: ::std::os::raw::c_uint,
349 pub firstLayer: ::std::os::raw::c_uint,
350 pub lastLayer: ::std::os::raw::c_uint,
351}
352#[repr(C)]
353#[derive(Debug, Copy, Clone)]
354pub struct cudaPointerAttributes {
355 pub memoryType: cudaMemoryType,
356 pub device: ::std::os::raw::c_int,
357 pub devicePointer: *mut ::std::os::raw::c_void,
358 pub hostPointer: *mut ::std::os::raw::c_void,
359 pub isManaged: ::std::os::raw::c_int,
360}
361#[repr(C)]
362#[derive(Debug, Copy, Clone)]
363pub struct cudaFuncAttributes {
364 pub sharedSizeBytes: usize,
365 pub constSizeBytes: usize,
366 pub localSizeBytes: usize,
367 pub maxThreadsPerBlock: ::std::os::raw::c_int,
368 pub numRegs: ::std::os::raw::c_int,
369 pub ptxVersion: ::std::os::raw::c_int,
370 pub binaryVersion: ::std::os::raw::c_int,
371 pub cacheModeCA: ::std::os::raw::c_int,
372 pub maxDynamicSharedSizeBytes: ::std::os::raw::c_int,
373 pub preferredShmemCarveout: ::std::os::raw::c_int,
374}
375pub const cudaFuncAttribute_cudaFuncAttributeMaxDynamicSharedMemorySize: cudaFuncAttribute = 8;
376pub const cudaFuncAttribute_cudaFuncAttributePreferredSharedMemoryCarveout: cudaFuncAttribute = 9;
377pub const cudaFuncAttribute_cudaFuncAttributeMax: cudaFuncAttribute = 10;
378pub type cudaFuncAttribute = ::std::os::raw::c_uint;
379pub const cudaFuncCache_cudaFuncCachePreferNone: cudaFuncCache = 0;
380pub const cudaFuncCache_cudaFuncCachePreferShared: cudaFuncCache = 1;
381pub const cudaFuncCache_cudaFuncCachePreferL1: cudaFuncCache = 2;
382pub const cudaFuncCache_cudaFuncCachePreferEqual: cudaFuncCache = 3;
383pub type cudaFuncCache = ::std::os::raw::c_uint;
384pub const cudaSharedMemConfig_cudaSharedMemBankSizeDefault: cudaSharedMemConfig = 0;
385pub const cudaSharedMemConfig_cudaSharedMemBankSizeFourByte: cudaSharedMemConfig = 1;
386pub const cudaSharedMemConfig_cudaSharedMemBankSizeEightByte: cudaSharedMemConfig = 2;
387pub type cudaSharedMemConfig = ::std::os::raw::c_uint;
388pub const cudaSharedCarveout_cudaSharedmemCarveoutDefault: cudaSharedCarveout = -1;
389pub const cudaSharedCarveout_cudaSharedmemCarveoutMaxShared: cudaSharedCarveout = 100;
390pub const cudaSharedCarveout_cudaSharedmemCarveoutMaxL1: cudaSharedCarveout = 0;
391pub type cudaSharedCarveout = ::std::os::raw::c_int;
392
393#[repr(i32)]
394#[derive(PartialEq, Eq, Clone, Copy, Debug)]
395pub enum cudaComputeMode {
396 Default = 0,
397 Exclusive = 1,
398 Prohibited = 2,
399 ExclusiveProcess = 3,
400}
401
402pub const cudaLimit_cudaLimitStackSize: cudaLimit = 0;
403pub const cudaLimit_cudaLimitPrintfFifoSize: cudaLimit = 1;
404pub const cudaLimit_cudaLimitMallocHeapSize: cudaLimit = 2;
405pub const cudaLimit_cudaLimitDevRuntimeSyncDepth: cudaLimit = 3;
406pub const cudaLimit_cudaLimitDevRuntimePendingLaunchCount: cudaLimit = 4;
407pub type cudaLimit = ::std::os::raw::c_uint;
408pub const cudaMemoryAdvise_cudaMemAdviseSetReadMostly: cudaMemoryAdvise = 1;
409pub const cudaMemoryAdvise_cudaMemAdviseUnsetReadMostly: cudaMemoryAdvise = 2;
410pub const cudaMemoryAdvise_cudaMemAdviseSetPreferredLocation: cudaMemoryAdvise = 3;
411pub const cudaMemoryAdvise_cudaMemAdviseUnsetPreferredLocation: cudaMemoryAdvise = 4;
412pub const cudaMemoryAdvise_cudaMemAdviseSetAccessedBy: cudaMemoryAdvise = 5;
413pub const cudaMemoryAdvise_cudaMemAdviseUnsetAccessedBy: cudaMemoryAdvise = 6;
414pub type cudaMemoryAdvise = ::std::os::raw::c_uint;
415pub const cudaMemRangeAttribute_cudaMemRangeAttributeReadMostly: cudaMemRangeAttribute = 1;
416pub const cudaMemRangeAttribute_cudaMemRangeAttributePreferredLocation: cudaMemRangeAttribute = 2;
417pub const cudaMemRangeAttribute_cudaMemRangeAttributeAccessedBy: cudaMemRangeAttribute = 3;
418pub const cudaMemRangeAttribute_cudaMemRangeAttributeLastPrefetchLocation: cudaMemRangeAttribute = 4;
419pub type cudaMemRangeAttribute = ::std::os::raw::c_uint;
420pub const cudaOutputMode_cudaKeyValuePair: cudaOutputMode = 0;
421pub const cudaOutputMode_cudaCSV: cudaOutputMode = 1;
422pub type cudaOutputMode = ::std::os::raw::c_uint;
423pub const cudaDeviceP2PAttr_cudaDevP2PAttrPerformanceRank: cudaDeviceP2PAttr = 1;
424pub const cudaDeviceP2PAttr_cudaDevP2PAttrAccessSupported: cudaDeviceP2PAttr = 2;
425pub const cudaDeviceP2PAttr_cudaDevP2PAttrNativeAtomicSupported: cudaDeviceP2PAttr = 3;
426pub type cudaDeviceP2PAttr = ::std::os::raw::c_uint;
427#[repr(C)]
428#[derive(Copy, Clone)]
429pub struct cudaDeviceProp {
430 pub name: [::std::os::raw::c_char; 256usize],
431 pub totalGlobalMem: usize,
432 pub sharedMemPerBlock: usize,
433 pub regsPerBlock: ::std::os::raw::c_int,
434 pub warpSize: ::std::os::raw::c_int,
435 pub memPitch: usize,
436 pub maxThreadsPerBlock: ::std::os::raw::c_int,
437 pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
438 pub maxGridSize: [::std::os::raw::c_int; 3usize],
439 pub clockRate: ::std::os::raw::c_int,
440 pub totalConstMem: usize,
441 pub major: ::std::os::raw::c_int,
442 pub minor: ::std::os::raw::c_int,
443 pub textureAlignment: usize,
444 pub texturePitchAlignment: usize,
445 pub deviceOverlap: ::std::os::raw::c_int,
446 pub multiProcessorCount: ::std::os::raw::c_int,
447 pub kernelExecTimeoutEnabled: ::std::os::raw::c_int,
448 pub integrated: ::std::os::raw::c_int,
449 pub canMapHostMemory: ::std::os::raw::c_int,
450 pub computeMode: cudaComputeMode,
451 pub maxTexture1D: ::std::os::raw::c_int,
452 pub maxTexture1DMipmap: ::std::os::raw::c_int,
453 pub maxTexture1DLinear: ::std::os::raw::c_int,
454 pub maxTexture2D: [::std::os::raw::c_int; 2usize],
455 pub maxTexture2DMipmap: [::std::os::raw::c_int; 2usize],
456 pub maxTexture2DLinear: [::std::os::raw::c_int; 3usize],
457 pub maxTexture2DGather: [::std::os::raw::c_int; 2usize],
458 pub maxTexture3D: [::std::os::raw::c_int; 3usize],
459 pub maxTexture3DAlt: [::std::os::raw::c_int; 3usize],
460 pub maxTextureCubemap: ::std::os::raw::c_int,
461 pub maxTexture1DLayered: [::std::os::raw::c_int; 2usize],
462 pub maxTexture2DLayered: [::std::os::raw::c_int; 3usize],
463 pub maxTextureCubemapLayered: [::std::os::raw::c_int; 2usize],
464 pub maxSurface1D: ::std::os::raw::c_int,
465 pub maxSurface2D: [::std::os::raw::c_int; 2usize],
466 pub maxSurface3D: [::std::os::raw::c_int; 3usize],
467 pub maxSurface1DLayered: [::std::os::raw::c_int; 2usize],
468 pub maxSurface2DLayered: [::std::os::raw::c_int; 3usize],
469 pub maxSurfaceCubemap: ::std::os::raw::c_int,
470 pub maxSurfaceCubemapLayered: [::std::os::raw::c_int; 2usize],
471 pub surfaceAlignment: usize,
472 pub concurrentKernels: ::std::os::raw::c_int,
473 pub ECCEnabled: ::std::os::raw::c_int,
474 pub pciBusID: ::std::os::raw::c_int,
475 pub pciDeviceID: ::std::os::raw::c_int,
476 pub pciDomainID: ::std::os::raw::c_int,
477 pub tccDriver: ::std::os::raw::c_int,
478 pub asyncEngineCount: ::std::os::raw::c_int,
479 pub unifiedAddressing: ::std::os::raw::c_int,
480 pub memoryClockRate: ::std::os::raw::c_int,
481 pub memoryBusWidth: ::std::os::raw::c_int,
482 pub l2CacheSize: ::std::os::raw::c_int,
483 pub maxThreadsPerMultiProcessor: ::std::os::raw::c_int,
484 pub streamPrioritiesSupported: ::std::os::raw::c_int,
485 pub globalL1CacheSupported: ::std::os::raw::c_int,
486 pub localL1CacheSupported: ::std::os::raw::c_int,
487 pub sharedMemPerMultiprocessor: usize,
488 pub regsPerMultiprocessor: ::std::os::raw::c_int,
489 pub managedMemory: ::std::os::raw::c_int,
490 pub isMultiGpuBoard: ::std::os::raw::c_int,
491 pub multiGpuBoardGroupID: ::std::os::raw::c_int,
492 pub hostNativeAtomicSupported: ::std::os::raw::c_int,
493 pub singleToDoublePrecisionPerfRatio: ::std::os::raw::c_int,
494 pub pageableMemoryAccess: ::std::os::raw::c_int,
495 pub concurrentManagedAccess: ::std::os::raw::c_int,
496 pub computePreemptionSupported: ::std::os::raw::c_int,
497 pub canUseHostPointerForRegisteredMem: ::std::os::raw::c_int,
498 pub cooperativeLaunch: ::std::os::raw::c_int,
499 pub cooperativeMultiDeviceLaunch: ::std::os::raw::c_int,
500 pub sharedMemPerBlockOptin: usize,
501}
502
503#[repr(u32)]
504#[derive(Copy, Clone)]
505pub enum cudaDeviceAttr {
506 MaxThreadsPerBlock = 1,
507 MaxBlockDimX = 2,
508 MaxBlockDimY = 3,
509 MaxBlockDimZ = 4,
510 MaxGridDimX = 5,
511 MaxGridDimY = 6,
512 MaxGridDimZ = 7,
513 MaxSharedMemoryPerBlock = 8,
514 TotalConstantMemory = 9,
515 WarpSize = 10,
516 MaxPitch = 11,
517 MaxRegistersPerBlock = 12,
518 ClockRate = 13,
519 TextureAlignment = 14,
520 GpuOverlap = 15,
521 MultiProcessorCount = 16,
522 KernelExecTimeout = 17,
523 Integrated = 18,
524 CanMapHostMemory = 19,
525 ComputeMode = 20,
526 MaxTexture1DWidth = 21,
527 MaxTexture2DWidth = 22,
528 MaxTexture2DHeight = 23,
529 MaxTexture3DWidth = 24,
530 MaxTexture3DHeight = 25,
531 MaxTexture3DDepth = 26,
532 MaxTexture2DLayeredWidth = 27,
533 MaxTexture2DLayeredHeight = 28,
534 MaxTexture2DLayeredLayers = 29,
535 SurfaceAlignment = 30,
536 ConcurrentKernels = 31,
537 EccEnabled = 32,
538 PciBusId = 33,
539 PciDeviceId = 34,
540 TccDriver = 35,
541 MemoryClockRate = 36,
542 GlobalMemoryBusWidth = 37,
543 L2CacheSize = 38,
544 MaxThreadsPerMultiProcessor = 39,
545 AsyncEngineCount = 40,
546 UnifiedAddressing = 41,
547 MaxTexture1DLayeredWidth = 42,
548 MaxTexture1DLayeredLayers = 43,
549 MaxTexture2DGatherWidth = 45,
550 MaxTexture2DGatherHeight = 46,
551 MaxTexture3DWidthAlt = 47,
552 MaxTexture3DHeightAlt = 48,
553 MaxTexture3DDepthAlt = 49,
554 PciDomainId = 50,
555 TexturePitchAlignment = 51,
556 MaxTextureCubemapWidth = 52,
557 MaxTextureCubemapLayeredWidth = 53,
558 MaxTextureCubemapLayeredLayers = 54,
559 MaxSurface1DWidth = 55,
560 MaxSurface2DWidth = 56,
561 MaxSurface2DHeight = 57,
562 MaxSurface3DWidth = 58,
563 MaxSurface3DHeight = 59,
564 MaxSurface3DDepth = 60,
565 MaxSurface1DLayeredWidth = 61,
566 MaxSurface1DLayeredLayers = 62,
567 MaxSurface2DLayeredWidth = 63,
568 MaxSurface2DLayeredHeight = 64,
569 MaxSurface2DLayeredLayers = 65,
570 MaxSurfaceCubemapWidth = 66,
571 MaxSurfaceCubemapLayeredWidth = 67,
572 MaxSurfaceCubemapLayeredLayers = 68,
573 MaxTexture1DLinearWidth = 69,
574 MaxTexture2DLinearWidth = 70,
575 MaxTexture2DLinearHeight = 71,
576 MaxTexture2DLinearPitch = 72,
577 MaxTexture2DMipmappedWidth = 73,
578 MaxTexture2DMipmappedHeight = 74,
579 ComputeCapabilityMajor = 75,
580 ComputeCapabilityMinor = 76,
581 MaxTexture1DMipmappedWidth = 77,
582 StreamPrioritiesSupported = 78,
583 GlobalL1CacheSupported = 79,
584 LocalL1CacheSupported = 80,
585 MaxSharedMemoryPerMultiprocessor = 81,
586 MaxRegistersPerMultiprocessor = 82,
587 ManagedMemory = 83,
588 IsMultiGpuBoard = 84,
589 MultiGpuBoardGroupID = 85,
590 HostNativeAtomicSupported = 86,
591 SingleToDoublePrecisionPerfRatio = 87,
592 PageableMemoryAccess = 88,
593 ConcurrentManagedAccess = 89,
594 ComputePreemptionSupported = 90,
595 CanUseHostPointerForRegisteredMem = 91,
596 Reserved92 = 92,
597 Reserved93 = 93,
598 Reserved94 = 94,
599 CooperativeLaunch = 95,
600 CooperativeMultiDeviceLaunch = 96,
601 MaxSharedMemoryPerBlockOptin = 97,
602}
603
604#[repr(C)]
605#[derive(Copy, Clone)]
606pub struct cudaIpcEventHandle_st {
607 pub reserved: [::std::os::raw::c_char; 64usize],
608}
609pub type cudaIpcEventHandle_t = cudaIpcEventHandle_st;
610#[repr(C)]
611#[derive(Copy, Clone)]
612pub struct cudaIpcMemHandle_st {
613 pub reserved: [::std::os::raw::c_char; 64usize],
614}
615pub type cudaIpcMemHandle_t = cudaIpcMemHandle_st;
616#[repr(C)]
617#[derive(Debug, Copy, Clone)]
618pub struct CUstream_st {
619 _unused: [u8; 0],
620}
621pub type cudaStream_t = *mut CUstream_st;
622#[repr(C)]
623#[derive(Debug, Copy, Clone)]
624pub struct CUevent_st {
625 _unused: [u8; 0],
626}
627pub type cudaEvent_t = *mut CUevent_st;
628pub type cudaGraphicsResource_t = *mut cudaGraphicsResource;
629#[repr(C)]
630#[derive(Debug, Copy, Clone)]
631pub struct CUuuid_st {
632 _unused: [u8; 0],
633}
634pub type cudaUUID_t = CUuuid_st;
635pub use self::cudaOutputMode as cudaOutputMode_t;
636pub const cudaCGScope_cudaCGScopeInvalid: cudaCGScope = 0;
637pub const cudaCGScope_cudaCGScopeGrid: cudaCGScope = 1;
638pub const cudaCGScope_cudaCGScopeMultiGrid: cudaCGScope = 2;
639pub type cudaCGScope = ::std::os::raw::c_uint;
640#[repr(C)]
641#[derive(Debug, Copy, Clone)]
642pub struct cudaLaunchParams {
643 pub func: *mut ::std::os::raw::c_void,
644 pub gridDim: dim3,
645 pub blockDim: dim3,
646 pub args: *mut *mut ::std::os::raw::c_void,
647 pub sharedMem: usize,
648 pub stream: cudaStream_t,
649}
650pub const cudaSurfaceBoundaryMode_cudaBoundaryModeZero: cudaSurfaceBoundaryMode = 0;
651pub const cudaSurfaceBoundaryMode_cudaBoundaryModeClamp: cudaSurfaceBoundaryMode = 1;
652pub const cudaSurfaceBoundaryMode_cudaBoundaryModeTrap: cudaSurfaceBoundaryMode = 2;
653pub type cudaSurfaceBoundaryMode = ::std::os::raw::c_uint;
654pub const cudaSurfaceFormatMode_cudaFormatModeForced: cudaSurfaceFormatMode = 0;
655pub const cudaSurfaceFormatMode_cudaFormatModeAuto: cudaSurfaceFormatMode = 1;
656pub type cudaSurfaceFormatMode = ::std::os::raw::c_uint;
657#[repr(C)]
658#[derive(Debug, Copy, Clone)]
659pub struct surfaceReference {
660 pub channelDesc: cudaChannelFormatDesc,
661}
662pub type cudaSurfaceObject_t = ::std::os::raw::c_ulonglong;
663pub const cudaTextureAddressMode_cudaAddressModeWrap: cudaTextureAddressMode = 0;
664pub const cudaTextureAddressMode_cudaAddressModeClamp: cudaTextureAddressMode = 1;
665pub const cudaTextureAddressMode_cudaAddressModeMirror: cudaTextureAddressMode = 2;
666pub const cudaTextureAddressMode_cudaAddressModeBorder: cudaTextureAddressMode = 3;
667pub type cudaTextureAddressMode = ::std::os::raw::c_uint;
668pub const cudaTextureFilterMode_cudaFilterModePoint: cudaTextureFilterMode = 0;
669pub const cudaTextureFilterMode_cudaFilterModeLinear: cudaTextureFilterMode = 1;
670pub type cudaTextureFilterMode = ::std::os::raw::c_uint;
671pub const cudaTextureReadMode_cudaReadModeElementType: cudaTextureReadMode = 0;
672pub const cudaTextureReadMode_cudaReadModeNormalizedFloat: cudaTextureReadMode = 1;
673pub type cudaTextureReadMode = ::std::os::raw::c_uint;
674#[repr(C)]
675#[derive(Debug, Copy, Clone)]
676pub struct textureReference {
677 pub normalized: ::std::os::raw::c_int,
678 pub filterMode: cudaTextureFilterMode,
679 pub addressMode: [cudaTextureAddressMode; 3usize],
680 pub channelDesc: cudaChannelFormatDesc,
681 pub sRGB: ::std::os::raw::c_int,
682 pub maxAnisotropy: ::std::os::raw::c_uint,
683 pub mipmapFilterMode: cudaTextureFilterMode,
684 pub mipmapLevelBias: f32,
685 pub minMipmapLevelClamp: f32,
686 pub maxMipmapLevelClamp: f32,
687 pub __cudaReserved: [::std::os::raw::c_int; 15usize],
688}
689#[repr(C)]
690#[derive(Debug, Copy, Clone)]
691pub struct cudaTextureDesc {
692 pub addressMode: [cudaTextureAddressMode; 3usize],
693 pub filterMode: cudaTextureFilterMode,
694 pub readMode: cudaTextureReadMode,
695 pub sRGB: ::std::os::raw::c_int,
696 pub borderColor: [f32; 4usize],
697 pub normalizedCoords: ::std::os::raw::c_int,
698 pub maxAnisotropy: ::std::os::raw::c_uint,
699 pub mipmapFilterMode: cudaTextureFilterMode,
700 pub mipmapLevelBias: f32,
701 pub minMipmapLevelClamp: f32,
702 pub maxMipmapLevelClamp: f32,
703}
704pub type cudaTextureObject_t = ::std::os::raw::c_ulonglong;
705pub const cudaDataType_t_CUDA_R_16F: cudaDataType_t = 2;
706pub const cudaDataType_t_CUDA_C_16F: cudaDataType_t = 6;
707pub const cudaDataType_t_CUDA_R_32F: cudaDataType_t = 0;
708pub const cudaDataType_t_CUDA_C_32F: cudaDataType_t = 4;
709pub const cudaDataType_t_CUDA_R_64F: cudaDataType_t = 1;
710pub const cudaDataType_t_CUDA_C_64F: cudaDataType_t = 5;
711pub const cudaDataType_t_CUDA_R_8I: cudaDataType_t = 3;
712pub const cudaDataType_t_CUDA_C_8I: cudaDataType_t = 7;
713pub const cudaDataType_t_CUDA_R_8U: cudaDataType_t = 8;
714pub const cudaDataType_t_CUDA_C_8U: cudaDataType_t = 9;
715pub const cudaDataType_t_CUDA_R_32I: cudaDataType_t = 10;
716pub const cudaDataType_t_CUDA_C_32I: cudaDataType_t = 11;
717pub const cudaDataType_t_CUDA_R_32U: cudaDataType_t = 12;
718pub const cudaDataType_t_CUDA_C_32U: cudaDataType_t = 13;
719pub type cudaDataType_t = ::std::os::raw::c_uint;
720pub use self::cudaDataType_t as cudaDataType;
721pub const libraryPropertyType_t_MAJOR_VERSION: libraryPropertyType_t = 0;
722pub const libraryPropertyType_t_MINOR_VERSION: libraryPropertyType_t = 1;
723pub const libraryPropertyType_t_PATCH_LEVEL: libraryPropertyType_t = 2;
724pub type libraryPropertyType_t = ::std::os::raw::c_uint;
725pub use self::libraryPropertyType_t as libraryPropertyType;
726extern "C" {
727 pub fn cudaDeviceReset() -> cudaError_t;
728
729 pub fn cudaDeviceSynchronize() -> cudaError_t;
730
731 pub fn cudaDeviceSetLimit(limit: cudaLimit, value: usize) -> cudaError_t;
732
733 pub fn cudaDeviceGetLimit(pValue: *mut usize, limit: cudaLimit) -> cudaError_t;
734
735 pub fn cudaDeviceGetCacheConfig(pCacheConfig: *mut cudaFuncCache) -> cudaError_t;
736
737 pub fn cudaDeviceGetStreamPriorityRange(
738 leastPriority: *mut ::std::os::raw::c_int,
739 greatestPriority: *mut ::std::os::raw::c_int,
740 ) -> cudaError_t;
741
742 pub fn cudaDeviceSetCacheConfig(cacheConfig: cudaFuncCache) -> cudaError_t;
743
744 pub fn cudaDeviceGetSharedMemConfig(pConfig: *mut cudaSharedMemConfig) -> cudaError_t;
745
746 pub fn cudaDeviceSetSharedMemConfig(config: cudaSharedMemConfig) -> cudaError_t;
747
748 pub fn cudaDeviceGetByPCIBusId(
749 device: *mut ::std::os::raw::c_int,
750 pciBusId: *const ::std::os::raw::c_char,
751 ) -> cudaError_t;
752
753 pub fn cudaDeviceGetPCIBusId(
754 pciBusId: *mut ::std::os::raw::c_char,
755 len: ::std::os::raw::c_int,
756 device: ::std::os::raw::c_int,
757 ) -> cudaError_t;
758
759 pub fn cudaIpcGetEventHandle(handle: *mut cudaIpcEventHandle_t, event: cudaEvent_t) -> cudaError_t;
760
761 pub fn cudaIpcOpenEventHandle(event: *mut cudaEvent_t, handle: cudaIpcEventHandle_t) -> cudaError_t;
762
763 pub fn cudaIpcGetMemHandle(handle: *mut cudaIpcMemHandle_t, devPtr: *mut ::std::os::raw::c_void) -> cudaError_t;
764
765 pub fn cudaIpcOpenMemHandle(
766 devPtr: *mut *mut ::std::os::raw::c_void,
767 handle: cudaIpcMemHandle_t,
768 flags: ::std::os::raw::c_uint,
769 ) -> cudaError_t;
770
771 pub fn cudaIpcCloseMemHandle(devPtr: *mut ::std::os::raw::c_void) -> cudaError_t;
772
773 pub fn cudaThreadExit() -> cudaError_t;
774
775 pub fn cudaThreadSynchronize() -> cudaError_t;
776
777 pub fn cudaThreadSetLimit(limit: cudaLimit, value: usize) -> cudaError_t;
778
779 pub fn cudaThreadGetLimit(pValue: *mut usize, limit: cudaLimit) -> cudaError_t;
780
781 pub fn cudaThreadGetCacheConfig(pCacheConfig: *mut cudaFuncCache) -> cudaError_t;
782
783 pub fn cudaThreadSetCacheConfig(cacheConfig: cudaFuncCache) -> cudaError_t;
784
785 pub fn cudaGetLastError() -> cudaError_t;
786
787 pub fn cudaPeekAtLastError() -> cudaError_t;
788
789 pub fn cudaGetErrorName(error: cudaError_t) -> *const ::std::os::raw::c_char;
790
791 pub fn cudaGetErrorString(error: cudaError_t) -> *const ::std::os::raw::c_char;
792
793 pub fn cudaGetDeviceCount(count: *mut ::std::os::raw::c_int) -> cudaError_t;
794
795 pub fn cudaGetDeviceProperties(prop: *mut cudaDeviceProp, device: ::std::os::raw::c_int) -> cudaError_t;
796
797 pub fn cudaDeviceGetAttribute(
798 value: *mut ::std::os::raw::c_int,
799 attr: cudaDeviceAttr,
800 device: ::std::os::raw::c_int,
801 ) -> cudaError_t;
802
803 pub fn cudaDeviceGetP2PAttribute(
804 value: *mut ::std::os::raw::c_int,
805 attr: cudaDeviceP2PAttr,
806 srcDevice: ::std::os::raw::c_int,
807 dstDevice: ::std::os::raw::c_int,
808 ) -> cudaError_t;
809
810 pub fn cudaChooseDevice(device: *mut ::std::os::raw::c_int, prop: *const cudaDeviceProp) -> cudaError_t;
811
812 pub fn cudaSetDevice(device: ::std::os::raw::c_int) -> cudaError_t;
813
814 pub fn cudaGetDevice(device: *mut ::std::os::raw::c_int) -> cudaError_t;
815
816 pub fn cudaSetValidDevices(device_arr: *mut ::std::os::raw::c_int, len: ::std::os::raw::c_int) -> cudaError_t;
817
818 pub fn cudaSetDeviceFlags(flags: ::std::os::raw::c_uint) -> cudaError_t;
819
820 pub fn cudaGetDeviceFlags(flags: *mut ::std::os::raw::c_uint) -> cudaError_t;
821
822 pub fn cudaStreamCreate(pStream: *mut cudaStream_t) -> cudaError_t;
823
824 pub fn cudaStreamCreateWithFlags(pStream: *mut cudaStream_t, flags: ::std::os::raw::c_uint) -> cudaError_t;
825
826 pub fn cudaStreamCreateWithPriority(
827 pStream: *mut cudaStream_t,
828 flags: ::std::os::raw::c_uint,
829 priority: ::std::os::raw::c_int,
830 ) -> cudaError_t;
831
832 pub fn cudaStreamGetPriority(hStream: cudaStream_t, priority: *mut ::std::os::raw::c_int) -> cudaError_t;
833
834 pub fn cudaStreamGetFlags(hStream: cudaStream_t, flags: *mut ::std::os::raw::c_uint) -> cudaError_t;
835
836 pub fn cudaStreamDestroy(stream: cudaStream_t) -> cudaError_t;
837
838 pub fn cudaStreamWaitEvent(stream: cudaStream_t, event: cudaEvent_t, flags: ::std::os::raw::c_uint) -> cudaError_t;
839}
840pub type cudaStreamCallback_t = ::std::option::Option<
841 unsafe extern "C" fn(stream: cudaStream_t, status: cudaError_t, userData: *mut ::std::os::raw::c_void),
842>;
843extern "C" {
844 pub fn cudaStreamAddCallback(
845 stream: cudaStream_t,
846 callback: cudaStreamCallback_t,
847 userData: *mut ::std::os::raw::c_void,
848 flags: ::std::os::raw::c_uint,
849 ) -> cudaError_t;
850
851 pub fn cudaStreamSynchronize(stream: cudaStream_t) -> cudaError_t;
852
853 pub fn cudaStreamQuery(stream: cudaStream_t) -> cudaError_t;
854
855 pub fn cudaStreamAttachMemAsync(
856 stream: cudaStream_t,
857 devPtr: *mut ::std::os::raw::c_void,
858 length: usize,
859 flags: ::std::os::raw::c_uint,
860 ) -> cudaError_t;
861
862 pub fn cudaEventCreate(event: *mut cudaEvent_t) -> cudaError_t;
863
864 pub fn cudaEventCreateWithFlags(event: *mut cudaEvent_t, flags: ::std::os::raw::c_uint) -> cudaError_t;
865
866 pub fn cudaEventRecord(event: cudaEvent_t, stream: cudaStream_t) -> cudaError_t;
867
868 pub fn cudaEventQuery(event: cudaEvent_t) -> cudaError_t;
869
870 pub fn cudaEventSynchronize(event: cudaEvent_t) -> cudaError_t;
871
872 pub fn cudaEventDestroy(event: cudaEvent_t) -> cudaError_t;
873
874 pub fn cudaEventElapsedTime(ms: *mut f32, start: cudaEvent_t, end: cudaEvent_t) -> cudaError_t;
875
876 pub fn cudaLaunchKernel(
877 func: *const ::std::os::raw::c_void,
878 gridDim: dim3,
879 blockDim: dim3,
880 args: *mut *mut ::std::os::raw::c_void,
881 sharedMem: usize,
882 stream: cudaStream_t,
883 ) -> cudaError_t;
884
885 pub fn cudaLaunchCooperativeKernel(
886 func: *const ::std::os::raw::c_void,
887 gridDim: dim3,
888 blockDim: dim3,
889 args: *mut *mut ::std::os::raw::c_void,
890 sharedMem: usize,
891 stream: cudaStream_t,
892 ) -> cudaError_t;
893
894 pub fn cudaLaunchCooperativeKernelMultiDevice(
895 launchParamsList: *mut cudaLaunchParams,
896 numDevices: ::std::os::raw::c_uint,
897 flags: ::std::os::raw::c_uint,
898 ) -> cudaError_t;
899
900 pub fn cudaFuncSetCacheConfig(func: *const ::std::os::raw::c_void, cacheConfig: cudaFuncCache) -> cudaError_t;
901
902 pub fn cudaFuncSetSharedMemConfig(func: *const ::std::os::raw::c_void, config: cudaSharedMemConfig) -> cudaError_t;
903
904 pub fn cudaFuncGetAttributes(attr: *mut cudaFuncAttributes, func: *const ::std::os::raw::c_void) -> cudaError_t;
905
906 pub fn cudaFuncSetAttribute(
907 func: *const ::std::os::raw::c_void,
908 attr: cudaFuncAttribute,
909 value: ::std::os::raw::c_int,
910 ) -> cudaError_t;
911
912 pub fn cudaSetDoubleForDevice(d: *mut f64) -> cudaError_t;
913
914 pub fn cudaSetDoubleForHost(d: *mut f64) -> cudaError_t;
915
916 pub fn cudaOccupancyMaxActiveBlocksPerMultiprocessor(
917 numBlocks: *mut ::std::os::raw::c_int,
918 func: *const ::std::os::raw::c_void,
919 blockSize: ::std::os::raw::c_int,
920 dynamicSMemSize: usize,
921 ) -> cudaError_t;
922
923 pub fn cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
924 numBlocks: *mut ::std::os::raw::c_int,
925 func: *const ::std::os::raw::c_void,
926 blockSize: ::std::os::raw::c_int,
927 dynamicSMemSize: usize,
928 flags: ::std::os::raw::c_uint,
929 ) -> cudaError_t;
930
931 pub fn cudaConfigureCall(gridDim: dim3, blockDim: dim3, sharedMem: usize, stream: cudaStream_t) -> cudaError_t;
932
933 pub fn cudaSetupArgument(arg: *const ::std::os::raw::c_void, size: usize, offset: usize) -> cudaError_t;
934
935 pub fn cudaLaunch(func: *const ::std::os::raw::c_void) -> cudaError_t;
936
937 pub fn cudaMallocManaged(
938 devPtr: *mut *mut ::std::os::raw::c_void,
939 size: usize,
940 flags: ::std::os::raw::c_uint,
941 ) -> cudaError_t;
942
943 pub fn cudaMalloc(devPtr: *mut *mut ::std::os::raw::c_void, size: usize) -> cudaError_t;
944
945 pub fn cudaMallocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> cudaError_t;
946
947 pub fn cudaMallocPitch(
948 devPtr: *mut *mut ::std::os::raw::c_void,
949 pitch: *mut usize,
950 width: usize,
951 height: usize,
952 ) -> cudaError_t;
953
954 pub fn cudaMallocArray(
955 array: *mut cudaArray_t,
956 desc: *const cudaChannelFormatDesc,
957 width: usize,
958 height: usize,
959 flags: ::std::os::raw::c_uint,
960 ) -> cudaError_t;
961
962 pub fn cudaFree(devPtr: *mut ::std::os::raw::c_void) -> cudaError_t;
963
964 pub fn cudaFreeHost(ptr: *mut ::std::os::raw::c_void) -> cudaError_t;
965
966 pub fn cudaFreeArray(array: cudaArray_t) -> cudaError_t;
967
968 pub fn cudaFreeMipmappedArray(mipmappedArray: cudaMipmappedArray_t) -> cudaError_t;
969
970 pub fn cudaHostAlloc(
971 pHost: *mut *mut ::std::os::raw::c_void,
972 size: usize,
973 flags: ::std::os::raw::c_uint,
974 ) -> cudaError_t;
975
976 pub fn cudaHostRegister(
977 ptr: *mut ::std::os::raw::c_void,
978 size: usize,
979 flags: ::std::os::raw::c_uint,
980 ) -> cudaError_t;
981
982 pub fn cudaHostUnregister(ptr: *mut ::std::os::raw::c_void) -> cudaError_t;
983
984 pub fn cudaHostGetDevicePointer(
985 pDevice: *mut *mut ::std::os::raw::c_void,
986 pHost: *mut ::std::os::raw::c_void,
987 flags: ::std::os::raw::c_uint,
988 ) -> cudaError_t;
989
990 pub fn cudaHostGetFlags(pFlags: *mut ::std::os::raw::c_uint, pHost: *mut ::std::os::raw::c_void) -> cudaError_t;
991
992 pub fn cudaMalloc3D(pitchedDevPtr: *mut cudaPitchedPtr, extent: cudaExtent) -> cudaError_t;
993
994 pub fn cudaMalloc3DArray(
995 array: *mut cudaArray_t,
996 desc: *const cudaChannelFormatDesc,
997 extent: cudaExtent,
998 flags: ::std::os::raw::c_uint,
999 ) -> cudaError_t;
1000
1001 pub fn cudaMallocMipmappedArray(
1002 mipmappedArray: *mut cudaMipmappedArray_t,
1003 desc: *const cudaChannelFormatDesc,
1004 extent: cudaExtent,
1005 numLevels: ::std::os::raw::c_uint,
1006 flags: ::std::os::raw::c_uint,
1007 ) -> cudaError_t;
1008
1009 pub fn cudaGetMipmappedArrayLevel(
1010 levelArray: *mut cudaArray_t,
1011 mipmappedArray: cudaMipmappedArray_const_t,
1012 level: ::std::os::raw::c_uint,
1013 ) -> cudaError_t;
1014
1015 pub fn cudaMemcpy3D(p: *const cudaMemcpy3DParms) -> cudaError_t;
1016
1017 pub fn cudaMemcpy3DPeer(p: *const cudaMemcpy3DPeerParms) -> cudaError_t;
1018
1019 pub fn cudaMemcpy3DAsync(p: *const cudaMemcpy3DParms, stream: cudaStream_t) -> cudaError_t;
1020
1021 pub fn cudaMemcpy3DPeerAsync(p: *const cudaMemcpy3DPeerParms, stream: cudaStream_t) -> cudaError_t;
1022
1023 pub fn cudaMemGetInfo(free: *mut usize, total: *mut usize) -> cudaError_t;
1024
1025 pub fn cudaArrayGetInfo(
1026 desc: *mut cudaChannelFormatDesc,
1027 extent: *mut cudaExtent,
1028 flags: *mut ::std::os::raw::c_uint,
1029 array: cudaArray_t,
1030 ) -> cudaError_t;
1031
1032 pub fn cudaMemcpy(
1033 dst: *mut ::std::os::raw::c_void,
1034 src: *const ::std::os::raw::c_void,
1035 count: usize,
1036 kind: cudaMemcpyKind,
1037 ) -> cudaError_t;
1038
1039 pub fn cudaMemcpyPeer(
1040 dst: *mut ::std::os::raw::c_void,
1041 dstDevice: ::std::os::raw::c_int,
1042 src: *const ::std::os::raw::c_void,
1043 srcDevice: ::std::os::raw::c_int,
1044 count: usize,
1045 ) -> cudaError_t;
1046
1047 pub fn cudaMemcpyToArray(
1048 dst: cudaArray_t,
1049 wOffset: usize,
1050 hOffset: usize,
1051 src: *const ::std::os::raw::c_void,
1052 count: usize,
1053 kind: cudaMemcpyKind,
1054 ) -> cudaError_t;
1055
1056 pub fn cudaMemcpyFromArray(
1057 dst: *mut ::std::os::raw::c_void,
1058 src: cudaArray_const_t,
1059 wOffset: usize,
1060 hOffset: usize,
1061 count: usize,
1062 kind: cudaMemcpyKind,
1063 ) -> cudaError_t;
1064
1065 pub fn cudaMemcpyArrayToArray(
1066 dst: cudaArray_t,
1067 wOffsetDst: usize,
1068 hOffsetDst: usize,
1069 src: cudaArray_const_t,
1070 wOffsetSrc: usize,
1071 hOffsetSrc: usize,
1072 count: usize,
1073 kind: cudaMemcpyKind,
1074 ) -> cudaError_t;
1075
1076 pub fn cudaMemcpy2D(
1077 dst: *mut ::std::os::raw::c_void,
1078 dpitch: usize,
1079 src: *const ::std::os::raw::c_void,
1080 spitch: usize,
1081 width: usize,
1082 height: usize,
1083 kind: cudaMemcpyKind,
1084 ) -> cudaError_t;
1085
1086 pub fn cudaMemcpy2DToArray(
1087 dst: cudaArray_t,
1088 wOffset: usize,
1089 hOffset: usize,
1090 src: *const ::std::os::raw::c_void,
1091 spitch: usize,
1092 width: usize,
1093 height: usize,
1094 kind: cudaMemcpyKind,
1095 ) -> cudaError_t;
1096
1097 pub fn cudaMemcpy2DFromArray(
1098 dst: *mut ::std::os::raw::c_void,
1099 dpitch: usize,
1100 src: cudaArray_const_t,
1101 wOffset: usize,
1102 hOffset: usize,
1103 width: usize,
1104 height: usize,
1105 kind: cudaMemcpyKind,
1106 ) -> cudaError_t;
1107
1108 pub fn cudaMemcpy2DArrayToArray(
1109 dst: cudaArray_t,
1110 wOffsetDst: usize,
1111 hOffsetDst: usize,
1112 src: cudaArray_const_t,
1113 wOffsetSrc: usize,
1114 hOffsetSrc: usize,
1115 width: usize,
1116 height: usize,
1117 kind: cudaMemcpyKind,
1118 ) -> cudaError_t;
1119
1120 pub fn cudaMemcpyToSymbol(
1121 symbol: *const ::std::os::raw::c_void,
1122 src: *const ::std::os::raw::c_void,
1123 count: usize,
1124 offset: usize,
1125 kind: cudaMemcpyKind,
1126 ) -> cudaError_t;
1127
1128 pub fn cudaMemcpyFromSymbol(
1129 dst: *mut ::std::os::raw::c_void,
1130 symbol: *const ::std::os::raw::c_void,
1131 count: usize,
1132 offset: usize,
1133 kind: cudaMemcpyKind,
1134 ) -> cudaError_t;
1135
1136 pub fn cudaMemcpyAsync(
1137 dst: *mut ::std::os::raw::c_void,
1138 src: *const ::std::os::raw::c_void,
1139 count: usize,
1140 kind: cudaMemcpyKind,
1141 stream: cudaStream_t,
1142 ) -> cudaError_t;
1143
1144 pub fn cudaMemcpyPeerAsync(
1145 dst: *mut ::std::os::raw::c_void,
1146 dstDevice: ::std::os::raw::c_int,
1147 src: *const ::std::os::raw::c_void,
1148 srcDevice: ::std::os::raw::c_int,
1149 count: usize,
1150 stream: cudaStream_t,
1151 ) -> cudaError_t;
1152
1153 pub fn cudaMemcpyToArrayAsync(
1154 dst: cudaArray_t,
1155 wOffset: usize,
1156 hOffset: usize,
1157 src: *const ::std::os::raw::c_void,
1158 count: usize,
1159 kind: cudaMemcpyKind,
1160 stream: cudaStream_t,
1161 ) -> cudaError_t;
1162
1163 pub fn cudaMemcpyFromArrayAsync(
1164 dst: *mut ::std::os::raw::c_void,
1165 src: cudaArray_const_t,
1166 wOffset: usize,
1167 hOffset: usize,
1168 count: usize,
1169 kind: cudaMemcpyKind,
1170 stream: cudaStream_t,
1171 ) -> cudaError_t;
1172
1173 pub fn cudaMemcpy2DAsync(
1174 dst: *mut ::std::os::raw::c_void,
1175 dpitch: usize,
1176 src: *const ::std::os::raw::c_void,
1177 spitch: usize,
1178 width: usize,
1179 height: usize,
1180 kind: cudaMemcpyKind,
1181 stream: cudaStream_t,
1182 ) -> cudaError_t;
1183
1184 pub fn cudaMemcpy2DToArrayAsync(
1185 dst: cudaArray_t,
1186 wOffset: usize,
1187 hOffset: usize,
1188 src: *const ::std::os::raw::c_void,
1189 spitch: usize,
1190 width: usize,
1191 height: usize,
1192 kind: cudaMemcpyKind,
1193 stream: cudaStream_t,
1194 ) -> cudaError_t;
1195
1196 pub fn cudaMemcpy2DFromArrayAsync(
1197 dst: *mut ::std::os::raw::c_void,
1198 dpitch: usize,
1199 src: cudaArray_const_t,
1200 wOffset: usize,
1201 hOffset: usize,
1202 width: usize,
1203 height: usize,
1204 kind: cudaMemcpyKind,
1205 stream: cudaStream_t,
1206 ) -> cudaError_t;
1207
1208 pub fn cudaMemcpyToSymbolAsync(
1209 symbol: *const ::std::os::raw::c_void,
1210 src: *const ::std::os::raw::c_void,
1211 count: usize,
1212 offset: usize,
1213 kind: cudaMemcpyKind,
1214 stream: cudaStream_t,
1215 ) -> cudaError_t;
1216
1217 pub fn cudaMemcpyFromSymbolAsync(
1218 dst: *mut ::std::os::raw::c_void,
1219 symbol: *const ::std::os::raw::c_void,
1220 count: usize,
1221 offset: usize,
1222 kind: cudaMemcpyKind,
1223 stream: cudaStream_t,
1224 ) -> cudaError_t;
1225
1226 pub fn cudaMemset(devPtr: *mut ::std::os::raw::c_void, value: ::std::os::raw::c_int, count: usize) -> cudaError_t;
1227
1228 pub fn cudaMemset2D(
1229 devPtr: *mut ::std::os::raw::c_void,
1230 pitch: usize,
1231 value: ::std::os::raw::c_int,
1232 width: usize,
1233 height: usize,
1234 ) -> cudaError_t;
1235
1236 pub fn cudaMemset3D(pitchedDevPtr: cudaPitchedPtr, value: ::std::os::raw::c_int, extent: cudaExtent)
1237 -> cudaError_t;
1238
1239 pub fn cudaMemsetAsync(
1240 devPtr: *mut ::std::os::raw::c_void,
1241 value: ::std::os::raw::c_int,
1242 count: usize,
1243 stream: cudaStream_t,
1244 ) -> cudaError_t;
1245
1246 pub fn cudaMemset2DAsync(
1247 devPtr: *mut ::std::os::raw::c_void,
1248 pitch: usize,
1249 value: ::std::os::raw::c_int,
1250 width: usize,
1251 height: usize,
1252 stream: cudaStream_t,
1253 ) -> cudaError_t;
1254
1255 pub fn cudaMemset3DAsync(
1256 pitchedDevPtr: cudaPitchedPtr,
1257 value: ::std::os::raw::c_int,
1258 extent: cudaExtent,
1259 stream: cudaStream_t,
1260 ) -> cudaError_t;
1261
1262 pub fn cudaGetSymbolAddress(
1263 devPtr: *mut *mut ::std::os::raw::c_void,
1264 symbol: *const ::std::os::raw::c_void,
1265 ) -> cudaError_t;
1266
1267 pub fn cudaGetSymbolSize(size: *mut usize, symbol: *const ::std::os::raw::c_void) -> cudaError_t;
1268
1269 pub fn cudaMemPrefetchAsync(
1270 devPtr: *const ::std::os::raw::c_void,
1271 count: usize,
1272 dstDevice: ::std::os::raw::c_int,
1273 stream: cudaStream_t,
1274 ) -> cudaError_t;
1275
1276 pub fn cudaMemAdvise(
1277 devPtr: *const ::std::os::raw::c_void,
1278 count: usize,
1279 advice: cudaMemoryAdvise,
1280 device: ::std::os::raw::c_int,
1281 ) -> cudaError_t;
1282
1283 pub fn cudaMemRangeGetAttribute(
1284 data: *mut ::std::os::raw::c_void,
1285 dataSize: usize,
1286 attribute: cudaMemRangeAttribute,
1287 devPtr: *const ::std::os::raw::c_void,
1288 count: usize,
1289 ) -> cudaError_t;
1290
1291 pub fn cudaMemRangeGetAttributes(
1292 data: *mut *mut ::std::os::raw::c_void,
1293 dataSizes: *mut usize,
1294 attributes: *mut cudaMemRangeAttribute,
1295 numAttributes: usize,
1296 devPtr: *const ::std::os::raw::c_void,
1297 count: usize,
1298 ) -> cudaError_t;
1299
1300 pub fn cudaPointerGetAttributes(
1301 attributes: *mut cudaPointerAttributes,
1302 ptr: *const ::std::os::raw::c_void,
1303 ) -> cudaError_t;
1304
1305 pub fn cudaDeviceCanAccessPeer(
1306 canAccessPeer: *mut ::std::os::raw::c_int,
1307 device: ::std::os::raw::c_int,
1308 peerDevice: ::std::os::raw::c_int,
1309 ) -> cudaError_t;
1310
1311 pub fn cudaDeviceEnablePeerAccess(peerDevice: ::std::os::raw::c_int, flags: ::std::os::raw::c_uint) -> cudaError_t;
1312
1313 pub fn cudaDeviceDisablePeerAccess(peerDevice: ::std::os::raw::c_int) -> cudaError_t;
1314
1315 pub fn cudaGraphicsUnregisterResource(resource: cudaGraphicsResource_t) -> cudaError_t;
1316
1317 pub fn cudaGraphicsResourceSetMapFlags(
1318 resource: cudaGraphicsResource_t,
1319 flags: ::std::os::raw::c_uint,
1320 ) -> cudaError_t;
1321
1322 pub fn cudaGraphicsMapResources(
1323 count: ::std::os::raw::c_int,
1324 resources: *mut cudaGraphicsResource_t,
1325 stream: cudaStream_t,
1326 ) -> cudaError_t;
1327
1328 pub fn cudaGraphicsUnmapResources(
1329 count: ::std::os::raw::c_int,
1330 resources: *mut cudaGraphicsResource_t,
1331 stream: cudaStream_t,
1332 ) -> cudaError_t;
1333
1334 pub fn cudaGraphicsResourceGetMappedPointer(
1335 devPtr: *mut *mut ::std::os::raw::c_void,
1336 size: *mut usize,
1337 resource: cudaGraphicsResource_t,
1338 ) -> cudaError_t;
1339
1340 pub fn cudaGraphicsSubResourceGetMappedArray(
1341 array: *mut cudaArray_t,
1342 resource: cudaGraphicsResource_t,
1343 arrayIndex: ::std::os::raw::c_uint,
1344 mipLevel: ::std::os::raw::c_uint,
1345 ) -> cudaError_t;
1346
1347 pub fn cudaGraphicsResourceGetMappedMipmappedArray(
1348 mipmappedArray: *mut cudaMipmappedArray_t,
1349 resource: cudaGraphicsResource_t,
1350 ) -> cudaError_t;
1351
1352 pub fn cudaGetChannelDesc(desc: *mut cudaChannelFormatDesc, array: cudaArray_const_t) -> cudaError_t;
1353
1354 pub fn cudaCreateChannelDesc(
1355 x: ::std::os::raw::c_int,
1356 y: ::std::os::raw::c_int,
1357 z: ::std::os::raw::c_int,
1358 w: ::std::os::raw::c_int,
1359 f: cudaChannelFormatKind,
1360 ) -> cudaChannelFormatDesc;
1361
1362 pub fn cudaBindTexture(
1363 offset: *mut usize,
1364 texref: *const textureReference,
1365 devPtr: *const ::std::os::raw::c_void,
1366 desc: *const cudaChannelFormatDesc,
1367 size: usize,
1368 ) -> cudaError_t;
1369
1370 pub fn cudaBindTexture2D(
1371 offset: *mut usize,
1372 texref: *const textureReference,
1373 devPtr: *const ::std::os::raw::c_void,
1374 desc: *const cudaChannelFormatDesc,
1375 width: usize,
1376 height: usize,
1377 pitch: usize,
1378 ) -> cudaError_t;
1379
1380 pub fn cudaBindTextureToArray(
1381 texref: *const textureReference,
1382 array: cudaArray_const_t,
1383 desc: *const cudaChannelFormatDesc,
1384 ) -> cudaError_t;
1385
1386 pub fn cudaBindTextureToMipmappedArray(
1387 texref: *const textureReference,
1388 mipmappedArray: cudaMipmappedArray_const_t,
1389 desc: *const cudaChannelFormatDesc,
1390 ) -> cudaError_t;
1391
1392 pub fn cudaUnbindTexture(texref: *const textureReference) -> cudaError_t;
1393
1394 pub fn cudaGetTextureAlignmentOffset(offset: *mut usize, texref: *const textureReference) -> cudaError_t;
1395
1396 pub fn cudaGetTextureReference(
1397 texref: *mut *const textureReference,
1398 symbol: *const ::std::os::raw::c_void,
1399 ) -> cudaError_t;
1400
1401 pub fn cudaBindSurfaceToArray(
1402 surfref: *const surfaceReference,
1403 array: cudaArray_const_t,
1404 desc: *const cudaChannelFormatDesc,
1405 ) -> cudaError_t;
1406
1407 pub fn cudaGetSurfaceReference(
1408 surfref: *mut *const surfaceReference,
1409 symbol: *const ::std::os::raw::c_void,
1410 ) -> cudaError_t;
1411
1412 pub fn cudaCreateTextureObject(
1413 pTexObject: *mut cudaTextureObject_t,
1414 pResDesc: *const cudaResourceDesc,
1415 pTexDesc: *const cudaTextureDesc,
1416 pResViewDesc: *const cudaResourceViewDesc,
1417 ) -> cudaError_t;
1418
1419 pub fn cudaDestroyTextureObject(texObject: cudaTextureObject_t) -> cudaError_t;
1420
1421 pub fn cudaGetTextureObjectResourceDesc(
1422 pResDesc: *mut cudaResourceDesc,
1423 texObject: cudaTextureObject_t,
1424 ) -> cudaError_t;
1425
1426 pub fn cudaGetTextureObjectTextureDesc(
1427 pTexDesc: *mut cudaTextureDesc,
1428 texObject: cudaTextureObject_t,
1429 ) -> cudaError_t;
1430
1431 pub fn cudaGetTextureObjectResourceViewDesc(
1432 pResViewDesc: *mut cudaResourceViewDesc,
1433 texObject: cudaTextureObject_t,
1434 ) -> cudaError_t;
1435
1436 pub fn cudaCreateSurfaceObject(
1437 pSurfObject: *mut cudaSurfaceObject_t,
1438 pResDesc: *const cudaResourceDesc,
1439 ) -> cudaError_t;
1440
1441 pub fn cudaDestroySurfaceObject(surfObject: cudaSurfaceObject_t) -> cudaError_t;
1442
1443 pub fn cudaGetSurfaceObjectResourceDesc(
1444 pResDesc: *mut cudaResourceDesc,
1445 surfObject: cudaSurfaceObject_t,
1446 ) -> cudaError_t;
1447
1448 pub fn cudaDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> cudaError_t;
1449
1450 pub fn cudaRuntimeGetVersion(runtimeVersion: *mut ::std::os::raw::c_int) -> cudaError_t;
1451
1452 pub fn cudaGetExportTable(
1453 ppExportTable: *mut *const ::std::os::raw::c_void,
1454 pExportTableId: *const cudaUUID_t,
1455 ) -> cudaError_t;
1456}