1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83pub const __HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__: u32 = 0;
84pub const __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__: u32 = 0;
85pub const __HIP_ARCH_HAS_SHARED_INT32_ATOMICS__: u32 = 0;
86pub const __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__: u32 = 0;
87pub const __HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__: u32 = 0;
88pub const __HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__: u32 = 0;
89pub const __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__: u32 = 0;
90pub const __HIP_ARCH_HAS_DOUBLES__: u32 = 0;
91pub const __HIP_ARCH_HAS_WARP_VOTE__: u32 = 0;
92pub const __HIP_ARCH_HAS_WARP_BALLOT__: u32 = 0;
93pub const __HIP_ARCH_HAS_WARP_SHUFFLE__: u32 = 0;
94pub const __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__: u32 = 0;
95pub const __HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__: u32 = 0;
96pub const __HIP_ARCH_HAS_SYNC_THREAD_EXT__: u32 = 0;
97pub const __HIP_ARCH_HAS_SURFACE_FUNCS__: u32 = 0;
98pub const __HIP_ARCH_HAS_3DGRID__: u32 = 0;
99pub const __HIP_ARCH_HAS_DYNAMIC_PARALLEL__: u32 = 0;
100pub const _FEATURES_H: u32 = 1;
101pub const _DEFAULT_SOURCE: u32 = 1;
102pub const __GLIBC_USE_ISOC2X: u32 = 0;
103pub const __USE_ISOC11: u32 = 1;
104pub const __USE_ISOC99: u32 = 1;
105pub const __USE_ISOC95: u32 = 1;
106pub const __USE_POSIX_IMPLICITLY: u32 = 1;
107pub const _POSIX_SOURCE: u32 = 1;
108pub const _POSIX_C_SOURCE: u32 = 200809;
109pub const __USE_POSIX: u32 = 1;
110pub const __USE_POSIX2: u32 = 1;
111pub const __USE_POSIX199309: u32 = 1;
112pub const __USE_POSIX199506: u32 = 1;
113pub const __USE_XOPEN2K: u32 = 1;
114pub const __USE_XOPEN2K8: u32 = 1;
115pub const _ATFILE_SOURCE: u32 = 1;
116pub const __WORDSIZE: u32 = 64;
117pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
118pub const __SYSCALL_WORDSIZE: u32 = 64;
119pub const __TIMESIZE: u32 = 64;
120pub const __USE_MISC: u32 = 1;
121pub const __USE_ATFILE: u32 = 1;
122pub const __USE_FORTIFY_LEVEL: u32 = 0;
123pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
124pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
125pub const __GLIBC_USE_C2X_STRTOL: u32 = 0;
126pub const _STDC_PREDEF_H: u32 = 1;
127pub const __STDC_IEC_559__: u32 = 1;
128pub const __STDC_IEC_60559_BFP__: u32 = 201404;
129pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
130pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
131pub const __STDC_ISO_10646__: u32 = 201706;
132pub const __GNU_LIBRARY__: u32 = 6;
133pub const __GLIBC__: u32 = 2;
134pub const __GLIBC_MINOR__: u32 = 39;
135pub const _SYS_CDEFS_H: u32 = 1;
136pub const __glibc_c99_flexarr_available: u32 = 1;
137pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
138pub const __HAVE_GENERIC_SELECTION: u32 = 1;
139pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
140pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
141pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
142pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
143pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
144pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
145pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
146pub const _STDLIB_H: u32 = 1;
147pub const WNOHANG: u32 = 1;
148pub const WUNTRACED: u32 = 2;
149pub const WSTOPPED: u32 = 2;
150pub const WEXITED: u32 = 4;
151pub const WCONTINUED: u32 = 8;
152pub const WNOWAIT: u32 = 16777216;
153pub const __WNOTHREAD: u32 = 536870912;
154pub const __WALL: u32 = 1073741824;
155pub const __WCLONE: u32 = 2147483648;
156pub const __W_CONTINUED: u32 = 65535;
157pub const __WCOREFLAG: u32 = 128;
158pub const __HAVE_FLOAT128: u32 = 0;
159pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
160pub const __HAVE_FLOAT64X: u32 = 1;
161pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
162pub const __HAVE_FLOAT16: u32 = 0;
163pub const __HAVE_FLOAT32: u32 = 1;
164pub const __HAVE_FLOAT64: u32 = 1;
165pub const __HAVE_FLOAT32X: u32 = 1;
166pub const __HAVE_FLOAT128X: u32 = 0;
167pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
168pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
169pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
170pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
171pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
172pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
173pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
174pub const __ldiv_t_defined: u32 = 1;
175pub const __lldiv_t_defined: u32 = 1;
176pub const RAND_MAX: u32 = 2147483647;
177pub const EXIT_FAILURE: u32 = 1;
178pub const EXIT_SUCCESS: u32 = 0;
179pub const _SYS_TYPES_H: u32 = 1;
180pub const _BITS_TYPES_H: u32 = 1;
181pub const _BITS_TYPESIZES_H: u32 = 1;
182pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
183pub const __INO_T_MATCHES_INO64_T: u32 = 1;
184pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
185pub const __STATFS_MATCHES_STATFS64: u32 = 1;
186pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
187pub const __FD_SETSIZE: u32 = 1024;
188pub const _BITS_TIME64_H: u32 = 1;
189pub const __clock_t_defined: u32 = 1;
190pub const __clockid_t_defined: u32 = 1;
191pub const __time_t_defined: u32 = 1;
192pub const __timer_t_defined: u32 = 1;
193pub const _BITS_STDINT_INTN_H: u32 = 1;
194pub const __BIT_TYPES_DEFINED__: u32 = 1;
195pub const _ENDIAN_H: u32 = 1;
196pub const _BITS_ENDIAN_H: u32 = 1;
197pub const __LITTLE_ENDIAN: u32 = 1234;
198pub const __BIG_ENDIAN: u32 = 4321;
199pub const __PDP_ENDIAN: u32 = 3412;
200pub const _BITS_ENDIANNESS_H: u32 = 1;
201pub const __BYTE_ORDER: u32 = 1234;
202pub const __FLOAT_WORD_ORDER: u32 = 1234;
203pub const LITTLE_ENDIAN: u32 = 1234;
204pub const BIG_ENDIAN: u32 = 4321;
205pub const PDP_ENDIAN: u32 = 3412;
206pub const BYTE_ORDER: u32 = 1234;
207pub const _BITS_BYTESWAP_H: u32 = 1;
208pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
209pub const _SYS_SELECT_H: u32 = 1;
210pub const __sigset_t_defined: u32 = 1;
211pub const __timeval_defined: u32 = 1;
212pub const _STRUCT_TIMESPEC: u32 = 1;
213pub const FD_SETSIZE: u32 = 1024;
214pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
215pub const _THREAD_SHARED_TYPES_H: u32 = 1;
216pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
217pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
218pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
219pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
220pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
221pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
222pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
223pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
224pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
225pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
226pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
227pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
228pub const __have_pthread_attr_t: u32 = 1;
229pub const _ALLOCA_H: u32 = 1;
230pub const _STRING_H: u32 = 1;
231pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
232pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
233pub const _STRINGS_H: u32 = 1;
234pub const HIP_VERSION_MAJOR: u32 = 6;
235pub const HIP_VERSION_MINOR: u32 = 4;
236pub const HIP_VERSION_PATCH: u32 = 43484;
237pub const HIP_VERSION_GITHASH: &[u8; 10] = b"123eb5128\0";
238pub const HIP_VERSION_BUILD_ID: u32 = 0;
239pub const HIP_VERSION_BUILD_NAME: &[u8; 1] = b"\0";
240pub const HIP_VERSION: u32 = 60443484;
241pub const __HIP_HAS_GET_PCH: u32 = 1;
242pub const _STDINT_H: u32 = 1;
243pub const _BITS_WCHAR_H: u32 = 1;
244pub const _BITS_STDINT_UINTN_H: u32 = 1;
245pub const _BITS_STDINT_LEAST_H: u32 = 1;
246pub const INT8_MIN: i32 = -128;
247pub const INT16_MIN: i32 = -32768;
248pub const INT32_MIN: i32 = -2147483648;
249pub const INT8_MAX: u32 = 127;
250pub const INT16_MAX: u32 = 32767;
251pub const INT32_MAX: u32 = 2147483647;
252pub const UINT8_MAX: u32 = 255;
253pub const UINT16_MAX: u32 = 65535;
254pub const UINT32_MAX: u32 = 4294967295;
255pub const INT_LEAST8_MIN: i32 = -128;
256pub const INT_LEAST16_MIN: i32 = -32768;
257pub const INT_LEAST32_MIN: i32 = -2147483648;
258pub const INT_LEAST8_MAX: u32 = 127;
259pub const INT_LEAST16_MAX: u32 = 32767;
260pub const INT_LEAST32_MAX: u32 = 2147483647;
261pub const UINT_LEAST8_MAX: u32 = 255;
262pub const UINT_LEAST16_MAX: u32 = 65535;
263pub const UINT_LEAST32_MAX: u32 = 4294967295;
264pub const INT_FAST8_MIN: i32 = -128;
265pub const INT_FAST16_MIN: i64 = -9223372036854775808;
266pub const INT_FAST32_MIN: i64 = -9223372036854775808;
267pub const INT_FAST8_MAX: u32 = 127;
268pub const INT_FAST16_MAX: u64 = 9223372036854775807;
269pub const INT_FAST32_MAX: u64 = 9223372036854775807;
270pub const UINT_FAST8_MAX: u32 = 255;
271pub const UINT_FAST16_MAX: i32 = -1;
272pub const UINT_FAST32_MAX: i32 = -1;
273pub const INTPTR_MIN: i64 = -9223372036854775808;
274pub const INTPTR_MAX: u64 = 9223372036854775807;
275pub const UINTPTR_MAX: i32 = -1;
276pub const PTRDIFF_MIN: i64 = -9223372036854775808;
277pub const PTRDIFF_MAX: u64 = 9223372036854775807;
278pub const SIG_ATOMIC_MIN: i32 = -2147483648;
279pub const SIG_ATOMIC_MAX: u32 = 2147483647;
280pub const SIZE_MAX: i32 = -1;
281pub const WINT_MIN: u32 = 0;
282pub const WINT_MAX: u32 = 4294967295;
283pub const GENERIC_GRID_LAUNCH: u32 = 1;
284pub const __bool_true_false_are_defined: u32 = 1;
285pub const true_: u32 = 1;
286pub const false_: u32 = 0;
287pub const HIP_TRSA_OVERRIDE_FORMAT: u32 = 1;
288pub const HIP_TRSF_READ_AS_INTEGER: u32 = 1;
289pub const HIP_TRSF_NORMALIZED_COORDINATES: u32 = 2;
290pub const HIP_TRSF_SRGB: u32 = 16;
291pub const _LIBC_LIMITS_H_: u32 = 1;
292pub const MB_LEN_MAX: u32 = 16;
293pub const _BITS_POSIX1_LIM_H: u32 = 1;
294pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
295pub const _POSIX_AIO_MAX: u32 = 1;
296pub const _POSIX_ARG_MAX: u32 = 4096;
297pub const _POSIX_CHILD_MAX: u32 = 25;
298pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
299pub const _POSIX_HOST_NAME_MAX: u32 = 255;
300pub const _POSIX_LINK_MAX: u32 = 8;
301pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
302pub const _POSIX_MAX_CANON: u32 = 255;
303pub const _POSIX_MAX_INPUT: u32 = 255;
304pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
305pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
306pub const _POSIX_NAME_MAX: u32 = 14;
307pub const _POSIX_NGROUPS_MAX: u32 = 8;
308pub const _POSIX_OPEN_MAX: u32 = 20;
309pub const _POSIX_PATH_MAX: u32 = 256;
310pub const _POSIX_PIPE_BUF: u32 = 512;
311pub const _POSIX_RE_DUP_MAX: u32 = 255;
312pub const _POSIX_RTSIG_MAX: u32 = 8;
313pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
314pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
315pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
316pub const _POSIX_SSIZE_MAX: u32 = 32767;
317pub const _POSIX_STREAM_MAX: u32 = 8;
318pub const _POSIX_SYMLINK_MAX: u32 = 255;
319pub const _POSIX_SYMLOOP_MAX: u32 = 8;
320pub const _POSIX_TIMER_MAX: u32 = 32;
321pub const _POSIX_TTY_NAME_MAX: u32 = 9;
322pub const _POSIX_TZNAME_MAX: u32 = 6;
323pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
324pub const NR_OPEN: u32 = 1024;
325pub const NGROUPS_MAX: u32 = 65536;
326pub const ARG_MAX: u32 = 131072;
327pub const LINK_MAX: u32 = 127;
328pub const MAX_CANON: u32 = 255;
329pub const MAX_INPUT: u32 = 255;
330pub const NAME_MAX: u32 = 255;
331pub const PATH_MAX: u32 = 4096;
332pub const PIPE_BUF: u32 = 4096;
333pub const XATTR_NAME_MAX: u32 = 255;
334pub const XATTR_SIZE_MAX: u32 = 65536;
335pub const XATTR_LIST_MAX: u32 = 65536;
336pub const RTSIG_MAX: u32 = 32;
337pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
338pub const PTHREAD_KEYS_MAX: u32 = 1024;
339pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
340pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
341pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
342pub const AIO_PRIO_DELTA_MAX: u32 = 20;
343pub const PTHREAD_STACK_MIN: u32 = 16384;
344pub const DELAYTIMER_MAX: u32 = 2147483647;
345pub const TTY_NAME_MAX: u32 = 32;
346pub const LOGIN_NAME_MAX: u32 = 256;
347pub const HOST_NAME_MAX: u32 = 64;
348pub const MQ_PRIO_MAX: u32 = 32768;
349pub const SEM_VALUE_MAX: u32 = 2147483647;
350pub const _BITS_POSIX2_LIM_H: u32 = 1;
351pub const _POSIX2_BC_BASE_MAX: u32 = 99;
352pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
353pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
354pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
355pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
356pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
357pub const _POSIX2_LINE_MAX: u32 = 2048;
358pub const _POSIX2_RE_DUP_MAX: u32 = 255;
359pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
360pub const BC_BASE_MAX: u32 = 99;
361pub const BC_DIM_MAX: u32 = 2048;
362pub const BC_SCALE_MAX: u32 = 99;
363pub const BC_STRING_MAX: u32 = 1000;
364pub const COLL_WEIGHTS_MAX: u32 = 255;
365pub const EXPR_NEST_MAX: u32 = 32;
366pub const LINE_MAX: u32 = 2048;
367pub const CHARCLASS_NAME_MAX: u32 = 2048;
368pub const RE_DUP_MAX: u32 = 32767;
369pub const __HIP_USE_NATIVE_VECTOR__: u32 = 1;
370pub const hipTextureType1D: u32 = 1;
371pub const hipTextureType2D: u32 = 2;
372pub const hipTextureType3D: u32 = 3;
373pub const hipTextureTypeCubemap: u32 = 12;
374pub const hipTextureType1DLayered: u32 = 241;
375pub const hipTextureType2DLayered: u32 = 242;
376pub const hipTextureTypeCubemapLayered: u32 = 252;
377pub const HIP_IMAGE_OBJECT_SIZE_DWORD: u32 = 12;
378pub const HIP_SAMPLER_OBJECT_SIZE_DWORD: u32 = 8;
379pub const HIP_SAMPLER_OBJECT_OFFSET_DWORD: u32 = 12;
380pub const HIP_TEXTURE_OBJECT_SIZE_DWORD: u32 = 20;
381pub const HIP_DEPRECATED_MSG : & [u8 ; 189] = b"This API is marked as deprecated and might not be supported in future releases. For more details please refer https://github.com/ROCm/HIP/blob/develop/docs/reference/deprecated_api_list.md\0" ;
382pub const hipIpcMemLazyEnablePeerAccess: u32 = 1;
383pub const HIP_IPC_HANDLE_SIZE: u32 = 64;
384pub const hipStreamDefault: u32 = 0;
385pub const hipStreamNonBlocking: u32 = 1;
386pub const hipEventDefault: u32 = 0;
387pub const hipEventBlockingSync: u32 = 1;
388pub const hipEventDisableTiming: u32 = 2;
389pub const hipEventInterprocess: u32 = 4;
390pub const hipEventRecordDefault: u32 = 0;
391pub const hipEventRecordExternal: u32 = 1;
392pub const hipEventWaitDefault: u32 = 0;
393pub const hipEventWaitExternal: u32 = 1;
394pub const hipEventDisableSystemFence: u32 = 536870912;
395pub const hipEventReleaseToDevice: u32 = 1073741824;
396pub const hipEventReleaseToSystem: u32 = 2147483648;
397pub const hipHostAllocDefault: u32 = 0;
398pub const hipHostMallocDefault: u32 = 0;
399pub const hipHostAllocPortable: u32 = 1;
400pub const hipHostMallocPortable: u32 = 1;
401pub const hipHostAllocMapped: u32 = 2;
402pub const hipHostMallocMapped: u32 = 2;
403pub const hipHostAllocWriteCombined: u32 = 4;
404pub const hipHostMallocWriteCombined: u32 = 4;
405pub const hipHostMallocNumaUser: u32 = 536870912;
406pub const hipHostMallocCoherent: u32 = 1073741824;
407pub const hipHostMallocNonCoherent: u32 = 2147483648;
408pub const hipMemAttachGlobal: u32 = 1;
409pub const hipMemAttachHost: u32 = 2;
410pub const hipMemAttachSingle: u32 = 4;
411pub const hipDeviceMallocDefault: u32 = 0;
412pub const hipDeviceMallocFinegrained: u32 = 1;
413pub const hipMallocSignalMemory: u32 = 2;
414pub const hipDeviceMallocUncached: u32 = 3;
415pub const hipDeviceMallocContiguous: u32 = 4;
416pub const hipHostRegisterDefault: u32 = 0;
417pub const hipHostRegisterPortable: u32 = 1;
418pub const hipHostRegisterMapped: u32 = 2;
419pub const hipHostRegisterIoMemory: u32 = 4;
420pub const hipHostRegisterReadOnly: u32 = 8;
421pub const hipExtHostRegisterCoarseGrained: u32 = 8;
422pub const hipDeviceScheduleAuto: u32 = 0;
423pub const hipDeviceScheduleSpin: u32 = 1;
424pub const hipDeviceScheduleYield: u32 = 2;
425pub const hipDeviceScheduleBlockingSync: u32 = 4;
426pub const hipDeviceScheduleMask: u32 = 7;
427pub const hipDeviceMapHost: u32 = 8;
428pub const hipDeviceLmemResizeToMax: u32 = 16;
429pub const hipArrayDefault: u32 = 0;
430pub const hipArrayLayered: u32 = 1;
431pub const hipArraySurfaceLoadStore: u32 = 2;
432pub const hipArrayCubemap: u32 = 4;
433pub const hipArrayTextureGather: u32 = 8;
434pub const hipOccupancyDefault: u32 = 0;
435pub const hipOccupancyDisableCachingOverride: u32 = 1;
436pub const hipCooperativeLaunchMultiDeviceNoPreSync: u32 = 1;
437pub const hipCooperativeLaunchMultiDeviceNoPostSync: u32 = 2;
438pub const hipExtAnyOrderLaunch: u32 = 1;
439pub const hipStreamWaitValueGte: u32 = 0;
440pub const hipStreamWaitValueEq: u32 = 1;
441pub const hipStreamWaitValueAnd: u32 = 2;
442pub const hipStreamWaitValueNor: u32 = 3;
443pub const hipExternalMemoryDedicated: u32 = 1;
444pub const hipGraphKernelNodePortDefault: u32 = 0;
445pub const hipGraphKernelNodePortLaunchCompletion: u32 = 2;
446pub const hipGraphKernelNodePortProgrammatic: u32 = 1;
447pub const USE_PEER_NON_UNIFIED: u32 = 1;
448#[doc = "< CUDA Only Maximum registers may be used in a thread,\n< passed to compiler"]
449pub const hipJitOption_hipJitOptionMaxRegisters: hipJitOption = 0;
450#[doc = "< CUDA Only Number of thread per block"]
451pub const hipJitOption_hipJitOptionThreadsPerBlock: hipJitOption = 1;
452#[doc = "< CUDA Only Value for total wall clock time"]
453pub const hipJitOption_hipJitOptionWallTime: hipJitOption = 2;
454#[doc = "< CUDA Only Pointer to the buffer with logged information"]
455pub const hipJitOption_hipJitOptionInfoLogBuffer: hipJitOption = 3;
456#[doc = "< CUDA Only Size of the buffer in bytes for logged info"]
457pub const hipJitOption_hipJitOptionInfoLogBufferSizeBytes: hipJitOption = 4;
458#[doc = "< CUDA Only Pointer to the buffer with logged error(s)"]
459pub const hipJitOption_hipJitOptionErrorLogBuffer: hipJitOption = 5;
460#[doc = "< CUDA Only Size of the buffer in bytes for logged error(s)"]
461pub const hipJitOption_hipJitOptionErrorLogBufferSizeBytes: hipJitOption = 6;
462#[doc = "< Value of optimization level for generated codes, acceptable options\n< -O0, -O1, -O2, -O3"]
463pub const hipJitOption_hipJitOptionOptimizationLevel: hipJitOption = 7;
464#[doc = "< CUDA Only The target context, which is the default"]
465pub const hipJitOption_hipJitOptionTargetFromContext: hipJitOption = 8;
466#[doc = "< CUDA Only JIT target"]
467pub const hipJitOption_hipJitOptionTarget: hipJitOption = 9;
468#[doc = "< CUDA Only Fallback strategy"]
469pub const hipJitOption_hipJitOptionFallbackStrategy: hipJitOption = 10;
470#[doc = "< CUDA Only Generate debug information"]
471pub const hipJitOption_hipJitOptionGenerateDebugInfo: hipJitOption = 11;
472#[doc = "< CUDA Only Generate log verbose"]
473pub const hipJitOption_hipJitOptionLogVerbose: hipJitOption = 12;
474#[doc = "< CUDA Only Generate line number information"]
475pub const hipJitOption_hipJitOptionGenerateLineInfo: hipJitOption = 13;
476#[doc = "< CUDA Only Set cache mode"]
477pub const hipJitOption_hipJitOptionCacheMode: hipJitOption = 14;
478#[doc = "< @deprecated CUDA Only New SM3X option."]
479pub const hipJitOption_hipJitOptionSm3xOpt: hipJitOption = 15;
480#[doc = "< CUDA Only Set fast compile"]
481pub const hipJitOption_hipJitOptionFastCompile: hipJitOption = 16;
482#[doc = "< CUDA Only Array of device symbol names to be relocated to the host"]
483pub const hipJitOption_hipJitOptionGlobalSymbolNames: hipJitOption = 17;
484#[doc = "< CUDA Only Array of host addresses to be relocated to the device"]
485pub const hipJitOption_hipJitOptionGlobalSymbolAddresses: hipJitOption = 18;
486#[doc = "< CUDA Only Number of symbol count."]
487pub const hipJitOption_hipJitOptionGlobalSymbolCount: hipJitOption = 19;
488#[doc = "< @deprecated CUDA Only Enable link-time optimization for device code"]
489pub const hipJitOption_hipJitOptionLto: hipJitOption = 20;
490#[doc = "< @deprecated CUDA Only Set single-precision denormals."]
491pub const hipJitOption_hipJitOptionFtz: hipJitOption = 21;
492#[doc = "< @deprecated CUDA Only Set single-precision floating-point division\n< and reciprocals"]
493pub const hipJitOption_hipJitOptionPrecDiv: hipJitOption = 22;
494#[doc = "< @deprecated CUDA Only Set single-precision floating-point square root"]
495pub const hipJitOption_hipJitOptionPrecSqrt: hipJitOption = 23;
496#[doc = "< @deprecated CUDA Only Enable floating-point multiplies and\n< adds/subtracts operations"]
497pub const hipJitOption_hipJitOptionFma: hipJitOption = 24;
498#[doc = "< CUDA Only Generates Position Independent code"]
499pub const hipJitOption_hipJitOptionPositionIndependentCode: hipJitOption = 25;
500#[doc = "< CUDA Only Hints to JIT compiler the minimum number of CTAs frin kernel's\n< grid to be mapped to SM"]
501pub const hipJitOption_hipJitOptionMinCTAPerSM: hipJitOption = 26;
502#[doc = "< CUDA only Maximum number of threads in a thread block"]
503pub const hipJitOption_hipJitOptionMaxThreadsPerBlock: hipJitOption = 27;
504#[doc = "< Cuda only Override Directive values"]
505pub const hipJitOption_hipJitOptionOverrideDirectiveValues: hipJitOption = 28;
506#[doc = "< Number of options"]
507pub const hipJitOption_hipJitOptionNumOptions: hipJitOption = 29;
508#[doc = "< Hip Only Linker options to be passed on to compiler"]
509pub const hipJitOption_hipJitOptionIRtoISAOptExt: hipJitOption = 10000;
510#[doc = "< Hip Only Count of linker options to be passed on to compiler"]
511pub const hipJitOption_hipJitOptionIRtoISAOptCountExt: hipJitOption = 10001;
512#[doc = " hipJitOption"]
513pub type hipJitOption = ::std::os::raw::c_uint;
514#[doc = "< Cuda only Input cubin"]
515pub const hipJitInputType_hipJitInputCubin: hipJitInputType = 0;
516#[doc = "< Cuda only Input PTX"]
517pub const hipJitInputType_hipJitInputPtx: hipJitInputType = 1;
518#[doc = "< Cuda Only Input FAT Binary"]
519pub const hipJitInputType_hipJitInputFatBinary: hipJitInputType = 2;
520#[doc = "< Cuda Only Host Object with embedded device code"]
521pub const hipJitInputType_hipJitInputObject: hipJitInputType = 3;
522#[doc = "< Cuda Only Archive of Host Objects with embedded\n< device code"]
523pub const hipJitInputType_hipJitInputLibrary: hipJitInputType = 4;
524#[doc = "< @deprecated Cuda only High Level intermediate\n< code for LTO"]
525pub const hipJitInputType_hipJitInputNvvm: hipJitInputType = 5;
526#[doc = "< Count of Legacy Input Types"]
527pub const hipJitInputType_hipJitNumLegacyInputTypes: hipJitInputType = 6;
528#[doc = "< HIP Only LLVM Bitcode or IR assembly"]
529pub const hipJitInputType_hipJitInputLLVMBitcode: hipJitInputType = 100;
530#[doc = "< HIP Only LLVM Clang Bundled Code"]
531pub const hipJitInputType_hipJitInputLLVMBundledBitcode: hipJitInputType = 101;
532#[doc = "< HIP Only LLVM Archive of Bundled Bitcode"]
533pub const hipJitInputType_hipJitInputLLVMArchivesOfBundledBitcode: hipJitInputType = 102;
534#[doc = "< HIP Only SPIRV Code Object"]
535pub const hipJitInputType_hipJitInputSpirv: hipJitInputType = 103;
536#[doc = "< Count of Input Types"]
537pub const hipJitInputType_hipJitNumInputTypes: hipJitInputType = 10;
538#[doc = " hipJitInputType"]
539pub type hipJitInputType = ::std::os::raw::c_uint;
540pub const hipJitCacheMode_hipJitCacheOptionNone: hipJitCacheMode = 0;
541pub const hipJitCacheMode_hipJitCacheOptionCG: hipJitCacheMode = 1;
542pub const hipJitCacheMode_hipJitCacheOptionCA: hipJitCacheMode = 2;
543#[doc = " hipJitCacheMode"]
544pub type hipJitCacheMode = ::std::os::raw::c_uint;
545pub const hipJitFallback_hipJitPreferPTX: hipJitFallback = 0;
546pub const hipJitFallback_hipJitPreferBinary: hipJitFallback = 1;
547#[doc = " hipJitFallback"]
548pub type hipJitFallback = ::std::os::raw::c_uint;
549pub type wchar_t = ::std::os::raw::c_int;
550pub type _Float32 = f32;
551pub type _Float64 = f64;
552pub type _Float32x = f64;
553pub type _Float64x = u128;
554#[repr(C)]
555#[derive(Debug, Copy, Clone)]
556pub struct div_t {
557 pub quot: ::std::os::raw::c_int,
558 pub rem: ::std::os::raw::c_int,
559}
560#[repr(C)]
561#[derive(Debug, Copy, Clone)]
562pub struct ldiv_t {
563 pub quot: ::std::os::raw::c_long,
564 pub rem: ::std::os::raw::c_long,
565}
566#[repr(C)]
567#[derive(Debug, Copy, Clone)]
568pub struct lldiv_t {
569 pub quot: ::std::os::raw::c_longlong,
570 pub rem: ::std::os::raw::c_longlong,
571}
572extern "C" {
573 pub fn __ctype_get_mb_cur_max() -> usize;
574}
575extern "C" {
576 pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
577}
578extern "C" {
579 pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
580}
581extern "C" {
582 pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
583}
584extern "C" {
585 pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
586}
587extern "C" {
588 pub fn strtod(
589 __nptr: *const ::std::os::raw::c_char,
590 __endptr: *mut *mut ::std::os::raw::c_char,
591 ) -> f64;
592}
593extern "C" {
594 pub fn strtof(
595 __nptr: *const ::std::os::raw::c_char,
596 __endptr: *mut *mut ::std::os::raw::c_char,
597 ) -> f32;
598}
599extern "C" {
600 pub fn strtold(
601 __nptr: *const ::std::os::raw::c_char,
602 __endptr: *mut *mut ::std::os::raw::c_char,
603 ) -> u128;
604}
605extern "C" {
606 pub fn strtol(
607 __nptr: *const ::std::os::raw::c_char,
608 __endptr: *mut *mut ::std::os::raw::c_char,
609 __base: ::std::os::raw::c_int,
610 ) -> ::std::os::raw::c_long;
611}
612extern "C" {
613 pub fn strtoul(
614 __nptr: *const ::std::os::raw::c_char,
615 __endptr: *mut *mut ::std::os::raw::c_char,
616 __base: ::std::os::raw::c_int,
617 ) -> ::std::os::raw::c_ulong;
618}
619extern "C" {
620 pub fn strtoq(
621 __nptr: *const ::std::os::raw::c_char,
622 __endptr: *mut *mut ::std::os::raw::c_char,
623 __base: ::std::os::raw::c_int,
624 ) -> ::std::os::raw::c_longlong;
625}
626extern "C" {
627 pub fn strtouq(
628 __nptr: *const ::std::os::raw::c_char,
629 __endptr: *mut *mut ::std::os::raw::c_char,
630 __base: ::std::os::raw::c_int,
631 ) -> ::std::os::raw::c_ulonglong;
632}
633extern "C" {
634 pub fn strtoll(
635 __nptr: *const ::std::os::raw::c_char,
636 __endptr: *mut *mut ::std::os::raw::c_char,
637 __base: ::std::os::raw::c_int,
638 ) -> ::std::os::raw::c_longlong;
639}
640extern "C" {
641 pub fn strtoull(
642 __nptr: *const ::std::os::raw::c_char,
643 __endptr: *mut *mut ::std::os::raw::c_char,
644 __base: ::std::os::raw::c_int,
645 ) -> ::std::os::raw::c_ulonglong;
646}
647extern "C" {
648 pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
649}
650extern "C" {
651 pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
652}
653pub type __u_char = ::std::os::raw::c_uchar;
654pub type __u_short = ::std::os::raw::c_ushort;
655pub type __u_int = ::std::os::raw::c_uint;
656pub type __u_long = ::std::os::raw::c_ulong;
657pub type __int8_t = ::std::os::raw::c_schar;
658pub type __uint8_t = ::std::os::raw::c_uchar;
659pub type __int16_t = ::std::os::raw::c_short;
660pub type __uint16_t = ::std::os::raw::c_ushort;
661pub type __int32_t = ::std::os::raw::c_int;
662pub type __uint32_t = ::std::os::raw::c_uint;
663pub type __int64_t = ::std::os::raw::c_long;
664pub type __uint64_t = ::std::os::raw::c_ulong;
665pub type __int_least8_t = __int8_t;
666pub type __uint_least8_t = __uint8_t;
667pub type __int_least16_t = __int16_t;
668pub type __uint_least16_t = __uint16_t;
669pub type __int_least32_t = __int32_t;
670pub type __uint_least32_t = __uint32_t;
671pub type __int_least64_t = __int64_t;
672pub type __uint_least64_t = __uint64_t;
673pub type __quad_t = ::std::os::raw::c_long;
674pub type __u_quad_t = ::std::os::raw::c_ulong;
675pub type __intmax_t = ::std::os::raw::c_long;
676pub type __uintmax_t = ::std::os::raw::c_ulong;
677pub type __dev_t = ::std::os::raw::c_ulong;
678pub type __uid_t = ::std::os::raw::c_uint;
679pub type __gid_t = ::std::os::raw::c_uint;
680pub type __ino_t = ::std::os::raw::c_ulong;
681pub type __ino64_t = ::std::os::raw::c_ulong;
682pub type __mode_t = ::std::os::raw::c_uint;
683pub type __nlink_t = ::std::os::raw::c_ulong;
684pub type __off_t = ::std::os::raw::c_long;
685pub type __off64_t = ::std::os::raw::c_long;
686pub type __pid_t = ::std::os::raw::c_int;
687#[repr(C)]
688#[derive(Debug, Copy, Clone)]
689pub struct __fsid_t {
690 pub __val: [::std::os::raw::c_int; 2usize],
691}
692pub type __clock_t = ::std::os::raw::c_long;
693pub type __rlim_t = ::std::os::raw::c_ulong;
694pub type __rlim64_t = ::std::os::raw::c_ulong;
695pub type __id_t = ::std::os::raw::c_uint;
696pub type __time_t = ::std::os::raw::c_long;
697pub type __useconds_t = ::std::os::raw::c_uint;
698pub type __suseconds_t = ::std::os::raw::c_long;
699pub type __suseconds64_t = ::std::os::raw::c_long;
700pub type __daddr_t = ::std::os::raw::c_int;
701pub type __key_t = ::std::os::raw::c_int;
702pub type __clockid_t = ::std::os::raw::c_int;
703pub type __timer_t = *mut ::std::os::raw::c_void;
704pub type __blksize_t = ::std::os::raw::c_long;
705pub type __blkcnt_t = ::std::os::raw::c_long;
706pub type __blkcnt64_t = ::std::os::raw::c_long;
707pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
708pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
709pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
710pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
711pub type __fsword_t = ::std::os::raw::c_long;
712pub type __ssize_t = ::std::os::raw::c_long;
713pub type __syscall_slong_t = ::std::os::raw::c_long;
714pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
715pub type __loff_t = __off64_t;
716pub type __caddr_t = *mut ::std::os::raw::c_char;
717pub type __intptr_t = ::std::os::raw::c_long;
718pub type __socklen_t = ::std::os::raw::c_uint;
719pub type __sig_atomic_t = ::std::os::raw::c_int;
720pub type u_char = __u_char;
721pub type u_short = __u_short;
722pub type u_int = __u_int;
723pub type u_long = __u_long;
724pub type quad_t = __quad_t;
725pub type u_quad_t = __u_quad_t;
726pub type fsid_t = __fsid_t;
727pub type loff_t = __loff_t;
728pub type ino_t = __ino_t;
729pub type dev_t = __dev_t;
730pub type gid_t = __gid_t;
731pub type mode_t = __mode_t;
732pub type nlink_t = __nlink_t;
733pub type uid_t = __uid_t;
734pub type off_t = __off_t;
735pub type pid_t = __pid_t;
736pub type id_t = __id_t;
737pub type daddr_t = __daddr_t;
738pub type caddr_t = __caddr_t;
739pub type key_t = __key_t;
740pub type clock_t = __clock_t;
741pub type clockid_t = __clockid_t;
742pub type time_t = __time_t;
743pub type timer_t = __timer_t;
744pub type ulong = ::std::os::raw::c_ulong;
745pub type ushort = ::std::os::raw::c_ushort;
746pub type uint = ::std::os::raw::c_uint;
747pub type u_int8_t = __uint8_t;
748pub type u_int16_t = __uint16_t;
749pub type u_int32_t = __uint32_t;
750pub type u_int64_t = __uint64_t;
751pub type register_t = ::std::os::raw::c_long;
752#[repr(C)]
753#[derive(Debug, Copy, Clone)]
754pub struct __sigset_t {
755 pub __val: [::std::os::raw::c_ulong; 16usize],
756}
757pub type sigset_t = __sigset_t;
758#[repr(C)]
759#[derive(Debug, Copy, Clone)]
760pub struct timeval {
761 pub tv_sec: __time_t,
762 pub tv_usec: __suseconds_t,
763}
764#[repr(C)]
765#[derive(Debug, Copy, Clone)]
766pub struct timespec {
767 pub tv_sec: __time_t,
768 pub tv_nsec: __syscall_slong_t,
769}
770pub type suseconds_t = __suseconds_t;
771pub type __fd_mask = ::std::os::raw::c_long;
772#[repr(C)]
773#[derive(Debug, Copy, Clone)]
774pub struct fd_set {
775 pub __fds_bits: [__fd_mask; 16usize],
776}
777pub type fd_mask = __fd_mask;
778extern "C" {
779 pub fn select(
780 __nfds: ::std::os::raw::c_int,
781 __readfds: *mut fd_set,
782 __writefds: *mut fd_set,
783 __exceptfds: *mut fd_set,
784 __timeout: *mut timeval,
785 ) -> ::std::os::raw::c_int;
786}
787extern "C" {
788 pub fn pselect(
789 __nfds: ::std::os::raw::c_int,
790 __readfds: *mut fd_set,
791 __writefds: *mut fd_set,
792 __exceptfds: *mut fd_set,
793 __timeout: *const timespec,
794 __sigmask: *const __sigset_t,
795 ) -> ::std::os::raw::c_int;
796}
797pub type blksize_t = __blksize_t;
798pub type blkcnt_t = __blkcnt_t;
799pub type fsblkcnt_t = __fsblkcnt_t;
800pub type fsfilcnt_t = __fsfilcnt_t;
801#[repr(C)]
802#[derive(Copy, Clone)]
803pub union __atomic_wide_counter {
804 pub __value64: ::std::os::raw::c_ulonglong,
805 pub __value32: __atomic_wide_counter__bindgen_ty_1,
806}
807#[repr(C)]
808#[derive(Debug, Copy, Clone)]
809pub struct __atomic_wide_counter__bindgen_ty_1 {
810 pub __low: ::std::os::raw::c_uint,
811 pub __high: ::std::os::raw::c_uint,
812}
813#[repr(C)]
814#[derive(Debug, Copy, Clone)]
815pub struct __pthread_internal_list {
816 pub __prev: *mut __pthread_internal_list,
817 pub __next: *mut __pthread_internal_list,
818}
819pub type __pthread_list_t = __pthread_internal_list;
820#[repr(C)]
821#[derive(Debug, Copy, Clone)]
822pub struct __pthread_internal_slist {
823 pub __next: *mut __pthread_internal_slist,
824}
825pub type __pthread_slist_t = __pthread_internal_slist;
826#[repr(C)]
827#[derive(Debug, Copy, Clone)]
828pub struct __pthread_mutex_s {
829 pub __lock: ::std::os::raw::c_int,
830 pub __count: ::std::os::raw::c_uint,
831 pub __owner: ::std::os::raw::c_int,
832 pub __nusers: ::std::os::raw::c_uint,
833 pub __kind: ::std::os::raw::c_int,
834 pub __spins: ::std::os::raw::c_short,
835 pub __elision: ::std::os::raw::c_short,
836 pub __list: __pthread_list_t,
837}
838#[repr(C)]
839#[derive(Debug, Copy, Clone)]
840pub struct __pthread_rwlock_arch_t {
841 pub __readers: ::std::os::raw::c_uint,
842 pub __writers: ::std::os::raw::c_uint,
843 pub __wrphase_futex: ::std::os::raw::c_uint,
844 pub __writers_futex: ::std::os::raw::c_uint,
845 pub __pad3: ::std::os::raw::c_uint,
846 pub __pad4: ::std::os::raw::c_uint,
847 pub __cur_writer: ::std::os::raw::c_int,
848 pub __shared: ::std::os::raw::c_int,
849 pub __rwelision: ::std::os::raw::c_schar,
850 pub __pad1: [::std::os::raw::c_uchar; 7usize],
851 pub __pad2: ::std::os::raw::c_ulong,
852 pub __flags: ::std::os::raw::c_uint,
853}
854#[repr(C)]
855#[derive(Copy, Clone)]
856pub struct __pthread_cond_s {
857 pub __wseq: __atomic_wide_counter,
858 pub __g1_start: __atomic_wide_counter,
859 pub __g_refs: [::std::os::raw::c_uint; 2usize],
860 pub __g_size: [::std::os::raw::c_uint; 2usize],
861 pub __g1_orig_size: ::std::os::raw::c_uint,
862 pub __wrefs: ::std::os::raw::c_uint,
863 pub __g_signals: [::std::os::raw::c_uint; 2usize],
864}
865pub type __tss_t = ::std::os::raw::c_uint;
866pub type __thrd_t = ::std::os::raw::c_ulong;
867#[repr(C)]
868#[derive(Debug, Copy, Clone)]
869pub struct __once_flag {
870 pub __data: ::std::os::raw::c_int,
871}
872pub type pthread_t = ::std::os::raw::c_ulong;
873#[repr(C)]
874#[derive(Copy, Clone)]
875pub union pthread_mutexattr_t {
876 pub __size: [::std::os::raw::c_char; 4usize],
877 pub __align: ::std::os::raw::c_int,
878}
879#[repr(C)]
880#[derive(Copy, Clone)]
881pub union pthread_condattr_t {
882 pub __size: [::std::os::raw::c_char; 4usize],
883 pub __align: ::std::os::raw::c_int,
884}
885pub type pthread_key_t = ::std::os::raw::c_uint;
886pub type pthread_once_t = ::std::os::raw::c_int;
887#[repr(C)]
888#[derive(Copy, Clone)]
889pub union pthread_attr_t {
890 pub __size: [::std::os::raw::c_char; 56usize],
891 pub __align: ::std::os::raw::c_long,
892}
893#[repr(C)]
894#[derive(Copy, Clone)]
895pub union pthread_mutex_t {
896 pub __data: __pthread_mutex_s,
897 pub __size: [::std::os::raw::c_char; 40usize],
898 pub __align: ::std::os::raw::c_long,
899}
900#[repr(C)]
901#[derive(Copy, Clone)]
902pub union pthread_cond_t {
903 pub __data: __pthread_cond_s,
904 pub __size: [::std::os::raw::c_char; 48usize],
905 pub __align: ::std::os::raw::c_longlong,
906}
907#[repr(C)]
908#[derive(Copy, Clone)]
909pub union pthread_rwlock_t {
910 pub __data: __pthread_rwlock_arch_t,
911 pub __size: [::std::os::raw::c_char; 56usize],
912 pub __align: ::std::os::raw::c_long,
913}
914#[repr(C)]
915#[derive(Copy, Clone)]
916pub union pthread_rwlockattr_t {
917 pub __size: [::std::os::raw::c_char; 8usize],
918 pub __align: ::std::os::raw::c_long,
919}
920pub type pthread_spinlock_t = ::std::os::raw::c_int;
921#[repr(C)]
922#[derive(Copy, Clone)]
923pub union pthread_barrier_t {
924 pub __size: [::std::os::raw::c_char; 32usize],
925 pub __align: ::std::os::raw::c_long,
926}
927#[repr(C)]
928#[derive(Copy, Clone)]
929pub union pthread_barrierattr_t {
930 pub __size: [::std::os::raw::c_char; 4usize],
931 pub __align: ::std::os::raw::c_int,
932}
933extern "C" {
934 pub fn random() -> ::std::os::raw::c_long;
935}
936extern "C" {
937 pub fn srandom(__seed: ::std::os::raw::c_uint);
938}
939extern "C" {
940 pub fn initstate(
941 __seed: ::std::os::raw::c_uint,
942 __statebuf: *mut ::std::os::raw::c_char,
943 __statelen: usize,
944 ) -> *mut ::std::os::raw::c_char;
945}
946extern "C" {
947 pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
948}
949#[repr(C)]
950#[derive(Debug, Copy, Clone)]
951pub struct random_data {
952 pub fptr: *mut i32,
953 pub rptr: *mut i32,
954 pub state: *mut i32,
955 pub rand_type: ::std::os::raw::c_int,
956 pub rand_deg: ::std::os::raw::c_int,
957 pub rand_sep: ::std::os::raw::c_int,
958 pub end_ptr: *mut i32,
959}
960extern "C" {
961 pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
962}
963extern "C" {
964 pub fn srandom_r(
965 __seed: ::std::os::raw::c_uint,
966 __buf: *mut random_data,
967 ) -> ::std::os::raw::c_int;
968}
969extern "C" {
970 pub fn initstate_r(
971 __seed: ::std::os::raw::c_uint,
972 __statebuf: *mut ::std::os::raw::c_char,
973 __statelen: usize,
974 __buf: *mut random_data,
975 ) -> ::std::os::raw::c_int;
976}
977extern "C" {
978 pub fn setstate_r(
979 __statebuf: *mut ::std::os::raw::c_char,
980 __buf: *mut random_data,
981 ) -> ::std::os::raw::c_int;
982}
983extern "C" {
984 pub fn rand() -> ::std::os::raw::c_int;
985}
986extern "C" {
987 pub fn srand(__seed: ::std::os::raw::c_uint);
988}
989extern "C" {
990 pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
991}
992extern "C" {
993 pub fn drand48() -> f64;
994}
995extern "C" {
996 pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
997}
998extern "C" {
999 pub fn lrand48() -> ::std::os::raw::c_long;
1000}
1001extern "C" {
1002 pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1003}
1004extern "C" {
1005 pub fn mrand48() -> ::std::os::raw::c_long;
1006}
1007extern "C" {
1008 pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1009}
1010extern "C" {
1011 pub fn srand48(__seedval: ::std::os::raw::c_long);
1012}
1013extern "C" {
1014 pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
1015}
1016extern "C" {
1017 pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
1018}
1019#[repr(C)]
1020#[derive(Debug, Copy, Clone)]
1021pub struct drand48_data {
1022 pub __x: [::std::os::raw::c_ushort; 3usize],
1023 pub __old_x: [::std::os::raw::c_ushort; 3usize],
1024 pub __c: ::std::os::raw::c_ushort,
1025 pub __init: ::std::os::raw::c_ushort,
1026 pub __a: ::std::os::raw::c_ulonglong,
1027}
1028extern "C" {
1029 pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
1030}
1031extern "C" {
1032 pub fn erand48_r(
1033 __xsubi: *mut ::std::os::raw::c_ushort,
1034 __buffer: *mut drand48_data,
1035 __result: *mut f64,
1036 ) -> ::std::os::raw::c_int;
1037}
1038extern "C" {
1039 pub fn lrand48_r(
1040 __buffer: *mut drand48_data,
1041 __result: *mut ::std::os::raw::c_long,
1042 ) -> ::std::os::raw::c_int;
1043}
1044extern "C" {
1045 pub fn nrand48_r(
1046 __xsubi: *mut ::std::os::raw::c_ushort,
1047 __buffer: *mut drand48_data,
1048 __result: *mut ::std::os::raw::c_long,
1049 ) -> ::std::os::raw::c_int;
1050}
1051extern "C" {
1052 pub fn mrand48_r(
1053 __buffer: *mut drand48_data,
1054 __result: *mut ::std::os::raw::c_long,
1055 ) -> ::std::os::raw::c_int;
1056}
1057extern "C" {
1058 pub fn jrand48_r(
1059 __xsubi: *mut ::std::os::raw::c_ushort,
1060 __buffer: *mut drand48_data,
1061 __result: *mut ::std::os::raw::c_long,
1062 ) -> ::std::os::raw::c_int;
1063}
1064extern "C" {
1065 pub fn srand48_r(
1066 __seedval: ::std::os::raw::c_long,
1067 __buffer: *mut drand48_data,
1068 ) -> ::std::os::raw::c_int;
1069}
1070extern "C" {
1071 pub fn seed48_r(
1072 __seed16v: *mut ::std::os::raw::c_ushort,
1073 __buffer: *mut drand48_data,
1074 ) -> ::std::os::raw::c_int;
1075}
1076extern "C" {
1077 pub fn lcong48_r(
1078 __param: *mut ::std::os::raw::c_ushort,
1079 __buffer: *mut drand48_data,
1080 ) -> ::std::os::raw::c_int;
1081}
1082extern "C" {
1083 pub fn arc4random() -> __uint32_t;
1084}
1085extern "C" {
1086 pub fn arc4random_buf(__buf: *mut ::std::os::raw::c_void, __size: usize);
1087}
1088extern "C" {
1089 pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
1090}
1091extern "C" {
1092 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1093}
1094extern "C" {
1095 pub fn calloc(
1096 __nmemb: ::std::os::raw::c_ulong,
1097 __size: ::std::os::raw::c_ulong,
1098 ) -> *mut ::std::os::raw::c_void;
1099}
1100extern "C" {
1101 pub fn realloc(
1102 __ptr: *mut ::std::os::raw::c_void,
1103 __size: ::std::os::raw::c_ulong,
1104 ) -> *mut ::std::os::raw::c_void;
1105}
1106extern "C" {
1107 pub fn free(__ptr: *mut ::std::os::raw::c_void);
1108}
1109extern "C" {
1110 pub fn reallocarray(
1111 __ptr: *mut ::std::os::raw::c_void,
1112 __nmemb: usize,
1113 __size: usize,
1114 ) -> *mut ::std::os::raw::c_void;
1115}
1116extern "C" {
1117 pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1118}
1119extern "C" {
1120 pub fn valloc(__size: usize) -> *mut ::std::os::raw::c_void;
1121}
1122extern "C" {
1123 pub fn posix_memalign(
1124 __memptr: *mut *mut ::std::os::raw::c_void,
1125 __alignment: usize,
1126 __size: usize,
1127 ) -> ::std::os::raw::c_int;
1128}
1129extern "C" {
1130 pub fn aligned_alloc(
1131 __alignment: ::std::os::raw::c_ulong,
1132 __size: ::std::os::raw::c_ulong,
1133 ) -> *mut ::std::os::raw::c_void;
1134}
1135extern "C" {
1136 pub fn abort() -> !;
1137}
1138extern "C" {
1139 pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
1140}
1141extern "C" {
1142 pub fn at_quick_exit(
1143 __func: ::std::option::Option<unsafe extern "C" fn()>,
1144 ) -> ::std::os::raw::c_int;
1145}
1146extern "C" {
1147 pub fn on_exit(
1148 __func: ::std::option::Option<
1149 unsafe extern "C" fn(
1150 __status: ::std::os::raw::c_int,
1151 __arg: *mut ::std::os::raw::c_void,
1152 ),
1153 >,
1154 __arg: *mut ::std::os::raw::c_void,
1155 ) -> ::std::os::raw::c_int;
1156}
1157extern "C" {
1158 pub fn exit(__status: ::std::os::raw::c_int) -> !;
1159}
1160extern "C" {
1161 pub fn quick_exit(__status: ::std::os::raw::c_int) -> !;
1162}
1163extern "C" {
1164 pub fn _Exit(__status: ::std::os::raw::c_int) -> !;
1165}
1166extern "C" {
1167 pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1168}
1169extern "C" {
1170 pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1171}
1172extern "C" {
1173 pub fn setenv(
1174 __name: *const ::std::os::raw::c_char,
1175 __value: *const ::std::os::raw::c_char,
1176 __replace: ::std::os::raw::c_int,
1177 ) -> ::std::os::raw::c_int;
1178}
1179extern "C" {
1180 pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1181}
1182extern "C" {
1183 pub fn clearenv() -> ::std::os::raw::c_int;
1184}
1185extern "C" {
1186 pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1187}
1188extern "C" {
1189 pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1190}
1191extern "C" {
1192 pub fn mkstemps(
1193 __template: *mut ::std::os::raw::c_char,
1194 __suffixlen: ::std::os::raw::c_int,
1195 ) -> ::std::os::raw::c_int;
1196}
1197extern "C" {
1198 pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1199}
1200extern "C" {
1201 pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1202}
1203extern "C" {
1204 pub fn realpath(
1205 __name: *const ::std::os::raw::c_char,
1206 __resolved: *mut ::std::os::raw::c_char,
1207 ) -> *mut ::std::os::raw::c_char;
1208}
1209pub type __compar_fn_t = ::std::option::Option<
1210 unsafe extern "C" fn(
1211 arg1: *const ::std::os::raw::c_void,
1212 arg2: *const ::std::os::raw::c_void,
1213 ) -> ::std::os::raw::c_int,
1214>;
1215extern "C" {
1216 pub fn bsearch(
1217 __key: *const ::std::os::raw::c_void,
1218 __base: *const ::std::os::raw::c_void,
1219 __nmemb: usize,
1220 __size: usize,
1221 __compar: __compar_fn_t,
1222 ) -> *mut ::std::os::raw::c_void;
1223}
1224extern "C" {
1225 pub fn qsort(
1226 __base: *mut ::std::os::raw::c_void,
1227 __nmemb: usize,
1228 __size: usize,
1229 __compar: __compar_fn_t,
1230 );
1231}
1232extern "C" {
1233 pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1234}
1235extern "C" {
1236 pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
1237}
1238extern "C" {
1239 pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
1240}
1241extern "C" {
1242 pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
1243}
1244extern "C" {
1245 pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
1246}
1247extern "C" {
1248 pub fn lldiv(
1249 __numer: ::std::os::raw::c_longlong,
1250 __denom: ::std::os::raw::c_longlong,
1251 ) -> lldiv_t;
1252}
1253extern "C" {
1254 pub fn ecvt(
1255 __value: f64,
1256 __ndigit: ::std::os::raw::c_int,
1257 __decpt: *mut ::std::os::raw::c_int,
1258 __sign: *mut ::std::os::raw::c_int,
1259 ) -> *mut ::std::os::raw::c_char;
1260}
1261extern "C" {
1262 pub fn fcvt(
1263 __value: f64,
1264 __ndigit: ::std::os::raw::c_int,
1265 __decpt: *mut ::std::os::raw::c_int,
1266 __sign: *mut ::std::os::raw::c_int,
1267 ) -> *mut ::std::os::raw::c_char;
1268}
1269extern "C" {
1270 pub fn gcvt(
1271 __value: f64,
1272 __ndigit: ::std::os::raw::c_int,
1273 __buf: *mut ::std::os::raw::c_char,
1274 ) -> *mut ::std::os::raw::c_char;
1275}
1276extern "C" {
1277 pub fn qecvt(
1278 __value: u128,
1279 __ndigit: ::std::os::raw::c_int,
1280 __decpt: *mut ::std::os::raw::c_int,
1281 __sign: *mut ::std::os::raw::c_int,
1282 ) -> *mut ::std::os::raw::c_char;
1283}
1284extern "C" {
1285 pub fn qfcvt(
1286 __value: u128,
1287 __ndigit: ::std::os::raw::c_int,
1288 __decpt: *mut ::std::os::raw::c_int,
1289 __sign: *mut ::std::os::raw::c_int,
1290 ) -> *mut ::std::os::raw::c_char;
1291}
1292extern "C" {
1293 pub fn qgcvt(
1294 __value: u128,
1295 __ndigit: ::std::os::raw::c_int,
1296 __buf: *mut ::std::os::raw::c_char,
1297 ) -> *mut ::std::os::raw::c_char;
1298}
1299extern "C" {
1300 pub fn ecvt_r(
1301 __value: f64,
1302 __ndigit: ::std::os::raw::c_int,
1303 __decpt: *mut ::std::os::raw::c_int,
1304 __sign: *mut ::std::os::raw::c_int,
1305 __buf: *mut ::std::os::raw::c_char,
1306 __len: usize,
1307 ) -> ::std::os::raw::c_int;
1308}
1309extern "C" {
1310 pub fn fcvt_r(
1311 __value: f64,
1312 __ndigit: ::std::os::raw::c_int,
1313 __decpt: *mut ::std::os::raw::c_int,
1314 __sign: *mut ::std::os::raw::c_int,
1315 __buf: *mut ::std::os::raw::c_char,
1316 __len: usize,
1317 ) -> ::std::os::raw::c_int;
1318}
1319extern "C" {
1320 pub fn qecvt_r(
1321 __value: u128,
1322 __ndigit: ::std::os::raw::c_int,
1323 __decpt: *mut ::std::os::raw::c_int,
1324 __sign: *mut ::std::os::raw::c_int,
1325 __buf: *mut ::std::os::raw::c_char,
1326 __len: usize,
1327 ) -> ::std::os::raw::c_int;
1328}
1329extern "C" {
1330 pub fn qfcvt_r(
1331 __value: u128,
1332 __ndigit: ::std::os::raw::c_int,
1333 __decpt: *mut ::std::os::raw::c_int,
1334 __sign: *mut ::std::os::raw::c_int,
1335 __buf: *mut ::std::os::raw::c_char,
1336 __len: usize,
1337 ) -> ::std::os::raw::c_int;
1338}
1339extern "C" {
1340 pub fn mblen(__s: *const ::std::os::raw::c_char, __n: usize) -> ::std::os::raw::c_int;
1341}
1342extern "C" {
1343 pub fn mbtowc(
1344 __pwc: *mut wchar_t,
1345 __s: *const ::std::os::raw::c_char,
1346 __n: usize,
1347 ) -> ::std::os::raw::c_int;
1348}
1349extern "C" {
1350 pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
1351}
1352extern "C" {
1353 pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const ::std::os::raw::c_char, __n: usize) -> usize;
1354}
1355extern "C" {
1356 pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
1357}
1358extern "C" {
1359 pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1360}
1361extern "C" {
1362 pub fn getsubopt(
1363 __optionp: *mut *mut ::std::os::raw::c_char,
1364 __tokens: *const *mut ::std::os::raw::c_char,
1365 __valuep: *mut *mut ::std::os::raw::c_char,
1366 ) -> ::std::os::raw::c_int;
1367}
1368extern "C" {
1369 pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
1370 -> ::std::os::raw::c_int;
1371}
1372#[doc = "< Success"]
1373pub const hiprtcResult_HIPRTC_SUCCESS: hiprtcResult = 0;
1374#[doc = "< Out of memory"]
1375pub const hiprtcResult_HIPRTC_ERROR_OUT_OF_MEMORY: hiprtcResult = 1;
1376#[doc = "< Failed to create program"]
1377pub const hiprtcResult_HIPRTC_ERROR_PROGRAM_CREATION_FAILURE: hiprtcResult = 2;
1378#[doc = "< Invalid input"]
1379pub const hiprtcResult_HIPRTC_ERROR_INVALID_INPUT: hiprtcResult = 3;
1380#[doc = "< Invalid program"]
1381pub const hiprtcResult_HIPRTC_ERROR_INVALID_PROGRAM: hiprtcResult = 4;
1382#[doc = "< Invalid option"]
1383pub const hiprtcResult_HIPRTC_ERROR_INVALID_OPTION: hiprtcResult = 5;
1384#[doc = "< Compilation error"]
1385pub const hiprtcResult_HIPRTC_ERROR_COMPILATION: hiprtcResult = 6;
1386#[doc = "< Failed in builtin operation"]
1387pub const hiprtcResult_HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE: hiprtcResult = 7;
1388#[doc = "< No name expression after compilation"]
1389pub const hiprtcResult_HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION: hiprtcResult = 8;
1390#[doc = "< No lowered names before compilation"]
1391pub const hiprtcResult_HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION: hiprtcResult = 9;
1392#[doc = "< Invalid name expression"]
1393pub const hiprtcResult_HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID: hiprtcResult = 10;
1394#[doc = "< Internal error"]
1395pub const hiprtcResult_HIPRTC_ERROR_INTERNAL_ERROR: hiprtcResult = 11;
1396#[doc = "< Error in linking"]
1397pub const hiprtcResult_HIPRTC_ERROR_LINKING: hiprtcResult = 100;
1398#[doc = " @addtogroup GlobalDefs\n @{\n\n/\n/**\n hiprtc error code"]
1399pub type hiprtcResult = ::std::os::raw::c_uint;
1400#[repr(C)]
1401#[derive(Debug, Copy, Clone)]
1402pub struct ihiprtcLinkState {
1403 _unused: [u8; 0],
1404}
1405#[doc = " hiprtc link state\n"]
1406pub type hiprtcLinkState = *mut ihiprtcLinkState;
1407extern "C" {
1408 #[doc = " @ingroup Runtime\n\n @brief Returns text string message to explain the error which occurred\n\n @param [in] result code to convert to string.\n @returns const char pointer to the NULL-terminated error string\n\n @warning In HIP, this function returns the name of the error,\n if the hiprtc result is defined, it will return \"Invalid HIPRTC error code\"\n\n @see hiprtcResult"]
1409 pub fn hiprtcGetErrorString(result: hiprtcResult) -> *const ::std::os::raw::c_char;
1410}
1411extern "C" {
1412 #[doc = " @ingroup Runtime\n @brief Sets the parameters as major and minor version.\n\n @param [out] major HIP Runtime Compilation major version.\n @param [out] minor HIP Runtime Compilation minor version.\n\n @returns #HIPRTC_ERROR_INVALID_INPUT, #HIPRTC_SUCCESS\n"]
1413 pub fn hiprtcVersion(
1414 major: *mut ::std::os::raw::c_int,
1415 minor: *mut ::std::os::raw::c_int,
1416 ) -> hiprtcResult;
1417}
1418#[repr(C)]
1419#[derive(Debug, Copy, Clone)]
1420pub struct _hiprtcProgram {
1421 _unused: [u8; 0],
1422}
1423#[doc = " hiprtc program\n"]
1424pub type hiprtcProgram = *mut _hiprtcProgram;
1425extern "C" {
1426 #[doc = " @ingroup Runtime\n @brief Adds the given name exprssion to the runtime compilation program.\n\n @param [in] prog runtime compilation program instance.\n @param [in] name_expression const char pointer to the name expression.\n @returns #HIPRTC_SUCCESS\n\n If const char pointer is NULL, it will return #HIPRTC_ERROR_INVALID_INPUT.\n\n @see hiprtcResult"]
1427 pub fn hiprtcAddNameExpression(
1428 prog: hiprtcProgram,
1429 name_expression: *const ::std::os::raw::c_char,
1430 ) -> hiprtcResult;
1431}
1432extern "C" {
1433 #[doc = " @ingroup Runtime\n @brief Compiles the given runtime compilation program.\n\n @param [in] prog runtime compilation program instance.\n @param [in] numOptions number of compiler options.\n @param [in] options compiler options as const array of strins.\n @returns #HIPRTC_SUCCESS\n\n If the compiler failed to build the runtime compilation program,\n it will return #HIPRTC_ERROR_COMPILATION.\n\n @see hiprtcResult"]
1434 pub fn hiprtcCompileProgram(
1435 prog: hiprtcProgram,
1436 numOptions: ::std::os::raw::c_int,
1437 options: *mut *const ::std::os::raw::c_char,
1438 ) -> hiprtcResult;
1439}
1440extern "C" {
1441 #[doc = " @ingroup Runtime\n @brief Creates an instance of hiprtcProgram with the given input parameters,\n and sets the output hiprtcProgram prog with it.\n\n @param [in, out] prog runtime compilation program instance.\n @param [in] src const char pointer to the program source.\n @param [in] name const char pointer to the program name.\n @param [in] numHeaders number of headers.\n @param [in] headers array of strings pointing to headers.\n @param [in] includeNames array of strings pointing to names included in program source.\n @returns #HIPRTC_SUCCESS\n\n Any invalide input parameter, it will return #HIPRTC_ERROR_INVALID_INPUT\n or #HIPRTC_ERROR_INVALID_PROGRAM.\n\n If failed to create the program, it will return #HIPRTC_ERROR_PROGRAM_CREATION_FAILURE.\n\n @see hiprtcResult"]
1442 pub fn hiprtcCreateProgram(
1443 prog: *mut hiprtcProgram,
1444 src: *const ::std::os::raw::c_char,
1445 name: *const ::std::os::raw::c_char,
1446 numHeaders: ::std::os::raw::c_int,
1447 headers: *mut *const ::std::os::raw::c_char,
1448 includeNames: *mut *const ::std::os::raw::c_char,
1449 ) -> hiprtcResult;
1450}
1451extern "C" {
1452 #[doc = " @brief Destroys an instance of given hiprtcProgram.\n @ingroup Runtime\n @param [in] prog runtime compilation program instance.\n @returns #HIPRTC_SUCCESS\n\n If prog is NULL, it will return #HIPRTC_ERROR_INVALID_INPUT.\n\n @see hiprtcResult"]
1453 pub fn hiprtcDestroyProgram(prog: *mut hiprtcProgram) -> hiprtcResult;
1454}
1455extern "C" {
1456 #[doc = " @brief Gets the lowered (mangled) name from an instance of hiprtcProgram with the given input parameters,\n and sets the output lowered_name with it.\n @ingroup Runtime\n @param [in] prog runtime compilation program instance.\n @param [in] name_expression const char pointer to the name expression.\n @param [in, out] lowered_name const char array to the lowered (mangled) name.\n @returns #HIPRTC_SUCCESS\n\n If any invalide nullptr input parameters, it will return #HIPRTC_ERROR_INVALID_INPUT\n\n If name_expression is not found, it will return #HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID\n\n If failed to get lowered_name from the program, it will return #HIPRTC_ERROR_COMPILATION.\n\n @see hiprtcResult"]
1457 pub fn hiprtcGetLoweredName(
1458 prog: hiprtcProgram,
1459 name_expression: *const ::std::os::raw::c_char,
1460 lowered_name: *mut *const ::std::os::raw::c_char,
1461 ) -> hiprtcResult;
1462}
1463extern "C" {
1464 #[doc = " @brief Gets the log generated by the runtime compilation program instance.\n @ingroup Runtime\n @param [in] prog runtime compilation program instance.\n @param [out] log memory pointer to the generated log.\n @returns #HIPRTC_SUCCESS\n\n @see hiprtcResult"]
1465 pub fn hiprtcGetProgramLog(
1466 prog: hiprtcProgram,
1467 log: *mut ::std::os::raw::c_char,
1468 ) -> hiprtcResult;
1469}
1470extern "C" {
1471 #[doc = " @brief Gets the size of log generated by the runtime compilation program instance.\n\n @param [in] prog runtime compilation program instance.\n @param [out] logSizeRet size of generated log.\n @returns #HIPRTC_SUCCESS\n\n @see hiprtcResult"]
1472 pub fn hiprtcGetProgramLogSize(prog: hiprtcProgram, logSizeRet: *mut usize) -> hiprtcResult;
1473}
1474extern "C" {
1475 #[doc = " @brief Gets the pointer of compilation binary by the runtime compilation program instance.\n @ingroup Runtime\n @param [in] prog runtime compilation program instance.\n @param [out] code char pointer to binary.\n @returns #HIPRTC_SUCCESS\n\n @see hiprtcResult"]
1476 pub fn hiprtcGetCode(prog: hiprtcProgram, code: *mut ::std::os::raw::c_char) -> hiprtcResult;
1477}
1478extern "C" {
1479 #[doc = " @brief Gets the size of compilation binary by the runtime compilation program instance.\n @ingroup Runtime\n @param [in] prog runtime compilation program instance.\n @param [out] codeSizeRet the size of binary.\n @returns #HIPRTC_SUCCESS\n\n @see hiprtcResult"]
1480 pub fn hiprtcGetCodeSize(prog: hiprtcProgram, codeSizeRet: *mut usize) -> hiprtcResult;
1481}
1482extern "C" {
1483 #[doc = " @brief Gets the pointer of compiled bitcode by the runtime compilation program instance.\n\n @param [in] prog runtime compilation program instance.\n @param [out] bitcode char pointer to bitcode.\n @return HIPRTC_SUCCESS\n\n @see hiprtcResult"]
1484 pub fn hiprtcGetBitcode(
1485 prog: hiprtcProgram,
1486 bitcode: *mut ::std::os::raw::c_char,
1487 ) -> hiprtcResult;
1488}
1489extern "C" {
1490 #[doc = " @brief Gets the size of compiled bitcode by the runtime compilation program instance.\n @ingroup Runtime\n\n @param [in] prog runtime compilation program instance.\n @param [out] bitcode_size the size of bitcode.\n @returns #HIPRTC_SUCCESS\n\n @see hiprtcResult"]
1491 pub fn hiprtcGetBitcodeSize(prog: hiprtcProgram, bitcode_size: *mut usize) -> hiprtcResult;
1492}
1493extern "C" {
1494 #[doc = " @brief Creates the link instance via hiprtc APIs.\n @ingroup Runtime\n @param [in] num_options Number of options\n @param [in] option_ptr Array of options\n @param [in] option_vals_pptr Array of option values cast to void*\n @param [out] hip_link_state_ptr hiprtc link state created upon success\n\n @returns #HIPRTC_SUCCESS, #HIPRTC_ERROR_INVALID_INPUT, #HIPRTC_ERROR_INVALID_OPTION\n\n @see hiprtcResult"]
1495 pub fn hiprtcLinkCreate(
1496 num_options: ::std::os::raw::c_uint,
1497 option_ptr: *mut hipJitOption,
1498 option_vals_pptr: *mut *mut ::std::os::raw::c_void,
1499 hip_link_state_ptr: *mut hiprtcLinkState,
1500 ) -> hiprtcResult;
1501}
1502extern "C" {
1503 #[doc = " @brief Adds a file with bit code to be linked with options\n @ingroup Runtime\n @param [in] hip_link_state hiprtc link state\n @param [in] input_type Type of the input data or bitcode\n @param [in] file_path Path to the input file where bitcode is present\n @param [in] num_options Size of the options\n @param [in] options_ptr Array of options applied to this input\n @param [in] option_values Array of option values cast to void*\n\n @returns #HIPRTC_SUCCESS\n\n If input values are invalid, it will\n @return #HIPRTC_ERROR_INVALID_INPUT\n\n @see hiprtcResult"]
1504 pub fn hiprtcLinkAddFile(
1505 hip_link_state: hiprtcLinkState,
1506 input_type: hipJitInputType,
1507 file_path: *const ::std::os::raw::c_char,
1508 num_options: ::std::os::raw::c_uint,
1509 options_ptr: *mut hipJitOption,
1510 option_values: *mut *mut ::std::os::raw::c_void,
1511 ) -> hiprtcResult;
1512}
1513extern "C" {
1514 #[doc = " @brief Completes the linking of the given program.\n @ingroup Runtime\n @param [in] hip_link_state hiprtc link state\n @param [in] input_type Type of the input data or bitcode\n @param [in] image Input data which is null terminated\n @param [in] image_size Size of the input data\n @param [in] name Optional name for this input\n @param [in] num_options Size of the options\n @param [in] options_ptr Array of options applied to this input\n @param [in] option_values Array of option values cast to void*\n\n @returns #HIPRTC_SUCCESS, #HIPRTC_ERROR_INVALID_INPUT\n\n If adding the file fails, it will\n @return #HIPRTC_ERROR_PROGRAM_CREATION_FAILURE\n\n @see hiprtcResult"]
1515 pub fn hiprtcLinkAddData(
1516 hip_link_state: hiprtcLinkState,
1517 input_type: hipJitInputType,
1518 image: *mut ::std::os::raw::c_void,
1519 image_size: usize,
1520 name: *const ::std::os::raw::c_char,
1521 num_options: ::std::os::raw::c_uint,
1522 options_ptr: *mut hipJitOption,
1523 option_values: *mut *mut ::std::os::raw::c_void,
1524 ) -> hiprtcResult;
1525}
1526extern "C" {
1527 #[doc = " @brief Completes the linking of the given program.\n @ingroup Runtime\n @param [in] hip_link_state hiprtc link state\n @param [out] bin_out Upon success, points to the output binary\n @param [out] size_out Size of the binary is stored (optional)\n\n @returns #HIPRTC_SUCCESS\n\n If adding the data fails, it will\n @return #HIPRTC_ERROR_LINKING\n\n @see hiprtcResult"]
1528 pub fn hiprtcLinkComplete(
1529 hip_link_state: hiprtcLinkState,
1530 bin_out: *mut *mut ::std::os::raw::c_void,
1531 size_out: *mut usize,
1532 ) -> hiprtcResult;
1533}
1534extern "C" {
1535 #[doc = " @brief Deletes the link instance via hiprtc APIs.\n @ingroup Runtime\n @param [in] hip_link_state link state instance\n\n @returns #HIPRTC_SUCCESS\n\n @see hiprtcResult"]
1536 pub fn hiprtcLinkDestroy(hip_link_state: hiprtcLinkState) -> hiprtcResult;
1537}
1538extern "C" {
1539 pub fn memcpy(
1540 __dest: *mut ::std::os::raw::c_void,
1541 __src: *const ::std::os::raw::c_void,
1542 __n: ::std::os::raw::c_ulong,
1543 ) -> *mut ::std::os::raw::c_void;
1544}
1545extern "C" {
1546 pub fn memmove(
1547 __dest: *mut ::std::os::raw::c_void,
1548 __src: *const ::std::os::raw::c_void,
1549 __n: ::std::os::raw::c_ulong,
1550 ) -> *mut ::std::os::raw::c_void;
1551}
1552extern "C" {
1553 pub fn memccpy(
1554 __dest: *mut ::std::os::raw::c_void,
1555 __src: *const ::std::os::raw::c_void,
1556 __c: ::std::os::raw::c_int,
1557 __n: ::std::os::raw::c_ulong,
1558 ) -> *mut ::std::os::raw::c_void;
1559}
1560extern "C" {
1561 pub fn memset(
1562 __s: *mut ::std::os::raw::c_void,
1563 __c: ::std::os::raw::c_int,
1564 __n: ::std::os::raw::c_ulong,
1565 ) -> *mut ::std::os::raw::c_void;
1566}
1567extern "C" {
1568 pub fn memcmp(
1569 __s1: *const ::std::os::raw::c_void,
1570 __s2: *const ::std::os::raw::c_void,
1571 __n: ::std::os::raw::c_ulong,
1572 ) -> ::std::os::raw::c_int;
1573}
1574extern "C" {
1575 pub fn __memcmpeq(
1576 __s1: *const ::std::os::raw::c_void,
1577 __s2: *const ::std::os::raw::c_void,
1578 __n: usize,
1579 ) -> ::std::os::raw::c_int;
1580}
1581extern "C" {
1582 pub fn memchr(
1583 __s: *const ::std::os::raw::c_void,
1584 __c: ::std::os::raw::c_int,
1585 __n: ::std::os::raw::c_ulong,
1586 ) -> *mut ::std::os::raw::c_void;
1587}
1588extern "C" {
1589 pub fn strcpy(
1590 __dest: *mut ::std::os::raw::c_char,
1591 __src: *const ::std::os::raw::c_char,
1592 ) -> *mut ::std::os::raw::c_char;
1593}
1594extern "C" {
1595 pub fn strncpy(
1596 __dest: *mut ::std::os::raw::c_char,
1597 __src: *const ::std::os::raw::c_char,
1598 __n: ::std::os::raw::c_ulong,
1599 ) -> *mut ::std::os::raw::c_char;
1600}
1601extern "C" {
1602 pub fn strcat(
1603 __dest: *mut ::std::os::raw::c_char,
1604 __src: *const ::std::os::raw::c_char,
1605 ) -> *mut ::std::os::raw::c_char;
1606}
1607extern "C" {
1608 pub fn strncat(
1609 __dest: *mut ::std::os::raw::c_char,
1610 __src: *const ::std::os::raw::c_char,
1611 __n: ::std::os::raw::c_ulong,
1612 ) -> *mut ::std::os::raw::c_char;
1613}
1614extern "C" {
1615 pub fn strcmp(
1616 __s1: *const ::std::os::raw::c_char,
1617 __s2: *const ::std::os::raw::c_char,
1618 ) -> ::std::os::raw::c_int;
1619}
1620extern "C" {
1621 pub fn strncmp(
1622 __s1: *const ::std::os::raw::c_char,
1623 __s2: *const ::std::os::raw::c_char,
1624 __n: ::std::os::raw::c_ulong,
1625 ) -> ::std::os::raw::c_int;
1626}
1627extern "C" {
1628 pub fn strcoll(
1629 __s1: *const ::std::os::raw::c_char,
1630 __s2: *const ::std::os::raw::c_char,
1631 ) -> ::std::os::raw::c_int;
1632}
1633extern "C" {
1634 pub fn strxfrm(
1635 __dest: *mut ::std::os::raw::c_char,
1636 __src: *const ::std::os::raw::c_char,
1637 __n: ::std::os::raw::c_ulong,
1638 ) -> ::std::os::raw::c_ulong;
1639}
1640#[repr(C)]
1641#[derive(Debug, Copy, Clone)]
1642pub struct __locale_struct {
1643 pub __locales: [*mut __locale_data; 13usize],
1644 pub __ctype_b: *const ::std::os::raw::c_ushort,
1645 pub __ctype_tolower: *const ::std::os::raw::c_int,
1646 pub __ctype_toupper: *const ::std::os::raw::c_int,
1647 pub __names: [*const ::std::os::raw::c_char; 13usize],
1648}
1649pub type __locale_t = *mut __locale_struct;
1650pub type locale_t = __locale_t;
1651extern "C" {
1652 pub fn strcoll_l(
1653 __s1: *const ::std::os::raw::c_char,
1654 __s2: *const ::std::os::raw::c_char,
1655 __l: locale_t,
1656 ) -> ::std::os::raw::c_int;
1657}
1658extern "C" {
1659 pub fn strxfrm_l(
1660 __dest: *mut ::std::os::raw::c_char,
1661 __src: *const ::std::os::raw::c_char,
1662 __n: usize,
1663 __l: locale_t,
1664 ) -> usize;
1665}
1666extern "C" {
1667 pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1668}
1669extern "C" {
1670 pub fn strndup(
1671 __string: *const ::std::os::raw::c_char,
1672 __n: ::std::os::raw::c_ulong,
1673 ) -> *mut ::std::os::raw::c_char;
1674}
1675extern "C" {
1676 pub fn strchr(
1677 __s: *const ::std::os::raw::c_char,
1678 __c: ::std::os::raw::c_int,
1679 ) -> *mut ::std::os::raw::c_char;
1680}
1681extern "C" {
1682 pub fn strrchr(
1683 __s: *const ::std::os::raw::c_char,
1684 __c: ::std::os::raw::c_int,
1685 ) -> *mut ::std::os::raw::c_char;
1686}
1687extern "C" {
1688 pub fn strchrnul(
1689 __s: *const ::std::os::raw::c_char,
1690 __c: ::std::os::raw::c_int,
1691 ) -> *mut ::std::os::raw::c_char;
1692}
1693extern "C" {
1694 pub fn strcspn(
1695 __s: *const ::std::os::raw::c_char,
1696 __reject: *const ::std::os::raw::c_char,
1697 ) -> ::std::os::raw::c_ulong;
1698}
1699extern "C" {
1700 pub fn strspn(
1701 __s: *const ::std::os::raw::c_char,
1702 __accept: *const ::std::os::raw::c_char,
1703 ) -> ::std::os::raw::c_ulong;
1704}
1705extern "C" {
1706 pub fn strpbrk(
1707 __s: *const ::std::os::raw::c_char,
1708 __accept: *const ::std::os::raw::c_char,
1709 ) -> *mut ::std::os::raw::c_char;
1710}
1711extern "C" {
1712 pub fn strstr(
1713 __haystack: *const ::std::os::raw::c_char,
1714 __needle: *const ::std::os::raw::c_char,
1715 ) -> *mut ::std::os::raw::c_char;
1716}
1717extern "C" {
1718 pub fn strtok(
1719 __s: *mut ::std::os::raw::c_char,
1720 __delim: *const ::std::os::raw::c_char,
1721 ) -> *mut ::std::os::raw::c_char;
1722}
1723extern "C" {
1724 pub fn __strtok_r(
1725 __s: *mut ::std::os::raw::c_char,
1726 __delim: *const ::std::os::raw::c_char,
1727 __save_ptr: *mut *mut ::std::os::raw::c_char,
1728 ) -> *mut ::std::os::raw::c_char;
1729}
1730extern "C" {
1731 pub fn strtok_r(
1732 __s: *mut ::std::os::raw::c_char,
1733 __delim: *const ::std::os::raw::c_char,
1734 __save_ptr: *mut *mut ::std::os::raw::c_char,
1735 ) -> *mut ::std::os::raw::c_char;
1736}
1737extern "C" {
1738 pub fn strcasestr(
1739 __haystack: *const ::std::os::raw::c_char,
1740 __needle: *const ::std::os::raw::c_char,
1741 ) -> *mut ::std::os::raw::c_char;
1742}
1743extern "C" {
1744 pub fn memmem(
1745 __haystack: *const ::std::os::raw::c_void,
1746 __haystacklen: usize,
1747 __needle: *const ::std::os::raw::c_void,
1748 __needlelen: usize,
1749 ) -> *mut ::std::os::raw::c_void;
1750}
1751extern "C" {
1752 pub fn __mempcpy(
1753 __dest: *mut ::std::os::raw::c_void,
1754 __src: *const ::std::os::raw::c_void,
1755 __n: usize,
1756 ) -> *mut ::std::os::raw::c_void;
1757}
1758extern "C" {
1759 pub fn mempcpy(
1760 __dest: *mut ::std::os::raw::c_void,
1761 __src: *const ::std::os::raw::c_void,
1762 __n: ::std::os::raw::c_ulong,
1763 ) -> *mut ::std::os::raw::c_void;
1764}
1765extern "C" {
1766 pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
1767}
1768extern "C" {
1769 pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: usize) -> usize;
1770}
1771extern "C" {
1772 pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
1773}
1774extern "C" {
1775 #[link_name = "\u{1}__xpg_strerror_r"]
1776 pub fn strerror_r(
1777 __errnum: ::std::os::raw::c_int,
1778 __buf: *mut ::std::os::raw::c_char,
1779 __buflen: usize,
1780 ) -> ::std::os::raw::c_int;
1781}
1782extern "C" {
1783 pub fn strerror_l(
1784 __errnum: ::std::os::raw::c_int,
1785 __l: locale_t,
1786 ) -> *mut ::std::os::raw::c_char;
1787}
1788extern "C" {
1789 pub fn bcmp(
1790 __s1: *const ::std::os::raw::c_void,
1791 __s2: *const ::std::os::raw::c_void,
1792 __n: ::std::os::raw::c_ulong,
1793 ) -> ::std::os::raw::c_int;
1794}
1795extern "C" {
1796 pub fn bcopy(
1797 __src: *const ::std::os::raw::c_void,
1798 __dest: *mut ::std::os::raw::c_void,
1799 __n: ::std::os::raw::c_ulong,
1800 );
1801}
1802extern "C" {
1803 pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
1804}
1805extern "C" {
1806 pub fn index(
1807 __s: *const ::std::os::raw::c_char,
1808 __c: ::std::os::raw::c_int,
1809 ) -> *mut ::std::os::raw::c_char;
1810}
1811extern "C" {
1812 pub fn rindex(
1813 __s: *const ::std::os::raw::c_char,
1814 __c: ::std::os::raw::c_int,
1815 ) -> *mut ::std::os::raw::c_char;
1816}
1817extern "C" {
1818 pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1819}
1820extern "C" {
1821 pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
1822}
1823extern "C" {
1824 pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
1825}
1826extern "C" {
1827 pub fn strcasecmp(
1828 __s1: *const ::std::os::raw::c_char,
1829 __s2: *const ::std::os::raw::c_char,
1830 ) -> ::std::os::raw::c_int;
1831}
1832extern "C" {
1833 pub fn strncasecmp(
1834 __s1: *const ::std::os::raw::c_char,
1835 __s2: *const ::std::os::raw::c_char,
1836 __n: ::std::os::raw::c_ulong,
1837 ) -> ::std::os::raw::c_int;
1838}
1839extern "C" {
1840 pub fn strcasecmp_l(
1841 __s1: *const ::std::os::raw::c_char,
1842 __s2: *const ::std::os::raw::c_char,
1843 __loc: locale_t,
1844 ) -> ::std::os::raw::c_int;
1845}
1846extern "C" {
1847 pub fn strncasecmp_l(
1848 __s1: *const ::std::os::raw::c_char,
1849 __s2: *const ::std::os::raw::c_char,
1850 __n: usize,
1851 __loc: locale_t,
1852 ) -> ::std::os::raw::c_int;
1853}
1854extern "C" {
1855 pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize);
1856}
1857extern "C" {
1858 pub fn strsep(
1859 __stringp: *mut *mut ::std::os::raw::c_char,
1860 __delim: *const ::std::os::raw::c_char,
1861 ) -> *mut ::std::os::raw::c_char;
1862}
1863extern "C" {
1864 pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
1865}
1866extern "C" {
1867 pub fn __stpcpy(
1868 __dest: *mut ::std::os::raw::c_char,
1869 __src: *const ::std::os::raw::c_char,
1870 ) -> *mut ::std::os::raw::c_char;
1871}
1872extern "C" {
1873 pub fn stpcpy(
1874 __dest: *mut ::std::os::raw::c_char,
1875 __src: *const ::std::os::raw::c_char,
1876 ) -> *mut ::std::os::raw::c_char;
1877}
1878extern "C" {
1879 pub fn __stpncpy(
1880 __dest: *mut ::std::os::raw::c_char,
1881 __src: *const ::std::os::raw::c_char,
1882 __n: usize,
1883 ) -> *mut ::std::os::raw::c_char;
1884}
1885extern "C" {
1886 pub fn stpncpy(
1887 __dest: *mut ::std::os::raw::c_char,
1888 __src: *const ::std::os::raw::c_char,
1889 __n: ::std::os::raw::c_ulong,
1890 ) -> *mut ::std::os::raw::c_char;
1891}
1892extern "C" {
1893 pub fn strlcpy(
1894 __dest: *mut ::std::os::raw::c_char,
1895 __src: *const ::std::os::raw::c_char,
1896 __n: usize,
1897 ) -> usize;
1898}
1899extern "C" {
1900 pub fn strlcat(
1901 __dest: *mut ::std::os::raw::c_char,
1902 __src: *const ::std::os::raw::c_char,
1903 __n: usize,
1904 ) -> usize;
1905}
1906pub const HIP_SUCCESS: _bindgen_ty_1 = 0;
1907pub const HIP_ERROR_INVALID_VALUE: _bindgen_ty_1 = 1;
1908pub const HIP_ERROR_NOT_INITIALIZED: _bindgen_ty_1 = 2;
1909pub const HIP_ERROR_LAUNCH_OUT_OF_RESOURCES: _bindgen_ty_1 = 3;
1910pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
1911#[doc = " @defgroup GlobalDefs Global enum and defines\n @{\n\n/\n/**\n hipDeviceArch_t\n"]
1912#[repr(C)]
1913#[repr(align(4))]
1914#[derive(Debug, Copy, Clone)]
1915pub struct hipDeviceArch_t {
1916 pub _bitfield_align_1: [u8; 0],
1917 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
1918 pub __bindgen_padding_0: u8,
1919}
1920impl hipDeviceArch_t {
1921 #[inline]
1922 pub fn hasGlobalInt32Atomics(&self) -> ::std::os::raw::c_uint {
1923 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1924 }
1925 #[inline]
1926 pub fn set_hasGlobalInt32Atomics(&mut self, val: ::std::os::raw::c_uint) {
1927 unsafe {
1928 let val: u32 = ::std::mem::transmute(val);
1929 self._bitfield_1.set(0usize, 1u8, val as u64)
1930 }
1931 }
1932 #[inline]
1933 pub fn hasGlobalFloatAtomicExch(&self) -> ::std::os::raw::c_uint {
1934 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1935 }
1936 #[inline]
1937 pub fn set_hasGlobalFloatAtomicExch(&mut self, val: ::std::os::raw::c_uint) {
1938 unsafe {
1939 let val: u32 = ::std::mem::transmute(val);
1940 self._bitfield_1.set(1usize, 1u8, val as u64)
1941 }
1942 }
1943 #[inline]
1944 pub fn hasSharedInt32Atomics(&self) -> ::std::os::raw::c_uint {
1945 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1946 }
1947 #[inline]
1948 pub fn set_hasSharedInt32Atomics(&mut self, val: ::std::os::raw::c_uint) {
1949 unsafe {
1950 let val: u32 = ::std::mem::transmute(val);
1951 self._bitfield_1.set(2usize, 1u8, val as u64)
1952 }
1953 }
1954 #[inline]
1955 pub fn hasSharedFloatAtomicExch(&self) -> ::std::os::raw::c_uint {
1956 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1957 }
1958 #[inline]
1959 pub fn set_hasSharedFloatAtomicExch(&mut self, val: ::std::os::raw::c_uint) {
1960 unsafe {
1961 let val: u32 = ::std::mem::transmute(val);
1962 self._bitfield_1.set(3usize, 1u8, val as u64)
1963 }
1964 }
1965 #[inline]
1966 pub fn hasFloatAtomicAdd(&self) -> ::std::os::raw::c_uint {
1967 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1968 }
1969 #[inline]
1970 pub fn set_hasFloatAtomicAdd(&mut self, val: ::std::os::raw::c_uint) {
1971 unsafe {
1972 let val: u32 = ::std::mem::transmute(val);
1973 self._bitfield_1.set(4usize, 1u8, val as u64)
1974 }
1975 }
1976 #[inline]
1977 pub fn hasGlobalInt64Atomics(&self) -> ::std::os::raw::c_uint {
1978 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1979 }
1980 #[inline]
1981 pub fn set_hasGlobalInt64Atomics(&mut self, val: ::std::os::raw::c_uint) {
1982 unsafe {
1983 let val: u32 = ::std::mem::transmute(val);
1984 self._bitfield_1.set(5usize, 1u8, val as u64)
1985 }
1986 }
1987 #[inline]
1988 pub fn hasSharedInt64Atomics(&self) -> ::std::os::raw::c_uint {
1989 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1990 }
1991 #[inline]
1992 pub fn set_hasSharedInt64Atomics(&mut self, val: ::std::os::raw::c_uint) {
1993 unsafe {
1994 let val: u32 = ::std::mem::transmute(val);
1995 self._bitfield_1.set(6usize, 1u8, val as u64)
1996 }
1997 }
1998 #[inline]
1999 pub fn hasDoubles(&self) -> ::std::os::raw::c_uint {
2000 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2001 }
2002 #[inline]
2003 pub fn set_hasDoubles(&mut self, val: ::std::os::raw::c_uint) {
2004 unsafe {
2005 let val: u32 = ::std::mem::transmute(val);
2006 self._bitfield_1.set(7usize, 1u8, val as u64)
2007 }
2008 }
2009 #[inline]
2010 pub fn hasWarpVote(&self) -> ::std::os::raw::c_uint {
2011 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
2012 }
2013 #[inline]
2014 pub fn set_hasWarpVote(&mut self, val: ::std::os::raw::c_uint) {
2015 unsafe {
2016 let val: u32 = ::std::mem::transmute(val);
2017 self._bitfield_1.set(8usize, 1u8, val as u64)
2018 }
2019 }
2020 #[inline]
2021 pub fn hasWarpBallot(&self) -> ::std::os::raw::c_uint {
2022 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
2023 }
2024 #[inline]
2025 pub fn set_hasWarpBallot(&mut self, val: ::std::os::raw::c_uint) {
2026 unsafe {
2027 let val: u32 = ::std::mem::transmute(val);
2028 self._bitfield_1.set(9usize, 1u8, val as u64)
2029 }
2030 }
2031 #[inline]
2032 pub fn hasWarpShuffle(&self) -> ::std::os::raw::c_uint {
2033 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
2034 }
2035 #[inline]
2036 pub fn set_hasWarpShuffle(&mut self, val: ::std::os::raw::c_uint) {
2037 unsafe {
2038 let val: u32 = ::std::mem::transmute(val);
2039 self._bitfield_1.set(10usize, 1u8, val as u64)
2040 }
2041 }
2042 #[inline]
2043 pub fn hasFunnelShift(&self) -> ::std::os::raw::c_uint {
2044 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
2045 }
2046 #[inline]
2047 pub fn set_hasFunnelShift(&mut self, val: ::std::os::raw::c_uint) {
2048 unsafe {
2049 let val: u32 = ::std::mem::transmute(val);
2050 self._bitfield_1.set(11usize, 1u8, val as u64)
2051 }
2052 }
2053 #[inline]
2054 pub fn hasThreadFenceSystem(&self) -> ::std::os::raw::c_uint {
2055 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
2056 }
2057 #[inline]
2058 pub fn set_hasThreadFenceSystem(&mut self, val: ::std::os::raw::c_uint) {
2059 unsafe {
2060 let val: u32 = ::std::mem::transmute(val);
2061 self._bitfield_1.set(12usize, 1u8, val as u64)
2062 }
2063 }
2064 #[inline]
2065 pub fn hasSyncThreadsExt(&self) -> ::std::os::raw::c_uint {
2066 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2067 }
2068 #[inline]
2069 pub fn set_hasSyncThreadsExt(&mut self, val: ::std::os::raw::c_uint) {
2070 unsafe {
2071 let val: u32 = ::std::mem::transmute(val);
2072 self._bitfield_1.set(13usize, 1u8, val as u64)
2073 }
2074 }
2075 #[inline]
2076 pub fn hasSurfaceFuncs(&self) -> ::std::os::raw::c_uint {
2077 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
2078 }
2079 #[inline]
2080 pub fn set_hasSurfaceFuncs(&mut self, val: ::std::os::raw::c_uint) {
2081 unsafe {
2082 let val: u32 = ::std::mem::transmute(val);
2083 self._bitfield_1.set(14usize, 1u8, val as u64)
2084 }
2085 }
2086 #[inline]
2087 pub fn has3dGrid(&self) -> ::std::os::raw::c_uint {
2088 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
2089 }
2090 #[inline]
2091 pub fn set_has3dGrid(&mut self, val: ::std::os::raw::c_uint) {
2092 unsafe {
2093 let val: u32 = ::std::mem::transmute(val);
2094 self._bitfield_1.set(15usize, 1u8, val as u64)
2095 }
2096 }
2097 #[inline]
2098 pub fn hasDynamicParallelism(&self) -> ::std::os::raw::c_uint {
2099 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2100 }
2101 #[inline]
2102 pub fn set_hasDynamicParallelism(&mut self, val: ::std::os::raw::c_uint) {
2103 unsafe {
2104 let val: u32 = ::std::mem::transmute(val);
2105 self._bitfield_1.set(16usize, 1u8, val as u64)
2106 }
2107 }
2108 #[inline]
2109 pub fn new_bitfield_1(
2110 hasGlobalInt32Atomics: ::std::os::raw::c_uint,
2111 hasGlobalFloatAtomicExch: ::std::os::raw::c_uint,
2112 hasSharedInt32Atomics: ::std::os::raw::c_uint,
2113 hasSharedFloatAtomicExch: ::std::os::raw::c_uint,
2114 hasFloatAtomicAdd: ::std::os::raw::c_uint,
2115 hasGlobalInt64Atomics: ::std::os::raw::c_uint,
2116 hasSharedInt64Atomics: ::std::os::raw::c_uint,
2117 hasDoubles: ::std::os::raw::c_uint,
2118 hasWarpVote: ::std::os::raw::c_uint,
2119 hasWarpBallot: ::std::os::raw::c_uint,
2120 hasWarpShuffle: ::std::os::raw::c_uint,
2121 hasFunnelShift: ::std::os::raw::c_uint,
2122 hasThreadFenceSystem: ::std::os::raw::c_uint,
2123 hasSyncThreadsExt: ::std::os::raw::c_uint,
2124 hasSurfaceFuncs: ::std::os::raw::c_uint,
2125 has3dGrid: ::std::os::raw::c_uint,
2126 hasDynamicParallelism: ::std::os::raw::c_uint,
2127 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
2128 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
2129 __bindgen_bitfield_unit.set(0usize, 1u8, {
2130 let hasGlobalInt32Atomics: u32 =
2131 unsafe { ::std::mem::transmute(hasGlobalInt32Atomics) };
2132 hasGlobalInt32Atomics as u64
2133 });
2134 __bindgen_bitfield_unit.set(1usize, 1u8, {
2135 let hasGlobalFloatAtomicExch: u32 =
2136 unsafe { ::std::mem::transmute(hasGlobalFloatAtomicExch) };
2137 hasGlobalFloatAtomicExch as u64
2138 });
2139 __bindgen_bitfield_unit.set(2usize, 1u8, {
2140 let hasSharedInt32Atomics: u32 =
2141 unsafe { ::std::mem::transmute(hasSharedInt32Atomics) };
2142 hasSharedInt32Atomics as u64
2143 });
2144 __bindgen_bitfield_unit.set(3usize, 1u8, {
2145 let hasSharedFloatAtomicExch: u32 =
2146 unsafe { ::std::mem::transmute(hasSharedFloatAtomicExch) };
2147 hasSharedFloatAtomicExch as u64
2148 });
2149 __bindgen_bitfield_unit.set(4usize, 1u8, {
2150 let hasFloatAtomicAdd: u32 = unsafe { ::std::mem::transmute(hasFloatAtomicAdd) };
2151 hasFloatAtomicAdd as u64
2152 });
2153 __bindgen_bitfield_unit.set(5usize, 1u8, {
2154 let hasGlobalInt64Atomics: u32 =
2155 unsafe { ::std::mem::transmute(hasGlobalInt64Atomics) };
2156 hasGlobalInt64Atomics as u64
2157 });
2158 __bindgen_bitfield_unit.set(6usize, 1u8, {
2159 let hasSharedInt64Atomics: u32 =
2160 unsafe { ::std::mem::transmute(hasSharedInt64Atomics) };
2161 hasSharedInt64Atomics as u64
2162 });
2163 __bindgen_bitfield_unit.set(7usize, 1u8, {
2164 let hasDoubles: u32 = unsafe { ::std::mem::transmute(hasDoubles) };
2165 hasDoubles as u64
2166 });
2167 __bindgen_bitfield_unit.set(8usize, 1u8, {
2168 let hasWarpVote: u32 = unsafe { ::std::mem::transmute(hasWarpVote) };
2169 hasWarpVote as u64
2170 });
2171 __bindgen_bitfield_unit.set(9usize, 1u8, {
2172 let hasWarpBallot: u32 = unsafe { ::std::mem::transmute(hasWarpBallot) };
2173 hasWarpBallot as u64
2174 });
2175 __bindgen_bitfield_unit.set(10usize, 1u8, {
2176 let hasWarpShuffle: u32 = unsafe { ::std::mem::transmute(hasWarpShuffle) };
2177 hasWarpShuffle as u64
2178 });
2179 __bindgen_bitfield_unit.set(11usize, 1u8, {
2180 let hasFunnelShift: u32 = unsafe { ::std::mem::transmute(hasFunnelShift) };
2181 hasFunnelShift as u64
2182 });
2183 __bindgen_bitfield_unit.set(12usize, 1u8, {
2184 let hasThreadFenceSystem: u32 = unsafe { ::std::mem::transmute(hasThreadFenceSystem) };
2185 hasThreadFenceSystem as u64
2186 });
2187 __bindgen_bitfield_unit.set(13usize, 1u8, {
2188 let hasSyncThreadsExt: u32 = unsafe { ::std::mem::transmute(hasSyncThreadsExt) };
2189 hasSyncThreadsExt as u64
2190 });
2191 __bindgen_bitfield_unit.set(14usize, 1u8, {
2192 let hasSurfaceFuncs: u32 = unsafe { ::std::mem::transmute(hasSurfaceFuncs) };
2193 hasSurfaceFuncs as u64
2194 });
2195 __bindgen_bitfield_unit.set(15usize, 1u8, {
2196 let has3dGrid: u32 = unsafe { ::std::mem::transmute(has3dGrid) };
2197 has3dGrid as u64
2198 });
2199 __bindgen_bitfield_unit.set(16usize, 1u8, {
2200 let hasDynamicParallelism: u32 =
2201 unsafe { ::std::mem::transmute(hasDynamicParallelism) };
2202 hasDynamicParallelism as u64
2203 });
2204 __bindgen_bitfield_unit
2205 }
2206}
2207#[repr(C)]
2208#[derive(Debug, Copy, Clone)]
2209pub struct hipUUID_t {
2210 pub bytes: [::std::os::raw::c_char; 16usize],
2211}
2212pub type hipUUID = hipUUID_t;
2213#[doc = " hipDeviceProp\n"]
2214#[repr(C)]
2215#[derive(Debug, Copy, Clone)]
2216pub struct hipDeviceProp_tR0600 {
2217 #[doc = "< Device name."]
2218 pub name: [::std::os::raw::c_char; 256usize],
2219 #[doc = "< UUID of a device"]
2220 pub uuid: hipUUID,
2221 #[doc = "< 8-byte unique identifier. Only valid on windows"]
2222 pub luid: [::std::os::raw::c_char; 8usize],
2223 #[doc = "< LUID node mask"]
2224 pub luidDeviceNodeMask: ::std::os::raw::c_uint,
2225 #[doc = "< Size of global memory region (in bytes)."]
2226 pub totalGlobalMem: usize,
2227 #[doc = "< Size of shared memory per block (in bytes)."]
2228 pub sharedMemPerBlock: usize,
2229 #[doc = "< Registers per block."]
2230 pub regsPerBlock: ::std::os::raw::c_int,
2231 #[doc = "< Warp size."]
2232 pub warpSize: ::std::os::raw::c_int,
2233 #[doc = "< Maximum pitch in bytes allowed by memory copies\n< pitched memory"]
2234 pub memPitch: usize,
2235 #[doc = "< Max work items per work group or workgroup max size."]
2236 pub maxThreadsPerBlock: ::std::os::raw::c_int,
2237 #[doc = "< Max number of threads in each dimension (XYZ) of a block."]
2238 pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
2239 #[doc = "< Max grid dimensions (XYZ)."]
2240 pub maxGridSize: [::std::os::raw::c_int; 3usize],
2241 #[doc = "< Max clock frequency of the multiProcessors in khz."]
2242 pub clockRate: ::std::os::raw::c_int,
2243 #[doc = "< Size of shared constant memory region on the device\n< (in bytes)."]
2244 pub totalConstMem: usize,
2245 #[doc = "< Major compute capability. On HCC, this is an approximation and features may\n< differ from CUDA CC. See the arch feature flags for portable ways to query\n< feature caps."]
2246 pub major: ::std::os::raw::c_int,
2247 #[doc = "< Minor compute capability. On HCC, this is an approximation and features may\n< differ from CUDA CC. See the arch feature flags for portable ways to query\n< feature caps."]
2248 pub minor: ::std::os::raw::c_int,
2249 #[doc = "< Alignment requirement for textures"]
2250 pub textureAlignment: usize,
2251 #[doc = "< Pitch alignment requirement for texture references bound to"]
2252 pub texturePitchAlignment: usize,
2253 #[doc = "< Deprecated. Use asyncEngineCount instead"]
2254 pub deviceOverlap: ::std::os::raw::c_int,
2255 #[doc = "< Number of multi-processors (compute units)."]
2256 pub multiProcessorCount: ::std::os::raw::c_int,
2257 #[doc = "< Run time limit for kernels executed on the device"]
2258 pub kernelExecTimeoutEnabled: ::std::os::raw::c_int,
2259 #[doc = "< APU vs dGPU"]
2260 pub integrated: ::std::os::raw::c_int,
2261 #[doc = "< Check whether HIP can map host memory"]
2262 pub canMapHostMemory: ::std::os::raw::c_int,
2263 #[doc = "< Compute mode."]
2264 pub computeMode: ::std::os::raw::c_int,
2265 #[doc = "< Maximum number of elements in 1D images"]
2266 pub maxTexture1D: ::std::os::raw::c_int,
2267 #[doc = "< Maximum 1D mipmap texture size"]
2268 pub maxTexture1DMipmap: ::std::os::raw::c_int,
2269 #[doc = "< Maximum size for 1D textures bound to linear memory"]
2270 pub maxTexture1DLinear: ::std::os::raw::c_int,
2271 #[doc = "< Maximum dimensions (width, height) of 2D images, in image elements"]
2272 pub maxTexture2D: [::std::os::raw::c_int; 2usize],
2273 #[doc = "< Maximum number of elements in 2D array mipmap of images"]
2274 pub maxTexture2DMipmap: [::std::os::raw::c_int; 2usize],
2275 #[doc = "< Maximum 2D tex dimensions if tex are bound to pitched memory"]
2276 pub maxTexture2DLinear: [::std::os::raw::c_int; 3usize],
2277 #[doc = "< Maximum 2D tex dimensions if gather has to be performed"]
2278 pub maxTexture2DGather: [::std::os::raw::c_int; 2usize],
2279 #[doc = "< Maximum dimensions (width, height, depth) of 3D images, in image\n< elements"]
2280 pub maxTexture3D: [::std::os::raw::c_int; 3usize],
2281 #[doc = "< Maximum alternate 3D texture dims"]
2282 pub maxTexture3DAlt: [::std::os::raw::c_int; 3usize],
2283 #[doc = "< Maximum cubemap texture dims"]
2284 pub maxTextureCubemap: ::std::os::raw::c_int,
2285 #[doc = "< Maximum number of elements in 1D array images"]
2286 pub maxTexture1DLayered: [::std::os::raw::c_int; 2usize],
2287 #[doc = "< Maximum number of elements in 2D array images"]
2288 pub maxTexture2DLayered: [::std::os::raw::c_int; 3usize],
2289 #[doc = "< Maximum cubemaps layered texture dims"]
2290 pub maxTextureCubemapLayered: [::std::os::raw::c_int; 2usize],
2291 #[doc = "< Maximum 1D surface size"]
2292 pub maxSurface1D: ::std::os::raw::c_int,
2293 #[doc = "< Maximum 2D surface size"]
2294 pub maxSurface2D: [::std::os::raw::c_int; 2usize],
2295 #[doc = "< Maximum 3D surface size"]
2296 pub maxSurface3D: [::std::os::raw::c_int; 3usize],
2297 #[doc = "< Maximum 1D layered surface size"]
2298 pub maxSurface1DLayered: [::std::os::raw::c_int; 2usize],
2299 #[doc = "< Maximum 2D layared surface size"]
2300 pub maxSurface2DLayered: [::std::os::raw::c_int; 3usize],
2301 #[doc = "< Maximum cubemap surface size"]
2302 pub maxSurfaceCubemap: ::std::os::raw::c_int,
2303 #[doc = "< Maximum cubemap layered surface size"]
2304 pub maxSurfaceCubemapLayered: [::std::os::raw::c_int; 2usize],
2305 #[doc = "< Alignment requirement for surface"]
2306 pub surfaceAlignment: usize,
2307 #[doc = "< Device can possibly execute multiple kernels concurrently."]
2308 pub concurrentKernels: ::std::os::raw::c_int,
2309 #[doc = "< Device has ECC support enabled"]
2310 pub ECCEnabled: ::std::os::raw::c_int,
2311 #[doc = "< PCI Bus ID."]
2312 pub pciBusID: ::std::os::raw::c_int,
2313 #[doc = "< PCI Device ID."]
2314 pub pciDeviceID: ::std::os::raw::c_int,
2315 #[doc = "< PCI Domain ID"]
2316 pub pciDomainID: ::std::os::raw::c_int,
2317 #[doc = "< 1:If device is Tesla device using TCC driver, else 0"]
2318 pub tccDriver: ::std::os::raw::c_int,
2319 #[doc = "< Number of async engines"]
2320 pub asyncEngineCount: ::std::os::raw::c_int,
2321 #[doc = "< Does device and host share unified address space"]
2322 pub unifiedAddressing: ::std::os::raw::c_int,
2323 #[doc = "< Max global memory clock frequency in khz."]
2324 pub memoryClockRate: ::std::os::raw::c_int,
2325 #[doc = "< Global memory bus width in bits."]
2326 pub memoryBusWidth: ::std::os::raw::c_int,
2327 #[doc = "< L2 cache size."]
2328 pub l2CacheSize: ::std::os::raw::c_int,
2329 #[doc = "< Device's max L2 persisting lines in bytes"]
2330 pub persistingL2CacheMaxSize: ::std::os::raw::c_int,
2331 #[doc = "< Maximum resident threads per multi-processor."]
2332 pub maxThreadsPerMultiProcessor: ::std::os::raw::c_int,
2333 #[doc = "< Device supports stream priority"]
2334 pub streamPrioritiesSupported: ::std::os::raw::c_int,
2335 #[doc = "< Indicates globals are cached in L1"]
2336 pub globalL1CacheSupported: ::std::os::raw::c_int,
2337 #[doc = "< Locals are cahced in L1"]
2338 pub localL1CacheSupported: ::std::os::raw::c_int,
2339 #[doc = "< Amount of shared memory available per multiprocessor."]
2340 pub sharedMemPerMultiprocessor: usize,
2341 #[doc = "< registers available per multiprocessor"]
2342 pub regsPerMultiprocessor: ::std::os::raw::c_int,
2343 #[doc = "< Device supports allocating managed memory on this system"]
2344 pub managedMemory: ::std::os::raw::c_int,
2345 #[doc = "< 1 if device is on a multi-GPU board, 0 if not."]
2346 pub isMultiGpuBoard: ::std::os::raw::c_int,
2347 #[doc = "< Unique identifier for a group of devices on same multiboard GPU"]
2348 pub multiGpuBoardGroupID: ::std::os::raw::c_int,
2349 #[doc = "< Link between host and device supports native atomics"]
2350 pub hostNativeAtomicSupported: ::std::os::raw::c_int,
2351 #[doc = "< Deprecated. CUDA only."]
2352 pub singleToDoublePrecisionPerfRatio: ::std::os::raw::c_int,
2353 #[doc = "< Device supports coherently accessing pageable memory\n< without calling hipHostRegister on it"]
2354 pub pageableMemoryAccess: ::std::os::raw::c_int,
2355 #[doc = "< Device can coherently access managed memory concurrently with\n< the CPU"]
2356 pub concurrentManagedAccess: ::std::os::raw::c_int,
2357 #[doc = "< Is compute preemption supported on the device"]
2358 pub computePreemptionSupported: ::std::os::raw::c_int,
2359 #[doc = "< Device can access host registered memory with same\n< address as the host"]
2360 pub canUseHostPointerForRegisteredMem: ::std::os::raw::c_int,
2361 #[doc = "< HIP device supports cooperative launch"]
2362 pub cooperativeLaunch: ::std::os::raw::c_int,
2363 #[doc = "< HIP device supports cooperative launch on multiple\n< devices"]
2364 pub cooperativeMultiDeviceLaunch: ::std::os::raw::c_int,
2365 #[doc = "< Per device m ax shared mem per block usable by special opt in"]
2366 pub sharedMemPerBlockOptin: usize,
2367 #[doc = "< Device accesses pageable memory via the host's\n< page tables"]
2368 pub pageableMemoryAccessUsesHostPageTables: ::std::os::raw::c_int,
2369 #[doc = "< Host can directly access managed memory on the device\n< without migration"]
2370 pub directManagedMemAccessFromHost: ::std::os::raw::c_int,
2371 #[doc = "< Max number of blocks on CU"]
2372 pub maxBlocksPerMultiProcessor: ::std::os::raw::c_int,
2373 #[doc = "< Max value of access policy window"]
2374 pub accessPolicyMaxWindowSize: ::std::os::raw::c_int,
2375 #[doc = "< Shared memory reserved by driver per block"]
2376 pub reservedSharedMemPerBlock: usize,
2377 #[doc = "< Device supports hipHostRegister"]
2378 pub hostRegisterSupported: ::std::os::raw::c_int,
2379 #[doc = "< Indicates if device supports sparse hip arrays"]
2380 pub sparseHipArraySupported: ::std::os::raw::c_int,
2381 #[doc = "< Device supports using the hipHostRegisterReadOnly flag\n< with hipHostRegistger"]
2382 pub hostRegisterReadOnlySupported: ::std::os::raw::c_int,
2383 #[doc = "< Indicates external timeline semaphore support"]
2384 pub timelineSemaphoreInteropSupported: ::std::os::raw::c_int,
2385 #[doc = "< Indicates if device supports hipMallocAsync and hipMemPool APIs"]
2386 pub memoryPoolsSupported: ::std::os::raw::c_int,
2387 #[doc = "< Indicates device support of RDMA APIs"]
2388 pub gpuDirectRDMASupported: ::std::os::raw::c_int,
2389 #[doc = "< Bitmask to be interpreted according to\n< hipFlushGPUDirectRDMAWritesOptions"]
2390 pub gpuDirectRDMAFlushWritesOptions: ::std::os::raw::c_uint,
2391 #[doc = "< value of hipGPUDirectRDMAWritesOrdering"]
2392 pub gpuDirectRDMAWritesOrdering: ::std::os::raw::c_int,
2393 #[doc = "< Bitmask of handle types support with mempool based IPC"]
2394 pub memoryPoolSupportedHandleTypes: ::std::os::raw::c_uint,
2395 #[doc = "< Device supports deferred mapping HIP arrays and HIP\n< mipmapped arrays"]
2396 pub deferredMappingHipArraySupported: ::std::os::raw::c_int,
2397 #[doc = "< Device supports IPC events"]
2398 pub ipcEventSupported: ::std::os::raw::c_int,
2399 #[doc = "< Device supports cluster launch"]
2400 pub clusterLaunch: ::std::os::raw::c_int,
2401 #[doc = "< Indicates device supports unified function pointers"]
2402 pub unifiedFunctionPointers: ::std::os::raw::c_int,
2403 #[doc = "< CUDA Reserved."]
2404 pub reserved: [::std::os::raw::c_int; 63usize],
2405 #[doc = "< Reserved for adding new entries for HIP/CUDA."]
2406 pub hipReserved: [::std::os::raw::c_int; 32usize],
2407 #[doc = "< AMD GCN Arch Name. HIP Only."]
2408 pub gcnArchName: [::std::os::raw::c_char; 256usize],
2409 #[doc = "< Maximum Shared Memory Per CU. HIP Only."]
2410 pub maxSharedMemoryPerMultiProcessor: usize,
2411 #[doc = "< Frequency in khz of the timer used by the device-side \"clock*\"\n< instructions. New for HIP."]
2412 pub clockInstructionRate: ::std::os::raw::c_int,
2413 #[doc = "< Architectural feature flags. New for HIP."]
2414 pub arch: hipDeviceArch_t,
2415 #[doc = "< Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register"]
2416 pub hdpMemFlushCntl: *mut ::std::os::raw::c_uint,
2417 #[doc = "< Addres of HDP_REG_COHERENCY_FLUSH_CNTL register"]
2418 pub hdpRegFlushCntl: *mut ::std::os::raw::c_uint,
2419 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2420 pub cooperativeMultiDeviceUnmatchedFunc: ::std::os::raw::c_int,
2421 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2422 pub cooperativeMultiDeviceUnmatchedGridDim: ::std::os::raw::c_int,
2423 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2424 pub cooperativeMultiDeviceUnmatchedBlockDim: ::std::os::raw::c_int,
2425 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2426 pub cooperativeMultiDeviceUnmatchedSharedMem: ::std::os::raw::c_int,
2427 #[doc = "< 1: if it is a large PCI bar device, else 0"]
2428 pub isLargeBar: ::std::os::raw::c_int,
2429 #[doc = "< Revision of the GPU in this device"]
2430 pub asicRevision: ::std::os::raw::c_int,
2431}
2432#[doc = "< Unregistered memory"]
2433pub const hipMemoryType_hipMemoryTypeUnregistered: hipMemoryType = 0;
2434#[doc = "< Memory is physically located on host"]
2435pub const hipMemoryType_hipMemoryTypeHost: hipMemoryType = 1;
2436#[doc = "< Memory is physically located on device. (see deviceId for\n< specific device)"]
2437pub const hipMemoryType_hipMemoryTypeDevice: hipMemoryType = 2;
2438#[doc = "< Managed memory, automaticallly managed by the unified\n< memory system\n< place holder for new values."]
2439pub const hipMemoryType_hipMemoryTypeManaged: hipMemoryType = 3;
2440#[doc = "< Array memory, physically located on device. (see deviceId for\n< specific device)"]
2441pub const hipMemoryType_hipMemoryTypeArray: hipMemoryType = 10;
2442#[doc = "< unified address space"]
2443pub const hipMemoryType_hipMemoryTypeUnified: hipMemoryType = 11;
2444#[doc = " hipMemoryType (for pointer attributes)\n\n @note hipMemoryType enum values are combination of cudaMemoryType and cuMemoryType and AMD specific enum values.\n"]
2445pub type hipMemoryType = ::std::os::raw::c_uint;
2446#[doc = " Pointer attributes"]
2447#[repr(C)]
2448#[derive(Debug, Copy, Clone)]
2449pub struct hipPointerAttribute_t {
2450 pub type_: hipMemoryType,
2451 pub device: ::std::os::raw::c_int,
2452 pub devicePointer: *mut ::std::os::raw::c_void,
2453 pub hostPointer: *mut ::std::os::raw::c_void,
2454 pub isManaged: ::std::os::raw::c_int,
2455 pub allocationFlags: ::std::os::raw::c_uint,
2456}
2457#[doc = "< Successful completion."]
2458pub const hipError_t_hipSuccess: hipError_t = 0;
2459#[doc = "< One or more of the parameters passed to the API call is NULL\n< or not in an acceptable range."]
2460pub const hipError_t_hipErrorInvalidValue: hipError_t = 1;
2461#[doc = "< out of memory range."]
2462pub const hipError_t_hipErrorOutOfMemory: hipError_t = 2;
2463#[doc = "< Memory allocation error."]
2464pub const hipError_t_hipErrorMemoryAllocation: hipError_t = 2;
2465#[doc = "< Invalid not initialized"]
2466pub const hipError_t_hipErrorNotInitialized: hipError_t = 3;
2467pub const hipError_t_hipErrorInitializationError: hipError_t = 3;
2468#[doc = "< Deinitialized"]
2469pub const hipError_t_hipErrorDeinitialized: hipError_t = 4;
2470pub const hipError_t_hipErrorProfilerDisabled: hipError_t = 5;
2471pub const hipError_t_hipErrorProfilerNotInitialized: hipError_t = 6;
2472pub const hipError_t_hipErrorProfilerAlreadyStarted: hipError_t = 7;
2473pub const hipError_t_hipErrorProfilerAlreadyStopped: hipError_t = 8;
2474#[doc = "< Invalide configuration"]
2475pub const hipError_t_hipErrorInvalidConfiguration: hipError_t = 9;
2476#[doc = "< Invalid pitch value"]
2477pub const hipError_t_hipErrorInvalidPitchValue: hipError_t = 12;
2478#[doc = "< Invalid symbol"]
2479pub const hipError_t_hipErrorInvalidSymbol: hipError_t = 13;
2480#[doc = "< Invalid Device Pointer"]
2481pub const hipError_t_hipErrorInvalidDevicePointer: hipError_t = 17;
2482#[doc = "< Invalid memory copy direction"]
2483pub const hipError_t_hipErrorInvalidMemcpyDirection: hipError_t = 21;
2484pub const hipError_t_hipErrorInsufficientDriver: hipError_t = 35;
2485pub const hipError_t_hipErrorMissingConfiguration: hipError_t = 52;
2486pub const hipError_t_hipErrorPriorLaunchFailure: hipError_t = 53;
2487#[doc = "< Invalid device function"]
2488pub const hipError_t_hipErrorInvalidDeviceFunction: hipError_t = 98;
2489#[doc = "< Call to hipGetDeviceCount returned 0 devices"]
2490pub const hipError_t_hipErrorNoDevice: hipError_t = 100;
2491#[doc = "< DeviceID must be in range from 0 to compute-devices."]
2492pub const hipError_t_hipErrorInvalidDevice: hipError_t = 101;
2493#[doc = "< Invalid image"]
2494pub const hipError_t_hipErrorInvalidImage: hipError_t = 200;
2495#[doc = "< Produced when input context is invalid."]
2496pub const hipError_t_hipErrorInvalidContext: hipError_t = 201;
2497pub const hipError_t_hipErrorContextAlreadyCurrent: hipError_t = 202;
2498pub const hipError_t_hipErrorMapFailed: hipError_t = 205;
2499#[doc = "< Produced when the IPC memory attach failed from ROCr."]
2500pub const hipError_t_hipErrorMapBufferObjectFailed: hipError_t = 205;
2501pub const hipError_t_hipErrorUnmapFailed: hipError_t = 206;
2502pub const hipError_t_hipErrorArrayIsMapped: hipError_t = 207;
2503pub const hipError_t_hipErrorAlreadyMapped: hipError_t = 208;
2504pub const hipError_t_hipErrorNoBinaryForGpu: hipError_t = 209;
2505pub const hipError_t_hipErrorAlreadyAcquired: hipError_t = 210;
2506pub const hipError_t_hipErrorNotMapped: hipError_t = 211;
2507pub const hipError_t_hipErrorNotMappedAsArray: hipError_t = 212;
2508pub const hipError_t_hipErrorNotMappedAsPointer: hipError_t = 213;
2509pub const hipError_t_hipErrorECCNotCorrectable: hipError_t = 214;
2510#[doc = "< Unsupported limit"]
2511pub const hipError_t_hipErrorUnsupportedLimit: hipError_t = 215;
2512#[doc = "< The context is already in use"]
2513pub const hipError_t_hipErrorContextAlreadyInUse: hipError_t = 216;
2514pub const hipError_t_hipErrorPeerAccessUnsupported: hipError_t = 217;
2515#[doc = "< In CUDA DRV, it is CUDA_ERROR_INVALID_PTX"]
2516pub const hipError_t_hipErrorInvalidKernelFile: hipError_t = 218;
2517pub const hipError_t_hipErrorInvalidGraphicsContext: hipError_t = 219;
2518#[doc = "< Invalid source."]
2519pub const hipError_t_hipErrorInvalidSource: hipError_t = 300;
2520#[doc = "< the file is not found."]
2521pub const hipError_t_hipErrorFileNotFound: hipError_t = 301;
2522pub const hipError_t_hipErrorSharedObjectSymbolNotFound: hipError_t = 302;
2523#[doc = "< Failed to initialize shared object."]
2524pub const hipError_t_hipErrorSharedObjectInitFailed: hipError_t = 303;
2525#[doc = "< Not the correct operating system"]
2526pub const hipError_t_hipErrorOperatingSystem: hipError_t = 304;
2527#[doc = "< Invalide handle"]
2528pub const hipError_t_hipErrorInvalidHandle: hipError_t = 400;
2529#[doc = "< Resource handle (hipEvent_t or hipStream_t) invalid."]
2530pub const hipError_t_hipErrorInvalidResourceHandle: hipError_t = 400;
2531#[doc = "< Resource required is not in a valid state to perform operation."]
2532pub const hipError_t_hipErrorIllegalState: hipError_t = 401;
2533#[doc = "< Not found"]
2534pub const hipError_t_hipErrorNotFound: hipError_t = 500;
2535#[doc = "< Indicates that asynchronous operations enqueued earlier are not\n< ready. This is not actually an error, but is used to distinguish\n< from hipSuccess (which indicates completion). APIs that return\n< this error include hipEventQuery and hipStreamQuery."]
2536pub const hipError_t_hipErrorNotReady: hipError_t = 600;
2537pub const hipError_t_hipErrorIllegalAddress: hipError_t = 700;
2538#[doc = "< Out of resources error."]
2539pub const hipError_t_hipErrorLaunchOutOfResources: hipError_t = 701;
2540#[doc = "< Timeout for the launch."]
2541pub const hipError_t_hipErrorLaunchTimeOut: hipError_t = 702;
2542#[doc = "< Peer access was already enabled from the current\n< device."]
2543pub const hipError_t_hipErrorPeerAccessAlreadyEnabled: hipError_t = 704;
2544#[doc = "< Peer access was never enabled from the current device."]
2545pub const hipError_t_hipErrorPeerAccessNotEnabled: hipError_t = 705;
2546#[doc = "< The process is active."]
2547pub const hipError_t_hipErrorSetOnActiveProcess: hipError_t = 708;
2548#[doc = "< The context is already destroyed"]
2549pub const hipError_t_hipErrorContextIsDestroyed: hipError_t = 709;
2550#[doc = "< Produced when the kernel calls assert."]
2551pub const hipError_t_hipErrorAssert: hipError_t = 710;
2552#[doc = "< Produced when trying to lock a page-locked\n< memory."]
2553pub const hipError_t_hipErrorHostMemoryAlreadyRegistered: hipError_t = 712;
2554#[doc = "< Produced when trying to unlock a non-page-locked\n< memory."]
2555pub const hipError_t_hipErrorHostMemoryNotRegistered: hipError_t = 713;
2556#[doc = "< An exception occurred on the device while executing a kernel."]
2557pub const hipError_t_hipErrorLaunchFailure: hipError_t = 719;
2558#[doc = "< This error indicates that the number of blocks\n< launched per grid for a kernel that was launched\n< via cooperative launch APIs exceeds the maximum\n< number of allowed blocks for the current device."]
2559pub const hipError_t_hipErrorCooperativeLaunchTooLarge: hipError_t = 720;
2560#[doc = "< Produced when the hip API is not supported/implemented"]
2561pub const hipError_t_hipErrorNotSupported: hipError_t = 801;
2562#[doc = "< The operation is not permitted when the stream\n< is capturing."]
2563pub const hipError_t_hipErrorStreamCaptureUnsupported: hipError_t = 900;
2564#[doc = "< The current capture sequence on the stream\n< has been invalidated due to a previous error."]
2565pub const hipError_t_hipErrorStreamCaptureInvalidated: hipError_t = 901;
2566#[doc = "< The operation would have resulted in a merge of\n< two independent capture sequences."]
2567pub const hipError_t_hipErrorStreamCaptureMerge: hipError_t = 902;
2568#[doc = "< The capture was not initiated in this stream."]
2569pub const hipError_t_hipErrorStreamCaptureUnmatched: hipError_t = 903;
2570#[doc = "< The capture sequence contains a fork that was not\n< joined to the primary stream."]
2571pub const hipError_t_hipErrorStreamCaptureUnjoined: hipError_t = 904;
2572#[doc = "< A dependency would have been created which crosses\n< the capture sequence boundary. Only implicit\n< in-stream ordering dependencies are allowed\n< to cross the boundary"]
2573pub const hipError_t_hipErrorStreamCaptureIsolation: hipError_t = 905;
2574#[doc = "< The operation would have resulted in a disallowed\n< implicit dependency on a current capture sequence\n< from hipStreamLegacy."]
2575pub const hipError_t_hipErrorStreamCaptureImplicit: hipError_t = 906;
2576#[doc = "< The operation is not permitted on an event which was last\n< recorded in a capturing stream."]
2577pub const hipError_t_hipErrorCapturedEvent: hipError_t = 907;
2578#[doc = "< A stream capture sequence not initiated with\n< the hipStreamCaptureModeRelaxed argument to\n< hipStreamBeginCapture was passed to\n< hipStreamEndCapture in a different thread."]
2579pub const hipError_t_hipErrorStreamCaptureWrongThread: hipError_t = 908;
2580#[doc = "< This error indicates that the graph update\n< not performed because it included changes which\n< violated constraintsspecific to instantiated graph\n< update."]
2581pub const hipError_t_hipErrorGraphExecUpdateFailure: hipError_t = 910;
2582#[doc = "< Invalid channel descriptor."]
2583pub const hipError_t_hipErrorInvalidChannelDescriptor: hipError_t = 911;
2584#[doc = "< Invalid texture."]
2585pub const hipError_t_hipErrorInvalidTexture: hipError_t = 912;
2586#[doc = "< Unknown error."]
2587pub const hipError_t_hipErrorUnknown: hipError_t = 999;
2588#[doc = "< HSA runtime memory call returned error. Typically not seen\n< in production systems."]
2589pub const hipError_t_hipErrorRuntimeMemory: hipError_t = 1052;
2590#[doc = "< HSA runtime call other than memory returned error. Typically\n< not seen in production systems."]
2591pub const hipError_t_hipErrorRuntimeOther: hipError_t = 1053;
2592#[doc = "< Marker that more error codes are needed."]
2593pub const hipError_t_hipErrorTbd: hipError_t = 1054;
2594#[doc = " HIP error type\n"]
2595pub type hipError_t = ::std::os::raw::c_uint;
2596pub const hipDeviceAttribute_t_hipDeviceAttributeCudaCompatibleBegin: hipDeviceAttribute_t = 0;
2597#[doc = "< Whether ECC support is enabled."]
2598pub const hipDeviceAttribute_t_hipDeviceAttributeEccEnabled: hipDeviceAttribute_t = 0;
2599#[doc = "< Cuda only. The maximum size of the window policy in bytes."]
2600pub const hipDeviceAttribute_t_hipDeviceAttributeAccessPolicyMaxWindowSize: hipDeviceAttribute_t =
2601 1;
2602#[doc = "< Asynchronous engines number."]
2603pub const hipDeviceAttribute_t_hipDeviceAttributeAsyncEngineCount: hipDeviceAttribute_t = 2;
2604#[doc = "< Whether host memory can be mapped into device address space"]
2605pub const hipDeviceAttribute_t_hipDeviceAttributeCanMapHostMemory: hipDeviceAttribute_t = 3;
2606#[doc = "< Device can access host registered memory\n< at the same virtual address as the CPU"]
2607pub const hipDeviceAttribute_t_hipDeviceAttributeCanUseHostPointerForRegisteredMem:
2608 hipDeviceAttribute_t = 4;
2609#[doc = "< Peak clock frequency in kilohertz."]
2610pub const hipDeviceAttribute_t_hipDeviceAttributeClockRate: hipDeviceAttribute_t = 5;
2611#[doc = "< Compute mode that device is currently in."]
2612pub const hipDeviceAttribute_t_hipDeviceAttributeComputeMode: hipDeviceAttribute_t = 6;
2613#[doc = "< Device supports Compute Preemption."]
2614pub const hipDeviceAttribute_t_hipDeviceAttributeComputePreemptionSupported: hipDeviceAttribute_t =
2615 7;
2616#[doc = "< Device can possibly execute multiple kernels concurrently."]
2617pub const hipDeviceAttribute_t_hipDeviceAttributeConcurrentKernels: hipDeviceAttribute_t = 8;
2618#[doc = "< Device can coherently access managed memory concurrently with the CPU"]
2619pub const hipDeviceAttribute_t_hipDeviceAttributeConcurrentManagedAccess: hipDeviceAttribute_t = 9;
2620#[doc = "< Support cooperative launch"]
2621pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeLaunch: hipDeviceAttribute_t = 10;
2622#[doc = "< Support cooperative launch on multiple devices"]
2623pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceLaunch:
2624 hipDeviceAttribute_t = 11;
2625#[doc = "< Device can concurrently copy memory and execute a kernel.\n< Deprecated. Use instead asyncEngineCount."]
2626pub const hipDeviceAttribute_t_hipDeviceAttributeDeviceOverlap: hipDeviceAttribute_t = 12;
2627#[doc = "< Host can directly access managed memory on\n< the device without migration"]
2628pub const hipDeviceAttribute_t_hipDeviceAttributeDirectManagedMemAccessFromHost:
2629 hipDeviceAttribute_t = 13;
2630#[doc = "< Device supports caching globals in L1"]
2631pub const hipDeviceAttribute_t_hipDeviceAttributeGlobalL1CacheSupported: hipDeviceAttribute_t = 14;
2632#[doc = "< Link between the device and the host supports native atomic operations"]
2633pub const hipDeviceAttribute_t_hipDeviceAttributeHostNativeAtomicSupported: hipDeviceAttribute_t =
2634 15;
2635#[doc = "< Device is integrated GPU"]
2636pub const hipDeviceAttribute_t_hipDeviceAttributeIntegrated: hipDeviceAttribute_t = 16;
2637#[doc = "< Multiple GPU devices."]
2638pub const hipDeviceAttribute_t_hipDeviceAttributeIsMultiGpuBoard: hipDeviceAttribute_t = 17;
2639#[doc = "< Run time limit for kernels executed on the device"]
2640pub const hipDeviceAttribute_t_hipDeviceAttributeKernelExecTimeout: hipDeviceAttribute_t = 18;
2641#[doc = "< Size of L2 cache in bytes. 0 if the device doesn't have L2 cache."]
2642pub const hipDeviceAttribute_t_hipDeviceAttributeL2CacheSize: hipDeviceAttribute_t = 19;
2643#[doc = "< caching locals in L1 is supported"]
2644pub const hipDeviceAttribute_t_hipDeviceAttributeLocalL1CacheSupported: hipDeviceAttribute_t = 20;
2645#[doc = "< 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms"]
2646pub const hipDeviceAttribute_t_hipDeviceAttributeLuid: hipDeviceAttribute_t = 21;
2647#[doc = "< Luid device node mask. Undefined on TCC and non-Windows platforms"]
2648pub const hipDeviceAttribute_t_hipDeviceAttributeLuidDeviceNodeMask: hipDeviceAttribute_t = 22;
2649#[doc = "< Major compute capability version number."]
2650pub const hipDeviceAttribute_t_hipDeviceAttributeComputeCapabilityMajor: hipDeviceAttribute_t = 23;
2651#[doc = "< Device supports allocating managed memory on this system"]
2652pub const hipDeviceAttribute_t_hipDeviceAttributeManagedMemory: hipDeviceAttribute_t = 24;
2653#[doc = "< Max block size per multiprocessor"]
2654pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlocksPerMultiProcessor: hipDeviceAttribute_t =
2655 25;
2656#[doc = "< Max block size in width."]
2657pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlockDimX: hipDeviceAttribute_t = 26;
2658#[doc = "< Max block size in height."]
2659pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlockDimY: hipDeviceAttribute_t = 27;
2660#[doc = "< Max block size in depth."]
2661pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlockDimZ: hipDeviceAttribute_t = 28;
2662#[doc = "< Max grid size in width."]
2663pub const hipDeviceAttribute_t_hipDeviceAttributeMaxGridDimX: hipDeviceAttribute_t = 29;
2664#[doc = "< Max grid size in height."]
2665pub const hipDeviceAttribute_t_hipDeviceAttributeMaxGridDimY: hipDeviceAttribute_t = 30;
2666#[doc = "< Max grid size in depth."]
2667pub const hipDeviceAttribute_t_hipDeviceAttributeMaxGridDimZ: hipDeviceAttribute_t = 31;
2668#[doc = "< Maximum size of 1D surface."]
2669pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface1D: hipDeviceAttribute_t = 32;
2670#[doc = "< Cuda only. Maximum dimensions of 1D layered surface."]
2671pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface1DLayered: hipDeviceAttribute_t = 33;
2672#[doc = "< Maximum dimension (width, height) of 2D surface."]
2673pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface2D: hipDeviceAttribute_t = 34;
2674#[doc = "< Cuda only. Maximum dimensions of 2D layered surface."]
2675pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface2DLayered: hipDeviceAttribute_t = 35;
2676#[doc = "< Maximum dimension (width, height, depth) of 3D surface."]
2677pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface3D: hipDeviceAttribute_t = 36;
2678#[doc = "< Cuda only. Maximum dimensions of Cubemap surface."]
2679pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurfaceCubemap: hipDeviceAttribute_t = 37;
2680#[doc = "< Cuda only. Maximum dimension of Cubemap layered surface."]
2681pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurfaceCubemapLayered: hipDeviceAttribute_t =
2682 38;
2683#[doc = "< Maximum size of 1D texture."]
2684pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DWidth: hipDeviceAttribute_t = 39;
2685#[doc = "< Maximum dimensions of 1D layered texture."]
2686pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DLayered: hipDeviceAttribute_t = 40;
2687#[doc = "< Maximum number of elements allocatable in a 1D linear texture.\n< Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda."]
2688pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DLinear: hipDeviceAttribute_t = 41;
2689#[doc = "< Maximum size of 1D mipmapped texture."]
2690pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DMipmap: hipDeviceAttribute_t = 42;
2691#[doc = "< Maximum dimension width of 2D texture."]
2692pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DWidth: hipDeviceAttribute_t = 43;
2693#[doc = "< Maximum dimension hight of 2D texture."]
2694pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DHeight: hipDeviceAttribute_t = 44;
2695#[doc = "< Maximum dimensions of 2D texture if gather operations performed."]
2696pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DGather: hipDeviceAttribute_t = 45;
2697#[doc = "< Maximum dimensions of 2D layered texture."]
2698pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DLayered: hipDeviceAttribute_t = 46;
2699#[doc = "< Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory."]
2700pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DLinear: hipDeviceAttribute_t = 47;
2701#[doc = "< Maximum dimensions of 2D mipmapped texture."]
2702pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DMipmap: hipDeviceAttribute_t = 48;
2703#[doc = "< Maximum dimension width of 3D texture."]
2704pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DWidth: hipDeviceAttribute_t = 49;
2705#[doc = "< Maximum dimension height of 3D texture."]
2706pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DHeight: hipDeviceAttribute_t = 50;
2707#[doc = "< Maximum dimension depth of 3D texture."]
2708pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DDepth: hipDeviceAttribute_t = 51;
2709#[doc = "< Maximum dimensions of alternate 3D texture."]
2710pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DAlt: hipDeviceAttribute_t = 52;
2711#[doc = "< Maximum dimensions of Cubemap texture"]
2712pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTextureCubemap: hipDeviceAttribute_t = 53;
2713#[doc = "< Maximum dimensions of Cubemap layered texture."]
2714pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTextureCubemapLayered: hipDeviceAttribute_t =
2715 54;
2716#[doc = "< Maximum dimension of a block"]
2717pub const hipDeviceAttribute_t_hipDeviceAttributeMaxThreadsDim: hipDeviceAttribute_t = 55;
2718#[doc = "< Maximum number of threads per block."]
2719pub const hipDeviceAttribute_t_hipDeviceAttributeMaxThreadsPerBlock: hipDeviceAttribute_t = 56;
2720#[doc = "< Maximum resident threads per multiprocessor."]
2721pub const hipDeviceAttribute_t_hipDeviceAttributeMaxThreadsPerMultiProcessor: hipDeviceAttribute_t =
2722 57;
2723#[doc = "< Maximum pitch in bytes allowed by memory copies"]
2724pub const hipDeviceAttribute_t_hipDeviceAttributeMaxPitch: hipDeviceAttribute_t = 58;
2725#[doc = "< Global memory bus width in bits."]
2726pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryBusWidth: hipDeviceAttribute_t = 59;
2727#[doc = "< Peak memory clock frequency in kilohertz."]
2728pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryClockRate: hipDeviceAttribute_t = 60;
2729#[doc = "< Minor compute capability version number."]
2730pub const hipDeviceAttribute_t_hipDeviceAttributeComputeCapabilityMinor: hipDeviceAttribute_t = 61;
2731#[doc = "< Unique ID of device group on the same multi-GPU board"]
2732pub const hipDeviceAttribute_t_hipDeviceAttributeMultiGpuBoardGroupID: hipDeviceAttribute_t = 62;
2733#[doc = "< Number of multiprocessors on the device."]
2734pub const hipDeviceAttribute_t_hipDeviceAttributeMultiprocessorCount: hipDeviceAttribute_t = 63;
2735#[doc = "< Previously hipDeviceAttributeName"]
2736pub const hipDeviceAttribute_t_hipDeviceAttributeUnused1: hipDeviceAttribute_t = 64;
2737#[doc = "< Device supports coherently accessing pageable memory\n< without calling hipHostRegister on it"]
2738pub const hipDeviceAttribute_t_hipDeviceAttributePageableMemoryAccess: hipDeviceAttribute_t = 65;
2739#[doc = "< Device accesses pageable memory via the host's page tables"]
2740pub const hipDeviceAttribute_t_hipDeviceAttributePageableMemoryAccessUsesHostPageTables:
2741 hipDeviceAttribute_t = 66;
2742#[doc = "< PCI Bus ID."]
2743pub const hipDeviceAttribute_t_hipDeviceAttributePciBusId: hipDeviceAttribute_t = 67;
2744#[doc = "< PCI Device ID."]
2745pub const hipDeviceAttribute_t_hipDeviceAttributePciDeviceId: hipDeviceAttribute_t = 68;
2746#[doc = "< PCI Domain ID."]
2747pub const hipDeviceAttribute_t_hipDeviceAttributePciDomainID: hipDeviceAttribute_t = 69;
2748#[doc = "< Maximum l2 persisting lines capacity in bytes"]
2749pub const hipDeviceAttribute_t_hipDeviceAttributePersistingL2CacheMaxSize: hipDeviceAttribute_t =
2750 70;
2751#[doc = "< 32-bit registers available to a thread block. This number is shared\n< by all thread blocks simultaneously resident on a multiprocessor."]
2752pub const hipDeviceAttribute_t_hipDeviceAttributeMaxRegistersPerBlock: hipDeviceAttribute_t = 71;
2753#[doc = "< 32-bit registers available per block."]
2754pub const hipDeviceAttribute_t_hipDeviceAttributeMaxRegistersPerMultiprocessor:
2755 hipDeviceAttribute_t = 72;
2756#[doc = "< Shared memory reserved by CUDA driver per block."]
2757pub const hipDeviceAttribute_t_hipDeviceAttributeReservedSharedMemPerBlock: hipDeviceAttribute_t =
2758 73;
2759#[doc = "< Maximum shared memory available per block in bytes."]
2760pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSharedMemoryPerBlock: hipDeviceAttribute_t = 74;
2761#[doc = "< Maximum shared memory per block usable by special opt in."]
2762pub const hipDeviceAttribute_t_hipDeviceAttributeSharedMemPerBlockOptin: hipDeviceAttribute_t = 75;
2763#[doc = "< Shared memory available per multiprocessor."]
2764pub const hipDeviceAttribute_t_hipDeviceAttributeSharedMemPerMultiprocessor: hipDeviceAttribute_t =
2765 76;
2766#[doc = "< Cuda only. Performance ratio of single precision to double precision."]
2767pub const hipDeviceAttribute_t_hipDeviceAttributeSingleToDoublePrecisionPerfRatio:
2768 hipDeviceAttribute_t = 77;
2769#[doc = "< Whether to support stream priorities."]
2770pub const hipDeviceAttribute_t_hipDeviceAttributeStreamPrioritiesSupported: hipDeviceAttribute_t =
2771 78;
2772#[doc = "< Alignment requirement for surfaces"]
2773pub const hipDeviceAttribute_t_hipDeviceAttributeSurfaceAlignment: hipDeviceAttribute_t = 79;
2774#[doc = "< Cuda only. Whether device is a Tesla device using TCC driver"]
2775pub const hipDeviceAttribute_t_hipDeviceAttributeTccDriver: hipDeviceAttribute_t = 80;
2776#[doc = "< Alignment requirement for textures"]
2777pub const hipDeviceAttribute_t_hipDeviceAttributeTextureAlignment: hipDeviceAttribute_t = 81;
2778#[doc = "< Pitch alignment requirement for 2D texture references bound to pitched memory;"]
2779pub const hipDeviceAttribute_t_hipDeviceAttributeTexturePitchAlignment: hipDeviceAttribute_t = 82;
2780#[doc = "< Constant memory size in bytes."]
2781pub const hipDeviceAttribute_t_hipDeviceAttributeTotalConstantMemory: hipDeviceAttribute_t = 83;
2782#[doc = "< Global memory available on devicice."]
2783pub const hipDeviceAttribute_t_hipDeviceAttributeTotalGlobalMem: hipDeviceAttribute_t = 84;
2784#[doc = "< Cuda only. An unified address space shared with the host."]
2785pub const hipDeviceAttribute_t_hipDeviceAttributeUnifiedAddressing: hipDeviceAttribute_t = 85;
2786#[doc = "< Previously hipDeviceAttributeUuid"]
2787pub const hipDeviceAttribute_t_hipDeviceAttributeUnused2: hipDeviceAttribute_t = 86;
2788#[doc = "< Warp size in threads."]
2789pub const hipDeviceAttribute_t_hipDeviceAttributeWarpSize: hipDeviceAttribute_t = 87;
2790#[doc = "< Device supports HIP Stream Ordered Memory Allocator"]
2791pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryPoolsSupported: hipDeviceAttribute_t = 88;
2792#[doc = "< Device supports HIP virtual memory management"]
2793pub const hipDeviceAttribute_t_hipDeviceAttributeVirtualMemoryManagementSupported:
2794 hipDeviceAttribute_t = 89;
2795#[doc = "< Can device support host memory registration via hipHostRegister"]
2796pub const hipDeviceAttribute_t_hipDeviceAttributeHostRegisterSupported: hipDeviceAttribute_t = 90;
2797#[doc = "< Supported handle mask for HIP Stream Ordered Memory Allocator"]
2798pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryPoolSupportedHandleTypes:
2799 hipDeviceAttribute_t = 91;
2800pub const hipDeviceAttribute_t_hipDeviceAttributeCudaCompatibleEnd: hipDeviceAttribute_t = 9999;
2801pub const hipDeviceAttribute_t_hipDeviceAttributeAmdSpecificBegin: hipDeviceAttribute_t = 10000;
2802#[doc = "< Frequency in khz of the timer used by the device-side \"clock*\""]
2803pub const hipDeviceAttribute_t_hipDeviceAttributeClockInstructionRate: hipDeviceAttribute_t = 10000;
2804#[doc = "< Previously hipDeviceAttributeArch"]
2805pub const hipDeviceAttribute_t_hipDeviceAttributeUnused3: hipDeviceAttribute_t = 10001;
2806#[doc = "< Maximum Shared Memory PerMultiprocessor."]
2807pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSharedMemoryPerMultiprocessor:
2808 hipDeviceAttribute_t = 10002;
2809#[doc = "< Previously hipDeviceAttributeGcnArch"]
2810pub const hipDeviceAttribute_t_hipDeviceAttributeUnused4: hipDeviceAttribute_t = 10003;
2811#[doc = "< Previously hipDeviceAttributeGcnArchName"]
2812pub const hipDeviceAttribute_t_hipDeviceAttributeUnused5: hipDeviceAttribute_t = 10004;
2813#[doc = "< Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register"]
2814pub const hipDeviceAttribute_t_hipDeviceAttributeHdpMemFlushCntl: hipDeviceAttribute_t = 10005;
2815#[doc = "< Address of the HDP_REG_COHERENCY_FLUSH_CNTL register"]
2816pub const hipDeviceAttribute_t_hipDeviceAttributeHdpRegFlushCntl: hipDeviceAttribute_t = 10006;
2817#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched functions"]
2818pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc:
2819 hipDeviceAttribute_t = 10007;
2820#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched grid dimensions"]
2821pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim:
2822 hipDeviceAttribute_t = 10008;
2823#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched block dimensions"]
2824pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim:
2825 hipDeviceAttribute_t = 10009;
2826#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched shared memories"]
2827pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem:
2828 hipDeviceAttribute_t = 10010;
2829#[doc = "< Whether it is LargeBar"]
2830pub const hipDeviceAttribute_t_hipDeviceAttributeIsLargeBar: hipDeviceAttribute_t = 10011;
2831#[doc = "< Revision of the GPU in this device"]
2832pub const hipDeviceAttribute_t_hipDeviceAttributeAsicRevision: hipDeviceAttribute_t = 10012;
2833#[doc = "< '1' if Device supports hipStreamWaitValue32() and\n< hipStreamWaitValue64(), '0' otherwise."]
2834pub const hipDeviceAttribute_t_hipDeviceAttributeCanUseStreamWaitValue: hipDeviceAttribute_t =
2835 10013;
2836#[doc = "< '1' if Device supports image, '0' otherwise."]
2837pub const hipDeviceAttribute_t_hipDeviceAttributeImageSupport: hipDeviceAttribute_t = 10014;
2838#[doc = "< All available physical compute\n< units for the device"]
2839pub const hipDeviceAttribute_t_hipDeviceAttributePhysicalMultiProcessorCount: hipDeviceAttribute_t =
2840 10015;
2841#[doc = "< '1' if Device supports fine grain, '0' otherwise"]
2842pub const hipDeviceAttribute_t_hipDeviceAttributeFineGrainSupport: hipDeviceAttribute_t = 10016;
2843#[doc = "< Constant frequency of wall clock in kilohertz."]
2844pub const hipDeviceAttribute_t_hipDeviceAttributeWallClockRate: hipDeviceAttribute_t = 10017;
2845pub const hipDeviceAttribute_t_hipDeviceAttributeAmdSpecificEnd: hipDeviceAttribute_t = 19999;
2846pub const hipDeviceAttribute_t_hipDeviceAttributeVendorSpecificBegin: hipDeviceAttribute_t = 20000;
2847#[doc = " hipDeviceAttribute_t\n hipDeviceAttributeUnused number: 5"]
2848pub type hipDeviceAttribute_t = ::std::os::raw::c_uint;
2849pub const hipDriverProcAddressQueryResult_HIP_GET_PROC_ADDRESS_SUCCESS:
2850 hipDriverProcAddressQueryResult = 0;
2851pub const hipDriverProcAddressQueryResult_HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND:
2852 hipDriverProcAddressQueryResult = 1;
2853pub const hipDriverProcAddressQueryResult_HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT:
2854 hipDriverProcAddressQueryResult = 2;
2855pub type hipDriverProcAddressQueryResult = ::std::os::raw::c_uint;
2856pub const hipComputeMode_hipComputeModeDefault: hipComputeMode = 0;
2857pub const hipComputeMode_hipComputeModeExclusive: hipComputeMode = 1;
2858pub const hipComputeMode_hipComputeModeProhibited: hipComputeMode = 2;
2859pub const hipComputeMode_hipComputeModeExclusiveProcess: hipComputeMode = 3;
2860pub type hipComputeMode = ::std::os::raw::c_uint;
2861pub const hipFlushGPUDirectRDMAWritesOptions_hipFlushGPUDirectRDMAWritesOptionHost:
2862 hipFlushGPUDirectRDMAWritesOptions = 1;
2863pub const hipFlushGPUDirectRDMAWritesOptions_hipFlushGPUDirectRDMAWritesOptionMemOps:
2864 hipFlushGPUDirectRDMAWritesOptions = 2;
2865pub type hipFlushGPUDirectRDMAWritesOptions = ::std::os::raw::c_uint;
2866pub const hipGPUDirectRDMAWritesOrdering_hipGPUDirectRDMAWritesOrderingNone:
2867 hipGPUDirectRDMAWritesOrdering = 0;
2868pub const hipGPUDirectRDMAWritesOrdering_hipGPUDirectRDMAWritesOrderingOwner:
2869 hipGPUDirectRDMAWritesOrdering = 100;
2870pub const hipGPUDirectRDMAWritesOrdering_hipGPUDirectRDMAWritesOrderingAllDevices:
2871 hipGPUDirectRDMAWritesOrdering = 200;
2872pub type hipGPUDirectRDMAWritesOrdering = ::std::os::raw::c_uint;
2873pub type int_least8_t = __int_least8_t;
2874pub type int_least16_t = __int_least16_t;
2875pub type int_least32_t = __int_least32_t;
2876pub type int_least64_t = __int_least64_t;
2877pub type uint_least8_t = __uint_least8_t;
2878pub type uint_least16_t = __uint_least16_t;
2879pub type uint_least32_t = __uint_least32_t;
2880pub type uint_least64_t = __uint_least64_t;
2881pub type int_fast8_t = ::std::os::raw::c_schar;
2882pub type int_fast16_t = ::std::os::raw::c_long;
2883pub type int_fast32_t = ::std::os::raw::c_long;
2884pub type int_fast64_t = ::std::os::raw::c_long;
2885pub type uint_fast8_t = ::std::os::raw::c_uchar;
2886pub type uint_fast16_t = ::std::os::raw::c_ulong;
2887pub type uint_fast32_t = ::std::os::raw::c_ulong;
2888pub type uint_fast64_t = ::std::os::raw::c_ulong;
2889pub type intmax_t = __intmax_t;
2890pub type uintmax_t = __uintmax_t;
2891#[repr(C)]
2892#[repr(align(16))]
2893#[derive(Debug, Copy, Clone)]
2894pub struct max_align_t {
2895 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
2896 pub __bindgen_padding_0: u64,
2897 pub __clang_max_align_nonce2: u128,
2898}
2899#[doc = " @defgroup DriverTypes Driver Types\n @{\n This section describes the driver data types.\n"]
2900pub type hipDeviceptr_t = *mut ::std::os::raw::c_void;
2901#[doc = "< Signed channel format"]
2902pub const hipChannelFormatKind_hipChannelFormatKindSigned: hipChannelFormatKind = 0;
2903#[doc = "< Unsigned channel format"]
2904pub const hipChannelFormatKind_hipChannelFormatKindUnsigned: hipChannelFormatKind = 1;
2905#[doc = "< Float channel format"]
2906pub const hipChannelFormatKind_hipChannelFormatKindFloat: hipChannelFormatKind = 2;
2907#[doc = "< No channel format"]
2908pub const hipChannelFormatKind_hipChannelFormatKindNone: hipChannelFormatKind = 3;
2909#[doc = " HIP channel format kinds"]
2910pub type hipChannelFormatKind = ::std::os::raw::c_uint;
2911#[doc = " HIP channel format descriptor"]
2912#[repr(C)]
2913#[derive(Debug, Copy, Clone)]
2914pub struct hipChannelFormatDesc {
2915 pub x: ::std::os::raw::c_int,
2916 pub y: ::std::os::raw::c_int,
2917 pub z: ::std::os::raw::c_int,
2918 pub w: ::std::os::raw::c_int,
2919 #[doc = "< Channel format kind"]
2920 pub f: hipChannelFormatKind,
2921}
2922#[repr(C)]
2923#[derive(Debug, Copy, Clone)]
2924pub struct hipArray {
2925 _unused: [u8; 0],
2926}
2927pub type hipArray_t = *mut hipArray;
2928pub type hipArray_const_t = *const hipArray;
2929#[doc = "< Unsigned 8-bit array format"]
2930pub const hipArray_Format_HIP_AD_FORMAT_UNSIGNED_INT8: hipArray_Format = 1;
2931#[doc = "< Unsigned 16-bit array format"]
2932pub const hipArray_Format_HIP_AD_FORMAT_UNSIGNED_INT16: hipArray_Format = 2;
2933#[doc = "< Unsigned 32-bit array format"]
2934pub const hipArray_Format_HIP_AD_FORMAT_UNSIGNED_INT32: hipArray_Format = 3;
2935#[doc = "< Signed 8-bit array format"]
2936pub const hipArray_Format_HIP_AD_FORMAT_SIGNED_INT8: hipArray_Format = 8;
2937#[doc = "< Signed 16-bit array format"]
2938pub const hipArray_Format_HIP_AD_FORMAT_SIGNED_INT16: hipArray_Format = 9;
2939#[doc = "< Signed 32-bit array format"]
2940pub const hipArray_Format_HIP_AD_FORMAT_SIGNED_INT32: hipArray_Format = 10;
2941#[doc = "< Half array format"]
2942pub const hipArray_Format_HIP_AD_FORMAT_HALF: hipArray_Format = 16;
2943#[doc = "< Float array format"]
2944pub const hipArray_Format_HIP_AD_FORMAT_FLOAT: hipArray_Format = 32;
2945#[doc = " HIP array format"]
2946pub type hipArray_Format = ::std::os::raw::c_uint;
2947#[doc = " HIP array descriptor"]
2948#[repr(C)]
2949#[derive(Debug, Copy, Clone)]
2950pub struct HIP_ARRAY_DESCRIPTOR {
2951 #[doc = "< Width of the array"]
2952 pub Width: usize,
2953 #[doc = "< Height of the array"]
2954 pub Height: usize,
2955 #[doc = "< Format of the array"]
2956 pub Format: hipArray_Format,
2957 #[doc = "< Number of channels of the array"]
2958 pub NumChannels: ::std::os::raw::c_uint,
2959}
2960#[doc = " HIP 3D array descriptor"]
2961#[repr(C)]
2962#[derive(Debug, Copy, Clone)]
2963pub struct HIP_ARRAY3D_DESCRIPTOR {
2964 #[doc = "< Width of the array"]
2965 pub Width: usize,
2966 #[doc = "< Height of the array"]
2967 pub Height: usize,
2968 #[doc = "< Depth of the array"]
2969 pub Depth: usize,
2970 #[doc = "< Format of the array"]
2971 pub Format: hipArray_Format,
2972 #[doc = "< Number of channels of the array"]
2973 pub NumChannels: ::std::os::raw::c_uint,
2974 #[doc = "< Flags of the array"]
2975 pub Flags: ::std::os::raw::c_uint,
2976}
2977#[doc = " HIP 2D memory copy parameters"]
2978#[repr(C)]
2979#[derive(Debug, Copy, Clone)]
2980pub struct hip_Memcpy2D {
2981 #[doc = "< Source width in bytes"]
2982 pub srcXInBytes: usize,
2983 #[doc = "< Source height"]
2984 pub srcY: usize,
2985 #[doc = "< Source memory type"]
2986 pub srcMemoryType: hipMemoryType,
2987 #[doc = "< Source pointer"]
2988 pub srcHost: *const ::std::os::raw::c_void,
2989 #[doc = "< Source device"]
2990 pub srcDevice: hipDeviceptr_t,
2991 #[doc = "< Source array"]
2992 pub srcArray: hipArray_t,
2993 #[doc = "< Source pitch"]
2994 pub srcPitch: usize,
2995 #[doc = "< Destination width in bytes"]
2996 pub dstXInBytes: usize,
2997 #[doc = "< Destination height"]
2998 pub dstY: usize,
2999 #[doc = "< Destination memory type"]
3000 pub dstMemoryType: hipMemoryType,
3001 #[doc = "< Destination pointer"]
3002 pub dstHost: *mut ::std::os::raw::c_void,
3003 #[doc = "< Destination device"]
3004 pub dstDevice: hipDeviceptr_t,
3005 #[doc = "< Destination array"]
3006 pub dstArray: hipArray_t,
3007 #[doc = "< Destination pitch"]
3008 pub dstPitch: usize,
3009 #[doc = "< Width in bytes of the 2D memory copy"]
3010 pub WidthInBytes: usize,
3011 #[doc = "< Height of the 2D memory copy"]
3012 pub Height: usize,
3013}
3014#[doc = " HIP mipmapped array"]
3015#[repr(C)]
3016#[derive(Debug, Copy, Clone)]
3017pub struct hipMipmappedArray {
3018 #[doc = "< Data pointer of the mipmapped array"]
3019 pub data: *mut ::std::os::raw::c_void,
3020 #[doc = "< Description of the mipmapped array"]
3021 pub desc: hipChannelFormatDesc,
3022 #[doc = "< Type of the mipmapped array"]
3023 pub type_: ::std::os::raw::c_uint,
3024 #[doc = "< Width of the mipmapped array"]
3025 pub width: ::std::os::raw::c_uint,
3026 #[doc = "< Height of the mipmapped array"]
3027 pub height: ::std::os::raw::c_uint,
3028 #[doc = "< Depth of the mipmapped array"]
3029 pub depth: ::std::os::raw::c_uint,
3030 #[doc = "< Minimum level of the mipmapped array"]
3031 pub min_mipmap_level: ::std::os::raw::c_uint,
3032 #[doc = "< Maximum level of the mipmapped array"]
3033 pub max_mipmap_level: ::std::os::raw::c_uint,
3034 #[doc = "< Flags of the mipmapped array"]
3035 pub flags: ::std::os::raw::c_uint,
3036 #[doc = "< Format of the mipmapped array"]
3037 pub format: hipArray_Format,
3038 #[doc = "< Number of channels of the mipmapped array"]
3039 pub num_channels: ::std::os::raw::c_uint,
3040}
3041#[doc = " HIP mipmapped array pointer"]
3042pub type hipMipmappedArray_t = *mut hipMipmappedArray;
3043pub type hipmipmappedArray = hipMipmappedArray_t;
3044pub type hipMipmappedArray_const_t = *const hipMipmappedArray;
3045#[doc = "< Array resource"]
3046pub const hipResourceType_hipResourceTypeArray: hipResourceType = 0;
3047#[doc = "< Mipmapped array resource"]
3048pub const hipResourceType_hipResourceTypeMipmappedArray: hipResourceType = 1;
3049#[doc = "< Linear resource"]
3050pub const hipResourceType_hipResourceTypeLinear: hipResourceType = 2;
3051#[doc = "< Pitch 2D resource"]
3052pub const hipResourceType_hipResourceTypePitch2D: hipResourceType = 3;
3053#[doc = " HIP resource types"]
3054pub type hipResourceType = ::std::os::raw::c_uint;
3055#[doc = "< Array resource"]
3056pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_ARRAY: HIPresourcetype_enum = 0;
3057#[doc = "< Mipmapped array resource"]
3058pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY: HIPresourcetype_enum = 1;
3059#[doc = "< Linear resource"]
3060pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_LINEAR: HIPresourcetype_enum = 2;
3061#[doc = "< Pitch 2D resource"]
3062pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_PITCH2D: HIPresourcetype_enum = 3;
3063pub type HIPresourcetype_enum = ::std::os::raw::c_uint;
3064pub use self::HIPresourcetype_enum as HIPresourcetype;
3065pub use self::HIPresourcetype_enum as hipResourcetype;
3066#[doc = "< Wrap address mode"]
3067pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_WRAP: HIPaddress_mode_enum = 0;
3068#[doc = "< Clamp address mode"]
3069pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_CLAMP: HIPaddress_mode_enum = 1;
3070#[doc = "< Mirror address mode"]
3071pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_MIRROR: HIPaddress_mode_enum = 2;
3072#[doc = "< Border address mode"]
3073pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_BORDER: HIPaddress_mode_enum = 3;
3074#[doc = " HIP texture address modes"]
3075pub type HIPaddress_mode_enum = ::std::os::raw::c_uint;
3076#[doc = " HIP texture address modes"]
3077pub use self::HIPaddress_mode_enum as HIPaddress_mode;
3078#[doc = "< Filter mode point"]
3079pub const HIPfilter_mode_enum_HIP_TR_FILTER_MODE_POINT: HIPfilter_mode_enum = 0;
3080#[doc = "< Filter mode linear"]
3081pub const HIPfilter_mode_enum_HIP_TR_FILTER_MODE_LINEAR: HIPfilter_mode_enum = 1;
3082#[doc = " HIP filter modes"]
3083pub type HIPfilter_mode_enum = ::std::os::raw::c_uint;
3084#[doc = " HIP filter modes"]
3085pub use self::HIPfilter_mode_enum as HIPfilter_mode;
3086#[doc = " HIP texture descriptor"]
3087#[repr(C)]
3088#[derive(Debug, Copy, Clone)]
3089pub struct HIP_TEXTURE_DESC_st {
3090 #[doc = "< Address modes"]
3091 pub addressMode: [HIPaddress_mode; 3usize],
3092 #[doc = "< Filter mode"]
3093 pub filterMode: HIPfilter_mode,
3094 #[doc = "< Flags"]
3095 pub flags: ::std::os::raw::c_uint,
3096 #[doc = "< Maximum anisotropy ratio"]
3097 pub maxAnisotropy: ::std::os::raw::c_uint,
3098 #[doc = "< Mipmap filter mode"]
3099 pub mipmapFilterMode: HIPfilter_mode,
3100 #[doc = "< Mipmap level bias"]
3101 pub mipmapLevelBias: f32,
3102 #[doc = "< Mipmap minimum level clamp"]
3103 pub minMipmapLevelClamp: f32,
3104 #[doc = "< Mipmap maximum level clamp"]
3105 pub maxMipmapLevelClamp: f32,
3106 #[doc = "< Border Color"]
3107 pub borderColor: [f32; 4usize],
3108 pub reserved: [::std::os::raw::c_int; 12usize],
3109}
3110#[doc = " HIP texture descriptor"]
3111pub type HIP_TEXTURE_DESC = HIP_TEXTURE_DESC_st;
3112#[doc = "< No resource view format (use underlying resource format)"]
3113pub const hipResourceViewFormat_hipResViewFormatNone: hipResourceViewFormat = 0;
3114#[doc = "< 1 channel, unsigned 8-bit integers"]
3115pub const hipResourceViewFormat_hipResViewFormatUnsignedChar1: hipResourceViewFormat = 1;
3116#[doc = "< 2 channels, unsigned 8-bit integers"]
3117pub const hipResourceViewFormat_hipResViewFormatUnsignedChar2: hipResourceViewFormat = 2;
3118#[doc = "< 4 channels, unsigned 8-bit integers"]
3119pub const hipResourceViewFormat_hipResViewFormatUnsignedChar4: hipResourceViewFormat = 3;
3120#[doc = "< 1 channel, signed 8-bit integers"]
3121pub const hipResourceViewFormat_hipResViewFormatSignedChar1: hipResourceViewFormat = 4;
3122#[doc = "< 2 channels, signed 8-bit integers"]
3123pub const hipResourceViewFormat_hipResViewFormatSignedChar2: hipResourceViewFormat = 5;
3124#[doc = "< 4 channels, signed 8-bit integers"]
3125pub const hipResourceViewFormat_hipResViewFormatSignedChar4: hipResourceViewFormat = 6;
3126#[doc = "< 1 channel, unsigned 16-bit integers"]
3127pub const hipResourceViewFormat_hipResViewFormatUnsignedShort1: hipResourceViewFormat = 7;
3128#[doc = "< 2 channels, unsigned 16-bit integers"]
3129pub const hipResourceViewFormat_hipResViewFormatUnsignedShort2: hipResourceViewFormat = 8;
3130#[doc = "< 4 channels, unsigned 16-bit integers"]
3131pub const hipResourceViewFormat_hipResViewFormatUnsignedShort4: hipResourceViewFormat = 9;
3132#[doc = "< 1 channel, signed 16-bit integers"]
3133pub const hipResourceViewFormat_hipResViewFormatSignedShort1: hipResourceViewFormat = 10;
3134#[doc = "< 2 channels, signed 16-bit integers"]
3135pub const hipResourceViewFormat_hipResViewFormatSignedShort2: hipResourceViewFormat = 11;
3136#[doc = "< 4 channels, signed 16-bit integers"]
3137pub const hipResourceViewFormat_hipResViewFormatSignedShort4: hipResourceViewFormat = 12;
3138#[doc = "< 1 channel, unsigned 32-bit integers"]
3139pub const hipResourceViewFormat_hipResViewFormatUnsignedInt1: hipResourceViewFormat = 13;
3140#[doc = "< 2 channels, unsigned 32-bit integers"]
3141pub const hipResourceViewFormat_hipResViewFormatUnsignedInt2: hipResourceViewFormat = 14;
3142#[doc = "< 4 channels, unsigned 32-bit integers"]
3143pub const hipResourceViewFormat_hipResViewFormatUnsignedInt4: hipResourceViewFormat = 15;
3144#[doc = "< 1 channel, signed 32-bit integers"]
3145pub const hipResourceViewFormat_hipResViewFormatSignedInt1: hipResourceViewFormat = 16;
3146#[doc = "< 2 channels, signed 32-bit integers"]
3147pub const hipResourceViewFormat_hipResViewFormatSignedInt2: hipResourceViewFormat = 17;
3148#[doc = "< 4 channels, signed 32-bit integers"]
3149pub const hipResourceViewFormat_hipResViewFormatSignedInt4: hipResourceViewFormat = 18;
3150#[doc = "< 1 channel, 16-bit floating point"]
3151pub const hipResourceViewFormat_hipResViewFormatHalf1: hipResourceViewFormat = 19;
3152#[doc = "< 2 channels, 16-bit floating point"]
3153pub const hipResourceViewFormat_hipResViewFormatHalf2: hipResourceViewFormat = 20;
3154#[doc = "< 4 channels, 16-bit floating point"]
3155pub const hipResourceViewFormat_hipResViewFormatHalf4: hipResourceViewFormat = 21;
3156#[doc = "< 1 channel, 32-bit floating point"]
3157pub const hipResourceViewFormat_hipResViewFormatFloat1: hipResourceViewFormat = 22;
3158#[doc = "< 2 channels, 32-bit floating point"]
3159pub const hipResourceViewFormat_hipResViewFormatFloat2: hipResourceViewFormat = 23;
3160#[doc = "< 4 channels, 32-bit floating point"]
3161pub const hipResourceViewFormat_hipResViewFormatFloat4: hipResourceViewFormat = 24;
3162#[doc = "< Block-compressed 1"]
3163pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed1: hipResourceViewFormat =
3164 25;
3165#[doc = "< Block-compressed 2"]
3166pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed2: hipResourceViewFormat =
3167 26;
3168#[doc = "< Block-compressed 3"]
3169pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed3: hipResourceViewFormat =
3170 27;
3171#[doc = "< Block-compressed 4 unsigned"]
3172pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed4: hipResourceViewFormat =
3173 28;
3174#[doc = "< Block-compressed 4 signed"]
3175pub const hipResourceViewFormat_hipResViewFormatSignedBlockCompressed4: hipResourceViewFormat = 29;
3176#[doc = "< Block-compressed 5 unsigned"]
3177pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed5: hipResourceViewFormat =
3178 30;
3179#[doc = "< Block-compressed 5 signed"]
3180pub const hipResourceViewFormat_hipResViewFormatSignedBlockCompressed5: hipResourceViewFormat = 31;
3181#[doc = "< Block-compressed 6 unsigned half-float"]
3182pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed6H: hipResourceViewFormat =
3183 32;
3184#[doc = "< Block-compressed 6 signed half-float"]
3185pub const hipResourceViewFormat_hipResViewFormatSignedBlockCompressed6H: hipResourceViewFormat = 33;
3186#[doc = "< Block-compressed 7"]
3187pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed7: hipResourceViewFormat =
3188 34;
3189#[doc = " HIP texture resource view formats"]
3190pub type hipResourceViewFormat = ::std::os::raw::c_uint;
3191#[doc = "< No resource view format (use underlying resource format)"]
3192pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_NONE: HIPresourceViewFormat_enum = 0;
3193#[doc = "< 1 channel, unsigned 8-bit integers"]
3194pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_1X8: HIPresourceViewFormat_enum = 1;
3195#[doc = "< 2 channels, unsigned 8-bit integers"]
3196pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_2X8: HIPresourceViewFormat_enum = 2;
3197#[doc = "< 4 channels, unsigned 8-bit integers"]
3198pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_4X8: HIPresourceViewFormat_enum = 3;
3199#[doc = "< 1 channel, signed 8-bit integers"]
3200pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_1X8: HIPresourceViewFormat_enum = 4;
3201#[doc = "< 2 channels, signed 8-bit integers"]
3202pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_2X8: HIPresourceViewFormat_enum = 5;
3203#[doc = "< 4 channels, signed 8-bit integers"]
3204pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_4X8: HIPresourceViewFormat_enum = 6;
3205#[doc = "< 1 channel, unsigned 16-bit integers"]
3206pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_1X16: HIPresourceViewFormat_enum = 7;
3207#[doc = "< 2 channels, unsigned 16-bit integers"]
3208pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_2X16: HIPresourceViewFormat_enum = 8;
3209#[doc = "< 4 channels, unsigned 16-bit integers"]
3210pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_4X16: HIPresourceViewFormat_enum = 9;
3211#[doc = "< 1 channel, signed 16-bit integers"]
3212pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_1X16: HIPresourceViewFormat_enum = 10;
3213#[doc = "< 2 channels, signed 16-bit integers"]
3214pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_2X16: HIPresourceViewFormat_enum = 11;
3215#[doc = "< 4 channels, signed 16-bit integers"]
3216pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_4X16: HIPresourceViewFormat_enum = 12;
3217#[doc = "< 1 channel, unsigned 32-bit integers"]
3218pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_1X32: HIPresourceViewFormat_enum = 13;
3219#[doc = "< 2 channels, unsigned 32-bit integers"]
3220pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_2X32: HIPresourceViewFormat_enum = 14;
3221#[doc = "< 4 channels, unsigned 32-bit integers"]
3222pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_4X32: HIPresourceViewFormat_enum = 15;
3223#[doc = "< 1 channel, signed 32-bit integers"]
3224pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_1X32: HIPresourceViewFormat_enum = 16;
3225#[doc = "< 2 channels, signed 32-bit integers"]
3226pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_2X32: HIPresourceViewFormat_enum = 17;
3227#[doc = "< 4 channels, signed 32-bit integers"]
3228pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_4X32: HIPresourceViewFormat_enum = 18;
3229#[doc = "< 1 channel, 16-bit floating point"]
3230pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_1X16: HIPresourceViewFormat_enum =
3231 19;
3232#[doc = "< 2 channels, 16-bit floating point"]
3233pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_2X16: HIPresourceViewFormat_enum =
3234 20;
3235#[doc = "< 4 channels, 16-bit floating point"]
3236pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_4X16: HIPresourceViewFormat_enum =
3237 21;
3238#[doc = "< 1 channel, 32-bit floating point"]
3239pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_1X32: HIPresourceViewFormat_enum =
3240 22;
3241#[doc = "< 2 channels, 32-bit floating point"]
3242pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_2X32: HIPresourceViewFormat_enum =
3243 23;
3244#[doc = "< 4 channels, 32-bit floating point"]
3245pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_4X32: HIPresourceViewFormat_enum =
3246 24;
3247#[doc = "< Block-compressed 1"]
3248pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC1: HIPresourceViewFormat_enum =
3249 25;
3250#[doc = "< Block-compressed 2"]
3251pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC2: HIPresourceViewFormat_enum =
3252 26;
3253#[doc = "< Block-compressed 3"]
3254pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC3: HIPresourceViewFormat_enum =
3255 27;
3256#[doc = "< Block-compressed 4 unsigned"]
3257pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC4: HIPresourceViewFormat_enum =
3258 28;
3259#[doc = "< Block-compressed 4 signed"]
3260pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SIGNED_BC4: HIPresourceViewFormat_enum =
3261 29;
3262#[doc = "< Block-compressed 5 unsigned"]
3263pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC5: HIPresourceViewFormat_enum =
3264 30;
3265#[doc = "< Block-compressed 5 signed"]
3266pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SIGNED_BC5: HIPresourceViewFormat_enum =
3267 31;
3268#[doc = "< Block-compressed 6 unsigned half-float"]
3269pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H: HIPresourceViewFormat_enum =
3270 32;
3271#[doc = "< Block-compressed 6 signed half-float"]
3272pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SIGNED_BC6H: HIPresourceViewFormat_enum =
3273 33;
3274#[doc = "< Block-compressed 7"]
3275pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC7: HIPresourceViewFormat_enum =
3276 34;
3277#[doc = " HIP texture resource view formats"]
3278pub type HIPresourceViewFormat_enum = ::std::os::raw::c_uint;
3279#[doc = " HIP texture resource view formats"]
3280pub use self::HIPresourceViewFormat_enum as HIPresourceViewFormat;
3281#[doc = " HIP resource descriptor"]
3282#[repr(C)]
3283#[derive(Copy, Clone)]
3284pub struct hipResourceDesc {
3285 #[doc = "< Resource type"]
3286 pub resType: hipResourceType,
3287 pub res: hipResourceDesc__bindgen_ty_1,
3288}
3289#[repr(C)]
3290#[derive(Copy, Clone)]
3291pub union hipResourceDesc__bindgen_ty_1 {
3292 pub array: hipResourceDesc__bindgen_ty_1__bindgen_ty_1,
3293 pub mipmap: hipResourceDesc__bindgen_ty_1__bindgen_ty_2,
3294 pub linear: hipResourceDesc__bindgen_ty_1__bindgen_ty_3,
3295 pub pitch2D: hipResourceDesc__bindgen_ty_1__bindgen_ty_4,
3296}
3297#[repr(C)]
3298#[derive(Debug, Copy, Clone)]
3299pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_1 {
3300 #[doc = "< HIP array"]
3301 pub array: hipArray_t,
3302}
3303#[repr(C)]
3304#[derive(Debug, Copy, Clone)]
3305pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_2 {
3306 #[doc = "< HIP mipmapped array"]
3307 pub mipmap: hipMipmappedArray_t,
3308}
3309#[repr(C)]
3310#[derive(Debug, Copy, Clone)]
3311pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_3 {
3312 #[doc = "< Device pointer"]
3313 pub devPtr: *mut ::std::os::raw::c_void,
3314 #[doc = "< Channel format description"]
3315 pub desc: hipChannelFormatDesc,
3316 #[doc = "< Size in bytes"]
3317 pub sizeInBytes: usize,
3318}
3319#[repr(C)]
3320#[derive(Debug, Copy, Clone)]
3321pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_4 {
3322 #[doc = "< Device pointer"]
3323 pub devPtr: *mut ::std::os::raw::c_void,
3324 #[doc = "< Channel format description"]
3325 pub desc: hipChannelFormatDesc,
3326 #[doc = "< Width of the array in elements"]
3327 pub width: usize,
3328 #[doc = "< Height of the array in elements"]
3329 pub height: usize,
3330 #[doc = "< Pitch between two rows in bytes"]
3331 pub pitchInBytes: usize,
3332}
3333#[doc = " HIP resource view descriptor struct"]
3334#[repr(C)]
3335#[derive(Copy, Clone)]
3336pub struct HIP_RESOURCE_DESC_st {
3337 #[doc = "< Resource type"]
3338 pub resType: HIPresourcetype,
3339 pub res: HIP_RESOURCE_DESC_st__bindgen_ty_1,
3340 #[doc = "< Flags (must be zero)"]
3341 pub flags: ::std::os::raw::c_uint,
3342}
3343#[repr(C)]
3344#[derive(Copy, Clone)]
3345pub union HIP_RESOURCE_DESC_st__bindgen_ty_1 {
3346 pub array: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1,
3347 pub mipmap: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2,
3348 pub linear: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
3349 pub pitch2D: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
3350 pub reserved: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
3351}
3352#[repr(C)]
3353#[derive(Debug, Copy, Clone)]
3354pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
3355 #[doc = "< HIP array"]
3356 pub hArray: hipArray_t,
3357}
3358#[repr(C)]
3359#[derive(Debug, Copy, Clone)]
3360pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
3361 #[doc = "< HIP mipmapped array"]
3362 pub hMipmappedArray: hipMipmappedArray_t,
3363}
3364#[repr(C)]
3365#[derive(Debug, Copy, Clone)]
3366pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
3367 #[doc = "< Device pointer"]
3368 pub devPtr: hipDeviceptr_t,
3369 #[doc = "< Array format"]
3370 pub format: hipArray_Format,
3371 #[doc = "< Channels per array element"]
3372 pub numChannels: ::std::os::raw::c_uint,
3373 #[doc = "< Size in bytes"]
3374 pub sizeInBytes: usize,
3375}
3376#[repr(C)]
3377#[derive(Debug, Copy, Clone)]
3378pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
3379 #[doc = "< Device pointer"]
3380 pub devPtr: hipDeviceptr_t,
3381 #[doc = "< Array format"]
3382 pub format: hipArray_Format,
3383 #[doc = "< Channels per array element"]
3384 pub numChannels: ::std::os::raw::c_uint,
3385 #[doc = "< Width of the array in elements"]
3386 pub width: usize,
3387 #[doc = "< Height of the array in elements"]
3388 pub height: usize,
3389 #[doc = "< Pitch between two rows in bytes"]
3390 pub pitchInBytes: usize,
3391}
3392#[repr(C)]
3393#[derive(Debug, Copy, Clone)]
3394pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
3395 pub reserved: [::std::os::raw::c_int; 32usize],
3396}
3397#[doc = " HIP resource view descriptor struct"]
3398pub type HIP_RESOURCE_DESC = HIP_RESOURCE_DESC_st;
3399#[doc = " HIP resource view descriptor"]
3400#[repr(C)]
3401#[derive(Debug, Copy, Clone)]
3402pub struct hipResourceViewDesc {
3403 #[doc = "< Resource view format"]
3404 pub format: hipResourceViewFormat,
3405 #[doc = "< Width of the resource view"]
3406 pub width: usize,
3407 #[doc = "< Height of the resource view"]
3408 pub height: usize,
3409 #[doc = "< Depth of the resource view"]
3410 pub depth: usize,
3411 #[doc = "< First defined mipmap level"]
3412 pub firstMipmapLevel: ::std::os::raw::c_uint,
3413 #[doc = "< Last defined mipmap level"]
3414 pub lastMipmapLevel: ::std::os::raw::c_uint,
3415 #[doc = "< First layer index"]
3416 pub firstLayer: ::std::os::raw::c_uint,
3417 #[doc = "< Last layer index"]
3418 pub lastLayer: ::std::os::raw::c_uint,
3419}
3420#[doc = " Resource view descriptor"]
3421#[repr(C)]
3422#[derive(Debug, Copy, Clone)]
3423pub struct HIP_RESOURCE_VIEW_DESC_st {
3424 #[doc = "< Resource view format"]
3425 pub format: HIPresourceViewFormat,
3426 #[doc = "< Width of the resource view"]
3427 pub width: usize,
3428 #[doc = "< Height of the resource view"]
3429 pub height: usize,
3430 #[doc = "< Depth of the resource view"]
3431 pub depth: usize,
3432 #[doc = "< First defined mipmap level"]
3433 pub firstMipmapLevel: ::std::os::raw::c_uint,
3434 #[doc = "< Last defined mipmap level"]
3435 pub lastMipmapLevel: ::std::os::raw::c_uint,
3436 #[doc = "< First layer index"]
3437 pub firstLayer: ::std::os::raw::c_uint,
3438 #[doc = "< Last layer index"]
3439 pub lastLayer: ::std::os::raw::c_uint,
3440 pub reserved: [::std::os::raw::c_uint; 16usize],
3441}
3442#[doc = " Resource view descriptor"]
3443pub type HIP_RESOURCE_VIEW_DESC = HIP_RESOURCE_VIEW_DESC_st;
3444#[doc = "< Host-to-Host Copy"]
3445pub const hipMemcpyKind_hipMemcpyHostToHost: hipMemcpyKind = 0;
3446#[doc = "< Host-to-Device Copy"]
3447pub const hipMemcpyKind_hipMemcpyHostToDevice: hipMemcpyKind = 1;
3448#[doc = "< Device-to-Host Copy"]
3449pub const hipMemcpyKind_hipMemcpyDeviceToHost: hipMemcpyKind = 2;
3450#[doc = "< Device-to-Device Copy"]
3451pub const hipMemcpyKind_hipMemcpyDeviceToDevice: hipMemcpyKind = 3;
3452#[doc = "< Runtime will automatically determine\n<copy-kind based on virtual addresses."]
3453pub const hipMemcpyKind_hipMemcpyDefault: hipMemcpyKind = 4;
3454#[doc = "< Device-to-Device Copy without using compute units"]
3455pub const hipMemcpyKind_hipMemcpyDeviceToDeviceNoCU: hipMemcpyKind = 1024;
3456pub type hipMemcpyKind = ::std::os::raw::c_uint;
3457#[doc = " HIP pithed pointer"]
3458#[repr(C)]
3459#[derive(Debug, Copy, Clone)]
3460pub struct hipPitchedPtr {
3461 #[doc = "< Pointer to the allocated memory"]
3462 pub ptr: *mut ::std::os::raw::c_void,
3463 #[doc = "< Pitch in bytes"]
3464 pub pitch: usize,
3465 #[doc = "< Logical size of the first dimension of allocation in elements"]
3466 pub xsize: usize,
3467 #[doc = "< Logical size of the second dimension of allocation in elements"]
3468 pub ysize: usize,
3469}
3470#[doc = " HIP extent"]
3471#[repr(C)]
3472#[derive(Debug, Copy, Clone)]
3473pub struct hipExtent {
3474 pub width: usize,
3475 pub height: usize,
3476 pub depth: usize,
3477}
3478#[doc = " HIP position"]
3479#[repr(C)]
3480#[derive(Debug, Copy, Clone)]
3481pub struct hipPos {
3482 #[doc = "< X coordinate"]
3483 pub x: usize,
3484 #[doc = "< Y coordinate"]
3485 pub y: usize,
3486 #[doc = "< Z coordinate"]
3487 pub z: usize,
3488}
3489#[doc = " HIP 3D memory copy parameters"]
3490#[repr(C)]
3491#[derive(Debug, Copy, Clone)]
3492pub struct hipMemcpy3DParms {
3493 #[doc = "< Source array"]
3494 pub srcArray: hipArray_t,
3495 #[doc = "< Source position"]
3496 pub srcPos: hipPos,
3497 #[doc = "< Source pointer"]
3498 pub srcPtr: hipPitchedPtr,
3499 #[doc = "< Destination array"]
3500 pub dstArray: hipArray_t,
3501 #[doc = "< Destination position"]
3502 pub dstPos: hipPos,
3503 #[doc = "< Destination pointer"]
3504 pub dstPtr: hipPitchedPtr,
3505 #[doc = "< Extent of 3D memory copy"]
3506 pub extent: hipExtent,
3507 #[doc = "< Kind of 3D memory copy"]
3508 pub kind: hipMemcpyKind,
3509}
3510#[doc = " HIP 3D memory copy"]
3511#[repr(C)]
3512#[derive(Debug, Copy, Clone)]
3513pub struct HIP_MEMCPY3D {
3514 #[doc = "< Source X in bytes"]
3515 pub srcXInBytes: usize,
3516 #[doc = "< Source Y"]
3517 pub srcY: usize,
3518 #[doc = "< Source Z"]
3519 pub srcZ: usize,
3520 #[doc = "< Source LOD"]
3521 pub srcLOD: usize,
3522 #[doc = "< Source memory type"]
3523 pub srcMemoryType: hipMemoryType,
3524 #[doc = "< Source host pointer"]
3525 pub srcHost: *const ::std::os::raw::c_void,
3526 #[doc = "< Source device"]
3527 pub srcDevice: hipDeviceptr_t,
3528 #[doc = "< Source array"]
3529 pub srcArray: hipArray_t,
3530 #[doc = "< Source pitch"]
3531 pub srcPitch: usize,
3532 #[doc = "< Source height"]
3533 pub srcHeight: usize,
3534 #[doc = "< Destination X in bytes"]
3535 pub dstXInBytes: usize,
3536 #[doc = "< Destination Y"]
3537 pub dstY: usize,
3538 #[doc = "< Destination Z"]
3539 pub dstZ: usize,
3540 #[doc = "< Destination LOD"]
3541 pub dstLOD: usize,
3542 #[doc = "< Destination memory type"]
3543 pub dstMemoryType: hipMemoryType,
3544 #[doc = "< Destination host pointer"]
3545 pub dstHost: *mut ::std::os::raw::c_void,
3546 #[doc = "< Destination device"]
3547 pub dstDevice: hipDeviceptr_t,
3548 #[doc = "< Destination array"]
3549 pub dstArray: hipArray_t,
3550 #[doc = "< Destination pitch"]
3551 pub dstPitch: usize,
3552 #[doc = "< Destination height"]
3553 pub dstHeight: usize,
3554 #[doc = "< Width in bytes of 3D memory copy"]
3555 pub WidthInBytes: usize,
3556 #[doc = "< Height in bytes of 3D memory copy"]
3557 pub Height: usize,
3558 #[doc = "< Depth in bytes of 3D memory copy"]
3559 pub Depth: usize,
3560}
3561#[doc = "< The maximum number of threads per block. Depends on function and device."]
3562pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK: hipFunction_attribute = 0;
3563#[doc = "< The statically allocated shared memory size in bytes per block required by the function."]
3564pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES: hipFunction_attribute = 1;
3565#[doc = "< The user-allocated constant memory by the function in bytes."]
3566pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES: hipFunction_attribute = 2;
3567#[doc = "< The local memory usage of each thread by this function in bytes."]
3568pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES: hipFunction_attribute = 3;
3569#[doc = "< The number of registers used by each thread of this function."]
3570pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_NUM_REGS: hipFunction_attribute = 4;
3571#[doc = "< PTX version"]
3572pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_PTX_VERSION: hipFunction_attribute = 5;
3573#[doc = "< Binary version"]
3574pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_BINARY_VERSION: hipFunction_attribute = 6;
3575#[doc = "< Cache mode"]
3576pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA: hipFunction_attribute = 7;
3577#[doc = "< The maximum dynamic shared memory per block for this function in bytes."]
3578pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES:
3579 hipFunction_attribute = 8;
3580#[doc = "< The shared memory carveout preference in percent of the maximum shared memory."]
3581pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT:
3582 hipFunction_attribute = 9;
3583pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_MAX: hipFunction_attribute = 10;
3584pub type hipFunction_attribute = ::std::os::raw::c_uint;
3585#[doc = "< The context on which a pointer was allocated\n< @warning This attribute is not supported in HIP"]
3586pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_CONTEXT: hipPointer_attribute = 1;
3587#[doc = "< memory type describing the location of a pointer"]
3588pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_MEMORY_TYPE: hipPointer_attribute = 2;
3589#[doc = "< address at which the pointer is allocated on the device"]
3590pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_DEVICE_POINTER: hipPointer_attribute = 3;
3591#[doc = "< address at which the pointer is allocated on the host"]
3592pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_HOST_POINTER: hipPointer_attribute = 4;
3593#[doc = "< A pair of tokens for use with Linux kernel interface\n< @warning This attribute is not supported in HIP"]
3594pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_P2P_TOKENS: hipPointer_attribute = 5;
3595#[doc = "< Synchronize every synchronous memory operation\n< initiated on this region"]
3596pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS: hipPointer_attribute = 6;
3597#[doc = "< Unique ID for an allocated memory region"]
3598pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_BUFFER_ID: hipPointer_attribute = 7;
3599#[doc = "< Indicates if the pointer points to managed memory"]
3600pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_IS_MANAGED: hipPointer_attribute = 8;
3601#[doc = "< device ordinal of a device on which a pointer\n< was allocated or registered"]
3602pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL: hipPointer_attribute = 9;
3603#[doc = "< if this pointer maps to an allocation\n< that is suitable for hipIpcGetMemHandle\n< @warning This attribute is not supported in HIP"]
3604pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE:
3605 hipPointer_attribute = 10;
3606#[doc = "< Starting address for this requested pointer"]
3607pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR: hipPointer_attribute = 11;
3608#[doc = "< Size of the address range for this requested pointer"]
3609pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_RANGE_SIZE: hipPointer_attribute = 12;
3610#[doc = "< tells if this pointer is in a valid address range\n< that is mapped to a backing allocation"]
3611pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_MAPPED: hipPointer_attribute = 13;
3612#[doc = "< Bitmask of allowed hipmemAllocationHandleType\n< for this allocation @warning This attribute is not supported in HIP"]
3613pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES: hipPointer_attribute =
3614 14;
3615#[doc = "< returns if the memory referenced by\n< this pointer can be used with the GPUDirect RDMA API\n< @warning This attribute is not supported in HIP"]
3616pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE:
3617 hipPointer_attribute = 15;
3618#[doc = "< Returns the access flags the device associated with\n< for the corresponding memory referenced by the ptr"]
3619pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS: hipPointer_attribute = 16;
3620#[doc = "< Returns the mempool handle for the allocation if\n< it was allocated from a mempool\n< @warning This attribute is not supported in HIP"]
3621pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE: hipPointer_attribute = 17;
3622pub type hipPointer_attribute = ::std::os::raw::c_uint;
3623#[repr(C)]
3624#[derive(Debug, Copy, Clone)]
3625pub struct uchar1 {
3626 pub x: ::std::os::raw::c_uchar,
3627}
3628#[repr(C)]
3629#[derive(Debug, Copy, Clone)]
3630pub struct uchar2 {
3631 pub x: ::std::os::raw::c_uchar,
3632 pub y: ::std::os::raw::c_uchar,
3633}
3634#[repr(C)]
3635#[derive(Debug, Copy, Clone)]
3636pub struct uchar3 {
3637 pub x: ::std::os::raw::c_uchar,
3638 pub y: ::std::os::raw::c_uchar,
3639 pub z: ::std::os::raw::c_uchar,
3640}
3641#[repr(C)]
3642#[derive(Debug, Copy, Clone)]
3643pub struct uchar4 {
3644 pub x: ::std::os::raw::c_uchar,
3645 pub y: ::std::os::raw::c_uchar,
3646 pub z: ::std::os::raw::c_uchar,
3647 pub w: ::std::os::raw::c_uchar,
3648}
3649#[repr(C)]
3650#[derive(Debug, Copy, Clone)]
3651pub struct char1 {
3652 pub x: ::std::os::raw::c_char,
3653}
3654#[repr(C)]
3655#[derive(Debug, Copy, Clone)]
3656pub struct char2 {
3657 pub x: ::std::os::raw::c_char,
3658 pub y: ::std::os::raw::c_char,
3659}
3660#[repr(C)]
3661#[derive(Debug, Copy, Clone)]
3662pub struct char3 {
3663 pub x: ::std::os::raw::c_char,
3664 pub y: ::std::os::raw::c_char,
3665 pub z: ::std::os::raw::c_char,
3666}
3667#[repr(C)]
3668#[derive(Debug, Copy, Clone)]
3669pub struct char4 {
3670 pub x: ::std::os::raw::c_char,
3671 pub y: ::std::os::raw::c_char,
3672 pub z: ::std::os::raw::c_char,
3673 pub w: ::std::os::raw::c_char,
3674}
3675#[repr(C)]
3676#[derive(Debug, Copy, Clone)]
3677pub struct ushort1 {
3678 pub x: ::std::os::raw::c_ushort,
3679}
3680#[repr(C)]
3681#[derive(Debug, Copy, Clone)]
3682pub struct ushort2 {
3683 pub x: ::std::os::raw::c_ushort,
3684 pub y: ::std::os::raw::c_ushort,
3685}
3686#[repr(C)]
3687#[derive(Debug, Copy, Clone)]
3688pub struct ushort3 {
3689 pub x: ::std::os::raw::c_ushort,
3690 pub y: ::std::os::raw::c_ushort,
3691 pub z: ::std::os::raw::c_ushort,
3692}
3693#[repr(C)]
3694#[derive(Debug, Copy, Clone)]
3695pub struct ushort4 {
3696 pub x: ::std::os::raw::c_ushort,
3697 pub y: ::std::os::raw::c_ushort,
3698 pub z: ::std::os::raw::c_ushort,
3699 pub w: ::std::os::raw::c_ushort,
3700}
3701#[repr(C)]
3702#[derive(Debug, Copy, Clone)]
3703pub struct short1 {
3704 pub x: ::std::os::raw::c_short,
3705}
3706#[repr(C)]
3707#[derive(Debug, Copy, Clone)]
3708pub struct short2 {
3709 pub x: ::std::os::raw::c_short,
3710 pub y: ::std::os::raw::c_short,
3711}
3712#[repr(C)]
3713#[derive(Debug, Copy, Clone)]
3714pub struct short3 {
3715 pub x: ::std::os::raw::c_short,
3716 pub y: ::std::os::raw::c_short,
3717 pub z: ::std::os::raw::c_short,
3718}
3719#[repr(C)]
3720#[derive(Debug, Copy, Clone)]
3721pub struct short4 {
3722 pub x: ::std::os::raw::c_short,
3723 pub y: ::std::os::raw::c_short,
3724 pub z: ::std::os::raw::c_short,
3725 pub w: ::std::os::raw::c_short,
3726}
3727#[repr(C)]
3728#[derive(Debug, Copy, Clone)]
3729pub struct uint1 {
3730 pub x: ::std::os::raw::c_uint,
3731}
3732#[repr(C)]
3733#[derive(Debug, Copy, Clone)]
3734pub struct uint2 {
3735 pub x: ::std::os::raw::c_uint,
3736 pub y: ::std::os::raw::c_uint,
3737}
3738#[repr(C)]
3739#[derive(Debug, Copy, Clone)]
3740pub struct uint3 {
3741 pub x: ::std::os::raw::c_uint,
3742 pub y: ::std::os::raw::c_uint,
3743 pub z: ::std::os::raw::c_uint,
3744}
3745#[repr(C)]
3746#[derive(Debug, Copy, Clone)]
3747pub struct uint4 {
3748 pub x: ::std::os::raw::c_uint,
3749 pub y: ::std::os::raw::c_uint,
3750 pub z: ::std::os::raw::c_uint,
3751 pub w: ::std::os::raw::c_uint,
3752}
3753#[repr(C)]
3754#[derive(Debug, Copy, Clone)]
3755pub struct int1 {
3756 pub x: ::std::os::raw::c_int,
3757}
3758#[repr(C)]
3759#[derive(Debug, Copy, Clone)]
3760pub struct int2 {
3761 pub x: ::std::os::raw::c_int,
3762 pub y: ::std::os::raw::c_int,
3763}
3764#[repr(C)]
3765#[derive(Debug, Copy, Clone)]
3766pub struct int3 {
3767 pub x: ::std::os::raw::c_int,
3768 pub y: ::std::os::raw::c_int,
3769 pub z: ::std::os::raw::c_int,
3770}
3771#[repr(C)]
3772#[derive(Debug, Copy, Clone)]
3773pub struct int4 {
3774 pub x: ::std::os::raw::c_int,
3775 pub y: ::std::os::raw::c_int,
3776 pub z: ::std::os::raw::c_int,
3777 pub w: ::std::os::raw::c_int,
3778}
3779#[repr(C)]
3780#[derive(Debug, Copy, Clone)]
3781pub struct ulong1 {
3782 pub x: ::std::os::raw::c_ulong,
3783}
3784#[repr(C)]
3785#[derive(Debug, Copy, Clone)]
3786pub struct ulong2 {
3787 pub x: ::std::os::raw::c_ulong,
3788 pub y: ::std::os::raw::c_ulong,
3789}
3790#[repr(C)]
3791#[derive(Debug, Copy, Clone)]
3792pub struct ulong3 {
3793 pub x: ::std::os::raw::c_ulong,
3794 pub y: ::std::os::raw::c_ulong,
3795 pub z: ::std::os::raw::c_ulong,
3796}
3797#[repr(C)]
3798#[derive(Debug, Copy, Clone)]
3799pub struct ulong4 {
3800 pub x: ::std::os::raw::c_ulong,
3801 pub y: ::std::os::raw::c_ulong,
3802 pub z: ::std::os::raw::c_ulong,
3803 pub w: ::std::os::raw::c_ulong,
3804}
3805#[repr(C)]
3806#[derive(Debug, Copy, Clone)]
3807pub struct long1 {
3808 pub x: ::std::os::raw::c_long,
3809}
3810#[repr(C)]
3811#[derive(Debug, Copy, Clone)]
3812pub struct long2 {
3813 pub x: ::std::os::raw::c_long,
3814 pub y: ::std::os::raw::c_long,
3815}
3816#[repr(C)]
3817#[derive(Debug, Copy, Clone)]
3818pub struct long3 {
3819 pub x: ::std::os::raw::c_long,
3820 pub y: ::std::os::raw::c_long,
3821 pub z: ::std::os::raw::c_long,
3822}
3823#[repr(C)]
3824#[derive(Debug, Copy, Clone)]
3825pub struct long4 {
3826 pub x: ::std::os::raw::c_long,
3827 pub y: ::std::os::raw::c_long,
3828 pub z: ::std::os::raw::c_long,
3829 pub w: ::std::os::raw::c_long,
3830}
3831#[repr(C)]
3832#[derive(Debug, Copy, Clone)]
3833pub struct ulonglong1 {
3834 pub x: ::std::os::raw::c_ulonglong,
3835}
3836#[repr(C)]
3837#[derive(Debug, Copy, Clone)]
3838pub struct ulonglong2 {
3839 pub x: ::std::os::raw::c_ulonglong,
3840 pub y: ::std::os::raw::c_ulonglong,
3841}
3842#[repr(C)]
3843#[derive(Debug, Copy, Clone)]
3844pub struct ulonglong3 {
3845 pub x: ::std::os::raw::c_ulonglong,
3846 pub y: ::std::os::raw::c_ulonglong,
3847 pub z: ::std::os::raw::c_ulonglong,
3848}
3849#[repr(C)]
3850#[derive(Debug, Copy, Clone)]
3851pub struct ulonglong4 {
3852 pub x: ::std::os::raw::c_ulonglong,
3853 pub y: ::std::os::raw::c_ulonglong,
3854 pub z: ::std::os::raw::c_ulonglong,
3855 pub w: ::std::os::raw::c_ulonglong,
3856}
3857#[repr(C)]
3858#[derive(Debug, Copy, Clone)]
3859pub struct longlong1 {
3860 pub x: ::std::os::raw::c_longlong,
3861}
3862#[repr(C)]
3863#[derive(Debug, Copy, Clone)]
3864pub struct longlong2 {
3865 pub x: ::std::os::raw::c_longlong,
3866 pub y: ::std::os::raw::c_longlong,
3867}
3868#[repr(C)]
3869#[derive(Debug, Copy, Clone)]
3870pub struct longlong3 {
3871 pub x: ::std::os::raw::c_longlong,
3872 pub y: ::std::os::raw::c_longlong,
3873 pub z: ::std::os::raw::c_longlong,
3874}
3875#[repr(C)]
3876#[derive(Debug, Copy, Clone)]
3877pub struct longlong4 {
3878 pub x: ::std::os::raw::c_longlong,
3879 pub y: ::std::os::raw::c_longlong,
3880 pub z: ::std::os::raw::c_longlong,
3881 pub w: ::std::os::raw::c_longlong,
3882}
3883#[repr(C)]
3884#[derive(Debug, Copy, Clone)]
3885pub struct float1 {
3886 pub x: f32,
3887}
3888#[repr(C)]
3889#[derive(Debug, Copy, Clone)]
3890pub struct float2 {
3891 pub x: f32,
3892 pub y: f32,
3893}
3894#[repr(C)]
3895#[derive(Debug, Copy, Clone)]
3896pub struct float3 {
3897 pub x: f32,
3898 pub y: f32,
3899 pub z: f32,
3900}
3901#[repr(C)]
3902#[derive(Debug, Copy, Clone)]
3903pub struct float4 {
3904 pub x: f32,
3905 pub y: f32,
3906 pub z: f32,
3907 pub w: f32,
3908}
3909#[repr(C)]
3910#[derive(Debug, Copy, Clone)]
3911pub struct double1 {
3912 pub x: f64,
3913}
3914#[repr(C)]
3915#[derive(Debug, Copy, Clone)]
3916pub struct double2 {
3917 pub x: f64,
3918 pub y: f64,
3919}
3920#[repr(C)]
3921#[derive(Debug, Copy, Clone)]
3922pub struct double3 {
3923 pub x: f64,
3924 pub y: f64,
3925 pub z: f64,
3926}
3927#[repr(C)]
3928#[derive(Debug, Copy, Clone)]
3929pub struct double4 {
3930 pub x: f64,
3931 pub y: f64,
3932 pub z: f64,
3933 pub w: f64,
3934}
3935extern "C" {
3936 pub fn hipCreateChannelDesc(
3937 x: ::std::os::raw::c_int,
3938 y: ::std::os::raw::c_int,
3939 z: ::std::os::raw::c_int,
3940 w: ::std::os::raw::c_int,
3941 f: hipChannelFormatKind,
3942 ) -> hipChannelFormatDesc;
3943}
3944#[doc = " An opaque value that represents a hip texture object"]
3945#[repr(C)]
3946#[derive(Debug, Copy, Clone)]
3947pub struct __hip_texture {
3948 _unused: [u8; 0],
3949}
3950pub type hipTextureObject_t = *mut __hip_texture;
3951pub const hipTextureAddressMode_hipAddressModeWrap: hipTextureAddressMode = 0;
3952pub const hipTextureAddressMode_hipAddressModeClamp: hipTextureAddressMode = 1;
3953pub const hipTextureAddressMode_hipAddressModeMirror: hipTextureAddressMode = 2;
3954pub const hipTextureAddressMode_hipAddressModeBorder: hipTextureAddressMode = 3;
3955#[doc = " hip texture address modes"]
3956pub type hipTextureAddressMode = ::std::os::raw::c_uint;
3957pub const hipTextureFilterMode_hipFilterModePoint: hipTextureFilterMode = 0;
3958pub const hipTextureFilterMode_hipFilterModeLinear: hipTextureFilterMode = 1;
3959#[doc = " hip texture filter modes"]
3960pub type hipTextureFilterMode = ::std::os::raw::c_uint;
3961pub const hipTextureReadMode_hipReadModeElementType: hipTextureReadMode = 0;
3962pub const hipTextureReadMode_hipReadModeNormalizedFloat: hipTextureReadMode = 1;
3963#[doc = " hip texture read modes"]
3964pub type hipTextureReadMode = ::std::os::raw::c_uint;
3965#[doc = " hip texture reference"]
3966#[repr(C)]
3967#[derive(Debug, Copy, Clone)]
3968pub struct textureReference {
3969 pub normalized: ::std::os::raw::c_int,
3970 pub readMode: hipTextureReadMode,
3971 pub filterMode: hipTextureFilterMode,
3972 pub addressMode: [hipTextureAddressMode; 3usize],
3973 pub channelDesc: hipChannelFormatDesc,
3974 pub sRGB: ::std::os::raw::c_int,
3975 pub maxAnisotropy: ::std::os::raw::c_uint,
3976 pub mipmapFilterMode: hipTextureFilterMode,
3977 pub mipmapLevelBias: f32,
3978 pub minMipmapLevelClamp: f32,
3979 pub maxMipmapLevelClamp: f32,
3980 pub textureObject: hipTextureObject_t,
3981 pub numChannels: ::std::os::raw::c_int,
3982 pub format: hipArray_Format,
3983}
3984#[doc = " hip texture descriptor"]
3985#[repr(C)]
3986#[derive(Debug, Copy, Clone)]
3987pub struct hipTextureDesc {
3988 pub addressMode: [hipTextureAddressMode; 3usize],
3989 pub filterMode: hipTextureFilterMode,
3990 pub readMode: hipTextureReadMode,
3991 pub sRGB: ::std::os::raw::c_int,
3992 pub borderColor: [f32; 4usize],
3993 pub normalizedCoords: ::std::os::raw::c_int,
3994 pub maxAnisotropy: ::std::os::raw::c_uint,
3995 pub mipmapFilterMode: hipTextureFilterMode,
3996 pub mipmapLevelBias: f32,
3997 pub minMipmapLevelClamp: f32,
3998 pub maxMipmapLevelClamp: f32,
3999}
4000#[doc = " An opaque value that represents a hip surface object"]
4001#[repr(C)]
4002#[derive(Debug, Copy, Clone)]
4003pub struct __hip_surface {
4004 _unused: [u8; 0],
4005}
4006pub type hipSurfaceObject_t = *mut __hip_surface;
4007#[doc = " hip surface reference"]
4008#[repr(C)]
4009#[derive(Debug, Copy, Clone)]
4010pub struct surfaceReference {
4011 pub surfaceObject: hipSurfaceObject_t,
4012}
4013pub const hipSurfaceBoundaryMode_hipBoundaryModeZero: hipSurfaceBoundaryMode = 0;
4014pub const hipSurfaceBoundaryMode_hipBoundaryModeTrap: hipSurfaceBoundaryMode = 1;
4015pub const hipSurfaceBoundaryMode_hipBoundaryModeClamp: hipSurfaceBoundaryMode = 2;
4016#[doc = " hip surface boundary modes"]
4017pub type hipSurfaceBoundaryMode = ::std::os::raw::c_uint;
4018#[repr(C)]
4019#[derive(Debug, Copy, Clone)]
4020pub struct ihipCtx_t {
4021 _unused: [u8; 0],
4022}
4023pub type hipCtx_t = *mut ihipCtx_t;
4024pub type hipDevice_t = ::std::os::raw::c_int;
4025pub const hipDeviceP2PAttr_hipDevP2PAttrPerformanceRank: hipDeviceP2PAttr = 0;
4026pub const hipDeviceP2PAttr_hipDevP2PAttrAccessSupported: hipDeviceP2PAttr = 1;
4027pub const hipDeviceP2PAttr_hipDevP2PAttrNativeAtomicSupported: hipDeviceP2PAttr = 2;
4028pub const hipDeviceP2PAttr_hipDevP2PAttrHipArrayAccessSupported: hipDeviceP2PAttr = 3;
4029pub type hipDeviceP2PAttr = ::std::os::raw::c_uint;
4030#[repr(C)]
4031#[derive(Debug, Copy, Clone)]
4032pub struct ihipStream_t {
4033 _unused: [u8; 0],
4034}
4035pub type hipStream_t = *mut ihipStream_t;
4036#[repr(C)]
4037#[derive(Debug, Copy, Clone)]
4038pub struct hipIpcMemHandle_st {
4039 pub reserved: [::std::os::raw::c_char; 64usize],
4040}
4041pub type hipIpcMemHandle_t = hipIpcMemHandle_st;
4042#[repr(C)]
4043#[derive(Debug, Copy, Clone)]
4044pub struct hipIpcEventHandle_st {
4045 pub reserved: [::std::os::raw::c_char; 64usize],
4046}
4047pub type hipIpcEventHandle_t = hipIpcEventHandle_st;
4048#[repr(C)]
4049#[derive(Debug, Copy, Clone)]
4050pub struct ihipModule_t {
4051 _unused: [u8; 0],
4052}
4053pub type hipModule_t = *mut ihipModule_t;
4054#[repr(C)]
4055#[derive(Debug, Copy, Clone)]
4056pub struct ihipModuleSymbol_t {
4057 _unused: [u8; 0],
4058}
4059pub type hipFunction_t = *mut ihipModuleSymbol_t;
4060#[repr(C)]
4061#[derive(Debug, Copy, Clone)]
4062pub struct ihipLinkState_t {
4063 _unused: [u8; 0],
4064}
4065pub type hipLinkState_t = *mut ihipLinkState_t;
4066#[repr(C)]
4067#[derive(Debug, Copy, Clone)]
4068pub struct ihipMemPoolHandle_t {
4069 _unused: [u8; 0],
4070}
4071#[doc = " HIP memory pool"]
4072pub type hipMemPool_t = *mut ihipMemPoolHandle_t;
4073#[repr(C)]
4074#[derive(Debug, Copy, Clone)]
4075pub struct hipFuncAttributes {
4076 pub binaryVersion: ::std::os::raw::c_int,
4077 pub cacheModeCA: ::std::os::raw::c_int,
4078 pub constSizeBytes: usize,
4079 pub localSizeBytes: usize,
4080 pub maxDynamicSharedSizeBytes: ::std::os::raw::c_int,
4081 pub maxThreadsPerBlock: ::std::os::raw::c_int,
4082 pub numRegs: ::std::os::raw::c_int,
4083 pub preferredShmemCarveout: ::std::os::raw::c_int,
4084 pub ptxVersion: ::std::os::raw::c_int,
4085 pub sharedSizeBytes: usize,
4086}
4087#[repr(C)]
4088#[derive(Debug, Copy, Clone)]
4089pub struct ihipEvent_t {
4090 _unused: [u8; 0],
4091}
4092pub type hipEvent_t = *mut ihipEvent_t;
4093#[doc = "< Limit of stack size in bytes on the current device, per\n< thread. The size is in units of 256 dwords, up to the\n< limit of (128K - 16)"]
4094pub const hipLimit_t_hipLimitStackSize: hipLimit_t = 0;
4095#[doc = "< Size limit in bytes of fifo used by printf call on the\n< device. Currently not supported"]
4096pub const hipLimit_t_hipLimitPrintfFifoSize: hipLimit_t = 1;
4097#[doc = "< Limit of heap size in bytes on the current device, should\n< be less than the global memory size on the device"]
4098pub const hipLimit_t_hipLimitMallocHeapSize: hipLimit_t = 2;
4099#[doc = "< Supported limit range"]
4100pub const hipLimit_t_hipLimitRange: hipLimit_t = 3;
4101#[doc = " hipLimit\n\n @note In HIP device limit-related APIs, any input limit value other than those defined in the\n enum is treated as \"UnsupportedLimit\" by default."]
4102pub type hipLimit_t = ::std::os::raw::c_uint;
4103pub const hipStreamBatchMemOpType_hipStreamMemOpWaitValue32: hipStreamBatchMemOpType = 1;
4104pub const hipStreamBatchMemOpType_hipStreamMemOpWriteValue32: hipStreamBatchMemOpType = 2;
4105pub const hipStreamBatchMemOpType_hipStreamMemOpWaitValue64: hipStreamBatchMemOpType = 4;
4106pub const hipStreamBatchMemOpType_hipStreamMemOpWriteValue64: hipStreamBatchMemOpType = 5;
4107#[doc = "< Currently not supported"]
4108pub const hipStreamBatchMemOpType_hipStreamMemOpBarrier: hipStreamBatchMemOpType = 6;
4109#[doc = "< Currently not supported"]
4110pub const hipStreamBatchMemOpType_hipStreamMemOpFlushRemoteWrites: hipStreamBatchMemOpType = 3;
4111#[doc = " Operations for hipStreamBatchMemOp"]
4112pub type hipStreamBatchMemOpType = ::std::os::raw::c_uint;
4113#[doc = " @brief Union representing batch memory operation parameters for HIP streams.\n\n hipStreamBatchMemOpParams is used to specify the parameters for batch memory\n operations in a HIP stream. This union supports various operations including\n waiting for a specific value, writing a value, and different flags for wait conditions.\n\n @details\n The union includes fields for different types of operations defined in the\n enum hipStreamBatchMemOpType:\n - hipStreamMemOpWaitValue32: Wait for a 32-bit value.\n - hipStreamMemOpWriteValue32: Write a 32-bit value.\n - hipStreamMemOpWaitValue64: Wait for a 64-bit value.\n - hipStreamMemOpWriteValue64: Write a 64-bit value.\n\n Each operation type includes an address, the value to wait for or write, flags, and an\n optional alias that is not relevant on AMD GPUs. Flags can be used to specify different\n wait conditions such as equality, bitwise AND, greater than or equal, and bitwise NOR.\n\n Example usage:\n @code\n hipStreamBatchMemOpParams myArray[2];\n myArray[0].operation = hipStreamMemOpWaitValue32;\n myArray[0].waitValue.address = waitAddr1;\n myArray[0].waitValue.value = 0x1;\n myArray[0].waitValue.flags = CU_STREAM_WAIT_VALUE_EQ;\n\n myArray[1].operation = hipStreamMemOpWriteValue32;\n myArray[1].writeValue.address = writeAddr1;\n myArray[1].writeValue.value = 0x1;\n myArray[1].writeValue.flags = 0x0;\n\n result = hipStreamBatchMemOp(stream, 2, myArray, 0);\n @endcode"]
4114#[repr(C)]
4115#[derive(Copy, Clone)]
4116pub union hipStreamBatchMemOpParams_union {
4117 pub operation: hipStreamBatchMemOpType,
4118 pub waitValue: hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t,
4119 pub writeValue: hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t,
4120 #[doc = "< Currently not supported on AMD"]
4121 pub flushRemoteWrites: hipStreamBatchMemOpParams_union_hipStreamMemOpFlushRemoteWritesParams_t,
4122 #[doc = "< Currently not supported on AMD"]
4123 pub memoryBarrier: hipStreamBatchMemOpParams_union_hipStreamMemOpMemoryBarrierParams_t,
4124 pub pad: [u64; 6usize],
4125}
4126#[repr(C)]
4127#[derive(Copy, Clone)]
4128pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t {
4129 pub operation: hipStreamBatchMemOpType,
4130 pub address: hipDeviceptr_t,
4131 pub __bindgen_anon_1:
4132 hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t__bindgen_ty_1,
4133 pub flags: ::std::os::raw::c_uint,
4134 #[doc = "< Not valid for AMD backend. Initial value is unimportant"]
4135 pub alias: hipDeviceptr_t,
4136}
4137#[repr(C)]
4138#[derive(Copy, Clone)]
4139pub union hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t__bindgen_ty_1 {
4140 pub value: u32,
4141 pub value64: u64,
4142}
4143#[repr(C)]
4144#[derive(Copy, Clone)]
4145pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t {
4146 pub operation: hipStreamBatchMemOpType,
4147 pub address: hipDeviceptr_t,
4148 pub __bindgen_anon_1:
4149 hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t__bindgen_ty_1,
4150 pub flags: ::std::os::raw::c_uint,
4151 #[doc = "< Not valid for AMD backend. Initial value is unimportant"]
4152 pub alias: hipDeviceptr_t,
4153}
4154#[repr(C)]
4155#[derive(Copy, Clone)]
4156pub union hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t__bindgen_ty_1 {
4157 pub value: u32,
4158 pub value64: u64,
4159}
4160#[repr(C)]
4161#[derive(Debug, Copy, Clone)]
4162pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpFlushRemoteWritesParams_t {
4163 pub operation: hipStreamBatchMemOpType,
4164 pub flags: ::std::os::raw::c_uint,
4165}
4166#[repr(C)]
4167#[derive(Debug, Copy, Clone)]
4168pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpMemoryBarrierParams_t {
4169 pub operation: hipStreamBatchMemOpType,
4170 pub flags: ::std::os::raw::c_uint,
4171}
4172#[doc = " @brief Union representing batch memory operation parameters for HIP streams.\n\n hipStreamBatchMemOpParams is used to specify the parameters for batch memory\n operations in a HIP stream. This union supports various operations including\n waiting for a specific value, writing a value, and different flags for wait conditions.\n\n @details\n The union includes fields for different types of operations defined in the\n enum hipStreamBatchMemOpType:\n - hipStreamMemOpWaitValue32: Wait for a 32-bit value.\n - hipStreamMemOpWriteValue32: Write a 32-bit value.\n - hipStreamMemOpWaitValue64: Wait for a 64-bit value.\n - hipStreamMemOpWriteValue64: Write a 64-bit value.\n\n Each operation type includes an address, the value to wait for or write, flags, and an\n optional alias that is not relevant on AMD GPUs. Flags can be used to specify different\n wait conditions such as equality, bitwise AND, greater than or equal, and bitwise NOR.\n\n Example usage:\n @code\n hipStreamBatchMemOpParams myArray[2];\n myArray[0].operation = hipStreamMemOpWaitValue32;\n myArray[0].waitValue.address = waitAddr1;\n myArray[0].waitValue.value = 0x1;\n myArray[0].waitValue.flags = CU_STREAM_WAIT_VALUE_EQ;\n\n myArray[1].operation = hipStreamMemOpWriteValue32;\n myArray[1].writeValue.address = writeAddr1;\n myArray[1].writeValue.value = 0x1;\n myArray[1].writeValue.flags = 0x0;\n\n result = hipStreamBatchMemOp(stream, 2, myArray, 0);\n @endcode"]
4173pub type hipStreamBatchMemOpParams = hipStreamBatchMemOpParams_union;
4174#[doc = " @brief Structure representing node parameters for batch memory operations in HIP graphs.\n\n hipBatchMemOpNodeParams is used to specify the parameters for batch memory\n operations in HIP graphs. This struct includes the context to use for the operations, the\n number of operations, and an array of hipStreamBatchMemOpParams that describe the operations.\n\n @details\n The structure includes the following fields:\n - ctx: The HIP context to use for the operations.\n - count: The number of operations in the paramArray.\n - paramArray: A pointer to an array of hipStreamBatchMemOpParams.\n - flags: Flags to control the node.\n\n Example usage:\n @code\n hipBatchMemOpNodeParams nodeParams;\n nodeParams.ctx = context;\n nodeParams.count = ARRAY_SIZE;\n nodeParams.paramArray = myArray;\n nodeParams.flags = 0;\n\n Pass nodeParams to a HIP graph APIs hipGraphAddBatchMemOpNode, hipGraphBatchMemOpNodeGetParams,\n hipGraphBatchMemOpNodeSetParams, hipGraphExecBatchMemOpNodeSetParams\n @endcode"]
4175#[repr(C)]
4176#[derive(Debug, Copy, Clone)]
4177pub struct hipBatchMemOpNodeParams {
4178 pub ctx: hipCtx_t,
4179 pub count: ::std::os::raw::c_uint,
4180 pub paramArray: *mut hipStreamBatchMemOpParams,
4181 pub flags: ::std::os::raw::c_uint,
4182}
4183#[doc = "< Data will mostly be read and only occassionally\n< be written to"]
4184pub const hipMemoryAdvise_hipMemAdviseSetReadMostly: hipMemoryAdvise = 1;
4185#[doc = "< Undo the effect of hipMemAdviseSetReadMostly"]
4186pub const hipMemoryAdvise_hipMemAdviseUnsetReadMostly: hipMemoryAdvise = 2;
4187#[doc = "< Set the preferred location for the data as\n< the specified device"]
4188pub const hipMemoryAdvise_hipMemAdviseSetPreferredLocation: hipMemoryAdvise = 3;
4189#[doc = "< Clear the preferred location for the data"]
4190pub const hipMemoryAdvise_hipMemAdviseUnsetPreferredLocation: hipMemoryAdvise = 4;
4191#[doc = "< Data will be accessed by the specified device\n< so prevent page faults as much as possible"]
4192pub const hipMemoryAdvise_hipMemAdviseSetAccessedBy: hipMemoryAdvise = 5;
4193#[doc = "< Let HIP to decide on the page faulting policy\n< for the specified device"]
4194pub const hipMemoryAdvise_hipMemAdviseUnsetAccessedBy: hipMemoryAdvise = 6;
4195#[doc = "< The default memory model is fine-grain. That allows\n< coherent operations between host and device, while\n< executing kernels. The coarse-grain can be used\n< for data that only needs to be coherent at dispatch\n< boundaries for better performance"]
4196pub const hipMemoryAdvise_hipMemAdviseSetCoarseGrain: hipMemoryAdvise = 100;
4197#[doc = "< Restores cache coherency policy back to fine-grain"]
4198pub const hipMemoryAdvise_hipMemAdviseUnsetCoarseGrain: hipMemoryAdvise = 101;
4199#[doc = " HIP Memory Advise values\n\n @note This memory advise enumeration is used on Linux, not Windows."]
4200pub type hipMemoryAdvise = ::std::os::raw::c_uint;
4201#[doc = "< Updates to memory with this attribute can be\n< done coherently from all devices"]
4202pub const hipMemRangeCoherencyMode_hipMemRangeCoherencyModeFineGrain: hipMemRangeCoherencyMode = 0;
4203#[doc = "< Writes to memory with this attribute can be\n< performed by a single device at a time"]
4204pub const hipMemRangeCoherencyMode_hipMemRangeCoherencyModeCoarseGrain: hipMemRangeCoherencyMode =
4205 1;
4206#[doc = "< Memory region queried contains subregions with\n< both hipMemRangeCoherencyModeFineGrain and\n< hipMemRangeCoherencyModeCoarseGrain attributes"]
4207pub const hipMemRangeCoherencyMode_hipMemRangeCoherencyModeIndeterminate: hipMemRangeCoherencyMode =
4208 2;
4209#[doc = " HIP Coherency Mode"]
4210pub type hipMemRangeCoherencyMode = ::std::os::raw::c_uint;
4211#[doc = "< Whether the range will mostly be read and\n< only occassionally be written to"]
4212pub const hipMemRangeAttribute_hipMemRangeAttributeReadMostly: hipMemRangeAttribute = 1;
4213#[doc = "< The preferred location of the range"]
4214pub const hipMemRangeAttribute_hipMemRangeAttributePreferredLocation: hipMemRangeAttribute = 2;
4215#[doc = "< Memory range has hipMemAdviseSetAccessedBy\n< set for the specified device"]
4216pub const hipMemRangeAttribute_hipMemRangeAttributeAccessedBy: hipMemRangeAttribute = 3;
4217#[doc = "< The last location to where the range was\n< prefetched"]
4218pub const hipMemRangeAttribute_hipMemRangeAttributeLastPrefetchLocation: hipMemRangeAttribute = 4;
4219#[doc = "< Returns coherency mode\n< @ref hipMemRangeCoherencyMode for the range"]
4220pub const hipMemRangeAttribute_hipMemRangeAttributeCoherencyMode: hipMemRangeAttribute = 100;
4221#[doc = " HIP range attributes"]
4222pub type hipMemRangeAttribute = ::std::os::raw::c_uint;
4223#[doc = " (value type = int)\n Allow @p hipMemAllocAsync to use memory asynchronously freed\n in another streams as long as a stream ordering dependency\n of the allocating stream on the free action exists.\n hip events and null stream interactions can create the required\n stream ordered dependencies. (default enabled)"]
4224pub const hipMemPoolAttr_hipMemPoolReuseFollowEventDependencies: hipMemPoolAttr = 1;
4225#[doc = " (value type = int)\n Allow reuse of already completed frees when there is no dependency\n between the free and allocation. (default enabled)"]
4226pub const hipMemPoolAttr_hipMemPoolReuseAllowOpportunistic: hipMemPoolAttr = 2;
4227#[doc = " (value type = int)\n Allow @p hipMemAllocAsync to insert new stream dependencies\n in order to establish the stream ordering required to reuse\n a piece of memory released by cuFreeAsync (default enabled)."]
4228pub const hipMemPoolAttr_hipMemPoolReuseAllowInternalDependencies: hipMemPoolAttr = 3;
4229#[doc = " (value type = uint64_t)\n Amount of reserved memory in bytes to hold onto before trying\n to release memory back to the OS. When more than the release\n threshold bytes of memory are held by the memory pool, the\n allocator will try to release memory back to the OS on the\n next call to stream, event or context synchronize. (default 0)"]
4230pub const hipMemPoolAttr_hipMemPoolAttrReleaseThreshold: hipMemPoolAttr = 4;
4231#[doc = " (value type = uint64_t)\n Amount of backing memory currently allocated for the mempool."]
4232pub const hipMemPoolAttr_hipMemPoolAttrReservedMemCurrent: hipMemPoolAttr = 5;
4233#[doc = " (value type = uint64_t)\n High watermark of backing memory allocated for the mempool since the\n last time it was reset. High watermark can only be reset to zero."]
4234pub const hipMemPoolAttr_hipMemPoolAttrReservedMemHigh: hipMemPoolAttr = 6;
4235#[doc = " (value type = uint64_t)\n Amount of memory from the pool that is currently in use by the application."]
4236pub const hipMemPoolAttr_hipMemPoolAttrUsedMemCurrent: hipMemPoolAttr = 7;
4237#[doc = " (value type = uint64_t)\n High watermark of the amount of memory from the pool that was in use by the application since\n the last time it was reset. High watermark can only be reset to zero."]
4238pub const hipMemPoolAttr_hipMemPoolAttrUsedMemHigh: hipMemPoolAttr = 8;
4239#[doc = " HIP memory pool attributes"]
4240pub type hipMemPoolAttr = ::std::os::raw::c_uint;
4241pub const hipMemLocationType_hipMemLocationTypeInvalid: hipMemLocationType = 0;
4242#[doc = "< Device location, thus it's HIP device ID"]
4243pub const hipMemLocationType_hipMemLocationTypeDevice: hipMemLocationType = 1;
4244#[doc = " Specifies the type of location"]
4245pub type hipMemLocationType = ::std::os::raw::c_uint;
4246#[doc = " Specifies a memory location.\n\n To specify a gpu, set type = @p hipMemLocationTypeDevice and set id = the gpu's device ID"]
4247#[repr(C)]
4248#[derive(Debug, Copy, Clone)]
4249pub struct hipMemLocation {
4250 #[doc = "< Specifies the location type, which describes the meaning of id"]
4251 pub type_: hipMemLocationType,
4252 #[doc = "< Identifier for the provided location type @p hipMemLocationType"]
4253 pub id: ::std::os::raw::c_int,
4254}
4255#[doc = "< Default, make the address range not accessible"]
4256pub const hipMemAccessFlags_hipMemAccessFlagsProtNone: hipMemAccessFlags = 0;
4257#[doc = "< Set the address range read accessible"]
4258pub const hipMemAccessFlags_hipMemAccessFlagsProtRead: hipMemAccessFlags = 1;
4259#[doc = "< Set the address range read-write accessible"]
4260pub const hipMemAccessFlags_hipMemAccessFlagsProtReadWrite: hipMemAccessFlags = 3;
4261#[doc = " Specifies the memory protection flags for mapping\n"]
4262pub type hipMemAccessFlags = ::std::os::raw::c_uint;
4263#[doc = " Memory access descriptor"]
4264#[repr(C)]
4265#[derive(Debug, Copy, Clone)]
4266pub struct hipMemAccessDesc {
4267 #[doc = "< Location on which the accessibility has to change"]
4268 pub location: hipMemLocation,
4269 #[doc = "< Accessibility flags to set"]
4270 pub flags: hipMemAccessFlags,
4271}
4272pub const hipMemAllocationType_hipMemAllocationTypeInvalid: hipMemAllocationType = 0;
4273#[doc = " This allocation type is 'pinned', i.e. cannot migrate from its current\n location while the application is actively using it"]
4274pub const hipMemAllocationType_hipMemAllocationTypePinned: hipMemAllocationType = 1;
4275#[doc = " This allocation type is 'pinned', i.e. cannot migrate from its current\n location while the application is actively using it"]
4276pub const hipMemAllocationType_hipMemAllocationTypeMax: hipMemAllocationType = 2147483647;
4277#[doc = " Defines the allocation types"]
4278pub type hipMemAllocationType = ::std::os::raw::c_uint;
4279#[doc = "< Does not allow any export mechanism"]
4280pub const hipMemAllocationHandleType_hipMemHandleTypeNone: hipMemAllocationHandleType = 0;
4281#[doc = "< Allows a file descriptor for exporting. Permitted only on POSIX systems"]
4282pub const hipMemAllocationHandleType_hipMemHandleTypePosixFileDescriptor:
4283 hipMemAllocationHandleType = 1;
4284#[doc = "< Allows a Win32 NT handle for exporting. (HANDLE)"]
4285pub const hipMemAllocationHandleType_hipMemHandleTypeWin32: hipMemAllocationHandleType = 2;
4286#[doc = "< Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)"]
4287pub const hipMemAllocationHandleType_hipMemHandleTypeWin32Kmt: hipMemAllocationHandleType = 4;
4288#[doc = " Flags for specifying handle types for memory pool allocations\n"]
4289pub type hipMemAllocationHandleType = ::std::os::raw::c_uint;
4290#[doc = " Specifies the properties of allocations made from the pool."]
4291#[repr(C)]
4292#[derive(Debug, Copy, Clone)]
4293pub struct hipMemPoolProps {
4294 #[doc = "< Allocation type. Currently must be specified as @p hipMemAllocationTypePinned"]
4295 pub allocType: hipMemAllocationType,
4296 #[doc = "< Handle types that will be supported by allocations from the pool"]
4297 pub handleTypes: hipMemAllocationHandleType,
4298 #[doc = "< Location where allocations should reside"]
4299 pub location: hipMemLocation,
4300 #[doc = " Windows-specific LPSECURITYATTRIBUTES required when @p hipMemHandleTypeWin32 is specified"]
4301 pub win32SecurityAttributes: *mut ::std::os::raw::c_void,
4302 #[doc = "< Maximum pool size. When set to 0, defaults to a system dependent value"]
4303 pub maxSize: usize,
4304 #[doc = "< Reserved for future use, must be 0"]
4305 pub reserved: [::std::os::raw::c_uchar; 56usize],
4306}
4307#[doc = " Opaque data structure for exporting a pool allocation"]
4308#[repr(C)]
4309#[derive(Debug, Copy, Clone)]
4310pub struct hipMemPoolPtrExportData {
4311 pub reserved: [::std::os::raw::c_uchar; 64usize],
4312}
4313pub const hipFuncAttribute_hipFuncAttributeMaxDynamicSharedMemorySize: hipFuncAttribute = 8;
4314pub const hipFuncAttribute_hipFuncAttributePreferredSharedMemoryCarveout: hipFuncAttribute = 9;
4315pub const hipFuncAttribute_hipFuncAttributeMax: hipFuncAttribute = 10;
4316#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
4317pub type hipFuncAttribute = ::std::os::raw::c_uint;
4318#[doc = "< no preference for shared memory or L1 (default)"]
4319pub const hipFuncCache_t_hipFuncCachePreferNone: hipFuncCache_t = 0;
4320#[doc = "< prefer larger shared memory and smaller L1 cache"]
4321pub const hipFuncCache_t_hipFuncCachePreferShared: hipFuncCache_t = 1;
4322#[doc = "< prefer larger L1 cache and smaller shared memory"]
4323pub const hipFuncCache_t_hipFuncCachePreferL1: hipFuncCache_t = 2;
4324#[doc = "< prefer equal size L1 cache and shared memory"]
4325pub const hipFuncCache_t_hipFuncCachePreferEqual: hipFuncCache_t = 3;
4326#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
4327pub type hipFuncCache_t = ::std::os::raw::c_uint;
4328#[doc = "< The compiler selects a device-specific value for the banking."]
4329pub const hipSharedMemConfig_hipSharedMemBankSizeDefault: hipSharedMemConfig = 0;
4330#[doc = "< Shared mem is banked at 4-bytes intervals and performs best\n< when adjacent threads access data 4 bytes apart."]
4331pub const hipSharedMemConfig_hipSharedMemBankSizeFourByte: hipSharedMemConfig = 1;
4332#[doc = "< Shared mem is banked at 8-byte intervals and performs best\n< when adjacent threads access data 4 bytes apart."]
4333pub const hipSharedMemConfig_hipSharedMemBankSizeEightByte: hipSharedMemConfig = 2;
4334#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
4335pub type hipSharedMemConfig = ::std::os::raw::c_uint;
4336#[doc = " Struct for data in 3D"]
4337#[repr(C)]
4338#[derive(Debug, Copy, Clone)]
4339pub struct dim3 {
4340 #[doc = "< x"]
4341 pub x: u32,
4342 #[doc = "< y"]
4343 pub y: u32,
4344 #[doc = "< z"]
4345 pub z: u32,
4346}
4347#[doc = " struct hipLaunchParams_t"]
4348#[repr(C)]
4349#[derive(Debug, Copy, Clone)]
4350pub struct hipLaunchParams_t {
4351 #[doc = "< Device function symbol"]
4352 pub func: *mut ::std::os::raw::c_void,
4353 #[doc = "< Grid dimensions"]
4354 pub gridDim: dim3,
4355 #[doc = "< Block dimensions"]
4356 pub blockDim: dim3,
4357 #[doc = "< Arguments"]
4358 pub args: *mut *mut ::std::os::raw::c_void,
4359 #[doc = "< Shared memory"]
4360 pub sharedMem: usize,
4361 #[doc = "< Stream identifier"]
4362 pub stream: hipStream_t,
4363}
4364#[doc = " struct hipLaunchParams_t"]
4365pub type hipLaunchParams = hipLaunchParams_t;
4366#[doc = " struct hipFunctionLaunchParams_t"]
4367#[repr(C)]
4368#[derive(Debug, Copy, Clone)]
4369pub struct hipFunctionLaunchParams_t {
4370 #[doc = "< Kernel to launch"]
4371 pub function: hipFunction_t,
4372 #[doc = "< Width(X) of grid in blocks"]
4373 pub gridDimX: ::std::os::raw::c_uint,
4374 #[doc = "< Height(Y) of grid in blocks"]
4375 pub gridDimY: ::std::os::raw::c_uint,
4376 #[doc = "< Depth(Z) of grid in blocks"]
4377 pub gridDimZ: ::std::os::raw::c_uint,
4378 #[doc = "< X dimension of each thread block"]
4379 pub blockDimX: ::std::os::raw::c_uint,
4380 #[doc = "< Y dimension of each thread block"]
4381 pub blockDimY: ::std::os::raw::c_uint,
4382 #[doc = "< Z dimension of each thread block"]
4383 pub blockDimZ: ::std::os::raw::c_uint,
4384 #[doc = "< Shared memory"]
4385 pub sharedMemBytes: ::std::os::raw::c_uint,
4386 #[doc = "< Stream identifier"]
4387 pub hStream: hipStream_t,
4388 #[doc = "< Kernel parameters"]
4389 pub kernelParams: *mut *mut ::std::os::raw::c_void,
4390}
4391#[doc = " struct hipFunctionLaunchParams_t"]
4392pub type hipFunctionLaunchParams = hipFunctionLaunchParams_t;
4393pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeOpaqueFd:
4394 hipExternalMemoryHandleType_enum = 1;
4395pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeOpaqueWin32:
4396 hipExternalMemoryHandleType_enum = 2;
4397pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeOpaqueWin32Kmt:
4398 hipExternalMemoryHandleType_enum = 3;
4399pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D12Heap:
4400 hipExternalMemoryHandleType_enum = 4;
4401pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D12Resource:
4402 hipExternalMemoryHandleType_enum = 5;
4403pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D11Resource:
4404 hipExternalMemoryHandleType_enum = 6;
4405pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D11ResourceKmt:
4406 hipExternalMemoryHandleType_enum = 7;
4407pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeNvSciBuf:
4408 hipExternalMemoryHandleType_enum = 8;
4409pub type hipExternalMemoryHandleType_enum = ::std::os::raw::c_uint;
4410pub use self::hipExternalMemoryHandleType_enum as hipExternalMemoryHandleType;
4411#[repr(C)]
4412#[derive(Copy, Clone)]
4413pub struct hipExternalMemoryHandleDesc_st {
4414 pub type_: hipExternalMemoryHandleType,
4415 pub handle: hipExternalMemoryHandleDesc_st__bindgen_ty_1,
4416 pub size: ::std::os::raw::c_ulonglong,
4417 pub flags: ::std::os::raw::c_uint,
4418 pub reserved: [::std::os::raw::c_uint; 16usize],
4419}
4420#[repr(C)]
4421#[derive(Copy, Clone)]
4422pub union hipExternalMemoryHandleDesc_st__bindgen_ty_1 {
4423 pub fd: ::std::os::raw::c_int,
4424 pub win32: hipExternalMemoryHandleDesc_st__bindgen_ty_1__bindgen_ty_1,
4425 pub nvSciBufObject: *const ::std::os::raw::c_void,
4426}
4427#[repr(C)]
4428#[derive(Debug, Copy, Clone)]
4429pub struct hipExternalMemoryHandleDesc_st__bindgen_ty_1__bindgen_ty_1 {
4430 pub handle: *mut ::std::os::raw::c_void,
4431 pub name: *const ::std::os::raw::c_void,
4432}
4433pub type hipExternalMemoryHandleDesc = hipExternalMemoryHandleDesc_st;
4434#[repr(C)]
4435#[derive(Debug, Copy, Clone)]
4436pub struct hipExternalMemoryBufferDesc_st {
4437 pub offset: ::std::os::raw::c_ulonglong,
4438 pub size: ::std::os::raw::c_ulonglong,
4439 pub flags: ::std::os::raw::c_uint,
4440 pub reserved: [::std::os::raw::c_uint; 16usize],
4441}
4442pub type hipExternalMemoryBufferDesc = hipExternalMemoryBufferDesc_st;
4443#[repr(C)]
4444#[derive(Debug, Copy, Clone)]
4445pub struct hipExternalMemoryMipmappedArrayDesc_st {
4446 pub offset: ::std::os::raw::c_ulonglong,
4447 pub formatDesc: hipChannelFormatDesc,
4448 pub extent: hipExtent,
4449 pub flags: ::std::os::raw::c_uint,
4450 pub numLevels: ::std::os::raw::c_uint,
4451}
4452pub type hipExternalMemoryMipmappedArrayDesc = hipExternalMemoryMipmappedArrayDesc_st;
4453pub type hipExternalMemory_t = *mut ::std::os::raw::c_void;
4454pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeOpaqueFd:
4455 hipExternalSemaphoreHandleType_enum = 1;
4456pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeOpaqueWin32:
4457 hipExternalSemaphoreHandleType_enum = 2;
4458pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeOpaqueWin32Kmt:
4459 hipExternalSemaphoreHandleType_enum = 3;
4460pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeD3D12Fence:
4461 hipExternalSemaphoreHandleType_enum = 4;
4462pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeD3D11Fence:
4463 hipExternalSemaphoreHandleType_enum = 5;
4464pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeNvSciSync:
4465 hipExternalSemaphoreHandleType_enum = 6;
4466pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeKeyedMutex:
4467 hipExternalSemaphoreHandleType_enum = 7;
4468pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeKeyedMutexKmt:
4469 hipExternalSemaphoreHandleType_enum = 8;
4470pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeTimelineSemaphoreFd:
4471 hipExternalSemaphoreHandleType_enum = 9;
4472pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 : hipExternalSemaphoreHandleType_enum = 10 ;
4473pub type hipExternalSemaphoreHandleType_enum = ::std::os::raw::c_uint;
4474pub use self::hipExternalSemaphoreHandleType_enum as hipExternalSemaphoreHandleType;
4475#[repr(C)]
4476#[derive(Copy, Clone)]
4477pub struct hipExternalSemaphoreHandleDesc_st {
4478 pub type_: hipExternalSemaphoreHandleType,
4479 pub handle: hipExternalSemaphoreHandleDesc_st__bindgen_ty_1,
4480 pub flags: ::std::os::raw::c_uint,
4481 pub reserved: [::std::os::raw::c_uint; 16usize],
4482}
4483#[repr(C)]
4484#[derive(Copy, Clone)]
4485pub union hipExternalSemaphoreHandleDesc_st__bindgen_ty_1 {
4486 pub fd: ::std::os::raw::c_int,
4487 pub win32: hipExternalSemaphoreHandleDesc_st__bindgen_ty_1__bindgen_ty_1,
4488 pub NvSciSyncObj: *const ::std::os::raw::c_void,
4489}
4490#[repr(C)]
4491#[derive(Debug, Copy, Clone)]
4492pub struct hipExternalSemaphoreHandleDesc_st__bindgen_ty_1__bindgen_ty_1 {
4493 pub handle: *mut ::std::os::raw::c_void,
4494 pub name: *const ::std::os::raw::c_void,
4495}
4496pub type hipExternalSemaphoreHandleDesc = hipExternalSemaphoreHandleDesc_st;
4497pub type hipExternalSemaphore_t = *mut ::std::os::raw::c_void;
4498#[repr(C)]
4499#[derive(Copy, Clone)]
4500pub struct hipExternalSemaphoreSignalParams_st {
4501 pub params: hipExternalSemaphoreSignalParams_st__bindgen_ty_1,
4502 pub flags: ::std::os::raw::c_uint,
4503 pub reserved: [::std::os::raw::c_uint; 16usize],
4504}
4505#[repr(C)]
4506#[derive(Copy, Clone)]
4507pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1 {
4508 pub fence: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_1,
4509 pub nvSciSync: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_2,
4510 pub keyedMutex: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_3,
4511 pub reserved: [::std::os::raw::c_uint; 12usize],
4512}
4513#[repr(C)]
4514#[derive(Debug, Copy, Clone)]
4515pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_1 {
4516 pub value: ::std::os::raw::c_ulonglong,
4517}
4518#[repr(C)]
4519#[derive(Copy, Clone)]
4520pub union hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_2 {
4521 pub fence: *mut ::std::os::raw::c_void,
4522 pub reserved: ::std::os::raw::c_ulonglong,
4523}
4524#[repr(C)]
4525#[derive(Debug, Copy, Clone)]
4526pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_3 {
4527 pub key: ::std::os::raw::c_ulonglong,
4528}
4529pub type hipExternalSemaphoreSignalParams = hipExternalSemaphoreSignalParams_st;
4530#[doc = " External semaphore wait parameters, compatible with driver type"]
4531#[repr(C)]
4532#[derive(Copy, Clone)]
4533pub struct hipExternalSemaphoreWaitParams_st {
4534 pub params: hipExternalSemaphoreWaitParams_st__bindgen_ty_1,
4535 pub flags: ::std::os::raw::c_uint,
4536 pub reserved: [::std::os::raw::c_uint; 16usize],
4537}
4538#[repr(C)]
4539#[derive(Copy, Clone)]
4540pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1 {
4541 pub fence: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_1,
4542 pub nvSciSync: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_2,
4543 pub keyedMutex: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_3,
4544 pub reserved: [::std::os::raw::c_uint; 10usize],
4545}
4546#[repr(C)]
4547#[derive(Debug, Copy, Clone)]
4548pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_1 {
4549 pub value: ::std::os::raw::c_ulonglong,
4550}
4551#[repr(C)]
4552#[derive(Copy, Clone)]
4553pub union hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_2 {
4554 pub fence: *mut ::std::os::raw::c_void,
4555 pub reserved: ::std::os::raw::c_ulonglong,
4556}
4557#[repr(C)]
4558#[derive(Debug, Copy, Clone)]
4559pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_3 {
4560 pub key: ::std::os::raw::c_ulonglong,
4561 pub timeoutMs: ::std::os::raw::c_uint,
4562}
4563#[doc = " External semaphore wait parameters, compatible with driver type"]
4564pub type hipExternalSemaphoreWaitParams = hipExternalSemaphoreWaitParams_st;
4565extern "C" {
4566 #[doc = " Internal use only. This API may change in the future\n Pre-Compiled header for online compilation"]
4567 pub fn __hipGetPCH(pch: *mut *const ::std::os::raw::c_char, size: *mut ::std::os::raw::c_uint);
4568}
4569pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsNone: hipGraphicsRegisterFlags = 0;
4570#[doc = "< HIP will not write to this registered resource"]
4571pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsReadOnly: hipGraphicsRegisterFlags = 1;
4572pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsWriteDiscard: hipGraphicsRegisterFlags =
4573 2;
4574#[doc = "< HIP will bind this resource to a surface"]
4575pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsSurfaceLoadStore:
4576 hipGraphicsRegisterFlags = 4;
4577pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsTextureGather: hipGraphicsRegisterFlags =
4578 8;
4579#[doc = " HIP Access falgs for Interop resources."]
4580pub type hipGraphicsRegisterFlags = ::std::os::raw::c_uint;
4581#[repr(C)]
4582#[derive(Debug, Copy, Clone)]
4583pub struct _hipGraphicsResource {
4584 _unused: [u8; 0],
4585}
4586pub type hipGraphicsResource = _hipGraphicsResource;
4587pub type hipGraphicsResource_t = *mut hipGraphicsResource;
4588#[repr(C)]
4589#[derive(Debug, Copy, Clone)]
4590pub struct ihipGraph {
4591 _unused: [u8; 0],
4592}
4593#[doc = " An opaque value that represents a hip graph"]
4594pub type hipGraph_t = *mut ihipGraph;
4595#[repr(C)]
4596#[derive(Debug, Copy, Clone)]
4597pub struct hipGraphNode {
4598 _unused: [u8; 0],
4599}
4600#[doc = " An opaque value that represents a hip graph node"]
4601pub type hipGraphNode_t = *mut hipGraphNode;
4602#[repr(C)]
4603#[derive(Debug, Copy, Clone)]
4604pub struct hipGraphExec {
4605 _unused: [u8; 0],
4606}
4607#[doc = " An opaque value that represents a hip graph Exec"]
4608pub type hipGraphExec_t = *mut hipGraphExec;
4609#[repr(C)]
4610#[derive(Debug, Copy, Clone)]
4611pub struct hipUserObject {
4612 _unused: [u8; 0],
4613}
4614#[doc = " An opaque value that represents a user obj"]
4615pub type hipUserObject_t = *mut hipUserObject;
4616#[doc = "< GPU kernel node"]
4617pub const hipGraphNodeType_hipGraphNodeTypeKernel: hipGraphNodeType = 0;
4618#[doc = "< Memcpy node"]
4619pub const hipGraphNodeType_hipGraphNodeTypeMemcpy: hipGraphNodeType = 1;
4620#[doc = "< Memset node"]
4621pub const hipGraphNodeType_hipGraphNodeTypeMemset: hipGraphNodeType = 2;
4622#[doc = "< Host (executable) node"]
4623pub const hipGraphNodeType_hipGraphNodeTypeHost: hipGraphNodeType = 3;
4624#[doc = "< Node which executes an embedded graph"]
4625pub const hipGraphNodeType_hipGraphNodeTypeGraph: hipGraphNodeType = 4;
4626#[doc = "< Empty (no-op) node"]
4627pub const hipGraphNodeType_hipGraphNodeTypeEmpty: hipGraphNodeType = 5;
4628#[doc = "< External event wait node"]
4629pub const hipGraphNodeType_hipGraphNodeTypeWaitEvent: hipGraphNodeType = 6;
4630#[doc = "< External event record node"]
4631pub const hipGraphNodeType_hipGraphNodeTypeEventRecord: hipGraphNodeType = 7;
4632#[doc = "< External Semaphore signal node"]
4633pub const hipGraphNodeType_hipGraphNodeTypeExtSemaphoreSignal: hipGraphNodeType = 8;
4634#[doc = "< External Semaphore wait node"]
4635pub const hipGraphNodeType_hipGraphNodeTypeExtSemaphoreWait: hipGraphNodeType = 9;
4636#[doc = "< Memory alloc node"]
4637pub const hipGraphNodeType_hipGraphNodeTypeMemAlloc: hipGraphNodeType = 10;
4638#[doc = "< Memory free node"]
4639pub const hipGraphNodeType_hipGraphNodeTypeMemFree: hipGraphNodeType = 11;
4640#[doc = "< MemcpyFromSymbol node"]
4641pub const hipGraphNodeType_hipGraphNodeTypeMemcpyFromSymbol: hipGraphNodeType = 12;
4642#[doc = "< MemcpyToSymbol node"]
4643pub const hipGraphNodeType_hipGraphNodeTypeMemcpyToSymbol: hipGraphNodeType = 13;
4644#[doc = "< BatchMemOp node"]
4645pub const hipGraphNodeType_hipGraphNodeTypeBatchMemOp: hipGraphNodeType = 14;
4646pub const hipGraphNodeType_hipGraphNodeTypeCount: hipGraphNodeType = 15;
4647#[doc = " hipGraphNodeType"]
4648pub type hipGraphNodeType = ::std::os::raw::c_uint;
4649pub type hipHostFn_t =
4650 ::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void)>;
4651#[repr(C)]
4652#[derive(Debug, Copy, Clone)]
4653pub struct hipHostNodeParams {
4654 pub fn_: hipHostFn_t,
4655 pub userData: *mut ::std::os::raw::c_void,
4656}
4657#[repr(C)]
4658#[derive(Debug, Copy, Clone)]
4659pub struct hipKernelNodeParams {
4660 pub blockDim: dim3,
4661 pub extra: *mut *mut ::std::os::raw::c_void,
4662 pub func: *mut ::std::os::raw::c_void,
4663 pub gridDim: dim3,
4664 pub kernelParams: *mut *mut ::std::os::raw::c_void,
4665 pub sharedMemBytes: ::std::os::raw::c_uint,
4666}
4667#[repr(C)]
4668#[derive(Debug, Copy, Clone)]
4669pub struct hipMemsetParams {
4670 pub dst: *mut ::std::os::raw::c_void,
4671 pub elementSize: ::std::os::raw::c_uint,
4672 pub height: usize,
4673 pub pitch: usize,
4674 pub value: ::std::os::raw::c_uint,
4675 pub width: usize,
4676}
4677#[repr(C)]
4678#[derive(Debug, Copy, Clone)]
4679pub struct hipMemAllocNodeParams {
4680 #[doc = "< Pool properties, which contain where\n< the location should reside"]
4681 pub poolProps: hipMemPoolProps,
4682 #[doc = "< The number of memory access descriptors."]
4683 pub accessDescs: *const hipMemAccessDesc,
4684 #[doc = "< The number of access descriptors.\n< Must not be bigger than the number of GPUs"]
4685 pub accessDescCount: usize,
4686 #[doc = "< The size of the requested allocation in bytes"]
4687 pub bytesize: usize,
4688 #[doc = "< Returned device address of the allocation"]
4689 pub dptr: *mut ::std::os::raw::c_void,
4690}
4691pub const hipAccessProperty_hipAccessPropertyNormal: hipAccessProperty = 0;
4692pub const hipAccessProperty_hipAccessPropertyStreaming: hipAccessProperty = 1;
4693pub const hipAccessProperty_hipAccessPropertyPersisting: hipAccessProperty = 2;
4694pub type hipAccessProperty = ::std::os::raw::c_uint;
4695#[repr(C)]
4696#[derive(Debug, Copy, Clone)]
4697pub struct hipAccessPolicyWindow {
4698 pub base_ptr: *mut ::std::os::raw::c_void,
4699 pub hitProp: hipAccessProperty,
4700 pub hitRatio: f32,
4701 pub missProp: hipAccessProperty,
4702 pub num_bytes: usize,
4703}
4704#[doc = "< Valid for Streams, graph nodes, launches"]
4705pub const hipLaunchAttributeID_hipLaunchAttributeAccessPolicyWindow: hipLaunchAttributeID = 1;
4706#[doc = "< Valid for graph nodes, launches"]
4707pub const hipLaunchAttributeID_hipLaunchAttributeCooperative: hipLaunchAttributeID = 2;
4708#[doc = "< Valid for graph node, streams, launches"]
4709pub const hipLaunchAttributeID_hipLaunchAttributePriority: hipLaunchAttributeID = 8;
4710#[doc = " Launch Attribute ID"]
4711pub type hipLaunchAttributeID = ::std::os::raw::c_uint;
4712#[doc = " Launch Attribute Value"]
4713#[repr(C)]
4714#[derive(Copy, Clone)]
4715pub union hipLaunchAttributeValue {
4716 #[doc = "< Value of launch attribute::\nhipLaunchAttributePolicyWindow."]
4717 pub accessPolicyWindow: hipAccessPolicyWindow,
4718 #[doc = "< Value of launch attribute ::hipLaunchAttributeCooperative"]
4719 pub cooperative: ::std::os::raw::c_int,
4720 #[doc = "< Value of launch attribute :: hipLaunchAttributePriority. Execution\npriority of kernel."]
4721 pub priority: ::std::os::raw::c_int,
4722}
4723#[doc = " Memset node params"]
4724#[repr(C)]
4725#[derive(Debug, Copy, Clone)]
4726pub struct HIP_MEMSET_NODE_PARAMS {
4727 #[doc = "< Destination pointer on device"]
4728 pub dst: hipDeviceptr_t,
4729 #[doc = "< Destination device pointer pitch. Unused if height equals 1"]
4730 pub pitch: usize,
4731 #[doc = "< Value of memset to be set"]
4732 pub value: ::std::os::raw::c_uint,
4733 #[doc = "< Element in bytes. Must be 1, 2, or 4."]
4734 pub elementSize: ::std::os::raw::c_uint,
4735 #[doc = "< Width of a row"]
4736 pub width: usize,
4737 #[doc = "< Number of rows"]
4738 pub height: usize,
4739}
4740#[doc = "< The update succeeded"]
4741pub const hipGraphExecUpdateResult_hipGraphExecUpdateSuccess: hipGraphExecUpdateResult = 0;
4742#[doc = "< The update failed for an unexpected reason which is described\n< in the return value of the function"]
4743pub const hipGraphExecUpdateResult_hipGraphExecUpdateError: hipGraphExecUpdateResult = 1;
4744#[doc = "< The update failed because the topology changed"]
4745pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorTopologyChanged:
4746 hipGraphExecUpdateResult = 2;
4747#[doc = "< The update failed because a node type changed"]
4748pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorNodeTypeChanged:
4749 hipGraphExecUpdateResult = 3;
4750pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorFunctionChanged:
4751 hipGraphExecUpdateResult = 4;
4752pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorParametersChanged:
4753 hipGraphExecUpdateResult = 5;
4754pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorNotSupported: hipGraphExecUpdateResult =
4755 6;
4756pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorUnsupportedFunctionChange:
4757 hipGraphExecUpdateResult = 7;
4758#[doc = " Graph execution update result"]
4759pub type hipGraphExecUpdateResult = ::std::os::raw::c_uint;
4760pub const hipStreamCaptureMode_hipStreamCaptureModeGlobal: hipStreamCaptureMode = 0;
4761pub const hipStreamCaptureMode_hipStreamCaptureModeThreadLocal: hipStreamCaptureMode = 1;
4762pub const hipStreamCaptureMode_hipStreamCaptureModeRelaxed: hipStreamCaptureMode = 2;
4763pub type hipStreamCaptureMode = ::std::os::raw::c_uint;
4764#[doc = "< Stream is not capturing"]
4765pub const hipStreamCaptureStatus_hipStreamCaptureStatusNone: hipStreamCaptureStatus = 0;
4766#[doc = "< Stream is actively capturing"]
4767pub const hipStreamCaptureStatus_hipStreamCaptureStatusActive: hipStreamCaptureStatus = 1;
4768#[doc = "< Stream is part of a capture sequence that has been\n< invalidated, but not terminated"]
4769pub const hipStreamCaptureStatus_hipStreamCaptureStatusInvalidated: hipStreamCaptureStatus = 2;
4770pub type hipStreamCaptureStatus = ::std::os::raw::c_uint;
4771#[doc = "< Add new nodes to the dependency set"]
4772pub const hipStreamUpdateCaptureDependenciesFlags_hipStreamAddCaptureDependencies:
4773 hipStreamUpdateCaptureDependenciesFlags = 0;
4774#[doc = "< Replace the dependency set with the new nodes"]
4775pub const hipStreamUpdateCaptureDependenciesFlags_hipStreamSetCaptureDependencies:
4776 hipStreamUpdateCaptureDependenciesFlags = 1;
4777pub type hipStreamUpdateCaptureDependenciesFlags = ::std::os::raw::c_uint;
4778#[doc = "< Amount of memory, in bytes, currently associated with graphs"]
4779pub const hipGraphMemAttributeType_hipGraphMemAttrUsedMemCurrent: hipGraphMemAttributeType = 0;
4780#[doc = "< High watermark of memory, in bytes, associated with graphs since the last time."]
4781pub const hipGraphMemAttributeType_hipGraphMemAttrUsedMemHigh: hipGraphMemAttributeType = 1;
4782#[doc = "< Amount of memory, in bytes, currently allocated for graphs."]
4783pub const hipGraphMemAttributeType_hipGraphMemAttrReservedMemCurrent: hipGraphMemAttributeType = 2;
4784#[doc = "< High watermark of memory, in bytes, currently allocated for graphs"]
4785pub const hipGraphMemAttributeType_hipGraphMemAttrReservedMemHigh: hipGraphMemAttributeType = 3;
4786pub type hipGraphMemAttributeType = ::std::os::raw::c_uint;
4787#[doc = "< Destructor execution is not synchronized."]
4788pub const hipUserObjectFlags_hipUserObjectNoDestructorSync: hipUserObjectFlags = 1;
4789pub type hipUserObjectFlags = ::std::os::raw::c_uint;
4790#[doc = "< Add new reference or retain."]
4791pub const hipUserObjectRetainFlags_hipGraphUserObjectMove: hipUserObjectRetainFlags = 1;
4792pub type hipUserObjectRetainFlags = ::std::os::raw::c_uint;
4793pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagAutoFreeOnLaunch:
4794 hipGraphInstantiateFlags = 1;
4795pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagUpload: hipGraphInstantiateFlags = 2;
4796pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagDeviceLaunch: hipGraphInstantiateFlags =
4797 4;
4798pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagUseNodePriority:
4799 hipGraphInstantiateFlags = 8;
4800pub type hipGraphInstantiateFlags = ::std::os::raw::c_uint;
4801pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsVerbose: hipGraphDebugDotFlags = 1;
4802#[doc = "< Adds hipKernelNodeParams to output"]
4803pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsKernelNodeParams: hipGraphDebugDotFlags = 4;
4804#[doc = "< Adds hipMemcpy3DParms to output"]
4805pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsMemcpyNodeParams: hipGraphDebugDotFlags = 8;
4806#[doc = "< Adds hipMemsetParams to output"]
4807pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsMemsetNodeParams: hipGraphDebugDotFlags = 16;
4808#[doc = "< Adds hipHostNodeParams to output"]
4809pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsHostNodeParams: hipGraphDebugDotFlags = 32;
4810pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsEventNodeParams: hipGraphDebugDotFlags = 64;
4811pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsExtSemasSignalNodeParams:
4812 hipGraphDebugDotFlags = 128;
4813pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsExtSemasWaitNodeParams: hipGraphDebugDotFlags =
4814 256;
4815pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsKernelNodeAttributes: hipGraphDebugDotFlags =
4816 512;
4817pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsHandles: hipGraphDebugDotFlags = 1024;
4818pub type hipGraphDebugDotFlags = ::std::os::raw::c_uint;
4819#[doc = "< Instantiation Success"]
4820pub const hipGraphInstantiateResult_hipGraphInstantiateSuccess: hipGraphInstantiateResult = 0;
4821#[doc = "< Instantiation failed for an\nunexpected reason which is described in the return value of the function"]
4822pub const hipGraphInstantiateResult_hipGraphInstantiateError: hipGraphInstantiateResult = 1;
4823#[doc = "< Instantiation failed due\nto invalid structure, such as cycles"]
4824pub const hipGraphInstantiateResult_hipGraphInstantiateInvalidStructure: hipGraphInstantiateResult =
4825 2;
4826#[doc = "< Instantiation for device launch failed\nbecause the graph contained an unsupported operation"]
4827pub const hipGraphInstantiateResult_hipGraphInstantiateNodeOperationNotSupported:
4828 hipGraphInstantiateResult = 3;
4829#[doc = "< Instantiation for device launch failed\ndue to the nodes belonging to different contexts"]
4830pub const hipGraphInstantiateResult_hipGraphInstantiateMultipleDevicesNotSupported:
4831 hipGraphInstantiateResult = 4;
4832#[doc = " hipGraphInstantiateWithParams results"]
4833pub type hipGraphInstantiateResult = ::std::os::raw::c_uint;
4834#[doc = " Graph Instantiation parameters"]
4835#[repr(C)]
4836#[derive(Debug, Copy, Clone)]
4837pub struct hipGraphInstantiateParams {
4838 #[doc = "< The node which caused instantiation to fail, if any"]
4839 pub errNode_out: hipGraphNode_t,
4840 #[doc = "< Instantiation flags"]
4841 pub flags: ::std::os::raw::c_ulonglong,
4842 #[doc = "< Whether instantiation was successful.\nIf it failed, the reason why"]
4843 pub result_out: hipGraphInstantiateResult,
4844 #[doc = "< Upload stream"]
4845 pub uploadStream: hipStream_t,
4846}
4847#[doc = " Memory allocation properties"]
4848#[repr(C)]
4849#[derive(Debug, Copy, Clone)]
4850pub struct hipMemAllocationProp {
4851 #[doc = "< Memory allocation type"]
4852 pub type_: hipMemAllocationType,
4853 #[doc = "< Requested handle type"]
4854 pub requestedHandleType: hipMemAllocationHandleType,
4855 #[doc = "< Memory location"]
4856 pub location: hipMemLocation,
4857 #[doc = "< Metadata for Win32 handles"]
4858 pub win32HandleMetaData: *mut ::std::os::raw::c_void,
4859 pub allocFlags: hipMemAllocationProp__bindgen_ty_1,
4860}
4861#[repr(C)]
4862#[derive(Debug, Copy, Clone)]
4863pub struct hipMemAllocationProp__bindgen_ty_1 {
4864 #[doc = "< Compression type"]
4865 pub compressionType: ::std::os::raw::c_uchar,
4866 #[doc = "< RDMA capable"]
4867 pub gpuDirectRDMACapable: ::std::os::raw::c_uchar,
4868 #[doc = "< Usage"]
4869 pub usage: ::std::os::raw::c_ushort,
4870}
4871#[doc = " External semaphore signal node parameters"]
4872#[repr(C)]
4873#[derive(Debug, Copy, Clone)]
4874pub struct hipExternalSemaphoreSignalNodeParams {
4875 pub extSemArray: *mut hipExternalSemaphore_t,
4876 pub paramsArray: *const hipExternalSemaphoreSignalParams,
4877 pub numExtSems: ::std::os::raw::c_uint,
4878}
4879#[doc = " External semaphore wait node parameters"]
4880#[repr(C)]
4881#[derive(Debug, Copy, Clone)]
4882pub struct hipExternalSemaphoreWaitNodeParams {
4883 pub extSemArray: *mut hipExternalSemaphore_t,
4884 pub paramsArray: *const hipExternalSemaphoreWaitParams,
4885 pub numExtSems: ::std::os::raw::c_uint,
4886}
4887#[repr(C)]
4888#[derive(Debug, Copy, Clone)]
4889pub struct ihipMemGenericAllocationHandle {
4890 _unused: [u8; 0],
4891}
4892#[doc = " Generic handle for memory allocation"]
4893pub type hipMemGenericAllocationHandle_t = *mut ihipMemGenericAllocationHandle;
4894#[doc = "< Minimum granularity"]
4895pub const hipMemAllocationGranularity_flags_hipMemAllocationGranularityMinimum:
4896 hipMemAllocationGranularity_flags = 0;
4897#[doc = "< Recommended granularity for performance"]
4898pub const hipMemAllocationGranularity_flags_hipMemAllocationGranularityRecommended:
4899 hipMemAllocationGranularity_flags = 1;
4900#[doc = " Flags for granularity"]
4901pub type hipMemAllocationGranularity_flags = ::std::os::raw::c_uint;
4902#[doc = "< Generic handle type"]
4903pub const hipMemHandleType_hipMemHandleTypeGeneric: hipMemHandleType = 0;
4904#[doc = " Memory handle type"]
4905pub type hipMemHandleType = ::std::os::raw::c_uint;
4906#[doc = "< Map operation"]
4907pub const hipMemOperationType_hipMemOperationTypeMap: hipMemOperationType = 1;
4908#[doc = "< Unmap operation"]
4909pub const hipMemOperationType_hipMemOperationTypeUnmap: hipMemOperationType = 2;
4910#[doc = " Memory operation types"]
4911pub type hipMemOperationType = ::std::os::raw::c_uint;
4912#[doc = "< Sparse level"]
4913pub const hipArraySparseSubresourceType_hipArraySparseSubresourceTypeSparseLevel:
4914 hipArraySparseSubresourceType = 0;
4915#[doc = "< Miptail"]
4916pub const hipArraySparseSubresourceType_hipArraySparseSubresourceTypeMiptail:
4917 hipArraySparseSubresourceType = 1;
4918#[doc = " Subresource types for sparse arrays"]
4919pub type hipArraySparseSubresourceType = ::std::os::raw::c_uint;
4920#[doc = " Map info for arrays"]
4921#[repr(C)]
4922#[derive(Copy, Clone)]
4923pub struct hipArrayMapInfo {
4924 #[doc = "< Resource type"]
4925 pub resourceType: hipResourceType,
4926 pub resource: hipArrayMapInfo__bindgen_ty_1,
4927 #[doc = "< Sparse subresource type"]
4928 pub subresourceType: hipArraySparseSubresourceType,
4929 pub subresource: hipArrayMapInfo__bindgen_ty_2,
4930 #[doc = "< Memory operation type"]
4931 pub memOperationType: hipMemOperationType,
4932 #[doc = "< Memory handle type"]
4933 pub memHandleType: hipMemHandleType,
4934 pub memHandle: hipArrayMapInfo__bindgen_ty_3,
4935 #[doc = "< Offset within the memory"]
4936 pub offset: ::std::os::raw::c_ulonglong,
4937 #[doc = "< Device ordinal bit mask"]
4938 pub deviceBitMask: ::std::os::raw::c_uint,
4939 #[doc = "< flags for future use, must be zero now."]
4940 pub flags: ::std::os::raw::c_uint,
4941 #[doc = "< Reserved for future use, must be zero now."]
4942 pub reserved: [::std::os::raw::c_uint; 2usize],
4943}
4944#[repr(C)]
4945#[derive(Copy, Clone)]
4946pub union hipArrayMapInfo__bindgen_ty_1 {
4947 pub mipmap: hipMipmappedArray,
4948 pub array: hipArray_t,
4949}
4950#[repr(C)]
4951#[derive(Copy, Clone)]
4952pub union hipArrayMapInfo__bindgen_ty_2 {
4953 pub sparseLevel: hipArrayMapInfo__bindgen_ty_2__bindgen_ty_1,
4954 pub miptail: hipArrayMapInfo__bindgen_ty_2__bindgen_ty_2,
4955}
4956#[repr(C)]
4957#[derive(Debug, Copy, Clone)]
4958pub struct hipArrayMapInfo__bindgen_ty_2__bindgen_ty_1 {
4959 #[doc = "< For mipmapped arrays must be a valid mipmap level. For arrays must be zero"]
4960 pub level: ::std::os::raw::c_uint,
4961 #[doc = "< For layered arrays must be a valid layer index. Otherwise, must be zero"]
4962 pub layer: ::std::os::raw::c_uint,
4963 #[doc = "< X offset in elements"]
4964 pub offsetX: ::std::os::raw::c_uint,
4965 #[doc = "< Y offset in elements"]
4966 pub offsetY: ::std::os::raw::c_uint,
4967 #[doc = "< Z offset in elements"]
4968 pub offsetZ: ::std::os::raw::c_uint,
4969 #[doc = "< Width in elements"]
4970 pub extentWidth: ::std::os::raw::c_uint,
4971 #[doc = "< Height in elements"]
4972 pub extentHeight: ::std::os::raw::c_uint,
4973 #[doc = "< Depth in elements"]
4974 pub extentDepth: ::std::os::raw::c_uint,
4975}
4976#[repr(C)]
4977#[derive(Debug, Copy, Clone)]
4978pub struct hipArrayMapInfo__bindgen_ty_2__bindgen_ty_2 {
4979 #[doc = "< For layered arrays must be a valid layer index. Otherwise, must be zero"]
4980 pub layer: ::std::os::raw::c_uint,
4981 #[doc = "< Offset within mip tail"]
4982 pub offset: ::std::os::raw::c_ulonglong,
4983 #[doc = "< Extent in bytes"]
4984 pub size: ::std::os::raw::c_ulonglong,
4985}
4986#[repr(C)]
4987#[derive(Copy, Clone)]
4988pub union hipArrayMapInfo__bindgen_ty_3 {
4989 pub memHandle: hipMemGenericAllocationHandle_t,
4990}
4991#[doc = " Memcpy node params"]
4992#[repr(C)]
4993#[derive(Debug, Copy, Clone)]
4994pub struct hipMemcpyNodeParams {
4995 #[doc = "< Must be zero."]
4996 pub flags: ::std::os::raw::c_int,
4997 #[doc = "< Must be zero."]
4998 pub reserved: [::std::os::raw::c_int; 3usize],
4999 #[doc = "< Params set for the memory copy."]
5000 pub copyParams: hipMemcpy3DParms,
5001}
5002#[doc = " Child graph node params"]
5003#[repr(C)]
5004#[derive(Debug, Copy, Clone)]
5005pub struct hipChildGraphNodeParams {
5006 #[doc = "< Either the child graph to clone into the node, or\n< a handle to the graph possesed by the node used during query"]
5007 pub graph: hipGraph_t,
5008}
5009#[doc = " Event record node params"]
5010#[repr(C)]
5011#[derive(Debug, Copy, Clone)]
5012pub struct hipEventWaitNodeParams {
5013 #[doc = "< Event to wait on"]
5014 pub event: hipEvent_t,
5015}
5016#[doc = " Event record node params"]
5017#[repr(C)]
5018#[derive(Debug, Copy, Clone)]
5019pub struct hipEventRecordNodeParams {
5020 #[doc = "< The event to be recorded when node executes"]
5021 pub event: hipEvent_t,
5022}
5023#[doc = " Memory free node params"]
5024#[repr(C)]
5025#[derive(Debug, Copy, Clone)]
5026pub struct hipMemFreeNodeParams {
5027 #[doc = "< the pointer to be freed"]
5028 pub dptr: *mut ::std::os::raw::c_void,
5029}
5030#[doc = " Params for different graph nodes"]
5031#[repr(C)]
5032#[derive(Copy, Clone)]
5033pub struct hipGraphNodeParams {
5034 pub type_: hipGraphNodeType,
5035 pub reserved0: [::std::os::raw::c_int; 3usize],
5036 pub __bindgen_anon_1: hipGraphNodeParams__bindgen_ty_1,
5037 pub reserved2: ::std::os::raw::c_longlong,
5038}
5039#[repr(C)]
5040#[derive(Copy, Clone)]
5041pub union hipGraphNodeParams__bindgen_ty_1 {
5042 pub reserved1: [::std::os::raw::c_longlong; 29usize],
5043 pub kernel: hipKernelNodeParams,
5044 pub memcpy: hipMemcpyNodeParams,
5045 pub memset: hipMemsetParams,
5046 pub host: hipHostNodeParams,
5047 pub graph: hipChildGraphNodeParams,
5048 pub eventWait: hipEventWaitNodeParams,
5049 pub eventRecord: hipEventRecordNodeParams,
5050 pub extSemSignal: hipExternalSemaphoreSignalNodeParams,
5051 pub extSemWait: hipExternalSemaphoreWaitNodeParams,
5052 pub alloc: hipMemAllocNodeParams,
5053 pub free: hipMemFreeNodeParams,
5054}
5055pub const hipGraphDependencyType_hipGraphDependencyTypeDefault: hipGraphDependencyType = 0;
5056pub const hipGraphDependencyType_hipGraphDependencyTypeProgrammatic: hipGraphDependencyType = 1;
5057pub type hipGraphDependencyType = ::std::os::raw::c_uint;
5058#[repr(C)]
5059#[derive(Debug, Copy, Clone)]
5060pub struct hipGraphEdgeData {
5061 #[doc = "< This indicates when the dependency is triggered from the upstream node on the\n< edge. The meaning is specfic to the node type. A value of 0 in all cases\n< means full completion of the upstream node, with memory visibility to the\n< downstream node or portion thereof (indicated by to_port). Only kernel nodes\n< define non-zero ports. A kernel node can use the following output port types:\n< hipGraphKernelNodePortDefault, hipGraphKernelNodePortProgrammatic, or\n< hipGraphKernelNodePortLaunchCompletion."]
5062 pub from_port: ::std::os::raw::c_uchar,
5063 #[doc = "< These bytes are unused and must be zeroed"]
5064 pub reserved: [::std::os::raw::c_uchar; 5usize],
5065 #[doc = "< Currently no node types define non-zero ports. This field must be set to zero."]
5066 pub to_port: ::std::os::raw::c_uchar,
5067 #[doc = "< This should be populated with a value from hipGraphDependencyType"]
5068 pub type_: ::std::os::raw::c_uchar,
5069}
5070extern "C" {
5071 #[doc = " @}\n/\n/**\n @defgroup API HIP API\n @{\n\n Defines the HIP API. See the individual sections for more information.\n/\n/**\n @defgroup Driver Initialization and Version\n @{\n This section describes the initializtion and version functions of HIP runtime API.\n\n/\n/**\n @brief Explicitly initializes the HIP runtime.\n\n @param [in] flags Initialization flag, should be zero.\n\n Most HIP APIs implicitly initialize the HIP runtime.\n This API provides control over the timing of the initialization.\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
5072 pub fn hipInit(flags: ::std::os::raw::c_uint) -> hipError_t;
5073}
5074extern "C" {
5075 #[doc = " @brief Returns the approximate HIP driver version.\n\n @param [out] driverVersion driver version\n\n HIP driver version shows up in the format:\n HIP_VERSION_MAJOR * 10000000 + HIP_VERSION_MINOR * 100000 + HIP_VERSION_PATCH.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning The HIP driver version does not correspond to an exact CUDA driver revision.\n On AMD platform, the API returns the HIP driver version, while on NVIDIA platform, it calls\n the corresponding CUDA runtime API and returns the CUDA driver version.\n There is no mapping/correlation between HIP driver version and CUDA driver version.\n\n @see hipRuntimeGetVersion"]
5076 pub fn hipDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> hipError_t;
5077}
5078extern "C" {
5079 #[doc = " @brief Returns the approximate HIP Runtime version.\n\n @param [out] runtimeVersion HIP runtime version\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning The version definition of HIP runtime is different from CUDA.\n On AMD platform, the function returns HIP runtime version,\n while on NVIDIA platform, it returns CUDA runtime version.\n And there is no mapping/correlation between HIP version and CUDA version.\n\n @see hipDriverGetVersion"]
5080 pub fn hipRuntimeGetVersion(runtimeVersion: *mut ::std::os::raw::c_int) -> hipError_t;
5081}
5082extern "C" {
5083 #[doc = " @brief Returns a handle to a compute device\n @param [out] device Handle of device\n @param [in] ordinal Device ordinal\n\n @returns #hipSuccess, #hipErrorInvalidDevice"]
5084 pub fn hipDeviceGet(device: *mut hipDevice_t, ordinal: ::std::os::raw::c_int) -> hipError_t;
5085}
5086extern "C" {
5087 #[doc = " @brief Returns the compute capability of the device\n @param [out] major Major compute capability version number\n @param [out] minor Minor compute capability version number\n @param [in] device Device ordinal\n\n @returns #hipSuccess, #hipErrorInvalidDevice"]
5088 pub fn hipDeviceComputeCapability(
5089 major: *mut ::std::os::raw::c_int,
5090 minor: *mut ::std::os::raw::c_int,
5091 device: hipDevice_t,
5092 ) -> hipError_t;
5093}
5094extern "C" {
5095 #[doc = " @brief Returns an identifer string for the device.\n @param [out] name String of the device name\n @param [in] len Maximum length of string to store in device name\n @param [in] device Device ordinal\n\n @returns #hipSuccess, #hipErrorInvalidDevice"]
5096 pub fn hipDeviceGetName(
5097 name: *mut ::std::os::raw::c_char,
5098 len: ::std::os::raw::c_int,
5099 device: hipDevice_t,
5100 ) -> hipError_t;
5101}
5102extern "C" {
5103 #[doc = " @brief Returns an UUID for the device.[BETA]\n @param [out] uuid UUID for the device\n @param [in] device device ordinal\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue, #hipErrorNotInitialized,\n #hipErrorDeinitialized"]
5104 pub fn hipDeviceGetUuid(uuid: *mut hipUUID, device: hipDevice_t) -> hipError_t;
5105}
5106extern "C" {
5107 #[doc = " @brief Returns a value for attribute of link between two devices\n @param [out] value Pointer of the value for the attrubute\n @param [in] attr enum of hipDeviceP2PAttr to query\n @param [in] srcDevice The source device of the link\n @param [in] dstDevice The destination device of the link\n\n @returns #hipSuccess, #hipErrorInvalidDevice"]
5108 pub fn hipDeviceGetP2PAttribute(
5109 value: *mut ::std::os::raw::c_int,
5110 attr: hipDeviceP2PAttr,
5111 srcDevice: ::std::os::raw::c_int,
5112 dstDevice: ::std::os::raw::c_int,
5113 ) -> hipError_t;
5114}
5115extern "C" {
5116 #[doc = " @brief Returns a PCI Bus Id string for the device, overloaded to take int device ID.\n @param [out] pciBusId The string of PCI Bus Id format for the device\n @param [in] len Maximum length of string\n @param [in] device The device ordinal\n\n @returns #hipSuccess, #hipErrorInvalidDevice"]
5117 pub fn hipDeviceGetPCIBusId(
5118 pciBusId: *mut ::std::os::raw::c_char,
5119 len: ::std::os::raw::c_int,
5120 device: ::std::os::raw::c_int,
5121 ) -> hipError_t;
5122}
5123extern "C" {
5124 #[doc = " @brief Returns a handle to a compute device.\n @param [out] device The handle of the device\n @param [in] pciBusId The string of PCI Bus Id for the device\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
5125 pub fn hipDeviceGetByPCIBusId(
5126 device: *mut ::std::os::raw::c_int,
5127 pciBusId: *const ::std::os::raw::c_char,
5128 ) -> hipError_t;
5129}
5130extern "C" {
5131 #[doc = " @brief Returns the total amount of memory on the device.\n @param [out] bytes The size of memory in bytes, on the device\n @param [in] device The ordinal of the device\n\n @returns #hipSuccess, #hipErrorInvalidDevice"]
5132 pub fn hipDeviceTotalMem(bytes: *mut usize, device: hipDevice_t) -> hipError_t;
5133}
5134extern "C" {
5135 #[doc = " @}\n/\n/**\n @defgroup Device Device Management\n @{\n This section describes the device management functions of HIP runtime API.\n/\n/**\n @brief Waits on all active streams on current device\n\n When this command is invoked, the host thread gets blocked until all the commands associated\n with streams associated with the device. HIP does not support multiple blocking modes (yet!).\n\n @returns #hipSuccess\n\n @see hipSetDevice, hipDeviceReset"]
5136 pub fn hipDeviceSynchronize() -> hipError_t;
5137}
5138extern "C" {
5139 #[doc = " @brief The state of current device is discarded and updated to a fresh state.\n\n Calling this function deletes all streams created, memory allocated, kernels running, events\n created. Make sure that no other thread is using the device or streams, memory, kernels, events\n associated with the current device.\n\n @returns #hipSuccess\n\n @see hipDeviceSynchronize"]
5140 pub fn hipDeviceReset() -> hipError_t;
5141}
5142extern "C" {
5143 #[doc = " @brief Set default device to be used for subsequent hip API calls from this thread.\n\n @param[in] deviceId Valid device in range 0...hipGetDeviceCount().\n\n Sets @p device as the default device for the calling host thread. Valid device id's are 0...\n (hipGetDeviceCount()-1).\n\n Many HIP APIs implicitly use the \"default device\" :\n\n - Any device memory subsequently allocated from this host thread (using hipMalloc) will be\n allocated on device.\n - Any streams or events created from this host thread will be associated with device.\n - Any kernels launched from this host thread (using hipLaunchKernel) will be executed on device\n (unless a specific stream is specified, in which case the device associated with that stream will\n be used).\n\n This function may be called from any host thread. Multiple host threads may use the same device.\n This function does no synchronization with the previous or new device, and has very little\n runtime overhead. Applications can use hipSetDevice to quickly switch the default device before\n making a HIP runtime call which uses the default device.\n\n The default device is stored in thread-local-storage for each thread.\n Thread-pool implementations may inherit the default device of the previous thread. A good\n practice is to always call hipSetDevice at the start of HIP coding sequency to establish a known\n standard device.\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorNoDevice\n\n @see #hipGetDevice, #hipGetDeviceCount"]
5144 pub fn hipSetDevice(deviceId: ::std::os::raw::c_int) -> hipError_t;
5145}
5146extern "C" {
5147 #[doc = " @brief Set a list of devices that can be used.\n\n @param[in] device_arr List of devices to try\n @param[in] len Number of devices in specified list\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see #hipGetDevice, #hipGetDeviceCount. #hipSetDevice. #hipGetDeviceProperties. #hipSetDeviceFlags. #hipChooseDevice\n"]
5148 pub fn hipSetValidDevices(
5149 device_arr: *mut ::std::os::raw::c_int,
5150 len: ::std::os::raw::c_int,
5151 ) -> hipError_t;
5152}
5153extern "C" {
5154 #[doc = " @brief Return the default device id for the calling host thread.\n\n @param [out] deviceId *device is written with the default device\n\n HIP maintains an default device for each thread using thread-local-storage.\n This device is used implicitly for HIP runtime APIs called by this thread.\n hipGetDevice returns in * @p device the default device for the calling host thread.\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see hipSetDevice, hipGetDevicesizeBytes"]
5155 pub fn hipGetDevice(deviceId: *mut ::std::os::raw::c_int) -> hipError_t;
5156}
5157extern "C" {
5158 #[doc = " @brief Return number of compute-capable devices.\n\n @param [out] count Returns number of compute-capable devices.\n\n @returns #hipSuccess, #hipErrorNoDevice\n\n\n Returns in @p *count the number of devices that have ability to run compute commands. If there\n are no such devices, then @ref hipGetDeviceCount will return #hipErrorNoDevice. If 1 or more\n devices can be found, then hipGetDeviceCount returns #hipSuccess."]
5159 pub fn hipGetDeviceCount(count: *mut ::std::os::raw::c_int) -> hipError_t;
5160}
5161extern "C" {
5162 #[doc = " @brief Query for a specific device attribute.\n\n @param [out] pi pointer to value to return\n @param [in] attr attribute to query\n @param [in] deviceId which device to query for information\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
5163 pub fn hipDeviceGetAttribute(
5164 pi: *mut ::std::os::raw::c_int,
5165 attr: hipDeviceAttribute_t,
5166 deviceId: ::std::os::raw::c_int,
5167 ) -> hipError_t;
5168}
5169extern "C" {
5170 #[doc = " @brief Returns the default memory pool of the specified device\n\n @param [out] mem_pool Default memory pool to return\n @param [in] device Device index for query the default memory pool\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @see hipDeviceGetDefaultMemPool, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute,\n hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
5171 pub fn hipDeviceGetDefaultMemPool(
5172 mem_pool: *mut hipMemPool_t,
5173 device: ::std::os::raw::c_int,
5174 ) -> hipError_t;
5175}
5176extern "C" {
5177 #[doc = " @brief Sets the current memory pool of a device\n\n The memory pool must be local to the specified device.\n @p hipMallocAsync allocates from the current mempool of the provided stream's device.\n By default, a device's current memory pool is its default memory pool.\n\n @note Use @p hipMallocFromPoolAsync for asynchronous memory allocations from a device\n different than the one the stream runs on.\n\n @param [in] device Device index for the update\n @param [in] mem_pool Memory pool for update as the current on the specified device\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDevice, #hipErrorNotSupported\n\n @see hipDeviceGetDefaultMemPool, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute,\n hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
5178 pub fn hipDeviceSetMemPool(device: ::std::os::raw::c_int, mem_pool: hipMemPool_t)
5179 -> hipError_t;
5180}
5181extern "C" {
5182 #[doc = " @brief Gets the current memory pool for the specified device\n\n Returns the last pool provided to @p hipDeviceSetMemPool for this device\n or the device's default memory pool if @p hipDeviceSetMemPool has never been called.\n By default the current mempool is the default mempool for a device,\n otherwise the returned pool must have been set with @p hipDeviceSetMemPool.\n\n @param [out] mem_pool Current memory pool on the specified device\n @param [in] device Device index to query the current memory pool\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @see hipDeviceGetDefaultMemPool, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute,\n hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
5183 pub fn hipDeviceGetMemPool(
5184 mem_pool: *mut hipMemPool_t,
5185 device: ::std::os::raw::c_int,
5186 ) -> hipError_t;
5187}
5188extern "C" {
5189 #[doc = " @brief Returns device properties.\n\n @param [out] prop written with device properties\n @param [in] deviceId which device to query for information\n\n @returns #hipSuccess, #hipErrorInvalidDevice\n @bug HCC always returns 0 for maxThreadsPerMultiProcessor\n @bug HCC always returns 0 for regsPerBlock\n @bug HCC always returns 0 for l2CacheSize\n\n Populates hipGetDeviceProperties with information for the specified device."]
5190 pub fn hipGetDevicePropertiesR0600(
5191 prop: *mut hipDeviceProp_tR0600,
5192 deviceId: ::std::os::raw::c_int,
5193 ) -> hipError_t;
5194}
5195extern "C" {
5196 #[doc = " @brief Gets the maximum width for 1D linear textures on the specified device\n\n This function queries the maximum width, in elements, of 1D linear textures that can be allocated\n on the specified device. The maximum width depends on the texture element size and the hardware\n limitations of the device.\n\n @param [out] max_width Maximum width, in elements, of 1D linear textures that the device can support\n @param [in] device Device index to query for maximum 1D texture width\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDevice\n\n @see hipDeviceGetAttribute, hipMalloc, hipTexRefSetAddressMode"]
5197 pub fn hipDeviceGetTexture1DLinearMaxWidth(
5198 mem_pool: *mut hipMemPool_t,
5199 device: ::std::os::raw::c_int,
5200 ) -> hipError_t;
5201}
5202extern "C" {
5203 #[doc = " @brief Set L1/Shared cache partition.\n\n @param [in] cacheConfig Cache configuration\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorNotSupported\n\n Note: AMD devices do not support reconfigurable cache. This API is not implemented\n on AMD platform. If the function is called, it will return hipErrorNotSupported.\n"]
5204 pub fn hipDeviceSetCacheConfig(cacheConfig: hipFuncCache_t) -> hipError_t;
5205}
5206extern "C" {
5207 #[doc = " @brief Get Cache configuration for a specific Device\n\n @param [out] cacheConfig Pointer of cache configuration\n\n @returns #hipSuccess, #hipErrorNotInitialized\n Note: AMD devices do not support reconfigurable cache. This hint is ignored\n on these architectures.\n"]
5208 pub fn hipDeviceGetCacheConfig(cacheConfig: *mut hipFuncCache_t) -> hipError_t;
5209}
5210extern "C" {
5211 #[doc = " @brief Gets resource limits of current device\n\n The function queries the size of limit value, as required by the input enum value hipLimit_t,\n which can be either #hipLimitStackSize, or #hipLimitMallocHeapSize. Any other input as\n default, the function will return #hipErrorUnsupportedLimit.\n\n @param [out] pValue Returns the size of the limit in bytes\n @param [in] limit The limit to query\n\n @returns #hipSuccess, #hipErrorUnsupportedLimit, #hipErrorInvalidValue\n"]
5212 pub fn hipDeviceGetLimit(pValue: *mut usize, limit: hipLimit_t) -> hipError_t;
5213}
5214extern "C" {
5215 #[doc = " @brief Sets resource limits of current device.\n\n As the input enum limit,\n #hipLimitStackSize sets the limit value of the stack size on the current GPU device, per thread.\n The limit size can get via hipDeviceGetLimit. The size is in units of 256 dwords, up to the limit\n (128K - 16).\n\n #hipLimitMallocHeapSize sets the limit value of the heap used by the malloc()/free()\n calls. For limit size, use the #hipDeviceGetLimit API.\n\n Any other input as default, the funtion will return hipErrorUnsupportedLimit.\n\n @param [in] limit Enum of hipLimit_t to set\n @param [in] value The size of limit value in bytes\n\n @returns #hipSuccess, #hipErrorUnsupportedLimit, #hipErrorInvalidValue\n"]
5216 pub fn hipDeviceSetLimit(limit: hipLimit_t, value: usize) -> hipError_t;
5217}
5218extern "C" {
5219 #[doc = " @brief Returns bank width of shared memory for current device\n\n @param [out] pConfig The pointer of the bank width for shared memory\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized\n\n Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is\n ignored on those architectures.\n"]
5220 pub fn hipDeviceGetSharedMemConfig(pConfig: *mut hipSharedMemConfig) -> hipError_t;
5221}
5222extern "C" {
5223 #[doc = " @brief Gets the flags set for current device\n\n @param [out] flags Pointer of the flags\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
5224 pub fn hipGetDeviceFlags(flags: *mut ::std::os::raw::c_uint) -> hipError_t;
5225}
5226extern "C" {
5227 #[doc = " @brief The bank width of shared memory on current device is set\n\n @param [in] config Configuration for the bank width of shared memory\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized\n\n Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is\n ignored on those architectures.\n"]
5228 pub fn hipDeviceSetSharedMemConfig(config: hipSharedMemConfig) -> hipError_t;
5229}
5230extern "C" {
5231 #[doc = " @brief The current device behavior is changed according to the flags passed.\n\n @param [in] flags Flag to set on the current device\n\n The schedule flags impact how HIP waits for the completion of a command running on a device.\n\n #hipDeviceScheduleSpin : HIP runtime will actively spin in the thread which submitted\n the work until the command completes. This offers the lowest latency, but will consume a CPU\n core and may increase power.\n\n #hipDeviceScheduleYield : The HIP runtime will yield the CPU to system so that other\n tasks can use it. This may increase latency to detect the completion but will consume less\n power and is friendlier to other tasks in the system.\n\n #hipDeviceScheduleBlockingSync : On ROCm platform, this is a synonym for hipDeviceScheduleYield.\n\n #hipDeviceScheduleAuto : This is the default value if the input 'flags' is zero.\n Uses a heuristic to select between Spin and Yield modes. If the number of HIP contexts is\n greater than the number of logical processors in the system, uses Spin scheduling, otherwise\n uses Yield scheduling.\n\n #hipDeviceMapHost : Allows mapping host memory. On ROCm, this is always allowed and\n the flag is ignored.\n\n #hipDeviceLmemResizeToMax : This flag is silently ignored on ROCm.\n\n @returns #hipSuccess, #hipErrorNoDevice, #hipErrorInvalidDevice, #hipErrorSetOnActiveProcess\n\n"]
5232 pub fn hipSetDeviceFlags(flags: ::std::os::raw::c_uint) -> hipError_t;
5233}
5234extern "C" {
5235 #[doc = " @brief Device which matches hipDeviceProp_t is returned\n\n @param [out] device Pointer of the device\n @param [in] prop Pointer of the properties\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
5236 pub fn hipChooseDeviceR0600(
5237 device: *mut ::std::os::raw::c_int,
5238 prop: *const hipDeviceProp_tR0600,
5239 ) -> hipError_t;
5240}
5241extern "C" {
5242 #[doc = " @brief Returns the link type and hop count between two devices\n\n @param [in] device1 Ordinal for device1\n @param [in] device2 Ordinal for device2\n @param [out] linktype Returns the link type (See hsa_amd_link_info_type_t) between the two devices\n @param [out] hopcount Returns the hop count between the two devices\n\n Queries and returns the HSA link type and the hop count between the two specified devices.\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
5243 pub fn hipExtGetLinkTypeAndHopCount(
5244 device1: ::std::os::raw::c_int,
5245 device2: ::std::os::raw::c_int,
5246 linktype: *mut u32,
5247 hopcount: *mut u32,
5248 ) -> hipError_t;
5249}
5250extern "C" {
5251 #[doc = " @brief Gets an interprocess memory handle for an existing device memory allocation.\n\n Takes a pointer to the base of an existing device memory allocation created with ::hipMalloc\n and exports it for use in another process. This is a lightweight operation and may be called\n multiple times on an allocation without adverse effects.\n\n If a region of memory is freed with ::hipFree and a subsequent call to ::hipMalloc returns\n memory with the same device address, ::hipIpcGetMemHandle will return a unique handle for\n the new memory.\n\n @param handle - Pointer to user allocated hipIpcMemHandle to return the handle in.\n @param devPtr - Base pointer to previously allocated device memory.\n\n @returns #hipSuccess, #hipErrorInvalidHandle, #hipErrorOutOfMemory, #hipErrorMapFailed\n\n @note This IPC memory related feature API on Windows may behave differently from Linux.\n"]
5252 pub fn hipIpcGetMemHandle(
5253 handle: *mut hipIpcMemHandle_t,
5254 devPtr: *mut ::std::os::raw::c_void,
5255 ) -> hipError_t;
5256}
5257extern "C" {
5258 #[doc = " @brief Opens an interprocess memory handle exported from another process and returns a device\n pointer usable in the local process.\n\n Maps memory exported from another process with ::hipIpcGetMemHandle into the current device\n address space. For contexts on different devices ::hipIpcOpenMemHandle can attempt to enable\n peer access between the devices like the user called ::hipDeviceEnablePeerAccess.\n This behavior is controlled by the flag #hipIpcMemLazyEnablePeerAccess.\n The API ::hipDeviceCanAccessPeer can determine if a mapping is possible.\n\n hipIpcMemHandles from each device in a given process may only be opened by one context per\n device per other process.\n\n Memory returned from ::hipIpcOpenMemHandle must be freed with ::hipIpcCloseMemHandle.\n\n Calling ::hipFree on an exported memory region before calling ::hipIpcCloseMemHandle in the\n importing context will result in undefined behavior.\n\n @param devPtr - Returned device pointer\n @param handle - hipIpcMemHandle to open\n @param flags - Flags for this operation. Must be specified as hipIpcMemLazyEnablePeerAccess\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidContext,\n #hipErrorInvalidDevicePointer\n\n @note During multiple processes, using the same memory handle opened by the current context,\n there is no guarantee that the same device pointer will be returned in @p *devPtr.\n This is diffrent from CUDA.\n\n @note This IPC memory related feature API on Windows may behave differently from Linux.\n"]
5259 pub fn hipIpcOpenMemHandle(
5260 devPtr: *mut *mut ::std::os::raw::c_void,
5261 handle: hipIpcMemHandle_t,
5262 flags: ::std::os::raw::c_uint,
5263 ) -> hipError_t;
5264}
5265extern "C" {
5266 #[doc = " @brief Close memory mapped with ::hipIpcOpenMemHandle\n\n Unmaps memory returned by ::hipIpcOpenMemHandle. The original allocation in the exporting\n process as well as imported mappings in other processes will be unaffected.\n\n Any resources used to enable peer access will be freed if this is the last mapping using them.\n\n @param devPtr - Device pointer returned by ::hipIpcOpenMemHandle\n\n @returns #hipSuccess, #hipErrorMapFailed, #hipErrorInvalidHandle\n\n @note This IPC memory related feature API on Windows may behave differently from Linux.\n"]
5267 pub fn hipIpcCloseMemHandle(devPtr: *mut ::std::os::raw::c_void) -> hipError_t;
5268}
5269extern "C" {
5270 #[doc = " @brief Gets an opaque interprocess handle for an event.\n\n The event is previously allocated with #hipEventInterprocess and #hipEventDisableTiming flags.\n The opaque interprocess handle may be copied into other processes and opened with\n ::hipIpcOpenEventHandle. Then ::hipEventRecord, ::hipEventSynchronize, ::hipStreamWaitEvent and\n ::hipEventQuery may be used in either process. After the exported event has been freed with\n ::hipEventDestroy, operations on the imported event will result in undefined behavior.\n\n @param[out] handle Pointer to #hipIpcEventHandle to return the opaque event handle\n @param[in] event Event allocated with #hipEventInterprocess and #hipEventDisableTiming flags\n\n @returns #hipSuccess, #hipErrorInvalidConfiguration, #hipErrorInvalidValue\n\n @note This IPC event related feature API is currently applicable on Linux.\n"]
5271 pub fn hipIpcGetEventHandle(handle: *mut hipIpcEventHandle_t, event: hipEvent_t) -> hipError_t;
5272}
5273extern "C" {
5274 #[doc = " @brief Opens an interprocess event handle.\n\n Opens an interprocess event handle exported from another process with ::hipIpcGetEventHandle.\n The returned #hipEvent_t behaves like a locally created event with the #hipEventDisableTiming\n flag specified. This event needs be freed with ::hipEventDestroy. After the exported event\n has been freed with ::hipEventDestroy, operations on the imported event will result in\n undefined behavior. If the input handle is from the same process, it will return\n #hipErrorInvalidContext.\n\n @param[out] event Pointer to hipEvent_t to return the imported event\n @param[in] handle The opaque interprocess handle to open\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidContext\n\n @note This IPC event related feature API is currently applicable on Linux.\n"]
5275 pub fn hipIpcOpenEventHandle(event: *mut hipEvent_t, handle: hipIpcEventHandle_t)
5276 -> hipError_t;
5277}
5278extern "C" {
5279 #[doc = " @}\n/\n/**\n\n @defgroup Execution Execution Control\n @{\n This section describes the execution control functions of HIP runtime API.\n\n/\n/**\n @brief Set attribute for a specific function\n\n @param [in] func Pointer of the function\n @param [in] attr Attribute to set\n @param [in] value Value to set\n\n @returns #hipSuccess, #hipErrorInvalidDeviceFunction, #hipErrorInvalidValue\n\n Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is\n ignored on those architectures.\n"]
5280 pub fn hipFuncSetAttribute(
5281 func: *const ::std::os::raw::c_void,
5282 attr: hipFuncAttribute,
5283 value: ::std::os::raw::c_int,
5284 ) -> hipError_t;
5285}
5286extern "C" {
5287 #[doc = " @brief Set Cache configuration for a specific function\n\n @param [in] func Pointer of the function.\n @param [in] config Configuration to set.\n\n @returns #hipSuccess, #hipErrorNotInitialized\n Note: AMD devices and some Nvidia GPUS do not support reconfigurable cache. This hint is ignored\n on those architectures.\n"]
5288 pub fn hipFuncSetCacheConfig(
5289 func: *const ::std::os::raw::c_void,
5290 config: hipFuncCache_t,
5291 ) -> hipError_t;
5292}
5293extern "C" {
5294 #[doc = " @brief Set shared memory configuation for a specific function\n\n @param [in] func Pointer of the function\n @param [in] config Configuration\n\n @returns #hipSuccess, #hipErrorInvalidDeviceFunction, #hipErrorInvalidValue\n\n Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is\n ignored on those architectures.\n"]
5295 pub fn hipFuncSetSharedMemConfig(
5296 func: *const ::std::os::raw::c_void,
5297 config: hipSharedMemConfig,
5298 ) -> hipError_t;
5299}
5300extern "C" {
5301 #[doc = " @}\n/\n/**\n-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n @defgroup Error Error Handling\n @{\n This section describes the error handling functions of HIP runtime API.\n/\n/**\n @brief Return last error returned by any HIP runtime API call and resets the stored error code to\n #hipSuccess\n\n @returns return code from last HIP called from the active host thread\n\n Returns the last error that has been returned by any of the runtime calls in the same host\n thread, and then resets the saved error to #hipSuccess.\n\n @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t"]
5302 pub fn hipGetLastError() -> hipError_t;
5303}
5304extern "C" {
5305 #[doc = " @brief Return last error returned by any HIP runtime API call and resets the stored error code to\n #hipSuccess\n\n @returns return code from last HIP called from the active host thread\n\n Returns the last error that has been returned by any of the runtime calls in the same host\n thread, and then resets the saved error to #hipSuccess.\n\n @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t"]
5306 pub fn hipExtGetLastError() -> hipError_t;
5307}
5308extern "C" {
5309 #[doc = " @brief Return last error returned by any HIP runtime API call.\n\n @returns #hipSuccess\n\n Returns the last error that has been returned by any of the runtime calls in the same host\n thread. Unlike hipGetLastError, this function does not reset the saved error code.\n\n @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t"]
5310 pub fn hipPeekAtLastError() -> hipError_t;
5311}
5312extern "C" {
5313 #[doc = " @brief Return hip error as text string form.\n\n @param hip_error Error code to convert to name.\n @returns const char pointer to the NULL-terminated error name\n\n @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t"]
5314 pub fn hipGetErrorName(hip_error: hipError_t) -> *const ::std::os::raw::c_char;
5315}
5316extern "C" {
5317 #[doc = " @brief Return handy text string message to explain the error which occurred\n\n @param hipError Error code to convert to string.\n @returns const char pointer to the NULL-terminated error string\n\n @see hipGetErrorName, hipGetLastError, hipPeakAtLastError, hipError_t"]
5318 pub fn hipGetErrorString(hipError: hipError_t) -> *const ::std::os::raw::c_char;
5319}
5320extern "C" {
5321 #[doc = " @brief Return hip error as text string form.\n\n @param [in] hipError Error code to convert to string.\n @param [out] errorString char pointer to the NULL-terminated error string\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipGetErrorName, hipGetLastError, hipPeakAtLastError, hipError_t"]
5322 pub fn hipDrvGetErrorName(
5323 hipError: hipError_t,
5324 errorString: *mut *const ::std::os::raw::c_char,
5325 ) -> hipError_t;
5326}
5327extern "C" {
5328 #[doc = " @brief Return handy text string message to explain the error which occurred\n\n @param [in] hipError Error code to convert to string.\n @param [out] errorString char pointer to the NULL-terminated error string\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipGetErrorName, hipGetLastError, hipPeakAtLastError, hipError_t"]
5329 pub fn hipDrvGetErrorString(
5330 hipError: hipError_t,
5331 errorString: *mut *const ::std::os::raw::c_char,
5332 ) -> hipError_t;
5333}
5334extern "C" {
5335 #[doc = " @brief Create an asynchronous stream.\n\n @param[in, out] stream Valid pointer to hipStream_t. This function writes the memory with the\n newly created stream.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Create a new asynchronous stream. @p stream returns an opaque handle that can be used to\n reference the newly created stream in subsequent hipStream* commands. The stream is allocated on\n the heap and will remain allocated even if the handle goes out-of-scope. To release the memory\n used by the stream, application must call hipStreamDestroy.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
5336 pub fn hipStreamCreate(stream: *mut hipStream_t) -> hipError_t;
5337}
5338extern "C" {
5339 #[doc = " @brief Create an asynchronous stream.\n\n @param[in, out] stream Pointer to new stream\n @param[in ] flags to control stream creation.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Create a new asynchronous stream. @p stream returns an opaque handle that can be used to\n reference the newly created stream in subsequent hipStream* commands. The stream is allocated on\n the heap and will remain allocated even if the handle goes out-of-scope. To release the memory\n used by the stream, application must call hipStreamDestroy. Flags controls behavior of the\n stream. See #hipStreamDefault, #hipStreamNonBlocking.\n\n\n @see hipStreamCreate, hipStreamCreateWithPriority, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
5340 pub fn hipStreamCreateWithFlags(
5341 stream: *mut hipStream_t,
5342 flags: ::std::os::raw::c_uint,
5343 ) -> hipError_t;
5344}
5345extern "C" {
5346 #[doc = " @brief Create an asynchronous stream with the specified priority.\n\n @param[in, out] stream Pointer to new stream\n @param[in ] flags to control stream creation.\n @param[in ] priority of the stream. Lower numbers represent higher priorities.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Create a new asynchronous stream with the specified priority. @p stream returns an opaque handle\n that can be used to reference the newly created stream in subsequent hipStream* commands. The\n stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope.\n To release the memory used by the stream, application must call hipStreamDestroy. Flags controls\n behavior of the stream. See #hipStreamDefault, #hipStreamNonBlocking.\n\n\n @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
5347 pub fn hipStreamCreateWithPriority(
5348 stream: *mut hipStream_t,
5349 flags: ::std::os::raw::c_uint,
5350 priority: ::std::os::raw::c_int,
5351 ) -> hipError_t;
5352}
5353extern "C" {
5354 #[doc = " @brief Returns numerical values that correspond to the least and greatest stream priority.\n\n @param[in, out] leastPriority pointer in which value corresponding to least priority is returned.\n @param[in, out] greatestPriority pointer in which value corresponding to greatest priority is returned.\n @returns #hipSuccess\n\n Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least\n and greatest stream priority respectively. Stream priorities follow a convention where lower numbers\n imply greater priorities. The range of meaningful stream priorities is given by\n [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value\n that is outside the meaningful range as specified by this API, the priority is automatically\n clamped to within the valid range."]
5355 pub fn hipDeviceGetStreamPriorityRange(
5356 leastPriority: *mut ::std::os::raw::c_int,
5357 greatestPriority: *mut ::std::os::raw::c_int,
5358 ) -> hipError_t;
5359}
5360extern "C" {
5361 #[doc = " @brief Destroys the specified stream.\n\n @param[in] stream stream identifier.\n @returns #hipSuccess #hipErrorInvalidHandle\n\n Destroys the specified stream.\n\n If commands are still executing on the specified stream, some may complete execution before the\n queue is deleted.\n\n The queue may be destroyed while some commands are still inflight, or may wait for all commands\n queued to the stream before destroying it.\n\n @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamQuery,\n hipStreamWaitEvent, hipStreamSynchronize"]
5362 pub fn hipStreamDestroy(stream: hipStream_t) -> hipError_t;
5363}
5364extern "C" {
5365 #[doc = " @brief Return #hipSuccess if all of the operations in the specified @p stream have completed, or\n #hipErrorNotReady if not.\n\n @param[in] stream stream to query\n\n @returns #hipSuccess, #hipErrorNotReady, #hipErrorInvalidHandle\n\n This is thread-safe and returns a snapshot of the current state of the queue. However, if other\n host threads are sending work to the stream, the status may change immediately after the function\n is called. It is typically used for debug.\n\n @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamWaitEvent,\n hipStreamSynchronize, hipStreamDestroy"]
5366 pub fn hipStreamQuery(stream: hipStream_t) -> hipError_t;
5367}
5368extern "C" {
5369 #[doc = " @brief Wait for all commands in stream to complete.\n\n @param[in] stream stream identifier.\n\n @returns #hipSuccess, #hipErrorInvalidHandle\n\n This command is host-synchronous : the host will block until the specified stream is empty.\n\n This command follows standard null-stream semantics. Specifically, specifying the null stream\n will cause the command to wait for other streams on the same device to complete all pending\n operations.\n\n This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active\n or blocking.\n\n @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamWaitEvent,\n hipStreamDestroy\n"]
5370 pub fn hipStreamSynchronize(stream: hipStream_t) -> hipError_t;
5371}
5372extern "C" {
5373 #[doc = " @brief Make the specified compute stream wait for an event\n\n @param[in] stream Stream to make wait\n @param[in] event Event to wait on\n @param[in] flags Parameters to control the operation\n\n @returns #hipSuccess, #hipErrorInvalidHandle, #hipErrorInvalidValue,\n #hipErrorStreamCaptureIsolation\n\n This function inserts a wait operation into the specified stream.\n All future work submitted to @p stream will wait until @p event reports completion before\n beginning execution.\n\n Flags include:\n hipEventWaitDefault: Default event creation flag.\n hipEventWaitExternal: Wait is captured in the graph as an external event node when\n performing stream capture\n\n This function only waits for commands in the current stream to complete. Notably, this function\n does not implicitly wait for commands in the default stream to complete, even if the specified\n stream is created with hipStreamNonBlocking = 0.\n\n @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamSynchronize, hipStreamDestroy"]
5374 pub fn hipStreamWaitEvent(
5375 stream: hipStream_t,
5376 event: hipEvent_t,
5377 flags: ::std::os::raw::c_uint,
5378 ) -> hipError_t;
5379}
5380extern "C" {
5381 #[doc = " @brief Return flags associated with this stream.\n\n @param[in] stream stream to be queried\n @param[in,out] flags Pointer to an unsigned integer in which the stream's flags are returned\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidHandle\n\n @returns #hipSuccess #hipErrorInvalidValue #hipErrorInvalidHandle\n\n Return flags associated with this stream in *@p flags.\n\n @see hipStreamCreateWithFlags"]
5382 pub fn hipStreamGetFlags(stream: hipStream_t, flags: *mut ::std::os::raw::c_uint)
5383 -> hipError_t;
5384}
5385extern "C" {
5386 #[doc = " @brief Query the priority of a stream.\n\n @param[in] stream stream to be queried\n @param[in,out] priority Pointer to an unsigned integer in which the stream's priority is returned\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidHandle\n\n @returns #hipSuccess #hipErrorInvalidValue #hipErrorInvalidHandle\n\n Query the priority of a stream. The priority is returned in in priority.\n\n @see hipStreamCreateWithFlags"]
5387 pub fn hipStreamGetPriority(
5388 stream: hipStream_t,
5389 priority: *mut ::std::os::raw::c_int,
5390 ) -> hipError_t;
5391}
5392extern "C" {
5393 #[doc = " @brief Get the device assocaited with the stream\n\n @param[in] stream stream to be queried\n @param[out] device device associated with the stream\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorContextIsDestroyed, #hipErrorInvalidHandle,\n #hipErrorNotInitialized, #hipErrorDeinitialized, #hipErrorInvalidContext\n\n @see hipStreamCreate, hipStreamDestroy, hipDeviceGetStreamPriorityRange"]
5394 pub fn hipStreamGetDevice(stream: hipStream_t, device: *mut hipDevice_t) -> hipError_t;
5395}
5396extern "C" {
5397 #[doc = " @brief Create an asynchronous stream with the specified CU mask.\n\n @param[in, out] stream Pointer to new stream\n @param[in ] cuMaskSize Size of CU mask bit array passed in.\n @param[in ] cuMask Bit-vector representing the CU mask. Each active bit represents using one CU.\n The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical\n CU number (i.e., multiProcessorCount member of hipDeviceProp_t), the extra elements are ignored.\n It is user's responsibility to make sure the input is meaningful.\n @returns #hipSuccess, #hipErrorInvalidHandle, #hipErrorInvalidValue\n\n Create a new asynchronous stream with the specified CU mask. @p stream returns an opaque handle\n that can be used to reference the newly created stream in subsequent hipStream* commands. The\n stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope.\n To release the memory used by the stream, application must call hipStreamDestroy.\n\n\n @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
5398 pub fn hipExtStreamCreateWithCUMask(
5399 stream: *mut hipStream_t,
5400 cuMaskSize: u32,
5401 cuMask: *const u32,
5402 ) -> hipError_t;
5403}
5404extern "C" {
5405 #[doc = " @brief Get CU mask associated with an asynchronous stream\n\n @param[in] stream stream to be queried\n @param[in] cuMaskSize number of the block of memories (uint32_t *) allocated by user\n @param[out] cuMask Pointer to a pre-allocated block of memories (uint32_t *) in which\n the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where\n each active bit represents one active CU\n @returns #hipSuccess, #hipErrorInvalidHandle, #hipErrorInvalidValue\n\n @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
5406 pub fn hipExtStreamGetCUMask(
5407 stream: hipStream_t,
5408 cuMaskSize: u32,
5409 cuMask: *mut u32,
5410 ) -> hipError_t;
5411}
5412#[doc = " Stream CallBack struct"]
5413pub type hipStreamCallback_t = ::std::option::Option<
5414 unsafe extern "C" fn(
5415 stream: hipStream_t,
5416 status: hipError_t,
5417 userData: *mut ::std::os::raw::c_void,
5418 ),
5419>;
5420extern "C" {
5421 #[doc = " @brief Adds a callback to be called on the host after all currently enqueued\n items in the stream have completed. For each\n hipStreamAddCallback call, a callback will be executed exactly once.\n The callback will block later work in the stream until it is finished.\n @param[in] stream - Stream to add callback to\n @param[in] callback - The function to call once preceding stream operations are complete\n @param[in] userData - User specified data to be passed to the callback function\n @param[in] flags - Reserved for future use, must be 0\n @returns #hipSuccess, #hipErrorInvalidHandle, #hipErrorNotSupported\n\n @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamQuery, hipStreamSynchronize,\n hipStreamWaitEvent, hipStreamDestroy, hipStreamCreateWithPriority\n"]
5422 pub fn hipStreamAddCallback(
5423 stream: hipStream_t,
5424 callback: hipStreamCallback_t,
5425 userData: *mut ::std::os::raw::c_void,
5426 flags: ::std::os::raw::c_uint,
5427 ) -> hipError_t;
5428}
5429extern "C" {
5430 #[doc = " @brief Enqueues a wait command to the stream.[BETA]\n\n @param [in] stream - Stream identifier\n @param [in] ptr - Pointer to memory object allocated using #hipMallocSignalMemory flag\n @param [in] value - Value to be used in compare operation\n @param [in] flags - Defines the compare operation, supported values are #hipStreamWaitValueGte\n #hipStreamWaitValueEq, #hipStreamWaitValueAnd and #hipStreamWaitValueNor\n @param [in] mask - Mask to be applied on value at memory before it is compared with value,\n default value is set to enable every bit\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Enqueues a wait command to the stream, all operations enqueued on this stream after this, will\n not execute until the defined wait condition is true.\n\n #hipStreamWaitValueGte: waits until *ptr&mask >= value\n\n #hipStreamWaitValueEq : waits until *ptr&mask == value\n\n #hipStreamWaitValueAnd: waits until ((*ptr&mask) & value) != 0\n\n #hipStreamWaitValueNor: waits until ~((*ptr&mask) | (value&mask)) != 0\n\n @note when using #hipStreamWaitValueNor, mask is applied on both 'value' and '*ptr'.\n\n @note Support for #hipStreamWaitValue32 can be queried using 'hipDeviceGetAttribute()' and\n 'hipDeviceAttributeCanUseStreamWaitValue' flag.\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @see hipExtMallocWithFlags, hipFree, hipStreamWaitValue64, hipStreamWriteValue64,\n hipStreamWriteValue32, hipDeviceGetAttribute"]
5431 pub fn hipStreamWaitValue32(
5432 stream: hipStream_t,
5433 ptr: *mut ::std::os::raw::c_void,
5434 value: u32,
5435 flags: ::std::os::raw::c_uint,
5436 mask: u32,
5437 ) -> hipError_t;
5438}
5439extern "C" {
5440 #[doc = " @brief Enqueues a wait command to the stream.[BETA]\n\n @param [in] stream - Stream identifier\n @param [in] ptr - Pointer to memory object allocated using 'hipMallocSignalMemory' flag\n @param [in] value - Value to be used in compare operation\n @param [in] flags - Defines the compare operation, supported values are #hipStreamWaitValueGte\n #hipStreamWaitValueEq, #hipStreamWaitValueAnd and #hipStreamWaitValueNor.\n @param [in] mask - Mask to be applied on value at memory before it is compared with value\n default value is set to enable every bit\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Enqueues a wait command to the stream, all operations enqueued on this stream after this, will\n not execute until the defined wait condition is true.\n\n #hipStreamWaitValueGte: waits until *ptr&mask >= value\n\n #hipStreamWaitValueEq : waits until *ptr&mask == value\n\n #hipStreamWaitValueAnd: waits until ((*ptr&mask) & value) != 0\n\n #hipStreamWaitValueNor: waits until ~((*ptr&mask) | (value&mask)) != 0\n\n @note when using #hipStreamWaitValueNor, mask is applied on both 'value' and '*ptr'.\n\n @note Support for hipStreamWaitValue64 can be queried using 'hipDeviceGetAttribute()' and\n 'hipDeviceAttributeCanUseStreamWaitValue' flag.\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @see hipExtMallocWithFlags, hipFree, hipStreamWaitValue32, hipStreamWriteValue64,\n hipStreamWriteValue32, hipDeviceGetAttribute"]
5441 pub fn hipStreamWaitValue64(
5442 stream: hipStream_t,
5443 ptr: *mut ::std::os::raw::c_void,
5444 value: u64,
5445 flags: ::std::os::raw::c_uint,
5446 mask: u64,
5447 ) -> hipError_t;
5448}
5449extern "C" {
5450 #[doc = " @brief Enqueues a write command to the stream.[BETA]\n\n @param [in] stream - Stream identifier\n @param [in] ptr - Pointer to a GPU accessible memory object\n @param [in] value - Value to be written\n @param [in] flags - reserved, ignored for now, will be used in future releases\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Enqueues a write command to the stream, write operation is performed after all earlier commands\n on this stream have completed the execution.\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @see hipExtMallocWithFlags, hipFree, hipStreamWriteValue32, hipStreamWaitValue32,\n hipStreamWaitValue64"]
5451 pub fn hipStreamWriteValue32(
5452 stream: hipStream_t,
5453 ptr: *mut ::std::os::raw::c_void,
5454 value: u32,
5455 flags: ::std::os::raw::c_uint,
5456 ) -> hipError_t;
5457}
5458extern "C" {
5459 #[doc = " @brief Enqueues a write command to the stream.[BETA]\n\n @param [in] stream - Stream identifier\n @param [in] ptr - Pointer to a GPU accessible memory object\n @param [in] value - Value to be written\n @param [in] flags - reserved, ignored for now, will be used in future releases\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Enqueues a write command to the stream, write operation is performed after all earlier commands\n on this stream have completed the execution.\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @see hipExtMallocWithFlags, hipFree, hipStreamWriteValue32, hipStreamWaitValue32,\n hipStreamWaitValue64"]
5460 pub fn hipStreamWriteValue64(
5461 stream: hipStream_t,
5462 ptr: *mut ::std::os::raw::c_void,
5463 value: u64,
5464 flags: ::std::os::raw::c_uint,
5465 ) -> hipError_t;
5466}
5467extern "C" {
5468 #[doc = " @brief Enqueues an array of stream memory operations in the stream.[BETA]\n\n @param [in] stream - Stream identifier\n @param [in] count - The number of operations in the array. Must be less than 256\n @param [in] paramArray - The types and parameters of the individual operations.\n @param [in] flags - Reserved for future expansion; must be 0.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Batch operations to synchronize the stream via memory operations.\n\n @warning This API is marked as beta, meaning, while this is feature complete,\n it is still open to changes and may have outstanding issues.\n\n @see hipStreamWriteValue32, hipStreamWaitValue32,\n hipStreamWaitValue64. hipStreamWriteValue64"]
5469 pub fn hipStreamBatchMemOp(
5470 stream: hipStream_t,
5471 count: ::std::os::raw::c_uint,
5472 paramArray: *mut hipStreamBatchMemOpParams,
5473 flags: ::std::os::raw::c_uint,
5474 ) -> hipError_t;
5475}
5476extern "C" {
5477 #[doc = " @brief Creates a batch memory operation node and adds it to a graph.[BETA]\n\n @param [in] phGraphNode - Returns the newly created node\n @param [in] hGraph - Graph to which to add the node\n @param [in] dependencies - Dependencies of the node\n @param [in] numDependencies - Number of dependencies\n @param [in] nodeParams - Parameters for the node\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as beta, meaning, while this is feature complete,\n it is still open to changes and may have outstanding issues.\n\n @see hipStreamWriteValue32, hipStreamWaitValue32,\n hipStreamWaitValue64. hipStreamWriteValue64, hipStreamBatchMemOp"]
5478 pub fn hipGraphAddBatchMemOpNode(
5479 phGraphNode: *mut hipGraphNode_t,
5480 hGraph: hipGraph_t,
5481 dependencies: *const hipGraphNode_t,
5482 numDependencies: usize,
5483 nodeParams: *const hipBatchMemOpNodeParams,
5484 ) -> hipError_t;
5485}
5486extern "C" {
5487 #[doc = " @brief Returns a batch mem op node's parameters.[BETA]\n\n @param [in] hNode - Node to get the parameters for\n @param [in] nodeParams_out - Pointer to return the parameters\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Returns the parameters of batch mem op node hNode in nodeParams_out.\n The paramArray returned in nodeParams_out is owned by the node.\n This memory remains valid until the node is destroyed or its parameters are modified,\n and should not be modified directly.\n\n @warning This API is marked as beta, meaning, while this is feature complete,\n it is still open to changes and may have outstanding issues.\n\n @see hipStreamWriteValue32, hipStreamWaitValue32,\n hipStreamWaitValue64. hipStreamWriteValue64. hipGraphBatchMemOpNodeSetParams"]
5488 pub fn hipGraphBatchMemOpNodeGetParams(
5489 hNode: hipGraphNode_t,
5490 nodeParams_out: *mut hipBatchMemOpNodeParams,
5491 ) -> hipError_t;
5492}
5493extern "C" {
5494 #[doc = " @brief Sets the batch mem op node's parameters.[BETA]\n\n @param [in] hNode - Node to set the parameters for\n @param [in] nodeParams - Parameters to copy\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Sets the parameters of batch mem op node hNode to nodeParams.\n\n @warning This API is marked as beta, meaning, while this is feature complete,\n it is still open to changes and may have outstanding issues.\n\n @see hipStreamWriteValue32, hipStreamWaitValue32,\n hipStreamWaitValue64. hipStreamWriteValue64, hipGraphBatchMemOpNodeGetParams"]
5495 pub fn hipGraphBatchMemOpNodeSetParams(
5496 hNode: hipGraphNode_t,
5497 nodeParams: *mut hipBatchMemOpNodeParams,
5498 ) -> hipError_t;
5499}
5500extern "C" {
5501 #[doc = " @brief Sets the parameters for a batch mem op node in the given graphExec.[BETA]\n\n @param [in] hGraphExec - The executable graph in which to set the specified node\n @param [in] hNode - Batch mem op node from the graph from which graphExec was instantiated\n @param [in] nodeParams - Updated Parameters to set\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n Sets the parameters of a batch mem op node in an executable graph hGraphExec.\n The node is identified by the corresponding node hNode in the non-executable graph,\n from which the executable graph was instantiated.\n\n @warning This API is marked as beta, meaning, while this is feature complete,\n it is still open to changes and may have outstanding issues.\n\n @see hipStreamWriteValue32, hipStreamWaitValue32,\n hipStreamWaitValue64. hipStreamWriteValue64, hipStreamBatchMemOp"]
5502 pub fn hipGraphExecBatchMemOpNodeSetParams(
5503 hGraphExec: hipGraphExec_t,
5504 hNode: hipGraphNode_t,
5505 nodeParams: *const hipBatchMemOpNodeParams,
5506 ) -> hipError_t;
5507}
5508extern "C" {
5509 #[doc = " @}\n/\n/**\n-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n @defgroup Event Event Management\n @{\n This section describes the event management functions of HIP runtime API.\n/\n/**\n @brief Create an event with the specified flags\n\n @param[in,out] event Returns the newly created event.\n @param[in] flags Flags to control event behavior. Valid values are #hipEventDefault,\n#hipEventBlockingSync, #hipEventDisableTiming, #hipEventInterprocess\n #hipEventDefault : Default flag. The event will use active synchronization and will support\ntiming. Blocking synchronization provides lowest possible latency at the expense of dedicating a\nCPU to poll on the event.\n #hipEventBlockingSync : The event will use blocking synchronization : if hipEventSynchronize is\ncalled on this event, the thread will block until the event completes. This can increase latency\nfor the synchroniation but can result in lower power and more resources for other CPU threads.\n #hipEventDisableTiming : Disable recording of timing information. Events created with this flag\nwould not record profiling data and provide best performance if used for synchronization.\n #hipEventInterprocess : The event can be used as an interprocess event. hipEventDisableTiming\nflag also must be set when hipEventInterprocess flag is set.\n #hipEventDisableSystemFence : Disable acquire and release system scope fence. This may\nimprove performance but device memory may not be visible to the host and other devices\nif this flag is set.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,\n#hipErrorLaunchFailure, #hipErrorOutOfMemory\n\n @see hipEventCreate, hipEventSynchronize, hipEventDestroy, hipEventElapsedTime"]
5510 pub fn hipEventCreateWithFlags(
5511 event: *mut hipEvent_t,
5512 flags: ::std::os::raw::c_uint,
5513 ) -> hipError_t;
5514}
5515extern "C" {
5516 #[doc = " Create an event\n\n @param[in,out] event Returns the newly created event.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,\n #hipErrorLaunchFailure, #hipErrorOutOfMemory\n\n @see hipEventCreateWithFlags, hipEventRecord, hipEventQuery, hipEventSynchronize,\n hipEventDestroy, hipEventElapsedTime"]
5517 pub fn hipEventCreate(event: *mut hipEvent_t) -> hipError_t;
5518}
5519extern "C" {
5520 #[doc = " @brief Record an event in the specified stream.\n\n @param[in] event event to record.\n @param[in] stream stream in which to record event.\n @param[in] flags parameter for operations\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized,\n #hipErrorInvalidHandle, #hipErrorLaunchFailure\n\n hipEventQuery() or hipEventSynchronize() must be used to determine when the event\n transitions from \"recording\" (after hipEventRecord() is called) to \"recorded\"\n (when timestamps are set, if requested).\n\n Events which are recorded in a non-NULL stream will transition to\n from recording to \"recorded\" state when they reach the head of\n the specified stream, after all previous\n commands in that stream have completed executing.\n\n Flags include:\n hipEventRecordDefault: Default event creation flag.\n hipEventRecordExternal: Event is captured in the graph as an external event node when\n performing stream capture\n\n If hipEventRecord() has been previously called on this event, then this call will overwrite any\n existing state in event.\n\n If this function is called on an event that is currently being recorded, results are undefined\n - either outstanding recording may save state into the event, and the order is not guaranteed.\n\n @note: If this function is not called before use hipEventQuery() or hipEventSynchronize(),\n #hipSuccess is returned, meaning no pending event in the stream.\n\n @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventSynchronize,\n hipEventDestroy, hipEventElapsedTime\n"]
5521 pub fn hipEventRecordWithFlags(
5522 event: hipEvent_t,
5523 stream: hipStream_t,
5524 flags: ::std::os::raw::c_uint,
5525 ) -> hipError_t;
5526}
5527extern "C" {
5528 pub fn hipEventRecord(event: hipEvent_t, stream: hipStream_t) -> hipError_t;
5529}
5530extern "C" {
5531 #[doc = " @brief Destroy the specified event.\n\n @param[in] event Event to destroy.\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,\n #hipErrorLaunchFailure\n\n Releases memory associated with the event. If the event is recording but has not completed\n recording when hipEventDestroy() is called, the function will return immediately and the\n completion_future resources will be released later, when the hipDevice is synchronized.\n\n @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventSynchronize, hipEventRecord,\n hipEventElapsedTime\n\n @returns #hipSuccess"]
5532 pub fn hipEventDestroy(event: hipEvent_t) -> hipError_t;
5533}
5534extern "C" {
5535 #[doc = " @brief Wait for an event to complete.\n\n This function will block until the event is ready, waiting for all previous work in the stream\n specified when event was recorded with hipEventRecord().\n\n If hipEventRecord() has not been called on @p event, this function returns #hipSuccess when no\n event is captured.\n\n\n @param[in] event Event on which to wait.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized,\n #hipErrorInvalidHandle, #hipErrorLaunchFailure\n\n @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventDestroy, hipEventRecord,\n hipEventElapsedTime"]
5536 pub fn hipEventSynchronize(event: hipEvent_t) -> hipError_t;
5537}
5538extern "C" {
5539 #[doc = " @brief Return the elapsed time between two events.\n\n @param[out] ms : Return time between start and stop in ms.\n @param[in] start : Start event.\n @param[in] stop : Stop event.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotReady, #hipErrorInvalidHandle,\n #hipErrorNotInitialized, #hipErrorLaunchFailure\n\n Computes the elapsed time between two events. Time is computed in ms, with\n a resolution of approximately 1 us.\n\n Events which are recorded in a NULL stream will block until all commands\n on all other streams complete execution, and then record the timestamp.\n\n Events which are recorded in a non-NULL stream will record their timestamp\n when they reach the head of the specified stream, after all previous\n commands in that stream have completed executing. Thus the time that\n the event recorded may be significantly after the host calls hipEventRecord().\n\n If hipEventRecord() has not been called on either event, then #hipErrorInvalidHandle is\n returned. If hipEventRecord() has been called on both events, but the timestamp has not yet been\n recorded on one or both events (that is, hipEventQuery() would return #hipErrorNotReady on at\n least one of the events), then #hipErrorNotReady is returned.\n\n @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventDestroy, hipEventRecord,\n hipEventSynchronize"]
5540 pub fn hipEventElapsedTime(ms: *mut f32, start: hipEvent_t, stop: hipEvent_t) -> hipError_t;
5541}
5542extern "C" {
5543 #[doc = " @brief Query event status\n\n @param[in] event Event to query.\n @returns #hipSuccess, #hipErrorNotReady, #hipErrorInvalidHandle, #hipErrorInvalidValue,\n #hipErrorNotInitialized, #hipErrorLaunchFailure\n\n Query the status of the specified event. This function will return #hipSuccess if all\n commands in the appropriate stream (specified to hipEventRecord()) have completed. If any execution\n has not completed, then #hipErrorNotReady is returned.\n\n @note This API returns #hipSuccess, if hipEventRecord() is not called before this API.\n\n @see hipEventCreate, hipEventCreateWithFlags, hipEventRecord, hipEventDestroy,\n hipEventSynchronize, hipEventElapsedTime"]
5544 pub fn hipEventQuery(event: hipEvent_t) -> hipError_t;
5545}
5546extern "C" {
5547 #[doc = " @brief Sets information on the specified pointer.[BETA]\n\n @param [in] value Sets pointer attribute value\n @param [in] attribute Attribute to set\n @param [in] ptr Pointer to set attributes for\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
5548 pub fn hipPointerSetAttribute(
5549 value: *const ::std::os::raw::c_void,
5550 attribute: hipPointer_attribute,
5551 ptr: hipDeviceptr_t,
5552 ) -> hipError_t;
5553}
5554extern "C" {
5555 #[doc = " @brief Returns attributes for the specified pointer\n\n @param [out] attributes attributes for the specified pointer\n @param [in] ptr pointer to get attributes for\n\n The output parameter 'attributes' has a member named 'type' that describes what memory the\n pointer is associated with, such as device memory, host memory, managed memory, and others.\n Otherwise, the API cannot handle the pointer and returns #hipErrorInvalidValue.\n\n @note The unrecognized memory type is unsupported to keep the HIP functionality backward\n compatibility due to #hipMemoryType enum values.\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @note The current behavior of this HIP API corresponds to the CUDA API before version 11.0.\n\n @see hipPointerGetAttribute"]
5556 pub fn hipPointerGetAttributes(
5557 attributes: *mut hipPointerAttribute_t,
5558 ptr: *const ::std::os::raw::c_void,
5559 ) -> hipError_t;
5560}
5561extern "C" {
5562 #[doc = " @brief Returns information about the specified pointer.[BETA]\n\n @param [in, out] data Returned pointer attribute value\n @param [in] attribute Attribute to query for\n @param [in] ptr Pointer to get attributes for\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @see hipPointerGetAttributes"]
5563 pub fn hipPointerGetAttribute(
5564 data: *mut ::std::os::raw::c_void,
5565 attribute: hipPointer_attribute,
5566 ptr: hipDeviceptr_t,
5567 ) -> hipError_t;
5568}
5569extern "C" {
5570 #[doc = " @brief Returns information about the specified pointer.[BETA]\n\n @param [in] numAttributes number of attributes to query for\n @param [in] attributes attributes to query for\n @param [in, out] data a two-dimensional containing pointers to memory locations\n where the result of each attribute query will be written to\n @param [in] ptr pointer to get attributes for\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @see hipPointerGetAttribute"]
5571 pub fn hipDrvPointerGetAttributes(
5572 numAttributes: ::std::os::raw::c_uint,
5573 attributes: *mut hipPointer_attribute,
5574 data: *mut *mut ::std::os::raw::c_void,
5575 ptr: hipDeviceptr_t,
5576 ) -> hipError_t;
5577}
5578extern "C" {
5579 #[doc = "-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n @defgroup External External Resource Interoperability\n @{\n @ingroup API\n\n This section describes the external resource interoperability functions of HIP runtime API.\n\n/\n/**\n @brief Imports an external semaphore.\n\n @param[out] extSem_out External semaphores to be waited on\n @param[in] semHandleDesc Semaphore import handle descriptor\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see\n\n @note This API is currently not supported on Linux.\n"]
5580 pub fn hipImportExternalSemaphore(
5581 extSem_out: *mut hipExternalSemaphore_t,
5582 semHandleDesc: *const hipExternalSemaphoreHandleDesc,
5583 ) -> hipError_t;
5584}
5585extern "C" {
5586 #[doc = " @brief Signals a set of external semaphore objects.\n\n @param[in] extSemArray External semaphores to be waited on\n @param[in] paramsArray Array of semaphore parameters\n @param[in] numExtSems Number of semaphores to wait on\n @param[in] stream Stream to enqueue the wait operations in\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see\n\n @note This API is currently not supported on Linux.\n"]
5587 pub fn hipSignalExternalSemaphoresAsync(
5588 extSemArray: *const hipExternalSemaphore_t,
5589 paramsArray: *const hipExternalSemaphoreSignalParams,
5590 numExtSems: ::std::os::raw::c_uint,
5591 stream: hipStream_t,
5592 ) -> hipError_t;
5593}
5594extern "C" {
5595 #[doc = " @brief Waits on a set of external semaphore objects\n\n @param[in] extSemArray External semaphores to be waited on\n @param[in] paramsArray Array of semaphore parameters\n @param[in] numExtSems Number of semaphores to wait on\n @param[in] stream Stream to enqueue the wait operations in\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see\n\n @note This API is currently not supported on Linux.\n"]
5596 pub fn hipWaitExternalSemaphoresAsync(
5597 extSemArray: *const hipExternalSemaphore_t,
5598 paramsArray: *const hipExternalSemaphoreWaitParams,
5599 numExtSems: ::std::os::raw::c_uint,
5600 stream: hipStream_t,
5601 ) -> hipError_t;
5602}
5603extern "C" {
5604 #[doc = " @brief Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.\n\n @param[in] extSem handle to an external memory object\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see\n\n @note This API is currently not supported on Linux.\n"]
5605 pub fn hipDestroyExternalSemaphore(extSem: hipExternalSemaphore_t) -> hipError_t;
5606}
5607extern "C" {
5608 #[doc = " @brief Imports an external memory object.\n\n @param[out] extMem_out Returned handle to an external memory object\n @param[in] memHandleDesc Memory import handle descriptor\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see"]
5609 pub fn hipImportExternalMemory(
5610 extMem_out: *mut hipExternalMemory_t,
5611 memHandleDesc: *const hipExternalMemoryHandleDesc,
5612 ) -> hipError_t;
5613}
5614extern "C" {
5615 #[doc = " @brief Maps a buffer onto an imported memory object.\n\n @param[out] devPtr Returned device pointer to buffer\n @param[in] extMem Handle to external memory object\n @param[in] bufferDesc Buffer descriptor\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see"]
5616 pub fn hipExternalMemoryGetMappedBuffer(
5617 devPtr: *mut *mut ::std::os::raw::c_void,
5618 extMem: hipExternalMemory_t,
5619 bufferDesc: *const hipExternalMemoryBufferDesc,
5620 ) -> hipError_t;
5621}
5622extern "C" {
5623 #[doc = " @brief Destroys an external memory object.\n\n @param[in] extMem External memory object to be destroyed\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n\n @see"]
5624 pub fn hipDestroyExternalMemory(extMem: hipExternalMemory_t) -> hipError_t;
5625}
5626extern "C" {
5627 #[doc = " @brief Maps a mipmapped array onto an external memory object.\n\n @param[out] mipmap mipmapped array to return\n @param[in] extMem external memory object handle\n @param[in] mipmapDesc external mipmapped array descriptor\n\n Returned mipmapped array must be freed using hipFreeMipmappedArray.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidResourceHandle\n\n @see hipImportExternalMemory, hipDestroyExternalMemory, hipExternalMemoryGetMappedBuffer, hipFreeMipmappedArray"]
5628 pub fn hipExternalMemoryGetMappedMipmappedArray(
5629 mipmap: *mut hipMipmappedArray_t,
5630 extMem: hipExternalMemory_t,
5631 mipmapDesc: *const hipExternalMemoryMipmappedArrayDesc,
5632 ) -> hipError_t;
5633}
5634extern "C" {
5635 #[doc = " @}\n/\n/**\n @brief Allocate memory on the default accelerator\n\n @param[out] ptr Pointer to the allocated memory\n @param[in] size Requested memory size\n\n If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.\n\n @returns #hipSuccess, #hipErrorOutOfMemory, #hipErrorInvalidValue (bad context, null *ptr)\n\n @see hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D, hipMalloc3DArray,\n hipHostFree, hipHostMalloc"]
5636 pub fn hipMalloc(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
5637}
5638extern "C" {
5639 #[doc = " @brief Allocate memory on the default accelerator\n\n @param[out] ptr Pointer to the allocated memory\n @param[in] sizeBytes Requested memory size\n @param[in] flags Type of memory allocation\n\n If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and #hipSuccess\n is returned.\n\n The memory allocation flag should be either #hipDeviceMallocDefault,\n #hipDeviceMallocFinegrained, #hipDeviceMallocUncached, or #hipMallocSignalMemory.\n If the flag is any other value, the API returns #hipErrorInvalidValue.\n\n @returns #hipSuccess, #hipErrorOutOfMemory, #hipErrorInvalidValue (bad context, null *ptr)\n\n @see hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D, hipMalloc3DArray,\n hipHostFree, hiHostMalloc"]
5640 pub fn hipExtMallocWithFlags(
5641 ptr: *mut *mut ::std::os::raw::c_void,
5642 sizeBytes: usize,
5643 flags: ::std::os::raw::c_uint,
5644 ) -> hipError_t;
5645}
5646extern "C" {
5647 #[doc = " @brief Allocate pinned host memory [Deprecated]\n\n @param[out] ptr Pointer to the allocated host pinned memory\n @param[in] size Requested memory size\n\n If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.\n\n @returns #hipSuccess, #hipErrorOutOfMemory\n\n @warning This API is deprecated, use hipHostMalloc() instead"]
5648 pub fn hipMallocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
5649}
5650extern "C" {
5651 #[doc = " @brief Allocate pinned host memory [Deprecated]\n\n @param[out] ptr Pointer to the allocated host pinned memory\n @param[in] size Requested memory size\n\n If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.\n\n @returns #hipSuccess, #hipErrorOutOfMemory\n\n @warning This API is deprecated, use hipHostMalloc() instead"]
5652 pub fn hipMemAllocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
5653}
5654extern "C" {
5655 #[doc = " @brief Allocates device accessible page locked (pinned) host memory\n\n This API allocates pinned host memory which is mapped into the address space of all GPUs\n in the system, the memory can be accessed directly by the GPU device, and can be read or\n written with much higher bandwidth than pageable memory obtained with functions such as\n malloc().\n\n Using the pinned host memory, applications can implement faster data transfers for HostToDevice\n and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the\n setup required for regular unpinned memory.\n\n When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent\n allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without need\n to copy the data.\n\n Currently the allocation granularity is 4KB for the API.\n\n Developers need to choose proper allocation flag with consideration of synchronization.\n\n @param[out] ptr Pointer to the allocated host pinned memory\n @param[in] size Requested memory size in bytes\n If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.\n @param[in] flags Type of host memory allocation. See the description of flags in\n hipSetDeviceFlags.\n\n If no input for flags, it will be the default pinned memory allocation on the host.\n\n @returns #hipSuccess, #hipErrorOutOfMemory\n\n\n @see hipSetDeviceFlags, hiptHostFree"]
5656 pub fn hipHostMalloc(
5657 ptr: *mut *mut ::std::os::raw::c_void,
5658 size: usize,
5659 flags: ::std::os::raw::c_uint,
5660 ) -> hipError_t;
5661}
5662extern "C" {
5663 #[doc = "-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n @defgroup MemoryM Managed Memory\n\n @ingroup Memory\n @{\n This section describes the managed memory management functions of HIP runtime API.\n\n @note The managed memory management APIs are implemented on Linux, under developement\n on Windows.\n\n/\n/**\n @brief Allocates memory that will be automatically managed by HIP.\n\n This API is used for managed memory, allows data be shared and accessible to both CPU and\n GPU using a single pointer.\n\n The API returns the allocation pointer, managed by HMM, can be used further to execute kernels\n on device and fetch data between the host and device as needed.\n\n @note It is recommend to do the capability check before call this API.\n\n @param [out] dev_ptr - pointer to allocated device memory\n @param [in] size - requested allocation size in bytes, it should be granularity of 4KB\n @param [in] flags - must be either hipMemAttachGlobal or hipMemAttachHost\n (defaults to hipMemAttachGlobal)\n\n @returns #hipSuccess, #hipErrorMemoryAllocation, #hipErrorNotSupported, #hipErrorInvalidValue\n"]
5664 pub fn hipMallocManaged(
5665 dev_ptr: *mut *mut ::std::os::raw::c_void,
5666 size: usize,
5667 flags: ::std::os::raw::c_uint,
5668 ) -> hipError_t;
5669}
5670extern "C" {
5671 #[doc = " @brief Prefetches memory to the specified destination device using HIP.\n\n @param [in] dev_ptr pointer to be prefetched\n @param [in] count size in bytes for prefetching\n @param [in] device destination device to prefetch to\n @param [in] stream stream to enqueue prefetch operation\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5672 pub fn hipMemPrefetchAsync(
5673 dev_ptr: *const ::std::os::raw::c_void,
5674 count: usize,
5675 device: ::std::os::raw::c_int,
5676 stream: hipStream_t,
5677 ) -> hipError_t;
5678}
5679extern "C" {
5680 #[doc = " @brief Advise about the usage of a given memory range to HIP.\n\n @param [in] dev_ptr pointer to memory to set the advice for\n @param [in] count size in bytes of the memory range, it should be CPU page size alligned.\n @param [in] advice advice to be applied for the specified memory range\n @param [in] device device to apply the advice for\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n This HIP API advises about the usage to be applied on unified memory allocation in the\n range starting from the pointer address devPtr, with the size of count bytes.\n The memory range must refer to managed memory allocated via the API hipMallocManaged, and the\n range will be handled with proper round down and round up respectively in the driver to\n be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version 8.0\n and afterwards.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5681 pub fn hipMemAdvise(
5682 dev_ptr: *const ::std::os::raw::c_void,
5683 count: usize,
5684 advice: hipMemoryAdvise,
5685 device: ::std::os::raw::c_int,
5686 ) -> hipError_t;
5687}
5688extern "C" {
5689 #[doc = " @brief Query an attribute of a given memory range in HIP.\n\n @param [in,out] data a pointer to a memory location where the result of each\n attribute query will be written to\n @param [in] data_size the size of data\n @param [in] attribute the attribute to query\n @param [in] dev_ptr start of the range to query\n @param [in] count size of the range to query\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5690 pub fn hipMemRangeGetAttribute(
5691 data: *mut ::std::os::raw::c_void,
5692 data_size: usize,
5693 attribute: hipMemRangeAttribute,
5694 dev_ptr: *const ::std::os::raw::c_void,
5695 count: usize,
5696 ) -> hipError_t;
5697}
5698extern "C" {
5699 #[doc = " @brief Query attributes of a given memory range in HIP.\n\n @param [in,out] data a two-dimensional array containing pointers to memory locations\n where the result of each attribute query will be written to\n @param [in] data_sizes an array, containing the sizes of each result\n @param [in] attributes the attribute to query\n @param [in] num_attributes an array of attributes to query (numAttributes and the number\n of attributes in this array should match)\n @param [in] dev_ptr start of the range to query\n @param [in] count size of the range to query\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5700 pub fn hipMemRangeGetAttributes(
5701 data: *mut *mut ::std::os::raw::c_void,
5702 data_sizes: *mut usize,
5703 attributes: *mut hipMemRangeAttribute,
5704 num_attributes: usize,
5705 dev_ptr: *const ::std::os::raw::c_void,
5706 count: usize,
5707 ) -> hipError_t;
5708}
5709extern "C" {
5710 #[doc = " @brief Attach memory to a stream asynchronously in HIP.\n\n @param [in] stream - stream in which to enqueue the attach operation\n @param [in] dev_ptr - pointer to memory (must be a pointer to managed memory or\n to a valid host-accessible region of system-allocated memory)\n @param [in] length - length of memory (defaults to zero)\n @param [in] flags - must be one of hipMemAttachGlobal, hipMemAttachHost or\n hipMemAttachSingle (defaults to hipMemAttachSingle)\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is under development. Currently it is a no-operation (NOP)\n function on AMD GPUs and returns #hipSuccess."]
5711 pub fn hipStreamAttachMemAsync(
5712 stream: hipStream_t,
5713 dev_ptr: *mut ::std::os::raw::c_void,
5714 length: usize,
5715 flags: ::std::os::raw::c_uint,
5716 ) -> hipError_t;
5717}
5718extern "C" {
5719 #[doc = " @brief Allocates memory with stream ordered semantics\n\n Inserts a memory allocation operation into @p stream.\n A pointer to the allocated memory is returned immediately in *dptr.\n The allocation must not be accessed until the allocation operation completes.\n The allocation comes from the memory pool associated with the stream's device.\n\n @note The default memory pool of a device contains device memory from that device.\n @note Basic stream ordering allows future work submitted into the same stream to use the\n allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that\n the allocation operation completes before work submitted in a separate stream runs.\n @note During stream capture, this function results in the creation of an allocation node.\n In this case, the allocation is owned by the graph instead of the memory pool. The memory\n pool's properties are used to set the node's creation parameters.\n\n @param [out] dev_ptr Returned device pointer of memory allocation\n @param [in] size Number of bytes to allocate\n @param [in] stream The stream establishing the stream ordering contract and\n the memory pool to allocate from\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported, #hipErrorOutOfMemory\n\n @see hipMallocFromPoolAsync, hipFreeAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute,\n hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5720 pub fn hipMallocAsync(
5721 dev_ptr: *mut *mut ::std::os::raw::c_void,
5722 size: usize,
5723 stream: hipStream_t,
5724 ) -> hipError_t;
5725}
5726extern "C" {
5727 #[doc = " @brief Frees memory with stream ordered semantics\n\n Inserts a free operation into @p stream.\n The allocation must not be used after stream execution reaches the free.\n After this API returns, accessing the memory from any subsequent work launched on the GPU\n or querying its pointer attributes results in undefined behavior.\n\n @note During stream capture, this function results in the creation of a free node and\n must therefore be passed the address of a graph allocation.\n\n @param [in] dev_ptr Pointer to device memory to free\n @param [in] stream The stream, where the destruciton will occur according to the execution order\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute,\n hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5728 pub fn hipFreeAsync(dev_ptr: *mut ::std::os::raw::c_void, stream: hipStream_t) -> hipError_t;
5729}
5730extern "C" {
5731 #[doc = " @brief Releases freed memory back to the OS\n\n Releases memory back to the OS until the pool contains fewer than @p min_bytes_to_keep\n reserved bytes, or there is no more memory that the allocator can safely release.\n The allocator cannot release OS allocations that back outstanding asynchronous allocations.\n The OS allocations may happen at different granularity from the user allocations.\n\n @note Allocations that have not been freed count as outstanding.\n @note Allocations that have been asynchronously freed but whose completion has\n not been observed on the host (eg. by a synchronize) can count as outstanding.\n\n @param[in] mem_pool The memory pool to trim allocations\n @param[in] min_bytes_to_hold If the pool has less than min_bytes_to_hold reserved,\n then the TrimTo operation is a no-op. Otherwise the memory pool will contain\n at least min_bytes_to_hold bytes reserved after the operation.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute,\n hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5732 pub fn hipMemPoolTrimTo(mem_pool: hipMemPool_t, min_bytes_to_hold: usize) -> hipError_t;
5733}
5734extern "C" {
5735 #[doc = " @brief Sets attributes of a memory pool\n\n Supported attributes are:\n - @p hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t)\n Amount of reserved memory in bytes to hold onto before trying\n to release memory back to the OS. When more than the release\n threshold bytes of memory are held by the memory pool, the\n allocator will try to release memory back to the OS on the\n next call to stream, event or context synchronize. (default 0)\n - @p hipMemPoolReuseFollowEventDependencies: (value type = int)\n Allow @p hipMallocAsync to use memory asynchronously freed\n in another stream as long as a stream ordering dependency\n of the allocating stream on the free action exists.\n HIP events and null stream interactions can create the required\n stream ordered dependencies. (default enabled)\n - @p hipMemPoolReuseAllowOpportunistic: (value type = int)\n Allow reuse of already completed frees when there is no dependency\n between the free and allocation. (default enabled)\n - @p hipMemPoolReuseAllowInternalDependencies: (value type = int)\n Allow @p hipMallocAsync to insert new stream dependencies\n in order to establish the stream ordering required to reuse\n a piece of memory released by @p hipFreeAsync (default enabled).\n\n @param [in] mem_pool The memory pool to modify\n @param [in] attr The attribute to modify\n @param [in] value Pointer to the value to assign\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute,\n hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5736 pub fn hipMemPoolSetAttribute(
5737 mem_pool: hipMemPool_t,
5738 attr: hipMemPoolAttr,
5739 value: *mut ::std::os::raw::c_void,
5740 ) -> hipError_t;
5741}
5742extern "C" {
5743 #[doc = " @brief Gets attributes of a memory pool\n\n Supported attributes are:\n - @p hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t)\n Amount of reserved memory in bytes to hold onto before trying\n to release memory back to the OS. When more than the release\n threshold bytes of memory are held by the memory pool, the\n allocator will try to release memory back to the OS on the\n next call to stream, event or context synchronize. (default 0)\n - @p hipMemPoolReuseFollowEventDependencies: (value type = int)\n Allow @p hipMallocAsync to use memory asynchronously freed\n in another stream as long as a stream ordering dependency\n of the allocating stream on the free action exists.\n HIP events and null stream interactions can create the required\n stream ordered dependencies. (default enabled)\n - @p hipMemPoolReuseAllowOpportunistic: (value type = int)\n Allow reuse of already completed frees when there is no dependency\n between the free and allocation. (default enabled)\n - @p hipMemPoolReuseAllowInternalDependencies: (value type = int)\n Allow @p hipMallocAsync to insert new stream dependencies\n in order to establish the stream ordering required to reuse\n a piece of memory released by @p hipFreeAsync (default enabled).\n\n @param [in] mem_pool The memory pool to get attributes of\n @param [in] attr The attribute to get\n @param [in] value Retrieved value\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync,\n hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5744 pub fn hipMemPoolGetAttribute(
5745 mem_pool: hipMemPool_t,
5746 attr: hipMemPoolAttr,
5747 value: *mut ::std::os::raw::c_void,
5748 ) -> hipError_t;
5749}
5750extern "C" {
5751 #[doc = " @brief Controls visibility of the specified pool between devices\n\n @param [in] mem_pool Memory pool for acccess change\n @param [in] desc_list Array of access descriptors. Each descriptor instructs the access to enable for a single gpu\n @param [in] count Number of descriptors in the map array.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute,\n hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5752 pub fn hipMemPoolSetAccess(
5753 mem_pool: hipMemPool_t,
5754 desc_list: *const hipMemAccessDesc,
5755 count: usize,
5756 ) -> hipError_t;
5757}
5758extern "C" {
5759 #[doc = " @brief Returns the accessibility of a pool from a device\n\n Returns the accessibility of the pool's memory from the specified location.\n\n @param [out] flags Accessibility of the memory pool from the specified location/device\n @param [in] mem_pool Memory pool being queried\n @param [in] location Location/device for memory pool access\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute,\n hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5760 pub fn hipMemPoolGetAccess(
5761 flags: *mut hipMemAccessFlags,
5762 mem_pool: hipMemPool_t,
5763 location: *mut hipMemLocation,
5764 ) -> hipError_t;
5765}
5766extern "C" {
5767 #[doc = " @brief Creates a memory pool\n\n Creates a HIP memory pool and returns the handle in @p mem_pool. The @p pool_props determines\n the properties of the pool such as the backing device and IPC capabilities.\n\n By default, the memory pool will be accessible from the device it is allocated on.\n\n @param [out] mem_pool Contains createed memory pool\n @param [in] pool_props Memory pool properties\n\n @note Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, hipMemPoolDestroy,\n hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5768 pub fn hipMemPoolCreate(
5769 mem_pool: *mut hipMemPool_t,
5770 pool_props: *const hipMemPoolProps,
5771 ) -> hipError_t;
5772}
5773extern "C" {
5774 #[doc = " @brief Destroys the specified memory pool\n\n If any pointers obtained from this pool haven't been freed or\n the pool has free operations that haven't completed\n when @p hipMemPoolDestroy is invoked, the function will return immediately and the\n resources associated with the pool will be released automatically\n once there are no more outstanding allocations.\n\n Destroying the current mempool of a device sets the default mempool of\n that device as the current mempool for that device.\n\n @param [in] mem_pool Memory pool for destruction\n\n @note A device's default memory pool cannot be destroyed.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, hipMemPoolCreate\n hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5775 pub fn hipMemPoolDestroy(mem_pool: hipMemPool_t) -> hipError_t;
5776}
5777extern "C" {
5778 #[doc = " @brief Allocates memory from a specified pool with stream ordered semantics.\n\n Inserts an allocation operation into @p stream.\n A pointer to the allocated memory is returned immediately in @p dev_ptr.\n The allocation must not be accessed until the allocation operation completes.\n The allocation comes from the specified memory pool.\n\n @note The specified memory pool may be from a device different than that of the specified @p stream.\n\n Basic stream ordering allows future work submitted into the same stream to use the allocation.\n Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation\n operation completes before work submitted in a separate stream runs.\n\n @note During stream capture, this function results in the creation of an allocation node. In this case,\n the allocation is owned by the graph instead of the memory pool. The memory pool's properties\n are used to set the node's creation parameters.\n\n @param [out] dev_ptr Returned device pointer\n @param [in] size Number of bytes to allocate\n @param [in] mem_pool The pool to allocate from\n @param [in] stream The stream establishing the stream ordering semantic\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported, #hipErrorOutOfMemory\n\n @see hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, hipMemPoolCreate\n hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess,\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5779 pub fn hipMallocFromPoolAsync(
5780 dev_ptr: *mut *mut ::std::os::raw::c_void,
5781 size: usize,
5782 mem_pool: hipMemPool_t,
5783 stream: hipStream_t,
5784 ) -> hipError_t;
5785}
5786extern "C" {
5787 #[doc = " @brief Exports a memory pool to the requested handle type.\n\n Given an IPC capable mempool, create an OS handle to share the pool with another process.\n A recipient process can convert the shareable handle into a mempool with @p hipMemPoolImportFromShareableHandle.\n Individual pointers can then be shared with the @p hipMemPoolExportPointer and @p hipMemPoolImportPointer APIs.\n The implementation of what the shareable handle is and how it can be transferred is defined by the requested\n handle type.\n\n @note To create an IPC capable mempool, create a mempool with a @p hipMemAllocationHandleType other\n than @p hipMemHandleTypeNone.\n\n @param [out] shared_handle Pointer to the location in which to store the requested handle\n @param [in] mem_pool Pool to export\n @param [in] handle_type The type of handle to create\n @param [in] flags Must be 0\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorOutOfMemory\n\n @see hipMemPoolImportFromShareableHandle\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5788 pub fn hipMemPoolExportToShareableHandle(
5789 shared_handle: *mut ::std::os::raw::c_void,
5790 mem_pool: hipMemPool_t,
5791 handle_type: hipMemAllocationHandleType,
5792 flags: ::std::os::raw::c_uint,
5793 ) -> hipError_t;
5794}
5795extern "C" {
5796 #[doc = " @brief Imports a memory pool from a shared handle.\n\n Specific allocations can be imported from the imported pool with @p hipMemPoolImportPointer.\n\n @note Imported memory pools do not support creating new allocations.\n As such imported memory pools may not be used in @p hipDeviceSetMemPool\n or @p hipMallocFromPoolAsync calls.\n\n @param [out] mem_pool Returned memory pool\n @param [in] shared_handle OS handle of the pool to open\n @param [in] handle_type The type of handle being imported\n @param [in] flags Must be 0\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorOutOfMemory\n\n @see hipMemPoolExportToShareableHandle\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5797 pub fn hipMemPoolImportFromShareableHandle(
5798 mem_pool: *mut hipMemPool_t,
5799 shared_handle: *mut ::std::os::raw::c_void,
5800 handle_type: hipMemAllocationHandleType,
5801 flags: ::std::os::raw::c_uint,
5802 ) -> hipError_t;
5803}
5804extern "C" {
5805 #[doc = " @brief Export data to share a memory pool allocation between processes.\n\n Constructs @p export_data for sharing a specific allocation from an already shared memory pool.\n The recipient process can import the allocation with the @p hipMemPoolImportPointer api.\n The data is not a handle and may be shared through any IPC mechanism.\n\n @param[out] export_data Returned export data\n @param[in] dev_ptr Pointer to memory being exported\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorOutOfMemory\n\n @see hipMemPoolImportPointer\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5806 pub fn hipMemPoolExportPointer(
5807 export_data: *mut hipMemPoolPtrExportData,
5808 dev_ptr: *mut ::std::os::raw::c_void,
5809 ) -> hipError_t;
5810}
5811extern "C" {
5812 #[doc = " @brief Import a memory pool allocation from another process.\n\n Returns in @p dev_ptr a pointer to the imported memory.\n The imported memory must not be accessed before the allocation operation completes\n in the exporting process. The imported memory must be freed from all importing processes before\n being freed in the exporting process. The pointer may be freed with @p hipFree\n or @p hipFreeAsync. If @p hipFreeAsync is used, the free must be completed\n on the importing process before the free operation on the exporting process.\n\n @note The @p hipFreeAsync api may be used in the exporting process before\n the @p hipFreeAsync operation completes in its stream as long as the\n @p hipFreeAsync in the exporting process specifies a stream with\n a stream dependency on the importing process's @p hipFreeAsync.\n\n @param [out] dev_ptr Pointer to imported memory\n @param [in] mem_pool Memory pool from which to import a pointer\n @param [in] export_data Data specifying the memory to import\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized, #hipErrorOutOfMemory\n\n @see hipMemPoolExportPointer\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
5813 pub fn hipMemPoolImportPointer(
5814 dev_ptr: *mut *mut ::std::os::raw::c_void,
5815 mem_pool: hipMemPool_t,
5816 export_data: *mut hipMemPoolPtrExportData,
5817 ) -> hipError_t;
5818}
5819extern "C" {
5820 #[doc = " @brief Allocate device accessible page locked host memory\n\n @param[out] ptr Pointer to the allocated host pinned memory\n @param[in] size Requested memory size in bytes\n @param[in] flags Type of host memory allocation see below\n\n If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.\n\n Flags:\n - #hipHostAllocDefault Default pinned memory allocation on the host.\n - #hipHostAllocPortable Memory is considered allocated by all contexts.\n - #hipHostAllocMapped Map the allocation into the address space for the current device.\n - #hipHostAllocWriteCombined Allocates the memory as write-combined.\n\n @return #hipSuccess, #hipErrorOutOfMemory, #hipErrorInvalidValue"]
5821 pub fn hipHostAlloc(
5822 ptr: *mut *mut ::std::os::raw::c_void,
5823 size: usize,
5824 flags: ::std::os::raw::c_uint,
5825 ) -> hipError_t;
5826}
5827extern "C" {
5828 #[doc = " @brief Get Device pointer from Host Pointer allocated through hipHostMalloc\n\n @param[out] devPtr Device Pointer mapped to passed host pointer\n @param[in] hstPtr Host Pointer allocated through hipHostMalloc\n @param[in] flags Flags to be passed for extension\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorOutOfMemory\n\n @see hipSetDeviceFlags, hipHostMalloc"]
5829 pub fn hipHostGetDevicePointer(
5830 devPtr: *mut *mut ::std::os::raw::c_void,
5831 hstPtr: *mut ::std::os::raw::c_void,
5832 flags: ::std::os::raw::c_uint,
5833 ) -> hipError_t;
5834}
5835extern "C" {
5836 #[doc = " @brief Return flags associated with host pointer\n\n @param[out] flagsPtr Memory location to store flags\n @param[in] hostPtr Host Pointer allocated through hipHostMalloc\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipHostMalloc"]
5837 pub fn hipHostGetFlags(
5838 flagsPtr: *mut ::std::os::raw::c_uint,
5839 hostPtr: *mut ::std::os::raw::c_void,
5840 ) -> hipError_t;
5841}
5842extern "C" {
5843 #[doc = " @brief Register host memory so it can be accessed from the current device.\n\n @param[out] hostPtr Pointer to host memory to be registered.\n @param[in] sizeBytes Size of the host memory\n @param[in] flags See below.\n\n Flags:\n - #hipHostRegisterDefault Memory is Mapped and Portable\n - #hipHostRegisterPortable Memory is considered registered by all contexts. HIP only supports\n one context so this is always assumed true.\n - #hipHostRegisterMapped Map the allocation into the address space for the current device.\n The device pointer can be obtained with #hipHostGetDevicePointer.\n\n\n After registering the memory, use #hipHostGetDevicePointer to obtain the mapped device pointer.\n On many systems, the mapped device pointer will have a different value than the mapped host\n pointer. Applications must use the device pointer in device code, and the host pointer in host\n code.\n\n On some systems, registered memory is pinned. On some systems, registered memory may not be\n actually be pinned but uses OS or hardware facilities to all GPU access to the host memory.\n\n Developers are strongly encouraged to register memory blocks which are aligned to the host\n cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction).\n\n If registering non-aligned pointers, the application must take care when register pointers from\n the same cache line on different devices. HIP's coarse-grained synchronization model does not\n guarantee correct results if different devices write to different parts of the same cache block -\n typically one of the writes will \"win\" and overwrite data from the other registered memory\n region.\n\n @returns #hipSuccess, #hipErrorOutOfMemory\n\n @see hipHostUnregister, hipHostGetFlags, hipHostGetDevicePointer"]
5844 pub fn hipHostRegister(
5845 hostPtr: *mut ::std::os::raw::c_void,
5846 sizeBytes: usize,
5847 flags: ::std::os::raw::c_uint,
5848 ) -> hipError_t;
5849}
5850extern "C" {
5851 #[doc = " @brief Un-register host pointer\n\n @param[in] hostPtr Host pointer previously registered with #hipHostRegister\n @returns Error code\n\n @see hipHostRegister"]
5852 pub fn hipHostUnregister(hostPtr: *mut ::std::os::raw::c_void) -> hipError_t;
5853}
5854extern "C" {
5855 #[doc = " Allocates at least width (in bytes) * height bytes of linear memory\n Padding may occur to ensure alighnment requirements are met for the given row\n The change in width size due to padding will be returned in *pitch.\n Currently the alignment is set to 128 bytes\n\n @param[out] ptr Pointer to the allocated device memory\n @param[out] pitch Pitch for allocation (in bytes)\n @param[in] width Requested pitched allocation width (in bytes)\n @param[in] height Requested pitched allocation height\n\n If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.\n\n @returns Error code\n\n @see hipMalloc, hipFree, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D,\n hipMalloc3DArray, hipHostMalloc"]
5856 pub fn hipMallocPitch(
5857 ptr: *mut *mut ::std::os::raw::c_void,
5858 pitch: *mut usize,
5859 width: usize,
5860 height: usize,
5861 ) -> hipError_t;
5862}
5863extern "C" {
5864 #[doc = " Allocates at least width (in bytes) * height bytes of linear memory\n Padding may occur to ensure alighnment requirements are met for the given row\n The change in width size due to padding will be returned in *pitch.\n Currently the alignment is set to 128 bytes\n\n @param[out] dptr Pointer to the allocated device memory\n @param[out] pitch Pitch for allocation (in bytes)\n @param[in] widthInBytes Requested pitched allocation width (in bytes)\n @param[in] height Requested pitched allocation height\n @param[in] elementSizeBytes The size of element bytes, should be 4, 8 or 16\n\n If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.\n The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array.\n Given the row and column of an array element of type T, the address is computed as:\n T* pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;\n\n @returns Error code\n\n @see hipMalloc, hipFree, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D,\n hipMalloc3DArray, hipHostMalloc"]
5865 pub fn hipMemAllocPitch(
5866 dptr: *mut hipDeviceptr_t,
5867 pitch: *mut usize,
5868 widthInBytes: usize,
5869 height: usize,
5870 elementSizeBytes: ::std::os::raw::c_uint,
5871 ) -> hipError_t;
5872}
5873extern "C" {
5874 #[doc = " @brief Free memory allocated by the hcc hip memory allocation API.\n This API performs an implicit hipDeviceSynchronize() call.\n If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.\n\n @param[in] ptr Pointer to memory to be freed\n @returns #hipSuccess\n @returns #hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated\n with hipHostMalloc)\n\n @see hipMalloc, hipMallocPitch, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D,\n hipMalloc3DArray, hipHostMalloc"]
5875 pub fn hipFree(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
5876}
5877extern "C" {
5878 #[doc = " @brief Frees page-locked memory\n This API performs an implicit hipDeviceSynchronize() call.\n If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.\n\n @param[in] ptr Pointer to memory to be freed\n @returns #hipSuccess,\n #hipErrorInvalidValue (if pointer is invalid, including device pointers allocated\n with hipMalloc)\n"]
5879 pub fn hipFreeHost(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
5880}
5881extern "C" {
5882 #[doc = " @brief Free memory allocated by the hcc hip host memory allocation API\n This API performs an implicit hipDeviceSynchronize() call.\n If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.\n\n @ingroup MemoryD\n\n @param[in] ptr Pointer to memory to be freed\n @returns #hipSuccess,\n #hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with\n hipMalloc)\n\n @see hipMalloc, hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D,\n hipMalloc3DArray, hipHostMalloc\n"]
5883 pub fn hipHostFree(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
5884}
5885extern "C" {
5886 #[doc = " @brief Copy data from src to dst.\n\n It supports memory from host to device,\n device to host, device to device and host to host\n The src and dst must not overlap.\n\n For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice).\n For multi-gpu or peer-to-peer configurations, it is recommended to set the current device to the\n device where the src data is physically located. For optimal peer-to-peer copies, the copy device\n must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy\n agent as the current device and src/dest as the peerDevice argument. if this is not done, the\n hipMemcpy will still work, but will perform the copy using a staging buffer on the host.\n Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in\n undefined behavior.\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n @param[in] kind Kind of transfer\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorUnknown\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5887 pub fn hipMemcpy(
5888 dst: *mut ::std::os::raw::c_void,
5889 src: *const ::std::os::raw::c_void,
5890 sizeBytes: usize,
5891 kind: hipMemcpyKind,
5892 ) -> hipError_t;
5893}
5894extern "C" {
5895 #[doc = " @brief Memory copy on the stream.\n It allows single or multiple devices to do memory copy on single or multiple streams.\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n @param[in] kind Kind of transfer\n @param[in] stream Valid stream\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorUnknown, #hipErrorContextIsDestroyed\n\n @see hipMemcpy, hipStreamCreate, hipStreamSynchronize, hipStreamDestroy, hipSetDevice, hipLaunchKernelGGL\n"]
5896 pub fn hipMemcpyWithStream(
5897 dst: *mut ::std::os::raw::c_void,
5898 src: *const ::std::os::raw::c_void,
5899 sizeBytes: usize,
5900 kind: hipMemcpyKind,
5901 stream: hipStream_t,
5902 ) -> hipError_t;
5903}
5904extern "C" {
5905 #[doc = " @brief Copy data from Host to Device\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5906 pub fn hipMemcpyHtoD(
5907 dst: hipDeviceptr_t,
5908 src: *mut ::std::os::raw::c_void,
5909 sizeBytes: usize,
5910 ) -> hipError_t;
5911}
5912extern "C" {
5913 #[doc = " @brief Copy data from Device to Host\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5914 pub fn hipMemcpyDtoH(
5915 dst: *mut ::std::os::raw::c_void,
5916 src: hipDeviceptr_t,
5917 sizeBytes: usize,
5918 ) -> hipError_t;
5919}
5920extern "C" {
5921 #[doc = " @brief Copy data from Device to Device\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5922 pub fn hipMemcpyDtoD(dst: hipDeviceptr_t, src: hipDeviceptr_t, sizeBytes: usize) -> hipError_t;
5923}
5924extern "C" {
5925 #[doc = " @brief Copies from one 1D array to device memory.\n\n @param[out] dstDevice Destination device pointer\n @param[in] srcArray Source array\n @param[in] srcOffset Offset in bytes of source array\n @param[in] ByteCount Size of memory copy in bytes\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5926 pub fn hipMemcpyAtoD(
5927 dstDevice: hipDeviceptr_t,
5928 srcArray: hipArray_t,
5929 srcOffset: usize,
5930 ByteCount: usize,
5931 ) -> hipError_t;
5932}
5933extern "C" {
5934 #[doc = " @brief Copies from device memory to a 1D array.\n\n @param[out] dstArray Destination array\n @param[in] dstOffset Offset in bytes of destination array\n @param[in] srcDevice Source device pointer\n @param[in] ByteCount Size of memory copy in bytes\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5935 pub fn hipMemcpyDtoA(
5936 dstArray: hipArray_t,
5937 dstOffset: usize,
5938 srcDevice: hipDeviceptr_t,
5939 ByteCount: usize,
5940 ) -> hipError_t;
5941}
5942extern "C" {
5943 #[doc = " @brief Copies from one 1D array to another.\n\n @param[out] dstArray Destination array\n @param[in] dstOffset Offset in bytes of destination array\n @param[in] srcArray Source array\n @param[in] srcOffset Offset in bytes of source array\n @param[in] ByteCount Size of memory copy in bytes\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5944 pub fn hipMemcpyAtoA(
5945 dstArray: hipArray_t,
5946 dstOffset: usize,
5947 srcArray: hipArray_t,
5948 srcOffset: usize,
5949 ByteCount: usize,
5950 ) -> hipError_t;
5951}
5952extern "C" {
5953 #[doc = " @brief Copy data from Host to Device asynchronously\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n @param[in] stream Stream identifier\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5954 pub fn hipMemcpyHtoDAsync(
5955 dst: hipDeviceptr_t,
5956 src: *mut ::std::os::raw::c_void,
5957 sizeBytes: usize,
5958 stream: hipStream_t,
5959 ) -> hipError_t;
5960}
5961extern "C" {
5962 #[doc = " @brief Copy data from Device to Host asynchronously\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n @param[in] stream Stream identifier\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5963 pub fn hipMemcpyDtoHAsync(
5964 dst: *mut ::std::os::raw::c_void,
5965 src: hipDeviceptr_t,
5966 sizeBytes: usize,
5967 stream: hipStream_t,
5968 ) -> hipError_t;
5969}
5970extern "C" {
5971 #[doc = " @brief Copy data from Device to Device asynchronously\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n @param[in] stream Stream identifier\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5972 pub fn hipMemcpyDtoDAsync(
5973 dst: hipDeviceptr_t,
5974 src: hipDeviceptr_t,
5975 sizeBytes: usize,
5976 stream: hipStream_t,
5977 ) -> hipError_t;
5978}
5979extern "C" {
5980 #[doc = " @brief Copies from one 1D array to host memory.\n\n @param[out] dstHost Destination pointer\n @param[in] srcArray Source array\n @param[in] srcOffset Offset in bytes of source array\n @param[in] ByteCount Size of memory copy in bytes\n @param[in] stream Stream identifier\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5981 pub fn hipMemcpyAtoHAsync(
5982 dstHost: *mut ::std::os::raw::c_void,
5983 srcArray: hipArray_t,
5984 srcOffset: usize,
5985 ByteCount: usize,
5986 stream: hipStream_t,
5987 ) -> hipError_t;
5988}
5989extern "C" {
5990 #[doc = " @brief Copies from host memory to a 1D array.\n\n @param[out] dstArray Destination array\n @param[in] dstOffset Offset in bytes of destination array\n @param[in] srcHost Source host pointer\n @param[in] ByteCount Size of memory copy in bytes\n @param[in] stream Stream identifier\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,\n hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,\n hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,\n hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,\n hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,\n hipMemHostAlloc, hipMemHostGetDevicePointer"]
5991 pub fn hipMemcpyHtoAAsync(
5992 dstArray: hipArray_t,
5993 dstOffset: usize,
5994 srcHost: *const ::std::os::raw::c_void,
5995 ByteCount: usize,
5996 stream: hipStream_t,
5997 ) -> hipError_t;
5998}
5999extern "C" {
6000 #[doc = " @brief Returns a global pointer from a module.\n @ingroup Module\n\n Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod.\n If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional.\n If one of them is NULL, it is ignored and hipSuccess is returned.\n\n @param[out] dptr Returns global device pointer\n @param[out] bytes Returns global size in bytes\n @param[in] hmod Module to retrieve global from\n @param[in] name Name of global to retrieve\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotFound, #hipErrorInvalidContext\n"]
6001 pub fn hipModuleGetGlobal(
6002 dptr: *mut hipDeviceptr_t,
6003 bytes: *mut usize,
6004 hmod: hipModule_t,
6005 name: *const ::std::os::raw::c_char,
6006 ) -> hipError_t;
6007}
6008extern "C" {
6009 #[doc = " @brief Gets device pointer associated with symbol on the device.\n\n @param[out] devPtr pointer to the device associated the symbole\n @param[in] symbol pointer to the symbole of the device\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6010 pub fn hipGetSymbolAddress(
6011 devPtr: *mut *mut ::std::os::raw::c_void,
6012 symbol: *const ::std::os::raw::c_void,
6013 ) -> hipError_t;
6014}
6015extern "C" {
6016 #[doc = " @brief Gets the size of the given symbol on the device.\n\n @param[in] symbol pointer to the device symbole\n @param[out] size pointer to the size\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6017 pub fn hipGetSymbolSize(size: *mut usize, symbol: *const ::std::os::raw::c_void) -> hipError_t;
6018}
6019extern "C" {
6020 #[doc = " @brief Gets the pointer of requested HIP driver function.\n\n @param[in] symbol The Symbol name of the driver function to request.\n @param[out] pfn Output pointer to the requested driver function.\n @param[in] hipVersion The HIP version for the requested driver function symbol.\n HIP version is defined as 100*version_major + version_minor. For example, in HIP 6.1, the\n hipversion is 601, for the symbol function \"hipGetDeviceProperties\", the specified hipVersion 601\n is greater or equal to the version 600, the symbol function will be handle properly as backend\n compatible function.\n\n @param[in] flags Currently only default flag is suppported.\n @param[out] symbolStatus Optional enumeration for returned status of searching for symbol driver\n function based on the input hipVersion.\n\n Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function.\n\n @returns #hipSuccess, #hipErrorInvalidValue."]
6021 pub fn hipGetProcAddress(
6022 symbol: *const ::std::os::raw::c_char,
6023 pfn: *mut *mut ::std::os::raw::c_void,
6024 hipVersion: ::std::os::raw::c_int,
6025 flags: u64,
6026 symbolStatus: *mut hipDriverProcAddressQueryResult,
6027 ) -> hipError_t;
6028}
6029extern "C" {
6030 #[doc = " @brief Copies data to the given symbol on the device.\n Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on\n the host side. The symbol can be in __constant or device space.\n Note that the symbol name needs to be encased in the HIP_SYMBOL macro.\n This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize.\n For detailed usage, see the\n <a href=\"https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/hip_porting_guide.html#memcpytosymbol\">memcpyToSymbol example</a>\n in the HIP Porting Guide.\n\n\n @param[out] symbol pointer to the device symbole\n @param[in] src pointer to the source address\n @param[in] sizeBytes size in bytes to copy\n @param[in] offset offset in bytes from start of symbole\n @param[in] kind type of memory transfer\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6031 pub fn hipMemcpyToSymbol(
6032 symbol: *const ::std::os::raw::c_void,
6033 src: *const ::std::os::raw::c_void,
6034 sizeBytes: usize,
6035 offset: usize,
6036 kind: hipMemcpyKind,
6037 ) -> hipError_t;
6038}
6039extern "C" {
6040 #[doc = " @brief Copies data to the given symbol on the device asynchronously.\n\n @param[out] symbol pointer to the device symbole\n @param[in] src pointer to the source address\n @param[in] sizeBytes size in bytes to copy\n @param[in] offset offset in bytes from start of symbole\n @param[in] kind type of memory transfer\n @param[in] stream stream identifier\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6041 pub fn hipMemcpyToSymbolAsync(
6042 symbol: *const ::std::os::raw::c_void,
6043 src: *const ::std::os::raw::c_void,
6044 sizeBytes: usize,
6045 offset: usize,
6046 kind: hipMemcpyKind,
6047 stream: hipStream_t,
6048 ) -> hipError_t;
6049}
6050extern "C" {
6051 #[doc = " @brief Copies data from the given symbol on the device.\n\n @param[out] dst Returns pointer to destinition memory address\n @param[in] symbol Pointer to the symbole address on the device\n @param[in] sizeBytes Size in bytes to copy\n @param[in] offset Offset in bytes from the start of symbole\n @param[in] kind Type of memory transfer\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6052 pub fn hipMemcpyFromSymbol(
6053 dst: *mut ::std::os::raw::c_void,
6054 symbol: *const ::std::os::raw::c_void,
6055 sizeBytes: usize,
6056 offset: usize,
6057 kind: hipMemcpyKind,
6058 ) -> hipError_t;
6059}
6060extern "C" {
6061 #[doc = " @brief Copies data from the given symbol on the device asynchronously.\n\n @param[out] dst Returns pointer to destinition memory address\n @param[in] symbol pointer to the symbole address on the device\n @param[in] sizeBytes size in bytes to copy\n @param[in] offset offset in bytes from the start of symbole\n @param[in] kind type of memory transfer\n @param[in] stream stream identifier\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6062 pub fn hipMemcpyFromSymbolAsync(
6063 dst: *mut ::std::os::raw::c_void,
6064 symbol: *const ::std::os::raw::c_void,
6065 sizeBytes: usize,
6066 offset: usize,
6067 kind: hipMemcpyKind,
6068 stream: hipStream_t,
6069 ) -> hipError_t;
6070}
6071extern "C" {
6072 #[doc = " @brief Copy data from src to dst asynchronously.\n\n @warning If host or dest are not pinned, the memory copy will be performed synchronously. For\n best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously.\n\n @warning on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies.\n For hipMemcpy, the copy is always performed by the device associated with the specified stream.\n\n For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a\n attached to the device where the src data is physically located. For optimal peer-to-peer copies,\n the copy device must be able to access the src and dst pointers (by calling\n hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice\n argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a\n staging buffer on the host.\n\n @param[out] dst Data being copy to\n @param[in] src Data being copy from\n @param[in] sizeBytes Data size in bytes\n @param[in] kind Type of memory transfer\n @param[in] stream Stream identifier\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorUnknown\n\n @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray,\n hipMemcpy2DFromArray, hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol,\n hipMemcpyFromSymbol, hipMemcpy2DAsync, hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync,\n hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync, hipMemcpyToSymbolAsync,\n hipMemcpyFromSymbolAsync"]
6073 pub fn hipMemcpyAsync(
6074 dst: *mut ::std::os::raw::c_void,
6075 src: *const ::std::os::raw::c_void,
6076 sizeBytes: usize,
6077 kind: hipMemcpyKind,
6078 stream: hipStream_t,
6079 ) -> hipError_t;
6080}
6081extern "C" {
6082 #[doc = " @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant\n byte value value.\n\n @param[out] dst Data being filled\n @param[in] value Value to be set\n @param[in] sizeBytes Data size in bytes\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
6083 pub fn hipMemset(
6084 dst: *mut ::std::os::raw::c_void,
6085 value: ::std::os::raw::c_int,
6086 sizeBytes: usize,
6087 ) -> hipError_t;
6088}
6089extern "C" {
6090 #[doc = " @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant\n byte value value.\n\n @param[out] dest Data ptr to be filled\n @param[in] value Value to be set\n @param[in] count Number of values to be set\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
6091 pub fn hipMemsetD8(
6092 dest: hipDeviceptr_t,
6093 value: ::std::os::raw::c_uchar,
6094 count: usize,
6095 ) -> hipError_t;
6096}
6097extern "C" {
6098 #[doc = " @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant\n byte value value.\n\n hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the\n memset is complete. The operation can optionally be associated to a stream by passing a non-zero\n stream argument. If stream is non-zero, the operation may overlap with operations in other\n streams.\n\n @param[out] dest Data ptr to be filled\n @param[in] value Constant value to be set\n @param[in] count Number of values to be set\n @param[in] stream Stream identifier\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
6099 pub fn hipMemsetD8Async(
6100 dest: hipDeviceptr_t,
6101 value: ::std::os::raw::c_uchar,
6102 count: usize,
6103 stream: hipStream_t,
6104 ) -> hipError_t;
6105}
6106extern "C" {
6107 #[doc = " @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant\n short value value.\n\n @param[out] dest Data ptr to be filled\n @param[in] value Constant value to be set\n @param[in] count Number of values to be set\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
6108 pub fn hipMemsetD16(
6109 dest: hipDeviceptr_t,
6110 value: ::std::os::raw::c_ushort,
6111 count: usize,
6112 ) -> hipError_t;
6113}
6114extern "C" {
6115 #[doc = " @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant\n short value value.\n\n hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the\n memset is complete. The operation can optionally be associated to a stream by passing a non-zero\n stream argument. If stream is non-zero, the operation may overlap with operations in other\n streams.\n\n @param[out] dest Data ptr to be filled\n @param[in] value Constant value to be set\n @param[in] count Number of values to be set\n @param[in] stream Stream identifier\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
6116 pub fn hipMemsetD16Async(
6117 dest: hipDeviceptr_t,
6118 value: ::std::os::raw::c_ushort,
6119 count: usize,
6120 stream: hipStream_t,
6121 ) -> hipError_t;
6122}
6123extern "C" {
6124 #[doc = " @brief Fills the memory area pointed to by dest with the constant integer\n value for specified number of times.\n\n @param[out] dest Data being filled\n @param[in] value Constant value to be set\n @param[in] count Number of values to be set\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
6125 pub fn hipMemsetD32(
6126 dest: hipDeviceptr_t,
6127 value: ::std::os::raw::c_int,
6128 count: usize,
6129 ) -> hipError_t;
6130}
6131extern "C" {
6132 #[doc = " @brief Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant\n byte value value.\n\n hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the\n memset is complete. The operation can optionally be associated to a stream by passing a non-zero\n stream argument. If stream is non-zero, the operation may overlap with operations in other\n streams.\n\n @param[out] dst Pointer to device memory\n @param[in] value Value to set for each byte of specified memory\n @param[in] sizeBytes Size in bytes to set\n @param[in] stream Stream identifier\n @return #hipSuccess, #hipErrorInvalidValue"]
6133 pub fn hipMemsetAsync(
6134 dst: *mut ::std::os::raw::c_void,
6135 value: ::std::os::raw::c_int,
6136 sizeBytes: usize,
6137 stream: hipStream_t,
6138 ) -> hipError_t;
6139}
6140extern "C" {
6141 #[doc = " @brief Fills the memory area pointed to by dev with the constant integer\n value for specified number of times.\n\n hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the\n memset is complete. The operation can optionally be associated to a stream by passing a non-zero\n stream argument. If stream is non-zero, the operation may overlap with operations in other\n streams.\n\n @param[out] dst Pointer to device memory\n @param[in] value Value to set for each byte of specified memory\n @param[in] count Number of values to be set\n @param[in] stream Stream identifier\n @return #hipSuccess, #hipErrorInvalidValue"]
6142 pub fn hipMemsetD32Async(
6143 dst: hipDeviceptr_t,
6144 value: ::std::os::raw::c_int,
6145 count: usize,
6146 stream: hipStream_t,
6147 ) -> hipError_t;
6148}
6149extern "C" {
6150 #[doc = " @brief Fills the memory area pointed to by dst with the constant value.\n\n @param[out] dst Pointer to device memory\n @param[in] pitch Data size in bytes\n @param[in] value Constant value to be set\n @param[in] width\n @param[in] height\n @returns #hipSuccess, #hipErrorInvalidValue"]
6151 pub fn hipMemset2D(
6152 dst: *mut ::std::os::raw::c_void,
6153 pitch: usize,
6154 value: ::std::os::raw::c_int,
6155 width: usize,
6156 height: usize,
6157 ) -> hipError_t;
6158}
6159extern "C" {
6160 #[doc = " @brief Fills asynchronously the memory area pointed to by dst with the constant value.\n\n @param[in] dst Pointer to 2D device memory\n @param[in] pitch Pitch size in bytes\n @param[in] value Value to be set for each byte of specified memory\n @param[in] width Width of matrix set columns in bytes\n @param[in] height Height of matrix set rows in bytes\n @param[in] stream Stream identifier\n @returns #hipSuccess, #hipErrorInvalidValue"]
6161 pub fn hipMemset2DAsync(
6162 dst: *mut ::std::os::raw::c_void,
6163 pitch: usize,
6164 value: ::std::os::raw::c_int,
6165 width: usize,
6166 height: usize,
6167 stream: hipStream_t,
6168 ) -> hipError_t;
6169}
6170extern "C" {
6171 #[doc = " @brief Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.\n\n @param[in] pitchedDevPtr Pointer to pitched device memory\n @param[in] value Value to set for each byte of specified memory\n @param[in] extent Size parameters for width field in bytes in device memory\n @returns #hipSuccess, #hipErrorInvalidValue"]
6172 pub fn hipMemset3D(
6173 pitchedDevPtr: hipPitchedPtr,
6174 value: ::std::os::raw::c_int,
6175 extent: hipExtent,
6176 ) -> hipError_t;
6177}
6178extern "C" {
6179 #[doc = " @brief Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.\n\n @param[in] pitchedDevPtr Pointer to pitched device memory\n @param[in] value Value to set for each byte of specified memory\n @param[in] extent Size parameters for width field in bytes in device memory\n @param[in] stream Stream identifier\n @returns #hipSuccess, #hipErrorInvalidValue"]
6180 pub fn hipMemset3DAsync(
6181 pitchedDevPtr: hipPitchedPtr,
6182 value: ::std::os::raw::c_int,
6183 extent: hipExtent,
6184 stream: hipStream_t,
6185 ) -> hipError_t;
6186}
6187extern "C" {
6188 #[doc = " @brief Query memory info.\n\n On ROCM, this function gets the actual free memory left on the current device, so supports\n the cases while running multi-workload (such as multiple processes, multiple threads, and\n multiple GPUs).\n\n @warning On Windows, the free memory only accounts for memory allocated by this process and may\n be optimistic.\n\n @param[out] free Returns free memory on the current device in bytes\n @param[out] total Returns total allocatable memory on the current device in bytes\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue\n"]
6189 pub fn hipMemGetInfo(free: *mut usize, total: *mut usize) -> hipError_t;
6190}
6191extern "C" {
6192 #[doc = " @brief Get allocated memory size via memory pointer.\n\n This function gets the allocated shared virtual memory size from memory pointer.\n\n @param[in] ptr Pointer to allocated memory\n @param[out] size Returns the allocated memory size in bytes\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6193 pub fn hipMemPtrGetInfo(ptr: *mut ::std::os::raw::c_void, size: *mut usize) -> hipError_t;
6194}
6195extern "C" {
6196 #[doc = " @brief Allocate an array on the device.\n\n @param[out] array Pointer to allocated array in device memory\n @param[in] desc Requested channel format\n @param[in] width Requested array allocation width\n @param[in] height Requested array allocation height\n @param[in] flags Requested properties of allocated array\n @returns #hipSuccess, #hipErrorOutOfMemory\n\n @see hipMalloc, hipMallocPitch, hipFree, hipFreeArray, hipHostMalloc, hipHostFree"]
6197 pub fn hipMallocArray(
6198 array: *mut hipArray_t,
6199 desc: *const hipChannelFormatDesc,
6200 width: usize,
6201 height: usize,
6202 flags: ::std::os::raw::c_uint,
6203 ) -> hipError_t;
6204}
6205extern "C" {
6206 #[doc = " @brief Create an array memory pointer on the device.\n\n @param[out] pHandle Pointer to the array memory\n @param[in] pAllocateArray Requested array desciptor\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @see hipMallocArray, hipArrayDestroy, hipFreeArray"]
6207 pub fn hipArrayCreate(
6208 pHandle: *mut hipArray_t,
6209 pAllocateArray: *const HIP_ARRAY_DESCRIPTOR,
6210 ) -> hipError_t;
6211}
6212extern "C" {
6213 #[doc = " @brief Destroy an array memory pointer on the device.\n\n @param[in] array Pointer to the array memory\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipArrayCreate, hipArrayDestroy, hipFreeArray"]
6214 pub fn hipArrayDestroy(array: hipArray_t) -> hipError_t;
6215}
6216extern "C" {
6217 #[doc = " @brief Create a 3D array memory pointer on the device.\n\n @param[out] array Pointer to the 3D array memory\n @param[in] pAllocateArray Requested array desciptor\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @see hipMallocArray, hipArrayDestroy, hipFreeArray"]
6218 pub fn hipArray3DCreate(
6219 array: *mut hipArray_t,
6220 pAllocateArray: *const HIP_ARRAY3D_DESCRIPTOR,
6221 ) -> hipError_t;
6222}
6223extern "C" {
6224 #[doc = " @brief Create a 3D memory pointer on the device.\n\n @param[out] pitchedDevPtr Pointer to the 3D memory\n @param[in] extent Requested extent\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @see hipMallocPitch, hipMemGetInfo, hipFree"]
6225 pub fn hipMalloc3D(pitchedDevPtr: *mut hipPitchedPtr, extent: hipExtent) -> hipError_t;
6226}
6227extern "C" {
6228 #[doc = " @brief Frees an array on the device.\n\n @param[in] array Pointer to array to free\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized\n\n @see hipMalloc, hipMallocPitch, hipFree, hipMallocArray, hipHostMalloc, hipHostFree"]
6229 pub fn hipFreeArray(array: hipArray_t) -> hipError_t;
6230}
6231extern "C" {
6232 #[doc = " @brief Allocate an array on the device.\n\n @param[out] array Pointer to allocated array in device memory\n @param[in] desc Requested channel format\n @param[in] extent Requested array allocation width, height and depth\n @param[in] flags Requested properties of allocated array\n @returns #hipSuccess, #hipErrorOutOfMemory\n\n @see hipMalloc, hipMallocPitch, hipFree, hipFreeArray, hipHostMalloc, hipHostFree"]
6233 pub fn hipMalloc3DArray(
6234 array: *mut hipArray_t,
6235 desc: *const hipChannelFormatDesc,
6236 extent: hipExtent,
6237 flags: ::std::os::raw::c_uint,
6238 ) -> hipError_t;
6239}
6240extern "C" {
6241 #[doc = " @brief Gets info about the specified array\n\n @param[out] desc - Returned array type\n @param[out] extent - Returned array shape. 2D arrays will have depth of zero\n @param[out] flags - Returned array flags\n @param[in] array - The HIP array to get info for\n\n @returns #hipSuccess, #hipErrorInvalidValue #hipErrorInvalidHandle\n\n @see hipArrayGetDescriptor, hipArray3DGetDescriptor"]
6242 pub fn hipArrayGetInfo(
6243 desc: *mut hipChannelFormatDesc,
6244 extent: *mut hipExtent,
6245 flags: *mut ::std::os::raw::c_uint,
6246 array: hipArray_t,
6247 ) -> hipError_t;
6248}
6249extern "C" {
6250 #[doc = " @brief Gets a 1D or 2D array descriptor\n\n @param[out] pArrayDescriptor - Returned array descriptor\n @param[in] array - Array to get descriptor of\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue #hipErrorInvalidHandle\n\n @see hipArray3DCreate, hipArray3DGetDescriptor, hipArrayCreate, hipArrayDestroy, hipMemAlloc,\n hipMemAllocHost, hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned,\n hipMemcpy3D, hipMemcpy3DAsync, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync,\n hipMemcpyDtoA, hipMemcpyDtoD, hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync,\n hipMemcpyHtoA, hipMemcpyHtoAAsync, hipMemcpyHtoD, hipMemcpyHtoDAsync, hipMemFree,\n hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, hipMemHostAlloc,\n hipMemHostGetDevicePointer, hipMemsetD8, hipMemsetD16, hipMemsetD32, hipArrayGetInfo"]
6251 pub fn hipArrayGetDescriptor(
6252 pArrayDescriptor: *mut HIP_ARRAY_DESCRIPTOR,
6253 array: hipArray_t,
6254 ) -> hipError_t;
6255}
6256extern "C" {
6257 #[doc = " @brief Gets a 3D array descriptor\n\n @param[out] pArrayDescriptor - Returned 3D array descriptor\n @param[in] array - 3D array to get descriptor of\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidValue #hipErrorInvalidHandle, #hipErrorContextIsDestroyed\n\n @see hipArray3DCreate, hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc,\n hipMemAllocHost, hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned,\n hipMemcpy3D, hipMemcpy3DAsync, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync,\n hipMemcpyDtoA, hipMemcpyDtoD, hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync,\n hipMemcpyHtoA, hipMemcpyHtoAAsync, hipMemcpyHtoD, hipMemcpyHtoDAsync, hipMemFree,\n hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, hipMemHostAlloc,\n hipMemHostGetDevicePointer, hipMemsetD8, hipMemsetD16, hipMemsetD32, hipArrayGetInfo"]
6258 pub fn hipArray3DGetDescriptor(
6259 pArrayDescriptor: *mut HIP_ARRAY3D_DESCRIPTOR,
6260 array: hipArray_t,
6261 ) -> hipError_t;
6262}
6263extern "C" {
6264 #[doc = " @brief Copies data between host and device.\n\n @param[in] dst Destination memory address\n @param[in] dpitch Pitch of destination memory\n @param[in] src Source memory address\n @param[in] spitch Pitch of source memory\n @param[in] width Width of matrix transfer (columns in bytes)\n @param[in] height Height of matrix transfer (rows)\n @param[in] kind Type of transfer\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6265 pub fn hipMemcpy2D(
6266 dst: *mut ::std::os::raw::c_void,
6267 dpitch: usize,
6268 src: *const ::std::os::raw::c_void,
6269 spitch: usize,
6270 width: usize,
6271 height: usize,
6272 kind: hipMemcpyKind,
6273 ) -> hipError_t;
6274}
6275extern "C" {
6276 #[doc = " @brief Copies memory for 2D arrays.\n @param[in] pCopy Parameters for the memory copy\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray,\n hipMemcpyToSymbol, hipMemcpyAsync"]
6277 pub fn hipMemcpyParam2D(pCopy: *const hip_Memcpy2D) -> hipError_t;
6278}
6279extern "C" {
6280 #[doc = " @brief Copies memory for 2D arrays.\n @param[in] pCopy Parameters for the memory copy\n @param[in] stream Stream to use\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray,\n hipMemcpyToSymbol, hipMemcpyAsync"]
6281 pub fn hipMemcpyParam2DAsync(pCopy: *const hip_Memcpy2D, stream: hipStream_t) -> hipError_t;
6282}
6283extern "C" {
6284 #[doc = " @brief Copies data between host and device.\n\n @param[in] dst Destination memory address\n @param[in] dpitch Pitch of destination memory\n @param[in] src Source memory address\n @param[in] spitch Pitch of source memory\n @param[in] width Width of matrix transfer (columns in bytes)\n @param[in] height Height of matrix transfer (rows)\n @param[in] kind Type of transfer\n @param[in] stream Stream to use\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6285 pub fn hipMemcpy2DAsync(
6286 dst: *mut ::std::os::raw::c_void,
6287 dpitch: usize,
6288 src: *const ::std::os::raw::c_void,
6289 spitch: usize,
6290 width: usize,
6291 height: usize,
6292 kind: hipMemcpyKind,
6293 stream: hipStream_t,
6294 ) -> hipError_t;
6295}
6296extern "C" {
6297 #[doc = " @brief Copies data between host and device.\n\n @param[in] dst Destination memory address\n @param[in] wOffset Destination starting X offset\n @param[in] hOffset Destination starting Y offset\n @param[in] src Source memory address\n @param[in] spitch Pitch of source memory\n @param[in] width Width of matrix transfer (columns in bytes)\n @param[in] height Height of matrix transfer (rows)\n @param[in] kind Type of transfer\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6298 pub fn hipMemcpy2DToArray(
6299 dst: hipArray_t,
6300 wOffset: usize,
6301 hOffset: usize,
6302 src: *const ::std::os::raw::c_void,
6303 spitch: usize,
6304 width: usize,
6305 height: usize,
6306 kind: hipMemcpyKind,
6307 ) -> hipError_t;
6308}
6309extern "C" {
6310 #[doc = " @brief Copies data between host and device.\n\n @param[in] dst Destination memory address\n @param[in] wOffset Destination starting X offset\n @param[in] hOffset Destination starting Y offset\n @param[in] src Source memory address\n @param[in] spitch Pitch of source memory\n @param[in] width Width of matrix transfer (columns in bytes)\n @param[in] height Height of matrix transfer (rows)\n @param[in] kind Type of transfer\n @param[in] stream Accelerator view which the copy is being enqueued\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6311 pub fn hipMemcpy2DToArrayAsync(
6312 dst: hipArray_t,
6313 wOffset: usize,
6314 hOffset: usize,
6315 src: *const ::std::os::raw::c_void,
6316 spitch: usize,
6317 width: usize,
6318 height: usize,
6319 kind: hipMemcpyKind,
6320 stream: hipStream_t,
6321 ) -> hipError_t;
6322}
6323extern "C" {
6324 #[doc = " @brief Copies data between host and device.\n\n @param[in] dst Destination memory address\n @param[in] wOffsetDst Destination starting X offset\n @param[in] hOffsetDst Destination starting Y offset\n @param[in] src Source memory address\n @param[in] wOffsetSrc Source starting X offset\n @param[in] hOffsetSrc Source starting Y offset (columns in bytes)\n @param[in] width Width of matrix transfer (columns in bytes)\n @param[in] height Height of matrix transfer (rows)\n @param[in] kind Type of transfer\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6325 pub fn hipMemcpy2DArrayToArray(
6326 dst: hipArray_t,
6327 wOffsetDst: usize,
6328 hOffsetDst: usize,
6329 src: hipArray_const_t,
6330 wOffsetSrc: usize,
6331 hOffsetSrc: usize,
6332 width: usize,
6333 height: usize,
6334 kind: hipMemcpyKind,
6335 ) -> hipError_t;
6336}
6337extern "C" {
6338 #[doc = " @brief Copies data between host and device [Deprecated]\n\n @ingroup MemoryD\n\n @param[in] dst Destination memory address\n @param[in] wOffset Destination starting X offset\n @param[in] hOffset Destination starting Y offset\n @param[in] src Source memory address\n @param[in] count size in bytes to copy\n @param[in] kind Type of transfer\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync\n @warning This API is deprecated."]
6339 pub fn hipMemcpyToArray(
6340 dst: hipArray_t,
6341 wOffset: usize,
6342 hOffset: usize,
6343 src: *const ::std::os::raw::c_void,
6344 count: usize,
6345 kind: hipMemcpyKind,
6346 ) -> hipError_t;
6347}
6348extern "C" {
6349 #[doc = " @brief Copies data between host and device [Deprecated]\n\n @ingroup MemoryD\n\n @param[in] dst Destination memory address\n @param[in] srcArray Source memory address\n @param[in] wOffset Source starting X offset\n @param[in] hOffset Source starting Y offset\n @param[in] count Size in bytes to copy\n @param[in] kind Type of transfer\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync\n @warning This API is deprecated."]
6350 pub fn hipMemcpyFromArray(
6351 dst: *mut ::std::os::raw::c_void,
6352 srcArray: hipArray_const_t,
6353 wOffset: usize,
6354 hOffset: usize,
6355 count: usize,
6356 kind: hipMemcpyKind,
6357 ) -> hipError_t;
6358}
6359extern "C" {
6360 #[doc = " @brief Copies data between host and device.\n\n @param[in] dst Destination memory address\n @param[in] dpitch Pitch of destination memory\n @param[in] src Source memory address\n @param[in] wOffset Source starting X offset\n @param[in] hOffset Source starting Y offset\n @param[in] width Width of matrix transfer (columns in bytes)\n @param[in] height Height of matrix transfer (rows)\n @param[in] kind Type of transfer\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6361 pub fn hipMemcpy2DFromArray(
6362 dst: *mut ::std::os::raw::c_void,
6363 dpitch: usize,
6364 src: hipArray_const_t,
6365 wOffset: usize,
6366 hOffset: usize,
6367 width: usize,
6368 height: usize,
6369 kind: hipMemcpyKind,
6370 ) -> hipError_t;
6371}
6372extern "C" {
6373 #[doc = " @brief Copies data between host and device asynchronously.\n\n @param[in] dst Destination memory address\n @param[in] dpitch Pitch of destination memory\n @param[in] src Source memory address\n @param[in] wOffset Source starting X offset\n @param[in] hOffset Source starting Y offset\n @param[in] width Width of matrix transfer (columns in bytes)\n @param[in] height Height of matrix transfer (rows)\n @param[in] kind Type of transfer\n @param[in] stream Accelerator view which the copy is being enqueued\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6374 pub fn hipMemcpy2DFromArrayAsync(
6375 dst: *mut ::std::os::raw::c_void,
6376 dpitch: usize,
6377 src: hipArray_const_t,
6378 wOffset: usize,
6379 hOffset: usize,
6380 width: usize,
6381 height: usize,
6382 kind: hipMemcpyKind,
6383 stream: hipStream_t,
6384 ) -> hipError_t;
6385}
6386extern "C" {
6387 #[doc = " @brief Copies data between host and device.\n\n @param[in] dst Destination memory address\n @param[in] srcArray Source array\n @param[in] srcOffset Offset in bytes of source array\n @param[in] count Size of memory copy in bytes\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6388 pub fn hipMemcpyAtoH(
6389 dst: *mut ::std::os::raw::c_void,
6390 srcArray: hipArray_t,
6391 srcOffset: usize,
6392 count: usize,
6393 ) -> hipError_t;
6394}
6395extern "C" {
6396 #[doc = " @brief Copies data between host and device.\n\n @param[in] dstArray Destination memory address\n @param[in] dstOffset Offset in bytes of destination array\n @param[in] srcHost Source host pointer\n @param[in] count Size of memory copy in bytes\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6397 pub fn hipMemcpyHtoA(
6398 dstArray: hipArray_t,
6399 dstOffset: usize,
6400 srcHost: *const ::std::os::raw::c_void,
6401 count: usize,
6402 ) -> hipError_t;
6403}
6404extern "C" {
6405 #[doc = " @brief Copies data between host and device.\n\n @param[in] p 3D memory copy parameters\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6406 pub fn hipMemcpy3D(p: *const hipMemcpy3DParms) -> hipError_t;
6407}
6408extern "C" {
6409 #[doc = " @brief Copies data between host and device asynchronously.\n\n @param[in] p 3D memory copy parameters\n @param[in] stream Stream to use\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6410 pub fn hipMemcpy3DAsync(p: *const hipMemcpy3DParms, stream: hipStream_t) -> hipError_t;
6411}
6412extern "C" {
6413 #[doc = " @brief Copies data between host and device.\n\n @param[in] pCopy 3D memory copy parameters\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6414 pub fn hipDrvMemcpy3D(pCopy: *const HIP_MEMCPY3D) -> hipError_t;
6415}
6416extern "C" {
6417 #[doc = " @brief Copies data between host and device asynchronously.\n\n @param[in] pCopy 3D memory copy parameters\n @param[in] stream Stream to use\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,\n #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection\n\n @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,\n hipMemcpyAsync"]
6418 pub fn hipDrvMemcpy3DAsync(pCopy: *const HIP_MEMCPY3D, stream: hipStream_t) -> hipError_t;
6419}
6420extern "C" {
6421 #[doc = " @}\n/\n/**\n-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n @defgroup PeerToPeer PeerToPeer Device Memory Access\n @{\n @warning PeerToPeer support is experimental.\n This section describes the PeerToPeer device memory access functions of HIP runtime API.\n/\n/**\n @brief Determine if a device can access a peer's memory.\n\n @param [out] canAccessPeer Returns the peer access capability (0 or 1)\n @param [in] deviceId - device from where memory may be accessed.\n @param [in] peerDeviceId - device where memory is physically located\n\n Returns \"1\" in @p canAccessPeer if the specified @p device is capable\n of directly accessing memory physically located on peerDevice , or \"0\" if not.\n\n Returns \"0\" in @p canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a\n device is not a peer of itself.\n\n @returns #hipSuccess,\n @returns #hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices"]
6422 pub fn hipDeviceCanAccessPeer(
6423 canAccessPeer: *mut ::std::os::raw::c_int,
6424 deviceId: ::std::os::raw::c_int,
6425 peerDeviceId: ::std::os::raw::c_int,
6426 ) -> hipError_t;
6427}
6428extern "C" {
6429 #[doc = " @brief Enable direct access from current device's virtual address space to memory allocations\n physically located on a peer device.\n\n Memory which already allocated on peer device will be mapped into the address space of the\n current device. In addition, all future memory allocations on peerDeviceId will be mapped into\n the address space of the current device when the memory is allocated. The peer memory remains\n accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.\n\n\n @param [in] peerDeviceId Peer device to enable direct access to from the current device\n @param [in] flags Reserved for future use, must be zero\n\n Returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue,\n @returns #hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device."]
6430 pub fn hipDeviceEnablePeerAccess(
6431 peerDeviceId: ::std::os::raw::c_int,
6432 flags: ::std::os::raw::c_uint,
6433 ) -> hipError_t;
6434}
6435extern "C" {
6436 #[doc = " @brief Disable direct access from current device's virtual address space to memory allocations\n physically located on a peer device.\n\n Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been\n enabled from the current device.\n\n @param [in] peerDeviceId Peer device to disable direct access to\n\n @returns #hipSuccess, #hipErrorPeerAccessNotEnabled"]
6437 pub fn hipDeviceDisablePeerAccess(peerDeviceId: ::std::os::raw::c_int) -> hipError_t;
6438}
6439extern "C" {
6440 #[doc = " @brief Get information on memory allocations.\n\n @param [out] pbase - BAse pointer address\n @param [out] psize - Size of allocation\n @param [in] dptr- Device Pointer\n\n @returns #hipSuccess, #hipErrorNotFound\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
6441 pub fn hipMemGetAddressRange(
6442 pbase: *mut hipDeviceptr_t,
6443 psize: *mut usize,
6444 dptr: hipDeviceptr_t,
6445 ) -> hipError_t;
6446}
6447extern "C" {
6448 #[doc = " @brief Copies memory from one device to memory on another device.\n\n @param [out] dst - Destination device pointer.\n @param [in] dstDeviceId - Destination device\n @param [in] src - Source device pointer\n @param [in] srcDeviceId - Source device\n @param [in] sizeBytes - Size of memory copy in bytes\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDevice"]
6449 pub fn hipMemcpyPeer(
6450 dst: *mut ::std::os::raw::c_void,
6451 dstDeviceId: ::std::os::raw::c_int,
6452 src: *const ::std::os::raw::c_void,
6453 srcDeviceId: ::std::os::raw::c_int,
6454 sizeBytes: usize,
6455 ) -> hipError_t;
6456}
6457extern "C" {
6458 #[doc = " @brief Copies memory from one device to memory on another device.\n\n @param [out] dst - Destination device pointer.\n @param [in] dstDeviceId - Destination device\n @param [in] src - Source device pointer\n @param [in] srcDevice - Source device\n @param [in] sizeBytes - Size of memory copy in bytes\n @param [in] stream - Stream identifier\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDevice"]
6459 pub fn hipMemcpyPeerAsync(
6460 dst: *mut ::std::os::raw::c_void,
6461 dstDeviceId: ::std::os::raw::c_int,
6462 src: *const ::std::os::raw::c_void,
6463 srcDevice: ::std::os::raw::c_int,
6464 sizeBytes: usize,
6465 stream: hipStream_t,
6466 ) -> hipError_t;
6467}
6468extern "C" {
6469 #[doc = " @brief Create a context and set it as current/default context\n\n @param [out] ctx Context to create\n @param [in] flags Context creation flags\n @param [in] device device handle\n\n @returns #hipSuccess\n\n @see hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxPushCurrent,\n hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform.\n"]
6470 pub fn hipCtxCreate(
6471 ctx: *mut hipCtx_t,
6472 flags: ::std::os::raw::c_uint,
6473 device: hipDevice_t,
6474 ) -> hipError_t;
6475}
6476extern "C" {
6477 #[doc = " @brief Destroy a HIP context [Deprecated]\n\n @param [in] ctx Context to destroy\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @see hipCtxCreate, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,hipCtxSetCurrent,\n hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6478 pub fn hipCtxDestroy(ctx: hipCtx_t) -> hipError_t;
6479}
6480extern "C" {
6481 #[doc = " @brief Pop the current/default context and return the popped context [Deprecated]\n\n @param [out] ctx The current context to pop\n\n @returns #hipSuccess, #hipErrorInvalidContext\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxSetCurrent, hipCtxGetCurrent,\n hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6482 pub fn hipCtxPopCurrent(ctx: *mut hipCtx_t) -> hipError_t;
6483}
6484extern "C" {
6485 #[doc = " @brief Push the context to be set as current/ default context [Deprecated]\n\n @param [in] ctx The current context to push\n\n @returns #hipSuccess, #hipErrorInvalidContext\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6486 pub fn hipCtxPushCurrent(ctx: hipCtx_t) -> hipError_t;
6487}
6488extern "C" {
6489 #[doc = " @brief Set the passed context as current/default [Deprecated]\n\n @param [in] ctx The context to set as current\n\n @returns #hipSuccess, #hipErrorInvalidContext\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6490 pub fn hipCtxSetCurrent(ctx: hipCtx_t) -> hipError_t;
6491}
6492extern "C" {
6493 #[doc = " @brief Get the handle of the current/ default context [Deprecated]\n\n @param [out] ctx The context to get as current\n\n @returns #hipSuccess, #hipErrorInvalidContext\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetDevice, hipCtxGetFlags, hipCtxPopCurrent,\n hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6494 pub fn hipCtxGetCurrent(ctx: *mut hipCtx_t) -> hipError_t;
6495}
6496extern "C" {
6497 #[doc = " @brief Get the handle of the device associated with current/default context [Deprecated]\n\n @param [out] device The device from the current context\n\n @returns #hipSuccess, #hipErrorInvalidContext\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6498 pub fn hipCtxGetDevice(device: *mut hipDevice_t) -> hipError_t;
6499}
6500extern "C" {
6501 #[doc = " @brief Returns the approximate HIP api version.\n\n @param [in] ctx Context to check [Deprecated]\n @param [out] apiVersion API version to get\n\n @returns #hipSuccess\n\n @warning The HIP feature set does not correspond to an exact CUDA SDK api revision.\n This function always set *apiVersion to 4 as an approximation though HIP supports\n some features which were introduced in later CUDA SDK revisions.\n HIP apps code should not rely on the api revision number here and should\n use arch feature flags to test device capabilities or conditional compilation.\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetDevice, hipCtxGetFlags, hipCtxPopCurrent,\n hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6502 pub fn hipCtxGetApiVersion(ctx: hipCtx_t, apiVersion: *mut ::std::os::raw::c_int)
6503 -> hipError_t;
6504}
6505extern "C" {
6506 #[doc = " @brief Get Cache configuration for a specific function [Deprecated]\n\n @param [out] cacheConfig Cache configuration\n\n @returns #hipSuccess\n\n @warning AMD devices and some Nvidia GPUS do not support reconfigurable cache. This hint is\n ignored on those architectures.\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6507 pub fn hipCtxGetCacheConfig(cacheConfig: *mut hipFuncCache_t) -> hipError_t;
6508}
6509extern "C" {
6510 #[doc = " @brief Set L1/Shared cache partition [Deprecated]\n\n @param [in] cacheConfig Cache configuration to set\n\n @return #hipSuccess\n\n @warning AMD devices and some Nvidia GPUS do not support reconfigurable cache. This hint is\n ignored on those architectures.\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6511 pub fn hipCtxSetCacheConfig(cacheConfig: hipFuncCache_t) -> hipError_t;
6512}
6513extern "C" {
6514 #[doc = " @brief Set Shared memory bank configuration [Deprecated]\n\n @param [in] config Shared memory configuration to set\n\n @return #hipSuccess\n\n @warning AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is\n ignored on those architectures.\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6515 pub fn hipCtxSetSharedMemConfig(config: hipSharedMemConfig) -> hipError_t;
6516}
6517extern "C" {
6518 #[doc = " @brief Get Shared memory bank configuration [Deprecated]\n\n @param [out] pConfig Pointer of shared memory configuration\n\n @return #hipSuccess\n\n @warning AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is\n ignored on those architectures.\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6519 pub fn hipCtxGetSharedMemConfig(pConfig: *mut hipSharedMemConfig) -> hipError_t;
6520}
6521extern "C" {
6522 #[doc = " @brief Blocks until the default context has completed all preceding requested tasks [Deprecated]\n\n @return #hipSuccess\n\n @warning This function waits for all streams on the default context to complete execution, and\n then returns.\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6523 pub fn hipCtxSynchronize() -> hipError_t;
6524}
6525extern "C" {
6526 #[doc = " @brief Return flags used for creating default context [Deprecated]\n\n @param [out] flags Pointer of flags\n\n @returns #hipSuccess\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6527 pub fn hipCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> hipError_t;
6528}
6529extern "C" {
6530 #[doc = " @brief Enables direct access to memory allocations in a peer context [Deprecated]\n\n Memory which already allocated on peer device will be mapped into the address space of the\n current device. In addition, all future memory allocations on peerDeviceId will be mapped into\n the address space of the current device when the memory is allocated. The peer memory remains\n accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.\n\n\n @param [in] peerCtx Peer context\n @param [in] flags flags, need to set as 0\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue,\n #hipErrorPeerAccessAlreadyEnabled\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n @warning PeerToPeer support is experimental.\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6531 pub fn hipCtxEnablePeerAccess(peerCtx: hipCtx_t, flags: ::std::os::raw::c_uint) -> hipError_t;
6532}
6533extern "C" {
6534 #[doc = " @brief Disable direct access from current context's virtual address space to memory allocations\n physically located on a peer context.Disables direct access to memory allocations in a peer\n context and unregisters any registered allocations [Deprecated]\n\n Returns #hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been\n enabled from the current device.\n\n @param [in] peerCtx Peer context to be disabled\n\n @returns #hipSuccess, #hipErrorPeerAccessNotEnabled\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n @warning PeerToPeer support is experimental.\n\n @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on the\n NVIDIA platform."]
6535 pub fn hipCtxDisablePeerAccess(peerCtx: hipCtx_t) -> hipError_t;
6536}
6537extern "C" {
6538 #[doc = " @brief Get the state of the primary context [Deprecated]\n\n @param [in] dev Device to get primary context flags for\n @param [out] flags Pointer to store flags\n @param [out] active Pointer to store context state; 0 = inactive, 1 = active\n\n @returns #hipSuccess\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent driver API on the\n NVIDIA platform."]
6539 pub fn hipDevicePrimaryCtxGetState(
6540 dev: hipDevice_t,
6541 flags: *mut ::std::os::raw::c_uint,
6542 active: *mut ::std::os::raw::c_int,
6543 ) -> hipError_t;
6544}
6545extern "C" {
6546 #[doc = " @brief Release the primary context on the GPU.\n\n @param [in] dev Device which primary context is released [Deprecated]\n\n @returns #hipSuccess\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n @warning This function return #hipSuccess though doesn't release the primaryCtx by design on\n HIP/HCC path.\n\n @warning This API is deprecated on the AMD platform, only for equivalent driver API on the NVIDIA\n platform."]
6547 pub fn hipDevicePrimaryCtxRelease(dev: hipDevice_t) -> hipError_t;
6548}
6549extern "C" {
6550 #[doc = " @brief Retain the primary context on the GPU [Deprecated]\n\n @param [out] pctx Returned context handle of the new context\n @param [in] dev Device which primary context is released\n\n @returns #hipSuccess\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent driver API on the NVIDIA\n platform."]
6551 pub fn hipDevicePrimaryCtxRetain(pctx: *mut hipCtx_t, dev: hipDevice_t) -> hipError_t;
6552}
6553extern "C" {
6554 #[doc = " @brief Resets the primary context on the GPU [Deprecated]\n\n @param [in] dev Device which primary context is reset\n\n @returns #hipSuccess\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent driver API on the NVIDIA\n platform."]
6555 pub fn hipDevicePrimaryCtxReset(dev: hipDevice_t) -> hipError_t;
6556}
6557extern "C" {
6558 #[doc = " @brief Set flags for the primary context [Deprecated]\n\n @param [in] dev Device for which the primary context flags are set\n @param [in] flags New flags for the device\n\n @returns #hipSuccess, #hipErrorContextAlreadyInUse\n\n @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,\n hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice\n\n @warning This API is deprecated on the AMD platform, only for equivalent driver API on the NVIDIA\n platform."]
6559 pub fn hipDevicePrimaryCtxSetFlags(
6560 dev: hipDevice_t,
6561 flags: ::std::os::raw::c_uint,
6562 ) -> hipError_t;
6563}
6564extern "C" {
6565 #[doc = " @}\n/\n/**\n-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n\n @defgroup Module Module Management\n @{\n @ingroup API\n This section describes the module management functions of HIP runtime API.\n\n/\n/**\n @brief Loads code object from file into a module the currrent context.\n\n @param [in] fname Filename of code object to load\n\n @param [out] module Module\n\n @warning File/memory resources allocated in this function are released only in hipModuleUnload.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidContext, #hipErrorFileNotFound,\n #hipErrorOutOfMemory, #hipErrorSharedObjectInitFailed, #hipErrorNotInitialized\n"]
6566 pub fn hipModuleLoad(
6567 module: *mut hipModule_t,
6568 fname: *const ::std::os::raw::c_char,
6569 ) -> hipError_t;
6570}
6571extern "C" {
6572 #[doc = " @brief Frees the module\n\n @param [in] module Module to free\n\n @returns #hipSuccess, #hipErrorInvalidResourceHandle\n\n The module is freed, and the code objects associated with it are destroyed."]
6573 pub fn hipModuleUnload(module: hipModule_t) -> hipError_t;
6574}
6575extern "C" {
6576 #[doc = " @brief Function with kname will be extracted if present in module\n\n @param [in] module Module to get function from\n @param [in] kname Pointer to the name of function\n @param [out] function Pointer to function handle\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidContext, #hipErrorNotInitialized,\n #hipErrorNotFound,"]
6577 pub fn hipModuleGetFunction(
6578 function: *mut hipFunction_t,
6579 module: hipModule_t,
6580 kname: *const ::std::os::raw::c_char,
6581 ) -> hipError_t;
6582}
6583extern "C" {
6584 #[doc = " @brief Find out attributes for a given function.\n @ingroup Execution\n @param [out] attr Attributes of funtion\n @param [in] func Pointer to the function handle\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDeviceFunction"]
6585 pub fn hipFuncGetAttributes(
6586 attr: *mut hipFuncAttributes,
6587 func: *const ::std::os::raw::c_void,
6588 ) -> hipError_t;
6589}
6590extern "C" {
6591 #[doc = " @brief Find out a specific attribute for a given function.\n @ingroup Execution\n @param [out] value Pointer to the value\n @param [in] attrib Attributes of the given funtion\n @param [in] hfunc Function to get attributes from\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDeviceFunction"]
6592 pub fn hipFuncGetAttribute(
6593 value: *mut ::std::os::raw::c_int,
6594 attrib: hipFunction_attribute,
6595 hfunc: hipFunction_t,
6596 ) -> hipError_t;
6597}
6598extern "C" {
6599 #[doc = " @brief Gets pointer to device entry function that matches entry function symbolPtr.\n\n @param [out] functionPtr Device entry function\n @param [in] symbolPtr Pointer to device entry function to search for\n\n @returns #hipSuccess, #hipErrorInvalidDeviceFunction\n"]
6600 pub fn hipGetFuncBySymbol(
6601 functionPtr: *mut hipFunction_t,
6602 symbolPtr: *const ::std::os::raw::c_void,
6603 ) -> hipError_t;
6604}
6605extern "C" {
6606 #[doc = " @brief returns the handle of the texture reference with the name from the module.\n\n @param [in] hmod Module\n @param [in] name Pointer of name of texture reference\n @param [out] texRef Pointer of texture reference\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorNotFound, #hipErrorInvalidValue"]
6607 pub fn hipModuleGetTexRef(
6608 texRef: *mut *mut textureReference,
6609 hmod: hipModule_t,
6610 name: *const ::std::os::raw::c_char,
6611 ) -> hipError_t;
6612}
6613extern "C" {
6614 #[doc = " @brief builds module from code object which resides in host memory. Image is pointer to that\n location.\n\n @param [in] image The pointer to the location of data\n @param [out] module Retuned module\n\n @returns hipSuccess, hipErrorNotInitialized, hipErrorOutOfMemory, hipErrorNotInitialized"]
6615 pub fn hipModuleLoadData(
6616 module: *mut hipModule_t,
6617 image: *const ::std::os::raw::c_void,
6618 ) -> hipError_t;
6619}
6620extern "C" {
6621 #[doc = " @brief builds module from code object which resides in host memory. Image is pointer to that\n location. Options are not used. hipModuleLoadData is called.\n\n @param [in] image The pointer to the location of data\n @param [out] module Retuned module\n @param [in] numOptions Number of options\n @param [in] options Options for JIT\n @param [in] optionValues Option values for JIT\n\n @returns hipSuccess, hipErrorNotInitialized, hipErrorOutOfMemory, hipErrorNotInitialized"]
6622 pub fn hipModuleLoadDataEx(
6623 module: *mut hipModule_t,
6624 image: *const ::std::os::raw::c_void,
6625 numOptions: ::std::os::raw::c_uint,
6626 options: *mut hipJitOption,
6627 optionValues: *mut *mut ::std::os::raw::c_void,
6628 ) -> hipError_t;
6629}
6630extern "C" {
6631 #[doc = " @brief Completes the linking of the given program.\n @param [in] state hip link state\n @param [in] type Type of the input data or bitcode\n @param [in] data Input data which is null terminated\n @param [in] size Size of the input data\n @param [in] name Optional name for this input\n @param [in] numOptions Size of the options\n @param [in] options Array of options applied to this input\n @param [in] optionValues Array of option values cast to void*\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidHandle\n\n If adding the file fails, it will\n @return #hipErrorInvalidConfiguration\n\n @see hipError_t"]
6632 pub fn hipLinkAddData(
6633 state: hipLinkState_t,
6634 type_: hipJitInputType,
6635 data: *mut ::std::os::raw::c_void,
6636 size: usize,
6637 name: *const ::std::os::raw::c_char,
6638 numOptions: ::std::os::raw::c_uint,
6639 options: *mut hipJitOption,
6640 optionValues: *mut *mut ::std::os::raw::c_void,
6641 ) -> hipError_t;
6642}
6643extern "C" {
6644 #[doc = " @brief Adds a file with bit code to be linked with options\n @param [in] state hip link state\n @param [in] type Type of the input data or bitcode\n @param [in] path Path to the input file where bitcode is present\n @param [in] numOptions Size of the options\n @param [in] options Array of options applied to this input\n @param [in] optionValues Array of option values cast to void*\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n If adding the file fails, it will\n @return #hipErrorInvalidConfiguration\n\n @see hipError_t"]
6645 pub fn hipLinkAddFile(
6646 state: hipLinkState_t,
6647 type_: hipJitInputType,
6648 path: *const ::std::os::raw::c_char,
6649 numOptions: ::std::os::raw::c_uint,
6650 options: *mut hipJitOption,
6651 optionValues: *mut *mut ::std::os::raw::c_void,
6652 ) -> hipError_t;
6653}
6654extern "C" {
6655 #[doc = " @brief Completes the linking of the given program.\n @param [in] state hip link state\n @param [out] hipBinOut Upon success, points to the output binary\n @param [out] sizeOut Size of the binary is stored (optional)\n\n @returns #hipSuccess #hipErrorInvalidValue\n\n If adding the data fails, it will\n @return #hipErrorInvalidConfiguration\n\n @see hipError_t"]
6656 pub fn hipLinkComplete(
6657 state: hipLinkState_t,
6658 hipBinOut: *mut *mut ::std::os::raw::c_void,
6659 sizeOut: *mut usize,
6660 ) -> hipError_t;
6661}
6662extern "C" {
6663 #[doc = " @brief Creates the link instance via hip APIs.\n @param [in] numOptions Number of options\n @param [in] option Array of options\n @param [in] optionValues Array of option values cast to void*\n @param [out] stateOut hip link state created upon success\n\n @returns #hipSuccess #hipErrorInvalidValue #hipErrorInvalidConfiguration\n\n @see hipSuccess"]
6664 pub fn hipLinkCreate(
6665 numOptions: ::std::os::raw::c_uint,
6666 options: *mut hipJitOption,
6667 optionValues: *mut *mut ::std::os::raw::c_void,
6668 stateOut: *mut hipLinkState_t,
6669 ) -> hipError_t;
6670}
6671extern "C" {
6672 #[doc = " @brief Deletes the link instance via hip APIs.\n @param [in] state link state instance\n\n @returns #hipSuccess #hipErrorInvalidValue\n\n @see hipSuccess"]
6673 pub fn hipLinkDestroy(state: hipLinkState_t) -> hipError_t;
6674}
6675extern "C" {
6676 #[doc = " @brief launches kernel f with launch parameters and shared memory on stream with arguments passed\n to kernelparams or extra\n @ingroup Execution\n @param [in] f Kernel to launch.\n @param [in] gridDimX X grid dimension specified as multiple of blockDimX.\n @param [in] gridDimY Y grid dimension specified as multiple of blockDimY.\n @param [in] gridDimZ Z grid dimension specified as multiple of blockDimZ.\n @param [in] blockDimX X block dimensions specified in work-items\n @param [in] blockDimY Y grid dimension specified in work-items\n @param [in] blockDimZ Z grid dimension specified in work-items\n @param [in] sharedMemBytes Amount of dynamic shared memory to allocate for this kernel. The\n HIP-Clang compiler provides support for extern shared declarations.\n @param [in] stream Stream where the kernel should be dispatched. May be 0, in which case th\n default stream is used with associated synchronization rules.\n @param [in] kernelParams Kernel parameters to launch\n @param [in] extra Pointer to kernel arguments. These are passed directly to the kernel and\n must be in the memory layout and alignment expected by the kernel.\n All passed arguments must be naturally aligned according to their type. The memory address of each\n argument should be a multiple of its size in bytes. Please refer to hip_porting_driver_api.md\n for sample usage.\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32. So gridDim.x * blockDim.x, gridDim.y * blockDim.y\n and gridDim.z * blockDim.z are always less than 2^32.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue"]
6677 pub fn hipModuleLaunchKernel(
6678 f: hipFunction_t,
6679 gridDimX: ::std::os::raw::c_uint,
6680 gridDimY: ::std::os::raw::c_uint,
6681 gridDimZ: ::std::os::raw::c_uint,
6682 blockDimX: ::std::os::raw::c_uint,
6683 blockDimY: ::std::os::raw::c_uint,
6684 blockDimZ: ::std::os::raw::c_uint,
6685 sharedMemBytes: ::std::os::raw::c_uint,
6686 stream: hipStream_t,
6687 kernelParams: *mut *mut ::std::os::raw::c_void,
6688 extra: *mut *mut ::std::os::raw::c_void,
6689 ) -> hipError_t;
6690}
6691extern "C" {
6692 #[doc = " \\addtogroup ModuleCooperativeG Cooperative groups kernel launch of Module management.\n \\ingroup Module\n @{ */\n/**\n @brief launches kernel f with launch parameters and shared memory on stream with arguments passed\n to kernelParams, where thread blocks can cooperate and synchronize as they execute\n\n @param [in] f Kernel to launch.\n @param [in] gridDimX X grid dimension specified as multiple of blockDimX.\n @param [in] gridDimY Y grid dimension specified as multiple of blockDimY.\n @param [in] gridDimZ Z grid dimension specified as multiple of blockDimZ.\n @param [in] blockDimX X block dimension specified in work-items.\n @param [in] blockDimY Y block dimension specified in work-items.\n @param [in] blockDimZ Z block dimension specified in work-items.\n @param [in] sharedMemBytes Amount of dynamic shared memory to allocate for this kernel. The\n HIP-Clang compiler provides support for extern shared declarations.\n @param [in] stream Stream where the kernel should be dispatched. May be 0,\n in which case the default stream is used with associated synchronization rules.\n @param [in] kernelParams A list of kernel arguments.\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size \\f$ gridDim \\cdot blockDim \\geq 2^{32} \\f$.\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidHandle, #hipErrorInvalidImage, #hipErrorInvalidValue,\n #hipErrorInvalidConfiguration, #hipErrorLaunchFailure, #hipErrorLaunchOutOfResources,\n #hipErrorLaunchTimeOut, #hipErrorCooperativeLaunchTooLarge, #hipErrorSharedObjectInitFailed"]
6693 pub fn hipModuleLaunchCooperativeKernel(
6694 f: hipFunction_t,
6695 gridDimX: ::std::os::raw::c_uint,
6696 gridDimY: ::std::os::raw::c_uint,
6697 gridDimZ: ::std::os::raw::c_uint,
6698 blockDimX: ::std::os::raw::c_uint,
6699 blockDimY: ::std::os::raw::c_uint,
6700 blockDimZ: ::std::os::raw::c_uint,
6701 sharedMemBytes: ::std::os::raw::c_uint,
6702 stream: hipStream_t,
6703 kernelParams: *mut *mut ::std::os::raw::c_void,
6704 ) -> hipError_t;
6705}
6706extern "C" {
6707 #[doc = " @brief Launches kernels on multiple devices where thread blocks can cooperate and\n synchronize as they execute.\n\n @param [in] launchParamsList List of launch parameters, one per device.\n @param [in] numDevices Size of the launchParamsList array.\n @param [in] flags Flags to control launch behavior.\n\n @returns #hipSuccess, #hipErrorDeinitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,\n #hipErrorInvalidHandle, #hipErrorInvalidImage, #hipErrorInvalidValue,\n #hipErrorInvalidConfiguration, #hipErrorInvalidResourceHandle, #hipErrorLaunchFailure,\n #hipErrorLaunchOutOfResources, #hipErrorLaunchTimeOut, #hipErrorCooperativeLaunchTooLarge,\n #hipErrorSharedObjectInitFailed"]
6708 pub fn hipModuleLaunchCooperativeKernelMultiDevice(
6709 launchParamsList: *mut hipFunctionLaunchParams,
6710 numDevices: ::std::os::raw::c_uint,
6711 flags: ::std::os::raw::c_uint,
6712 ) -> hipError_t;
6713}
6714extern "C" {
6715 #[doc = " @brief Launches kernel f with launch parameters and shared memory on stream with arguments passed\n to kernelparams or extra, where thread blocks can cooperate and synchronize as they execute.\n\n @param [in] f - Kernel to launch.\n @param [in] gridDim - Grid dimensions specified as multiple of blockDim.\n @param [in] blockDimX - Block dimensions specified in work-items\n @param [in] kernelParams - Pointer of arguments passed to the kernel. If the kernel has multiple\n parameters, 'kernelParams' should be array of pointers, each points the corresponding argument.\n @param [in] sharedMemBytes - Amount of dynamic shared memory to allocate for this kernel. The\n HIP-Clang compiler provides support for extern shared declarations.\n @param [in] stream - Stream where the kernel should be dispatched. May be 0, in which case th\n default stream is used with associated synchronization rules.\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size \\f$ gridDim \\cdot blockDim \\geq 2^{32} \\f$.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,\n #hipErrorCooperativeLaunchTooLarge"]
6716 pub fn hipLaunchCooperativeKernel(
6717 f: *const ::std::os::raw::c_void,
6718 gridDim: dim3,
6719 blockDimX: dim3,
6720 kernelParams: *mut *mut ::std::os::raw::c_void,
6721 sharedMemBytes: ::std::os::raw::c_uint,
6722 stream: hipStream_t,
6723 ) -> hipError_t;
6724}
6725extern "C" {
6726 #[doc = " @brief Launches kernels on multiple devices where thread blocks can cooperate and\n synchronize as they execute.\n\n @param [in] launchParamsList List of launch parameters, one per device.\n @param [in] numDevices Size of the launchParamsList array.\n @param [in] flags Flags to control launch behavior.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,\n #hipErrorCooperativeLaunchTooLarge"]
6727 pub fn hipLaunchCooperativeKernelMultiDevice(
6728 launchParamsList: *mut hipLaunchParams,
6729 numDevices: ::std::os::raw::c_int,
6730 flags: ::std::os::raw::c_uint,
6731 ) -> hipError_t;
6732}
6733extern "C" {
6734 #[doc = " @brief Launches kernels on multiple devices and guarantees all specified kernels are dispatched\n on respective streams before enqueuing any other work on the specified streams from any other threads\n @ingroup Execution\n @param [in] launchParamsList List of launch parameters, one per device.\n @param [in] numDevices Size of the launchParamsList array.\n @param [in] flags Flags to control launch behavior.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue"]
6735 pub fn hipExtLaunchMultiKernelMultiDevice(
6736 launchParamsList: *mut hipLaunchParams,
6737 numDevices: ::std::os::raw::c_int,
6738 flags: ::std::os::raw::c_uint,
6739 ) -> hipError_t;
6740}
6741extern "C" {
6742 #[doc = "-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n @defgroup Occupancy Occupancy\n @{\n This section describes the occupancy functions of HIP runtime API.\n\n/\n/**\n @brief determine the grid and block sizes to achieves maximum occupancy for a kernel\n\n @param [out] gridSize minimum grid size for maximum potential occupancy\n @param [out] blockSize block size for maximum potential occupancy\n @param [in] f kernel function for which occupancy is calulated\n @param [in] dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block\n @param [in] blockSizeLimit the maximum block size for the kernel, use 0 for no limit\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32.\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
6743 pub fn hipModuleOccupancyMaxPotentialBlockSize(
6744 gridSize: *mut ::std::os::raw::c_int,
6745 blockSize: *mut ::std::os::raw::c_int,
6746 f: hipFunction_t,
6747 dynSharedMemPerBlk: usize,
6748 blockSizeLimit: ::std::os::raw::c_int,
6749 ) -> hipError_t;
6750}
6751extern "C" {
6752 #[doc = " @brief determine the grid and block sizes to achieves maximum occupancy for a kernel\n\n @param [out] gridSize minimum grid size for maximum potential occupancy\n @param [out] blockSize block size for maximum potential occupancy\n @param [in] f kernel function for which occupancy is calulated\n @param [in] dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block\n @param [in] blockSizeLimit the maximum block size for the kernel, use 0 for no limit\n @param [in] flags Extra flags for occupancy calculation (only default supported)\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32.\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
6753 pub fn hipModuleOccupancyMaxPotentialBlockSizeWithFlags(
6754 gridSize: *mut ::std::os::raw::c_int,
6755 blockSize: *mut ::std::os::raw::c_int,
6756 f: hipFunction_t,
6757 dynSharedMemPerBlk: usize,
6758 blockSizeLimit: ::std::os::raw::c_int,
6759 flags: ::std::os::raw::c_uint,
6760 ) -> hipError_t;
6761}
6762extern "C" {
6763 #[doc = " @brief Returns occupancy for a device function.\n\n @param [out] numBlocks Returned occupancy\n @param [in] f Kernel function (hipFunction) for which occupancy is calulated\n @param [in] blockSize Block size the kernel is intended to be launched with\n @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block\n @returns #hipSuccess, #hipErrorInvalidValue"]
6764 pub fn hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(
6765 numBlocks: *mut ::std::os::raw::c_int,
6766 f: hipFunction_t,
6767 blockSize: ::std::os::raw::c_int,
6768 dynSharedMemPerBlk: usize,
6769 ) -> hipError_t;
6770}
6771extern "C" {
6772 #[doc = " @brief Returns occupancy for a device function.\n\n @param [out] numBlocks Returned occupancy\n @param [in] f Kernel function(hipFunction_t) for which occupancy is calulated\n @param [in] blockSize Block size the kernel is intended to be launched with\n @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block\n @param [in] flags Extra flags for occupancy calculation (only default supported)\n @returns #hipSuccess, #hipErrorInvalidValue"]
6773 pub fn hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
6774 numBlocks: *mut ::std::os::raw::c_int,
6775 f: hipFunction_t,
6776 blockSize: ::std::os::raw::c_int,
6777 dynSharedMemPerBlk: usize,
6778 flags: ::std::os::raw::c_uint,
6779 ) -> hipError_t;
6780}
6781extern "C" {
6782 #[doc = " @brief Returns occupancy for a device function.\n\n @param [out] numBlocks Returned occupancy\n @param [in] f Kernel function for which occupancy is calulated\n @param [in] blockSize Block size the kernel is intended to be launched with\n @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block\n @returns #hipSuccess, #hipErrorInvalidDeviceFunction, #hipErrorInvalidValue"]
6783 pub fn hipOccupancyMaxActiveBlocksPerMultiprocessor(
6784 numBlocks: *mut ::std::os::raw::c_int,
6785 f: *const ::std::os::raw::c_void,
6786 blockSize: ::std::os::raw::c_int,
6787 dynSharedMemPerBlk: usize,
6788 ) -> hipError_t;
6789}
6790extern "C" {
6791 #[doc = " @brief Returns occupancy for a device function.\n\n @param [out] numBlocks Returned occupancy\n @param [in] f Kernel function for which occupancy is calulated\n @param [in] blockSize Block size the kernel is intended to be launched with\n @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block\n @param [in] flags Extra flags for occupancy calculation (currently ignored)\n @returns #hipSuccess, #hipErrorInvalidDeviceFunction, #hipErrorInvalidValue"]
6792 pub fn hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
6793 numBlocks: *mut ::std::os::raw::c_int,
6794 f: *const ::std::os::raw::c_void,
6795 blockSize: ::std::os::raw::c_int,
6796 dynSharedMemPerBlk: usize,
6797 flags: ::std::os::raw::c_uint,
6798 ) -> hipError_t;
6799}
6800extern "C" {
6801 #[doc = " @brief determine the grid and block sizes to achieves maximum occupancy for a kernel\n\n @param [out] gridSize minimum grid size for maximum potential occupancy\n @param [out] blockSize block size for maximum potential occupancy\n @param [in] f kernel function for which occupancy is calulated\n @param [in] dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block\n @param [in] blockSizeLimit the maximum block size for the kernel, use 0 for no limit\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32.\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
6802 pub fn hipOccupancyMaxPotentialBlockSize(
6803 gridSize: *mut ::std::os::raw::c_int,
6804 blockSize: *mut ::std::os::raw::c_int,
6805 f: *const ::std::os::raw::c_void,
6806 dynSharedMemPerBlk: usize,
6807 blockSizeLimit: ::std::os::raw::c_int,
6808 ) -> hipError_t;
6809}
6810extern "C" {
6811 #[doc = " @brief Start recording of profiling information [Deprecated]\n When using this API, start the profiler with profiling disabled. (--startdisabled)\n @returns #hipErrorNotSupported\n @warning hipProfilerStart API is deprecated, use roctracer/rocTX instead."]
6812 pub fn hipProfilerStart() -> hipError_t;
6813}
6814extern "C" {
6815 #[doc = " @brief Stop recording of profiling information [Deprecated]\n When using this API, start the profiler with profiling disabled. (--startdisabled)\n @returns #hipErrorNotSupported\n @warning hipProfilerStart API is deprecated, use roctracer/rocTX instead."]
6816 pub fn hipProfilerStop() -> hipError_t;
6817}
6818extern "C" {
6819 #[doc = " @}\n/\n/**\n-------------------------------------------------------------------------------------------------\n-------------------------------------------------------------------------------------------------\n @defgroup Clang Launch API to support the triple-chevron syntax\n @{\n This section describes the API to support the triple-chevron syntax.\n/\n/**\n @brief Configure a kernel launch.\n\n @param [in] gridDim grid dimension specified as multiple of blockDim.\n @param [in] blockDim block dimensions specified in work-items\n @param [in] sharedMem Amount of dynamic shared memory to allocate for this kernel. The\n HIP-Clang compiler provides support for extern shared declarations.\n @param [in] stream Stream where the kernel should be dispatched. May be 0, in which case the\n default stream is used with associated synchronization rules.\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue\n"]
6820 pub fn hipConfigureCall(
6821 gridDim: dim3,
6822 blockDim: dim3,
6823 sharedMem: usize,
6824 stream: hipStream_t,
6825 ) -> hipError_t;
6826}
6827extern "C" {
6828 #[doc = " @brief Set a kernel argument.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue\n\n @param [in] arg Pointer the argument in host memory.\n @param [in] size Size of the argument.\n @param [in] offset Offset of the argument on the argument stack.\n"]
6829 pub fn hipSetupArgument(
6830 arg: *const ::std::os::raw::c_void,
6831 size: usize,
6832 offset: usize,
6833 ) -> hipError_t;
6834}
6835extern "C" {
6836 #[doc = " @brief Launch a kernel.\n\n @param [in] func Kernel to launch.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue\n"]
6837 pub fn hipLaunchByPtr(func: *const ::std::os::raw::c_void) -> hipError_t;
6838}
6839extern "C" {
6840 #[doc = " @brief Push configuration of a kernel launch.\n\n @param [in] gridDim grid dimension specified as multiple of blockDim.\n @param [in] blockDim block dimensions specified in work-items\n @param [in] sharedMem Amount of dynamic shared memory to allocate for this kernel. The\n HIP-Clang compiler provides support for extern shared declarations.\n @param [in] stream Stream where the kernel should be dispatched. May be 0, in which case the\n default stream is used with associated synchronization rules.\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue\n"]
6841 pub fn __hipPushCallConfiguration(
6842 gridDim: dim3,
6843 blockDim: dim3,
6844 sharedMem: usize,
6845 stream: hipStream_t,
6846 ) -> hipError_t;
6847}
6848extern "C" {
6849 #[doc = " @brief Pop configuration of a kernel launch.\n\n @param [out] gridDim grid dimension specified as multiple of blockDim.\n @param [out] blockDim block dimensions specified in work-items\n @param [out] sharedMem Amount of dynamic shared memory to allocate for this kernel. The\n HIP-Clang compiler provides support for extern shared declarations.\n @param [out] stream Stream where the kernel should be dispatched. May be 0, in which case the\n default stream is used with associated synchronization rules.\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32.\n\n Please note, HIP does not support kernel launch with total work items defined in dimension with\n size gridDim x blockDim >= 2^32.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue\n"]
6850 pub fn __hipPopCallConfiguration(
6851 gridDim: *mut dim3,
6852 blockDim: *mut dim3,
6853 sharedMem: *mut usize,
6854 stream: *mut hipStream_t,
6855 ) -> hipError_t;
6856}
6857extern "C" {
6858 #[doc = " @brief C compliant kernel launch API\n\n @param [in] function_address - Kernel stub function pointer.\n @param [in] numBlocks - Number of blocks.\n @param [in] dimBlocks - Dimension of a block\n @param [in] args - Pointer of arguments passed to the kernel. If the kernel has multiple\n parameters, 'args' should be array of pointers, each points the corresponding argument.\n @param [in] sharedMemBytes - Amount of dynamic shared memory to allocate for this kernel. The\n HIP-Clang compiler provides support for extern shared declarations.\n @param [in] stream - Stream where the kernel should be dispatched. May be 0, in which case th\n default stream is used with associated synchronization rules.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6859 pub fn hipLaunchKernel(
6860 function_address: *const ::std::os::raw::c_void,
6861 numBlocks: dim3,
6862 dimBlocks: dim3,
6863 args: *mut *mut ::std::os::raw::c_void,
6864 sharedMemBytes: usize,
6865 stream: hipStream_t,
6866 ) -> hipError_t;
6867}
6868extern "C" {
6869 #[doc = " @brief Enqueues a host function call in a stream.\n\n @param [in] stream - The stream to enqueue work in.\n @param [in] fn - The function to call once enqueued preceeding operations are complete.\n @param [in] userData - User-specified data to be passed to the function.\n\n @returns #hipSuccess, #hipErrorInvalidResourceHandle, #hipErrorInvalidValue,\n #hipErrorNotSupported\n\n The host function to call in this API will be executed after the preceding operations in\n the stream are complete. The function is a blocking operation that blocks operations in the\n stream that follow it, until the function is returned.\n Event synchronization and internal callback functions make sure enqueued operations will\n execute in order, in the stream.\n\n The host function must not make any HIP API calls. The host function is non-reentrant. It must\n not perform sychronization with any operation that may depend on other processing execution\n but is not enqueued to run earlier in the stream.\n\n Host functions that are enqueued respectively in different non-blocking streams can run concurrently.\n\n @warning This API is marked as beta, meaning, while this is feature complete,\n it is still open to changes and may have outstanding issues."]
6870 pub fn hipLaunchHostFunc(
6871 stream: hipStream_t,
6872 fn_: hipHostFn_t,
6873 userData: *mut ::std::os::raw::c_void,
6874 ) -> hipError_t;
6875}
6876extern "C" {
6877 #[doc = " Copies memory for 2D arrays.\n\n @param pCopy - Parameters for the memory copy\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
6878 pub fn hipDrvMemcpy2DUnaligned(pCopy: *const hip_Memcpy2D) -> hipError_t;
6879}
6880extern "C" {
6881 #[doc = " @brief Launches kernel from the pointer address, with arguments and shared memory on stream.\n\n @param [in] function_address - Pointer to the Kernel to launch.\n @param [in] numBlocks - Number of blocks.\n @param [in] dimBlocks - Dimension of a block.\n @param [in] args - Pointer of arguments passed to the kernel. If the kernel has multiple\n parameters, 'args' should be array of pointers, each points the corresponding argument.\n @param [in] sharedMemBytes - Amount of dynamic shared memory to allocate for this kernel.\n HIP-Clang compiler provides support for extern shared declarations.\n @param [in] stream - Stream where the kernel should be dispatched.\n May be 0, in which case the default stream is used with associated synchronization rules.\n @param [in] startEvent - If non-null, specified event will be updated to track the start time of\n the kernel launch. The event must be created before calling this API.\n @param [in] stopEvent - If non-null, specified event will be updated to track the stop time of\n the kernel launch. The event must be created before calling this API.\n @param [in] flags - The value of hipExtAnyOrderLaunch, signifies if kernel can be\n launched in any order.\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue.\n"]
6882 pub fn hipExtLaunchKernel(
6883 function_address: *const ::std::os::raw::c_void,
6884 numBlocks: dim3,
6885 dimBlocks: dim3,
6886 args: *mut *mut ::std::os::raw::c_void,
6887 sharedMemBytes: usize,
6888 stream: hipStream_t,
6889 startEvent: hipEvent_t,
6890 stopEvent: hipEvent_t,
6891 flags: ::std::os::raw::c_int,
6892 ) -> hipError_t;
6893}
6894extern "C" {
6895 #[doc = " @brief Creates a texture object.\n\n @param [out] pTexObject pointer to the texture object to create\n @param [in] pResDesc pointer to resource descriptor\n @param [in] pTexDesc pointer to texture descriptor\n @param [in] pResViewDesc pointer to resource view descriptor\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported, #hipErrorOutOfMemory\n\n @note 3D liner filter isn't supported on GFX90A boards, on which the API @p hipCreateTextureObject will\n return hipErrorNotSupported.\n"]
6896 pub fn hipCreateTextureObject(
6897 pTexObject: *mut hipTextureObject_t,
6898 pResDesc: *const hipResourceDesc,
6899 pTexDesc: *const hipTextureDesc,
6900 pResViewDesc: *const hipResourceViewDesc,
6901 ) -> hipError_t;
6902}
6903extern "C" {
6904 #[doc = " @brief Destroys a texture object.\n\n @param [in] textureObject texture object to destroy\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6905 pub fn hipDestroyTextureObject(textureObject: hipTextureObject_t) -> hipError_t;
6906}
6907extern "C" {
6908 #[doc = " @brief Gets the channel descriptor in an array.\n\n @param [in] desc pointer to channel format descriptor\n @param [out] array memory array on the device\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6909 pub fn hipGetChannelDesc(
6910 desc: *mut hipChannelFormatDesc,
6911 array: hipArray_const_t,
6912 ) -> hipError_t;
6913}
6914extern "C" {
6915 #[doc = " @brief Gets resource descriptor for the texture object.\n\n @param [out] pResDesc pointer to resource descriptor\n @param [in] textureObject texture object\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6916 pub fn hipGetTextureObjectResourceDesc(
6917 pResDesc: *mut hipResourceDesc,
6918 textureObject: hipTextureObject_t,
6919 ) -> hipError_t;
6920}
6921extern "C" {
6922 #[doc = " @brief Gets resource view descriptor for the texture object.\n\n @param [out] pResViewDesc pointer to resource view descriptor\n @param [in] textureObject texture object\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6923 pub fn hipGetTextureObjectResourceViewDesc(
6924 pResViewDesc: *mut hipResourceViewDesc,
6925 textureObject: hipTextureObject_t,
6926 ) -> hipError_t;
6927}
6928extern "C" {
6929 #[doc = " @brief Gets texture descriptor for the texture object.\n\n @param [out] pTexDesc pointer to texture descriptor\n @param [in] textureObject texture object\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6930 pub fn hipGetTextureObjectTextureDesc(
6931 pTexDesc: *mut hipTextureDesc,
6932 textureObject: hipTextureObject_t,
6933 ) -> hipError_t;
6934}
6935extern "C" {
6936 #[doc = " @brief Creates a texture object.\n\n @param [out] pTexObject pointer to texture object to create\n @param [in] pResDesc pointer to resource descriptor\n @param [in] pTexDesc pointer to texture descriptor\n @param [in] pResViewDesc pointer to resource view descriptor\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6937 pub fn hipTexObjectCreate(
6938 pTexObject: *mut hipTextureObject_t,
6939 pResDesc: *const HIP_RESOURCE_DESC,
6940 pTexDesc: *const HIP_TEXTURE_DESC,
6941 pResViewDesc: *const HIP_RESOURCE_VIEW_DESC,
6942 ) -> hipError_t;
6943}
6944extern "C" {
6945 #[doc = " @brief Destroys a texture object.\n\n @param [in] texObject texture object to destroy\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6946 pub fn hipTexObjectDestroy(texObject: hipTextureObject_t) -> hipError_t;
6947}
6948extern "C" {
6949 #[doc = " @brief Gets resource descriptor of a texture object.\n\n @param [out] pResDesc pointer to resource descriptor\n @param [in] texObject texture object\n\n @returns #hipSuccess, #hipErrorNotSupported, #hipErrorInvalidValue\n"]
6950 pub fn hipTexObjectGetResourceDesc(
6951 pResDesc: *mut HIP_RESOURCE_DESC,
6952 texObject: hipTextureObject_t,
6953 ) -> hipError_t;
6954}
6955extern "C" {
6956 #[doc = " @brief Gets resource view descriptor of a texture object.\n\n @param [out] pResViewDesc pointer to resource view descriptor\n @param [in] texObject texture object\n\n @returns #hipSuccess, #hipErrorNotSupported, #hipErrorInvalidValue\n"]
6957 pub fn hipTexObjectGetResourceViewDesc(
6958 pResViewDesc: *mut HIP_RESOURCE_VIEW_DESC,
6959 texObject: hipTextureObject_t,
6960 ) -> hipError_t;
6961}
6962extern "C" {
6963 #[doc = " @brief Gets texture descriptor of a texture object.\n\n @param [out] pTexDesc pointer to texture descriptor\n @param [in] texObject texture object\n\n @returns #hipSuccess, #hipErrorNotSupported, #hipErrorInvalidValue\n"]
6964 pub fn hipTexObjectGetTextureDesc(
6965 pTexDesc: *mut HIP_TEXTURE_DESC,
6966 texObject: hipTextureObject_t,
6967 ) -> hipError_t;
6968}
6969extern "C" {
6970 #[doc = " @brief Allocate a mipmapped array on the device.\n\n @param[out] mipmappedArray - Pointer to allocated mipmapped array in device memory\n @param[in] desc - Requested channel format\n @param[in] extent - Requested allocation size (width field in elements)\n @param[in] numLevels - Number of mipmap levels to allocate\n @param[in] flags - Flags for extensions\n\n @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryAllocation\n\n @note This API is implemented on Linux and is under development on Microsoft Windows.\n"]
6971 pub fn hipMallocMipmappedArray(
6972 mipmappedArray: *mut hipMipmappedArray_t,
6973 desc: *const hipChannelFormatDesc,
6974 extent: hipExtent,
6975 numLevels: ::std::os::raw::c_uint,
6976 flags: ::std::os::raw::c_uint,
6977 ) -> hipError_t;
6978}
6979extern "C" {
6980 #[doc = " @brief Frees a mipmapped array on the device.\n\n @param[in] mipmappedArray - Pointer to mipmapped array to free\n\n @return #hipSuccess, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows.\n"]
6981 pub fn hipFreeMipmappedArray(mipmappedArray: hipMipmappedArray_t) -> hipError_t;
6982}
6983extern "C" {
6984 #[doc = " @brief Gets a mipmap level of a HIP mipmapped array.\n\n @param[out] levelArray - Returned mipmap level HIP array\n @param[in] mipmappedArray - HIP mipmapped array\n @param[in] level - Mipmap level\n\n @return #hipSuccess, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows.\n"]
6985 pub fn hipGetMipmappedArrayLevel(
6986 levelArray: *mut hipArray_t,
6987 mipmappedArray: hipMipmappedArray_const_t,
6988 level: ::std::os::raw::c_uint,
6989 ) -> hipError_t;
6990}
6991extern "C" {
6992 #[doc = " @brief Create a mipmapped array.\n\n @param [out] pHandle pointer to mipmapped array\n @param [in] pMipmappedArrayDesc mipmapped array descriptor\n @param [in] numMipmapLevels mipmap level\n\n @returns #hipSuccess, #hipErrorNotSupported, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
6993 pub fn hipMipmappedArrayCreate(
6994 pHandle: *mut hipMipmappedArray_t,
6995 pMipmappedArrayDesc: *mut HIP_ARRAY3D_DESCRIPTOR,
6996 numMipmapLevels: ::std::os::raw::c_uint,
6997 ) -> hipError_t;
6998}
6999extern "C" {
7000 #[doc = " @brief Destroy a mipmapped array.\n\n @param [out] hMipmappedArray pointer to mipmapped array to destroy\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows.\n"]
7001 pub fn hipMipmappedArrayDestroy(hMipmappedArray: hipMipmappedArray_t) -> hipError_t;
7002}
7003extern "C" {
7004 #[doc = " @brief Get a mipmapped array on a mipmapped level.\n\n @param [in] pLevelArray Pointer of array\n @param [out] hMipMappedArray Pointer of mipmapped array on the requested mipmap level\n @param [out] level Mipmap level\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @note This API is implemented on Linux and is under development on Microsoft Windows.\n"]
7005 pub fn hipMipmappedArrayGetLevel(
7006 pLevelArray: *mut hipArray_t,
7007 hMipMappedArray: hipMipmappedArray_t,
7008 level: ::std::os::raw::c_uint,
7009 ) -> hipError_t;
7010}
7011extern "C" {
7012 #[doc = " @brief Binds a mipmapped array to a texture [Deprecated]\n\n @param [in] tex pointer to the texture reference to bind\n @param [in] mipmappedArray memory mipmapped array on the device\n @param [in] desc opointer to the channel format\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
7013 pub fn hipBindTextureToMipmappedArray(
7014 tex: *const textureReference,
7015 mipmappedArray: hipMipmappedArray_const_t,
7016 desc: *const hipChannelFormatDesc,
7017 ) -> hipError_t;
7018}
7019extern "C" {
7020 #[doc = " @brief Gets the texture reference related with the symbol [Deprecated]\n\n @param [out] texref texture reference\n @param [in] symbol pointer to the symbol related with the texture for the reference\n\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is deprecated.\n"]
7021 pub fn hipGetTextureReference(
7022 texref: *mut *const textureReference,
7023 symbol: *const ::std::os::raw::c_void,
7024 ) -> hipError_t;
7025}
7026extern "C" {
7027 #[doc = " @brief Gets the border color used by a texture reference [Deprecated]\n\n @param [out] pBorderColor Returned Type and Value of RGBA color.\n @param [in] texRef Texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is deprecated.\n"]
7028 pub fn hipTexRefGetBorderColor(
7029 pBorderColor: *mut f32,
7030 texRef: *const textureReference,
7031 ) -> hipError_t;
7032}
7033extern "C" {
7034 #[doc = " @brief Gets the array bound to a texture reference [Deprecated]\n\n\n @param [in] pArray Returned array.\n @param [in] texRef texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is deprecated.\n"]
7035 pub fn hipTexRefGetArray(
7036 pArray: *mut hipArray_t,
7037 texRef: *const textureReference,
7038 ) -> hipError_t;
7039}
7040extern "C" {
7041 #[doc = " @brief Sets address mode for a texture reference [Deprecated]\n\n @param [in] texRef texture reference.\n @param [in] dim Dimension of the texture.\n @param [in] am Value of the texture address mode.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is deprecated.\n"]
7042 pub fn hipTexRefSetAddressMode(
7043 texRef: *mut textureReference,
7044 dim: ::std::os::raw::c_int,
7045 am: hipTextureAddressMode,
7046 ) -> hipError_t;
7047}
7048extern "C" {
7049 #[doc = " @brief Binds an array as a texture reference [Deprecated]\n\n @param [in] tex Pointer texture reference.\n @param [in] array Array to bind.\n @param [in] flags Flags should be set as HIP_TRSA_OVERRIDE_FORMAT, as a valid value.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is deprecated.\n"]
7050 pub fn hipTexRefSetArray(
7051 tex: *mut textureReference,
7052 array: hipArray_const_t,
7053 flags: ::std::os::raw::c_uint,
7054 ) -> hipError_t;
7055}
7056extern "C" {
7057 #[doc = " @brief Set filter mode for a texture reference [Deprecated]\n\n @param [in] texRef Pointer texture reference.\n @param [in] fm Value of texture filter mode.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is deprecated.\n"]
7058 pub fn hipTexRefSetFilterMode(
7059 texRef: *mut textureReference,
7060 fm: hipTextureFilterMode,
7061 ) -> hipError_t;
7062}
7063extern "C" {
7064 #[doc = " @brief Set flags for a texture reference [Deprecated]\n\n @param [in] texRef Pointer texture reference.\n @param [in] Flags Value of flags.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is deprecated.\n"]
7065 pub fn hipTexRefSetFlags(
7066 texRef: *mut textureReference,
7067 Flags: ::std::os::raw::c_uint,
7068 ) -> hipError_t;
7069}
7070extern "C" {
7071 #[doc = " @brief Set format for a texture reference [Deprecated]\n\n @param [in] texRef Pointer texture reference.\n @param [in] fmt Value of format.\n @param [in] NumPackedComponents Number of components per array.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is deprecated.\n"]
7072 pub fn hipTexRefSetFormat(
7073 texRef: *mut textureReference,
7074 fmt: hipArray_Format,
7075 NumPackedComponents: ::std::os::raw::c_int,
7076 ) -> hipError_t;
7077}
7078extern "C" {
7079 #[doc = " @brief Binds a memory area to a texture [Deprecated]\n\n @param [in] offset Offset in bytes.\n @param [in] tex Texture to bind.\n @param [in] devPtr Pointer of memory on the device.\n @param [in] desc Pointer of channel format descriptor.\n @param [in] size Size of memory in bites.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7080 pub fn hipBindTexture(
7081 offset: *mut usize,
7082 tex: *const textureReference,
7083 devPtr: *const ::std::os::raw::c_void,
7084 desc: *const hipChannelFormatDesc,
7085 size: usize,
7086 ) -> hipError_t;
7087}
7088extern "C" {
7089 #[doc = " @brief Binds a 2D memory area to a texture [Deprecated]\n\n @param [in] offset Offset in bytes.\n @param [in] tex Texture to bind.\n @param [in] devPtr Pointer of 2D memory area on the device.\n @param [in] desc Pointer of channel format descriptor.\n @param [in] width Width in texel units.\n @param [in] height Height in texel units.\n @param [in] pitch Pitch in bytes.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7090 pub fn hipBindTexture2D(
7091 offset: *mut usize,
7092 tex: *const textureReference,
7093 devPtr: *const ::std::os::raw::c_void,
7094 desc: *const hipChannelFormatDesc,
7095 width: usize,
7096 height: usize,
7097 pitch: usize,
7098 ) -> hipError_t;
7099}
7100extern "C" {
7101 #[doc = " @brief Binds a memory area to a texture [Deprecated]\n\n @param [in] tex Pointer of texture reference.\n @param [in] array Array to bind.\n @param [in] desc Pointer of channel format descriptor.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7102 pub fn hipBindTextureToArray(
7103 tex: *const textureReference,
7104 array: hipArray_const_t,
7105 desc: *const hipChannelFormatDesc,
7106 ) -> hipError_t;
7107}
7108extern "C" {
7109 #[doc = " @brief Get the offset of the alignment in a texture [Deprecated]\n\n @param [in] offset Offset in bytes.\n @param [in] texref Pointer of texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7110 pub fn hipGetTextureAlignmentOffset(
7111 offset: *mut usize,
7112 texref: *const textureReference,
7113 ) -> hipError_t;
7114}
7115extern "C" {
7116 #[doc = " @brief Unbinds a texture [Deprecated]\n\n @param [in] tex Texture to unbind.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7117 pub fn hipUnbindTexture(tex: *const textureReference) -> hipError_t;
7118}
7119extern "C" {
7120 #[doc = " @brief Gets the address for a texture reference [Deprecated]\n\n @param [out] dev_ptr Pointer of device address.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7121 pub fn hipTexRefGetAddress(
7122 dev_ptr: *mut hipDeviceptr_t,
7123 texRef: *const textureReference,
7124 ) -> hipError_t;
7125}
7126extern "C" {
7127 #[doc = " @brief Gets the address mode for a texture reference [Deprecated]\n\n @param [out] pam Pointer of address mode.\n @param [in] texRef Pointer of texture reference.\n @param [in] dim Dimension.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7128 pub fn hipTexRefGetAddressMode(
7129 pam: *mut hipTextureAddressMode,
7130 texRef: *const textureReference,
7131 dim: ::std::os::raw::c_int,
7132 ) -> hipError_t;
7133}
7134extern "C" {
7135 #[doc = " @brief Gets filter mode for a texture reference [Deprecated]\n\n @param [out] pfm Pointer of filter mode.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7136 pub fn hipTexRefGetFilterMode(
7137 pfm: *mut hipTextureFilterMode,
7138 texRef: *const textureReference,
7139 ) -> hipError_t;
7140}
7141extern "C" {
7142 #[doc = " @brief Gets flags for a texture reference [Deprecated]\n\n @param [out] pFlags Pointer of flags.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7143 pub fn hipTexRefGetFlags(
7144 pFlags: *mut ::std::os::raw::c_uint,
7145 texRef: *const textureReference,
7146 ) -> hipError_t;
7147}
7148extern "C" {
7149 #[doc = " @brief Gets texture format for a texture reference [Deprecated]\n\n @param [out] pFormat Pointer of the format.\n @param [out] pNumChannels Pointer of number of channels.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7150 pub fn hipTexRefGetFormat(
7151 pFormat: *mut hipArray_Format,
7152 pNumChannels: *mut ::std::os::raw::c_int,
7153 texRef: *const textureReference,
7154 ) -> hipError_t;
7155}
7156extern "C" {
7157 #[doc = " @brief Gets the maximum anisotropy for a texture reference [Deprecated]\n\n @param [out] pmaxAnsio Pointer of the maximum anisotropy.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7158 pub fn hipTexRefGetMaxAnisotropy(
7159 pmaxAnsio: *mut ::std::os::raw::c_int,
7160 texRef: *const textureReference,
7161 ) -> hipError_t;
7162}
7163extern "C" {
7164 #[doc = " @brief Gets the mipmap filter mode for a texture reference [Deprecated]\n\n @param [out] pfm Pointer of the mipmap filter mode.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7165 pub fn hipTexRefGetMipmapFilterMode(
7166 pfm: *mut hipTextureFilterMode,
7167 texRef: *const textureReference,
7168 ) -> hipError_t;
7169}
7170extern "C" {
7171 #[doc = " @brief Gets the mipmap level bias for a texture reference [Deprecated]\n\n @param [out] pbias Pointer of the mipmap level bias.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7172 pub fn hipTexRefGetMipmapLevelBias(
7173 pbias: *mut f32,
7174 texRef: *const textureReference,
7175 ) -> hipError_t;
7176}
7177extern "C" {
7178 #[doc = " @brief Gets the minimum and maximum mipmap level clamps for a texture reference [Deprecated]\n\n @param [out] pminMipmapLevelClamp Pointer of the minimum mipmap level clamp.\n @param [out] pmaxMipmapLevelClamp Pointer of the maximum mipmap level clamp.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7179 pub fn hipTexRefGetMipmapLevelClamp(
7180 pminMipmapLevelClamp: *mut f32,
7181 pmaxMipmapLevelClamp: *mut f32,
7182 texRef: *const textureReference,
7183 ) -> hipError_t;
7184}
7185extern "C" {
7186 #[doc = " @brief Gets the mipmapped array bound to a texture reference [Deprecated]\n\n @param [out] pArray Pointer of the mipmapped array.\n @param [in] texRef Pointer of texture reference.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7187 pub fn hipTexRefGetMipMappedArray(
7188 pArray: *mut hipMipmappedArray_t,
7189 texRef: *const textureReference,
7190 ) -> hipError_t;
7191}
7192extern "C" {
7193 #[doc = " @brief Sets an bound address for a texture reference [Deprecated]\n\n @param [out] ByteOffset Pointer of the offset in bytes.\n @param [in] texRef Pointer of texture reference.\n @param [in] dptr Pointer of device address to bind.\n @param [in] bytes Size in bytes.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is deprecated.\n"]
7194 pub fn hipTexRefSetAddress(
7195 ByteOffset: *mut usize,
7196 texRef: *mut textureReference,
7197 dptr: hipDeviceptr_t,
7198 bytes: usize,
7199 ) -> hipError_t;
7200}
7201extern "C" {
7202 #[doc = " @brief Set a bind an address as a 2D texture reference [Deprecated]\n\n @param [in] texRef Pointer of texture reference.\n @param [in] desc Pointer of array descriptor.\n @param [in] dptr Pointer of device address to bind.\n @param [in] Pitch Pitch in bytes.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7203 pub fn hipTexRefSetAddress2D(
7204 texRef: *mut textureReference,
7205 desc: *const HIP_ARRAY_DESCRIPTOR,
7206 dptr: hipDeviceptr_t,
7207 Pitch: usize,
7208 ) -> hipError_t;
7209}
7210extern "C" {
7211 #[doc = " @brief Sets the maximum anisotropy for a texture reference [Deprecated]\n\n @param [in] texRef Pointer of texture reference.\n @param [out] maxAniso Value of the maximum anisotropy.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7212 pub fn hipTexRefSetMaxAnisotropy(
7213 texRef: *mut textureReference,
7214 maxAniso: ::std::os::raw::c_uint,
7215 ) -> hipError_t;
7216}
7217extern "C" {
7218 #[doc = " @brief Sets border color for a texture reference [Deprecated]\n\n @param [in] texRef Pointer of texture reference.\n @param [in] pBorderColor Pointer of border color.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7219 pub fn hipTexRefSetBorderColor(
7220 texRef: *mut textureReference,
7221 pBorderColor: *mut f32,
7222 ) -> hipError_t;
7223}
7224extern "C" {
7225 #[doc = " @brief Sets mipmap filter mode for a texture reference [Deprecated]\n\n @param [in] texRef Pointer of texture reference.\n @param [in] fm Value of filter mode.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7226 pub fn hipTexRefSetMipmapFilterMode(
7227 texRef: *mut textureReference,
7228 fm: hipTextureFilterMode,
7229 ) -> hipError_t;
7230}
7231extern "C" {
7232 #[doc = " @brief Sets mipmap level bias for a texture reference [Deprecated]\n\n @param [in] texRef Pointer of texture reference.\n @param [in] bias Value of mipmap bias.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7233 pub fn hipTexRefSetMipmapLevelBias(texRef: *mut textureReference, bias: f32) -> hipError_t;
7234}
7235extern "C" {
7236 #[doc = " @brief Sets mipmap level clamp for a texture reference [Deprecated]\n\n @param [in] texRef Pointer of texture reference.\n @param [in] minMipMapLevelClamp Value of minimum mipmap level clamp.\n @param [in] maxMipMapLevelClamp Value of maximum mipmap level clamp.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n\n @warning This API is deprecated.\n"]
7237 pub fn hipTexRefSetMipmapLevelClamp(
7238 texRef: *mut textureReference,
7239 minMipMapLevelClamp: f32,
7240 maxMipMapLevelClamp: f32,
7241 ) -> hipError_t;
7242}
7243extern "C" {
7244 #[doc = " @brief Binds mipmapped array to a texture reference [Deprecated]\n\n @param [in] texRef Pointer of texture reference to bind.\n @param [in] mipmappedArray Pointer of mipmapped array to bind.\n @param [in] Flags Flags should be set as HIP_TRSA_OVERRIDE_FORMAT, as a valid value.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is deprecated.\n"]
7245 pub fn hipTexRefSetMipmappedArray(
7246 texRef: *mut textureReference,
7247 mipmappedArray: *mut hipMipmappedArray,
7248 Flags: ::std::os::raw::c_uint,
7249 ) -> hipError_t;
7250}
7251extern "C" {
7252 #[doc = " @defgroup Callback Callback Activity APIs\n @{\n This section describes the callback/Activity of HIP runtime API.\n/\n/**\n @brief Returns HIP API name by ID.\n\n @param [in] id ID of HIP API\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
7253 pub fn hipApiName(id: u32) -> *const ::std::os::raw::c_char;
7254}
7255extern "C" {
7256 #[doc = " @brief Returns kernel name reference by function name.\n\n @param [in] f Name of function\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
7257 pub fn hipKernelNameRef(f: hipFunction_t) -> *const ::std::os::raw::c_char;
7258}
7259extern "C" {
7260 #[doc = " @brief Retrives kernel for a given host pointer, unless stated otherwise.\n\n @param [in] hostFunction Pointer of host function.\n @param [in] stream Stream the kernel is executed on.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
7261 pub fn hipKernelNameRefByPtr(
7262 hostFunction: *const ::std::os::raw::c_void,
7263 stream: hipStream_t,
7264 ) -> *const ::std::os::raw::c_char;
7265}
7266extern "C" {
7267 #[doc = " @brief Returns device ID on the stream.\n\n @param [in] stream Stream of device executed on.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
7268 pub fn hipGetStreamDeviceId(stream: hipStream_t) -> ::std::os::raw::c_int;
7269}
7270extern "C" {
7271 #[doc = " @brief Begins graph capture on a stream.\n\n @param [in] stream - Stream to initiate capture.\n @param [in] mode - Controls the interaction of this capture sequence with other API calls that\n are not safe.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7272 pub fn hipStreamBeginCapture(stream: hipStream_t, mode: hipStreamCaptureMode) -> hipError_t;
7273}
7274extern "C" {
7275 #[doc = " @brief Begins graph capture on a stream to an existing graph.\n\n @param [in] stream - Stream to initiate capture.\n @param [in] graph - Graph to capture into.\n @param [in] dependencies - Dependencies of the first node captured in the stream. Can be NULL if\n numDependencies is 0.\n @param [in] dependencyData - Optional array of data associated with each dependency.\n @param [in] numDependencies - Number of dependencies.\n @param [in] mode - Controls the interaction of this capture sequence with other API calls that\nare not safe.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning param \"const hipGraphEdgeData* dependencyData\" is currently not supported and has to be\npassed as nullptr. This API is marked as beta, meaning, while this is feature complete, it is still\nopen to changes and may have outstanding issues."]
7276 pub fn hipStreamBeginCaptureToGraph(
7277 stream: hipStream_t,
7278 graph: hipGraph_t,
7279 dependencies: *const hipGraphNode_t,
7280 dependencyData: *const hipGraphEdgeData,
7281 numDependencies: usize,
7282 mode: hipStreamCaptureMode,
7283 ) -> hipError_t;
7284}
7285extern "C" {
7286 #[doc = " @brief Ends capture on a stream, returning the captured graph.\n\n @param [in] stream - Stream to end capture.\n @param [out] pGraph - Captured graph.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7287 pub fn hipStreamEndCapture(stream: hipStream_t, pGraph: *mut hipGraph_t) -> hipError_t;
7288}
7289extern "C" {
7290 #[doc = " @brief Get capture status of a stream.\n\n @param [in] stream - Stream of which to get capture status from.\n @param [out] pCaptureStatus - Returns current capture status.\n @param [out] pId - Unique capture ID.\n\n @returns #hipSuccess, #hipErrorStreamCaptureImplicit\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7291 pub fn hipStreamGetCaptureInfo(
7292 stream: hipStream_t,
7293 pCaptureStatus: *mut hipStreamCaptureStatus,
7294 pId: *mut ::std::os::raw::c_ulonglong,
7295 ) -> hipError_t;
7296}
7297extern "C" {
7298 #[doc = " @brief Get stream's capture state\n\n @param [in] stream - Stream of which to get capture status from.\n @param [out] captureStatus_out - Returns current capture status.\n @param [out] id_out - Unique capture ID.\n @param [out] graph_out - Returns the graph being captured into.\n @param [out] dependencies_out - Pointer to an array of nodes representing the graphs dependencies.\n @param [out] numDependencies_out - Returns size of the array returned in dependencies_out.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorStreamCaptureImplicit\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7299 pub fn hipStreamGetCaptureInfo_v2(
7300 stream: hipStream_t,
7301 captureStatus_out: *mut hipStreamCaptureStatus,
7302 id_out: *mut ::std::os::raw::c_ulonglong,
7303 graph_out: *mut hipGraph_t,
7304 dependencies_out: *mut *const hipGraphNode_t,
7305 numDependencies_out: *mut usize,
7306 ) -> hipError_t;
7307}
7308extern "C" {
7309 #[doc = " @brief Get stream's capture state\n\n @param [in] stream - Stream of which to get capture status from.\n @param [out] pCaptureStatus - Returns current capture status.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorStreamCaptureImplicit\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7310 pub fn hipStreamIsCapturing(
7311 stream: hipStream_t,
7312 pCaptureStatus: *mut hipStreamCaptureStatus,
7313 ) -> hipError_t;
7314}
7315extern "C" {
7316 #[doc = " @brief Update the set of dependencies in a capturing stream\n\n @param [in] stream Stream that is being captured.\n @param [in] dependencies Pointer to an array of nodes to add/replace.\n @param [in] numDependencies Size of the dependencies array.\n @param [in] flags Flag to update dependency set. Should be one of the values\n in enum #hipStreamUpdateCaptureDependenciesFlags.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorIllegalState\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7317 pub fn hipStreamUpdateCaptureDependencies(
7318 stream: hipStream_t,
7319 dependencies: *mut hipGraphNode_t,
7320 numDependencies: usize,
7321 flags: ::std::os::raw::c_uint,
7322 ) -> hipError_t;
7323}
7324extern "C" {
7325 #[doc = " @brief Swaps the stream capture mode of a thread.\n\n @param [in] mode - Pointer to mode value to swap with the current mode.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7326 pub fn hipThreadExchangeStreamCaptureMode(mode: *mut hipStreamCaptureMode) -> hipError_t;
7327}
7328extern "C" {
7329 #[doc = " @brief Creates a graph\n\n @param [out] pGraph - pointer to graph to create.\n @param [in] flags - flags for graph creation, must be 0.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryAllocation\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7330 pub fn hipGraphCreate(pGraph: *mut hipGraph_t, flags: ::std::os::raw::c_uint) -> hipError_t;
7331}
7332extern "C" {
7333 #[doc = " @brief Destroys a graph\n\n @param [in] graph - instance of graph to destroy.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7334 pub fn hipGraphDestroy(graph: hipGraph_t) -> hipError_t;
7335}
7336extern "C" {
7337 #[doc = " @brief Adds dependency edges to a graph.\n\n @param [in] graph - Instance of the graph to add dependencies to.\n @param [in] from - Pointer to the graph nodes with dependencies to add from.\n @param [in] to - Pointer to the graph nodes to add dependencies to.\n @param [in] numDependencies - Number of dependencies to add.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7338 pub fn hipGraphAddDependencies(
7339 graph: hipGraph_t,
7340 from: *const hipGraphNode_t,
7341 to: *const hipGraphNode_t,
7342 numDependencies: usize,
7343 ) -> hipError_t;
7344}
7345extern "C" {
7346 #[doc = " @brief Removes dependency edges from a graph.\n\n @param [in] graph - Instance of the graph to remove dependencies from.\n @param [in] from - Array of nodes that provide the dependencies.\n @param [in] to - Array of dependent nodes.\n @param [in] numDependencies - Number of dependencies to remove.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7347 pub fn hipGraphRemoveDependencies(
7348 graph: hipGraph_t,
7349 from: *const hipGraphNode_t,
7350 to: *const hipGraphNode_t,
7351 numDependencies: usize,
7352 ) -> hipError_t;
7353}
7354extern "C" {
7355 #[doc = " @brief Returns a graph's dependency edges.\n\n @param [in] graph - Instance of the graph to get the edges from.\n @param [out] from - Pointer to the graph nodes to return edge endpoints.\n @param [out] to - Pointer to the graph nodes to return edge endpoints.\n @param [out] numEdges - Returns number of edges.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n from and to may both be NULL, in which case this function only returns the number of edges in\n numEdges. Otherwise, numEdges entries will be filled in. If numEdges is higher than the actual\n number of edges, the remaining entries in from and to will be set to NULL, and the number of\n edges actually returned will be written to numEdges.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7356 pub fn hipGraphGetEdges(
7357 graph: hipGraph_t,
7358 from: *mut hipGraphNode_t,
7359 to: *mut hipGraphNode_t,
7360 numEdges: *mut usize,
7361 ) -> hipError_t;
7362}
7363extern "C" {
7364 #[doc = " @brief Returns a graph's nodes.\n\n @param [in] graph - Instance of graph to get the nodes from.\n @param [out] nodes - Pointer to return the graph nodes.\n @param [out] numNodes - Returns the number of graph nodes.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n nodes may be NULL, in which case this function will return the number of nodes in numNodes.\n Otherwise, numNodes entries will be filled in. If numNodes is higher than the actual number of\n nodes, the remaining entries in nodes will be set to NULL, and the number of nodes actually\n obtained will be returned in numNodes.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7365 pub fn hipGraphGetNodes(
7366 graph: hipGraph_t,
7367 nodes: *mut hipGraphNode_t,
7368 numNodes: *mut usize,
7369 ) -> hipError_t;
7370}
7371extern "C" {
7372 #[doc = " @brief Returns a graph's root nodes.\n\n @param [in] graph - Instance of the graph to get the nodes from.\n @param [out] pRootNodes - Pointer to return the graph's root nodes.\n @param [out] pNumRootNodes - Returns the number of graph's root nodes.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n pRootNodes may be NULL, in which case this function will return the number of root nodes in\n pNumRootNodes. Otherwise, pNumRootNodes entries will be filled in. If pNumRootNodes is higher\n than the actual number of root nodes, the remaining entries in pRootNodes will be set to NULL,\n and the number of nodes actually obtained will be returned in pNumRootNodes.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7373 pub fn hipGraphGetRootNodes(
7374 graph: hipGraph_t,
7375 pRootNodes: *mut hipGraphNode_t,
7376 pNumRootNodes: *mut usize,
7377 ) -> hipError_t;
7378}
7379extern "C" {
7380 #[doc = " @brief Returns a node's dependencies.\n\n @param [in] node - Graph node to get the dependencies from.\n @param [out] pDependencies - Pointer to return the dependencies.\n @param [out] pNumDependencies - Returns the number of graph node dependencies.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n pDependencies may be NULL, in which case this function will return the number of dependencies in\n pNumDependencies. Otherwise, pNumDependencies entries will be filled in. If pNumDependencies is\n higher than the actual number of dependencies, the remaining entries in pDependencies will be set\n to NULL, and the number of nodes actually obtained will be returned in pNumDependencies.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7381 pub fn hipGraphNodeGetDependencies(
7382 node: hipGraphNode_t,
7383 pDependencies: *mut hipGraphNode_t,
7384 pNumDependencies: *mut usize,
7385 ) -> hipError_t;
7386}
7387extern "C" {
7388 #[doc = " @brief Returns a node's dependent nodes.\n\n @param [in] node - Graph node to get the dependent nodes from.\n @param [out] pDependentNodes - Pointer to return the graph dependent nodes.\n @param [out] pNumDependentNodes - Returns the number of graph node dependent nodes.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n pDependentNodes may be NULL, in which case this function will return the number of dependent nodes\n in pNumDependentNodes. Otherwise, pNumDependentNodes entries will be filled in. If\n pNumDependentNodes is higher than the actual number of dependent nodes, the remaining entries in\n pDependentNodes will be set to NULL, and the number of nodes actually obtained will be returned\n in pNumDependentNodes.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7389 pub fn hipGraphNodeGetDependentNodes(
7390 node: hipGraphNode_t,
7391 pDependentNodes: *mut hipGraphNode_t,
7392 pNumDependentNodes: *mut usize,
7393 ) -> hipError_t;
7394}
7395extern "C" {
7396 #[doc = " @brief Returns a node's type.\n\n @param [in] node - Node to get type of.\n @param [out] pType - Returns the node's type.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7397 pub fn hipGraphNodeGetType(node: hipGraphNode_t, pType: *mut hipGraphNodeType) -> hipError_t;
7398}
7399extern "C" {
7400 #[doc = " @brief Remove a node from the graph.\n\n @param [in] node - graph node to remove\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7401 pub fn hipGraphDestroyNode(node: hipGraphNode_t) -> hipError_t;
7402}
7403extern "C" {
7404 #[doc = " @brief Clones a graph.\n\n @param [out] pGraphClone - Returns newly created cloned graph.\n @param [in] originalGraph - original graph to clone from.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryAllocation\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7405 pub fn hipGraphClone(pGraphClone: *mut hipGraph_t, originalGraph: hipGraph_t) -> hipError_t;
7406}
7407extern "C" {
7408 #[doc = " @brief Finds a cloned version of a node.\n\n @param [out] pNode - Returns the cloned node.\n @param [in] originalNode - original node handle.\n @param [in] clonedGraph - Cloned graph to query.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7409 pub fn hipGraphNodeFindInClone(
7410 pNode: *mut hipGraphNode_t,
7411 originalNode: hipGraphNode_t,
7412 clonedGraph: hipGraph_t,
7413 ) -> hipError_t;
7414}
7415extern "C" {
7416 #[doc = " @brief Creates an executable graph from a graph\n\n @param [out] pGraphExec - Pointer to instantiated executable graph.\n @param [in] graph - Instance of graph to instantiate.\n @param [out] pErrorNode - Pointer to error node. In case an error occured during\n graph instantiation, it could modify the corresponding node.\n @param [out] pLogBuffer - Pointer to log buffer.\n @param [out] bufferSize - Size of the log buffer.\n\n @returns #hipSuccess, #hipErrorOutOfMemory\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n"]
7417 pub fn hipGraphInstantiate(
7418 pGraphExec: *mut hipGraphExec_t,
7419 graph: hipGraph_t,
7420 pErrorNode: *mut hipGraphNode_t,
7421 pLogBuffer: *mut ::std::os::raw::c_char,
7422 bufferSize: usize,
7423 ) -> hipError_t;
7424}
7425extern "C" {
7426 #[doc = " @brief Creates an executable graph from a graph.\n\n @param [out] pGraphExec - Pointer to instantiated executable graph.\n @param [in] graph - Instance of graph to instantiate.\n @param [in] flags - Flags to control instantiation.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues. It does not support any of\n flag and is behaving as hipGraphInstantiate."]
7427 pub fn hipGraphInstantiateWithFlags(
7428 pGraphExec: *mut hipGraphExec_t,
7429 graph: hipGraph_t,
7430 flags: ::std::os::raw::c_ulonglong,
7431 ) -> hipError_t;
7432}
7433extern "C" {
7434 #[doc = " @brief Creates an executable graph from a graph.\n\n @param [out] pGraphExec - Pointer to instantiated executable graph.\n @param [in] graph - Instance of graph to instantiate.\n @param [in] instantiateParams - Graph instantiation Params\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7435 pub fn hipGraphInstantiateWithParams(
7436 pGraphExec: *mut hipGraphExec_t,
7437 graph: hipGraph_t,
7438 instantiateParams: *mut hipGraphInstantiateParams,
7439 ) -> hipError_t;
7440}
7441extern "C" {
7442 #[doc = " @brief Launches an executable graph in the specified stream.\n\n @param [in] graphExec - Instance of executable graph to launch.\n @param [in] stream - Instance of stream in which to launch executable graph.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7443 pub fn hipGraphLaunch(graphExec: hipGraphExec_t, stream: hipStream_t) -> hipError_t;
7444}
7445extern "C" {
7446 #[doc = " @brief Uploads an executable graph to a stream\n\n @param [in] graphExec - Instance of executable graph to be uploaded.\n @param [in] stream - Instance of stream to which the executable graph is uploaded to.\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7447 pub fn hipGraphUpload(graphExec: hipGraphExec_t, stream: hipStream_t) -> hipError_t;
7448}
7449extern "C" {
7450 #[doc = " @brief Creates a kernel execution node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to kernel graph node that is created.\n @param [in] graph - Instance of graph to add the created node to.\n @param [in] pDependencies - Pointer to the dependencies on the kernel execution node.\n @param [in] numDependencies - Number of dependencies.\n @param [in] nodeParams - Pointer to the node parameters.\n @returns #hipSuccess, #hipErrorInvalidValue.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7451 pub fn hipGraphAddNode(
7452 pGraphNode: *mut hipGraphNode_t,
7453 graph: hipGraph_t,
7454 pDependencies: *const hipGraphNode_t,
7455 numDependencies: usize,
7456 nodeParams: *mut hipGraphNodeParams,
7457 ) -> hipError_t;
7458}
7459extern "C" {
7460 #[doc = " @brief Return the flags of an executable graph.\n\n @param [in] graphExec - Executable graph to get the flags from.\n @param [out] flags - Flags used to instantiate this executable graph.\n @returns #hipSuccess, #hipErrorInvalidValue.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7461 pub fn hipGraphExecGetFlags(
7462 graphExec: hipGraphExec_t,
7463 flags: *mut ::std::os::raw::c_ulonglong,
7464 ) -> hipError_t;
7465}
7466extern "C" {
7467 #[doc = " @brief Updates parameters of a graph's node.\n\n @param [in] node - Instance of the node to set parameters for.\n @param [in] nodeParams - Pointer to the parameters to be set.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDeviceFunction, #hipErrorNotSupported.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7468 pub fn hipGraphNodeSetParams(
7469 node: hipGraphNode_t,
7470 nodeParams: *mut hipGraphNodeParams,
7471 ) -> hipError_t;
7472}
7473extern "C" {
7474 #[doc = " @brief Updates parameters of an executable graph's node.\n\n @param [in] graphExec - Instance of the executable graph.\n @param [in] node - Instance of the node to set parameters to.\n @param [in] nodeParams - Pointer to the parameters to be set.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDeviceFunction, #hipErrorNotSupported.\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7475 pub fn hipGraphExecNodeSetParams(
7476 graphExec: hipGraphExec_t,
7477 node: hipGraphNode_t,
7478 nodeParams: *mut hipGraphNodeParams,
7479 ) -> hipError_t;
7480}
7481extern "C" {
7482 #[doc = " @brief Destroys an executable graph\n\n @param [in] graphExec - Instance of executable graph to destroy.\n\n @returns #hipSuccess.\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7483 pub fn hipGraphExecDestroy(graphExec: hipGraphExec_t) -> hipError_t;
7484}
7485extern "C" {
7486 #[doc = " @brief Check whether an executable graph can be updated with a graph and perform the update if *\n possible.\n\n @param [in] hGraphExec - instance of executable graph to update.\n @param [in] hGraph - graph that contains the updated parameters.\n @param [in] hErrorNode_out - node which caused the permissibility check to forbid the update.\n @param [in] updateResult_out - Return code whether the graph update was performed.\n @returns #hipSuccess, #hipErrorGraphExecUpdateFailure\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7487 pub fn hipGraphExecUpdate(
7488 hGraphExec: hipGraphExec_t,
7489 hGraph: hipGraph_t,
7490 hErrorNode_out: *mut hipGraphNode_t,
7491 updateResult_out: *mut hipGraphExecUpdateResult,
7492 ) -> hipError_t;
7493}
7494extern "C" {
7495 #[doc = " @brief Creates a kernel execution node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created\n @param [in] graph - Instance of graph to add the created node to.\n @param [in] pDependencies - Pointer to the dependencies of the kernel execution node.\n @param [in] numDependencies - The number of the dependencies.\n @param [in] pNodeParams - Pointer to the parameters of the kernel execution node.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDeviceFunction\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7496 pub fn hipGraphAddKernelNode(
7497 pGraphNode: *mut hipGraphNode_t,
7498 graph: hipGraph_t,
7499 pDependencies: *const hipGraphNode_t,
7500 numDependencies: usize,
7501 pNodeParams: *const hipKernelNodeParams,
7502 ) -> hipError_t;
7503}
7504extern "C" {
7505 #[doc = " @brief Gets kernel node's parameters.\n\n @param [in] node - instance of the node to get parameters from.\n @param [out] pNodeParams - pointer to the parameters\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7506 pub fn hipGraphKernelNodeGetParams(
7507 node: hipGraphNode_t,
7508 pNodeParams: *mut hipKernelNodeParams,
7509 ) -> hipError_t;
7510}
7511extern "C" {
7512 #[doc = " @brief Sets a kernel node's parameters.\n\n @param [in] node - Instance of the node to set parameters of.\n @param [in] pNodeParams - const pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7513 pub fn hipGraphKernelNodeSetParams(
7514 node: hipGraphNode_t,
7515 pNodeParams: *const hipKernelNodeParams,
7516 ) -> hipError_t;
7517}
7518extern "C" {
7519 #[doc = " @brief Sets the parameters for a kernel node in the given graphExec.\n\n @param [in] hGraphExec - Instance of the executable graph with the node.\n @param [in] node - Instance of the node to set parameters of.\n @param [in] pNodeParams - const pointer to the kernel node parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7520 pub fn hipGraphExecKernelNodeSetParams(
7521 hGraphExec: hipGraphExec_t,
7522 node: hipGraphNode_t,
7523 pNodeParams: *const hipKernelNodeParams,
7524 ) -> hipError_t;
7525}
7526extern "C" {
7527 #[doc = " @brief Creates a memcpy node and adds it to a graph.\n\n @param [out] phGraphNode - Pointer to graph node that is created.\n @param [in] hGraph - Instance of graph to add the created node to.\n @param [in] dependencies - const pointer to the dependencies of the memcpy execution node.\n @param [in] numDependencies - The number of dependencies.\n @param [in] copyParams - const pointer to the parameters for the memory copy.\n @param [in] ctx - context related to current device.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7528 pub fn hipDrvGraphAddMemcpyNode(
7529 phGraphNode: *mut hipGraphNode_t,
7530 hGraph: hipGraph_t,
7531 dependencies: *const hipGraphNode_t,
7532 numDependencies: usize,
7533 copyParams: *const HIP_MEMCPY3D,
7534 ctx: hipCtx_t,
7535 ) -> hipError_t;
7536}
7537extern "C" {
7538 #[doc = " @brief Creates a memcpy node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of graph to add the created node to.\n @param [in] pDependencies - const pointer to the dependencies of the memcpy execution node.\n @param [in] numDependencies - The number of dependencies.\n @param [in] pCopyParams - const pointer to the parameters for the memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7539 pub fn hipGraphAddMemcpyNode(
7540 pGraphNode: *mut hipGraphNode_t,
7541 graph: hipGraph_t,
7542 pDependencies: *const hipGraphNode_t,
7543 numDependencies: usize,
7544 pCopyParams: *const hipMemcpy3DParms,
7545 ) -> hipError_t;
7546}
7547extern "C" {
7548 #[doc = " @brief Gets a memcpy node's parameters.\n\n @param [in] node - instance of the node to get parameters from.\n @param [out] pNodeParams - pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7549 pub fn hipGraphMemcpyNodeGetParams(
7550 node: hipGraphNode_t,
7551 pNodeParams: *mut hipMemcpy3DParms,
7552 ) -> hipError_t;
7553}
7554extern "C" {
7555 #[doc = " @brief Sets a memcpy node's parameters.\n\n @param [in] node - instance of the node to set parameters to.\n @param [in] pNodeParams - const pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7556 pub fn hipGraphMemcpyNodeSetParams(
7557 node: hipGraphNode_t,
7558 pNodeParams: *const hipMemcpy3DParms,
7559 ) -> hipError_t;
7560}
7561extern "C" {
7562 #[doc = " @brief Sets a node's attribute.\n\n @param [in] hNode - Instance of the node to set parameters of.\n @param [in] attr - The attribute type to be set.\n @param [in] value - const pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7563 pub fn hipGraphKernelNodeSetAttribute(
7564 hNode: hipGraphNode_t,
7565 attr: hipLaunchAttributeID,
7566 value: *const hipLaunchAttributeValue,
7567 ) -> hipError_t;
7568}
7569extern "C" {
7570 #[doc = " @brief Gets a node's attribute.\n\n @param [in] hNode - Instance of the node to set parameters of.\n @param [in] attr - The attribute type to be set.\n @param [in] value - const pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7571 pub fn hipGraphKernelNodeGetAttribute(
7572 hNode: hipGraphNode_t,
7573 attr: hipLaunchAttributeID,
7574 value: *mut hipLaunchAttributeValue,
7575 ) -> hipError_t;
7576}
7577extern "C" {
7578 #[doc = " @brief Sets the parameters of a memcpy node in the given graphExec.\n\n @param [in] hGraphExec - Instance of the executable graph with the node.\n @param [in] node - Instance of the node to set parameters of.\n @param [in] pNodeParams - const pointer to the kernel node parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7579 pub fn hipGraphExecMemcpyNodeSetParams(
7580 hGraphExec: hipGraphExec_t,
7581 node: hipGraphNode_t,
7582 pNodeParams: *mut hipMemcpy3DParms,
7583 ) -> hipError_t;
7584}
7585extern "C" {
7586 #[doc = " @brief Creates a 1D memcpy node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of graph to add the created node to.\n @param [in] pDependencies - const pointer to the dependencies of the memcpy execution node.\n @param [in] numDependencies - The number of dependencies.\n @param [in] dst - Pointer to memory address of the destination.\n @param [in] src - Pointer to memory address of the source.\n @param [in] count - Size of the memory to copy.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7587 pub fn hipGraphAddMemcpyNode1D(
7588 pGraphNode: *mut hipGraphNode_t,
7589 graph: hipGraph_t,
7590 pDependencies: *const hipGraphNode_t,
7591 numDependencies: usize,
7592 dst: *mut ::std::os::raw::c_void,
7593 src: *const ::std::os::raw::c_void,
7594 count: usize,
7595 kind: hipMemcpyKind,
7596 ) -> hipError_t;
7597}
7598extern "C" {
7599 #[doc = " @brief Sets a memcpy node's parameters to perform a 1-dimensional copy.\n\n @param [in] node - Instance of the node to set parameters of.\n @param [in] dst - Pointer to memory address of the destination.\n @param [in] src - Pointer to memory address of the source.\n @param [in] count - Size of the memory to copy.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7600 pub fn hipGraphMemcpyNodeSetParams1D(
7601 node: hipGraphNode_t,
7602 dst: *mut ::std::os::raw::c_void,
7603 src: *const ::std::os::raw::c_void,
7604 count: usize,
7605 kind: hipMemcpyKind,
7606 ) -> hipError_t;
7607}
7608extern "C" {
7609 #[doc = " @brief Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional\n copy.\n\n @param [in] hGraphExec - Instance of the executable graph with the node.\n @param [in] node - Instance of the node to set parameters of.\n @param [in] dst - Pointer to memory address of the destination.\n @param [in] src - Pointer to memory address of the source.\n @param [in] count - Size of the memory to copy.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7610 pub fn hipGraphExecMemcpyNodeSetParams1D(
7611 hGraphExec: hipGraphExec_t,
7612 node: hipGraphNode_t,
7613 dst: *mut ::std::os::raw::c_void,
7614 src: *const ::std::os::raw::c_void,
7615 count: usize,
7616 kind: hipMemcpyKind,
7617 ) -> hipError_t;
7618}
7619extern "C" {
7620 #[doc = " @brief Creates a memcpy node to copy from a symbol on the device and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of graph to add the created node to.\n @param [in] pDependencies - const pointer to the dependencies of the memcpy execution node.\n @param [in] numDependencies - Number of the dependencies.\n @param [in] dst - Pointer to memory address of the destination.\n @param [in] symbol - Device symbol address.\n @param [in] count - Size of the memory to copy.\n @param [in] offset - Offset from start of symbol in bytes.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7621 pub fn hipGraphAddMemcpyNodeFromSymbol(
7622 pGraphNode: *mut hipGraphNode_t,
7623 graph: hipGraph_t,
7624 pDependencies: *const hipGraphNode_t,
7625 numDependencies: usize,
7626 dst: *mut ::std::os::raw::c_void,
7627 symbol: *const ::std::os::raw::c_void,
7628 count: usize,
7629 offset: usize,
7630 kind: hipMemcpyKind,
7631 ) -> hipError_t;
7632}
7633extern "C" {
7634 #[doc = " @brief Sets a memcpy node's parameters to copy from a symbol on the device.\n\n @param [in] node - Instance of the node to set parameters of.\n @param [in] dst - Pointer to memory address of the destination.\n @param [in] symbol - Device symbol address.\n @param [in] count - Size of the memory to copy.\n @param [in] offset - Offset from start of symbol in bytes.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7635 pub fn hipGraphMemcpyNodeSetParamsFromSymbol(
7636 node: hipGraphNode_t,
7637 dst: *mut ::std::os::raw::c_void,
7638 symbol: *const ::std::os::raw::c_void,
7639 count: usize,
7640 offset: usize,
7641 kind: hipMemcpyKind,
7642 ) -> hipError_t;
7643}
7644extern "C" {
7645 #[doc = " @brief Sets the parameters for a memcpy node in the given graphExec to copy from a symbol on the\n * device.\n\n @param [in] hGraphExec - Instance of the executable graph with the node.\n @param [in] node - Instance of the node to set parameters of.\n @param [in] dst - Pointer to memory address of the destination.\n @param [in] symbol - Device symbol address.\n @param [in] count - Size of the memory to copy.\n @param [in] offset - Offset from start of symbol in bytes.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7646 pub fn hipGraphExecMemcpyNodeSetParamsFromSymbol(
7647 hGraphExec: hipGraphExec_t,
7648 node: hipGraphNode_t,
7649 dst: *mut ::std::os::raw::c_void,
7650 symbol: *const ::std::os::raw::c_void,
7651 count: usize,
7652 offset: usize,
7653 kind: hipMemcpyKind,
7654 ) -> hipError_t;
7655}
7656extern "C" {
7657 #[doc = " @brief Creates a memcpy node to copy to a symbol on the device and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of graph to add the created node to.\n @param [in] pDependencies - const pointer to the dependencies on the memcpy execution node.\n @param [in] numDependencies - Number of dependencies.\n @param [in] symbol - Device symbol address.\n @param [in] src - Pointer to memory address of the src.\n @param [in] count - Size of the memory to copy.\n @param [in] offset - Offset from start of symbol in bytes.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7658 pub fn hipGraphAddMemcpyNodeToSymbol(
7659 pGraphNode: *mut hipGraphNode_t,
7660 graph: hipGraph_t,
7661 pDependencies: *const hipGraphNode_t,
7662 numDependencies: usize,
7663 symbol: *const ::std::os::raw::c_void,
7664 src: *const ::std::os::raw::c_void,
7665 count: usize,
7666 offset: usize,
7667 kind: hipMemcpyKind,
7668 ) -> hipError_t;
7669}
7670extern "C" {
7671 #[doc = " @brief Sets a memcpy node's parameters to copy to a symbol on the device.\n\n @param [in] node - Instance of the node to set parameters of.\n @param [in] symbol - Device symbol address.\n @param [in] src - Pointer to memory address of the src.\n @param [in] count - Size of the memory to copy.\n @param [in] offset - Offset from start of symbol in bytes.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7672 pub fn hipGraphMemcpyNodeSetParamsToSymbol(
7673 node: hipGraphNode_t,
7674 symbol: *const ::std::os::raw::c_void,
7675 src: *const ::std::os::raw::c_void,
7676 count: usize,
7677 offset: usize,
7678 kind: hipMemcpyKind,
7679 ) -> hipError_t;
7680}
7681extern "C" {
7682 #[doc = " @brief Sets the parameters for a memcpy node in the given graphExec to copy to a symbol on the\n device.\n @param [in] hGraphExec - Instance of the executable graph with the node.\n @param [in] node - Instance of the node to set parameters of.\n @param [in] symbol - Device symbol address.\n @param [in] src - Pointer to memory address of the src.\n @param [in] count - Size of the memory to copy.\n @param [in] offset - Offset from start of symbol in bytes.\n @param [in] kind - Type of memory copy.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7683 pub fn hipGraphExecMemcpyNodeSetParamsToSymbol(
7684 hGraphExec: hipGraphExec_t,
7685 node: hipGraphNode_t,
7686 symbol: *const ::std::os::raw::c_void,
7687 src: *const ::std::os::raw::c_void,
7688 count: usize,
7689 offset: usize,
7690 kind: hipMemcpyKind,
7691 ) -> hipError_t;
7692}
7693extern "C" {
7694 #[doc = " @brief Creates a memset node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of the graph to add the created node to.\n @param [in] pDependencies - const pointer to the dependencies on the memset execution node.\n @param [in] numDependencies - Number of dependencies.\n @param [in] pMemsetParams - const pointer to the parameters for the memory set.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7695 pub fn hipGraphAddMemsetNode(
7696 pGraphNode: *mut hipGraphNode_t,
7697 graph: hipGraph_t,
7698 pDependencies: *const hipGraphNode_t,
7699 numDependencies: usize,
7700 pMemsetParams: *const hipMemsetParams,
7701 ) -> hipError_t;
7702}
7703extern "C" {
7704 #[doc = " @brief Gets a memset node's parameters.\n\n @param [in] node - Instance of the node to get parameters of.\n @param [out] pNodeParams - Pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7705 pub fn hipGraphMemsetNodeGetParams(
7706 node: hipGraphNode_t,
7707 pNodeParams: *mut hipMemsetParams,
7708 ) -> hipError_t;
7709}
7710extern "C" {
7711 #[doc = " @brief Sets a memset node's parameters.\n\n @param [in] node - Instance of the node to set parameters of.\n @param [in] pNodeParams - Pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7712 pub fn hipGraphMemsetNodeSetParams(
7713 node: hipGraphNode_t,
7714 pNodeParams: *const hipMemsetParams,
7715 ) -> hipError_t;
7716}
7717extern "C" {
7718 #[doc = " @brief Sets the parameters for a memset node in the given graphExec.\n\n @param [in] hGraphExec - Instance of the executable graph with the node.\n @param [in] node - Instance of the node to set parameters of.\n @param [in] pNodeParams - Pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7719 pub fn hipGraphExecMemsetNodeSetParams(
7720 hGraphExec: hipGraphExec_t,
7721 node: hipGraphNode_t,
7722 pNodeParams: *const hipMemsetParams,
7723 ) -> hipError_t;
7724}
7725extern "C" {
7726 #[doc = " @brief Creates a host execution node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of the graph to add the created node to.\n @param [in] pDependencies - const pointer to the dependencies of the memset execution node.\n @param [in] numDependencies - Number of dependencies.\n @param [in] pNodeParams - Pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7727 pub fn hipGraphAddHostNode(
7728 pGraphNode: *mut hipGraphNode_t,
7729 graph: hipGraph_t,
7730 pDependencies: *const hipGraphNode_t,
7731 numDependencies: usize,
7732 pNodeParams: *const hipHostNodeParams,
7733 ) -> hipError_t;
7734}
7735extern "C" {
7736 #[doc = " @brief Returns a host node's parameters.\n\n @param [in] node - Instance of the node to get parameters of.\n @param [out] pNodeParams - Pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7737 pub fn hipGraphHostNodeGetParams(
7738 node: hipGraphNode_t,
7739 pNodeParams: *mut hipHostNodeParams,
7740 ) -> hipError_t;
7741}
7742extern "C" {
7743 #[doc = " @brief Sets a host node's parameters.\n\n @param [in] node - Instance of the node to set parameters of.\n @param [in] pNodeParams - Pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7744 pub fn hipGraphHostNodeSetParams(
7745 node: hipGraphNode_t,
7746 pNodeParams: *const hipHostNodeParams,
7747 ) -> hipError_t;
7748}
7749extern "C" {
7750 #[doc = " @brief Sets the parameters for a host node in the given graphExec.\n\n @param [in] hGraphExec - Instance of the executable graph with the node.\n @param [in] node - Instance of the node to set parameters of.\n @param [in] pNodeParams - Pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7751 pub fn hipGraphExecHostNodeSetParams(
7752 hGraphExec: hipGraphExec_t,
7753 node: hipGraphNode_t,
7754 pNodeParams: *const hipHostNodeParams,
7755 ) -> hipError_t;
7756}
7757extern "C" {
7758 #[doc = " @brief Creates a child graph node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of the graph to add the created node.\n @param [in] pDependencies - const pointer to the dependencies of the memset execution node.\n @param [in] numDependencies - Number of dependencies.\n @param [in] childGraph - Graph to clone into this node\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7759 pub fn hipGraphAddChildGraphNode(
7760 pGraphNode: *mut hipGraphNode_t,
7761 graph: hipGraph_t,
7762 pDependencies: *const hipGraphNode_t,
7763 numDependencies: usize,
7764 childGraph: hipGraph_t,
7765 ) -> hipError_t;
7766}
7767extern "C" {
7768 #[doc = " @brief Gets a handle to the embedded graph of a child graph node.\n\n @param [in] node - Instance of the node to get child graph of.\n @param [out] pGraph - Pointer to get the graph.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7769 pub fn hipGraphChildGraphNodeGetGraph(
7770 node: hipGraphNode_t,
7771 pGraph: *mut hipGraph_t,
7772 ) -> hipError_t;
7773}
7774extern "C" {
7775 #[doc = " @brief Updates node parameters in the child graph node in the given graphExec.\n\n @param [in] hGraphExec - instance of the executable graph with the node.\n @param [in] node - node from the graph which was used to instantiate graphExec.\n @param [in] childGraph - child graph with updated parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7776 pub fn hipGraphExecChildGraphNodeSetParams(
7777 hGraphExec: hipGraphExec_t,
7778 node: hipGraphNode_t,
7779 childGraph: hipGraph_t,
7780 ) -> hipError_t;
7781}
7782extern "C" {
7783 #[doc = " @brief Creates an empty node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of the graph the node is added to.\n @param [in] pDependencies - const pointer to the node dependencies.\n @param [in] numDependencies - Number of dependencies.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7784 pub fn hipGraphAddEmptyNode(
7785 pGraphNode: *mut hipGraphNode_t,
7786 graph: hipGraph_t,
7787 pDependencies: *const hipGraphNode_t,
7788 numDependencies: usize,
7789 ) -> hipError_t;
7790}
7791extern "C" {
7792 #[doc = " @brief Creates an event record node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of the graph the node is added to.\n @param [in] pDependencies - const pointer to the node dependencies.\n @param [in] numDependencies - Number of dependencies.\n @param [in] event - Event of the node.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7793 pub fn hipGraphAddEventRecordNode(
7794 pGraphNode: *mut hipGraphNode_t,
7795 graph: hipGraph_t,
7796 pDependencies: *const hipGraphNode_t,
7797 numDependencies: usize,
7798 event: hipEvent_t,
7799 ) -> hipError_t;
7800}
7801extern "C" {
7802 #[doc = " @brief Returns the event associated with an event record node.\n\n @param [in] node - Instance of the node to get event of.\n @param [out] event_out - Pointer to return the event.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7803 pub fn hipGraphEventRecordNodeGetEvent(
7804 node: hipGraphNode_t,
7805 event_out: *mut hipEvent_t,
7806 ) -> hipError_t;
7807}
7808extern "C" {
7809 #[doc = " @brief Sets an event record node's event.\n\n @param [in] node - Instance of the node to set event to.\n @param [in] event - Pointer to the event.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7810 pub fn hipGraphEventRecordNodeSetEvent(node: hipGraphNode_t, event: hipEvent_t) -> hipError_t;
7811}
7812extern "C" {
7813 #[doc = " @brief Sets the event for an event record node in the given graphExec.\n\n @param [in] hGraphExec - instance of the executable graph with the node.\n @param [in] hNode - node from the graph which was used to instantiate graphExec.\n @param [in] event - pointer to the event.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7814 pub fn hipGraphExecEventRecordNodeSetEvent(
7815 hGraphExec: hipGraphExec_t,
7816 hNode: hipGraphNode_t,
7817 event: hipEvent_t,
7818 ) -> hipError_t;
7819}
7820extern "C" {
7821 #[doc = " @brief Creates an event wait node and adds it to a graph.\n\n @param [out] pGraphNode - Pointer to graph node that is created.\n @param [in] graph - Instance of the graph the node to be added.\n @param [in] pDependencies - const pointer to the node dependencies.\n @param [in] numDependencies - Number of dependencies.\n @param [in] event - Event for the node.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7822 pub fn hipGraphAddEventWaitNode(
7823 pGraphNode: *mut hipGraphNode_t,
7824 graph: hipGraph_t,
7825 pDependencies: *const hipGraphNode_t,
7826 numDependencies: usize,
7827 event: hipEvent_t,
7828 ) -> hipError_t;
7829}
7830extern "C" {
7831 #[doc = " @brief Returns the event associated with an event wait node.\n\n @param [in] node - Instance of the node to get event of.\n @param [out] event_out - Pointer to return the event.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7832 pub fn hipGraphEventWaitNodeGetEvent(
7833 node: hipGraphNode_t,
7834 event_out: *mut hipEvent_t,
7835 ) -> hipError_t;
7836}
7837extern "C" {
7838 #[doc = " @brief Sets an event wait node's event.\n\n @param [in] node - Instance of the node to set event of.\n @param [in] event - Pointer to the event.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7839 pub fn hipGraphEventWaitNodeSetEvent(node: hipGraphNode_t, event: hipEvent_t) -> hipError_t;
7840}
7841extern "C" {
7842 #[doc = " @brief Sets the event for an event record node in the given graphExec.\n\n @param [in] hGraphExec - instance of the executable graph with the node.\n @param [in] hNode - node from the graph which was used to instantiate graphExec.\n @param [in] event - pointer to the event.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7843 pub fn hipGraphExecEventWaitNodeSetEvent(
7844 hGraphExec: hipGraphExec_t,
7845 hNode: hipGraphNode_t,
7846 event: hipEvent_t,
7847 ) -> hipError_t;
7848}
7849extern "C" {
7850 #[doc = " @brief Creates a memory allocation node and adds it to a graph\n\n @param [out] pGraphNode - Pointer to the graph node to create and add to the graph\n @param [in] graph - Instance of the graph node to be added\n @param [in] pDependencies - Const pointer to the node dependencies\n @param [in] numDependencies - The number of dependencies\n @param [in, out] pNodeParams - Node parameters for memory allocation, returns a pointer to the allocated memory.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7851 pub fn hipGraphAddMemAllocNode(
7852 pGraphNode: *mut hipGraphNode_t,
7853 graph: hipGraph_t,
7854 pDependencies: *const hipGraphNode_t,
7855 numDependencies: usize,
7856 pNodeParams: *mut hipMemAllocNodeParams,
7857 ) -> hipError_t;
7858}
7859extern "C" {
7860 #[doc = " @brief Returns parameters for memory allocation node\n\n @param [in] node - Memory allocation node to query\n @param [out] pNodeParams - Parameters for the specified memory allocation node\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7861 pub fn hipGraphMemAllocNodeGetParams(
7862 node: hipGraphNode_t,
7863 pNodeParams: *mut hipMemAllocNodeParams,
7864 ) -> hipError_t;
7865}
7866extern "C" {
7867 #[doc = " @brief Creates a memory free node and adds it to a graph\n\n @param [out] pGraphNode - Pointer to the graph node to create and add to the graph\n @param [in] graph - Instance of the graph node to be added\n @param [in] pDependencies - Const pointer to the node dependencies\n @param [in] numDependencies - The number of dependencies\n @param [in] dev_ptr - Pointer to the memory to be freed\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7868 pub fn hipGraphAddMemFreeNode(
7869 pGraphNode: *mut hipGraphNode_t,
7870 graph: hipGraph_t,
7871 pDependencies: *const hipGraphNode_t,
7872 numDependencies: usize,
7873 dev_ptr: *mut ::std::os::raw::c_void,
7874 ) -> hipError_t;
7875}
7876extern "C" {
7877 #[doc = " @brief Returns parameters for memory free node\n\n @param [in] node - Memory free node to query\n @param [out] dev_ptr - Device pointer of the specified memory free node\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7878 pub fn hipGraphMemFreeNodeGetParams(
7879 node: hipGraphNode_t,
7880 dev_ptr: *mut ::std::os::raw::c_void,
7881 ) -> hipError_t;
7882}
7883extern "C" {
7884 #[doc = " @brief Get the mem attribute for graphs.\n\n @param [in] device - Device to get attributes from\n @param [in] attr - Attribute type to be queried\n @param [out] value - Value of the queried attribute\n @returns #hipSuccess, #hipErrorInvalidDevice\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7885 pub fn hipDeviceGetGraphMemAttribute(
7886 device: ::std::os::raw::c_int,
7887 attr: hipGraphMemAttributeType,
7888 value: *mut ::std::os::raw::c_void,
7889 ) -> hipError_t;
7890}
7891extern "C" {
7892 #[doc = " @brief Set the mem attribute for graphs.\n\n @param [in] device - Device to set attribute of.\n @param [in] attr - Attribute type to be set.\n @param [in] value - Value of the attribute.\n @returns #hipSuccess, #hipErrorInvalidDevice\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7893 pub fn hipDeviceSetGraphMemAttribute(
7894 device: ::std::os::raw::c_int,
7895 attr: hipGraphMemAttributeType,
7896 value: *mut ::std::os::raw::c_void,
7897 ) -> hipError_t;
7898}
7899extern "C" {
7900 #[doc = " @brief Free unused memory reserved for graphs on a specific device and return it back to the OS.\n\n @param [in] device - Device for which memory should be trimmed\n @returns #hipSuccess, #hipErrorInvalidDevice\n\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7901 pub fn hipDeviceGraphMemTrim(device: ::std::os::raw::c_int) -> hipError_t;
7902}
7903extern "C" {
7904 #[doc = " @brief Create an instance of userObject to manage lifetime of a resource.\n\n @param [out] object_out - pointer to instace of userobj.\n @param [in] ptr - pointer to pass to destroy function.\n @param [in] destroy - destroy callback to remove resource.\n @param [in] initialRefcount - reference to resource.\n @param [in] flags - flags passed to API.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7905 pub fn hipUserObjectCreate(
7906 object_out: *mut hipUserObject_t,
7907 ptr: *mut ::std::os::raw::c_void,
7908 destroy: hipHostFn_t,
7909 initialRefcount: ::std::os::raw::c_uint,
7910 flags: ::std::os::raw::c_uint,
7911 ) -> hipError_t;
7912}
7913extern "C" {
7914 #[doc = " @brief Release number of references to resource.\n\n @param [in] object - pointer to instace of userobj.\n @param [in] count - reference to resource to be retained.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7915 pub fn hipUserObjectRelease(
7916 object: hipUserObject_t,
7917 count: ::std::os::raw::c_uint,
7918 ) -> hipError_t;
7919}
7920extern "C" {
7921 #[doc = " @brief Retain number of references to resource.\n\n @param [in] object - pointer to instace of userobj.\n @param [in] count - reference to resource to be retained.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7922 pub fn hipUserObjectRetain(
7923 object: hipUserObject_t,
7924 count: ::std::os::raw::c_uint,
7925 ) -> hipError_t;
7926}
7927extern "C" {
7928 #[doc = " @brief Retain user object for graphs.\n\n @param [in] graph - pointer to graph to retain the user object for.\n @param [in] object - pointer to instace of userobj.\n @param [in] count - reference to resource to be retained.\n @param [in] flags - flags passed to API.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7929 pub fn hipGraphRetainUserObject(
7930 graph: hipGraph_t,
7931 object: hipUserObject_t,
7932 count: ::std::os::raw::c_uint,
7933 flags: ::std::os::raw::c_uint,
7934 ) -> hipError_t;
7935}
7936extern "C" {
7937 #[doc = " @brief Release user object from graphs.\n\n @param [in] graph - pointer to graph to retain the user object for.\n @param [in] object - pointer to instace of userobj.\n @param [in] count - reference to resource to be retained.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7938 pub fn hipGraphReleaseUserObject(
7939 graph: hipGraph_t,
7940 object: hipUserObject_t,
7941 count: ::std::os::raw::c_uint,
7942 ) -> hipError_t;
7943}
7944extern "C" {
7945 #[doc = " @brief Write a DOT file describing graph structure.\n\n @param [in] graph - graph object for which DOT file has to be generated.\n @param [in] path - path to write the DOT file.\n @param [in] flags - Flags from hipGraphDebugDotFlags to get additional node information.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorOperatingSystem\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7946 pub fn hipGraphDebugDotPrint(
7947 graph: hipGraph_t,
7948 path: *const ::std::os::raw::c_char,
7949 flags: ::std::os::raw::c_uint,
7950 ) -> hipError_t;
7951}
7952extern "C" {
7953 #[doc = " @brief Copies attributes from source node to destination node.\n\n Copies attributes from source node to destination node.\n Both node must have the same context.\n\n @param [out] hDst - Destination node.\n @param [in] hSrc - Source node.\n For list of attributes see ::hipKernelNodeAttrID.\n\n @returns #hipSuccess, #hipErrorInvalidContext\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7954 pub fn hipGraphKernelNodeCopyAttributes(
7955 hSrc: hipGraphNode_t,
7956 hDst: hipGraphNode_t,
7957 ) -> hipError_t;
7958}
7959extern "C" {
7960 #[doc = " @brief Enables or disables the specified node in the given graphExec\n\n Sets hNode to be either enabled or disabled. Disabled nodes are functionally equivalent\n to empty nodes until they are reenabled. Existing node parameters are not affected by\n disabling/enabling the node.\n\n The node is identified by the corresponding hNode in the non-executable graph, from which the\n executable graph was instantiated.\n\n hNode must not have been removed from the original graph.\n\n @note Currently only kernel, memset and memcpy nodes are supported.\n\n @param [in] hGraphExec - The executable graph in which to set the specified node.\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [in] isEnabled - Node is enabled if != 0, otherwise the node is disabled.\n\n @returns #hipSuccess, #hipErrorInvalidValue,\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7961 pub fn hipGraphNodeSetEnabled(
7962 hGraphExec: hipGraphExec_t,
7963 hNode: hipGraphNode_t,
7964 isEnabled: ::std::os::raw::c_uint,
7965 ) -> hipError_t;
7966}
7967extern "C" {
7968 #[doc = " @brief Query whether a node in the given graphExec is enabled\n\n Sets isEnabled to 1 if hNode is enabled, or 0 if it is disabled.\n\n The node is identified by the corresponding node in the non-executable graph, from which the\n executable graph was instantiated.\n\n hNode must not have been removed from the original graph.\n\n @note Currently only kernel, memset and memcpy nodes are supported.\n\n @param [in] hGraphExec - The executable graph in which to set the specified node.\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [out] isEnabled - Location to return the enabled status of the node.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7969 pub fn hipGraphNodeGetEnabled(
7970 hGraphExec: hipGraphExec_t,
7971 hNode: hipGraphNode_t,
7972 isEnabled: *mut ::std::os::raw::c_uint,
7973 ) -> hipError_t;
7974}
7975extern "C" {
7976 #[doc = " @brief Creates a external semaphor wait node and adds it to a graph.\n\n @param [out] pGraphNode - pointer to the graph node to create.\n @param [in] graph - instance of the graph to add the created node.\n @param [in] pDependencies - const pointer to the dependencies on the memset execution node.\n @param [in] numDependencies - the number of the dependencies.\n @param [in] nodeParams -pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7977 pub fn hipGraphAddExternalSemaphoresWaitNode(
7978 pGraphNode: *mut hipGraphNode_t,
7979 graph: hipGraph_t,
7980 pDependencies: *const hipGraphNode_t,
7981 numDependencies: usize,
7982 nodeParams: *const hipExternalSemaphoreWaitNodeParams,
7983 ) -> hipError_t;
7984}
7985extern "C" {
7986 #[doc = " @brief Creates a external semaphor signal node and adds it to a graph.\n\n @param [out] pGraphNode - pointer to the graph node to create.\n @param [in] graph - instance of the graph to add the created node.\n @param [in] pDependencies - const pointer to the dependencies on the memset execution node.\n @param [in] numDependencies - the number of the dependencies.\n @param [in] nodeParams -pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7987 pub fn hipGraphAddExternalSemaphoresSignalNode(
7988 pGraphNode: *mut hipGraphNode_t,
7989 graph: hipGraph_t,
7990 pDependencies: *const hipGraphNode_t,
7991 numDependencies: usize,
7992 nodeParams: *const hipExternalSemaphoreSignalNodeParams,
7993 ) -> hipError_t;
7994}
7995extern "C" {
7996 #[doc = " @brief Updates node parameters in the external semaphore signal node.\n\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [in] nodeParams - Pointer to the params to be set.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
7997 pub fn hipGraphExternalSemaphoresSignalNodeSetParams(
7998 hNode: hipGraphNode_t,
7999 nodeParams: *const hipExternalSemaphoreSignalNodeParams,
8000 ) -> hipError_t;
8001}
8002extern "C" {
8003 #[doc = " @brief Updates node parameters in the external semaphore wait node.\n\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [in] nodeParams - Pointer to the params to be set.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8004 pub fn hipGraphExternalSemaphoresWaitNodeSetParams(
8005 hNode: hipGraphNode_t,
8006 nodeParams: *const hipExternalSemaphoreWaitNodeParams,
8007 ) -> hipError_t;
8008}
8009extern "C" {
8010 #[doc = " @brief Returns external semaphore signal node params.\n\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [out] params_out - Pointer to params.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8011 pub fn hipGraphExternalSemaphoresSignalNodeGetParams(
8012 hNode: hipGraphNode_t,
8013 params_out: *mut hipExternalSemaphoreSignalNodeParams,
8014 ) -> hipError_t;
8015}
8016extern "C" {
8017 #[doc = " @brief Returns external semaphore wait node params.\n\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [out] params_out - Pointer to params.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8018 pub fn hipGraphExternalSemaphoresWaitNodeGetParams(
8019 hNode: hipGraphNode_t,
8020 params_out: *mut hipExternalSemaphoreWaitNodeParams,
8021 ) -> hipError_t;
8022}
8023extern "C" {
8024 #[doc = " @brief Updates node parameters in the external semaphore signal node in the given graphExec.\n\n @param [in] hGraphExec - The executable graph in which to set the specified node.\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [in] nodeParams - Pointer to the params to be set.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8025 pub fn hipGraphExecExternalSemaphoresSignalNodeSetParams(
8026 hGraphExec: hipGraphExec_t,
8027 hNode: hipGraphNode_t,
8028 nodeParams: *const hipExternalSemaphoreSignalNodeParams,
8029 ) -> hipError_t;
8030}
8031extern "C" {
8032 #[doc = " @brief Updates node parameters in the external semaphore wait node in the given graphExec.\n\n @param [in] hGraphExec - The executable graph in which to set the specified node.\n @param [in] hNode - Node from the graph from which graphExec was instantiated.\n @param [in] nodeParams - Pointer to the params to be set.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8033 pub fn hipGraphExecExternalSemaphoresWaitNodeSetParams(
8034 hGraphExec: hipGraphExec_t,
8035 hNode: hipGraphNode_t,
8036 nodeParams: *const hipExternalSemaphoreWaitNodeParams,
8037 ) -> hipError_t;
8038}
8039extern "C" {
8040 #[doc = " @brief Gets a memcpy node's parameters.\n\n @param [in] hNode - instance of the node to get parameters from.\n @param [out] nodeParams - pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8041 pub fn hipDrvGraphMemcpyNodeGetParams(
8042 hNode: hipGraphNode_t,
8043 nodeParams: *mut HIP_MEMCPY3D,
8044 ) -> hipError_t;
8045}
8046extern "C" {
8047 #[doc = " @brief Sets a memcpy node's parameters.\n\n @param [in] hNode - instance of the node to Set parameters for.\n @param [out] nodeParams - pointer to the parameters.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8048 pub fn hipDrvGraphMemcpyNodeSetParams(
8049 hNode: hipGraphNode_t,
8050 nodeParams: *const HIP_MEMCPY3D,
8051 ) -> hipError_t;
8052}
8053extern "C" {
8054 #[doc = " @brief Creates a memset node and adds it to a graph.\n\n @param [out] phGraphNode - pointer to graph node to create.\n @param [in] hGraph - instance of graph to add the created node to.\n @param [in] dependencies - const pointer to the dependencies on the memset execution node.\n @param [in] numDependencies - number of the dependencies.\n @param [in] memsetParams - const pointer to the parameters for the memory set.\n @param [in] ctx - cotext related to current device.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8055 pub fn hipDrvGraphAddMemsetNode(
8056 phGraphNode: *mut hipGraphNode_t,
8057 hGraph: hipGraph_t,
8058 dependencies: *const hipGraphNode_t,
8059 numDependencies: usize,
8060 memsetParams: *const HIP_MEMSET_NODE_PARAMS,
8061 ctx: hipCtx_t,
8062 ) -> hipError_t;
8063}
8064extern "C" {
8065 #[doc = " @brief Creates a memory free node and adds it to a graph\n\n @param [out] phGraphNode - Pointer to the graph node to create and add to the graph\n @param [in] hGraph - Instance of the graph the node to be added\n @param [in] dependencies - Const pointer to the node dependencies\n @param [in] numDependencies - The number of dependencies\n @param [in] dptr - Pointer to the memory to be freed\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8066 pub fn hipDrvGraphAddMemFreeNode(
8067 phGraphNode: *mut hipGraphNode_t,
8068 hGraph: hipGraph_t,
8069 dependencies: *const hipGraphNode_t,
8070 numDependencies: usize,
8071 dptr: hipDeviceptr_t,
8072 ) -> hipError_t;
8073}
8074extern "C" {
8075 #[doc = " @brief Sets the parameters for a memcpy node in the given graphExec.\n\n @param [in] hGraphExec - instance of the executable graph with the node.\n @param [in] hNode - instance of the node to set parameters to.\n @param [in] copyParams - const pointer to the memcpy node params.\n @param [in] ctx - cotext related to current device.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8076 pub fn hipDrvGraphExecMemcpyNodeSetParams(
8077 hGraphExec: hipGraphExec_t,
8078 hNode: hipGraphNode_t,
8079 copyParams: *const HIP_MEMCPY3D,
8080 ctx: hipCtx_t,
8081 ) -> hipError_t;
8082}
8083extern "C" {
8084 #[doc = " @brief Sets the parameters for a memset node in the given graphExec.\n\n @param [in] hGraphExec - instance of the executable graph with the node.\n @param [in] hNode - instance of the node to set parameters to.\n @param [in] memsetParams - pointer to the parameters.\n @param [in] ctx - cotext related to current device.\n @returns #hipSuccess, #hipErrorInvalidValue\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues."]
8085 pub fn hipDrvGraphExecMemsetNodeSetParams(
8086 hGraphExec: hipGraphExec_t,
8087 hNode: hipGraphNode_t,
8088 memsetParams: *const HIP_MEMSET_NODE_PARAMS,
8089 ctx: hipCtx_t,
8090 ) -> hipError_t;
8091}
8092extern "C" {
8093 #[doc = " @brief Frees an address range reservation made via hipMemAddressReserve\n\n @param [in] devPtr - starting address of the range.\n @param [in] size - size of the range.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8094 pub fn hipMemAddressFree(devPtr: *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
8095}
8096extern "C" {
8097 #[doc = " @brief Reserves an address range\n\n @param [out] ptr - starting address of the reserved range.\n @param [in] size - size of the reservation.\n @param [in] alignment - alignment of the address.\n @param [in] addr - requested starting address of the range.\n @param [in] flags - currently unused, must be zero.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8098 pub fn hipMemAddressReserve(
8099 ptr: *mut *mut ::std::os::raw::c_void,
8100 size: usize,
8101 alignment: usize,
8102 addr: *mut ::std::os::raw::c_void,
8103 flags: ::std::os::raw::c_ulonglong,
8104 ) -> hipError_t;
8105}
8106extern "C" {
8107 #[doc = " @brief Creates a memory allocation described by the properties and size\n\n @param [out] handle - value of the returned handle.\n @param [in] size - size of the allocation.\n @param [in] prop - properties of the allocation.\n @param [in] flags - currently unused, must be zero.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8108 pub fn hipMemCreate(
8109 handle: *mut hipMemGenericAllocationHandle_t,
8110 size: usize,
8111 prop: *const hipMemAllocationProp,
8112 flags: ::std::os::raw::c_ulonglong,
8113 ) -> hipError_t;
8114}
8115extern "C" {
8116 #[doc = " @brief Exports an allocation to a requested shareable handle type.\n\n @param [out] shareableHandle - value of the returned handle.\n @param [in] handle - handle to share.\n @param [in] handleType - type of the shareable handle.\n @param [in] flags - currently unused, must be zero.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8117 pub fn hipMemExportToShareableHandle(
8118 shareableHandle: *mut ::std::os::raw::c_void,
8119 handle: hipMemGenericAllocationHandle_t,
8120 handleType: hipMemAllocationHandleType,
8121 flags: ::std::os::raw::c_ulonglong,
8122 ) -> hipError_t;
8123}
8124extern "C" {
8125 #[doc = " @brief Get the access flags set for the given location and ptr.\n\n @param [out] flags - flags for this location.\n @param [in] location - target location.\n @param [in] ptr - address to check the access flags.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8126 pub fn hipMemGetAccess(
8127 flags: *mut ::std::os::raw::c_ulonglong,
8128 location: *const hipMemLocation,
8129 ptr: *mut ::std::os::raw::c_void,
8130 ) -> hipError_t;
8131}
8132extern "C" {
8133 #[doc = " @brief Calculates either the minimal or recommended granularity.\n\n @param [out] granularity - returned granularity.\n @param [in] prop - location properties.\n @param [in] option - determines which granularity to return.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows.\n"]
8134 pub fn hipMemGetAllocationGranularity(
8135 granularity: *mut usize,
8136 prop: *const hipMemAllocationProp,
8137 option: hipMemAllocationGranularity_flags,
8138 ) -> hipError_t;
8139}
8140extern "C" {
8141 #[doc = " @brief Retrieve the property structure of the given handle.\n\n @param [out] prop - properties of the given handle.\n @param [in] handle - handle to perform the query on.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8142 pub fn hipMemGetAllocationPropertiesFromHandle(
8143 prop: *mut hipMemAllocationProp,
8144 handle: hipMemGenericAllocationHandle_t,
8145 ) -> hipError_t;
8146}
8147extern "C" {
8148 #[doc = " @brief Imports an allocation from a requested shareable handle type.\n\n @param [out] handle - returned value.\n @param [in] osHandle - shareable handle representing the memory allocation.\n @param [in] shHandleType - handle type.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8149 pub fn hipMemImportFromShareableHandle(
8150 handle: *mut hipMemGenericAllocationHandle_t,
8151 osHandle: *mut ::std::os::raw::c_void,
8152 shHandleType: hipMemAllocationHandleType,
8153 ) -> hipError_t;
8154}
8155extern "C" {
8156 #[doc = " @brief Maps an allocation handle to a reserved virtual address range.\n\n @param [in] ptr - address where the memory will be mapped.\n @param [in] size - size of the mapping.\n @param [in] offset - offset into the memory, currently must be zero.\n @param [in] handle - memory allocation to be mapped.\n @param [in] flags - currently unused, must be zero.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8157 pub fn hipMemMap(
8158 ptr: *mut ::std::os::raw::c_void,
8159 size: usize,
8160 offset: usize,
8161 handle: hipMemGenericAllocationHandle_t,
8162 flags: ::std::os::raw::c_ulonglong,
8163 ) -> hipError_t;
8164}
8165extern "C" {
8166 #[doc = " @brief Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.\n\n @param [in] mapInfoList - list of hipArrayMapInfo.\n @param [in] count - number of hipArrayMapInfo in mapInfoList.\n @param [in] stream - stream identifier for the stream to use for map or unmap operations.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is under development. Currently it is not supported on AMD\n GPUs and returns #hipErrorNotSupported."]
8167 pub fn hipMemMapArrayAsync(
8168 mapInfoList: *mut hipArrayMapInfo,
8169 count: ::std::os::raw::c_uint,
8170 stream: hipStream_t,
8171 ) -> hipError_t;
8172}
8173extern "C" {
8174 #[doc = " @brief Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.\n\n @param [in] handle - handle of the memory allocation.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8175 pub fn hipMemRelease(handle: hipMemGenericAllocationHandle_t) -> hipError_t;
8176}
8177extern "C" {
8178 #[doc = " @brief Returns the allocation handle of the backing memory allocation given the address.\n\n @param [out] handle - handle representing addr.\n @param [in] addr - address to look up.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8179 pub fn hipMemRetainAllocationHandle(
8180 handle: *mut hipMemGenericAllocationHandle_t,
8181 addr: *mut ::std::os::raw::c_void,
8182 ) -> hipError_t;
8183}
8184extern "C" {
8185 #[doc = " @brief Set the access flags for each location specified in desc for the given virtual address range.\n\n @param [in] ptr - starting address of the virtual address range.\n @param [in] size - size of the range.\n @param [in] desc - array of hipMemAccessDesc.\n @param [in] count - number of hipMemAccessDesc in desc.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8186 pub fn hipMemSetAccess(
8187 ptr: *mut ::std::os::raw::c_void,
8188 size: usize,
8189 desc: *const hipMemAccessDesc,
8190 count: usize,
8191 ) -> hipError_t;
8192}
8193extern "C" {
8194 #[doc = " @brief Unmap memory allocation of a given address range.\n\n @param [in] ptr - starting address of the range to unmap.\n @param [in] size - size of the virtual address range.\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotSupported\n @warning This API is marked as Beta. While this feature is complete, it can\n change and might have outstanding issues.\n\n @note This API is implemented on Linux and is under development on Microsoft Windows."]
8195 pub fn hipMemUnmap(ptr: *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
8196}
8197extern "C" {
8198 #[doc = " @brief Maps a graphics resource for access.\n\n @param [in] count - Number of resources to map.\n @param [in] resources - Pointer of resources to map.\n @param [in] stream - Stream for synchronization.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorUnknown, #hipErrorInvalidResourceHandle\n"]
8199 pub fn hipGraphicsMapResources(
8200 count: ::std::os::raw::c_int,
8201 resources: *mut hipGraphicsResource_t,
8202 stream: hipStream_t,
8203 ) -> hipError_t;
8204}
8205extern "C" {
8206 #[doc = " @brief Get an array through which to access a subresource of a mapped graphics resource.\n\n @param [out] array - Pointer of array through which a subresource of resource may be accessed.\n @param [in] resource - Mapped resource to access.\n @param [in] arrayIndex - Array index for the subresource to access.\n @param [in] mipLevel - Mipmap level for the subresource to access.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n\n @note In this API, the value of arrayIndex higher than zero is currently not supported.\n"]
8207 pub fn hipGraphicsSubResourceGetMappedArray(
8208 array: *mut hipArray_t,
8209 resource: hipGraphicsResource_t,
8210 arrayIndex: ::std::os::raw::c_uint,
8211 mipLevel: ::std::os::raw::c_uint,
8212 ) -> hipError_t;
8213}
8214extern "C" {
8215 #[doc = " @brief Gets device accessible address of a graphics resource.\n\n @param [out] devPtr - Pointer of device through which graphic resource may be accessed.\n @param [out] size - Size of the buffer accessible from devPtr.\n @param [in] resource - Mapped resource to access.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
8216 pub fn hipGraphicsResourceGetMappedPointer(
8217 devPtr: *mut *mut ::std::os::raw::c_void,
8218 size: *mut usize,
8219 resource: hipGraphicsResource_t,
8220 ) -> hipError_t;
8221}
8222extern "C" {
8223 #[doc = " @brief Unmaps graphics resources.\n\n @param [in] count - Number of resources to unmap.\n @param [in] resources - Pointer of resources to unmap.\n @param [in] stream - Stream for synchronization.\n\n @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorUnknown, #hipErrorContextIsDestroyed\n"]
8224 pub fn hipGraphicsUnmapResources(
8225 count: ::std::os::raw::c_int,
8226 resources: *mut hipGraphicsResource_t,
8227 stream: hipStream_t,
8228 ) -> hipError_t;
8229}
8230extern "C" {
8231 #[doc = " @brief Unregisters a graphics resource.\n\n @param [in] resource - Graphics resources to unregister.\n\n @returns #hipSuccess\n"]
8232 pub fn hipGraphicsUnregisterResource(resource: hipGraphicsResource_t) -> hipError_t;
8233}
8234extern "C" {
8235 #[doc = " @brief Create a surface object.\n\n @param [out] pSurfObject Pointer of surface object to be created.\n @param [in] pResDesc Pointer of suface object descriptor.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
8236 pub fn hipCreateSurfaceObject(
8237 pSurfObject: *mut hipSurfaceObject_t,
8238 pResDesc: *const hipResourceDesc,
8239 ) -> hipError_t;
8240}
8241extern "C" {
8242 #[doc = " @brief Destroy a surface object.\n\n @param [in] surfaceObject Surface object to be destroyed.\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
8243 pub fn hipDestroySurfaceObject(surfaceObject: hipSurfaceObject_t) -> hipError_t;
8244}
8245extern "C" {
8246 pub fn hipMemcpy_spt(
8247 dst: *mut ::std::os::raw::c_void,
8248 src: *const ::std::os::raw::c_void,
8249 sizeBytes: usize,
8250 kind: hipMemcpyKind,
8251 ) -> hipError_t;
8252}
8253extern "C" {
8254 pub fn hipMemcpyToSymbol_spt(
8255 symbol: *const ::std::os::raw::c_void,
8256 src: *const ::std::os::raw::c_void,
8257 sizeBytes: usize,
8258 offset: usize,
8259 kind: hipMemcpyKind,
8260 ) -> hipError_t;
8261}
8262extern "C" {
8263 pub fn hipMemcpyFromSymbol_spt(
8264 dst: *mut ::std::os::raw::c_void,
8265 symbol: *const ::std::os::raw::c_void,
8266 sizeBytes: usize,
8267 offset: usize,
8268 kind: hipMemcpyKind,
8269 ) -> hipError_t;
8270}
8271extern "C" {
8272 pub fn hipMemcpy2D_spt(
8273 dst: *mut ::std::os::raw::c_void,
8274 dpitch: usize,
8275 src: *const ::std::os::raw::c_void,
8276 spitch: usize,
8277 width: usize,
8278 height: usize,
8279 kind: hipMemcpyKind,
8280 ) -> hipError_t;
8281}
8282extern "C" {
8283 pub fn hipMemcpy2DFromArray_spt(
8284 dst: *mut ::std::os::raw::c_void,
8285 dpitch: usize,
8286 src: hipArray_const_t,
8287 wOffset: usize,
8288 hOffset: usize,
8289 width: usize,
8290 height: usize,
8291 kind: hipMemcpyKind,
8292 ) -> hipError_t;
8293}
8294extern "C" {
8295 pub fn hipMemcpy3D_spt(p: *const hipMemcpy3DParms) -> hipError_t;
8296}
8297extern "C" {
8298 pub fn hipMemset_spt(
8299 dst: *mut ::std::os::raw::c_void,
8300 value: ::std::os::raw::c_int,
8301 sizeBytes: usize,
8302 ) -> hipError_t;
8303}
8304extern "C" {
8305 pub fn hipMemsetAsync_spt(
8306 dst: *mut ::std::os::raw::c_void,
8307 value: ::std::os::raw::c_int,
8308 sizeBytes: usize,
8309 stream: hipStream_t,
8310 ) -> hipError_t;
8311}
8312extern "C" {
8313 pub fn hipMemset2D_spt(
8314 dst: *mut ::std::os::raw::c_void,
8315 pitch: usize,
8316 value: ::std::os::raw::c_int,
8317 width: usize,
8318 height: usize,
8319 ) -> hipError_t;
8320}
8321extern "C" {
8322 pub fn hipMemset2DAsync_spt(
8323 dst: *mut ::std::os::raw::c_void,
8324 pitch: usize,
8325 value: ::std::os::raw::c_int,
8326 width: usize,
8327 height: usize,
8328 stream: hipStream_t,
8329 ) -> hipError_t;
8330}
8331extern "C" {
8332 pub fn hipMemset3DAsync_spt(
8333 pitchedDevPtr: hipPitchedPtr,
8334 value: ::std::os::raw::c_int,
8335 extent: hipExtent,
8336 stream: hipStream_t,
8337 ) -> hipError_t;
8338}
8339extern "C" {
8340 pub fn hipMemset3D_spt(
8341 pitchedDevPtr: hipPitchedPtr,
8342 value: ::std::os::raw::c_int,
8343 extent: hipExtent,
8344 ) -> hipError_t;
8345}
8346extern "C" {
8347 pub fn hipMemcpyAsync_spt(
8348 dst: *mut ::std::os::raw::c_void,
8349 src: *const ::std::os::raw::c_void,
8350 sizeBytes: usize,
8351 kind: hipMemcpyKind,
8352 stream: hipStream_t,
8353 ) -> hipError_t;
8354}
8355extern "C" {
8356 pub fn hipMemcpy3DAsync_spt(p: *const hipMemcpy3DParms, stream: hipStream_t) -> hipError_t;
8357}
8358extern "C" {
8359 pub fn hipMemcpy2DAsync_spt(
8360 dst: *mut ::std::os::raw::c_void,
8361 dpitch: usize,
8362 src: *const ::std::os::raw::c_void,
8363 spitch: usize,
8364 width: usize,
8365 height: usize,
8366 kind: hipMemcpyKind,
8367 stream: hipStream_t,
8368 ) -> hipError_t;
8369}
8370extern "C" {
8371 pub fn hipMemcpyFromSymbolAsync_spt(
8372 dst: *mut ::std::os::raw::c_void,
8373 symbol: *const ::std::os::raw::c_void,
8374 sizeBytes: usize,
8375 offset: usize,
8376 kind: hipMemcpyKind,
8377 stream: hipStream_t,
8378 ) -> hipError_t;
8379}
8380extern "C" {
8381 pub fn hipMemcpyToSymbolAsync_spt(
8382 symbol: *const ::std::os::raw::c_void,
8383 src: *const ::std::os::raw::c_void,
8384 sizeBytes: usize,
8385 offset: usize,
8386 kind: hipMemcpyKind,
8387 stream: hipStream_t,
8388 ) -> hipError_t;
8389}
8390extern "C" {
8391 pub fn hipMemcpyFromArray_spt(
8392 dst: *mut ::std::os::raw::c_void,
8393 src: hipArray_const_t,
8394 wOffsetSrc: usize,
8395 hOffset: usize,
8396 count: usize,
8397 kind: hipMemcpyKind,
8398 ) -> hipError_t;
8399}
8400extern "C" {
8401 pub fn hipMemcpy2DToArray_spt(
8402 dst: hipArray_t,
8403 wOffset: usize,
8404 hOffset: usize,
8405 src: *const ::std::os::raw::c_void,
8406 spitch: usize,
8407 width: usize,
8408 height: usize,
8409 kind: hipMemcpyKind,
8410 ) -> hipError_t;
8411}
8412extern "C" {
8413 pub fn hipMemcpy2DFromArrayAsync_spt(
8414 dst: *mut ::std::os::raw::c_void,
8415 dpitch: usize,
8416 src: hipArray_const_t,
8417 wOffsetSrc: usize,
8418 hOffsetSrc: usize,
8419 width: usize,
8420 height: usize,
8421 kind: hipMemcpyKind,
8422 stream: hipStream_t,
8423 ) -> hipError_t;
8424}
8425extern "C" {
8426 pub fn hipMemcpy2DToArrayAsync_spt(
8427 dst: hipArray_t,
8428 wOffset: usize,
8429 hOffset: usize,
8430 src: *const ::std::os::raw::c_void,
8431 spitch: usize,
8432 width: usize,
8433 height: usize,
8434 kind: hipMemcpyKind,
8435 stream: hipStream_t,
8436 ) -> hipError_t;
8437}
8438extern "C" {
8439 pub fn hipStreamQuery_spt(stream: hipStream_t) -> hipError_t;
8440}
8441extern "C" {
8442 pub fn hipStreamSynchronize_spt(stream: hipStream_t) -> hipError_t;
8443}
8444extern "C" {
8445 pub fn hipStreamGetPriority_spt(
8446 stream: hipStream_t,
8447 priority: *mut ::std::os::raw::c_int,
8448 ) -> hipError_t;
8449}
8450extern "C" {
8451 pub fn hipStreamWaitEvent_spt(
8452 stream: hipStream_t,
8453 event: hipEvent_t,
8454 flags: ::std::os::raw::c_uint,
8455 ) -> hipError_t;
8456}
8457extern "C" {
8458 pub fn hipStreamGetFlags_spt(
8459 stream: hipStream_t,
8460 flags: *mut ::std::os::raw::c_uint,
8461 ) -> hipError_t;
8462}
8463extern "C" {
8464 pub fn hipStreamAddCallback_spt(
8465 stream: hipStream_t,
8466 callback: hipStreamCallback_t,
8467 userData: *mut ::std::os::raw::c_void,
8468 flags: ::std::os::raw::c_uint,
8469 ) -> hipError_t;
8470}
8471extern "C" {
8472 pub fn hipEventRecord_spt(event: hipEvent_t, stream: hipStream_t) -> hipError_t;
8473}
8474extern "C" {
8475 pub fn hipLaunchCooperativeKernel_spt(
8476 f: *const ::std::os::raw::c_void,
8477 gridDim: dim3,
8478 blockDim: dim3,
8479 kernelParams: *mut *mut ::std::os::raw::c_void,
8480 sharedMemBytes: u32,
8481 hStream: hipStream_t,
8482 ) -> hipError_t;
8483}
8484extern "C" {
8485 pub fn hipLaunchKernel_spt(
8486 function_address: *const ::std::os::raw::c_void,
8487 numBlocks: dim3,
8488 dimBlocks: dim3,
8489 args: *mut *mut ::std::os::raw::c_void,
8490 sharedMemBytes: usize,
8491 stream: hipStream_t,
8492 ) -> hipError_t;
8493}
8494extern "C" {
8495 pub fn hipGraphLaunch_spt(graphExec: hipGraphExec_t, stream: hipStream_t) -> hipError_t;
8496}
8497extern "C" {
8498 pub fn hipStreamBeginCapture_spt(stream: hipStream_t, mode: hipStreamCaptureMode)
8499 -> hipError_t;
8500}
8501extern "C" {
8502 pub fn hipStreamEndCapture_spt(stream: hipStream_t, pGraph: *mut hipGraph_t) -> hipError_t;
8503}
8504extern "C" {
8505 pub fn hipStreamIsCapturing_spt(
8506 stream: hipStream_t,
8507 pCaptureStatus: *mut hipStreamCaptureStatus,
8508 ) -> hipError_t;
8509}
8510extern "C" {
8511 pub fn hipStreamGetCaptureInfo_spt(
8512 stream: hipStream_t,
8513 pCaptureStatus: *mut hipStreamCaptureStatus,
8514 pId: *mut ::std::os::raw::c_ulonglong,
8515 ) -> hipError_t;
8516}
8517extern "C" {
8518 pub fn hipStreamGetCaptureInfo_v2_spt(
8519 stream: hipStream_t,
8520 captureStatus_out: *mut hipStreamCaptureStatus,
8521 id_out: *mut ::std::os::raw::c_ulonglong,
8522 graph_out: *mut hipGraph_t,
8523 dependencies_out: *mut *const hipGraphNode_t,
8524 numDependencies_out: *mut usize,
8525 ) -> hipError_t;
8526}
8527extern "C" {
8528 pub fn hipLaunchHostFunc_spt(
8529 stream: hipStream_t,
8530 fn_: hipHostFn_t,
8531 userData: *mut ::std::os::raw::c_void,
8532 ) -> hipError_t;
8533}
8534#[repr(C)]
8535#[derive(Debug, Copy, Clone)]
8536pub struct __locale_data {
8537 pub _address: u8,
8538}