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}
83#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
84#[repr(C)]
85pub struct __BindgenComplex<T> {
86 pub re: T,
87 pub im: T,
88}
89pub const __HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__: u32 = 0;
90pub const __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__: u32 = 0;
91pub const __HIP_ARCH_HAS_SHARED_INT32_ATOMICS__: u32 = 0;
92pub const __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__: u32 = 0;
93pub const __HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__: u32 = 0;
94pub const __HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__: u32 = 0;
95pub const __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__: u32 = 0;
96pub const __HIP_ARCH_HAS_DOUBLES__: u32 = 0;
97pub const __HIP_ARCH_HAS_WARP_VOTE__: u32 = 0;
98pub const __HIP_ARCH_HAS_WARP_BALLOT__: u32 = 0;
99pub const __HIP_ARCH_HAS_WARP_SHUFFLE__: u32 = 0;
100pub const __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__: u32 = 0;
101pub const __HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__: u32 = 0;
102pub const __HIP_ARCH_HAS_SYNC_THREAD_EXT__: u32 = 0;
103pub const __HIP_ARCH_HAS_SURFACE_FUNCS__: u32 = 0;
104pub const __HIP_ARCH_HAS_3DGRID__: u32 = 0;
105pub const __HIP_ARCH_HAS_DYNAMIC_PARALLEL__: u32 = 0;
106pub const _FEATURES_H: u32 = 1;
107pub const _DEFAULT_SOURCE: u32 = 1;
108pub const __GLIBC_USE_ISOC2Y: u32 = 0;
109pub const __GLIBC_USE_ISOC23: u32 = 0;
110pub const __USE_ISOC11: u32 = 1;
111pub const __USE_ISOC99: u32 = 1;
112pub const __USE_ISOC95: u32 = 1;
113pub const __USE_POSIX_IMPLICITLY: u32 = 1;
114pub const _POSIX_SOURCE: u32 = 1;
115pub const _POSIX_C_SOURCE: u32 = 200809;
116pub const __USE_POSIX: u32 = 1;
117pub const __USE_POSIX2: u32 = 1;
118pub const __USE_POSIX199309: u32 = 1;
119pub const __USE_POSIX199506: u32 = 1;
120pub const __USE_XOPEN2K: u32 = 1;
121pub const __USE_XOPEN2K8: u32 = 1;
122pub const _ATFILE_SOURCE: u32 = 1;
123pub const __WORDSIZE: u32 = 64;
124pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
125pub const __SYSCALL_WORDSIZE: u32 = 64;
126pub const __TIMESIZE: u32 = 64;
127pub const __USE_TIME_BITS64: u32 = 1;
128pub const __USE_MISC: u32 = 1;
129pub const __USE_ATFILE: u32 = 1;
130pub const __USE_FORTIFY_LEVEL: u32 = 0;
131pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
132pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
133pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
134pub const _STDC_PREDEF_H: u32 = 1;
135pub const __STDC_IEC_559__: u32 = 1;
136pub const __STDC_IEC_60559_BFP__: u32 = 201404;
137pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
138pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
139pub const __STDC_ISO_10646__: u32 = 201706;
140pub const __GNU_LIBRARY__: u32 = 6;
141pub const __GLIBC__: u32 = 2;
142pub const __GLIBC_MINOR__: u32 = 41;
143pub const _SYS_CDEFS_H: u32 = 1;
144pub const __glibc_c99_flexarr_available: u32 = 1;
145pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
146pub const __HAVE_GENERIC_SELECTION: u32 = 1;
147pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
148pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
149pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 0;
150pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
151pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
152pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 0;
153pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
154pub const _STDLIB_H: u32 = 1;
155pub const WNOHANG: u32 = 1;
156pub const WUNTRACED: u32 = 2;
157pub const WSTOPPED: u32 = 2;
158pub const WEXITED: u32 = 4;
159pub const WCONTINUED: u32 = 8;
160pub const WNOWAIT: u32 = 16777216;
161pub const __WNOTHREAD: u32 = 536870912;
162pub const __WALL: u32 = 1073741824;
163pub const __WCLONE: u32 = 2147483648;
164pub const __W_CONTINUED: u32 = 65535;
165pub const __WCOREFLAG: u32 = 128;
166pub const __HAVE_FLOAT128: u32 = 1;
167pub const __HAVE_DISTINCT_FLOAT128: u32 = 1;
168pub const __HAVE_FLOAT64X: u32 = 1;
169pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
170pub const __HAVE_FLOAT16: u32 = 0;
171pub const __HAVE_FLOAT32: u32 = 1;
172pub const __HAVE_FLOAT64: u32 = 1;
173pub const __HAVE_FLOAT32X: u32 = 1;
174pub const __HAVE_FLOAT128X: u32 = 0;
175pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
176pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
177pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
178pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
179pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
180pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
181pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
182pub const __ldiv_t_defined: u32 = 1;
183pub const __lldiv_t_defined: u32 = 1;
184pub const RAND_MAX: u32 = 2147483647;
185pub const EXIT_FAILURE: u32 = 1;
186pub const EXIT_SUCCESS: u32 = 0;
187pub const _SYS_TYPES_H: u32 = 1;
188pub const _BITS_TYPES_H: u32 = 1;
189pub const _BITS_TYPESIZES_H: u32 = 1;
190pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
191pub const __INO_T_MATCHES_INO64_T: u32 = 1;
192pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
193pub const __STATFS_MATCHES_STATFS64: u32 = 1;
194pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
195pub const __FD_SETSIZE: u32 = 1024;
196pub const _BITS_TIME64_H: u32 = 1;
197pub const __clock_t_defined: u32 = 1;
198pub const __clockid_t_defined: u32 = 1;
199pub const __time_t_defined: u32 = 1;
200pub const __timer_t_defined: u32 = 1;
201pub const _BITS_STDINT_INTN_H: u32 = 1;
202pub const __BIT_TYPES_DEFINED__: u32 = 1;
203pub const _ENDIAN_H: u32 = 1;
204pub const _BITS_ENDIAN_H: u32 = 1;
205pub const __LITTLE_ENDIAN: u32 = 1234;
206pub const __BIG_ENDIAN: u32 = 4321;
207pub const __PDP_ENDIAN: u32 = 3412;
208pub const _BITS_ENDIANNESS_H: u32 = 1;
209pub const __BYTE_ORDER: u32 = 1234;
210pub const __FLOAT_WORD_ORDER: u32 = 1234;
211pub const LITTLE_ENDIAN: u32 = 1234;
212pub const BIG_ENDIAN: u32 = 4321;
213pub const PDP_ENDIAN: u32 = 3412;
214pub const BYTE_ORDER: u32 = 1234;
215pub const _BITS_BYTESWAP_H: u32 = 1;
216pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
217pub const _SYS_SELECT_H: u32 = 1;
218pub const __sigset_t_defined: u32 = 1;
219pub const __timeval_defined: u32 = 1;
220pub const _STRUCT_TIMESPEC: u32 = 1;
221pub const FD_SETSIZE: u32 = 1024;
222pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
223pub const _THREAD_SHARED_TYPES_H: u32 = 1;
224pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
225pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
226pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
227pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
228pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
229pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
230pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
231pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
232pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
233pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
234pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
235pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
236pub const __have_pthread_attr_t: u32 = 1;
237pub const _ALLOCA_H: u32 = 1;
238pub const _STRING_H: u32 = 1;
239pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
240pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
241pub const _STRINGS_H: u32 = 1;
242pub const HIP_VERSION_MAJOR: u32 = 6;
243pub const HIP_VERSION_MINOR: u32 = 4;
244pub const HIP_VERSION_PATCH: u32 = 43482;
245pub const HIP_VERSION_GITHASH: &[u8; 10] = b"0f2d60242\0";
246pub const HIP_VERSION_BUILD_ID: u32 = 0;
247pub const HIP_VERSION_BUILD_NAME: &[u8; 1] = b"\0";
248pub const HIP_VERSION: u32 = 60443482;
249pub const __HIP_HAS_GET_PCH: u32 = 1;
250pub const _STDINT_H: u32 = 1;
251pub const _BITS_WCHAR_H: u32 = 1;
252pub const _BITS_STDINT_UINTN_H: u32 = 1;
253pub const _BITS_STDINT_LEAST_H: u32 = 1;
254pub const INT8_MIN: i32 = -128;
255pub const INT16_MIN: i32 = -32768;
256pub const INT32_MIN: i32 = -2147483648;
257pub const INT8_MAX: u32 = 127;
258pub const INT16_MAX: u32 = 32767;
259pub const INT32_MAX: u32 = 2147483647;
260pub const UINT8_MAX: u32 = 255;
261pub const UINT16_MAX: u32 = 65535;
262pub const UINT32_MAX: u32 = 4294967295;
263pub const INT_LEAST8_MIN: i32 = -128;
264pub const INT_LEAST16_MIN: i32 = -32768;
265pub const INT_LEAST32_MIN: i32 = -2147483648;
266pub const INT_LEAST8_MAX: u32 = 127;
267pub const INT_LEAST16_MAX: u32 = 32767;
268pub const INT_LEAST32_MAX: u32 = 2147483647;
269pub const UINT_LEAST8_MAX: u32 = 255;
270pub const UINT_LEAST16_MAX: u32 = 65535;
271pub const UINT_LEAST32_MAX: u32 = 4294967295;
272pub const INT_FAST8_MIN: i32 = -128;
273pub const INT_FAST16_MIN: i64 = -9223372036854775808;
274pub const INT_FAST32_MIN: i64 = -9223372036854775808;
275pub const INT_FAST8_MAX: u32 = 127;
276pub const INT_FAST16_MAX: u64 = 9223372036854775807;
277pub const INT_FAST32_MAX: u64 = 9223372036854775807;
278pub const UINT_FAST8_MAX: u32 = 255;
279pub const UINT_FAST16_MAX: i32 = -1;
280pub const UINT_FAST32_MAX: i32 = -1;
281pub const INTPTR_MIN: i64 = -9223372036854775808;
282pub const INTPTR_MAX: u64 = 9223372036854775807;
283pub const UINTPTR_MAX: i32 = -1;
284pub const PTRDIFF_MIN: i64 = -9223372036854775808;
285pub const PTRDIFF_MAX: u64 = 9223372036854775807;
286pub const SIG_ATOMIC_MIN: i32 = -2147483648;
287pub const SIG_ATOMIC_MAX: u32 = 2147483647;
288pub const SIZE_MAX: i32 = -1;
289pub const WINT_MIN: u32 = 0;
290pub const WINT_MAX: u32 = 4294967295;
291pub const GENERIC_GRID_LAUNCH: u32 = 1;
292pub const __bool_true_false_are_defined: u32 = 1;
293pub const true_: u32 = 1;
294pub const false_: u32 = 0;
295pub const HIP_TRSA_OVERRIDE_FORMAT: u32 = 1;
296pub const HIP_TRSF_READ_AS_INTEGER: u32 = 1;
297pub const HIP_TRSF_NORMALIZED_COORDINATES: u32 = 2;
298pub const HIP_TRSF_SRGB: u32 = 16;
299pub const _LIBC_LIMITS_H_: u32 = 1;
300pub const MB_LEN_MAX: u32 = 16;
301pub const _BITS_POSIX1_LIM_H: u32 = 1;
302pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
303pub const _POSIX_AIO_MAX: u32 = 1;
304pub const _POSIX_ARG_MAX: u32 = 4096;
305pub const _POSIX_CHILD_MAX: u32 = 25;
306pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
307pub const _POSIX_HOST_NAME_MAX: u32 = 255;
308pub const _POSIX_LINK_MAX: u32 = 8;
309pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
310pub const _POSIX_MAX_CANON: u32 = 255;
311pub const _POSIX_MAX_INPUT: u32 = 255;
312pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
313pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
314pub const _POSIX_NAME_MAX: u32 = 14;
315pub const _POSIX_NGROUPS_MAX: u32 = 8;
316pub const _POSIX_OPEN_MAX: u32 = 20;
317pub const _POSIX_PATH_MAX: u32 = 256;
318pub const _POSIX_PIPE_BUF: u32 = 512;
319pub const _POSIX_RE_DUP_MAX: u32 = 255;
320pub const _POSIX_RTSIG_MAX: u32 = 8;
321pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
322pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
323pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
324pub const _POSIX_SSIZE_MAX: u32 = 32767;
325pub const _POSIX_STREAM_MAX: u32 = 8;
326pub const _POSIX_SYMLINK_MAX: u32 = 255;
327pub const _POSIX_SYMLOOP_MAX: u32 = 8;
328pub const _POSIX_TIMER_MAX: u32 = 32;
329pub const _POSIX_TTY_NAME_MAX: u32 = 9;
330pub const _POSIX_TZNAME_MAX: u32 = 6;
331pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
332pub const NR_OPEN: u32 = 1024;
333pub const NGROUPS_MAX: u32 = 65536;
334pub const ARG_MAX: u32 = 131072;
335pub const LINK_MAX: u32 = 127;
336pub const MAX_CANON: u32 = 255;
337pub const MAX_INPUT: u32 = 255;
338pub const NAME_MAX: u32 = 255;
339pub const PATH_MAX: u32 = 4096;
340pub const PIPE_BUF: u32 = 4096;
341pub const XATTR_NAME_MAX: u32 = 255;
342pub const XATTR_SIZE_MAX: u32 = 65536;
343pub const XATTR_LIST_MAX: u32 = 65536;
344pub const RTSIG_MAX: u32 = 32;
345pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
346pub const PTHREAD_KEYS_MAX: u32 = 1024;
347pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
348pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
349pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
350pub const AIO_PRIO_DELTA_MAX: u32 = 20;
351pub const PTHREAD_STACK_MIN: u32 = 16384;
352pub const DELAYTIMER_MAX: u32 = 2147483647;
353pub const TTY_NAME_MAX: u32 = 32;
354pub const LOGIN_NAME_MAX: u32 = 256;
355pub const HOST_NAME_MAX: u32 = 64;
356pub const MQ_PRIO_MAX: u32 = 32768;
357pub const SEM_VALUE_MAX: u32 = 2147483647;
358pub const _BITS_POSIX2_LIM_H: u32 = 1;
359pub const _POSIX2_BC_BASE_MAX: u32 = 99;
360pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
361pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
362pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
363pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
364pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
365pub const _POSIX2_LINE_MAX: u32 = 2048;
366pub const _POSIX2_RE_DUP_MAX: u32 = 255;
367pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
368pub const BC_BASE_MAX: u32 = 99;
369pub const BC_DIM_MAX: u32 = 2048;
370pub const BC_SCALE_MAX: u32 = 99;
371pub const BC_STRING_MAX: u32 = 1000;
372pub const COLL_WEIGHTS_MAX: u32 = 255;
373pub const EXPR_NEST_MAX: u32 = 32;
374pub const LINE_MAX: u32 = 2048;
375pub const CHARCLASS_NAME_MAX: u32 = 2048;
376pub const RE_DUP_MAX: u32 = 32767;
377pub const __HIP_USE_NATIVE_VECTOR__: u32 = 1;
378pub const hipTextureType1D: u32 = 1;
379pub const hipTextureType2D: u32 = 2;
380pub const hipTextureType3D: u32 = 3;
381pub const hipTextureTypeCubemap: u32 = 12;
382pub const hipTextureType1DLayered: u32 = 241;
383pub const hipTextureType2DLayered: u32 = 242;
384pub const hipTextureTypeCubemapLayered: u32 = 252;
385pub const HIP_IMAGE_OBJECT_SIZE_DWORD: u32 = 12;
386pub const HIP_SAMPLER_OBJECT_SIZE_DWORD: u32 = 8;
387pub const HIP_SAMPLER_OBJECT_OFFSET_DWORD: u32 = 12;
388pub const HIP_TEXTURE_OBJECT_SIZE_DWORD: u32 = 20;
389pub 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" ;
390pub const hipIpcMemLazyEnablePeerAccess: u32 = 1;
391pub const HIP_IPC_HANDLE_SIZE: u32 = 64;
392pub const hipStreamDefault: u32 = 0;
393pub const hipStreamNonBlocking: u32 = 1;
394pub const hipEventDefault: u32 = 0;
395pub const hipEventBlockingSync: u32 = 1;
396pub const hipEventDisableTiming: u32 = 2;
397pub const hipEventInterprocess: u32 = 4;
398pub const hipEventRecordDefault: u32 = 0;
399pub const hipEventRecordExternal: u32 = 1;
400pub const hipEventDisableSystemFence: u32 = 536870912;
401pub const hipEventReleaseToDevice: u32 = 1073741824;
402pub const hipEventReleaseToSystem: u32 = 2147483648;
403pub const hipHostAllocDefault: u32 = 0;
404pub const hipHostMallocDefault: u32 = 0;
405pub const hipHostAllocPortable: u32 = 1;
406pub const hipHostMallocPortable: u32 = 1;
407pub const hipHostAllocMapped: u32 = 2;
408pub const hipHostMallocMapped: u32 = 2;
409pub const hipHostAllocWriteCombined: u32 = 4;
410pub const hipHostMallocWriteCombined: u32 = 4;
411pub const hipHostMallocNumaUser: u32 = 536870912;
412pub const hipHostMallocCoherent: u32 = 1073741824;
413pub const hipHostMallocNonCoherent: u32 = 2147483648;
414pub const hipMemAttachGlobal: u32 = 1;
415pub const hipMemAttachHost: u32 = 2;
416pub const hipMemAttachSingle: u32 = 4;
417pub const hipDeviceMallocDefault: u32 = 0;
418pub const hipDeviceMallocFinegrained: u32 = 1;
419pub const hipMallocSignalMemory: u32 = 2;
420pub const hipDeviceMallocUncached: u32 = 3;
421pub const hipDeviceMallocContiguous: u32 = 4;
422pub const hipHostRegisterDefault: u32 = 0;
423pub const hipHostRegisterPortable: u32 = 1;
424pub const hipHostRegisterMapped: u32 = 2;
425pub const hipHostRegisterIoMemory: u32 = 4;
426pub const hipHostRegisterReadOnly: u32 = 8;
427pub const hipExtHostRegisterCoarseGrained: u32 = 8;
428pub const hipDeviceScheduleAuto: u32 = 0;
429pub const hipDeviceScheduleSpin: u32 = 1;
430pub const hipDeviceScheduleYield: u32 = 2;
431pub const hipDeviceScheduleBlockingSync: u32 = 4;
432pub const hipDeviceScheduleMask: u32 = 7;
433pub const hipDeviceMapHost: u32 = 8;
434pub const hipDeviceLmemResizeToMax: u32 = 16;
435pub const hipArrayDefault: u32 = 0;
436pub const hipArrayLayered: u32 = 1;
437pub const hipArraySurfaceLoadStore: u32 = 2;
438pub const hipArrayCubemap: u32 = 4;
439pub const hipArrayTextureGather: u32 = 8;
440pub const hipOccupancyDefault: u32 = 0;
441pub const hipOccupancyDisableCachingOverride: u32 = 1;
442pub const hipCooperativeLaunchMultiDeviceNoPreSync: u32 = 1;
443pub const hipCooperativeLaunchMultiDeviceNoPostSync: u32 = 2;
444pub const hipExtAnyOrderLaunch: u32 = 1;
445pub const hipStreamWaitValueGte: u32 = 0;
446pub const hipStreamWaitValueEq: u32 = 1;
447pub const hipStreamWaitValueAnd: u32 = 2;
448pub const hipStreamWaitValueNor: u32 = 3;
449pub const hipExternalMemoryDedicated: u32 = 1;
450pub const hipGraphKernelNodePortDefault: u32 = 0;
451pub const hipGraphKernelNodePortLaunchCompletion: u32 = 2;
452pub const hipGraphKernelNodePortProgrammatic: u32 = 1;
453pub const USE_PEER_NON_UNIFIED: u32 = 1;
454#[doc = "< CUDA Only Maximum registers may be used in a thread,\n< passed to compiler"]
455pub const hipJitOption_hipJitOptionMaxRegisters: hipJitOption = 0;
456#[doc = "< CUDA Only Number of thread per block"]
457pub const hipJitOption_hipJitOptionThreadsPerBlock: hipJitOption = 1;
458#[doc = "< CUDA Only Value for total wall clock time"]
459pub const hipJitOption_hipJitOptionWallTime: hipJitOption = 2;
460#[doc = "< CUDA Only Pointer to the buffer with logged information"]
461pub const hipJitOption_hipJitOptionInfoLogBuffer: hipJitOption = 3;
462#[doc = "< CUDA Only Size of the buffer in bytes for logged info"]
463pub const hipJitOption_hipJitOptionInfoLogBufferSizeBytes: hipJitOption = 4;
464#[doc = "< CUDA Only Pointer to the buffer with logged error(s)"]
465pub const hipJitOption_hipJitOptionErrorLogBuffer: hipJitOption = 5;
466#[doc = "< CUDA Only Size of the buffer in bytes for logged error(s)"]
467pub const hipJitOption_hipJitOptionErrorLogBufferSizeBytes: hipJitOption = 6;
468#[doc = "< Value of optimization level for generated codes, acceptable options\n< -O0, -O1, -O2, -O3"]
469pub const hipJitOption_hipJitOptionOptimizationLevel: hipJitOption = 7;
470#[doc = "< CUDA Only The target context, which is the default"]
471pub const hipJitOption_hipJitOptionTargetFromContext: hipJitOption = 8;
472#[doc = "< CUDA Only JIT target"]
473pub const hipJitOption_hipJitOptionTarget: hipJitOption = 9;
474#[doc = "< CUDA Only Fallback strategy"]
475pub const hipJitOption_hipJitOptionFallbackStrategy: hipJitOption = 10;
476#[doc = "< CUDA Only Generate debug information"]
477pub const hipJitOption_hipJitOptionGenerateDebugInfo: hipJitOption = 11;
478#[doc = "< CUDA Only Generate log verbose"]
479pub const hipJitOption_hipJitOptionLogVerbose: hipJitOption = 12;
480#[doc = "< CUDA Only Generate line number information"]
481pub const hipJitOption_hipJitOptionGenerateLineInfo: hipJitOption = 13;
482#[doc = "< CUDA Only Set cache mode"]
483pub const hipJitOption_hipJitOptionCacheMode: hipJitOption = 14;
484#[doc = "< @deprecated CUDA Only New SM3X option."]
485pub const hipJitOption_hipJitOptionSm3xOpt: hipJitOption = 15;
486#[doc = "< CUDA Only Set fast compile"]
487pub const hipJitOption_hipJitOptionFastCompile: hipJitOption = 16;
488#[doc = "< CUDA Only Array of device symbol names to be relocated to the host"]
489pub const hipJitOption_hipJitOptionGlobalSymbolNames: hipJitOption = 17;
490#[doc = "< CUDA Only Array of host addresses to be relocated to the device"]
491pub const hipJitOption_hipJitOptionGlobalSymbolAddresses: hipJitOption = 18;
492#[doc = "< CUDA Only Number of symbol count."]
493pub const hipJitOption_hipJitOptionGlobalSymbolCount: hipJitOption = 19;
494#[doc = "< @deprecated CUDA Only Enable link-time optimization for device code"]
495pub const hipJitOption_hipJitOptionLto: hipJitOption = 20;
496#[doc = "< @deprecated CUDA Only Set single-precision denormals."]
497pub const hipJitOption_hipJitOptionFtz: hipJitOption = 21;
498#[doc = "< @deprecated CUDA Only Set single-precision floating-point division\n< and reciprocals"]
499pub const hipJitOption_hipJitOptionPrecDiv: hipJitOption = 22;
500#[doc = "< @deprecated CUDA Only Set single-precision floating-point square root"]
501pub const hipJitOption_hipJitOptionPrecSqrt: hipJitOption = 23;
502#[doc = "< @deprecated CUDA Only Enable floating-point multiplies and\n< adds/subtracts operations"]
503pub const hipJitOption_hipJitOptionFma: hipJitOption = 24;
504#[doc = "< CUDA Only Generates Position Independent code"]
505pub const hipJitOption_hipJitOptionPositionIndependentCode: hipJitOption = 25;
506#[doc = "< CUDA Only Hints to JIT compiler the minimum number of CTAs frin kernel's\n< grid to be mapped to SM"]
507pub const hipJitOption_hipJitOptionMinCTAPerSM: hipJitOption = 26;
508#[doc = "< CUDA only Maximum number of threads in a thread block"]
509pub const hipJitOption_hipJitOptionMaxThreadsPerBlock: hipJitOption = 27;
510#[doc = "< Cuda only Override Directive values"]
511pub const hipJitOption_hipJitOptionOverrideDirectiveValues: hipJitOption = 28;
512#[doc = "< Number of options"]
513pub const hipJitOption_hipJitOptionNumOptions: hipJitOption = 29;
514#[doc = "< Hip Only Linker options to be passed on to compiler"]
515pub const hipJitOption_hipJitOptionIRtoISAOptExt: hipJitOption = 10000;
516#[doc = "< Hip Only Count of linker options to be passed on to compiler"]
517pub const hipJitOption_hipJitOptionIRtoISAOptCountExt: hipJitOption = 10001;
518#[doc = " hipJitOption"]
519pub type hipJitOption = ::std::os::raw::c_uint;
520#[doc = "< Cuda only Input cubin"]
521pub const hipJitInputType_hipJitInputCubin: hipJitInputType = 0;
522#[doc = "< Cuda only Input PTX"]
523pub const hipJitInputType_hipJitInputPtx: hipJitInputType = 1;
524#[doc = "< Cuda Only Input FAT Binary"]
525pub const hipJitInputType_hipJitInputFatBinary: hipJitInputType = 2;
526#[doc = "< Cuda Only Host Object with embedded device code"]
527pub const hipJitInputType_hipJitInputObject: hipJitInputType = 3;
528#[doc = "< Cuda Only Archive of Host Objects with embedded\n< device code"]
529pub const hipJitInputType_hipJitInputLibrary: hipJitInputType = 4;
530#[doc = "< @deprecated Cuda only High Level intermediate\n< code for LTO"]
531pub const hipJitInputType_hipJitInputNvvm: hipJitInputType = 5;
532#[doc = "< Count of Legacy Input Types"]
533pub const hipJitInputType_hipJitNumLegacyInputTypes: hipJitInputType = 6;
534#[doc = "< HIP Only LLVM Bitcode or IR assembly"]
535pub const hipJitInputType_hipJitInputLLVMBitcode: hipJitInputType = 100;
536#[doc = "< HIP Only LLVM Clang Bundled Code"]
537pub const hipJitInputType_hipJitInputLLVMBundledBitcode: hipJitInputType = 101;
538#[doc = "< HIP Only LLVM Archive of Bundled Bitcode"]
539pub const hipJitInputType_hipJitInputLLVMArchivesOfBundledBitcode: hipJitInputType = 102;
540#[doc = "< HIP Only SPIRV Code Object"]
541pub const hipJitInputType_hipJitInputSpirv: hipJitInputType = 103;
542#[doc = "< Count of Input Types"]
543pub const hipJitInputType_hipJitNumInputTypes: hipJitInputType = 10;
544#[doc = " hipJitInputType"]
545pub type hipJitInputType = ::std::os::raw::c_uint;
546pub const hipJitCacheMode_hipJitCacheOptionNone: hipJitCacheMode = 0;
547pub const hipJitCacheMode_hipJitCacheOptionCG: hipJitCacheMode = 1;
548pub const hipJitCacheMode_hipJitCacheOptionCA: hipJitCacheMode = 2;
549#[doc = " hipJitCacheMode"]
550pub type hipJitCacheMode = ::std::os::raw::c_uint;
551pub const hipJitFallback_hipJitPreferPTX: hipJitFallback = 0;
552pub const hipJitFallback_hipJitPreferBinary: hipJitFallback = 1;
553#[doc = " hipJitFallback"]
554pub type hipJitFallback = ::std::os::raw::c_uint;
555pub type wchar_t = ::std::os::raw::c_int;
556pub type __cfloat128 = __BindgenComplex<u128>;
557pub type _Float128 = u128;
558pub type _Float32 = f32;
559pub type _Float64 = f64;
560pub type _Float32x = f64;
561pub type _Float64x = u128;
562#[repr(C)]
563#[derive(Debug, Copy, Clone)]
564pub struct div_t {
565 pub quot: ::std::os::raw::c_int,
566 pub rem: ::std::os::raw::c_int,
567}
568#[repr(C)]
569#[derive(Debug, Copy, Clone)]
570pub struct ldiv_t {
571 pub quot: ::std::os::raw::c_long,
572 pub rem: ::std::os::raw::c_long,
573}
574#[repr(C)]
575#[derive(Debug, Copy, Clone)]
576pub struct lldiv_t {
577 pub quot: ::std::os::raw::c_longlong,
578 pub rem: ::std::os::raw::c_longlong,
579}
580extern "C" {
581 pub fn __ctype_get_mb_cur_max() -> usize;
582}
583extern "C" {
584 pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
585}
586extern "C" {
587 pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
588}
589extern "C" {
590 pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
591}
592extern "C" {
593 pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
594}
595extern "C" {
596 pub fn strtod(
597 __nptr: *const ::std::os::raw::c_char,
598 __endptr: *mut *mut ::std::os::raw::c_char,
599 ) -> f64;
600}
601extern "C" {
602 pub fn strtof(
603 __nptr: *const ::std::os::raw::c_char,
604 __endptr: *mut *mut ::std::os::raw::c_char,
605 ) -> f32;
606}
607extern "C" {
608 pub fn strtold(
609 __nptr: *const ::std::os::raw::c_char,
610 __endptr: *mut *mut ::std::os::raw::c_char,
611 ) -> u128;
612}
613extern "C" {
614 pub fn strtol(
615 __nptr: *const ::std::os::raw::c_char,
616 __endptr: *mut *mut ::std::os::raw::c_char,
617 __base: ::std::os::raw::c_int,
618 ) -> ::std::os::raw::c_long;
619}
620extern "C" {
621 pub fn strtoul(
622 __nptr: *const ::std::os::raw::c_char,
623 __endptr: *mut *mut ::std::os::raw::c_char,
624 __base: ::std::os::raw::c_int,
625 ) -> ::std::os::raw::c_ulong;
626}
627extern "C" {
628 pub fn strtoq(
629 __nptr: *const ::std::os::raw::c_char,
630 __endptr: *mut *mut ::std::os::raw::c_char,
631 __base: ::std::os::raw::c_int,
632 ) -> ::std::os::raw::c_longlong;
633}
634extern "C" {
635 pub fn strtouq(
636 __nptr: *const ::std::os::raw::c_char,
637 __endptr: *mut *mut ::std::os::raw::c_char,
638 __base: ::std::os::raw::c_int,
639 ) -> ::std::os::raw::c_ulonglong;
640}
641extern "C" {
642 pub fn strtoll(
643 __nptr: *const ::std::os::raw::c_char,
644 __endptr: *mut *mut ::std::os::raw::c_char,
645 __base: ::std::os::raw::c_int,
646 ) -> ::std::os::raw::c_longlong;
647}
648extern "C" {
649 pub fn strtoull(
650 __nptr: *const ::std::os::raw::c_char,
651 __endptr: *mut *mut ::std::os::raw::c_char,
652 __base: ::std::os::raw::c_int,
653 ) -> ::std::os::raw::c_ulonglong;
654}
655extern "C" {
656 pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
657}
658extern "C" {
659 pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
660}
661pub type __u_char = ::std::os::raw::c_uchar;
662pub type __u_short = ::std::os::raw::c_ushort;
663pub type __u_int = ::std::os::raw::c_uint;
664pub type __u_long = ::std::os::raw::c_ulong;
665pub type __int8_t = ::std::os::raw::c_schar;
666pub type __uint8_t = ::std::os::raw::c_uchar;
667pub type __int16_t = ::std::os::raw::c_short;
668pub type __uint16_t = ::std::os::raw::c_ushort;
669pub type __int32_t = ::std::os::raw::c_int;
670pub type __uint32_t = ::std::os::raw::c_uint;
671pub type __int64_t = ::std::os::raw::c_long;
672pub type __uint64_t = ::std::os::raw::c_ulong;
673pub type __int_least8_t = __int8_t;
674pub type __uint_least8_t = __uint8_t;
675pub type __int_least16_t = __int16_t;
676pub type __uint_least16_t = __uint16_t;
677pub type __int_least32_t = __int32_t;
678pub type __uint_least32_t = __uint32_t;
679pub type __int_least64_t = __int64_t;
680pub type __uint_least64_t = __uint64_t;
681pub type __quad_t = ::std::os::raw::c_long;
682pub type __u_quad_t = ::std::os::raw::c_ulong;
683pub type __intmax_t = ::std::os::raw::c_long;
684pub type __uintmax_t = ::std::os::raw::c_ulong;
685pub type __dev_t = ::std::os::raw::c_ulong;
686pub type __uid_t = ::std::os::raw::c_uint;
687pub type __gid_t = ::std::os::raw::c_uint;
688pub type __ino_t = ::std::os::raw::c_ulong;
689pub type __ino64_t = ::std::os::raw::c_ulong;
690pub type __mode_t = ::std::os::raw::c_uint;
691pub type __nlink_t = ::std::os::raw::c_ulong;
692pub type __off_t = ::std::os::raw::c_long;
693pub type __off64_t = ::std::os::raw::c_long;
694pub type __pid_t = ::std::os::raw::c_int;
695#[repr(C)]
696#[derive(Debug, Copy, Clone)]
697pub struct __fsid_t {
698 pub __val: [::std::os::raw::c_int; 2usize],
699}
700pub type __clock_t = ::std::os::raw::c_long;
701pub type __rlim_t = ::std::os::raw::c_ulong;
702pub type __rlim64_t = ::std::os::raw::c_ulong;
703pub type __id_t = ::std::os::raw::c_uint;
704pub type __time_t = ::std::os::raw::c_long;
705pub type __useconds_t = ::std::os::raw::c_uint;
706pub type __suseconds_t = ::std::os::raw::c_long;
707pub type __suseconds64_t = ::std::os::raw::c_long;
708pub type __daddr_t = ::std::os::raw::c_int;
709pub type __key_t = ::std::os::raw::c_int;
710pub type __clockid_t = ::std::os::raw::c_int;
711pub type __timer_t = *mut ::std::os::raw::c_void;
712pub type __blksize_t = ::std::os::raw::c_long;
713pub type __blkcnt_t = ::std::os::raw::c_long;
714pub type __blkcnt64_t = ::std::os::raw::c_long;
715pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
716pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
717pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
718pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
719pub type __fsword_t = ::std::os::raw::c_long;
720pub type __ssize_t = ::std::os::raw::c_long;
721pub type __syscall_slong_t = ::std::os::raw::c_long;
722pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
723pub type __loff_t = __off64_t;
724pub type __caddr_t = *mut ::std::os::raw::c_char;
725pub type __intptr_t = ::std::os::raw::c_long;
726pub type __socklen_t = ::std::os::raw::c_uint;
727pub type __sig_atomic_t = ::std::os::raw::c_int;
728pub type u_char = __u_char;
729pub type u_short = __u_short;
730pub type u_int = __u_int;
731pub type u_long = __u_long;
732pub type quad_t = __quad_t;
733pub type u_quad_t = __u_quad_t;
734pub type fsid_t = __fsid_t;
735pub type loff_t = __loff_t;
736pub type ino_t = __ino_t;
737pub type dev_t = __dev_t;
738pub type gid_t = __gid_t;
739pub type mode_t = __mode_t;
740pub type nlink_t = __nlink_t;
741pub type uid_t = __uid_t;
742pub type off_t = __off_t;
743pub type pid_t = __pid_t;
744pub type id_t = __id_t;
745pub type daddr_t = __daddr_t;
746pub type caddr_t = __caddr_t;
747pub type key_t = __key_t;
748pub type clock_t = __clock_t;
749pub type clockid_t = __clockid_t;
750pub type time_t = __time_t;
751pub type timer_t = __timer_t;
752pub type ulong = ::std::os::raw::c_ulong;
753pub type ushort = ::std::os::raw::c_ushort;
754pub type uint = ::std::os::raw::c_uint;
755pub type u_int8_t = __uint8_t;
756pub type u_int16_t = __uint16_t;
757pub type u_int32_t = __uint32_t;
758pub type u_int64_t = __uint64_t;
759pub type register_t = ::std::os::raw::c_long;
760#[repr(C)]
761#[derive(Debug, Copy, Clone)]
762pub struct __sigset_t {
763 pub __val: [::std::os::raw::c_ulong; 16usize],
764}
765pub type sigset_t = __sigset_t;
766#[repr(C)]
767#[derive(Debug, Copy, Clone)]
768pub struct timeval {
769 pub tv_sec: __time_t,
770 pub tv_usec: __suseconds_t,
771}
772#[repr(C)]
773#[derive(Debug, Copy, Clone)]
774pub struct timespec {
775 pub tv_sec: __time_t,
776 pub tv_nsec: __syscall_slong_t,
777}
778pub type suseconds_t = __suseconds_t;
779pub type __fd_mask = ::std::os::raw::c_long;
780#[repr(C)]
781#[derive(Debug, Copy, Clone)]
782pub struct fd_set {
783 pub __fds_bits: [__fd_mask; 16usize],
784}
785pub type fd_mask = __fd_mask;
786extern "C" {
787 pub fn select(
788 __nfds: ::std::os::raw::c_int,
789 __readfds: *mut fd_set,
790 __writefds: *mut fd_set,
791 __exceptfds: *mut fd_set,
792 __timeout: *mut timeval,
793 ) -> ::std::os::raw::c_int;
794}
795extern "C" {
796 pub fn pselect(
797 __nfds: ::std::os::raw::c_int,
798 __readfds: *mut fd_set,
799 __writefds: *mut fd_set,
800 __exceptfds: *mut fd_set,
801 __timeout: *const timespec,
802 __sigmask: *const __sigset_t,
803 ) -> ::std::os::raw::c_int;
804}
805pub type blksize_t = __blksize_t;
806pub type blkcnt_t = __blkcnt_t;
807pub type fsblkcnt_t = __fsblkcnt_t;
808pub type fsfilcnt_t = __fsfilcnt_t;
809#[repr(C)]
810#[derive(Copy, Clone)]
811pub union __atomic_wide_counter {
812 pub __value64: ::std::os::raw::c_ulonglong,
813 pub __value32: __atomic_wide_counter__bindgen_ty_1,
814}
815#[repr(C)]
816#[derive(Debug, Copy, Clone)]
817pub struct __atomic_wide_counter__bindgen_ty_1 {
818 pub __low: ::std::os::raw::c_uint,
819 pub __high: ::std::os::raw::c_uint,
820}
821#[repr(C)]
822#[derive(Debug, Copy, Clone)]
823pub struct __pthread_internal_list {
824 pub __prev: *mut __pthread_internal_list,
825 pub __next: *mut __pthread_internal_list,
826}
827pub type __pthread_list_t = __pthread_internal_list;
828#[repr(C)]
829#[derive(Debug, Copy, Clone)]
830pub struct __pthread_internal_slist {
831 pub __next: *mut __pthread_internal_slist,
832}
833pub type __pthread_slist_t = __pthread_internal_slist;
834#[repr(C)]
835#[derive(Debug, Copy, Clone)]
836pub struct __pthread_mutex_s {
837 pub __lock: ::std::os::raw::c_int,
838 pub __count: ::std::os::raw::c_uint,
839 pub __owner: ::std::os::raw::c_int,
840 pub __nusers: ::std::os::raw::c_uint,
841 pub __kind: ::std::os::raw::c_int,
842 pub __spins: ::std::os::raw::c_short,
843 pub __elision: ::std::os::raw::c_short,
844 pub __list: __pthread_list_t,
845}
846#[repr(C)]
847#[derive(Debug, Copy, Clone)]
848pub struct __pthread_rwlock_arch_t {
849 pub __readers: ::std::os::raw::c_uint,
850 pub __writers: ::std::os::raw::c_uint,
851 pub __wrphase_futex: ::std::os::raw::c_uint,
852 pub __writers_futex: ::std::os::raw::c_uint,
853 pub __pad3: ::std::os::raw::c_uint,
854 pub __pad4: ::std::os::raw::c_uint,
855 pub __cur_writer: ::std::os::raw::c_int,
856 pub __shared: ::std::os::raw::c_int,
857 pub __rwelision: ::std::os::raw::c_schar,
858 pub __pad1: [::std::os::raw::c_uchar; 7usize],
859 pub __pad2: ::std::os::raw::c_ulong,
860 pub __flags: ::std::os::raw::c_uint,
861}
862#[repr(C)]
863#[derive(Copy, Clone)]
864pub struct __pthread_cond_s {
865 pub __wseq: __atomic_wide_counter,
866 pub __g1_start: __atomic_wide_counter,
867 pub __g_size: [::std::os::raw::c_uint; 2usize],
868 pub __g1_orig_size: ::std::os::raw::c_uint,
869 pub __wrefs: ::std::os::raw::c_uint,
870 pub __g_signals: [::std::os::raw::c_uint; 2usize],
871}
872pub type __tss_t = ::std::os::raw::c_uint;
873pub type __thrd_t = ::std::os::raw::c_ulong;
874#[repr(C)]
875#[derive(Debug, Copy, Clone)]
876pub struct __once_flag {
877 pub __data: ::std::os::raw::c_int,
878}
879pub type pthread_t = ::std::os::raw::c_ulong;
880#[repr(C)]
881#[derive(Copy, Clone)]
882pub union pthread_mutexattr_t {
883 pub __size: [::std::os::raw::c_char; 4usize],
884 pub __align: ::std::os::raw::c_int,
885}
886#[repr(C)]
887#[derive(Copy, Clone)]
888pub union pthread_condattr_t {
889 pub __size: [::std::os::raw::c_char; 4usize],
890 pub __align: ::std::os::raw::c_int,
891}
892pub type pthread_key_t = ::std::os::raw::c_uint;
893pub type pthread_once_t = ::std::os::raw::c_int;
894#[repr(C)]
895#[derive(Copy, Clone)]
896pub union pthread_attr_t {
897 pub __size: [::std::os::raw::c_char; 56usize],
898 pub __align: ::std::os::raw::c_long,
899}
900#[repr(C)]
901#[derive(Copy, Clone)]
902pub union pthread_mutex_t {
903 pub __data: __pthread_mutex_s,
904 pub __size: [::std::os::raw::c_char; 40usize],
905 pub __align: ::std::os::raw::c_long,
906}
907#[repr(C)]
908#[derive(Copy, Clone)]
909pub union pthread_cond_t {
910 pub __data: __pthread_cond_s,
911 pub __size: [::std::os::raw::c_char; 48usize],
912 pub __align: ::std::os::raw::c_longlong,
913}
914#[repr(C)]
915#[derive(Copy, Clone)]
916pub union pthread_rwlock_t {
917 pub __data: __pthread_rwlock_arch_t,
918 pub __size: [::std::os::raw::c_char; 56usize],
919 pub __align: ::std::os::raw::c_long,
920}
921#[repr(C)]
922#[derive(Copy, Clone)]
923pub union pthread_rwlockattr_t {
924 pub __size: [::std::os::raw::c_char; 8usize],
925 pub __align: ::std::os::raw::c_long,
926}
927pub type pthread_spinlock_t = ::std::os::raw::c_int;
928#[repr(C)]
929#[derive(Copy, Clone)]
930pub union pthread_barrier_t {
931 pub __size: [::std::os::raw::c_char; 32usize],
932 pub __align: ::std::os::raw::c_long,
933}
934#[repr(C)]
935#[derive(Copy, Clone)]
936pub union pthread_barrierattr_t {
937 pub __size: [::std::os::raw::c_char; 4usize],
938 pub __align: ::std::os::raw::c_int,
939}
940extern "C" {
941 pub fn random() -> ::std::os::raw::c_long;
942}
943extern "C" {
944 pub fn srandom(__seed: ::std::os::raw::c_uint);
945}
946extern "C" {
947 pub fn initstate(
948 __seed: ::std::os::raw::c_uint,
949 __statebuf: *mut ::std::os::raw::c_char,
950 __statelen: usize,
951 ) -> *mut ::std::os::raw::c_char;
952}
953extern "C" {
954 pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
955}
956#[repr(C)]
957#[derive(Debug, Copy, Clone)]
958pub struct random_data {
959 pub fptr: *mut i32,
960 pub rptr: *mut i32,
961 pub state: *mut i32,
962 pub rand_type: ::std::os::raw::c_int,
963 pub rand_deg: ::std::os::raw::c_int,
964 pub rand_sep: ::std::os::raw::c_int,
965 pub end_ptr: *mut i32,
966}
967extern "C" {
968 pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
969}
970extern "C" {
971 pub fn srandom_r(
972 __seed: ::std::os::raw::c_uint,
973 __buf: *mut random_data,
974 ) -> ::std::os::raw::c_int;
975}
976extern "C" {
977 pub fn initstate_r(
978 __seed: ::std::os::raw::c_uint,
979 __statebuf: *mut ::std::os::raw::c_char,
980 __statelen: usize,
981 __buf: *mut random_data,
982 ) -> ::std::os::raw::c_int;
983}
984extern "C" {
985 pub fn setstate_r(
986 __statebuf: *mut ::std::os::raw::c_char,
987 __buf: *mut random_data,
988 ) -> ::std::os::raw::c_int;
989}
990extern "C" {
991 pub fn rand() -> ::std::os::raw::c_int;
992}
993extern "C" {
994 pub fn srand(__seed: ::std::os::raw::c_uint);
995}
996extern "C" {
997 pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
998}
999extern "C" {
1000 pub fn drand48() -> f64;
1001}
1002extern "C" {
1003 pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
1004}
1005extern "C" {
1006 pub fn lrand48() -> ::std::os::raw::c_long;
1007}
1008extern "C" {
1009 pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1010}
1011extern "C" {
1012 pub fn mrand48() -> ::std::os::raw::c_long;
1013}
1014extern "C" {
1015 pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1016}
1017extern "C" {
1018 pub fn srand48(__seedval: ::std::os::raw::c_long);
1019}
1020extern "C" {
1021 pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
1022}
1023extern "C" {
1024 pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
1025}
1026#[repr(C)]
1027#[derive(Debug, Copy, Clone)]
1028pub struct drand48_data {
1029 pub __x: [::std::os::raw::c_ushort; 3usize],
1030 pub __old_x: [::std::os::raw::c_ushort; 3usize],
1031 pub __c: ::std::os::raw::c_ushort,
1032 pub __init: ::std::os::raw::c_ushort,
1033 pub __a: ::std::os::raw::c_ulonglong,
1034}
1035extern "C" {
1036 pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
1037}
1038extern "C" {
1039 pub fn erand48_r(
1040 __xsubi: *mut ::std::os::raw::c_ushort,
1041 __buffer: *mut drand48_data,
1042 __result: *mut f64,
1043 ) -> ::std::os::raw::c_int;
1044}
1045extern "C" {
1046 pub fn lrand48_r(
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 nrand48_r(
1053 __xsubi: *mut ::std::os::raw::c_ushort,
1054 __buffer: *mut drand48_data,
1055 __result: *mut ::std::os::raw::c_long,
1056 ) -> ::std::os::raw::c_int;
1057}
1058extern "C" {
1059 pub fn mrand48_r(
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 jrand48_r(
1066 __xsubi: *mut ::std::os::raw::c_ushort,
1067 __buffer: *mut drand48_data,
1068 __result: *mut ::std::os::raw::c_long,
1069 ) -> ::std::os::raw::c_int;
1070}
1071extern "C" {
1072 pub fn srand48_r(
1073 __seedval: ::std::os::raw::c_long,
1074 __buffer: *mut drand48_data,
1075 ) -> ::std::os::raw::c_int;
1076}
1077extern "C" {
1078 pub fn seed48_r(
1079 __seed16v: *mut ::std::os::raw::c_ushort,
1080 __buffer: *mut drand48_data,
1081 ) -> ::std::os::raw::c_int;
1082}
1083extern "C" {
1084 pub fn lcong48_r(
1085 __param: *mut ::std::os::raw::c_ushort,
1086 __buffer: *mut drand48_data,
1087 ) -> ::std::os::raw::c_int;
1088}
1089extern "C" {
1090 pub fn arc4random() -> __uint32_t;
1091}
1092extern "C" {
1093 pub fn arc4random_buf(__buf: *mut ::std::os::raw::c_void, __size: usize);
1094}
1095extern "C" {
1096 pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
1097}
1098extern "C" {
1099 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1100}
1101extern "C" {
1102 pub fn calloc(
1103 __nmemb: ::std::os::raw::c_ulong,
1104 __size: ::std::os::raw::c_ulong,
1105 ) -> *mut ::std::os::raw::c_void;
1106}
1107extern "C" {
1108 pub fn realloc(
1109 __ptr: *mut ::std::os::raw::c_void,
1110 __size: ::std::os::raw::c_ulong,
1111 ) -> *mut ::std::os::raw::c_void;
1112}
1113extern "C" {
1114 pub fn free(__ptr: *mut ::std::os::raw::c_void);
1115}
1116extern "C" {
1117 pub fn reallocarray(
1118 __ptr: *mut ::std::os::raw::c_void,
1119 __nmemb: usize,
1120 __size: usize,
1121 ) -> *mut ::std::os::raw::c_void;
1122}
1123extern "C" {
1124 pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1125}
1126extern "C" {
1127 pub fn valloc(__size: usize) -> *mut ::std::os::raw::c_void;
1128}
1129extern "C" {
1130 pub fn posix_memalign(
1131 __memptr: *mut *mut ::std::os::raw::c_void,
1132 __alignment: usize,
1133 __size: usize,
1134 ) -> ::std::os::raw::c_int;
1135}
1136extern "C" {
1137 pub fn aligned_alloc(
1138 __alignment: ::std::os::raw::c_ulong,
1139 __size: ::std::os::raw::c_ulong,
1140 ) -> *mut ::std::os::raw::c_void;
1141}
1142extern "C" {
1143 pub fn abort() -> !;
1144}
1145extern "C" {
1146 pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
1147}
1148extern "C" {
1149 pub fn at_quick_exit(
1150 __func: ::std::option::Option<unsafe extern "C" fn()>,
1151 ) -> ::std::os::raw::c_int;
1152}
1153extern "C" {
1154 pub fn on_exit(
1155 __func: ::std::option::Option<
1156 unsafe extern "C" fn(
1157 __status: ::std::os::raw::c_int,
1158 __arg: *mut ::std::os::raw::c_void,
1159 ),
1160 >,
1161 __arg: *mut ::std::os::raw::c_void,
1162 ) -> ::std::os::raw::c_int;
1163}
1164extern "C" {
1165 pub fn exit(__status: ::std::os::raw::c_int) -> !;
1166}
1167extern "C" {
1168 pub fn quick_exit(__status: ::std::os::raw::c_int) -> !;
1169}
1170extern "C" {
1171 pub fn _Exit(__status: ::std::os::raw::c_int) -> !;
1172}
1173extern "C" {
1174 pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1175}
1176extern "C" {
1177 pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1178}
1179extern "C" {
1180 pub fn setenv(
1181 __name: *const ::std::os::raw::c_char,
1182 __value: *const ::std::os::raw::c_char,
1183 __replace: ::std::os::raw::c_int,
1184 ) -> ::std::os::raw::c_int;
1185}
1186extern "C" {
1187 pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1188}
1189extern "C" {
1190 pub fn clearenv() -> ::std::os::raw::c_int;
1191}
1192extern "C" {
1193 pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1194}
1195extern "C" {
1196 pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1197}
1198extern "C" {
1199 pub fn mkstemps(
1200 __template: *mut ::std::os::raw::c_char,
1201 __suffixlen: ::std::os::raw::c_int,
1202 ) -> ::std::os::raw::c_int;
1203}
1204extern "C" {
1205 pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1206}
1207extern "C" {
1208 pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1209}
1210extern "C" {
1211 pub fn realpath(
1212 __name: *const ::std::os::raw::c_char,
1213 __resolved: *mut ::std::os::raw::c_char,
1214 ) -> *mut ::std::os::raw::c_char;
1215}
1216pub type __compar_fn_t = ::std::option::Option<
1217 unsafe extern "C" fn(
1218 arg1: *const ::std::os::raw::c_void,
1219 arg2: *const ::std::os::raw::c_void,
1220 ) -> ::std::os::raw::c_int,
1221>;
1222extern "C" {
1223 pub fn bsearch(
1224 __key: *const ::std::os::raw::c_void,
1225 __base: *const ::std::os::raw::c_void,
1226 __nmemb: usize,
1227 __size: usize,
1228 __compar: __compar_fn_t,
1229 ) -> *mut ::std::os::raw::c_void;
1230}
1231extern "C" {
1232 pub fn qsort(
1233 __base: *mut ::std::os::raw::c_void,
1234 __nmemb: usize,
1235 __size: usize,
1236 __compar: __compar_fn_t,
1237 );
1238}
1239extern "C" {
1240 pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1241}
1242extern "C" {
1243 pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
1244}
1245extern "C" {
1246 pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
1247}
1248extern "C" {
1249 pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
1250}
1251extern "C" {
1252 pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
1253}
1254extern "C" {
1255 pub fn lldiv(
1256 __numer: ::std::os::raw::c_longlong,
1257 __denom: ::std::os::raw::c_longlong,
1258 ) -> lldiv_t;
1259}
1260extern "C" {
1261 pub fn ecvt(
1262 __value: f64,
1263 __ndigit: ::std::os::raw::c_int,
1264 __decpt: *mut ::std::os::raw::c_int,
1265 __sign: *mut ::std::os::raw::c_int,
1266 ) -> *mut ::std::os::raw::c_char;
1267}
1268extern "C" {
1269 pub fn fcvt(
1270 __value: f64,
1271 __ndigit: ::std::os::raw::c_int,
1272 __decpt: *mut ::std::os::raw::c_int,
1273 __sign: *mut ::std::os::raw::c_int,
1274 ) -> *mut ::std::os::raw::c_char;
1275}
1276extern "C" {
1277 pub fn gcvt(
1278 __value: f64,
1279 __ndigit: ::std::os::raw::c_int,
1280 __buf: *mut ::std::os::raw::c_char,
1281 ) -> *mut ::std::os::raw::c_char;
1282}
1283extern "C" {
1284 pub fn qecvt(
1285 __value: u128,
1286 __ndigit: ::std::os::raw::c_int,
1287 __decpt: *mut ::std::os::raw::c_int,
1288 __sign: *mut ::std::os::raw::c_int,
1289 ) -> *mut ::std::os::raw::c_char;
1290}
1291extern "C" {
1292 pub fn qfcvt(
1293 __value: u128,
1294 __ndigit: ::std::os::raw::c_int,
1295 __decpt: *mut ::std::os::raw::c_int,
1296 __sign: *mut ::std::os::raw::c_int,
1297 ) -> *mut ::std::os::raw::c_char;
1298}
1299extern "C" {
1300 pub fn qgcvt(
1301 __value: u128,
1302 __ndigit: ::std::os::raw::c_int,
1303 __buf: *mut ::std::os::raw::c_char,
1304 ) -> *mut ::std::os::raw::c_char;
1305}
1306extern "C" {
1307 pub fn ecvt_r(
1308 __value: f64,
1309 __ndigit: ::std::os::raw::c_int,
1310 __decpt: *mut ::std::os::raw::c_int,
1311 __sign: *mut ::std::os::raw::c_int,
1312 __buf: *mut ::std::os::raw::c_char,
1313 __len: usize,
1314 ) -> ::std::os::raw::c_int;
1315}
1316extern "C" {
1317 pub fn fcvt_r(
1318 __value: f64,
1319 __ndigit: ::std::os::raw::c_int,
1320 __decpt: *mut ::std::os::raw::c_int,
1321 __sign: *mut ::std::os::raw::c_int,
1322 __buf: *mut ::std::os::raw::c_char,
1323 __len: usize,
1324 ) -> ::std::os::raw::c_int;
1325}
1326extern "C" {
1327 pub fn qecvt_r(
1328 __value: u128,
1329 __ndigit: ::std::os::raw::c_int,
1330 __decpt: *mut ::std::os::raw::c_int,
1331 __sign: *mut ::std::os::raw::c_int,
1332 __buf: *mut ::std::os::raw::c_char,
1333 __len: usize,
1334 ) -> ::std::os::raw::c_int;
1335}
1336extern "C" {
1337 pub fn qfcvt_r(
1338 __value: u128,
1339 __ndigit: ::std::os::raw::c_int,
1340 __decpt: *mut ::std::os::raw::c_int,
1341 __sign: *mut ::std::os::raw::c_int,
1342 __buf: *mut ::std::os::raw::c_char,
1343 __len: usize,
1344 ) -> ::std::os::raw::c_int;
1345}
1346extern "C" {
1347 pub fn mblen(__s: *const ::std::os::raw::c_char, __n: usize) -> ::std::os::raw::c_int;
1348}
1349extern "C" {
1350 pub fn mbtowc(
1351 __pwc: *mut wchar_t,
1352 __s: *const ::std::os::raw::c_char,
1353 __n: usize,
1354 ) -> ::std::os::raw::c_int;
1355}
1356extern "C" {
1357 pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
1358}
1359extern "C" {
1360 pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const ::std::os::raw::c_char, __n: usize) -> usize;
1361}
1362extern "C" {
1363 pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
1364}
1365extern "C" {
1366 pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1367}
1368extern "C" {
1369 pub fn getsubopt(
1370 __optionp: *mut *mut ::std::os::raw::c_char,
1371 __tokens: *const *mut ::std::os::raw::c_char,
1372 __valuep: *mut *mut ::std::os::raw::c_char,
1373 ) -> ::std::os::raw::c_int;
1374}
1375extern "C" {
1376 pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
1377 -> ::std::os::raw::c_int;
1378}
1379#[doc = "< Success"]
1380pub const hiprtcResult_HIPRTC_SUCCESS: hiprtcResult = 0;
1381#[doc = "< Out of memory"]
1382pub const hiprtcResult_HIPRTC_ERROR_OUT_OF_MEMORY: hiprtcResult = 1;
1383#[doc = "< Failed to create program"]
1384pub const hiprtcResult_HIPRTC_ERROR_PROGRAM_CREATION_FAILURE: hiprtcResult = 2;
1385#[doc = "< Invalid input"]
1386pub const hiprtcResult_HIPRTC_ERROR_INVALID_INPUT: hiprtcResult = 3;
1387#[doc = "< Invalid program"]
1388pub const hiprtcResult_HIPRTC_ERROR_INVALID_PROGRAM: hiprtcResult = 4;
1389#[doc = "< Invalid option"]
1390pub const hiprtcResult_HIPRTC_ERROR_INVALID_OPTION: hiprtcResult = 5;
1391#[doc = "< Compilation error"]
1392pub const hiprtcResult_HIPRTC_ERROR_COMPILATION: hiprtcResult = 6;
1393#[doc = "< Failed in builtin operation"]
1394pub const hiprtcResult_HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE: hiprtcResult = 7;
1395#[doc = "< No name expression after compilation"]
1396pub const hiprtcResult_HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION: hiprtcResult = 8;
1397#[doc = "< No lowered names before compilation"]
1398pub const hiprtcResult_HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION: hiprtcResult = 9;
1399#[doc = "< Invalid name expression"]
1400pub const hiprtcResult_HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID: hiprtcResult = 10;
1401#[doc = "< Internal error"]
1402pub const hiprtcResult_HIPRTC_ERROR_INTERNAL_ERROR: hiprtcResult = 11;
1403#[doc = "< Error in linking"]
1404pub const hiprtcResult_HIPRTC_ERROR_LINKING: hiprtcResult = 100;
1405#[doc = " @addtogroup GlobalDefs\n @{\n\n/\n/**\n hiprtc error code"]
1406pub type hiprtcResult = ::std::os::raw::c_uint;
1407#[repr(C)]
1408#[derive(Debug, Copy, Clone)]
1409pub struct ihiprtcLinkState {
1410 _unused: [u8; 0],
1411}
1412#[doc = " hiprtc link state\n"]
1413pub type hiprtcLinkState = *mut ihiprtcLinkState;
1414extern "C" {
1415 #[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"]
1416 pub fn hiprtcGetErrorString(result: hiprtcResult) -> *const ::std::os::raw::c_char;
1417}
1418extern "C" {
1419 #[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"]
1420 pub fn hiprtcVersion(
1421 major: *mut ::std::os::raw::c_int,
1422 minor: *mut ::std::os::raw::c_int,
1423 ) -> hiprtcResult;
1424}
1425#[repr(C)]
1426#[derive(Debug, Copy, Clone)]
1427pub struct _hiprtcProgram {
1428 _unused: [u8; 0],
1429}
1430#[doc = " hiprtc program\n"]
1431pub type hiprtcProgram = *mut _hiprtcProgram;
1432extern "C" {
1433 #[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"]
1434 pub fn hiprtcAddNameExpression(
1435 prog: hiprtcProgram,
1436 name_expression: *const ::std::os::raw::c_char,
1437 ) -> hiprtcResult;
1438}
1439extern "C" {
1440 #[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"]
1441 pub fn hiprtcCompileProgram(
1442 prog: hiprtcProgram,
1443 numOptions: ::std::os::raw::c_int,
1444 options: *mut *const ::std::os::raw::c_char,
1445 ) -> hiprtcResult;
1446}
1447extern "C" {
1448 #[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"]
1449 pub fn hiprtcCreateProgram(
1450 prog: *mut hiprtcProgram,
1451 src: *const ::std::os::raw::c_char,
1452 name: *const ::std::os::raw::c_char,
1453 numHeaders: ::std::os::raw::c_int,
1454 headers: *mut *const ::std::os::raw::c_char,
1455 includeNames: *mut *const ::std::os::raw::c_char,
1456 ) -> hiprtcResult;
1457}
1458extern "C" {
1459 #[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"]
1460 pub fn hiprtcDestroyProgram(prog: *mut hiprtcProgram) -> hiprtcResult;
1461}
1462extern "C" {
1463 #[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"]
1464 pub fn hiprtcGetLoweredName(
1465 prog: hiprtcProgram,
1466 name_expression: *const ::std::os::raw::c_char,
1467 lowered_name: *mut *const ::std::os::raw::c_char,
1468 ) -> hiprtcResult;
1469}
1470extern "C" {
1471 #[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"]
1472 pub fn hiprtcGetProgramLog(
1473 prog: hiprtcProgram,
1474 log: *mut ::std::os::raw::c_char,
1475 ) -> hiprtcResult;
1476}
1477extern "C" {
1478 #[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"]
1479 pub fn hiprtcGetProgramLogSize(prog: hiprtcProgram, logSizeRet: *mut usize) -> hiprtcResult;
1480}
1481extern "C" {
1482 #[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"]
1483 pub fn hiprtcGetCode(prog: hiprtcProgram, code: *mut ::std::os::raw::c_char) -> hiprtcResult;
1484}
1485extern "C" {
1486 #[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"]
1487 pub fn hiprtcGetCodeSize(prog: hiprtcProgram, codeSizeRet: *mut usize) -> hiprtcResult;
1488}
1489extern "C" {
1490 #[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"]
1491 pub fn hiprtcGetBitcode(
1492 prog: hiprtcProgram,
1493 bitcode: *mut ::std::os::raw::c_char,
1494 ) -> hiprtcResult;
1495}
1496extern "C" {
1497 #[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"]
1498 pub fn hiprtcGetBitcodeSize(prog: hiprtcProgram, bitcode_size: *mut usize) -> hiprtcResult;
1499}
1500extern "C" {
1501 #[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"]
1502 pub fn hiprtcLinkCreate(
1503 num_options: ::std::os::raw::c_uint,
1504 option_ptr: *mut hipJitOption,
1505 option_vals_pptr: *mut *mut ::std::os::raw::c_void,
1506 hip_link_state_ptr: *mut hiprtcLinkState,
1507 ) -> hiprtcResult;
1508}
1509extern "C" {
1510 #[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"]
1511 pub fn hiprtcLinkAddFile(
1512 hip_link_state: hiprtcLinkState,
1513 input_type: hipJitInputType,
1514 file_path: *const ::std::os::raw::c_char,
1515 num_options: ::std::os::raw::c_uint,
1516 options_ptr: *mut hipJitOption,
1517 option_values: *mut *mut ::std::os::raw::c_void,
1518 ) -> hiprtcResult;
1519}
1520extern "C" {
1521 #[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"]
1522 pub fn hiprtcLinkAddData(
1523 hip_link_state: hiprtcLinkState,
1524 input_type: hipJitInputType,
1525 image: *mut ::std::os::raw::c_void,
1526 image_size: usize,
1527 name: *const ::std::os::raw::c_char,
1528 num_options: ::std::os::raw::c_uint,
1529 options_ptr: *mut hipJitOption,
1530 option_values: *mut *mut ::std::os::raw::c_void,
1531 ) -> hiprtcResult;
1532}
1533extern "C" {
1534 #[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"]
1535 pub fn hiprtcLinkComplete(
1536 hip_link_state: hiprtcLinkState,
1537 bin_out: *mut *mut ::std::os::raw::c_void,
1538 size_out: *mut usize,
1539 ) -> hiprtcResult;
1540}
1541extern "C" {
1542 #[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"]
1543 pub fn hiprtcLinkDestroy(hip_link_state: hiprtcLinkState) -> hiprtcResult;
1544}
1545extern "C" {
1546 pub fn memcpy(
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 memmove(
1554 __dest: *mut ::std::os::raw::c_void,
1555 __src: *const ::std::os::raw::c_void,
1556 __n: ::std::os::raw::c_ulong,
1557 ) -> *mut ::std::os::raw::c_void;
1558}
1559extern "C" {
1560 pub fn memccpy(
1561 __dest: *mut ::std::os::raw::c_void,
1562 __src: *const ::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 memset(
1569 __s: *mut ::std::os::raw::c_void,
1570 __c: ::std::os::raw::c_int,
1571 __n: ::std::os::raw::c_ulong,
1572 ) -> *mut ::std::os::raw::c_void;
1573}
1574extern "C" {
1575 pub fn memcmp(
1576 __s1: *const ::std::os::raw::c_void,
1577 __s2: *const ::std::os::raw::c_void,
1578 __n: ::std::os::raw::c_ulong,
1579 ) -> ::std::os::raw::c_int;
1580}
1581extern "C" {
1582 pub fn __memcmpeq(
1583 __s1: *const ::std::os::raw::c_void,
1584 __s2: *const ::std::os::raw::c_void,
1585 __n: usize,
1586 ) -> ::std::os::raw::c_int;
1587}
1588extern "C" {
1589 pub fn memchr(
1590 __s: *const ::std::os::raw::c_void,
1591 __c: ::std::os::raw::c_int,
1592 __n: ::std::os::raw::c_ulong,
1593 ) -> *mut ::std::os::raw::c_void;
1594}
1595extern "C" {
1596 pub fn strcpy(
1597 __dest: *mut ::std::os::raw::c_char,
1598 __src: *const ::std::os::raw::c_char,
1599 ) -> *mut ::std::os::raw::c_char;
1600}
1601extern "C" {
1602 pub fn strncpy(
1603 __dest: *mut ::std::os::raw::c_char,
1604 __src: *const ::std::os::raw::c_char,
1605 __n: ::std::os::raw::c_ulong,
1606 ) -> *mut ::std::os::raw::c_char;
1607}
1608extern "C" {
1609 pub fn strcat(
1610 __dest: *mut ::std::os::raw::c_char,
1611 __src: *const ::std::os::raw::c_char,
1612 ) -> *mut ::std::os::raw::c_char;
1613}
1614extern "C" {
1615 pub fn strncat(
1616 __dest: *mut ::std::os::raw::c_char,
1617 __src: *const ::std::os::raw::c_char,
1618 __n: ::std::os::raw::c_ulong,
1619 ) -> *mut ::std::os::raw::c_char;
1620}
1621extern "C" {
1622 pub fn strcmp(
1623 __s1: *const ::std::os::raw::c_char,
1624 __s2: *const ::std::os::raw::c_char,
1625 ) -> ::std::os::raw::c_int;
1626}
1627extern "C" {
1628 pub fn strncmp(
1629 __s1: *const ::std::os::raw::c_char,
1630 __s2: *const ::std::os::raw::c_char,
1631 __n: ::std::os::raw::c_ulong,
1632 ) -> ::std::os::raw::c_int;
1633}
1634extern "C" {
1635 pub fn strcoll(
1636 __s1: *const ::std::os::raw::c_char,
1637 __s2: *const ::std::os::raw::c_char,
1638 ) -> ::std::os::raw::c_int;
1639}
1640extern "C" {
1641 pub fn strxfrm(
1642 __dest: *mut ::std::os::raw::c_char,
1643 __src: *const ::std::os::raw::c_char,
1644 __n: ::std::os::raw::c_ulong,
1645 ) -> ::std::os::raw::c_ulong;
1646}
1647#[repr(C)]
1648#[derive(Debug, Copy, Clone)]
1649pub struct __locale_struct {
1650 pub __locales: [*mut __locale_data; 13usize],
1651 pub __ctype_b: *const ::std::os::raw::c_ushort,
1652 pub __ctype_tolower: *const ::std::os::raw::c_int,
1653 pub __ctype_toupper: *const ::std::os::raw::c_int,
1654 pub __names: [*const ::std::os::raw::c_char; 13usize],
1655}
1656pub type __locale_t = *mut __locale_struct;
1657pub type locale_t = __locale_t;
1658extern "C" {
1659 pub fn strcoll_l(
1660 __s1: *const ::std::os::raw::c_char,
1661 __s2: *const ::std::os::raw::c_char,
1662 __l: locale_t,
1663 ) -> ::std::os::raw::c_int;
1664}
1665extern "C" {
1666 pub fn strxfrm_l(
1667 __dest: *mut ::std::os::raw::c_char,
1668 __src: *const ::std::os::raw::c_char,
1669 __n: usize,
1670 __l: locale_t,
1671 ) -> usize;
1672}
1673extern "C" {
1674 pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1675}
1676extern "C" {
1677 pub fn strndup(
1678 __string: *const ::std::os::raw::c_char,
1679 __n: ::std::os::raw::c_ulong,
1680 ) -> *mut ::std::os::raw::c_char;
1681}
1682extern "C" {
1683 pub fn strchr(
1684 __s: *const ::std::os::raw::c_char,
1685 __c: ::std::os::raw::c_int,
1686 ) -> *mut ::std::os::raw::c_char;
1687}
1688extern "C" {
1689 pub fn strrchr(
1690 __s: *const ::std::os::raw::c_char,
1691 __c: ::std::os::raw::c_int,
1692 ) -> *mut ::std::os::raw::c_char;
1693}
1694extern "C" {
1695 pub fn strchrnul(
1696 __s: *const ::std::os::raw::c_char,
1697 __c: ::std::os::raw::c_int,
1698 ) -> *mut ::std::os::raw::c_char;
1699}
1700extern "C" {
1701 pub fn strcspn(
1702 __s: *const ::std::os::raw::c_char,
1703 __reject: *const ::std::os::raw::c_char,
1704 ) -> ::std::os::raw::c_ulong;
1705}
1706extern "C" {
1707 pub fn strspn(
1708 __s: *const ::std::os::raw::c_char,
1709 __accept: *const ::std::os::raw::c_char,
1710 ) -> ::std::os::raw::c_ulong;
1711}
1712extern "C" {
1713 pub fn strpbrk(
1714 __s: *const ::std::os::raw::c_char,
1715 __accept: *const ::std::os::raw::c_char,
1716 ) -> *mut ::std::os::raw::c_char;
1717}
1718extern "C" {
1719 pub fn strstr(
1720 __haystack: *const ::std::os::raw::c_char,
1721 __needle: *const ::std::os::raw::c_char,
1722 ) -> *mut ::std::os::raw::c_char;
1723}
1724extern "C" {
1725 pub fn strtok(
1726 __s: *mut ::std::os::raw::c_char,
1727 __delim: *const ::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 strtok_r(
1739 __s: *mut ::std::os::raw::c_char,
1740 __delim: *const ::std::os::raw::c_char,
1741 __save_ptr: *mut *mut ::std::os::raw::c_char,
1742 ) -> *mut ::std::os::raw::c_char;
1743}
1744extern "C" {
1745 pub fn strcasestr(
1746 __haystack: *const ::std::os::raw::c_char,
1747 __needle: *const ::std::os::raw::c_char,
1748 ) -> *mut ::std::os::raw::c_char;
1749}
1750extern "C" {
1751 pub fn memmem(
1752 __haystack: *const ::std::os::raw::c_void,
1753 __haystacklen: usize,
1754 __needle: *const ::std::os::raw::c_void,
1755 __needlelen: 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: usize,
1763 ) -> *mut ::std::os::raw::c_void;
1764}
1765extern "C" {
1766 pub fn mempcpy(
1767 __dest: *mut ::std::os::raw::c_void,
1768 __src: *const ::std::os::raw::c_void,
1769 __n: ::std::os::raw::c_ulong,
1770 ) -> *mut ::std::os::raw::c_void;
1771}
1772extern "C" {
1773 pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
1774}
1775extern "C" {
1776 pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: usize) -> usize;
1777}
1778extern "C" {
1779 pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
1780}
1781extern "C" {
1782 #[link_name = "\u{1}__xpg_strerror_r"]
1783 pub fn strerror_r(
1784 __errnum: ::std::os::raw::c_int,
1785 __buf: *mut ::std::os::raw::c_char,
1786 __buflen: usize,
1787 ) -> ::std::os::raw::c_int;
1788}
1789extern "C" {
1790 pub fn strerror_l(
1791 __errnum: ::std::os::raw::c_int,
1792 __l: locale_t,
1793 ) -> *mut ::std::os::raw::c_char;
1794}
1795extern "C" {
1796 pub fn bcmp(
1797 __s1: *const ::std::os::raw::c_void,
1798 __s2: *const ::std::os::raw::c_void,
1799 __n: ::std::os::raw::c_ulong,
1800 ) -> ::std::os::raw::c_int;
1801}
1802extern "C" {
1803 pub fn bcopy(
1804 __src: *const ::std::os::raw::c_void,
1805 __dest: *mut ::std::os::raw::c_void,
1806 __n: ::std::os::raw::c_ulong,
1807 );
1808}
1809extern "C" {
1810 pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
1811}
1812extern "C" {
1813 pub fn index(
1814 __s: *const ::std::os::raw::c_char,
1815 __c: ::std::os::raw::c_int,
1816 ) -> *mut ::std::os::raw::c_char;
1817}
1818extern "C" {
1819 pub fn rindex(
1820 __s: *const ::std::os::raw::c_char,
1821 __c: ::std::os::raw::c_int,
1822 ) -> *mut ::std::os::raw::c_char;
1823}
1824extern "C" {
1825 pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1826}
1827extern "C" {
1828 pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
1829}
1830extern "C" {
1831 pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
1832}
1833extern "C" {
1834 pub fn strcasecmp(
1835 __s1: *const ::std::os::raw::c_char,
1836 __s2: *const ::std::os::raw::c_char,
1837 ) -> ::std::os::raw::c_int;
1838}
1839extern "C" {
1840 pub fn strncasecmp(
1841 __s1: *const ::std::os::raw::c_char,
1842 __s2: *const ::std::os::raw::c_char,
1843 __n: ::std::os::raw::c_ulong,
1844 ) -> ::std::os::raw::c_int;
1845}
1846extern "C" {
1847 pub fn strcasecmp_l(
1848 __s1: *const ::std::os::raw::c_char,
1849 __s2: *const ::std::os::raw::c_char,
1850 __loc: locale_t,
1851 ) -> ::std::os::raw::c_int;
1852}
1853extern "C" {
1854 pub fn strncasecmp_l(
1855 __s1: *const ::std::os::raw::c_char,
1856 __s2: *const ::std::os::raw::c_char,
1857 __n: usize,
1858 __loc: locale_t,
1859 ) -> ::std::os::raw::c_int;
1860}
1861extern "C" {
1862 pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize);
1863}
1864extern "C" {
1865 pub fn strsep(
1866 __stringp: *mut *mut ::std::os::raw::c_char,
1867 __delim: *const ::std::os::raw::c_char,
1868 ) -> *mut ::std::os::raw::c_char;
1869}
1870extern "C" {
1871 pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
1872}
1873extern "C" {
1874 pub fn __stpcpy(
1875 __dest: *mut ::std::os::raw::c_char,
1876 __src: *const ::std::os::raw::c_char,
1877 ) -> *mut ::std::os::raw::c_char;
1878}
1879extern "C" {
1880 pub fn stpcpy(
1881 __dest: *mut ::std::os::raw::c_char,
1882 __src: *const ::std::os::raw::c_char,
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: usize,
1890 ) -> *mut ::std::os::raw::c_char;
1891}
1892extern "C" {
1893 pub fn stpncpy(
1894 __dest: *mut ::std::os::raw::c_char,
1895 __src: *const ::std::os::raw::c_char,
1896 __n: ::std::os::raw::c_ulong,
1897 ) -> *mut ::std::os::raw::c_char;
1898}
1899extern "C" {
1900 pub fn strlcpy(
1901 __dest: *mut ::std::os::raw::c_char,
1902 __src: *const ::std::os::raw::c_char,
1903 __n: ::std::os::raw::c_ulong,
1904 ) -> ::std::os::raw::c_ulong;
1905}
1906extern "C" {
1907 pub fn strlcat(
1908 __dest: *mut ::std::os::raw::c_char,
1909 __src: *const ::std::os::raw::c_char,
1910 __n: ::std::os::raw::c_ulong,
1911 ) -> ::std::os::raw::c_ulong;
1912}
1913pub const HIP_SUCCESS: _bindgen_ty_1 = 0;
1914pub const HIP_ERROR_INVALID_VALUE: _bindgen_ty_1 = 1;
1915pub const HIP_ERROR_NOT_INITIALIZED: _bindgen_ty_1 = 2;
1916pub const HIP_ERROR_LAUNCH_OUT_OF_RESOURCES: _bindgen_ty_1 = 3;
1917pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
1918#[doc = " @defgroup GlobalDefs Global enum and defines\n @{\n\n/\n/**\n hipDeviceArch_t\n"]
1919#[repr(C)]
1920#[repr(align(4))]
1921#[derive(Debug, Copy, Clone)]
1922pub struct hipDeviceArch_t {
1923 pub _bitfield_align_1: [u8; 0],
1924 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
1925 pub __bindgen_padding_0: u8,
1926}
1927impl hipDeviceArch_t {
1928 #[inline]
1929 pub fn hasGlobalInt32Atomics(&self) -> ::std::os::raw::c_uint {
1930 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1931 }
1932 #[inline]
1933 pub fn set_hasGlobalInt32Atomics(&mut self, val: ::std::os::raw::c_uint) {
1934 unsafe {
1935 let val: u32 = ::std::mem::transmute(val);
1936 self._bitfield_1.set(0usize, 1u8, val as u64)
1937 }
1938 }
1939 #[inline]
1940 pub fn hasGlobalFloatAtomicExch(&self) -> ::std::os::raw::c_uint {
1941 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1942 }
1943 #[inline]
1944 pub fn set_hasGlobalFloatAtomicExch(&mut self, val: ::std::os::raw::c_uint) {
1945 unsafe {
1946 let val: u32 = ::std::mem::transmute(val);
1947 self._bitfield_1.set(1usize, 1u8, val as u64)
1948 }
1949 }
1950 #[inline]
1951 pub fn hasSharedInt32Atomics(&self) -> ::std::os::raw::c_uint {
1952 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1953 }
1954 #[inline]
1955 pub fn set_hasSharedInt32Atomics(&mut self, val: ::std::os::raw::c_uint) {
1956 unsafe {
1957 let val: u32 = ::std::mem::transmute(val);
1958 self._bitfield_1.set(2usize, 1u8, val as u64)
1959 }
1960 }
1961 #[inline]
1962 pub fn hasSharedFloatAtomicExch(&self) -> ::std::os::raw::c_uint {
1963 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1964 }
1965 #[inline]
1966 pub fn set_hasSharedFloatAtomicExch(&mut self, val: ::std::os::raw::c_uint) {
1967 unsafe {
1968 let val: u32 = ::std::mem::transmute(val);
1969 self._bitfield_1.set(3usize, 1u8, val as u64)
1970 }
1971 }
1972 #[inline]
1973 pub fn hasFloatAtomicAdd(&self) -> ::std::os::raw::c_uint {
1974 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1975 }
1976 #[inline]
1977 pub fn set_hasFloatAtomicAdd(&mut self, val: ::std::os::raw::c_uint) {
1978 unsafe {
1979 let val: u32 = ::std::mem::transmute(val);
1980 self._bitfield_1.set(4usize, 1u8, val as u64)
1981 }
1982 }
1983 #[inline]
1984 pub fn hasGlobalInt64Atomics(&self) -> ::std::os::raw::c_uint {
1985 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1986 }
1987 #[inline]
1988 pub fn set_hasGlobalInt64Atomics(&mut self, val: ::std::os::raw::c_uint) {
1989 unsafe {
1990 let val: u32 = ::std::mem::transmute(val);
1991 self._bitfield_1.set(5usize, 1u8, val as u64)
1992 }
1993 }
1994 #[inline]
1995 pub fn hasSharedInt64Atomics(&self) -> ::std::os::raw::c_uint {
1996 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1997 }
1998 #[inline]
1999 pub fn set_hasSharedInt64Atomics(&mut self, val: ::std::os::raw::c_uint) {
2000 unsafe {
2001 let val: u32 = ::std::mem::transmute(val);
2002 self._bitfield_1.set(6usize, 1u8, val as u64)
2003 }
2004 }
2005 #[inline]
2006 pub fn hasDoubles(&self) -> ::std::os::raw::c_uint {
2007 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2008 }
2009 #[inline]
2010 pub fn set_hasDoubles(&mut self, val: ::std::os::raw::c_uint) {
2011 unsafe {
2012 let val: u32 = ::std::mem::transmute(val);
2013 self._bitfield_1.set(7usize, 1u8, val as u64)
2014 }
2015 }
2016 #[inline]
2017 pub fn hasWarpVote(&self) -> ::std::os::raw::c_uint {
2018 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
2019 }
2020 #[inline]
2021 pub fn set_hasWarpVote(&mut self, val: ::std::os::raw::c_uint) {
2022 unsafe {
2023 let val: u32 = ::std::mem::transmute(val);
2024 self._bitfield_1.set(8usize, 1u8, val as u64)
2025 }
2026 }
2027 #[inline]
2028 pub fn hasWarpBallot(&self) -> ::std::os::raw::c_uint {
2029 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
2030 }
2031 #[inline]
2032 pub fn set_hasWarpBallot(&mut self, val: ::std::os::raw::c_uint) {
2033 unsafe {
2034 let val: u32 = ::std::mem::transmute(val);
2035 self._bitfield_1.set(9usize, 1u8, val as u64)
2036 }
2037 }
2038 #[inline]
2039 pub fn hasWarpShuffle(&self) -> ::std::os::raw::c_uint {
2040 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
2041 }
2042 #[inline]
2043 pub fn set_hasWarpShuffle(&mut self, val: ::std::os::raw::c_uint) {
2044 unsafe {
2045 let val: u32 = ::std::mem::transmute(val);
2046 self._bitfield_1.set(10usize, 1u8, val as u64)
2047 }
2048 }
2049 #[inline]
2050 pub fn hasFunnelShift(&self) -> ::std::os::raw::c_uint {
2051 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
2052 }
2053 #[inline]
2054 pub fn set_hasFunnelShift(&mut self, val: ::std::os::raw::c_uint) {
2055 unsafe {
2056 let val: u32 = ::std::mem::transmute(val);
2057 self._bitfield_1.set(11usize, 1u8, val as u64)
2058 }
2059 }
2060 #[inline]
2061 pub fn hasThreadFenceSystem(&self) -> ::std::os::raw::c_uint {
2062 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
2063 }
2064 #[inline]
2065 pub fn set_hasThreadFenceSystem(&mut self, val: ::std::os::raw::c_uint) {
2066 unsafe {
2067 let val: u32 = ::std::mem::transmute(val);
2068 self._bitfield_1.set(12usize, 1u8, val as u64)
2069 }
2070 }
2071 #[inline]
2072 pub fn hasSyncThreadsExt(&self) -> ::std::os::raw::c_uint {
2073 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2074 }
2075 #[inline]
2076 pub fn set_hasSyncThreadsExt(&mut self, val: ::std::os::raw::c_uint) {
2077 unsafe {
2078 let val: u32 = ::std::mem::transmute(val);
2079 self._bitfield_1.set(13usize, 1u8, val as u64)
2080 }
2081 }
2082 #[inline]
2083 pub fn hasSurfaceFuncs(&self) -> ::std::os::raw::c_uint {
2084 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
2085 }
2086 #[inline]
2087 pub fn set_hasSurfaceFuncs(&mut self, val: ::std::os::raw::c_uint) {
2088 unsafe {
2089 let val: u32 = ::std::mem::transmute(val);
2090 self._bitfield_1.set(14usize, 1u8, val as u64)
2091 }
2092 }
2093 #[inline]
2094 pub fn has3dGrid(&self) -> ::std::os::raw::c_uint {
2095 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
2096 }
2097 #[inline]
2098 pub fn set_has3dGrid(&mut self, val: ::std::os::raw::c_uint) {
2099 unsafe {
2100 let val: u32 = ::std::mem::transmute(val);
2101 self._bitfield_1.set(15usize, 1u8, val as u64)
2102 }
2103 }
2104 #[inline]
2105 pub fn hasDynamicParallelism(&self) -> ::std::os::raw::c_uint {
2106 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2107 }
2108 #[inline]
2109 pub fn set_hasDynamicParallelism(&mut self, val: ::std::os::raw::c_uint) {
2110 unsafe {
2111 let val: u32 = ::std::mem::transmute(val);
2112 self._bitfield_1.set(16usize, 1u8, val as u64)
2113 }
2114 }
2115 #[inline]
2116 pub fn new_bitfield_1(
2117 hasGlobalInt32Atomics: ::std::os::raw::c_uint,
2118 hasGlobalFloatAtomicExch: ::std::os::raw::c_uint,
2119 hasSharedInt32Atomics: ::std::os::raw::c_uint,
2120 hasSharedFloatAtomicExch: ::std::os::raw::c_uint,
2121 hasFloatAtomicAdd: ::std::os::raw::c_uint,
2122 hasGlobalInt64Atomics: ::std::os::raw::c_uint,
2123 hasSharedInt64Atomics: ::std::os::raw::c_uint,
2124 hasDoubles: ::std::os::raw::c_uint,
2125 hasWarpVote: ::std::os::raw::c_uint,
2126 hasWarpBallot: ::std::os::raw::c_uint,
2127 hasWarpShuffle: ::std::os::raw::c_uint,
2128 hasFunnelShift: ::std::os::raw::c_uint,
2129 hasThreadFenceSystem: ::std::os::raw::c_uint,
2130 hasSyncThreadsExt: ::std::os::raw::c_uint,
2131 hasSurfaceFuncs: ::std::os::raw::c_uint,
2132 has3dGrid: ::std::os::raw::c_uint,
2133 hasDynamicParallelism: ::std::os::raw::c_uint,
2134 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
2135 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
2136 __bindgen_bitfield_unit.set(0usize, 1u8, {
2137 let hasGlobalInt32Atomics: u32 =
2138 unsafe { ::std::mem::transmute(hasGlobalInt32Atomics) };
2139 hasGlobalInt32Atomics as u64
2140 });
2141 __bindgen_bitfield_unit.set(1usize, 1u8, {
2142 let hasGlobalFloatAtomicExch: u32 =
2143 unsafe { ::std::mem::transmute(hasGlobalFloatAtomicExch) };
2144 hasGlobalFloatAtomicExch as u64
2145 });
2146 __bindgen_bitfield_unit.set(2usize, 1u8, {
2147 let hasSharedInt32Atomics: u32 =
2148 unsafe { ::std::mem::transmute(hasSharedInt32Atomics) };
2149 hasSharedInt32Atomics as u64
2150 });
2151 __bindgen_bitfield_unit.set(3usize, 1u8, {
2152 let hasSharedFloatAtomicExch: u32 =
2153 unsafe { ::std::mem::transmute(hasSharedFloatAtomicExch) };
2154 hasSharedFloatAtomicExch as u64
2155 });
2156 __bindgen_bitfield_unit.set(4usize, 1u8, {
2157 let hasFloatAtomicAdd: u32 = unsafe { ::std::mem::transmute(hasFloatAtomicAdd) };
2158 hasFloatAtomicAdd as u64
2159 });
2160 __bindgen_bitfield_unit.set(5usize, 1u8, {
2161 let hasGlobalInt64Atomics: u32 =
2162 unsafe { ::std::mem::transmute(hasGlobalInt64Atomics) };
2163 hasGlobalInt64Atomics as u64
2164 });
2165 __bindgen_bitfield_unit.set(6usize, 1u8, {
2166 let hasSharedInt64Atomics: u32 =
2167 unsafe { ::std::mem::transmute(hasSharedInt64Atomics) };
2168 hasSharedInt64Atomics as u64
2169 });
2170 __bindgen_bitfield_unit.set(7usize, 1u8, {
2171 let hasDoubles: u32 = unsafe { ::std::mem::transmute(hasDoubles) };
2172 hasDoubles as u64
2173 });
2174 __bindgen_bitfield_unit.set(8usize, 1u8, {
2175 let hasWarpVote: u32 = unsafe { ::std::mem::transmute(hasWarpVote) };
2176 hasWarpVote as u64
2177 });
2178 __bindgen_bitfield_unit.set(9usize, 1u8, {
2179 let hasWarpBallot: u32 = unsafe { ::std::mem::transmute(hasWarpBallot) };
2180 hasWarpBallot as u64
2181 });
2182 __bindgen_bitfield_unit.set(10usize, 1u8, {
2183 let hasWarpShuffle: u32 = unsafe { ::std::mem::transmute(hasWarpShuffle) };
2184 hasWarpShuffle as u64
2185 });
2186 __bindgen_bitfield_unit.set(11usize, 1u8, {
2187 let hasFunnelShift: u32 = unsafe { ::std::mem::transmute(hasFunnelShift) };
2188 hasFunnelShift as u64
2189 });
2190 __bindgen_bitfield_unit.set(12usize, 1u8, {
2191 let hasThreadFenceSystem: u32 = unsafe { ::std::mem::transmute(hasThreadFenceSystem) };
2192 hasThreadFenceSystem as u64
2193 });
2194 __bindgen_bitfield_unit.set(13usize, 1u8, {
2195 let hasSyncThreadsExt: u32 = unsafe { ::std::mem::transmute(hasSyncThreadsExt) };
2196 hasSyncThreadsExt as u64
2197 });
2198 __bindgen_bitfield_unit.set(14usize, 1u8, {
2199 let hasSurfaceFuncs: u32 = unsafe { ::std::mem::transmute(hasSurfaceFuncs) };
2200 hasSurfaceFuncs as u64
2201 });
2202 __bindgen_bitfield_unit.set(15usize, 1u8, {
2203 let has3dGrid: u32 = unsafe { ::std::mem::transmute(has3dGrid) };
2204 has3dGrid as u64
2205 });
2206 __bindgen_bitfield_unit.set(16usize, 1u8, {
2207 let hasDynamicParallelism: u32 =
2208 unsafe { ::std::mem::transmute(hasDynamicParallelism) };
2209 hasDynamicParallelism as u64
2210 });
2211 __bindgen_bitfield_unit
2212 }
2213}
2214#[repr(C)]
2215#[derive(Debug, Copy, Clone)]
2216pub struct hipUUID_t {
2217 pub bytes: [::std::os::raw::c_char; 16usize],
2218}
2219pub type hipUUID = hipUUID_t;
2220#[doc = " hipDeviceProp\n"]
2221#[repr(C)]
2222#[derive(Debug, Copy, Clone)]
2223pub struct hipDeviceProp_tR0600 {
2224 #[doc = "< Device name."]
2225 pub name: [::std::os::raw::c_char; 256usize],
2226 #[doc = "< UUID of a device"]
2227 pub uuid: hipUUID,
2228 #[doc = "< 8-byte unique identifier. Only valid on windows"]
2229 pub luid: [::std::os::raw::c_char; 8usize],
2230 #[doc = "< LUID node mask"]
2231 pub luidDeviceNodeMask: ::std::os::raw::c_uint,
2232 #[doc = "< Size of global memory region (in bytes)."]
2233 pub totalGlobalMem: usize,
2234 #[doc = "< Size of shared memory per block (in bytes)."]
2235 pub sharedMemPerBlock: usize,
2236 #[doc = "< Registers per block."]
2237 pub regsPerBlock: ::std::os::raw::c_int,
2238 #[doc = "< Warp size."]
2239 pub warpSize: ::std::os::raw::c_int,
2240 #[doc = "< Maximum pitch in bytes allowed by memory copies\n< pitched memory"]
2241 pub memPitch: usize,
2242 #[doc = "< Max work items per work group or workgroup max size."]
2243 pub maxThreadsPerBlock: ::std::os::raw::c_int,
2244 #[doc = "< Max number of threads in each dimension (XYZ) of a block."]
2245 pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
2246 #[doc = "< Max grid dimensions (XYZ)."]
2247 pub maxGridSize: [::std::os::raw::c_int; 3usize],
2248 #[doc = "< Max clock frequency of the multiProcessors in khz."]
2249 pub clockRate: ::std::os::raw::c_int,
2250 #[doc = "< Size of shared constant memory region on the device\n< (in bytes)."]
2251 pub totalConstMem: usize,
2252 #[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."]
2253 pub major: ::std::os::raw::c_int,
2254 #[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."]
2255 pub minor: ::std::os::raw::c_int,
2256 #[doc = "< Alignment requirement for textures"]
2257 pub textureAlignment: usize,
2258 #[doc = "< Pitch alignment requirement for texture references bound to"]
2259 pub texturePitchAlignment: usize,
2260 #[doc = "< Deprecated. Use asyncEngineCount instead"]
2261 pub deviceOverlap: ::std::os::raw::c_int,
2262 #[doc = "< Number of multi-processors (compute units)."]
2263 pub multiProcessorCount: ::std::os::raw::c_int,
2264 #[doc = "< Run time limit for kernels executed on the device"]
2265 pub kernelExecTimeoutEnabled: ::std::os::raw::c_int,
2266 #[doc = "< APU vs dGPU"]
2267 pub integrated: ::std::os::raw::c_int,
2268 #[doc = "< Check whether HIP can map host memory"]
2269 pub canMapHostMemory: ::std::os::raw::c_int,
2270 #[doc = "< Compute mode."]
2271 pub computeMode: ::std::os::raw::c_int,
2272 #[doc = "< Maximum number of elements in 1D images"]
2273 pub maxTexture1D: ::std::os::raw::c_int,
2274 #[doc = "< Maximum 1D mipmap texture size"]
2275 pub maxTexture1DMipmap: ::std::os::raw::c_int,
2276 #[doc = "< Maximum size for 1D textures bound to linear memory"]
2277 pub maxTexture1DLinear: ::std::os::raw::c_int,
2278 #[doc = "< Maximum dimensions (width, height) of 2D images, in image elements"]
2279 pub maxTexture2D: [::std::os::raw::c_int; 2usize],
2280 #[doc = "< Maximum number of elements in 2D array mipmap of images"]
2281 pub maxTexture2DMipmap: [::std::os::raw::c_int; 2usize],
2282 #[doc = "< Maximum 2D tex dimensions if tex are bound to pitched memory"]
2283 pub maxTexture2DLinear: [::std::os::raw::c_int; 3usize],
2284 #[doc = "< Maximum 2D tex dimensions if gather has to be performed"]
2285 pub maxTexture2DGather: [::std::os::raw::c_int; 2usize],
2286 #[doc = "< Maximum dimensions (width, height, depth) of 3D images, in image\n< elements"]
2287 pub maxTexture3D: [::std::os::raw::c_int; 3usize],
2288 #[doc = "< Maximum alternate 3D texture dims"]
2289 pub maxTexture3DAlt: [::std::os::raw::c_int; 3usize],
2290 #[doc = "< Maximum cubemap texture dims"]
2291 pub maxTextureCubemap: ::std::os::raw::c_int,
2292 #[doc = "< Maximum number of elements in 1D array images"]
2293 pub maxTexture1DLayered: [::std::os::raw::c_int; 2usize],
2294 #[doc = "< Maximum number of elements in 2D array images"]
2295 pub maxTexture2DLayered: [::std::os::raw::c_int; 3usize],
2296 #[doc = "< Maximum cubemaps layered texture dims"]
2297 pub maxTextureCubemapLayered: [::std::os::raw::c_int; 2usize],
2298 #[doc = "< Maximum 1D surface size"]
2299 pub maxSurface1D: ::std::os::raw::c_int,
2300 #[doc = "< Maximum 2D surface size"]
2301 pub maxSurface2D: [::std::os::raw::c_int; 2usize],
2302 #[doc = "< Maximum 3D surface size"]
2303 pub maxSurface3D: [::std::os::raw::c_int; 3usize],
2304 #[doc = "< Maximum 1D layered surface size"]
2305 pub maxSurface1DLayered: [::std::os::raw::c_int; 2usize],
2306 #[doc = "< Maximum 2D layared surface size"]
2307 pub maxSurface2DLayered: [::std::os::raw::c_int; 3usize],
2308 #[doc = "< Maximum cubemap surface size"]
2309 pub maxSurfaceCubemap: ::std::os::raw::c_int,
2310 #[doc = "< Maximum cubemap layered surface size"]
2311 pub maxSurfaceCubemapLayered: [::std::os::raw::c_int; 2usize],
2312 #[doc = "< Alignment requirement for surface"]
2313 pub surfaceAlignment: usize,
2314 #[doc = "< Device can possibly execute multiple kernels concurrently."]
2315 pub concurrentKernels: ::std::os::raw::c_int,
2316 #[doc = "< Device has ECC support enabled"]
2317 pub ECCEnabled: ::std::os::raw::c_int,
2318 #[doc = "< PCI Bus ID."]
2319 pub pciBusID: ::std::os::raw::c_int,
2320 #[doc = "< PCI Device ID."]
2321 pub pciDeviceID: ::std::os::raw::c_int,
2322 #[doc = "< PCI Domain ID"]
2323 pub pciDomainID: ::std::os::raw::c_int,
2324 #[doc = "< 1:If device is Tesla device using TCC driver, else 0"]
2325 pub tccDriver: ::std::os::raw::c_int,
2326 #[doc = "< Number of async engines"]
2327 pub asyncEngineCount: ::std::os::raw::c_int,
2328 #[doc = "< Does device and host share unified address space"]
2329 pub unifiedAddressing: ::std::os::raw::c_int,
2330 #[doc = "< Max global memory clock frequency in khz."]
2331 pub memoryClockRate: ::std::os::raw::c_int,
2332 #[doc = "< Global memory bus width in bits."]
2333 pub memoryBusWidth: ::std::os::raw::c_int,
2334 #[doc = "< L2 cache size."]
2335 pub l2CacheSize: ::std::os::raw::c_int,
2336 #[doc = "< Device's max L2 persisting lines in bytes"]
2337 pub persistingL2CacheMaxSize: ::std::os::raw::c_int,
2338 #[doc = "< Maximum resident threads per multi-processor."]
2339 pub maxThreadsPerMultiProcessor: ::std::os::raw::c_int,
2340 #[doc = "< Device supports stream priority"]
2341 pub streamPrioritiesSupported: ::std::os::raw::c_int,
2342 #[doc = "< Indicates globals are cached in L1"]
2343 pub globalL1CacheSupported: ::std::os::raw::c_int,
2344 #[doc = "< Locals are cahced in L1"]
2345 pub localL1CacheSupported: ::std::os::raw::c_int,
2346 #[doc = "< Amount of shared memory available per multiprocessor."]
2347 pub sharedMemPerMultiprocessor: usize,
2348 #[doc = "< registers available per multiprocessor"]
2349 pub regsPerMultiprocessor: ::std::os::raw::c_int,
2350 #[doc = "< Device supports allocating managed memory on this system"]
2351 pub managedMemory: ::std::os::raw::c_int,
2352 #[doc = "< 1 if device is on a multi-GPU board, 0 if not."]
2353 pub isMultiGpuBoard: ::std::os::raw::c_int,
2354 #[doc = "< Unique identifier for a group of devices on same multiboard GPU"]
2355 pub multiGpuBoardGroupID: ::std::os::raw::c_int,
2356 #[doc = "< Link between host and device supports native atomics"]
2357 pub hostNativeAtomicSupported: ::std::os::raw::c_int,
2358 #[doc = "< Deprecated. CUDA only."]
2359 pub singleToDoublePrecisionPerfRatio: ::std::os::raw::c_int,
2360 #[doc = "< Device supports coherently accessing pageable memory\n< without calling hipHostRegister on it"]
2361 pub pageableMemoryAccess: ::std::os::raw::c_int,
2362 #[doc = "< Device can coherently access managed memory concurrently with\n< the CPU"]
2363 pub concurrentManagedAccess: ::std::os::raw::c_int,
2364 #[doc = "< Is compute preemption supported on the device"]
2365 pub computePreemptionSupported: ::std::os::raw::c_int,
2366 #[doc = "< Device can access host registered memory with same\n< address as the host"]
2367 pub canUseHostPointerForRegisteredMem: ::std::os::raw::c_int,
2368 #[doc = "< HIP device supports cooperative launch"]
2369 pub cooperativeLaunch: ::std::os::raw::c_int,
2370 #[doc = "< HIP device supports cooperative launch on multiple\n< devices"]
2371 pub cooperativeMultiDeviceLaunch: ::std::os::raw::c_int,
2372 #[doc = "< Per device m ax shared mem per block usable by special opt in"]
2373 pub sharedMemPerBlockOptin: usize,
2374 #[doc = "< Device accesses pageable memory via the host's\n< page tables"]
2375 pub pageableMemoryAccessUsesHostPageTables: ::std::os::raw::c_int,
2376 #[doc = "< Host can directly access managed memory on the device\n< without migration"]
2377 pub directManagedMemAccessFromHost: ::std::os::raw::c_int,
2378 #[doc = "< Max number of blocks on CU"]
2379 pub maxBlocksPerMultiProcessor: ::std::os::raw::c_int,
2380 #[doc = "< Max value of access policy window"]
2381 pub accessPolicyMaxWindowSize: ::std::os::raw::c_int,
2382 #[doc = "< Shared memory reserved by driver per block"]
2383 pub reservedSharedMemPerBlock: usize,
2384 #[doc = "< Device supports hipHostRegister"]
2385 pub hostRegisterSupported: ::std::os::raw::c_int,
2386 #[doc = "< Indicates if device supports sparse hip arrays"]
2387 pub sparseHipArraySupported: ::std::os::raw::c_int,
2388 #[doc = "< Device supports using the hipHostRegisterReadOnly flag\n< with hipHostRegistger"]
2389 pub hostRegisterReadOnlySupported: ::std::os::raw::c_int,
2390 #[doc = "< Indicates external timeline semaphore support"]
2391 pub timelineSemaphoreInteropSupported: ::std::os::raw::c_int,
2392 #[doc = "< Indicates if device supports hipMallocAsync and hipMemPool APIs"]
2393 pub memoryPoolsSupported: ::std::os::raw::c_int,
2394 #[doc = "< Indicates device support of RDMA APIs"]
2395 pub gpuDirectRDMASupported: ::std::os::raw::c_int,
2396 #[doc = "< Bitmask to be interpreted according to\n< hipFlushGPUDirectRDMAWritesOptions"]
2397 pub gpuDirectRDMAFlushWritesOptions: ::std::os::raw::c_uint,
2398 #[doc = "< value of hipGPUDirectRDMAWritesOrdering"]
2399 pub gpuDirectRDMAWritesOrdering: ::std::os::raw::c_int,
2400 #[doc = "< Bitmask of handle types support with mempool based IPC"]
2401 pub memoryPoolSupportedHandleTypes: ::std::os::raw::c_uint,
2402 #[doc = "< Device supports deferred mapping HIP arrays and HIP\n< mipmapped arrays"]
2403 pub deferredMappingHipArraySupported: ::std::os::raw::c_int,
2404 #[doc = "< Device supports IPC events"]
2405 pub ipcEventSupported: ::std::os::raw::c_int,
2406 #[doc = "< Device supports cluster launch"]
2407 pub clusterLaunch: ::std::os::raw::c_int,
2408 #[doc = "< Indicates device supports unified function pointers"]
2409 pub unifiedFunctionPointers: ::std::os::raw::c_int,
2410 #[doc = "< CUDA Reserved."]
2411 pub reserved: [::std::os::raw::c_int; 63usize],
2412 #[doc = "< Reserved for adding new entries for HIP/CUDA."]
2413 pub hipReserved: [::std::os::raw::c_int; 32usize],
2414 #[doc = "< AMD GCN Arch Name. HIP Only."]
2415 pub gcnArchName: [::std::os::raw::c_char; 256usize],
2416 #[doc = "< Maximum Shared Memory Per CU. HIP Only."]
2417 pub maxSharedMemoryPerMultiProcessor: usize,
2418 #[doc = "< Frequency in khz of the timer used by the device-side \"clock*\"\n< instructions. New for HIP."]
2419 pub clockInstructionRate: ::std::os::raw::c_int,
2420 #[doc = "< Architectural feature flags. New for HIP."]
2421 pub arch: hipDeviceArch_t,
2422 #[doc = "< Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register"]
2423 pub hdpMemFlushCntl: *mut ::std::os::raw::c_uint,
2424 #[doc = "< Addres of HDP_REG_COHERENCY_FLUSH_CNTL register"]
2425 pub hdpRegFlushCntl: *mut ::std::os::raw::c_uint,
2426 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2427 pub cooperativeMultiDeviceUnmatchedFunc: ::std::os::raw::c_int,
2428 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2429 pub cooperativeMultiDeviceUnmatchedGridDim: ::std::os::raw::c_int,
2430 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2431 pub cooperativeMultiDeviceUnmatchedBlockDim: ::std::os::raw::c_int,
2432 #[doc = "< HIP device supports cooperative launch on\n< multiple"]
2433 pub cooperativeMultiDeviceUnmatchedSharedMem: ::std::os::raw::c_int,
2434 #[doc = "< 1: if it is a large PCI bar device, else 0"]
2435 pub isLargeBar: ::std::os::raw::c_int,
2436 #[doc = "< Revision of the GPU in this device"]
2437 pub asicRevision: ::std::os::raw::c_int,
2438}
2439#[doc = "< Unregistered memory"]
2440pub const hipMemoryType_hipMemoryTypeUnregistered: hipMemoryType = 0;
2441#[doc = "< Memory is physically located on host"]
2442pub const hipMemoryType_hipMemoryTypeHost: hipMemoryType = 1;
2443#[doc = "< Memory is physically located on device. (see deviceId for\n< specific device)"]
2444pub const hipMemoryType_hipMemoryTypeDevice: hipMemoryType = 2;
2445#[doc = "< Managed memory, automaticallly managed by the unified\n< memory system\n< place holder for new values."]
2446pub const hipMemoryType_hipMemoryTypeManaged: hipMemoryType = 3;
2447#[doc = "< Array memory, physically located on device. (see deviceId for\n< specific device)"]
2448pub const hipMemoryType_hipMemoryTypeArray: hipMemoryType = 10;
2449#[doc = "< unified address space"]
2450pub const hipMemoryType_hipMemoryTypeUnified: hipMemoryType = 11;
2451#[doc = " hipMemoryType (for pointer attributes)\n\n @note hipMemoryType enum values are combination of cudaMemoryType and cuMemoryType and AMD specific enum values.\n"]
2452pub type hipMemoryType = ::std::os::raw::c_uint;
2453#[doc = " Pointer attributes"]
2454#[repr(C)]
2455#[derive(Debug, Copy, Clone)]
2456pub struct hipPointerAttribute_t {
2457 pub type_: hipMemoryType,
2458 pub device: ::std::os::raw::c_int,
2459 pub devicePointer: *mut ::std::os::raw::c_void,
2460 pub hostPointer: *mut ::std::os::raw::c_void,
2461 pub isManaged: ::std::os::raw::c_int,
2462 pub allocationFlags: ::std::os::raw::c_uint,
2463}
2464#[doc = "< Successful completion."]
2465pub const hipError_t_hipSuccess: hipError_t = 0;
2466#[doc = "< One or more of the parameters passed to the API call is NULL\n< or not in an acceptable range."]
2467pub const hipError_t_hipErrorInvalidValue: hipError_t = 1;
2468#[doc = "< out of memory range."]
2469pub const hipError_t_hipErrorOutOfMemory: hipError_t = 2;
2470#[doc = "< Memory allocation error."]
2471pub const hipError_t_hipErrorMemoryAllocation: hipError_t = 2;
2472#[doc = "< Invalid not initialized"]
2473pub const hipError_t_hipErrorNotInitialized: hipError_t = 3;
2474pub const hipError_t_hipErrorInitializationError: hipError_t = 3;
2475#[doc = "< Deinitialized"]
2476pub const hipError_t_hipErrorDeinitialized: hipError_t = 4;
2477pub const hipError_t_hipErrorProfilerDisabled: hipError_t = 5;
2478pub const hipError_t_hipErrorProfilerNotInitialized: hipError_t = 6;
2479pub const hipError_t_hipErrorProfilerAlreadyStarted: hipError_t = 7;
2480pub const hipError_t_hipErrorProfilerAlreadyStopped: hipError_t = 8;
2481#[doc = "< Invalide configuration"]
2482pub const hipError_t_hipErrorInvalidConfiguration: hipError_t = 9;
2483#[doc = "< Invalid pitch value"]
2484pub const hipError_t_hipErrorInvalidPitchValue: hipError_t = 12;
2485#[doc = "< Invalid symbol"]
2486pub const hipError_t_hipErrorInvalidSymbol: hipError_t = 13;
2487#[doc = "< Invalid Device Pointer"]
2488pub const hipError_t_hipErrorInvalidDevicePointer: hipError_t = 17;
2489#[doc = "< Invalid memory copy direction"]
2490pub const hipError_t_hipErrorInvalidMemcpyDirection: hipError_t = 21;
2491pub const hipError_t_hipErrorInsufficientDriver: hipError_t = 35;
2492pub const hipError_t_hipErrorMissingConfiguration: hipError_t = 52;
2493pub const hipError_t_hipErrorPriorLaunchFailure: hipError_t = 53;
2494#[doc = "< Invalid device function"]
2495pub const hipError_t_hipErrorInvalidDeviceFunction: hipError_t = 98;
2496#[doc = "< Call to hipGetDeviceCount returned 0 devices"]
2497pub const hipError_t_hipErrorNoDevice: hipError_t = 100;
2498#[doc = "< DeviceID must be in range from 0 to compute-devices."]
2499pub const hipError_t_hipErrorInvalidDevice: hipError_t = 101;
2500#[doc = "< Invalid image"]
2501pub const hipError_t_hipErrorInvalidImage: hipError_t = 200;
2502#[doc = "< Produced when input context is invalid."]
2503pub const hipError_t_hipErrorInvalidContext: hipError_t = 201;
2504pub const hipError_t_hipErrorContextAlreadyCurrent: hipError_t = 202;
2505pub const hipError_t_hipErrorMapFailed: hipError_t = 205;
2506#[doc = "< Produced when the IPC memory attach failed from ROCr."]
2507pub const hipError_t_hipErrorMapBufferObjectFailed: hipError_t = 205;
2508pub const hipError_t_hipErrorUnmapFailed: hipError_t = 206;
2509pub const hipError_t_hipErrorArrayIsMapped: hipError_t = 207;
2510pub const hipError_t_hipErrorAlreadyMapped: hipError_t = 208;
2511pub const hipError_t_hipErrorNoBinaryForGpu: hipError_t = 209;
2512pub const hipError_t_hipErrorAlreadyAcquired: hipError_t = 210;
2513pub const hipError_t_hipErrorNotMapped: hipError_t = 211;
2514pub const hipError_t_hipErrorNotMappedAsArray: hipError_t = 212;
2515pub const hipError_t_hipErrorNotMappedAsPointer: hipError_t = 213;
2516pub const hipError_t_hipErrorECCNotCorrectable: hipError_t = 214;
2517#[doc = "< Unsupported limit"]
2518pub const hipError_t_hipErrorUnsupportedLimit: hipError_t = 215;
2519#[doc = "< The context is already in use"]
2520pub const hipError_t_hipErrorContextAlreadyInUse: hipError_t = 216;
2521pub const hipError_t_hipErrorPeerAccessUnsupported: hipError_t = 217;
2522#[doc = "< In CUDA DRV, it is CUDA_ERROR_INVALID_PTX"]
2523pub const hipError_t_hipErrorInvalidKernelFile: hipError_t = 218;
2524pub const hipError_t_hipErrorInvalidGraphicsContext: hipError_t = 219;
2525#[doc = "< Invalid source."]
2526pub const hipError_t_hipErrorInvalidSource: hipError_t = 300;
2527#[doc = "< the file is not found."]
2528pub const hipError_t_hipErrorFileNotFound: hipError_t = 301;
2529pub const hipError_t_hipErrorSharedObjectSymbolNotFound: hipError_t = 302;
2530#[doc = "< Failed to initialize shared object."]
2531pub const hipError_t_hipErrorSharedObjectInitFailed: hipError_t = 303;
2532#[doc = "< Not the correct operating system"]
2533pub const hipError_t_hipErrorOperatingSystem: hipError_t = 304;
2534#[doc = "< Invalide handle"]
2535pub const hipError_t_hipErrorInvalidHandle: hipError_t = 400;
2536#[doc = "< Resource handle (hipEvent_t or hipStream_t) invalid."]
2537pub const hipError_t_hipErrorInvalidResourceHandle: hipError_t = 400;
2538#[doc = "< Resource required is not in a valid state to perform operation."]
2539pub const hipError_t_hipErrorIllegalState: hipError_t = 401;
2540#[doc = "< Not found"]
2541pub const hipError_t_hipErrorNotFound: hipError_t = 500;
2542#[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."]
2543pub const hipError_t_hipErrorNotReady: hipError_t = 600;
2544pub const hipError_t_hipErrorIllegalAddress: hipError_t = 700;
2545#[doc = "< Out of resources error."]
2546pub const hipError_t_hipErrorLaunchOutOfResources: hipError_t = 701;
2547#[doc = "< Timeout for the launch."]
2548pub const hipError_t_hipErrorLaunchTimeOut: hipError_t = 702;
2549#[doc = "< Peer access was already enabled from the current\n< device."]
2550pub const hipError_t_hipErrorPeerAccessAlreadyEnabled: hipError_t = 704;
2551#[doc = "< Peer access was never enabled from the current device."]
2552pub const hipError_t_hipErrorPeerAccessNotEnabled: hipError_t = 705;
2553#[doc = "< The process is active."]
2554pub const hipError_t_hipErrorSetOnActiveProcess: hipError_t = 708;
2555#[doc = "< The context is already destroyed"]
2556pub const hipError_t_hipErrorContextIsDestroyed: hipError_t = 709;
2557#[doc = "< Produced when the kernel calls assert."]
2558pub const hipError_t_hipErrorAssert: hipError_t = 710;
2559#[doc = "< Produced when trying to lock a page-locked\n< memory."]
2560pub const hipError_t_hipErrorHostMemoryAlreadyRegistered: hipError_t = 712;
2561#[doc = "< Produced when trying to unlock a non-page-locked\n< memory."]
2562pub const hipError_t_hipErrorHostMemoryNotRegistered: hipError_t = 713;
2563#[doc = "< An exception occurred on the device while executing a kernel."]
2564pub const hipError_t_hipErrorLaunchFailure: hipError_t = 719;
2565#[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."]
2566pub const hipError_t_hipErrorCooperativeLaunchTooLarge: hipError_t = 720;
2567#[doc = "< Produced when the hip API is not supported/implemented"]
2568pub const hipError_t_hipErrorNotSupported: hipError_t = 801;
2569#[doc = "< The operation is not permitted when the stream\n< is capturing."]
2570pub const hipError_t_hipErrorStreamCaptureUnsupported: hipError_t = 900;
2571#[doc = "< The current capture sequence on the stream\n< has been invalidated due to a previous error."]
2572pub const hipError_t_hipErrorStreamCaptureInvalidated: hipError_t = 901;
2573#[doc = "< The operation would have resulted in a merge of\n< two independent capture sequences."]
2574pub const hipError_t_hipErrorStreamCaptureMerge: hipError_t = 902;
2575#[doc = "< The capture was not initiated in this stream."]
2576pub const hipError_t_hipErrorStreamCaptureUnmatched: hipError_t = 903;
2577#[doc = "< The capture sequence contains a fork that was not\n< joined to the primary stream."]
2578pub const hipError_t_hipErrorStreamCaptureUnjoined: hipError_t = 904;
2579#[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"]
2580pub const hipError_t_hipErrorStreamCaptureIsolation: hipError_t = 905;
2581#[doc = "< The operation would have resulted in a disallowed\n< implicit dependency on a current capture sequence\n< from hipStreamLegacy."]
2582pub const hipError_t_hipErrorStreamCaptureImplicit: hipError_t = 906;
2583#[doc = "< The operation is not permitted on an event which was last\n< recorded in a capturing stream."]
2584pub const hipError_t_hipErrorCapturedEvent: hipError_t = 907;
2585#[doc = "< A stream capture sequence not initiated with\n< the hipStreamCaptureModeRelaxed argument to\n< hipStreamBeginCapture was passed to\n< hipStreamEndCapture in a different thread."]
2586pub const hipError_t_hipErrorStreamCaptureWrongThread: hipError_t = 908;
2587#[doc = "< This error indicates that the graph update\n< not performed because it included changes which\n< violated constraintsspecific to instantiated graph\n< update."]
2588pub const hipError_t_hipErrorGraphExecUpdateFailure: hipError_t = 910;
2589#[doc = "< Invalid channel descriptor."]
2590pub const hipError_t_hipErrorInvalidChannelDescriptor: hipError_t = 911;
2591#[doc = "< Invalid texture."]
2592pub const hipError_t_hipErrorInvalidTexture: hipError_t = 912;
2593#[doc = "< Unknown error."]
2594pub const hipError_t_hipErrorUnknown: hipError_t = 999;
2595#[doc = "< HSA runtime memory call returned error. Typically not seen\n< in production systems."]
2596pub const hipError_t_hipErrorRuntimeMemory: hipError_t = 1052;
2597#[doc = "< HSA runtime call other than memory returned error. Typically\n< not seen in production systems."]
2598pub const hipError_t_hipErrorRuntimeOther: hipError_t = 1053;
2599#[doc = "< Marker that more error codes are needed."]
2600pub const hipError_t_hipErrorTbd: hipError_t = 1054;
2601#[doc = " HIP error type\n"]
2602pub type hipError_t = ::std::os::raw::c_uint;
2603pub const hipDeviceAttribute_t_hipDeviceAttributeCudaCompatibleBegin: hipDeviceAttribute_t = 0;
2604#[doc = "< Whether ECC support is enabled."]
2605pub const hipDeviceAttribute_t_hipDeviceAttributeEccEnabled: hipDeviceAttribute_t = 0;
2606#[doc = "< Cuda only. The maximum size of the window policy in bytes."]
2607pub const hipDeviceAttribute_t_hipDeviceAttributeAccessPolicyMaxWindowSize: hipDeviceAttribute_t =
2608 1;
2609#[doc = "< Asynchronous engines number."]
2610pub const hipDeviceAttribute_t_hipDeviceAttributeAsyncEngineCount: hipDeviceAttribute_t = 2;
2611#[doc = "< Whether host memory can be mapped into device address space"]
2612pub const hipDeviceAttribute_t_hipDeviceAttributeCanMapHostMemory: hipDeviceAttribute_t = 3;
2613#[doc = "< Device can access host registered memory\n< at the same virtual address as the CPU"]
2614pub const hipDeviceAttribute_t_hipDeviceAttributeCanUseHostPointerForRegisteredMem:
2615 hipDeviceAttribute_t = 4;
2616#[doc = "< Peak clock frequency in kilohertz."]
2617pub const hipDeviceAttribute_t_hipDeviceAttributeClockRate: hipDeviceAttribute_t = 5;
2618#[doc = "< Compute mode that device is currently in."]
2619pub const hipDeviceAttribute_t_hipDeviceAttributeComputeMode: hipDeviceAttribute_t = 6;
2620#[doc = "< Device supports Compute Preemption."]
2621pub const hipDeviceAttribute_t_hipDeviceAttributeComputePreemptionSupported: hipDeviceAttribute_t =
2622 7;
2623#[doc = "< Device can possibly execute multiple kernels concurrently."]
2624pub const hipDeviceAttribute_t_hipDeviceAttributeConcurrentKernels: hipDeviceAttribute_t = 8;
2625#[doc = "< Device can coherently access managed memory concurrently with the CPU"]
2626pub const hipDeviceAttribute_t_hipDeviceAttributeConcurrentManagedAccess: hipDeviceAttribute_t = 9;
2627#[doc = "< Support cooperative launch"]
2628pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeLaunch: hipDeviceAttribute_t = 10;
2629#[doc = "< Support cooperative launch on multiple devices"]
2630pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceLaunch:
2631 hipDeviceAttribute_t = 11;
2632#[doc = "< Device can concurrently copy memory and execute a kernel.\n< Deprecated. Use instead asyncEngineCount."]
2633pub const hipDeviceAttribute_t_hipDeviceAttributeDeviceOverlap: hipDeviceAttribute_t = 12;
2634#[doc = "< Host can directly access managed memory on\n< the device without migration"]
2635pub const hipDeviceAttribute_t_hipDeviceAttributeDirectManagedMemAccessFromHost:
2636 hipDeviceAttribute_t = 13;
2637#[doc = "< Device supports caching globals in L1"]
2638pub const hipDeviceAttribute_t_hipDeviceAttributeGlobalL1CacheSupported: hipDeviceAttribute_t = 14;
2639#[doc = "< Link between the device and the host supports native atomic operations"]
2640pub const hipDeviceAttribute_t_hipDeviceAttributeHostNativeAtomicSupported: hipDeviceAttribute_t =
2641 15;
2642#[doc = "< Device is integrated GPU"]
2643pub const hipDeviceAttribute_t_hipDeviceAttributeIntegrated: hipDeviceAttribute_t = 16;
2644#[doc = "< Multiple GPU devices."]
2645pub const hipDeviceAttribute_t_hipDeviceAttributeIsMultiGpuBoard: hipDeviceAttribute_t = 17;
2646#[doc = "< Run time limit for kernels executed on the device"]
2647pub const hipDeviceAttribute_t_hipDeviceAttributeKernelExecTimeout: hipDeviceAttribute_t = 18;
2648#[doc = "< Size of L2 cache in bytes. 0 if the device doesn't have L2 cache."]
2649pub const hipDeviceAttribute_t_hipDeviceAttributeL2CacheSize: hipDeviceAttribute_t = 19;
2650#[doc = "< caching locals in L1 is supported"]
2651pub const hipDeviceAttribute_t_hipDeviceAttributeLocalL1CacheSupported: hipDeviceAttribute_t = 20;
2652#[doc = "< 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms"]
2653pub const hipDeviceAttribute_t_hipDeviceAttributeLuid: hipDeviceAttribute_t = 21;
2654#[doc = "< Luid device node mask. Undefined on TCC and non-Windows platforms"]
2655pub const hipDeviceAttribute_t_hipDeviceAttributeLuidDeviceNodeMask: hipDeviceAttribute_t = 22;
2656#[doc = "< Major compute capability version number."]
2657pub const hipDeviceAttribute_t_hipDeviceAttributeComputeCapabilityMajor: hipDeviceAttribute_t = 23;
2658#[doc = "< Device supports allocating managed memory on this system"]
2659pub const hipDeviceAttribute_t_hipDeviceAttributeManagedMemory: hipDeviceAttribute_t = 24;
2660#[doc = "< Max block size per multiprocessor"]
2661pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlocksPerMultiProcessor: hipDeviceAttribute_t =
2662 25;
2663#[doc = "< Max block size in width."]
2664pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlockDimX: hipDeviceAttribute_t = 26;
2665#[doc = "< Max block size in height."]
2666pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlockDimY: hipDeviceAttribute_t = 27;
2667#[doc = "< Max block size in depth."]
2668pub const hipDeviceAttribute_t_hipDeviceAttributeMaxBlockDimZ: hipDeviceAttribute_t = 28;
2669#[doc = "< Max grid size in width."]
2670pub const hipDeviceAttribute_t_hipDeviceAttributeMaxGridDimX: hipDeviceAttribute_t = 29;
2671#[doc = "< Max grid size in height."]
2672pub const hipDeviceAttribute_t_hipDeviceAttributeMaxGridDimY: hipDeviceAttribute_t = 30;
2673#[doc = "< Max grid size in depth."]
2674pub const hipDeviceAttribute_t_hipDeviceAttributeMaxGridDimZ: hipDeviceAttribute_t = 31;
2675#[doc = "< Maximum size of 1D surface."]
2676pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface1D: hipDeviceAttribute_t = 32;
2677#[doc = "< Cuda only. Maximum dimensions of 1D layered surface."]
2678pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface1DLayered: hipDeviceAttribute_t = 33;
2679#[doc = "< Maximum dimension (width, height) of 2D surface."]
2680pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface2D: hipDeviceAttribute_t = 34;
2681#[doc = "< Cuda only. Maximum dimensions of 2D layered surface."]
2682pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface2DLayered: hipDeviceAttribute_t = 35;
2683#[doc = "< Maximum dimension (width, height, depth) of 3D surface."]
2684pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurface3D: hipDeviceAttribute_t = 36;
2685#[doc = "< Cuda only. Maximum dimensions of Cubemap surface."]
2686pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurfaceCubemap: hipDeviceAttribute_t = 37;
2687#[doc = "< Cuda only. Maximum dimension of Cubemap layered surface."]
2688pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSurfaceCubemapLayered: hipDeviceAttribute_t =
2689 38;
2690#[doc = "< Maximum size of 1D texture."]
2691pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DWidth: hipDeviceAttribute_t = 39;
2692#[doc = "< Maximum dimensions of 1D layered texture."]
2693pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DLayered: hipDeviceAttribute_t = 40;
2694#[doc = "< Maximum number of elements allocatable in a 1D linear texture.\n< Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda."]
2695pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DLinear: hipDeviceAttribute_t = 41;
2696#[doc = "< Maximum size of 1D mipmapped texture."]
2697pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture1DMipmap: hipDeviceAttribute_t = 42;
2698#[doc = "< Maximum dimension width of 2D texture."]
2699pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DWidth: hipDeviceAttribute_t = 43;
2700#[doc = "< Maximum dimension hight of 2D texture."]
2701pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DHeight: hipDeviceAttribute_t = 44;
2702#[doc = "< Maximum dimensions of 2D texture if gather operations performed."]
2703pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DGather: hipDeviceAttribute_t = 45;
2704#[doc = "< Maximum dimensions of 2D layered texture."]
2705pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DLayered: hipDeviceAttribute_t = 46;
2706#[doc = "< Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory."]
2707pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DLinear: hipDeviceAttribute_t = 47;
2708#[doc = "< Maximum dimensions of 2D mipmapped texture."]
2709pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture2DMipmap: hipDeviceAttribute_t = 48;
2710#[doc = "< Maximum dimension width of 3D texture."]
2711pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DWidth: hipDeviceAttribute_t = 49;
2712#[doc = "< Maximum dimension height of 3D texture."]
2713pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DHeight: hipDeviceAttribute_t = 50;
2714#[doc = "< Maximum dimension depth of 3D texture."]
2715pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DDepth: hipDeviceAttribute_t = 51;
2716#[doc = "< Maximum dimensions of alternate 3D texture."]
2717pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTexture3DAlt: hipDeviceAttribute_t = 52;
2718#[doc = "< Maximum dimensions of Cubemap texture"]
2719pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTextureCubemap: hipDeviceAttribute_t = 53;
2720#[doc = "< Maximum dimensions of Cubemap layered texture."]
2721pub const hipDeviceAttribute_t_hipDeviceAttributeMaxTextureCubemapLayered: hipDeviceAttribute_t =
2722 54;
2723#[doc = "< Maximum dimension of a block"]
2724pub const hipDeviceAttribute_t_hipDeviceAttributeMaxThreadsDim: hipDeviceAttribute_t = 55;
2725#[doc = "< Maximum number of threads per block."]
2726pub const hipDeviceAttribute_t_hipDeviceAttributeMaxThreadsPerBlock: hipDeviceAttribute_t = 56;
2727#[doc = "< Maximum resident threads per multiprocessor."]
2728pub const hipDeviceAttribute_t_hipDeviceAttributeMaxThreadsPerMultiProcessor: hipDeviceAttribute_t =
2729 57;
2730#[doc = "< Maximum pitch in bytes allowed by memory copies"]
2731pub const hipDeviceAttribute_t_hipDeviceAttributeMaxPitch: hipDeviceAttribute_t = 58;
2732#[doc = "< Global memory bus width in bits."]
2733pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryBusWidth: hipDeviceAttribute_t = 59;
2734#[doc = "< Peak memory clock frequency in kilohertz."]
2735pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryClockRate: hipDeviceAttribute_t = 60;
2736#[doc = "< Minor compute capability version number."]
2737pub const hipDeviceAttribute_t_hipDeviceAttributeComputeCapabilityMinor: hipDeviceAttribute_t = 61;
2738#[doc = "< Unique ID of device group on the same multi-GPU board"]
2739pub const hipDeviceAttribute_t_hipDeviceAttributeMultiGpuBoardGroupID: hipDeviceAttribute_t = 62;
2740#[doc = "< Number of multiprocessors on the device."]
2741pub const hipDeviceAttribute_t_hipDeviceAttributeMultiprocessorCount: hipDeviceAttribute_t = 63;
2742#[doc = "< Previously hipDeviceAttributeName"]
2743pub const hipDeviceAttribute_t_hipDeviceAttributeUnused1: hipDeviceAttribute_t = 64;
2744#[doc = "< Device supports coherently accessing pageable memory\n< without calling hipHostRegister on it"]
2745pub const hipDeviceAttribute_t_hipDeviceAttributePageableMemoryAccess: hipDeviceAttribute_t = 65;
2746#[doc = "< Device accesses pageable memory via the host's page tables"]
2747pub const hipDeviceAttribute_t_hipDeviceAttributePageableMemoryAccessUsesHostPageTables:
2748 hipDeviceAttribute_t = 66;
2749#[doc = "< PCI Bus ID."]
2750pub const hipDeviceAttribute_t_hipDeviceAttributePciBusId: hipDeviceAttribute_t = 67;
2751#[doc = "< PCI Device ID."]
2752pub const hipDeviceAttribute_t_hipDeviceAttributePciDeviceId: hipDeviceAttribute_t = 68;
2753#[doc = "< PCI Domain ID."]
2754pub const hipDeviceAttribute_t_hipDeviceAttributePciDomainID: hipDeviceAttribute_t = 69;
2755#[doc = "< Maximum l2 persisting lines capacity in bytes"]
2756pub const hipDeviceAttribute_t_hipDeviceAttributePersistingL2CacheMaxSize: hipDeviceAttribute_t =
2757 70;
2758#[doc = "< 32-bit registers available to a thread block. This number is shared\n< by all thread blocks simultaneously resident on a multiprocessor."]
2759pub const hipDeviceAttribute_t_hipDeviceAttributeMaxRegistersPerBlock: hipDeviceAttribute_t = 71;
2760#[doc = "< 32-bit registers available per block."]
2761pub const hipDeviceAttribute_t_hipDeviceAttributeMaxRegistersPerMultiprocessor:
2762 hipDeviceAttribute_t = 72;
2763#[doc = "< Shared memory reserved by CUDA driver per block."]
2764pub const hipDeviceAttribute_t_hipDeviceAttributeReservedSharedMemPerBlock: hipDeviceAttribute_t =
2765 73;
2766#[doc = "< Maximum shared memory available per block in bytes."]
2767pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSharedMemoryPerBlock: hipDeviceAttribute_t = 74;
2768#[doc = "< Maximum shared memory per block usable by special opt in."]
2769pub const hipDeviceAttribute_t_hipDeviceAttributeSharedMemPerBlockOptin: hipDeviceAttribute_t = 75;
2770#[doc = "< Shared memory available per multiprocessor."]
2771pub const hipDeviceAttribute_t_hipDeviceAttributeSharedMemPerMultiprocessor: hipDeviceAttribute_t =
2772 76;
2773#[doc = "< Cuda only. Performance ratio of single precision to double precision."]
2774pub const hipDeviceAttribute_t_hipDeviceAttributeSingleToDoublePrecisionPerfRatio:
2775 hipDeviceAttribute_t = 77;
2776#[doc = "< Whether to support stream priorities."]
2777pub const hipDeviceAttribute_t_hipDeviceAttributeStreamPrioritiesSupported: hipDeviceAttribute_t =
2778 78;
2779#[doc = "< Alignment requirement for surfaces"]
2780pub const hipDeviceAttribute_t_hipDeviceAttributeSurfaceAlignment: hipDeviceAttribute_t = 79;
2781#[doc = "< Cuda only. Whether device is a Tesla device using TCC driver"]
2782pub const hipDeviceAttribute_t_hipDeviceAttributeTccDriver: hipDeviceAttribute_t = 80;
2783#[doc = "< Alignment requirement for textures"]
2784pub const hipDeviceAttribute_t_hipDeviceAttributeTextureAlignment: hipDeviceAttribute_t = 81;
2785#[doc = "< Pitch alignment requirement for 2D texture references bound to pitched memory;"]
2786pub const hipDeviceAttribute_t_hipDeviceAttributeTexturePitchAlignment: hipDeviceAttribute_t = 82;
2787#[doc = "< Constant memory size in bytes."]
2788pub const hipDeviceAttribute_t_hipDeviceAttributeTotalConstantMemory: hipDeviceAttribute_t = 83;
2789#[doc = "< Global memory available on devicice."]
2790pub const hipDeviceAttribute_t_hipDeviceAttributeTotalGlobalMem: hipDeviceAttribute_t = 84;
2791#[doc = "< Cuda only. An unified address space shared with the host."]
2792pub const hipDeviceAttribute_t_hipDeviceAttributeUnifiedAddressing: hipDeviceAttribute_t = 85;
2793#[doc = "< Previously hipDeviceAttributeUuid"]
2794pub const hipDeviceAttribute_t_hipDeviceAttributeUnused2: hipDeviceAttribute_t = 86;
2795#[doc = "< Warp size in threads."]
2796pub const hipDeviceAttribute_t_hipDeviceAttributeWarpSize: hipDeviceAttribute_t = 87;
2797#[doc = "< Device supports HIP Stream Ordered Memory Allocator"]
2798pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryPoolsSupported: hipDeviceAttribute_t = 88;
2799#[doc = "< Device supports HIP virtual memory management"]
2800pub const hipDeviceAttribute_t_hipDeviceAttributeVirtualMemoryManagementSupported:
2801 hipDeviceAttribute_t = 89;
2802#[doc = "< Can device support host memory registration via hipHostRegister"]
2803pub const hipDeviceAttribute_t_hipDeviceAttributeHostRegisterSupported: hipDeviceAttribute_t = 90;
2804#[doc = "< Supported handle mask for HIP Stream Ordered Memory Allocator"]
2805pub const hipDeviceAttribute_t_hipDeviceAttributeMemoryPoolSupportedHandleTypes:
2806 hipDeviceAttribute_t = 91;
2807pub const hipDeviceAttribute_t_hipDeviceAttributeCudaCompatibleEnd: hipDeviceAttribute_t = 9999;
2808pub const hipDeviceAttribute_t_hipDeviceAttributeAmdSpecificBegin: hipDeviceAttribute_t = 10000;
2809#[doc = "< Frequency in khz of the timer used by the device-side \"clock*\""]
2810pub const hipDeviceAttribute_t_hipDeviceAttributeClockInstructionRate: hipDeviceAttribute_t = 10000;
2811#[doc = "< Previously hipDeviceAttributeArch"]
2812pub const hipDeviceAttribute_t_hipDeviceAttributeUnused3: hipDeviceAttribute_t = 10001;
2813#[doc = "< Maximum Shared Memory PerMultiprocessor."]
2814pub const hipDeviceAttribute_t_hipDeviceAttributeMaxSharedMemoryPerMultiprocessor:
2815 hipDeviceAttribute_t = 10002;
2816#[doc = "< Previously hipDeviceAttributeGcnArch"]
2817pub const hipDeviceAttribute_t_hipDeviceAttributeUnused4: hipDeviceAttribute_t = 10003;
2818#[doc = "< Previously hipDeviceAttributeGcnArchName"]
2819pub const hipDeviceAttribute_t_hipDeviceAttributeUnused5: hipDeviceAttribute_t = 10004;
2820#[doc = "< Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register"]
2821pub const hipDeviceAttribute_t_hipDeviceAttributeHdpMemFlushCntl: hipDeviceAttribute_t = 10005;
2822#[doc = "< Address of the HDP_REG_COHERENCY_FLUSH_CNTL register"]
2823pub const hipDeviceAttribute_t_hipDeviceAttributeHdpRegFlushCntl: hipDeviceAttribute_t = 10006;
2824#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched functions"]
2825pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc:
2826 hipDeviceAttribute_t = 10007;
2827#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched grid dimensions"]
2828pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim:
2829 hipDeviceAttribute_t = 10008;
2830#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched block dimensions"]
2831pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim:
2832 hipDeviceAttribute_t = 10009;
2833#[doc = "< Supports cooperative launch on multiple\n< devices with unmatched shared memories"]
2834pub const hipDeviceAttribute_t_hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem:
2835 hipDeviceAttribute_t = 10010;
2836#[doc = "< Whether it is LargeBar"]
2837pub const hipDeviceAttribute_t_hipDeviceAttributeIsLargeBar: hipDeviceAttribute_t = 10011;
2838#[doc = "< Revision of the GPU in this device"]
2839pub const hipDeviceAttribute_t_hipDeviceAttributeAsicRevision: hipDeviceAttribute_t = 10012;
2840#[doc = "< '1' if Device supports hipStreamWaitValue32() and\n< hipStreamWaitValue64(), '0' otherwise."]
2841pub const hipDeviceAttribute_t_hipDeviceAttributeCanUseStreamWaitValue: hipDeviceAttribute_t =
2842 10013;
2843#[doc = "< '1' if Device supports image, '0' otherwise."]
2844pub const hipDeviceAttribute_t_hipDeviceAttributeImageSupport: hipDeviceAttribute_t = 10014;
2845#[doc = "< All available physical compute\n< units for the device"]
2846pub const hipDeviceAttribute_t_hipDeviceAttributePhysicalMultiProcessorCount: hipDeviceAttribute_t =
2847 10015;
2848#[doc = "< '1' if Device supports fine grain, '0' otherwise"]
2849pub const hipDeviceAttribute_t_hipDeviceAttributeFineGrainSupport: hipDeviceAttribute_t = 10016;
2850#[doc = "< Constant frequency of wall clock in kilohertz."]
2851pub const hipDeviceAttribute_t_hipDeviceAttributeWallClockRate: hipDeviceAttribute_t = 10017;
2852pub const hipDeviceAttribute_t_hipDeviceAttributeAmdSpecificEnd: hipDeviceAttribute_t = 19999;
2853pub const hipDeviceAttribute_t_hipDeviceAttributeVendorSpecificBegin: hipDeviceAttribute_t = 20000;
2854#[doc = " hipDeviceAttribute_t\n hipDeviceAttributeUnused number: 5"]
2855pub type hipDeviceAttribute_t = ::std::os::raw::c_uint;
2856pub const hipDriverProcAddressQueryResult_HIP_GET_PROC_ADDRESS_SUCCESS:
2857 hipDriverProcAddressQueryResult = 0;
2858pub const hipDriverProcAddressQueryResult_HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND:
2859 hipDriverProcAddressQueryResult = 1;
2860pub const hipDriverProcAddressQueryResult_HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT:
2861 hipDriverProcAddressQueryResult = 2;
2862pub type hipDriverProcAddressQueryResult = ::std::os::raw::c_uint;
2863pub const hipComputeMode_hipComputeModeDefault: hipComputeMode = 0;
2864pub const hipComputeMode_hipComputeModeExclusive: hipComputeMode = 1;
2865pub const hipComputeMode_hipComputeModeProhibited: hipComputeMode = 2;
2866pub const hipComputeMode_hipComputeModeExclusiveProcess: hipComputeMode = 3;
2867pub type hipComputeMode = ::std::os::raw::c_uint;
2868pub const hipFlushGPUDirectRDMAWritesOptions_hipFlushGPUDirectRDMAWritesOptionHost:
2869 hipFlushGPUDirectRDMAWritesOptions = 1;
2870pub const hipFlushGPUDirectRDMAWritesOptions_hipFlushGPUDirectRDMAWritesOptionMemOps:
2871 hipFlushGPUDirectRDMAWritesOptions = 2;
2872pub type hipFlushGPUDirectRDMAWritesOptions = ::std::os::raw::c_uint;
2873pub const hipGPUDirectRDMAWritesOrdering_hipGPUDirectRDMAWritesOrderingNone:
2874 hipGPUDirectRDMAWritesOrdering = 0;
2875pub const hipGPUDirectRDMAWritesOrdering_hipGPUDirectRDMAWritesOrderingOwner:
2876 hipGPUDirectRDMAWritesOrdering = 100;
2877pub const hipGPUDirectRDMAWritesOrdering_hipGPUDirectRDMAWritesOrderingAllDevices:
2878 hipGPUDirectRDMAWritesOrdering = 200;
2879pub type hipGPUDirectRDMAWritesOrdering = ::std::os::raw::c_uint;
2880pub type int_least8_t = __int_least8_t;
2881pub type int_least16_t = __int_least16_t;
2882pub type int_least32_t = __int_least32_t;
2883pub type int_least64_t = __int_least64_t;
2884pub type uint_least8_t = __uint_least8_t;
2885pub type uint_least16_t = __uint_least16_t;
2886pub type uint_least32_t = __uint_least32_t;
2887pub type uint_least64_t = __uint_least64_t;
2888pub type int_fast8_t = ::std::os::raw::c_schar;
2889pub type int_fast16_t = ::std::os::raw::c_long;
2890pub type int_fast32_t = ::std::os::raw::c_long;
2891pub type int_fast64_t = ::std::os::raw::c_long;
2892pub type uint_fast8_t = ::std::os::raw::c_uchar;
2893pub type uint_fast16_t = ::std::os::raw::c_ulong;
2894pub type uint_fast32_t = ::std::os::raw::c_ulong;
2895pub type uint_fast64_t = ::std::os::raw::c_ulong;
2896pub type intmax_t = __intmax_t;
2897pub type uintmax_t = __uintmax_t;
2898#[repr(C)]
2899#[repr(align(16))]
2900#[derive(Debug, Copy, Clone)]
2901pub struct max_align_t {
2902 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
2903 pub __bindgen_padding_0: u64,
2904 pub __clang_max_align_nonce2: u128,
2905}
2906#[doc = " @defgroup DriverTypes Driver Types\n @{\n This section describes the driver data types.\n"]
2907pub type hipDeviceptr_t = *mut ::std::os::raw::c_void;
2908#[doc = "< Signed channel format"]
2909pub const hipChannelFormatKind_hipChannelFormatKindSigned: hipChannelFormatKind = 0;
2910#[doc = "< Unsigned channel format"]
2911pub const hipChannelFormatKind_hipChannelFormatKindUnsigned: hipChannelFormatKind = 1;
2912#[doc = "< Float channel format"]
2913pub const hipChannelFormatKind_hipChannelFormatKindFloat: hipChannelFormatKind = 2;
2914#[doc = "< No channel format"]
2915pub const hipChannelFormatKind_hipChannelFormatKindNone: hipChannelFormatKind = 3;
2916#[doc = " HIP channel format kinds"]
2917pub type hipChannelFormatKind = ::std::os::raw::c_uint;
2918#[doc = " HIP channel format descriptor"]
2919#[repr(C)]
2920#[derive(Debug, Copy, Clone)]
2921pub struct hipChannelFormatDesc {
2922 pub x: ::std::os::raw::c_int,
2923 pub y: ::std::os::raw::c_int,
2924 pub z: ::std::os::raw::c_int,
2925 pub w: ::std::os::raw::c_int,
2926 #[doc = "< Channel format kind"]
2927 pub f: hipChannelFormatKind,
2928}
2929#[repr(C)]
2930#[derive(Debug, Copy, Clone)]
2931pub struct hipArray {
2932 _unused: [u8; 0],
2933}
2934pub type hipArray_t = *mut hipArray;
2935pub type hipArray_const_t = *const hipArray;
2936#[doc = "< Unsigned 8-bit array format"]
2937pub const hipArray_Format_HIP_AD_FORMAT_UNSIGNED_INT8: hipArray_Format = 1;
2938#[doc = "< Unsigned 16-bit array format"]
2939pub const hipArray_Format_HIP_AD_FORMAT_UNSIGNED_INT16: hipArray_Format = 2;
2940#[doc = "< Unsigned 32-bit array format"]
2941pub const hipArray_Format_HIP_AD_FORMAT_UNSIGNED_INT32: hipArray_Format = 3;
2942#[doc = "< Signed 8-bit array format"]
2943pub const hipArray_Format_HIP_AD_FORMAT_SIGNED_INT8: hipArray_Format = 8;
2944#[doc = "< Signed 16-bit array format"]
2945pub const hipArray_Format_HIP_AD_FORMAT_SIGNED_INT16: hipArray_Format = 9;
2946#[doc = "< Signed 32-bit array format"]
2947pub const hipArray_Format_HIP_AD_FORMAT_SIGNED_INT32: hipArray_Format = 10;
2948#[doc = "< Half array format"]
2949pub const hipArray_Format_HIP_AD_FORMAT_HALF: hipArray_Format = 16;
2950#[doc = "< Float array format"]
2951pub const hipArray_Format_HIP_AD_FORMAT_FLOAT: hipArray_Format = 32;
2952#[doc = " HIP array format"]
2953pub type hipArray_Format = ::std::os::raw::c_uint;
2954#[doc = " HIP array descriptor"]
2955#[repr(C)]
2956#[derive(Debug, Copy, Clone)]
2957pub struct HIP_ARRAY_DESCRIPTOR {
2958 #[doc = "< Width of the array"]
2959 pub Width: usize,
2960 #[doc = "< Height of the array"]
2961 pub Height: usize,
2962 #[doc = "< Format of the array"]
2963 pub Format: hipArray_Format,
2964 #[doc = "< Number of channels of the array"]
2965 pub NumChannels: ::std::os::raw::c_uint,
2966}
2967#[doc = " HIP 3D array descriptor"]
2968#[repr(C)]
2969#[derive(Debug, Copy, Clone)]
2970pub struct HIP_ARRAY3D_DESCRIPTOR {
2971 #[doc = "< Width of the array"]
2972 pub Width: usize,
2973 #[doc = "< Height of the array"]
2974 pub Height: usize,
2975 #[doc = "< Depth of the array"]
2976 pub Depth: usize,
2977 #[doc = "< Format of the array"]
2978 pub Format: hipArray_Format,
2979 #[doc = "< Number of channels of the array"]
2980 pub NumChannels: ::std::os::raw::c_uint,
2981 #[doc = "< Flags of the array"]
2982 pub Flags: ::std::os::raw::c_uint,
2983}
2984#[doc = " HIP 2D memory copy parameters"]
2985#[repr(C)]
2986#[derive(Debug, Copy, Clone)]
2987pub struct hip_Memcpy2D {
2988 #[doc = "< Source width in bytes"]
2989 pub srcXInBytes: usize,
2990 #[doc = "< Source height"]
2991 pub srcY: usize,
2992 #[doc = "< Source memory type"]
2993 pub srcMemoryType: hipMemoryType,
2994 #[doc = "< Source pointer"]
2995 pub srcHost: *const ::std::os::raw::c_void,
2996 #[doc = "< Source device"]
2997 pub srcDevice: hipDeviceptr_t,
2998 #[doc = "< Source array"]
2999 pub srcArray: hipArray_t,
3000 #[doc = "< Source pitch"]
3001 pub srcPitch: usize,
3002 #[doc = "< Destination width in bytes"]
3003 pub dstXInBytes: usize,
3004 #[doc = "< Destination height"]
3005 pub dstY: usize,
3006 #[doc = "< Destination memory type"]
3007 pub dstMemoryType: hipMemoryType,
3008 #[doc = "< Destination pointer"]
3009 pub dstHost: *mut ::std::os::raw::c_void,
3010 #[doc = "< Destination device"]
3011 pub dstDevice: hipDeviceptr_t,
3012 #[doc = "< Destination array"]
3013 pub dstArray: hipArray_t,
3014 #[doc = "< Destination pitch"]
3015 pub dstPitch: usize,
3016 #[doc = "< Width in bytes of the 2D memory copy"]
3017 pub WidthInBytes: usize,
3018 #[doc = "< Height of the 2D memory copy"]
3019 pub Height: usize,
3020}
3021#[doc = " HIP mipmapped array"]
3022#[repr(C)]
3023#[derive(Debug, Copy, Clone)]
3024pub struct hipMipmappedArray {
3025 #[doc = "< Data pointer of the mipmapped array"]
3026 pub data: *mut ::std::os::raw::c_void,
3027 #[doc = "< Description of the mipmapped array"]
3028 pub desc: hipChannelFormatDesc,
3029 #[doc = "< Type of the mipmapped array"]
3030 pub type_: ::std::os::raw::c_uint,
3031 #[doc = "< Width of the mipmapped array"]
3032 pub width: ::std::os::raw::c_uint,
3033 #[doc = "< Height of the mipmapped array"]
3034 pub height: ::std::os::raw::c_uint,
3035 #[doc = "< Depth of the mipmapped array"]
3036 pub depth: ::std::os::raw::c_uint,
3037 #[doc = "< Minimum level of the mipmapped array"]
3038 pub min_mipmap_level: ::std::os::raw::c_uint,
3039 #[doc = "< Maximum level of the mipmapped array"]
3040 pub max_mipmap_level: ::std::os::raw::c_uint,
3041 #[doc = "< Flags of the mipmapped array"]
3042 pub flags: ::std::os::raw::c_uint,
3043 #[doc = "< Format of the mipmapped array"]
3044 pub format: hipArray_Format,
3045 #[doc = "< Number of channels of the mipmapped array"]
3046 pub num_channels: ::std::os::raw::c_uint,
3047}
3048#[doc = " HIP mipmapped array pointer"]
3049pub type hipMipmappedArray_t = *mut hipMipmappedArray;
3050pub type hipmipmappedArray = hipMipmappedArray_t;
3051pub type hipMipmappedArray_const_t = *const hipMipmappedArray;
3052#[doc = "< Array resource"]
3053pub const hipResourceType_hipResourceTypeArray: hipResourceType = 0;
3054#[doc = "< Mipmapped array resource"]
3055pub const hipResourceType_hipResourceTypeMipmappedArray: hipResourceType = 1;
3056#[doc = "< Linear resource"]
3057pub const hipResourceType_hipResourceTypeLinear: hipResourceType = 2;
3058#[doc = "< Pitch 2D resource"]
3059pub const hipResourceType_hipResourceTypePitch2D: hipResourceType = 3;
3060#[doc = " HIP resource types"]
3061pub type hipResourceType = ::std::os::raw::c_uint;
3062#[doc = "< Array resource"]
3063pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_ARRAY: HIPresourcetype_enum = 0;
3064#[doc = "< Mipmapped array resource"]
3065pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY: HIPresourcetype_enum = 1;
3066#[doc = "< Linear resource"]
3067pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_LINEAR: HIPresourcetype_enum = 2;
3068#[doc = "< Pitch 2D resource"]
3069pub const HIPresourcetype_enum_HIP_RESOURCE_TYPE_PITCH2D: HIPresourcetype_enum = 3;
3070pub type HIPresourcetype_enum = ::std::os::raw::c_uint;
3071pub use self::HIPresourcetype_enum as HIPresourcetype;
3072pub use self::HIPresourcetype_enum as hipResourcetype;
3073#[doc = "< Wrap address mode"]
3074pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_WRAP: HIPaddress_mode_enum = 0;
3075#[doc = "< Clamp address mode"]
3076pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_CLAMP: HIPaddress_mode_enum = 1;
3077#[doc = "< Mirror address mode"]
3078pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_MIRROR: HIPaddress_mode_enum = 2;
3079#[doc = "< Border address mode"]
3080pub const HIPaddress_mode_enum_HIP_TR_ADDRESS_MODE_BORDER: HIPaddress_mode_enum = 3;
3081#[doc = " HIP texture address modes"]
3082pub type HIPaddress_mode_enum = ::std::os::raw::c_uint;
3083#[doc = " HIP texture address modes"]
3084pub use self::HIPaddress_mode_enum as HIPaddress_mode;
3085#[doc = "< Filter mode point"]
3086pub const HIPfilter_mode_enum_HIP_TR_FILTER_MODE_POINT: HIPfilter_mode_enum = 0;
3087#[doc = "< Filter mode linear"]
3088pub const HIPfilter_mode_enum_HIP_TR_FILTER_MODE_LINEAR: HIPfilter_mode_enum = 1;
3089#[doc = " HIP filter modes"]
3090pub type HIPfilter_mode_enum = ::std::os::raw::c_uint;
3091#[doc = " HIP filter modes"]
3092pub use self::HIPfilter_mode_enum as HIPfilter_mode;
3093#[doc = " HIP texture descriptor"]
3094#[repr(C)]
3095#[derive(Debug, Copy, Clone)]
3096pub struct HIP_TEXTURE_DESC_st {
3097 #[doc = "< Address modes"]
3098 pub addressMode: [HIPaddress_mode; 3usize],
3099 #[doc = "< Filter mode"]
3100 pub filterMode: HIPfilter_mode,
3101 #[doc = "< Flags"]
3102 pub flags: ::std::os::raw::c_uint,
3103 #[doc = "< Maximum anisotropy ratio"]
3104 pub maxAnisotropy: ::std::os::raw::c_uint,
3105 #[doc = "< Mipmap filter mode"]
3106 pub mipmapFilterMode: HIPfilter_mode,
3107 #[doc = "< Mipmap level bias"]
3108 pub mipmapLevelBias: f32,
3109 #[doc = "< Mipmap minimum level clamp"]
3110 pub minMipmapLevelClamp: f32,
3111 #[doc = "< Mipmap maximum level clamp"]
3112 pub maxMipmapLevelClamp: f32,
3113 #[doc = "< Border Color"]
3114 pub borderColor: [f32; 4usize],
3115 pub reserved: [::std::os::raw::c_int; 12usize],
3116}
3117#[doc = " HIP texture descriptor"]
3118pub type HIP_TEXTURE_DESC = HIP_TEXTURE_DESC_st;
3119#[doc = "< No resource view format (use underlying resource format)"]
3120pub const hipResourceViewFormat_hipResViewFormatNone: hipResourceViewFormat = 0;
3121#[doc = "< 1 channel, unsigned 8-bit integers"]
3122pub const hipResourceViewFormat_hipResViewFormatUnsignedChar1: hipResourceViewFormat = 1;
3123#[doc = "< 2 channels, unsigned 8-bit integers"]
3124pub const hipResourceViewFormat_hipResViewFormatUnsignedChar2: hipResourceViewFormat = 2;
3125#[doc = "< 4 channels, unsigned 8-bit integers"]
3126pub const hipResourceViewFormat_hipResViewFormatUnsignedChar4: hipResourceViewFormat = 3;
3127#[doc = "< 1 channel, signed 8-bit integers"]
3128pub const hipResourceViewFormat_hipResViewFormatSignedChar1: hipResourceViewFormat = 4;
3129#[doc = "< 2 channels, signed 8-bit integers"]
3130pub const hipResourceViewFormat_hipResViewFormatSignedChar2: hipResourceViewFormat = 5;
3131#[doc = "< 4 channels, signed 8-bit integers"]
3132pub const hipResourceViewFormat_hipResViewFormatSignedChar4: hipResourceViewFormat = 6;
3133#[doc = "< 1 channel, unsigned 16-bit integers"]
3134pub const hipResourceViewFormat_hipResViewFormatUnsignedShort1: hipResourceViewFormat = 7;
3135#[doc = "< 2 channels, unsigned 16-bit integers"]
3136pub const hipResourceViewFormat_hipResViewFormatUnsignedShort2: hipResourceViewFormat = 8;
3137#[doc = "< 4 channels, unsigned 16-bit integers"]
3138pub const hipResourceViewFormat_hipResViewFormatUnsignedShort4: hipResourceViewFormat = 9;
3139#[doc = "< 1 channel, signed 16-bit integers"]
3140pub const hipResourceViewFormat_hipResViewFormatSignedShort1: hipResourceViewFormat = 10;
3141#[doc = "< 2 channels, signed 16-bit integers"]
3142pub const hipResourceViewFormat_hipResViewFormatSignedShort2: hipResourceViewFormat = 11;
3143#[doc = "< 4 channels, signed 16-bit integers"]
3144pub const hipResourceViewFormat_hipResViewFormatSignedShort4: hipResourceViewFormat = 12;
3145#[doc = "< 1 channel, unsigned 32-bit integers"]
3146pub const hipResourceViewFormat_hipResViewFormatUnsignedInt1: hipResourceViewFormat = 13;
3147#[doc = "< 2 channels, unsigned 32-bit integers"]
3148pub const hipResourceViewFormat_hipResViewFormatUnsignedInt2: hipResourceViewFormat = 14;
3149#[doc = "< 4 channels, unsigned 32-bit integers"]
3150pub const hipResourceViewFormat_hipResViewFormatUnsignedInt4: hipResourceViewFormat = 15;
3151#[doc = "< 1 channel, signed 32-bit integers"]
3152pub const hipResourceViewFormat_hipResViewFormatSignedInt1: hipResourceViewFormat = 16;
3153#[doc = "< 2 channels, signed 32-bit integers"]
3154pub const hipResourceViewFormat_hipResViewFormatSignedInt2: hipResourceViewFormat = 17;
3155#[doc = "< 4 channels, signed 32-bit integers"]
3156pub const hipResourceViewFormat_hipResViewFormatSignedInt4: hipResourceViewFormat = 18;
3157#[doc = "< 1 channel, 16-bit floating point"]
3158pub const hipResourceViewFormat_hipResViewFormatHalf1: hipResourceViewFormat = 19;
3159#[doc = "< 2 channels, 16-bit floating point"]
3160pub const hipResourceViewFormat_hipResViewFormatHalf2: hipResourceViewFormat = 20;
3161#[doc = "< 4 channels, 16-bit floating point"]
3162pub const hipResourceViewFormat_hipResViewFormatHalf4: hipResourceViewFormat = 21;
3163#[doc = "< 1 channel, 32-bit floating point"]
3164pub const hipResourceViewFormat_hipResViewFormatFloat1: hipResourceViewFormat = 22;
3165#[doc = "< 2 channels, 32-bit floating point"]
3166pub const hipResourceViewFormat_hipResViewFormatFloat2: hipResourceViewFormat = 23;
3167#[doc = "< 4 channels, 32-bit floating point"]
3168pub const hipResourceViewFormat_hipResViewFormatFloat4: hipResourceViewFormat = 24;
3169#[doc = "< Block-compressed 1"]
3170pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed1: hipResourceViewFormat =
3171 25;
3172#[doc = "< Block-compressed 2"]
3173pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed2: hipResourceViewFormat =
3174 26;
3175#[doc = "< Block-compressed 3"]
3176pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed3: hipResourceViewFormat =
3177 27;
3178#[doc = "< Block-compressed 4 unsigned"]
3179pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed4: hipResourceViewFormat =
3180 28;
3181#[doc = "< Block-compressed 4 signed"]
3182pub const hipResourceViewFormat_hipResViewFormatSignedBlockCompressed4: hipResourceViewFormat = 29;
3183#[doc = "< Block-compressed 5 unsigned"]
3184pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed5: hipResourceViewFormat =
3185 30;
3186#[doc = "< Block-compressed 5 signed"]
3187pub const hipResourceViewFormat_hipResViewFormatSignedBlockCompressed5: hipResourceViewFormat = 31;
3188#[doc = "< Block-compressed 6 unsigned half-float"]
3189pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed6H: hipResourceViewFormat =
3190 32;
3191#[doc = "< Block-compressed 6 signed half-float"]
3192pub const hipResourceViewFormat_hipResViewFormatSignedBlockCompressed6H: hipResourceViewFormat = 33;
3193#[doc = "< Block-compressed 7"]
3194pub const hipResourceViewFormat_hipResViewFormatUnsignedBlockCompressed7: hipResourceViewFormat =
3195 34;
3196#[doc = " HIP texture resource view formats"]
3197pub type hipResourceViewFormat = ::std::os::raw::c_uint;
3198#[doc = "< No resource view format (use underlying resource format)"]
3199pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_NONE: HIPresourceViewFormat_enum = 0;
3200#[doc = "< 1 channel, unsigned 8-bit integers"]
3201pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_1X8: HIPresourceViewFormat_enum = 1;
3202#[doc = "< 2 channels, unsigned 8-bit integers"]
3203pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_2X8: HIPresourceViewFormat_enum = 2;
3204#[doc = "< 4 channels, unsigned 8-bit integers"]
3205pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_4X8: HIPresourceViewFormat_enum = 3;
3206#[doc = "< 1 channel, signed 8-bit integers"]
3207pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_1X8: HIPresourceViewFormat_enum = 4;
3208#[doc = "< 2 channels, signed 8-bit integers"]
3209pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_2X8: HIPresourceViewFormat_enum = 5;
3210#[doc = "< 4 channels, signed 8-bit integers"]
3211pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_4X8: HIPresourceViewFormat_enum = 6;
3212#[doc = "< 1 channel, unsigned 16-bit integers"]
3213pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_1X16: HIPresourceViewFormat_enum = 7;
3214#[doc = "< 2 channels, unsigned 16-bit integers"]
3215pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_2X16: HIPresourceViewFormat_enum = 8;
3216#[doc = "< 4 channels, unsigned 16-bit integers"]
3217pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_4X16: HIPresourceViewFormat_enum = 9;
3218#[doc = "< 1 channel, signed 16-bit integers"]
3219pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_1X16: HIPresourceViewFormat_enum = 10;
3220#[doc = "< 2 channels, signed 16-bit integers"]
3221pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_2X16: HIPresourceViewFormat_enum = 11;
3222#[doc = "< 4 channels, signed 16-bit integers"]
3223pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_4X16: HIPresourceViewFormat_enum = 12;
3224#[doc = "< 1 channel, unsigned 32-bit integers"]
3225pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_1X32: HIPresourceViewFormat_enum = 13;
3226#[doc = "< 2 channels, unsigned 32-bit integers"]
3227pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_2X32: HIPresourceViewFormat_enum = 14;
3228#[doc = "< 4 channels, unsigned 32-bit integers"]
3229pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UINT_4X32: HIPresourceViewFormat_enum = 15;
3230#[doc = "< 1 channel, signed 32-bit integers"]
3231pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_1X32: HIPresourceViewFormat_enum = 16;
3232#[doc = "< 2 channels, signed 32-bit integers"]
3233pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_2X32: HIPresourceViewFormat_enum = 17;
3234#[doc = "< 4 channels, signed 32-bit integers"]
3235pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SINT_4X32: HIPresourceViewFormat_enum = 18;
3236#[doc = "< 1 channel, 16-bit floating point"]
3237pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_1X16: HIPresourceViewFormat_enum =
3238 19;
3239#[doc = "< 2 channels, 16-bit floating point"]
3240pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_2X16: HIPresourceViewFormat_enum =
3241 20;
3242#[doc = "< 4 channels, 16-bit floating point"]
3243pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_4X16: HIPresourceViewFormat_enum =
3244 21;
3245#[doc = "< 1 channel, 32-bit floating point"]
3246pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_1X32: HIPresourceViewFormat_enum =
3247 22;
3248#[doc = "< 2 channels, 32-bit floating point"]
3249pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_2X32: HIPresourceViewFormat_enum =
3250 23;
3251#[doc = "< 4 channels, 32-bit floating point"]
3252pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_FLOAT_4X32: HIPresourceViewFormat_enum =
3253 24;
3254#[doc = "< Block-compressed 1"]
3255pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC1: HIPresourceViewFormat_enum =
3256 25;
3257#[doc = "< Block-compressed 2"]
3258pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC2: HIPresourceViewFormat_enum =
3259 26;
3260#[doc = "< Block-compressed 3"]
3261pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC3: HIPresourceViewFormat_enum =
3262 27;
3263#[doc = "< Block-compressed 4 unsigned"]
3264pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC4: HIPresourceViewFormat_enum =
3265 28;
3266#[doc = "< Block-compressed 4 signed"]
3267pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SIGNED_BC4: HIPresourceViewFormat_enum =
3268 29;
3269#[doc = "< Block-compressed 5 unsigned"]
3270pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC5: HIPresourceViewFormat_enum =
3271 30;
3272#[doc = "< Block-compressed 5 signed"]
3273pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SIGNED_BC5: HIPresourceViewFormat_enum =
3274 31;
3275#[doc = "< Block-compressed 6 unsigned half-float"]
3276pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H: HIPresourceViewFormat_enum =
3277 32;
3278#[doc = "< Block-compressed 6 signed half-float"]
3279pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_SIGNED_BC6H: HIPresourceViewFormat_enum =
3280 33;
3281#[doc = "< Block-compressed 7"]
3282pub const HIPresourceViewFormat_enum_HIP_RES_VIEW_FORMAT_UNSIGNED_BC7: HIPresourceViewFormat_enum =
3283 34;
3284#[doc = " HIP texture resource view formats"]
3285pub type HIPresourceViewFormat_enum = ::std::os::raw::c_uint;
3286#[doc = " HIP texture resource view formats"]
3287pub use self::HIPresourceViewFormat_enum as HIPresourceViewFormat;
3288#[doc = " HIP resource descriptor"]
3289#[repr(C)]
3290#[derive(Copy, Clone)]
3291pub struct hipResourceDesc {
3292 #[doc = "< Resource type"]
3293 pub resType: hipResourceType,
3294 pub res: hipResourceDesc__bindgen_ty_1,
3295}
3296#[repr(C)]
3297#[derive(Copy, Clone)]
3298pub union hipResourceDesc__bindgen_ty_1 {
3299 pub array: hipResourceDesc__bindgen_ty_1__bindgen_ty_1,
3300 pub mipmap: hipResourceDesc__bindgen_ty_1__bindgen_ty_2,
3301 pub linear: hipResourceDesc__bindgen_ty_1__bindgen_ty_3,
3302 pub pitch2D: hipResourceDesc__bindgen_ty_1__bindgen_ty_4,
3303}
3304#[repr(C)]
3305#[derive(Debug, Copy, Clone)]
3306pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_1 {
3307 #[doc = "< HIP array"]
3308 pub array: hipArray_t,
3309}
3310#[repr(C)]
3311#[derive(Debug, Copy, Clone)]
3312pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_2 {
3313 #[doc = "< HIP mipmapped array"]
3314 pub mipmap: hipMipmappedArray_t,
3315}
3316#[repr(C)]
3317#[derive(Debug, Copy, Clone)]
3318pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_3 {
3319 #[doc = "< Device pointer"]
3320 pub devPtr: *mut ::std::os::raw::c_void,
3321 #[doc = "< Channel format description"]
3322 pub desc: hipChannelFormatDesc,
3323 #[doc = "< Size in bytes"]
3324 pub sizeInBytes: usize,
3325}
3326#[repr(C)]
3327#[derive(Debug, Copy, Clone)]
3328pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_4 {
3329 #[doc = "< Device pointer"]
3330 pub devPtr: *mut ::std::os::raw::c_void,
3331 #[doc = "< Channel format description"]
3332 pub desc: hipChannelFormatDesc,
3333 #[doc = "< Width of the array in elements"]
3334 pub width: usize,
3335 #[doc = "< Height of the array in elements"]
3336 pub height: usize,
3337 #[doc = "< Pitch between two rows in bytes"]
3338 pub pitchInBytes: usize,
3339}
3340#[doc = " HIP resource view descriptor struct"]
3341#[repr(C)]
3342#[derive(Copy, Clone)]
3343pub struct HIP_RESOURCE_DESC_st {
3344 #[doc = "< Resource type"]
3345 pub resType: HIPresourcetype,
3346 pub res: HIP_RESOURCE_DESC_st__bindgen_ty_1,
3347 #[doc = "< Flags (must be zero)"]
3348 pub flags: ::std::os::raw::c_uint,
3349}
3350#[repr(C)]
3351#[derive(Copy, Clone)]
3352pub union HIP_RESOURCE_DESC_st__bindgen_ty_1 {
3353 pub array: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1,
3354 pub mipmap: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2,
3355 pub linear: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
3356 pub pitch2D: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
3357 pub reserved: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
3358}
3359#[repr(C)]
3360#[derive(Debug, Copy, Clone)]
3361pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
3362 #[doc = "< HIP array"]
3363 pub hArray: hipArray_t,
3364}
3365#[repr(C)]
3366#[derive(Debug, Copy, Clone)]
3367pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
3368 #[doc = "< HIP mipmapped array"]
3369 pub hMipmappedArray: hipMipmappedArray_t,
3370}
3371#[repr(C)]
3372#[derive(Debug, Copy, Clone)]
3373pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
3374 #[doc = "< Device pointer"]
3375 pub devPtr: hipDeviceptr_t,
3376 #[doc = "< Array format"]
3377 pub format: hipArray_Format,
3378 #[doc = "< Channels per array element"]
3379 pub numChannels: ::std::os::raw::c_uint,
3380 #[doc = "< Size in bytes"]
3381 pub sizeInBytes: usize,
3382}
3383#[repr(C)]
3384#[derive(Debug, Copy, Clone)]
3385pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
3386 #[doc = "< Device pointer"]
3387 pub devPtr: hipDeviceptr_t,
3388 #[doc = "< Array format"]
3389 pub format: hipArray_Format,
3390 #[doc = "< Channels per array element"]
3391 pub numChannels: ::std::os::raw::c_uint,
3392 #[doc = "< Width of the array in elements"]
3393 pub width: usize,
3394 #[doc = "< Height of the array in elements"]
3395 pub height: usize,
3396 #[doc = "< Pitch between two rows in bytes"]
3397 pub pitchInBytes: usize,
3398}
3399#[repr(C)]
3400#[derive(Debug, Copy, Clone)]
3401pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
3402 pub reserved: [::std::os::raw::c_int; 32usize],
3403}
3404#[doc = " HIP resource view descriptor struct"]
3405pub type HIP_RESOURCE_DESC = HIP_RESOURCE_DESC_st;
3406#[doc = " HIP resource view descriptor"]
3407#[repr(C)]
3408#[derive(Debug, Copy, Clone)]
3409pub struct hipResourceViewDesc {
3410 #[doc = "< Resource view format"]
3411 pub format: hipResourceViewFormat,
3412 #[doc = "< Width of the resource view"]
3413 pub width: usize,
3414 #[doc = "< Height of the resource view"]
3415 pub height: usize,
3416 #[doc = "< Depth of the resource view"]
3417 pub depth: usize,
3418 #[doc = "< First defined mipmap level"]
3419 pub firstMipmapLevel: ::std::os::raw::c_uint,
3420 #[doc = "< Last defined mipmap level"]
3421 pub lastMipmapLevel: ::std::os::raw::c_uint,
3422 #[doc = "< First layer index"]
3423 pub firstLayer: ::std::os::raw::c_uint,
3424 #[doc = "< Last layer index"]
3425 pub lastLayer: ::std::os::raw::c_uint,
3426}
3427#[doc = " Resource view descriptor"]
3428#[repr(C)]
3429#[derive(Debug, Copy, Clone)]
3430pub struct HIP_RESOURCE_VIEW_DESC_st {
3431 #[doc = "< Resource view format"]
3432 pub format: HIPresourceViewFormat,
3433 #[doc = "< Width of the resource view"]
3434 pub width: usize,
3435 #[doc = "< Height of the resource view"]
3436 pub height: usize,
3437 #[doc = "< Depth of the resource view"]
3438 pub depth: usize,
3439 #[doc = "< First defined mipmap level"]
3440 pub firstMipmapLevel: ::std::os::raw::c_uint,
3441 #[doc = "< Last defined mipmap level"]
3442 pub lastMipmapLevel: ::std::os::raw::c_uint,
3443 #[doc = "< First layer index"]
3444 pub firstLayer: ::std::os::raw::c_uint,
3445 #[doc = "< Last layer index"]
3446 pub lastLayer: ::std::os::raw::c_uint,
3447 pub reserved: [::std::os::raw::c_uint; 16usize],
3448}
3449#[doc = " Resource view descriptor"]
3450pub type HIP_RESOURCE_VIEW_DESC = HIP_RESOURCE_VIEW_DESC_st;
3451#[doc = "< Host-to-Host Copy"]
3452pub const hipMemcpyKind_hipMemcpyHostToHost: hipMemcpyKind = 0;
3453#[doc = "< Host-to-Device Copy"]
3454pub const hipMemcpyKind_hipMemcpyHostToDevice: hipMemcpyKind = 1;
3455#[doc = "< Device-to-Host Copy"]
3456pub const hipMemcpyKind_hipMemcpyDeviceToHost: hipMemcpyKind = 2;
3457#[doc = "< Device-to-Device Copy"]
3458pub const hipMemcpyKind_hipMemcpyDeviceToDevice: hipMemcpyKind = 3;
3459#[doc = "< Runtime will automatically determine\n<copy-kind based on virtual addresses."]
3460pub const hipMemcpyKind_hipMemcpyDefault: hipMemcpyKind = 4;
3461#[doc = "< Device-to-Device Copy without using compute units"]
3462pub const hipMemcpyKind_hipMemcpyDeviceToDeviceNoCU: hipMemcpyKind = 1024;
3463pub type hipMemcpyKind = ::std::os::raw::c_uint;
3464#[doc = " HIP pithed pointer"]
3465#[repr(C)]
3466#[derive(Debug, Copy, Clone)]
3467pub struct hipPitchedPtr {
3468 #[doc = "< Pointer to the allocated memory"]
3469 pub ptr: *mut ::std::os::raw::c_void,
3470 #[doc = "< Pitch in bytes"]
3471 pub pitch: usize,
3472 #[doc = "< Logical size of the first dimension of allocation in elements"]
3473 pub xsize: usize,
3474 #[doc = "< Logical size of the second dimension of allocation in elements"]
3475 pub ysize: usize,
3476}
3477#[doc = " HIP extent"]
3478#[repr(C)]
3479#[derive(Debug, Copy, Clone)]
3480pub struct hipExtent {
3481 pub width: usize,
3482 pub height: usize,
3483 pub depth: usize,
3484}
3485#[doc = " HIP position"]
3486#[repr(C)]
3487#[derive(Debug, Copy, Clone)]
3488pub struct hipPos {
3489 #[doc = "< X coordinate"]
3490 pub x: usize,
3491 #[doc = "< Y coordinate"]
3492 pub y: usize,
3493 #[doc = "< Z coordinate"]
3494 pub z: usize,
3495}
3496#[doc = " HIP 3D memory copy parameters"]
3497#[repr(C)]
3498#[derive(Debug, Copy, Clone)]
3499pub struct hipMemcpy3DParms {
3500 #[doc = "< Source array"]
3501 pub srcArray: hipArray_t,
3502 #[doc = "< Source position"]
3503 pub srcPos: hipPos,
3504 #[doc = "< Source pointer"]
3505 pub srcPtr: hipPitchedPtr,
3506 #[doc = "< Destination array"]
3507 pub dstArray: hipArray_t,
3508 #[doc = "< Destination position"]
3509 pub dstPos: hipPos,
3510 #[doc = "< Destination pointer"]
3511 pub dstPtr: hipPitchedPtr,
3512 #[doc = "< Extent of 3D memory copy"]
3513 pub extent: hipExtent,
3514 #[doc = "< Kind of 3D memory copy"]
3515 pub kind: hipMemcpyKind,
3516}
3517#[doc = " HIP 3D memory copy"]
3518#[repr(C)]
3519#[derive(Debug, Copy, Clone)]
3520pub struct HIP_MEMCPY3D {
3521 #[doc = "< Source X in bytes"]
3522 pub srcXInBytes: usize,
3523 #[doc = "< Source Y"]
3524 pub srcY: usize,
3525 #[doc = "< Source Z"]
3526 pub srcZ: usize,
3527 #[doc = "< Source LOD"]
3528 pub srcLOD: usize,
3529 #[doc = "< Source memory type"]
3530 pub srcMemoryType: hipMemoryType,
3531 #[doc = "< Source host pointer"]
3532 pub srcHost: *const ::std::os::raw::c_void,
3533 #[doc = "< Source device"]
3534 pub srcDevice: hipDeviceptr_t,
3535 #[doc = "< Source array"]
3536 pub srcArray: hipArray_t,
3537 #[doc = "< Source pitch"]
3538 pub srcPitch: usize,
3539 #[doc = "< Source height"]
3540 pub srcHeight: usize,
3541 #[doc = "< Destination X in bytes"]
3542 pub dstXInBytes: usize,
3543 #[doc = "< Destination Y"]
3544 pub dstY: usize,
3545 #[doc = "< Destination Z"]
3546 pub dstZ: usize,
3547 #[doc = "< Destination LOD"]
3548 pub dstLOD: usize,
3549 #[doc = "< Destination memory type"]
3550 pub dstMemoryType: hipMemoryType,
3551 #[doc = "< Destination host pointer"]
3552 pub dstHost: *mut ::std::os::raw::c_void,
3553 #[doc = "< Destination device"]
3554 pub dstDevice: hipDeviceptr_t,
3555 #[doc = "< Destination array"]
3556 pub dstArray: hipArray_t,
3557 #[doc = "< Destination pitch"]
3558 pub dstPitch: usize,
3559 #[doc = "< Destination height"]
3560 pub dstHeight: usize,
3561 #[doc = "< Width in bytes of 3D memory copy"]
3562 pub WidthInBytes: usize,
3563 #[doc = "< Height in bytes of 3D memory copy"]
3564 pub Height: usize,
3565 #[doc = "< Depth in bytes of 3D memory copy"]
3566 pub Depth: usize,
3567}
3568#[doc = "< The maximum number of threads per block. Depends on function and device."]
3569pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK: hipFunction_attribute = 0;
3570#[doc = "< The statically allocated shared memory size in bytes per block required by the function."]
3571pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES: hipFunction_attribute = 1;
3572#[doc = "< The user-allocated constant memory by the function in bytes."]
3573pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES: hipFunction_attribute = 2;
3574#[doc = "< The local memory usage of each thread by this function in bytes."]
3575pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES: hipFunction_attribute = 3;
3576#[doc = "< The number of registers used by each thread of this function."]
3577pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_NUM_REGS: hipFunction_attribute = 4;
3578#[doc = "< PTX version"]
3579pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_PTX_VERSION: hipFunction_attribute = 5;
3580#[doc = "< Binary version"]
3581pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_BINARY_VERSION: hipFunction_attribute = 6;
3582#[doc = "< Cache mode"]
3583pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA: hipFunction_attribute = 7;
3584#[doc = "< The maximum dynamic shared memory per block for this function in bytes."]
3585pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES:
3586 hipFunction_attribute = 8;
3587#[doc = "< The shared memory carveout preference in percent of the maximum shared memory."]
3588pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT:
3589 hipFunction_attribute = 9;
3590pub const hipFunction_attribute_HIP_FUNC_ATTRIBUTE_MAX: hipFunction_attribute = 10;
3591pub type hipFunction_attribute = ::std::os::raw::c_uint;
3592#[doc = "< The context on which a pointer was allocated\n< @warning This attribute is not supported in HIP"]
3593pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_CONTEXT: hipPointer_attribute = 1;
3594#[doc = "< memory type describing the location of a pointer"]
3595pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_MEMORY_TYPE: hipPointer_attribute = 2;
3596#[doc = "< address at which the pointer is allocated on the device"]
3597pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_DEVICE_POINTER: hipPointer_attribute = 3;
3598#[doc = "< address at which the pointer is allocated on the host"]
3599pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_HOST_POINTER: hipPointer_attribute = 4;
3600#[doc = "< A pair of tokens for use with Linux kernel interface\n< @warning This attribute is not supported in HIP"]
3601pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_P2P_TOKENS: hipPointer_attribute = 5;
3602#[doc = "< Synchronize every synchronous memory operation\n< initiated on this region"]
3603pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS: hipPointer_attribute = 6;
3604#[doc = "< Unique ID for an allocated memory region"]
3605pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_BUFFER_ID: hipPointer_attribute = 7;
3606#[doc = "< Indicates if the pointer points to managed memory"]
3607pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_IS_MANAGED: hipPointer_attribute = 8;
3608#[doc = "< device ordinal of a device on which a pointer\n< was allocated or registered"]
3609pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL: hipPointer_attribute = 9;
3610#[doc = "< if this pointer maps to an allocation\n< that is suitable for hipIpcGetMemHandle\n< @warning This attribute is not supported in HIP"]
3611pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE:
3612 hipPointer_attribute = 10;
3613#[doc = "< Starting address for this requested pointer"]
3614pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR: hipPointer_attribute = 11;
3615#[doc = "< Size of the address range for this requested pointer"]
3616pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_RANGE_SIZE: hipPointer_attribute = 12;
3617#[doc = "< tells if this pointer is in a valid address range\n< that is mapped to a backing allocation"]
3618pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_MAPPED: hipPointer_attribute = 13;
3619#[doc = "< Bitmask of allowed hipmemAllocationHandleType\n< for this allocation @warning This attribute is not supported in HIP"]
3620pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES: hipPointer_attribute =
3621 14;
3622#[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"]
3623pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE:
3624 hipPointer_attribute = 15;
3625#[doc = "< Returns the access flags the device associated with\n< for the corresponding memory referenced by the ptr"]
3626pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS: hipPointer_attribute = 16;
3627#[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"]
3628pub const hipPointer_attribute_HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE: hipPointer_attribute = 17;
3629pub type hipPointer_attribute = ::std::os::raw::c_uint;
3630#[repr(C)]
3631#[derive(Debug, Copy, Clone)]
3632pub struct uchar1 {
3633 pub x: ::std::os::raw::c_uchar,
3634}
3635#[repr(C)]
3636#[derive(Debug, Copy, Clone)]
3637pub struct uchar2 {
3638 pub x: ::std::os::raw::c_uchar,
3639 pub y: ::std::os::raw::c_uchar,
3640}
3641#[repr(C)]
3642#[derive(Debug, Copy, Clone)]
3643pub struct uchar3 {
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}
3648#[repr(C)]
3649#[derive(Debug, Copy, Clone)]
3650pub struct uchar4 {
3651 pub x: ::std::os::raw::c_uchar,
3652 pub y: ::std::os::raw::c_uchar,
3653 pub z: ::std::os::raw::c_uchar,
3654 pub w: ::std::os::raw::c_uchar,
3655}
3656#[repr(C)]
3657#[derive(Debug, Copy, Clone)]
3658pub struct char1 {
3659 pub x: ::std::os::raw::c_char,
3660}
3661#[repr(C)]
3662#[derive(Debug, Copy, Clone)]
3663pub struct char2 {
3664 pub x: ::std::os::raw::c_char,
3665 pub y: ::std::os::raw::c_char,
3666}
3667#[repr(C)]
3668#[derive(Debug, Copy, Clone)]
3669pub struct char3 {
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}
3674#[repr(C)]
3675#[derive(Debug, Copy, Clone)]
3676pub struct char4 {
3677 pub x: ::std::os::raw::c_char,
3678 pub y: ::std::os::raw::c_char,
3679 pub z: ::std::os::raw::c_char,
3680 pub w: ::std::os::raw::c_char,
3681}
3682#[repr(C)]
3683#[derive(Debug, Copy, Clone)]
3684pub struct ushort1 {
3685 pub x: ::std::os::raw::c_ushort,
3686}
3687#[repr(C)]
3688#[derive(Debug, Copy, Clone)]
3689pub struct ushort2 {
3690 pub x: ::std::os::raw::c_ushort,
3691 pub y: ::std::os::raw::c_ushort,
3692}
3693#[repr(C)]
3694#[derive(Debug, Copy, Clone)]
3695pub struct ushort3 {
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}
3700#[repr(C)]
3701#[derive(Debug, Copy, Clone)]
3702pub struct ushort4 {
3703 pub x: ::std::os::raw::c_ushort,
3704 pub y: ::std::os::raw::c_ushort,
3705 pub z: ::std::os::raw::c_ushort,
3706 pub w: ::std::os::raw::c_ushort,
3707}
3708#[repr(C)]
3709#[derive(Debug, Copy, Clone)]
3710pub struct short1 {
3711 pub x: ::std::os::raw::c_short,
3712}
3713#[repr(C)]
3714#[derive(Debug, Copy, Clone)]
3715pub struct short2 {
3716 pub x: ::std::os::raw::c_short,
3717 pub y: ::std::os::raw::c_short,
3718}
3719#[repr(C)]
3720#[derive(Debug, Copy, Clone)]
3721pub struct short3 {
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}
3726#[repr(C)]
3727#[derive(Debug, Copy, Clone)]
3728pub struct short4 {
3729 pub x: ::std::os::raw::c_short,
3730 pub y: ::std::os::raw::c_short,
3731 pub z: ::std::os::raw::c_short,
3732 pub w: ::std::os::raw::c_short,
3733}
3734#[repr(C)]
3735#[derive(Debug, Copy, Clone)]
3736pub struct uint1 {
3737 pub x: ::std::os::raw::c_uint,
3738}
3739#[repr(C)]
3740#[derive(Debug, Copy, Clone)]
3741pub struct uint2 {
3742 pub x: ::std::os::raw::c_uint,
3743 pub y: ::std::os::raw::c_uint,
3744}
3745#[repr(C)]
3746#[derive(Debug, Copy, Clone)]
3747pub struct uint3 {
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}
3752#[repr(C)]
3753#[derive(Debug, Copy, Clone)]
3754pub struct uint4 {
3755 pub x: ::std::os::raw::c_uint,
3756 pub y: ::std::os::raw::c_uint,
3757 pub z: ::std::os::raw::c_uint,
3758 pub w: ::std::os::raw::c_uint,
3759}
3760#[repr(C)]
3761#[derive(Debug, Copy, Clone)]
3762pub struct int1 {
3763 pub x: ::std::os::raw::c_int,
3764}
3765#[repr(C)]
3766#[derive(Debug, Copy, Clone)]
3767pub struct int2 {
3768 pub x: ::std::os::raw::c_int,
3769 pub y: ::std::os::raw::c_int,
3770}
3771#[repr(C)]
3772#[derive(Debug, Copy, Clone)]
3773pub struct int3 {
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}
3778#[repr(C)]
3779#[derive(Debug, Copy, Clone)]
3780pub struct int4 {
3781 pub x: ::std::os::raw::c_int,
3782 pub y: ::std::os::raw::c_int,
3783 pub z: ::std::os::raw::c_int,
3784 pub w: ::std::os::raw::c_int,
3785}
3786#[repr(C)]
3787#[derive(Debug, Copy, Clone)]
3788pub struct ulong1 {
3789 pub x: ::std::os::raw::c_ulong,
3790}
3791#[repr(C)]
3792#[derive(Debug, Copy, Clone)]
3793pub struct ulong2 {
3794 pub x: ::std::os::raw::c_ulong,
3795 pub y: ::std::os::raw::c_ulong,
3796}
3797#[repr(C)]
3798#[derive(Debug, Copy, Clone)]
3799pub struct ulong3 {
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}
3804#[repr(C)]
3805#[derive(Debug, Copy, Clone)]
3806pub struct ulong4 {
3807 pub x: ::std::os::raw::c_ulong,
3808 pub y: ::std::os::raw::c_ulong,
3809 pub z: ::std::os::raw::c_ulong,
3810 pub w: ::std::os::raw::c_ulong,
3811}
3812#[repr(C)]
3813#[derive(Debug, Copy, Clone)]
3814pub struct long1 {
3815 pub x: ::std::os::raw::c_long,
3816}
3817#[repr(C)]
3818#[derive(Debug, Copy, Clone)]
3819pub struct long2 {
3820 pub x: ::std::os::raw::c_long,
3821 pub y: ::std::os::raw::c_long,
3822}
3823#[repr(C)]
3824#[derive(Debug, Copy, Clone)]
3825pub struct long3 {
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}
3830#[repr(C)]
3831#[derive(Debug, Copy, Clone)]
3832pub struct long4 {
3833 pub x: ::std::os::raw::c_long,
3834 pub y: ::std::os::raw::c_long,
3835 pub z: ::std::os::raw::c_long,
3836 pub w: ::std::os::raw::c_long,
3837}
3838#[repr(C)]
3839#[derive(Debug, Copy, Clone)]
3840pub struct ulonglong1 {
3841 pub x: ::std::os::raw::c_ulonglong,
3842}
3843#[repr(C)]
3844#[derive(Debug, Copy, Clone)]
3845pub struct ulonglong2 {
3846 pub x: ::std::os::raw::c_ulonglong,
3847 pub y: ::std::os::raw::c_ulonglong,
3848}
3849#[repr(C)]
3850#[derive(Debug, Copy, Clone)]
3851pub struct ulonglong3 {
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}
3856#[repr(C)]
3857#[derive(Debug, Copy, Clone)]
3858pub struct ulonglong4 {
3859 pub x: ::std::os::raw::c_ulonglong,
3860 pub y: ::std::os::raw::c_ulonglong,
3861 pub z: ::std::os::raw::c_ulonglong,
3862 pub w: ::std::os::raw::c_ulonglong,
3863}
3864#[repr(C)]
3865#[derive(Debug, Copy, Clone)]
3866pub struct longlong1 {
3867 pub x: ::std::os::raw::c_longlong,
3868}
3869#[repr(C)]
3870#[derive(Debug, Copy, Clone)]
3871pub struct longlong2 {
3872 pub x: ::std::os::raw::c_longlong,
3873 pub y: ::std::os::raw::c_longlong,
3874}
3875#[repr(C)]
3876#[derive(Debug, Copy, Clone)]
3877pub struct longlong3 {
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}
3882#[repr(C)]
3883#[derive(Debug, Copy, Clone)]
3884pub struct longlong4 {
3885 pub x: ::std::os::raw::c_longlong,
3886 pub y: ::std::os::raw::c_longlong,
3887 pub z: ::std::os::raw::c_longlong,
3888 pub w: ::std::os::raw::c_longlong,
3889}
3890#[repr(C)]
3891#[derive(Debug, Copy, Clone)]
3892pub struct float1 {
3893 pub x: f32,
3894}
3895#[repr(C)]
3896#[derive(Debug, Copy, Clone)]
3897pub struct float2 {
3898 pub x: f32,
3899 pub y: f32,
3900}
3901#[repr(C)]
3902#[derive(Debug, Copy, Clone)]
3903pub struct float3 {
3904 pub x: f32,
3905 pub y: f32,
3906 pub z: f32,
3907}
3908#[repr(C)]
3909#[derive(Debug, Copy, Clone)]
3910pub struct float4 {
3911 pub x: f32,
3912 pub y: f32,
3913 pub z: f32,
3914 pub w: f32,
3915}
3916#[repr(C)]
3917#[derive(Debug, Copy, Clone)]
3918pub struct double1 {
3919 pub x: f64,
3920}
3921#[repr(C)]
3922#[derive(Debug, Copy, Clone)]
3923pub struct double2 {
3924 pub x: f64,
3925 pub y: f64,
3926}
3927#[repr(C)]
3928#[derive(Debug, Copy, Clone)]
3929pub struct double3 {
3930 pub x: f64,
3931 pub y: f64,
3932 pub z: f64,
3933}
3934#[repr(C)]
3935#[derive(Debug, Copy, Clone)]
3936pub struct double4 {
3937 pub x: f64,
3938 pub y: f64,
3939 pub z: f64,
3940 pub w: f64,
3941}
3942extern "C" {
3943 pub fn hipCreateChannelDesc(
3944 x: ::std::os::raw::c_int,
3945 y: ::std::os::raw::c_int,
3946 z: ::std::os::raw::c_int,
3947 w: ::std::os::raw::c_int,
3948 f: hipChannelFormatKind,
3949 ) -> hipChannelFormatDesc;
3950}
3951#[doc = " An opaque value that represents a hip texture object"]
3952#[repr(C)]
3953#[derive(Debug, Copy, Clone)]
3954pub struct __hip_texture {
3955 _unused: [u8; 0],
3956}
3957pub type hipTextureObject_t = *mut __hip_texture;
3958pub const hipTextureAddressMode_hipAddressModeWrap: hipTextureAddressMode = 0;
3959pub const hipTextureAddressMode_hipAddressModeClamp: hipTextureAddressMode = 1;
3960pub const hipTextureAddressMode_hipAddressModeMirror: hipTextureAddressMode = 2;
3961pub const hipTextureAddressMode_hipAddressModeBorder: hipTextureAddressMode = 3;
3962#[doc = " hip texture address modes"]
3963pub type hipTextureAddressMode = ::std::os::raw::c_uint;
3964pub const hipTextureFilterMode_hipFilterModePoint: hipTextureFilterMode = 0;
3965pub const hipTextureFilterMode_hipFilterModeLinear: hipTextureFilterMode = 1;
3966#[doc = " hip texture filter modes"]
3967pub type hipTextureFilterMode = ::std::os::raw::c_uint;
3968pub const hipTextureReadMode_hipReadModeElementType: hipTextureReadMode = 0;
3969pub const hipTextureReadMode_hipReadModeNormalizedFloat: hipTextureReadMode = 1;
3970#[doc = " hip texture read modes"]
3971pub type hipTextureReadMode = ::std::os::raw::c_uint;
3972#[doc = " hip texture reference"]
3973#[repr(C)]
3974#[derive(Debug, Copy, Clone)]
3975pub struct textureReference {
3976 pub normalized: ::std::os::raw::c_int,
3977 pub readMode: hipTextureReadMode,
3978 pub filterMode: hipTextureFilterMode,
3979 pub addressMode: [hipTextureAddressMode; 3usize],
3980 pub channelDesc: hipChannelFormatDesc,
3981 pub sRGB: ::std::os::raw::c_int,
3982 pub maxAnisotropy: ::std::os::raw::c_uint,
3983 pub mipmapFilterMode: hipTextureFilterMode,
3984 pub mipmapLevelBias: f32,
3985 pub minMipmapLevelClamp: f32,
3986 pub maxMipmapLevelClamp: f32,
3987 pub textureObject: hipTextureObject_t,
3988 pub numChannels: ::std::os::raw::c_int,
3989 pub format: hipArray_Format,
3990}
3991#[doc = " hip texture descriptor"]
3992#[repr(C)]
3993#[derive(Debug, Copy, Clone)]
3994pub struct hipTextureDesc {
3995 pub addressMode: [hipTextureAddressMode; 3usize],
3996 pub filterMode: hipTextureFilterMode,
3997 pub readMode: hipTextureReadMode,
3998 pub sRGB: ::std::os::raw::c_int,
3999 pub borderColor: [f32; 4usize],
4000 pub normalizedCoords: ::std::os::raw::c_int,
4001 pub maxAnisotropy: ::std::os::raw::c_uint,
4002 pub mipmapFilterMode: hipTextureFilterMode,
4003 pub mipmapLevelBias: f32,
4004 pub minMipmapLevelClamp: f32,
4005 pub maxMipmapLevelClamp: f32,
4006}
4007#[doc = " An opaque value that represents a hip surface object"]
4008#[repr(C)]
4009#[derive(Debug, Copy, Clone)]
4010pub struct __hip_surface {
4011 _unused: [u8; 0],
4012}
4013pub type hipSurfaceObject_t = *mut __hip_surface;
4014#[doc = " hip surface reference"]
4015#[repr(C)]
4016#[derive(Debug, Copy, Clone)]
4017pub struct surfaceReference {
4018 pub surfaceObject: hipSurfaceObject_t,
4019}
4020pub const hipSurfaceBoundaryMode_hipBoundaryModeZero: hipSurfaceBoundaryMode = 0;
4021pub const hipSurfaceBoundaryMode_hipBoundaryModeTrap: hipSurfaceBoundaryMode = 1;
4022pub const hipSurfaceBoundaryMode_hipBoundaryModeClamp: hipSurfaceBoundaryMode = 2;
4023#[doc = " hip surface boundary modes"]
4024pub type hipSurfaceBoundaryMode = ::std::os::raw::c_uint;
4025#[repr(C)]
4026#[derive(Debug, Copy, Clone)]
4027pub struct ihipCtx_t {
4028 _unused: [u8; 0],
4029}
4030pub type hipCtx_t = *mut ihipCtx_t;
4031pub type hipDevice_t = ::std::os::raw::c_int;
4032pub const hipDeviceP2PAttr_hipDevP2PAttrPerformanceRank: hipDeviceP2PAttr = 0;
4033pub const hipDeviceP2PAttr_hipDevP2PAttrAccessSupported: hipDeviceP2PAttr = 1;
4034pub const hipDeviceP2PAttr_hipDevP2PAttrNativeAtomicSupported: hipDeviceP2PAttr = 2;
4035pub const hipDeviceP2PAttr_hipDevP2PAttrHipArrayAccessSupported: hipDeviceP2PAttr = 3;
4036pub type hipDeviceP2PAttr = ::std::os::raw::c_uint;
4037#[repr(C)]
4038#[derive(Debug, Copy, Clone)]
4039pub struct ihipStream_t {
4040 _unused: [u8; 0],
4041}
4042pub type hipStream_t = *mut ihipStream_t;
4043#[repr(C)]
4044#[derive(Debug, Copy, Clone)]
4045pub struct hipIpcMemHandle_st {
4046 pub reserved: [::std::os::raw::c_char; 64usize],
4047}
4048pub type hipIpcMemHandle_t = hipIpcMemHandle_st;
4049#[repr(C)]
4050#[derive(Debug, Copy, Clone)]
4051pub struct hipIpcEventHandle_st {
4052 pub reserved: [::std::os::raw::c_char; 64usize],
4053}
4054pub type hipIpcEventHandle_t = hipIpcEventHandle_st;
4055#[repr(C)]
4056#[derive(Debug, Copy, Clone)]
4057pub struct ihipModule_t {
4058 _unused: [u8; 0],
4059}
4060pub type hipModule_t = *mut ihipModule_t;
4061#[repr(C)]
4062#[derive(Debug, Copy, Clone)]
4063pub struct ihipModuleSymbol_t {
4064 _unused: [u8; 0],
4065}
4066pub type hipFunction_t = *mut ihipModuleSymbol_t;
4067#[repr(C)]
4068#[derive(Debug, Copy, Clone)]
4069pub struct ihipLinkState_t {
4070 _unused: [u8; 0],
4071}
4072pub type hipLinkState_t = *mut ihipLinkState_t;
4073#[repr(C)]
4074#[derive(Debug, Copy, Clone)]
4075pub struct ihipMemPoolHandle_t {
4076 _unused: [u8; 0],
4077}
4078#[doc = " HIP memory pool"]
4079pub type hipMemPool_t = *mut ihipMemPoolHandle_t;
4080#[repr(C)]
4081#[derive(Debug, Copy, Clone)]
4082pub struct hipFuncAttributes {
4083 pub binaryVersion: ::std::os::raw::c_int,
4084 pub cacheModeCA: ::std::os::raw::c_int,
4085 pub constSizeBytes: usize,
4086 pub localSizeBytes: usize,
4087 pub maxDynamicSharedSizeBytes: ::std::os::raw::c_int,
4088 pub maxThreadsPerBlock: ::std::os::raw::c_int,
4089 pub numRegs: ::std::os::raw::c_int,
4090 pub preferredShmemCarveout: ::std::os::raw::c_int,
4091 pub ptxVersion: ::std::os::raw::c_int,
4092 pub sharedSizeBytes: usize,
4093}
4094#[repr(C)]
4095#[derive(Debug, Copy, Clone)]
4096pub struct ihipEvent_t {
4097 _unused: [u8; 0],
4098}
4099pub type hipEvent_t = *mut ihipEvent_t;
4100#[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)"]
4101pub const hipLimit_t_hipLimitStackSize: hipLimit_t = 0;
4102#[doc = "< Size limit in bytes of fifo used by printf call on the\n< device. Currently not supported"]
4103pub const hipLimit_t_hipLimitPrintfFifoSize: hipLimit_t = 1;
4104#[doc = "< Limit of heap size in bytes on the current device, should\n< be less than the global memory size on the device"]
4105pub const hipLimit_t_hipLimitMallocHeapSize: hipLimit_t = 2;
4106#[doc = "< Supported limit range"]
4107pub const hipLimit_t_hipLimitRange: hipLimit_t = 3;
4108#[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."]
4109pub type hipLimit_t = ::std::os::raw::c_uint;
4110pub const hipStreamBatchMemOpType_hipStreamMemOpWaitValue32: hipStreamBatchMemOpType = 1;
4111pub const hipStreamBatchMemOpType_hipStreamMemOpWriteValue32: hipStreamBatchMemOpType = 2;
4112pub const hipStreamBatchMemOpType_hipStreamMemOpWaitValue64: hipStreamBatchMemOpType = 4;
4113pub const hipStreamBatchMemOpType_hipStreamMemOpWriteValue64: hipStreamBatchMemOpType = 5;
4114#[doc = "< Currently not supported"]
4115pub const hipStreamBatchMemOpType_hipStreamMemOpBarrier: hipStreamBatchMemOpType = 6;
4116#[doc = "< Currently not supported"]
4117pub const hipStreamBatchMemOpType_hipStreamMemOpFlushRemoteWrites: hipStreamBatchMemOpType = 3;
4118#[doc = " Operations for hipStreamBatchMemOp"]
4119pub type hipStreamBatchMemOpType = ::std::os::raw::c_uint;
4120#[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"]
4121#[repr(C)]
4122#[derive(Copy, Clone)]
4123pub union hipStreamBatchMemOpParams_union {
4124 pub operation: hipStreamBatchMemOpType,
4125 pub waitValue: hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t,
4126 pub writeValue: hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t,
4127 #[doc = "< Currently not supported on AMD"]
4128 pub flushRemoteWrites: hipStreamBatchMemOpParams_union_hipStreamMemOpFlushRemoteWritesParams_t,
4129 #[doc = "< Currently not supported on AMD"]
4130 pub memoryBarrier: hipStreamBatchMemOpParams_union_hipStreamMemOpMemoryBarrierParams_t,
4131 pub pad: [u64; 6usize],
4132}
4133#[repr(C)]
4134#[derive(Copy, Clone)]
4135pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t {
4136 pub operation: hipStreamBatchMemOpType,
4137 pub address: hipDeviceptr_t,
4138 pub __bindgen_anon_1:
4139 hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t__bindgen_ty_1,
4140 pub flags: ::std::os::raw::c_uint,
4141 #[doc = "< Not valid for AMD backend. Initial value is unimportant"]
4142 pub alias: hipDeviceptr_t,
4143}
4144#[repr(C)]
4145#[derive(Copy, Clone)]
4146pub union hipStreamBatchMemOpParams_union_hipStreamMemOpWaitValueParams_t__bindgen_ty_1 {
4147 pub value: u32,
4148 pub value64: u64,
4149}
4150#[repr(C)]
4151#[derive(Copy, Clone)]
4152pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t {
4153 pub operation: hipStreamBatchMemOpType,
4154 pub address: hipDeviceptr_t,
4155 pub __bindgen_anon_1:
4156 hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t__bindgen_ty_1,
4157 pub flags: ::std::os::raw::c_uint,
4158 #[doc = "< Not valid for AMD backend. Initial value is unimportant"]
4159 pub alias: hipDeviceptr_t,
4160}
4161#[repr(C)]
4162#[derive(Copy, Clone)]
4163pub union hipStreamBatchMemOpParams_union_hipStreamMemOpWriteValueParams_t__bindgen_ty_1 {
4164 pub value: u32,
4165 pub value64: u64,
4166}
4167#[repr(C)]
4168#[derive(Debug, Copy, Clone)]
4169pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpFlushRemoteWritesParams_t {
4170 pub operation: hipStreamBatchMemOpType,
4171 pub flags: ::std::os::raw::c_uint,
4172}
4173#[repr(C)]
4174#[derive(Debug, Copy, Clone)]
4175pub struct hipStreamBatchMemOpParams_union_hipStreamMemOpMemoryBarrierParams_t {
4176 pub operation: hipStreamBatchMemOpType,
4177 pub flags: ::std::os::raw::c_uint,
4178}
4179#[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"]
4180pub type hipStreamBatchMemOpParams = hipStreamBatchMemOpParams_union;
4181#[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"]
4182#[repr(C)]
4183#[derive(Debug, Copy, Clone)]
4184pub struct hipBatchMemOpNodeParams {
4185 pub ctx: hipCtx_t,
4186 pub count: ::std::os::raw::c_uint,
4187 pub paramArray: *mut hipStreamBatchMemOpParams,
4188 pub flags: ::std::os::raw::c_uint,
4189}
4190#[doc = "< Data will mostly be read and only occassionally\n< be written to"]
4191pub const hipMemoryAdvise_hipMemAdviseSetReadMostly: hipMemoryAdvise = 1;
4192#[doc = "< Undo the effect of hipMemAdviseSetReadMostly"]
4193pub const hipMemoryAdvise_hipMemAdviseUnsetReadMostly: hipMemoryAdvise = 2;
4194#[doc = "< Set the preferred location for the data as\n< the specified device"]
4195pub const hipMemoryAdvise_hipMemAdviseSetPreferredLocation: hipMemoryAdvise = 3;
4196#[doc = "< Clear the preferred location for the data"]
4197pub const hipMemoryAdvise_hipMemAdviseUnsetPreferredLocation: hipMemoryAdvise = 4;
4198#[doc = "< Data will be accessed by the specified device\n< so prevent page faults as much as possible"]
4199pub const hipMemoryAdvise_hipMemAdviseSetAccessedBy: hipMemoryAdvise = 5;
4200#[doc = "< Let HIP to decide on the page faulting policy\n< for the specified device"]
4201pub const hipMemoryAdvise_hipMemAdviseUnsetAccessedBy: hipMemoryAdvise = 6;
4202#[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"]
4203pub const hipMemoryAdvise_hipMemAdviseSetCoarseGrain: hipMemoryAdvise = 100;
4204#[doc = "< Restores cache coherency policy back to fine-grain"]
4205pub const hipMemoryAdvise_hipMemAdviseUnsetCoarseGrain: hipMemoryAdvise = 101;
4206#[doc = " HIP Memory Advise values\n\n @note This memory advise enumeration is used on Linux, not Windows."]
4207pub type hipMemoryAdvise = ::std::os::raw::c_uint;
4208#[doc = "< Updates to memory with this attribute can be\n< done coherently from all devices"]
4209pub const hipMemRangeCoherencyMode_hipMemRangeCoherencyModeFineGrain: hipMemRangeCoherencyMode = 0;
4210#[doc = "< Writes to memory with this attribute can be\n< performed by a single device at a time"]
4211pub const hipMemRangeCoherencyMode_hipMemRangeCoherencyModeCoarseGrain: hipMemRangeCoherencyMode =
4212 1;
4213#[doc = "< Memory region queried contains subregions with\n< both hipMemRangeCoherencyModeFineGrain and\n< hipMemRangeCoherencyModeCoarseGrain attributes"]
4214pub const hipMemRangeCoherencyMode_hipMemRangeCoherencyModeIndeterminate: hipMemRangeCoherencyMode =
4215 2;
4216#[doc = " HIP Coherency Mode"]
4217pub type hipMemRangeCoherencyMode = ::std::os::raw::c_uint;
4218#[doc = "< Whether the range will mostly be read and\n< only occassionally be written to"]
4219pub const hipMemRangeAttribute_hipMemRangeAttributeReadMostly: hipMemRangeAttribute = 1;
4220#[doc = "< The preferred location of the range"]
4221pub const hipMemRangeAttribute_hipMemRangeAttributePreferredLocation: hipMemRangeAttribute = 2;
4222#[doc = "< Memory range has hipMemAdviseSetAccessedBy\n< set for the specified device"]
4223pub const hipMemRangeAttribute_hipMemRangeAttributeAccessedBy: hipMemRangeAttribute = 3;
4224#[doc = "< The last location to where the range was\n< prefetched"]
4225pub const hipMemRangeAttribute_hipMemRangeAttributeLastPrefetchLocation: hipMemRangeAttribute = 4;
4226#[doc = "< Returns coherency mode\n< @ref hipMemRangeCoherencyMode for the range"]
4227pub const hipMemRangeAttribute_hipMemRangeAttributeCoherencyMode: hipMemRangeAttribute = 100;
4228#[doc = " HIP range attributes"]
4229pub type hipMemRangeAttribute = ::std::os::raw::c_uint;
4230#[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)"]
4231pub const hipMemPoolAttr_hipMemPoolReuseFollowEventDependencies: hipMemPoolAttr = 1;
4232#[doc = " (value type = int)\n Allow reuse of already completed frees when there is no dependency\n between the free and allocation. (default enabled)"]
4233pub const hipMemPoolAttr_hipMemPoolReuseAllowOpportunistic: hipMemPoolAttr = 2;
4234#[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)."]
4235pub const hipMemPoolAttr_hipMemPoolReuseAllowInternalDependencies: hipMemPoolAttr = 3;
4236#[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)"]
4237pub const hipMemPoolAttr_hipMemPoolAttrReleaseThreshold: hipMemPoolAttr = 4;
4238#[doc = " (value type = uint64_t)\n Amount of backing memory currently allocated for the mempool."]
4239pub const hipMemPoolAttr_hipMemPoolAttrReservedMemCurrent: hipMemPoolAttr = 5;
4240#[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."]
4241pub const hipMemPoolAttr_hipMemPoolAttrReservedMemHigh: hipMemPoolAttr = 6;
4242#[doc = " (value type = uint64_t)\n Amount of memory from the pool that is currently in use by the application."]
4243pub const hipMemPoolAttr_hipMemPoolAttrUsedMemCurrent: hipMemPoolAttr = 7;
4244#[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."]
4245pub const hipMemPoolAttr_hipMemPoolAttrUsedMemHigh: hipMemPoolAttr = 8;
4246#[doc = " HIP memory pool attributes"]
4247pub type hipMemPoolAttr = ::std::os::raw::c_uint;
4248pub const hipMemLocationType_hipMemLocationTypeInvalid: hipMemLocationType = 0;
4249#[doc = "< Device location, thus it's HIP device ID"]
4250pub const hipMemLocationType_hipMemLocationTypeDevice: hipMemLocationType = 1;
4251#[doc = " Specifies the type of location"]
4252pub type hipMemLocationType = ::std::os::raw::c_uint;
4253#[doc = " Specifies a memory location.\n\n To specify a gpu, set type = @p hipMemLocationTypeDevice and set id = the gpu's device ID"]
4254#[repr(C)]
4255#[derive(Debug, Copy, Clone)]
4256pub struct hipMemLocation {
4257 #[doc = "< Specifies the location type, which describes the meaning of id"]
4258 pub type_: hipMemLocationType,
4259 #[doc = "< Identifier for the provided location type @p hipMemLocationType"]
4260 pub id: ::std::os::raw::c_int,
4261}
4262#[doc = "< Default, make the address range not accessible"]
4263pub const hipMemAccessFlags_hipMemAccessFlagsProtNone: hipMemAccessFlags = 0;
4264#[doc = "< Set the address range read accessible"]
4265pub const hipMemAccessFlags_hipMemAccessFlagsProtRead: hipMemAccessFlags = 1;
4266#[doc = "< Set the address range read-write accessible"]
4267pub const hipMemAccessFlags_hipMemAccessFlagsProtReadWrite: hipMemAccessFlags = 3;
4268#[doc = " Specifies the memory protection flags for mapping\n"]
4269pub type hipMemAccessFlags = ::std::os::raw::c_uint;
4270#[doc = " Memory access descriptor"]
4271#[repr(C)]
4272#[derive(Debug, Copy, Clone)]
4273pub struct hipMemAccessDesc {
4274 #[doc = "< Location on which the accessibility has to change"]
4275 pub location: hipMemLocation,
4276 #[doc = "< Accessibility flags to set"]
4277 pub flags: hipMemAccessFlags,
4278}
4279pub const hipMemAllocationType_hipMemAllocationTypeInvalid: hipMemAllocationType = 0;
4280#[doc = " This allocation type is 'pinned', i.e. cannot migrate from its current\n location while the application is actively using it"]
4281pub const hipMemAllocationType_hipMemAllocationTypePinned: hipMemAllocationType = 1;
4282#[doc = " This allocation type is 'pinned', i.e. cannot migrate from its current\n location while the application is actively using it"]
4283pub const hipMemAllocationType_hipMemAllocationTypeMax: hipMemAllocationType = 2147483647;
4284#[doc = " Defines the allocation types"]
4285pub type hipMemAllocationType = ::std::os::raw::c_uint;
4286#[doc = "< Does not allow any export mechanism"]
4287pub const hipMemAllocationHandleType_hipMemHandleTypeNone: hipMemAllocationHandleType = 0;
4288#[doc = "< Allows a file descriptor for exporting. Permitted only on POSIX systems"]
4289pub const hipMemAllocationHandleType_hipMemHandleTypePosixFileDescriptor:
4290 hipMemAllocationHandleType = 1;
4291#[doc = "< Allows a Win32 NT handle for exporting. (HANDLE)"]
4292pub const hipMemAllocationHandleType_hipMemHandleTypeWin32: hipMemAllocationHandleType = 2;
4293#[doc = "< Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)"]
4294pub const hipMemAllocationHandleType_hipMemHandleTypeWin32Kmt: hipMemAllocationHandleType = 4;
4295#[doc = " Flags for specifying handle types for memory pool allocations\n"]
4296pub type hipMemAllocationHandleType = ::std::os::raw::c_uint;
4297#[doc = " Specifies the properties of allocations made from the pool."]
4298#[repr(C)]
4299#[derive(Debug, Copy, Clone)]
4300pub struct hipMemPoolProps {
4301 #[doc = "< Allocation type. Currently must be specified as @p hipMemAllocationTypePinned"]
4302 pub allocType: hipMemAllocationType,
4303 #[doc = "< Handle types that will be supported by allocations from the pool"]
4304 pub handleTypes: hipMemAllocationHandleType,
4305 #[doc = "< Location where allocations should reside"]
4306 pub location: hipMemLocation,
4307 #[doc = " Windows-specific LPSECURITYATTRIBUTES required when @p hipMemHandleTypeWin32 is specified"]
4308 pub win32SecurityAttributes: *mut ::std::os::raw::c_void,
4309 #[doc = "< Maximum pool size. When set to 0, defaults to a system dependent value"]
4310 pub maxSize: usize,
4311 #[doc = "< Reserved for future use, must be 0"]
4312 pub reserved: [::std::os::raw::c_uchar; 56usize],
4313}
4314#[doc = " Opaque data structure for exporting a pool allocation"]
4315#[repr(C)]
4316#[derive(Debug, Copy, Clone)]
4317pub struct hipMemPoolPtrExportData {
4318 pub reserved: [::std::os::raw::c_uchar; 64usize],
4319}
4320pub const hipFuncAttribute_hipFuncAttributeMaxDynamicSharedMemorySize: hipFuncAttribute = 8;
4321pub const hipFuncAttribute_hipFuncAttributePreferredSharedMemoryCarveout: hipFuncAttribute = 9;
4322pub const hipFuncAttribute_hipFuncAttributeMax: hipFuncAttribute = 10;
4323#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
4324pub type hipFuncAttribute = ::std::os::raw::c_uint;
4325#[doc = "< no preference for shared memory or L1 (default)"]
4326pub const hipFuncCache_t_hipFuncCachePreferNone: hipFuncCache_t = 0;
4327#[doc = "< prefer larger shared memory and smaller L1 cache"]
4328pub const hipFuncCache_t_hipFuncCachePreferShared: hipFuncCache_t = 1;
4329#[doc = "< prefer larger L1 cache and smaller shared memory"]
4330pub const hipFuncCache_t_hipFuncCachePreferL1: hipFuncCache_t = 2;
4331#[doc = "< prefer equal size L1 cache and shared memory"]
4332pub const hipFuncCache_t_hipFuncCachePreferEqual: hipFuncCache_t = 3;
4333#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
4334pub type hipFuncCache_t = ::std::os::raw::c_uint;
4335#[doc = "< The compiler selects a device-specific value for the banking."]
4336pub const hipSharedMemConfig_hipSharedMemBankSizeDefault: hipSharedMemConfig = 0;
4337#[doc = "< Shared mem is banked at 4-bytes intervals and performs best\n< when adjacent threads access data 4 bytes apart."]
4338pub const hipSharedMemConfig_hipSharedMemBankSizeFourByte: hipSharedMemConfig = 1;
4339#[doc = "< Shared mem is banked at 8-byte intervals and performs best\n< when adjacent threads access data 4 bytes apart."]
4340pub const hipSharedMemConfig_hipSharedMemBankSizeEightByte: hipSharedMemConfig = 2;
4341#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
4342pub type hipSharedMemConfig = ::std::os::raw::c_uint;
4343#[doc = " Struct for data in 3D"]
4344#[repr(C)]
4345#[derive(Debug, Copy, Clone)]
4346pub struct dim3 {
4347 #[doc = "< x"]
4348 pub x: u32,
4349 #[doc = "< y"]
4350 pub y: u32,
4351 #[doc = "< z"]
4352 pub z: u32,
4353}
4354#[doc = " struct hipLaunchParams_t"]
4355#[repr(C)]
4356#[derive(Debug, Copy, Clone)]
4357pub struct hipLaunchParams_t {
4358 #[doc = "< Device function symbol"]
4359 pub func: *mut ::std::os::raw::c_void,
4360 #[doc = "< Grid dimensions"]
4361 pub gridDim: dim3,
4362 #[doc = "< Block dimensions"]
4363 pub blockDim: dim3,
4364 #[doc = "< Arguments"]
4365 pub args: *mut *mut ::std::os::raw::c_void,
4366 #[doc = "< Shared memory"]
4367 pub sharedMem: usize,
4368 #[doc = "< Stream identifier"]
4369 pub stream: hipStream_t,
4370}
4371#[doc = " struct hipLaunchParams_t"]
4372pub type hipLaunchParams = hipLaunchParams_t;
4373#[doc = " struct hipFunctionLaunchParams_t"]
4374#[repr(C)]
4375#[derive(Debug, Copy, Clone)]
4376pub struct hipFunctionLaunchParams_t {
4377 #[doc = "< Kernel to launch"]
4378 pub function: hipFunction_t,
4379 #[doc = "< Width(X) of grid in blocks"]
4380 pub gridDimX: ::std::os::raw::c_uint,
4381 #[doc = "< Height(Y) of grid in blocks"]
4382 pub gridDimY: ::std::os::raw::c_uint,
4383 #[doc = "< Depth(Z) of grid in blocks"]
4384 pub gridDimZ: ::std::os::raw::c_uint,
4385 #[doc = "< X dimension of each thread block"]
4386 pub blockDimX: ::std::os::raw::c_uint,
4387 #[doc = "< Y dimension of each thread block"]
4388 pub blockDimY: ::std::os::raw::c_uint,
4389 #[doc = "< Z dimension of each thread block"]
4390 pub blockDimZ: ::std::os::raw::c_uint,
4391 #[doc = "< Shared memory"]
4392 pub sharedMemBytes: ::std::os::raw::c_uint,
4393 #[doc = "< Stream identifier"]
4394 pub hStream: hipStream_t,
4395 #[doc = "< Kernel parameters"]
4396 pub kernelParams: *mut *mut ::std::os::raw::c_void,
4397}
4398#[doc = " struct hipFunctionLaunchParams_t"]
4399pub type hipFunctionLaunchParams = hipFunctionLaunchParams_t;
4400pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeOpaqueFd:
4401 hipExternalMemoryHandleType_enum = 1;
4402pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeOpaqueWin32:
4403 hipExternalMemoryHandleType_enum = 2;
4404pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeOpaqueWin32Kmt:
4405 hipExternalMemoryHandleType_enum = 3;
4406pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D12Heap:
4407 hipExternalMemoryHandleType_enum = 4;
4408pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D12Resource:
4409 hipExternalMemoryHandleType_enum = 5;
4410pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D11Resource:
4411 hipExternalMemoryHandleType_enum = 6;
4412pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeD3D11ResourceKmt:
4413 hipExternalMemoryHandleType_enum = 7;
4414pub const hipExternalMemoryHandleType_enum_hipExternalMemoryHandleTypeNvSciBuf:
4415 hipExternalMemoryHandleType_enum = 8;
4416pub type hipExternalMemoryHandleType_enum = ::std::os::raw::c_uint;
4417pub use self::hipExternalMemoryHandleType_enum as hipExternalMemoryHandleType;
4418#[repr(C)]
4419#[derive(Copy, Clone)]
4420pub struct hipExternalMemoryHandleDesc_st {
4421 pub type_: hipExternalMemoryHandleType,
4422 pub handle: hipExternalMemoryHandleDesc_st__bindgen_ty_1,
4423 pub size: ::std::os::raw::c_ulonglong,
4424 pub flags: ::std::os::raw::c_uint,
4425 pub reserved: [::std::os::raw::c_uint; 16usize],
4426}
4427#[repr(C)]
4428#[derive(Copy, Clone)]
4429pub union hipExternalMemoryHandleDesc_st__bindgen_ty_1 {
4430 pub fd: ::std::os::raw::c_int,
4431 pub win32: hipExternalMemoryHandleDesc_st__bindgen_ty_1__bindgen_ty_1,
4432 pub nvSciBufObject: *const ::std::os::raw::c_void,
4433}
4434#[repr(C)]
4435#[derive(Debug, Copy, Clone)]
4436pub struct hipExternalMemoryHandleDesc_st__bindgen_ty_1__bindgen_ty_1 {
4437 pub handle: *mut ::std::os::raw::c_void,
4438 pub name: *const ::std::os::raw::c_void,
4439}
4440pub type hipExternalMemoryHandleDesc = hipExternalMemoryHandleDesc_st;
4441#[repr(C)]
4442#[derive(Debug, Copy, Clone)]
4443pub struct hipExternalMemoryBufferDesc_st {
4444 pub offset: ::std::os::raw::c_ulonglong,
4445 pub size: ::std::os::raw::c_ulonglong,
4446 pub flags: ::std::os::raw::c_uint,
4447 pub reserved: [::std::os::raw::c_uint; 16usize],
4448}
4449pub type hipExternalMemoryBufferDesc = hipExternalMemoryBufferDesc_st;
4450#[repr(C)]
4451#[derive(Debug, Copy, Clone)]
4452pub struct hipExternalMemoryMipmappedArrayDesc_st {
4453 pub offset: ::std::os::raw::c_ulonglong,
4454 pub formatDesc: hipChannelFormatDesc,
4455 pub extent: hipExtent,
4456 pub flags: ::std::os::raw::c_uint,
4457 pub numLevels: ::std::os::raw::c_uint,
4458}
4459pub type hipExternalMemoryMipmappedArrayDesc = hipExternalMemoryMipmappedArrayDesc_st;
4460pub type hipExternalMemory_t = *mut ::std::os::raw::c_void;
4461pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeOpaqueFd:
4462 hipExternalSemaphoreHandleType_enum = 1;
4463pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeOpaqueWin32:
4464 hipExternalSemaphoreHandleType_enum = 2;
4465pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeOpaqueWin32Kmt:
4466 hipExternalSemaphoreHandleType_enum = 3;
4467pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeD3D12Fence:
4468 hipExternalSemaphoreHandleType_enum = 4;
4469pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeD3D11Fence:
4470 hipExternalSemaphoreHandleType_enum = 5;
4471pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeNvSciSync:
4472 hipExternalSemaphoreHandleType_enum = 6;
4473pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeKeyedMutex:
4474 hipExternalSemaphoreHandleType_enum = 7;
4475pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeKeyedMutexKmt:
4476 hipExternalSemaphoreHandleType_enum = 8;
4477pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeTimelineSemaphoreFd:
4478 hipExternalSemaphoreHandleType_enum = 9;
4479pub const hipExternalSemaphoreHandleType_enum_hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 : hipExternalSemaphoreHandleType_enum = 10 ;
4480pub type hipExternalSemaphoreHandleType_enum = ::std::os::raw::c_uint;
4481pub use self::hipExternalSemaphoreHandleType_enum as hipExternalSemaphoreHandleType;
4482#[repr(C)]
4483#[derive(Copy, Clone)]
4484pub struct hipExternalSemaphoreHandleDesc_st {
4485 pub type_: hipExternalSemaphoreHandleType,
4486 pub handle: hipExternalSemaphoreHandleDesc_st__bindgen_ty_1,
4487 pub flags: ::std::os::raw::c_uint,
4488 pub reserved: [::std::os::raw::c_uint; 16usize],
4489}
4490#[repr(C)]
4491#[derive(Copy, Clone)]
4492pub union hipExternalSemaphoreHandleDesc_st__bindgen_ty_1 {
4493 pub fd: ::std::os::raw::c_int,
4494 pub win32: hipExternalSemaphoreHandleDesc_st__bindgen_ty_1__bindgen_ty_1,
4495 pub NvSciSyncObj: *const ::std::os::raw::c_void,
4496}
4497#[repr(C)]
4498#[derive(Debug, Copy, Clone)]
4499pub struct hipExternalSemaphoreHandleDesc_st__bindgen_ty_1__bindgen_ty_1 {
4500 pub handle: *mut ::std::os::raw::c_void,
4501 pub name: *const ::std::os::raw::c_void,
4502}
4503pub type hipExternalSemaphoreHandleDesc = hipExternalSemaphoreHandleDesc_st;
4504pub type hipExternalSemaphore_t = *mut ::std::os::raw::c_void;
4505#[repr(C)]
4506#[derive(Copy, Clone)]
4507pub struct hipExternalSemaphoreSignalParams_st {
4508 pub params: hipExternalSemaphoreSignalParams_st__bindgen_ty_1,
4509 pub flags: ::std::os::raw::c_uint,
4510 pub reserved: [::std::os::raw::c_uint; 16usize],
4511}
4512#[repr(C)]
4513#[derive(Copy, Clone)]
4514pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1 {
4515 pub fence: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_1,
4516 pub nvSciSync: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_2,
4517 pub keyedMutex: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_3,
4518 pub reserved: [::std::os::raw::c_uint; 12usize],
4519}
4520#[repr(C)]
4521#[derive(Debug, Copy, Clone)]
4522pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_1 {
4523 pub value: ::std::os::raw::c_ulonglong,
4524}
4525#[repr(C)]
4526#[derive(Copy, Clone)]
4527pub union hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_2 {
4528 pub fence: *mut ::std::os::raw::c_void,
4529 pub reserved: ::std::os::raw::c_ulonglong,
4530}
4531#[repr(C)]
4532#[derive(Debug, Copy, Clone)]
4533pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_3 {
4534 pub key: ::std::os::raw::c_ulonglong,
4535}
4536pub type hipExternalSemaphoreSignalParams = hipExternalSemaphoreSignalParams_st;
4537#[doc = " External semaphore wait parameters, compatible with driver type"]
4538#[repr(C)]
4539#[derive(Copy, Clone)]
4540pub struct hipExternalSemaphoreWaitParams_st {
4541 pub params: hipExternalSemaphoreWaitParams_st__bindgen_ty_1,
4542 pub flags: ::std::os::raw::c_uint,
4543 pub reserved: [::std::os::raw::c_uint; 16usize],
4544}
4545#[repr(C)]
4546#[derive(Copy, Clone)]
4547pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1 {
4548 pub fence: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_1,
4549 pub nvSciSync: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_2,
4550 pub keyedMutex: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_3,
4551 pub reserved: [::std::os::raw::c_uint; 10usize],
4552}
4553#[repr(C)]
4554#[derive(Debug, Copy, Clone)]
4555pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_1 {
4556 pub value: ::std::os::raw::c_ulonglong,
4557}
4558#[repr(C)]
4559#[derive(Copy, Clone)]
4560pub union hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_2 {
4561 pub fence: *mut ::std::os::raw::c_void,
4562 pub reserved: ::std::os::raw::c_ulonglong,
4563}
4564#[repr(C)]
4565#[derive(Debug, Copy, Clone)]
4566pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_3 {
4567 pub key: ::std::os::raw::c_ulonglong,
4568 pub timeoutMs: ::std::os::raw::c_uint,
4569}
4570#[doc = " External semaphore wait parameters, compatible with driver type"]
4571pub type hipExternalSemaphoreWaitParams = hipExternalSemaphoreWaitParams_st;
4572extern "C" {
4573 #[doc = " Internal use only. This API may change in the future\n Pre-Compiled header for online compilation"]
4574 pub fn __hipGetPCH(pch: *mut *const ::std::os::raw::c_char, size: *mut ::std::os::raw::c_uint);
4575}
4576pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsNone: hipGraphicsRegisterFlags = 0;
4577#[doc = "< HIP will not write to this registered resource"]
4578pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsReadOnly: hipGraphicsRegisterFlags = 1;
4579pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsWriteDiscard: hipGraphicsRegisterFlags =
4580 2;
4581#[doc = "< HIP will bind this resource to a surface"]
4582pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsSurfaceLoadStore:
4583 hipGraphicsRegisterFlags = 4;
4584pub const hipGraphicsRegisterFlags_hipGraphicsRegisterFlagsTextureGather: hipGraphicsRegisterFlags =
4585 8;
4586#[doc = " HIP Access falgs for Interop resources."]
4587pub type hipGraphicsRegisterFlags = ::std::os::raw::c_uint;
4588#[repr(C)]
4589#[derive(Debug, Copy, Clone)]
4590pub struct _hipGraphicsResource {
4591 _unused: [u8; 0],
4592}
4593pub type hipGraphicsResource = _hipGraphicsResource;
4594pub type hipGraphicsResource_t = *mut hipGraphicsResource;
4595#[repr(C)]
4596#[derive(Debug, Copy, Clone)]
4597pub struct ihipGraph {
4598 _unused: [u8; 0],
4599}
4600#[doc = " An opaque value that represents a hip graph"]
4601pub type hipGraph_t = *mut ihipGraph;
4602#[repr(C)]
4603#[derive(Debug, Copy, Clone)]
4604pub struct hipGraphNode {
4605 _unused: [u8; 0],
4606}
4607#[doc = " An opaque value that represents a hip graph node"]
4608pub type hipGraphNode_t = *mut hipGraphNode;
4609#[repr(C)]
4610#[derive(Debug, Copy, Clone)]
4611pub struct hipGraphExec {
4612 _unused: [u8; 0],
4613}
4614#[doc = " An opaque value that represents a hip graph Exec"]
4615pub type hipGraphExec_t = *mut hipGraphExec;
4616#[repr(C)]
4617#[derive(Debug, Copy, Clone)]
4618pub struct hipUserObject {
4619 _unused: [u8; 0],
4620}
4621#[doc = " An opaque value that represents a user obj"]
4622pub type hipUserObject_t = *mut hipUserObject;
4623#[doc = "< GPU kernel node"]
4624pub const hipGraphNodeType_hipGraphNodeTypeKernel: hipGraphNodeType = 0;
4625#[doc = "< Memcpy node"]
4626pub const hipGraphNodeType_hipGraphNodeTypeMemcpy: hipGraphNodeType = 1;
4627#[doc = "< Memset node"]
4628pub const hipGraphNodeType_hipGraphNodeTypeMemset: hipGraphNodeType = 2;
4629#[doc = "< Host (executable) node"]
4630pub const hipGraphNodeType_hipGraphNodeTypeHost: hipGraphNodeType = 3;
4631#[doc = "< Node which executes an embedded graph"]
4632pub const hipGraphNodeType_hipGraphNodeTypeGraph: hipGraphNodeType = 4;
4633#[doc = "< Empty (no-op) node"]
4634pub const hipGraphNodeType_hipGraphNodeTypeEmpty: hipGraphNodeType = 5;
4635#[doc = "< External event wait node"]
4636pub const hipGraphNodeType_hipGraphNodeTypeWaitEvent: hipGraphNodeType = 6;
4637#[doc = "< External event record node"]
4638pub const hipGraphNodeType_hipGraphNodeTypeEventRecord: hipGraphNodeType = 7;
4639#[doc = "< External Semaphore signal node"]
4640pub const hipGraphNodeType_hipGraphNodeTypeExtSemaphoreSignal: hipGraphNodeType = 8;
4641#[doc = "< External Semaphore wait node"]
4642pub const hipGraphNodeType_hipGraphNodeTypeExtSemaphoreWait: hipGraphNodeType = 9;
4643#[doc = "< Memory alloc node"]
4644pub const hipGraphNodeType_hipGraphNodeTypeMemAlloc: hipGraphNodeType = 10;
4645#[doc = "< Memory free node"]
4646pub const hipGraphNodeType_hipGraphNodeTypeMemFree: hipGraphNodeType = 11;
4647#[doc = "< MemcpyFromSymbol node"]
4648pub const hipGraphNodeType_hipGraphNodeTypeMemcpyFromSymbol: hipGraphNodeType = 12;
4649#[doc = "< MemcpyToSymbol node"]
4650pub const hipGraphNodeType_hipGraphNodeTypeMemcpyToSymbol: hipGraphNodeType = 13;
4651#[doc = "< BatchMemOp node"]
4652pub const hipGraphNodeType_hipGraphNodeTypeBatchMemOp: hipGraphNodeType = 14;
4653pub const hipGraphNodeType_hipGraphNodeTypeCount: hipGraphNodeType = 15;
4654#[doc = " hipGraphNodeType"]
4655pub type hipGraphNodeType = ::std::os::raw::c_uint;
4656pub type hipHostFn_t =
4657 ::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void)>;
4658#[repr(C)]
4659#[derive(Debug, Copy, Clone)]
4660pub struct hipHostNodeParams {
4661 pub fn_: hipHostFn_t,
4662 pub userData: *mut ::std::os::raw::c_void,
4663}
4664#[repr(C)]
4665#[derive(Debug, Copy, Clone)]
4666pub struct hipKernelNodeParams {
4667 pub blockDim: dim3,
4668 pub extra: *mut *mut ::std::os::raw::c_void,
4669 pub func: *mut ::std::os::raw::c_void,
4670 pub gridDim: dim3,
4671 pub kernelParams: *mut *mut ::std::os::raw::c_void,
4672 pub sharedMemBytes: ::std::os::raw::c_uint,
4673}
4674#[repr(C)]
4675#[derive(Debug, Copy, Clone)]
4676pub struct hipMemsetParams {
4677 pub dst: *mut ::std::os::raw::c_void,
4678 pub elementSize: ::std::os::raw::c_uint,
4679 pub height: usize,
4680 pub pitch: usize,
4681 pub value: ::std::os::raw::c_uint,
4682 pub width: usize,
4683}
4684#[repr(C)]
4685#[derive(Debug, Copy, Clone)]
4686pub struct hipMemAllocNodeParams {
4687 #[doc = "< Pool properties, which contain where\n< the location should reside"]
4688 pub poolProps: hipMemPoolProps,
4689 #[doc = "< The number of memory access descriptors."]
4690 pub accessDescs: *const hipMemAccessDesc,
4691 #[doc = "< The number of access descriptors.\n< Must not be bigger than the number of GPUs"]
4692 pub accessDescCount: usize,
4693 #[doc = "< The size of the requested allocation in bytes"]
4694 pub bytesize: usize,
4695 #[doc = "< Returned device address of the allocation"]
4696 pub dptr: *mut ::std::os::raw::c_void,
4697}
4698pub const hipAccessProperty_hipAccessPropertyNormal: hipAccessProperty = 0;
4699pub const hipAccessProperty_hipAccessPropertyStreaming: hipAccessProperty = 1;
4700pub const hipAccessProperty_hipAccessPropertyPersisting: hipAccessProperty = 2;
4701pub type hipAccessProperty = ::std::os::raw::c_uint;
4702#[repr(C)]
4703#[derive(Debug, Copy, Clone)]
4704pub struct hipAccessPolicyWindow {
4705 pub base_ptr: *mut ::std::os::raw::c_void,
4706 pub hitProp: hipAccessProperty,
4707 pub hitRatio: f32,
4708 pub missProp: hipAccessProperty,
4709 pub num_bytes: usize,
4710}
4711#[doc = "< Valid for Streams, graph nodes, launches"]
4712pub const hipLaunchAttributeID_hipLaunchAttributeAccessPolicyWindow: hipLaunchAttributeID = 1;
4713#[doc = "< Valid for graph nodes, launches"]
4714pub const hipLaunchAttributeID_hipLaunchAttributeCooperative: hipLaunchAttributeID = 2;
4715#[doc = "< Valid for graph node, streams, launches"]
4716pub const hipLaunchAttributeID_hipLaunchAttributePriority: hipLaunchAttributeID = 8;
4717#[doc = " Launch Attribute ID"]
4718pub type hipLaunchAttributeID = ::std::os::raw::c_uint;
4719#[doc = " Launch Attribute Value"]
4720#[repr(C)]
4721#[derive(Copy, Clone)]
4722pub union hipLaunchAttributeValue {
4723 #[doc = "< Value of launch attribute::\nhipLaunchAttributePolicyWindow."]
4724 pub accessPolicyWindow: hipAccessPolicyWindow,
4725 #[doc = "< Value of launch attribute ::hipLaunchAttributeCooperative"]
4726 pub cooperative: ::std::os::raw::c_int,
4727 #[doc = "< Value of launch attribute :: hipLaunchAttributePriority. Execution\npriority of kernel."]
4728 pub priority: ::std::os::raw::c_int,
4729}
4730#[doc = " Memset node params"]
4731#[repr(C)]
4732#[derive(Debug, Copy, Clone)]
4733pub struct HIP_MEMSET_NODE_PARAMS {
4734 #[doc = "< Destination pointer on device"]
4735 pub dst: hipDeviceptr_t,
4736 #[doc = "< Destination device pointer pitch. Unused if height equals 1"]
4737 pub pitch: usize,
4738 #[doc = "< Value of memset to be set"]
4739 pub value: ::std::os::raw::c_uint,
4740 #[doc = "< Element in bytes. Must be 1, 2, or 4."]
4741 pub elementSize: ::std::os::raw::c_uint,
4742 #[doc = "< Width of a row"]
4743 pub width: usize,
4744 #[doc = "< Number of rows"]
4745 pub height: usize,
4746}
4747#[doc = "< The update succeeded"]
4748pub const hipGraphExecUpdateResult_hipGraphExecUpdateSuccess: hipGraphExecUpdateResult = 0;
4749#[doc = "< The update failed for an unexpected reason which is described\n< in the return value of the function"]
4750pub const hipGraphExecUpdateResult_hipGraphExecUpdateError: hipGraphExecUpdateResult = 1;
4751#[doc = "< The update failed because the topology changed"]
4752pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorTopologyChanged:
4753 hipGraphExecUpdateResult = 2;
4754#[doc = "< The update failed because a node type changed"]
4755pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorNodeTypeChanged:
4756 hipGraphExecUpdateResult = 3;
4757pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorFunctionChanged:
4758 hipGraphExecUpdateResult = 4;
4759pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorParametersChanged:
4760 hipGraphExecUpdateResult = 5;
4761pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorNotSupported: hipGraphExecUpdateResult =
4762 6;
4763pub const hipGraphExecUpdateResult_hipGraphExecUpdateErrorUnsupportedFunctionChange:
4764 hipGraphExecUpdateResult = 7;
4765#[doc = " Graph execution update result"]
4766pub type hipGraphExecUpdateResult = ::std::os::raw::c_uint;
4767pub const hipStreamCaptureMode_hipStreamCaptureModeGlobal: hipStreamCaptureMode = 0;
4768pub const hipStreamCaptureMode_hipStreamCaptureModeThreadLocal: hipStreamCaptureMode = 1;
4769pub const hipStreamCaptureMode_hipStreamCaptureModeRelaxed: hipStreamCaptureMode = 2;
4770pub type hipStreamCaptureMode = ::std::os::raw::c_uint;
4771#[doc = "< Stream is not capturing"]
4772pub const hipStreamCaptureStatus_hipStreamCaptureStatusNone: hipStreamCaptureStatus = 0;
4773#[doc = "< Stream is actively capturing"]
4774pub const hipStreamCaptureStatus_hipStreamCaptureStatusActive: hipStreamCaptureStatus = 1;
4775#[doc = "< Stream is part of a capture sequence that has been\n< invalidated, but not terminated"]
4776pub const hipStreamCaptureStatus_hipStreamCaptureStatusInvalidated: hipStreamCaptureStatus = 2;
4777pub type hipStreamCaptureStatus = ::std::os::raw::c_uint;
4778#[doc = "< Add new nodes to the dependency set"]
4779pub const hipStreamUpdateCaptureDependenciesFlags_hipStreamAddCaptureDependencies:
4780 hipStreamUpdateCaptureDependenciesFlags = 0;
4781#[doc = "< Replace the dependency set with the new nodes"]
4782pub const hipStreamUpdateCaptureDependenciesFlags_hipStreamSetCaptureDependencies:
4783 hipStreamUpdateCaptureDependenciesFlags = 1;
4784pub type hipStreamUpdateCaptureDependenciesFlags = ::std::os::raw::c_uint;
4785#[doc = "< Amount of memory, in bytes, currently associated with graphs"]
4786pub const hipGraphMemAttributeType_hipGraphMemAttrUsedMemCurrent: hipGraphMemAttributeType = 0;
4787#[doc = "< High watermark of memory, in bytes, associated with graphs since the last time."]
4788pub const hipGraphMemAttributeType_hipGraphMemAttrUsedMemHigh: hipGraphMemAttributeType = 1;
4789#[doc = "< Amount of memory, in bytes, currently allocated for graphs."]
4790pub const hipGraphMemAttributeType_hipGraphMemAttrReservedMemCurrent: hipGraphMemAttributeType = 2;
4791#[doc = "< High watermark of memory, in bytes, currently allocated for graphs"]
4792pub const hipGraphMemAttributeType_hipGraphMemAttrReservedMemHigh: hipGraphMemAttributeType = 3;
4793pub type hipGraphMemAttributeType = ::std::os::raw::c_uint;
4794#[doc = "< Destructor execution is not synchronized."]
4795pub const hipUserObjectFlags_hipUserObjectNoDestructorSync: hipUserObjectFlags = 1;
4796pub type hipUserObjectFlags = ::std::os::raw::c_uint;
4797#[doc = "< Add new reference or retain."]
4798pub const hipUserObjectRetainFlags_hipGraphUserObjectMove: hipUserObjectRetainFlags = 1;
4799pub type hipUserObjectRetainFlags = ::std::os::raw::c_uint;
4800pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagAutoFreeOnLaunch:
4801 hipGraphInstantiateFlags = 1;
4802pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagUpload: hipGraphInstantiateFlags = 2;
4803pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagDeviceLaunch: hipGraphInstantiateFlags =
4804 4;
4805pub const hipGraphInstantiateFlags_hipGraphInstantiateFlagUseNodePriority:
4806 hipGraphInstantiateFlags = 8;
4807pub type hipGraphInstantiateFlags = ::std::os::raw::c_uint;
4808pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsVerbose: hipGraphDebugDotFlags = 1;
4809#[doc = "< Adds hipKernelNodeParams to output"]
4810pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsKernelNodeParams: hipGraphDebugDotFlags = 4;
4811#[doc = "< Adds hipMemcpy3DParms to output"]
4812pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsMemcpyNodeParams: hipGraphDebugDotFlags = 8;
4813#[doc = "< Adds hipMemsetParams to output"]
4814pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsMemsetNodeParams: hipGraphDebugDotFlags = 16;
4815#[doc = "< Adds hipHostNodeParams to output"]
4816pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsHostNodeParams: hipGraphDebugDotFlags = 32;
4817pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsEventNodeParams: hipGraphDebugDotFlags = 64;
4818pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsExtSemasSignalNodeParams:
4819 hipGraphDebugDotFlags = 128;
4820pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsExtSemasWaitNodeParams: hipGraphDebugDotFlags =
4821 256;
4822pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsKernelNodeAttributes: hipGraphDebugDotFlags =
4823 512;
4824pub const hipGraphDebugDotFlags_hipGraphDebugDotFlagsHandles: hipGraphDebugDotFlags = 1024;
4825pub type hipGraphDebugDotFlags = ::std::os::raw::c_uint;
4826#[doc = "< Instantiation Success"]
4827pub const hipGraphInstantiateResult_hipGraphInstantiateSuccess: hipGraphInstantiateResult = 0;
4828#[doc = "< Instantiation failed for an\nunexpected reason which is described in the return value of the function"]
4829pub const hipGraphInstantiateResult_hipGraphInstantiateError: hipGraphInstantiateResult = 1;
4830#[doc = "< Instantiation failed due\nto invalid structure, such as cycles"]
4831pub const hipGraphInstantiateResult_hipGraphInstantiateInvalidStructure: hipGraphInstantiateResult =
4832 2;
4833#[doc = "< Instantiation for device launch failed\nbecause the graph contained an unsupported operation"]
4834pub const hipGraphInstantiateResult_hipGraphInstantiateNodeOperationNotSupported:
4835 hipGraphInstantiateResult = 3;
4836#[doc = "< Instantiation for device launch failed\ndue to the nodes belonging to different contexts"]
4837pub const hipGraphInstantiateResult_hipGraphInstantiateMultipleDevicesNotSupported:
4838 hipGraphInstantiateResult = 4;
4839#[doc = " hipGraphInstantiateWithParams results"]
4840pub type hipGraphInstantiateResult = ::std::os::raw::c_uint;
4841#[doc = " Graph Instantiation parameters"]
4842#[repr(C)]
4843#[derive(Debug, Copy, Clone)]
4844pub struct hipGraphInstantiateParams {
4845 #[doc = "< The node which caused instantiation to fail, if any"]
4846 pub errNode_out: hipGraphNode_t,
4847 #[doc = "< Instantiation flags"]
4848 pub flags: ::std::os::raw::c_ulonglong,
4849 #[doc = "< Whether instantiation was successful.\nIf it failed, the reason why"]
4850 pub result_out: hipGraphInstantiateResult,
4851 #[doc = "< Upload stream"]
4852 pub uploadStream: hipStream_t,
4853}
4854#[doc = " Memory allocation properties"]
4855#[repr(C)]
4856#[derive(Debug, Copy, Clone)]
4857pub struct hipMemAllocationProp {
4858 #[doc = "< Memory allocation type"]
4859 pub type_: hipMemAllocationType,
4860 #[doc = "< Requested handle type"]
4861 pub requestedHandleType: hipMemAllocationHandleType,
4862 #[doc = "< Memory location"]
4863 pub location: hipMemLocation,
4864 #[doc = "< Metadata for Win32 handles"]
4865 pub win32HandleMetaData: *mut ::std::os::raw::c_void,
4866 pub allocFlags: hipMemAllocationProp__bindgen_ty_1,
4867}
4868#[repr(C)]
4869#[derive(Debug, Copy, Clone)]
4870pub struct hipMemAllocationProp__bindgen_ty_1 {
4871 #[doc = "< Compression type"]
4872 pub compressionType: ::std::os::raw::c_uchar,
4873 #[doc = "< RDMA capable"]
4874 pub gpuDirectRDMACapable: ::std::os::raw::c_uchar,
4875 #[doc = "< Usage"]
4876 pub usage: ::std::os::raw::c_ushort,
4877}
4878#[doc = " External semaphore signal node parameters"]
4879#[repr(C)]
4880#[derive(Debug, Copy, Clone)]
4881pub struct hipExternalSemaphoreSignalNodeParams {
4882 pub extSemArray: *mut hipExternalSemaphore_t,
4883 pub paramsArray: *const hipExternalSemaphoreSignalParams,
4884 pub numExtSems: ::std::os::raw::c_uint,
4885}
4886#[doc = " External semaphore wait node parameters"]
4887#[repr(C)]
4888#[derive(Debug, Copy, Clone)]
4889pub struct hipExternalSemaphoreWaitNodeParams {
4890 pub extSemArray: *mut hipExternalSemaphore_t,
4891 pub paramsArray: *const hipExternalSemaphoreWaitParams,
4892 pub numExtSems: ::std::os::raw::c_uint,
4893}
4894#[repr(C)]
4895#[derive(Debug, Copy, Clone)]
4896pub struct ihipMemGenericAllocationHandle {
4897 _unused: [u8; 0],
4898}
4899#[doc = " Generic handle for memory allocation"]
4900pub type hipMemGenericAllocationHandle_t = *mut ihipMemGenericAllocationHandle;
4901#[doc = "< Minimum granularity"]
4902pub const hipMemAllocationGranularity_flags_hipMemAllocationGranularityMinimum:
4903 hipMemAllocationGranularity_flags = 0;
4904#[doc = "< Recommended granularity for performance"]
4905pub const hipMemAllocationGranularity_flags_hipMemAllocationGranularityRecommended:
4906 hipMemAllocationGranularity_flags = 1;
4907#[doc = " Flags for granularity"]
4908pub type hipMemAllocationGranularity_flags = ::std::os::raw::c_uint;
4909#[doc = "< Generic handle type"]
4910pub const hipMemHandleType_hipMemHandleTypeGeneric: hipMemHandleType = 0;
4911#[doc = " Memory handle type"]
4912pub type hipMemHandleType = ::std::os::raw::c_uint;
4913#[doc = "< Map operation"]
4914pub const hipMemOperationType_hipMemOperationTypeMap: hipMemOperationType = 1;
4915#[doc = "< Unmap operation"]
4916pub const hipMemOperationType_hipMemOperationTypeUnmap: hipMemOperationType = 2;
4917#[doc = " Memory operation types"]
4918pub type hipMemOperationType = ::std::os::raw::c_uint;
4919#[doc = "< Sparse level"]
4920pub const hipArraySparseSubresourceType_hipArraySparseSubresourceTypeSparseLevel:
4921 hipArraySparseSubresourceType = 0;
4922#[doc = "< Miptail"]
4923pub const hipArraySparseSubresourceType_hipArraySparseSubresourceTypeMiptail:
4924 hipArraySparseSubresourceType = 1;
4925#[doc = " Subresource types for sparse arrays"]
4926pub type hipArraySparseSubresourceType = ::std::os::raw::c_uint;
4927#[doc = " Map info for arrays"]
4928#[repr(C)]
4929#[derive(Copy, Clone)]
4930pub struct hipArrayMapInfo {
4931 #[doc = "< Resource type"]
4932 pub resourceType: hipResourceType,
4933 pub resource: hipArrayMapInfo__bindgen_ty_1,
4934 #[doc = "< Sparse subresource type"]
4935 pub subresourceType: hipArraySparseSubresourceType,
4936 pub subresource: hipArrayMapInfo__bindgen_ty_2,
4937 #[doc = "< Memory operation type"]
4938 pub memOperationType: hipMemOperationType,
4939 #[doc = "< Memory handle type"]
4940 pub memHandleType: hipMemHandleType,
4941 pub memHandle: hipArrayMapInfo__bindgen_ty_3,
4942 #[doc = "< Offset within the memory"]
4943 pub offset: ::std::os::raw::c_ulonglong,
4944 #[doc = "< Device ordinal bit mask"]
4945 pub deviceBitMask: ::std::os::raw::c_uint,
4946 #[doc = "< flags for future use, must be zero now."]
4947 pub flags: ::std::os::raw::c_uint,
4948 #[doc = "< Reserved for future use, must be zero now."]
4949 pub reserved: [::std::os::raw::c_uint; 2usize],
4950}
4951#[repr(C)]
4952#[derive(Copy, Clone)]
4953pub union hipArrayMapInfo__bindgen_ty_1 {
4954 pub mipmap: hipMipmappedArray,
4955 pub array: hipArray_t,
4956}
4957#[repr(C)]
4958#[derive(Copy, Clone)]
4959pub union hipArrayMapInfo__bindgen_ty_2 {
4960 pub sparseLevel: hipArrayMapInfo__bindgen_ty_2__bindgen_ty_1,
4961 pub miptail: hipArrayMapInfo__bindgen_ty_2__bindgen_ty_2,
4962}
4963#[repr(C)]
4964#[derive(Debug, Copy, Clone)]
4965pub struct hipArrayMapInfo__bindgen_ty_2__bindgen_ty_1 {
4966 #[doc = "< For mipmapped arrays must be a valid mipmap level. For arrays must be zero"]
4967 pub level: ::std::os::raw::c_uint,
4968 #[doc = "< For layered arrays must be a valid layer index. Otherwise, must be zero"]
4969 pub layer: ::std::os::raw::c_uint,
4970 #[doc = "< X offset in elements"]
4971 pub offsetX: ::std::os::raw::c_uint,
4972 #[doc = "< Y offset in elements"]
4973 pub offsetY: ::std::os::raw::c_uint,
4974 #[doc = "< Z offset in elements"]
4975 pub offsetZ: ::std::os::raw::c_uint,
4976 #[doc = "< Width in elements"]
4977 pub extentWidth: ::std::os::raw::c_uint,
4978 #[doc = "< Height in elements"]
4979 pub extentHeight: ::std::os::raw::c_uint,
4980 #[doc = "< Depth in elements"]
4981 pub extentDepth: ::std::os::raw::c_uint,
4982}
4983#[repr(C)]
4984#[derive(Debug, Copy, Clone)]
4985pub struct hipArrayMapInfo__bindgen_ty_2__bindgen_ty_2 {
4986 #[doc = "< For layered arrays must be a valid layer index. Otherwise, must be zero"]
4987 pub layer: ::std::os::raw::c_uint,
4988 #[doc = "< Offset within mip tail"]
4989 pub offset: ::std::os::raw::c_ulonglong,
4990 #[doc = "< Extent in bytes"]
4991 pub size: ::std::os::raw::c_ulonglong,
4992}
4993#[repr(C)]
4994#[derive(Copy, Clone)]
4995pub union hipArrayMapInfo__bindgen_ty_3 {
4996 pub memHandle: hipMemGenericAllocationHandle_t,
4997}
4998#[doc = " Memcpy node params"]
4999#[repr(C)]
5000#[derive(Debug, Copy, Clone)]
5001pub struct hipMemcpyNodeParams {
5002 #[doc = "< Must be zero."]
5003 pub flags: ::std::os::raw::c_int,
5004 #[doc = "< Must be zero."]
5005 pub reserved: [::std::os::raw::c_int; 3usize],
5006 #[doc = "< Params set for the memory copy."]
5007 pub copyParams: hipMemcpy3DParms,
5008}
5009#[doc = " Child graph node params"]
5010#[repr(C)]
5011#[derive(Debug, Copy, Clone)]
5012pub struct hipChildGraphNodeParams {
5013 #[doc = "< Either the child graph to clone into the node, or\n< a handle to the graph possesed by the node used during query"]
5014 pub graph: hipGraph_t,
5015}
5016#[doc = " Event record node params"]
5017#[repr(C)]
5018#[derive(Debug, Copy, Clone)]
5019pub struct hipEventWaitNodeParams {
5020 #[doc = "< Event to wait on"]
5021 pub event: hipEvent_t,
5022}
5023#[doc = " Event record node params"]
5024#[repr(C)]
5025#[derive(Debug, Copy, Clone)]
5026pub struct hipEventRecordNodeParams {
5027 #[doc = "< The event to be recorded when node executes"]
5028 pub event: hipEvent_t,
5029}
5030#[doc = " Memory free node params"]
5031#[repr(C)]
5032#[derive(Debug, Copy, Clone)]
5033pub struct hipMemFreeNodeParams {
5034 #[doc = "< the pointer to be freed"]
5035 pub dptr: *mut ::std::os::raw::c_void,
5036}
5037#[doc = " Params for different graph nodes"]
5038#[repr(C)]
5039#[derive(Copy, Clone)]
5040pub struct hipGraphNodeParams {
5041 pub type_: hipGraphNodeType,
5042 pub reserved0: [::std::os::raw::c_int; 3usize],
5043 pub __bindgen_anon_1: hipGraphNodeParams__bindgen_ty_1,
5044 pub reserved2: ::std::os::raw::c_longlong,
5045}
5046#[repr(C)]
5047#[derive(Copy, Clone)]
5048pub union hipGraphNodeParams__bindgen_ty_1 {
5049 pub reserved1: [::std::os::raw::c_longlong; 29usize],
5050 pub kernel: hipKernelNodeParams,
5051 pub memcpy: hipMemcpyNodeParams,
5052 pub memset: hipMemsetParams,
5053 pub host: hipHostNodeParams,
5054 pub graph: hipChildGraphNodeParams,
5055 pub eventWait: hipEventWaitNodeParams,
5056 pub eventRecord: hipEventRecordNodeParams,
5057 pub extSemSignal: hipExternalSemaphoreSignalNodeParams,
5058 pub extSemWait: hipExternalSemaphoreWaitNodeParams,
5059 pub alloc: hipMemAllocNodeParams,
5060 pub free: hipMemFreeNodeParams,
5061}
5062pub const hipGraphDependencyType_hipGraphDependencyTypeDefault: hipGraphDependencyType = 0;
5063pub const hipGraphDependencyType_hipGraphDependencyTypeProgrammatic: hipGraphDependencyType = 1;
5064pub type hipGraphDependencyType = ::std::os::raw::c_uint;
5065#[repr(C)]
5066#[derive(Debug, Copy, Clone)]
5067pub struct hipGraphEdgeData {
5068 #[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."]
5069 pub from_port: ::std::os::raw::c_uchar,
5070 #[doc = "< These bytes are unused and must be zeroed"]
5071 pub reserved: [::std::os::raw::c_uchar; 5usize],
5072 #[doc = "< Currently no node types define non-zero ports. This field must be set to zero."]
5073 pub to_port: ::std::os::raw::c_uchar,
5074 #[doc = "< This should be populated with a value from hipGraphDependencyType"]
5075 pub type_: ::std::os::raw::c_uchar,
5076}
5077extern "C" {
5078 #[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"]
5079 pub fn hipInit(flags: ::std::os::raw::c_uint) -> hipError_t;
5080}
5081extern "C" {
5082 #[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"]
5083 pub fn hipDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> hipError_t;
5084}
5085extern "C" {
5086 #[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"]
5087 pub fn hipRuntimeGetVersion(runtimeVersion: *mut ::std::os::raw::c_int) -> hipError_t;
5088}
5089extern "C" {
5090 #[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"]
5091 pub fn hipDeviceGet(device: *mut hipDevice_t, ordinal: ::std::os::raw::c_int) -> hipError_t;
5092}
5093extern "C" {
5094 #[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"]
5095 pub fn hipDeviceComputeCapability(
5096 major: *mut ::std::os::raw::c_int,
5097 minor: *mut ::std::os::raw::c_int,
5098 device: hipDevice_t,
5099 ) -> hipError_t;
5100}
5101extern "C" {
5102 #[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"]
5103 pub fn hipDeviceGetName(
5104 name: *mut ::std::os::raw::c_char,
5105 len: ::std::os::raw::c_int,
5106 device: hipDevice_t,
5107 ) -> hipError_t;
5108}
5109extern "C" {
5110 #[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"]
5111 pub fn hipDeviceGetUuid(uuid: *mut hipUUID, device: hipDevice_t) -> hipError_t;
5112}
5113extern "C" {
5114 #[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"]
5115 pub fn hipDeviceGetP2PAttribute(
5116 value: *mut ::std::os::raw::c_int,
5117 attr: hipDeviceP2PAttr,
5118 srcDevice: ::std::os::raw::c_int,
5119 dstDevice: ::std::os::raw::c_int,
5120 ) -> hipError_t;
5121}
5122extern "C" {
5123 #[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"]
5124 pub fn hipDeviceGetPCIBusId(
5125 pciBusId: *mut ::std::os::raw::c_char,
5126 len: ::std::os::raw::c_int,
5127 device: ::std::os::raw::c_int,
5128 ) -> hipError_t;
5129}
5130extern "C" {
5131 #[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"]
5132 pub fn hipDeviceGetByPCIBusId(
5133 device: *mut ::std::os::raw::c_int,
5134 pciBusId: *const ::std::os::raw::c_char,
5135 ) -> hipError_t;
5136}
5137extern "C" {
5138 #[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"]
5139 pub fn hipDeviceTotalMem(bytes: *mut usize, device: hipDevice_t) -> hipError_t;
5140}
5141extern "C" {
5142 #[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"]
5143 pub fn hipDeviceSynchronize() -> hipError_t;
5144}
5145extern "C" {
5146 #[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"]
5147 pub fn hipDeviceReset() -> hipError_t;
5148}
5149extern "C" {
5150 #[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"]
5151 pub fn hipSetDevice(deviceId: ::std::os::raw::c_int) -> hipError_t;
5152}
5153extern "C" {
5154 #[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"]
5155 pub fn hipSetValidDevices(
5156 device_arr: *mut ::std::os::raw::c_int,
5157 len: ::std::os::raw::c_int,
5158 ) -> hipError_t;
5159}
5160extern "C" {
5161 #[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"]
5162 pub fn hipGetDevice(deviceId: *mut ::std::os::raw::c_int) -> hipError_t;
5163}
5164extern "C" {
5165 #[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."]
5166 pub fn hipGetDeviceCount(count: *mut ::std::os::raw::c_int) -> hipError_t;
5167}
5168extern "C" {
5169 #[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"]
5170 pub fn hipDeviceGetAttribute(
5171 pi: *mut ::std::os::raw::c_int,
5172 attr: hipDeviceAttribute_t,
5173 deviceId: ::std::os::raw::c_int,
5174 ) -> hipError_t;
5175}
5176extern "C" {
5177 #[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."]
5178 pub fn hipDeviceGetDefaultMemPool(
5179 mem_pool: *mut hipMemPool_t,
5180 device: ::std::os::raw::c_int,
5181 ) -> hipError_t;
5182}
5183extern "C" {
5184 #[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."]
5185 pub fn hipDeviceSetMemPool(device: ::std::os::raw::c_int, mem_pool: hipMemPool_t)
5186 -> hipError_t;
5187}
5188extern "C" {
5189 #[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."]
5190 pub fn hipDeviceGetMemPool(
5191 mem_pool: *mut hipMemPool_t,
5192 device: ::std::os::raw::c_int,
5193 ) -> hipError_t;
5194}
5195extern "C" {
5196 #[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."]
5197 pub fn hipGetDevicePropertiesR0600(
5198 prop: *mut hipDeviceProp_tR0600,
5199 deviceId: ::std::os::raw::c_int,
5200 ) -> hipError_t;
5201}
5202extern "C" {
5203 #[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"]
5204 pub fn hipDeviceGetTexture1DLinearMaxWidth(
5205 mem_pool: *mut hipMemPool_t,
5206 device: ::std::os::raw::c_int,
5207 ) -> hipError_t;
5208}
5209extern "C" {
5210 #[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"]
5211 pub fn hipDeviceSetCacheConfig(cacheConfig: hipFuncCache_t) -> hipError_t;
5212}
5213extern "C" {
5214 #[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"]
5215 pub fn hipDeviceGetCacheConfig(cacheConfig: *mut hipFuncCache_t) -> hipError_t;
5216}
5217extern "C" {
5218 #[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"]
5219 pub fn hipDeviceGetLimit(pValue: *mut usize, limit: hipLimit_t) -> hipError_t;
5220}
5221extern "C" {
5222 #[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"]
5223 pub fn hipDeviceSetLimit(limit: hipLimit_t, value: usize) -> hipError_t;
5224}
5225extern "C" {
5226 #[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"]
5227 pub fn hipDeviceGetSharedMemConfig(pConfig: *mut hipSharedMemConfig) -> hipError_t;
5228}
5229extern "C" {
5230 #[doc = " @brief Gets the flags set for current device\n\n @param [out] flags Pointer of the flags\n\n @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
5231 pub fn hipGetDeviceFlags(flags: *mut ::std::os::raw::c_uint) -> hipError_t;
5232}
5233extern "C" {
5234 #[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"]
5235 pub fn hipDeviceSetSharedMemConfig(config: hipSharedMemConfig) -> hipError_t;
5236}
5237extern "C" {
5238 #[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"]
5239 pub fn hipSetDeviceFlags(flags: ::std::os::raw::c_uint) -> hipError_t;
5240}
5241extern "C" {
5242 #[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"]
5243 pub fn hipChooseDeviceR0600(
5244 device: *mut ::std::os::raw::c_int,
5245 prop: *const hipDeviceProp_tR0600,
5246 ) -> hipError_t;
5247}
5248extern "C" {
5249 #[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"]
5250 pub fn hipExtGetLinkTypeAndHopCount(
5251 device1: ::std::os::raw::c_int,
5252 device2: ::std::os::raw::c_int,
5253 linktype: *mut u32,
5254 hopcount: *mut u32,
5255 ) -> hipError_t;
5256}
5257extern "C" {
5258 #[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"]
5259 pub fn hipIpcGetMemHandle(
5260 handle: *mut hipIpcMemHandle_t,
5261 devPtr: *mut ::std::os::raw::c_void,
5262 ) -> hipError_t;
5263}
5264extern "C" {
5265 #[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"]
5266 pub fn hipIpcOpenMemHandle(
5267 devPtr: *mut *mut ::std::os::raw::c_void,
5268 handle: hipIpcMemHandle_t,
5269 flags: ::std::os::raw::c_uint,
5270 ) -> hipError_t;
5271}
5272extern "C" {
5273 #[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"]
5274 pub fn hipIpcCloseMemHandle(devPtr: *mut ::std::os::raw::c_void) -> hipError_t;
5275}
5276extern "C" {
5277 #[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"]
5278 pub fn hipIpcGetEventHandle(handle: *mut hipIpcEventHandle_t, event: hipEvent_t) -> hipError_t;
5279}
5280extern "C" {
5281 #[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"]
5282 pub fn hipIpcOpenEventHandle(event: *mut hipEvent_t, handle: hipIpcEventHandle_t)
5283 -> hipError_t;
5284}
5285extern "C" {
5286 #[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"]
5287 pub fn hipFuncSetAttribute(
5288 func: *const ::std::os::raw::c_void,
5289 attr: hipFuncAttribute,
5290 value: ::std::os::raw::c_int,
5291 ) -> hipError_t;
5292}
5293extern "C" {
5294 #[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"]
5295 pub fn hipFuncSetCacheConfig(
5296 func: *const ::std::os::raw::c_void,
5297 config: hipFuncCache_t,
5298 ) -> hipError_t;
5299}
5300extern "C" {
5301 #[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"]
5302 pub fn hipFuncSetSharedMemConfig(
5303 func: *const ::std::os::raw::c_void,
5304 config: hipSharedMemConfig,
5305 ) -> hipError_t;
5306}
5307extern "C" {
5308 #[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"]
5309 pub fn hipGetLastError() -> hipError_t;
5310}
5311extern "C" {
5312 #[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"]
5313 pub fn hipExtGetLastError() -> hipError_t;
5314}
5315extern "C" {
5316 #[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"]
5317 pub fn hipPeekAtLastError() -> hipError_t;
5318}
5319extern "C" {
5320 #[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"]
5321 pub fn hipGetErrorName(hip_error: hipError_t) -> *const ::std::os::raw::c_char;
5322}
5323extern "C" {
5324 #[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"]
5325 pub fn hipGetErrorString(hipError: hipError_t) -> *const ::std::os::raw::c_char;
5326}
5327extern "C" {
5328 #[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"]
5329 pub fn hipDrvGetErrorName(
5330 hipError: hipError_t,
5331 errorString: *mut *const ::std::os::raw::c_char,
5332 ) -> hipError_t;
5333}
5334extern "C" {
5335 #[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"]
5336 pub fn hipDrvGetErrorString(
5337 hipError: hipError_t,
5338 errorString: *mut *const ::std::os::raw::c_char,
5339 ) -> hipError_t;
5340}
5341extern "C" {
5342 #[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"]
5343 pub fn hipStreamCreate(stream: *mut hipStream_t) -> hipError_t;
5344}
5345extern "C" {
5346 #[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"]
5347 pub fn hipStreamCreateWithFlags(
5348 stream: *mut hipStream_t,
5349 flags: ::std::os::raw::c_uint,
5350 ) -> hipError_t;
5351}
5352extern "C" {
5353 #[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"]
5354 pub fn hipStreamCreateWithPriority(
5355 stream: *mut hipStream_t,
5356 flags: ::std::os::raw::c_uint,
5357 priority: ::std::os::raw::c_int,
5358 ) -> hipError_t;
5359}
5360extern "C" {
5361 #[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."]
5362 pub fn hipDeviceGetStreamPriorityRange(
5363 leastPriority: *mut ::std::os::raw::c_int,
5364 greatestPriority: *mut ::std::os::raw::c_int,
5365 ) -> hipError_t;
5366}
5367extern "C" {
5368 #[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"]
5369 pub fn hipStreamDestroy(stream: hipStream_t) -> hipError_t;
5370}
5371extern "C" {
5372 #[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"]
5373 pub fn hipStreamQuery(stream: hipStream_t) -> hipError_t;
5374}
5375extern "C" {
5376 #[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"]
5377 pub fn hipStreamSynchronize(stream: hipStream_t) -> hipError_t;
5378}
5379extern "C" {
5380 #[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 control operation [must be 0]\n\n @returns #hipSuccess, #hipErrorInvalidHandle\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 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"]
5381 pub fn hipStreamWaitEvent(
5382 stream: hipStream_t,
5383 event: hipEvent_t,
5384 flags: ::std::os::raw::c_uint,
5385 ) -> hipError_t;
5386}
5387extern "C" {
5388 #[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"]
5389 pub fn hipStreamGetFlags(stream: hipStream_t, flags: *mut ::std::os::raw::c_uint)
5390 -> hipError_t;
5391}
5392extern "C" {
5393 #[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"]
5394 pub fn hipStreamGetPriority(
5395 stream: hipStream_t,
5396 priority: *mut ::std::os::raw::c_int,
5397 ) -> hipError_t;
5398}
5399extern "C" {
5400 #[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"]
5401 pub fn hipStreamGetDevice(stream: hipStream_t, device: *mut hipDevice_t) -> hipError_t;
5402}
5403extern "C" {
5404 #[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"]
5405 pub fn hipExtStreamCreateWithCUMask(
5406 stream: *mut hipStream_t,
5407 cuMaskSize: u32,
5408 cuMask: *const u32,
5409 ) -> hipError_t;
5410}
5411extern "C" {
5412 #[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"]
5413 pub fn hipExtStreamGetCUMask(
5414 stream: hipStream_t,
5415 cuMaskSize: u32,
5416 cuMask: *mut u32,
5417 ) -> hipError_t;
5418}
5419#[doc = " Stream CallBack struct"]
5420pub type hipStreamCallback_t = ::std::option::Option<
5421 unsafe extern "C" fn(
5422 stream: hipStream_t,
5423 status: hipError_t,
5424 userData: *mut ::std::os::raw::c_void,
5425 ),
5426>;
5427extern "C" {
5428 #[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"]
5429 pub fn hipStreamAddCallback(
5430 stream: hipStream_t,
5431 callback: hipStreamCallback_t,
5432 userData: *mut ::std::os::raw::c_void,
5433 flags: ::std::os::raw::c_uint,
5434 ) -> hipError_t;
5435}
5436extern "C" {
5437 #[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"]
5438 pub fn hipStreamWaitValue32(
5439 stream: hipStream_t,
5440 ptr: *mut ::std::os::raw::c_void,
5441 value: u32,
5442 flags: ::std::os::raw::c_uint,
5443 mask: u32,
5444 ) -> hipError_t;
5445}
5446extern "C" {
5447 #[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"]
5448 pub fn hipStreamWaitValue64(
5449 stream: hipStream_t,
5450 ptr: *mut ::std::os::raw::c_void,
5451 value: u64,
5452 flags: ::std::os::raw::c_uint,
5453 mask: u64,
5454 ) -> hipError_t;
5455}
5456extern "C" {
5457 #[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"]
5458 pub fn hipStreamWriteValue32(
5459 stream: hipStream_t,
5460 ptr: *mut ::std::os::raw::c_void,
5461 value: u32,
5462 flags: ::std::os::raw::c_uint,
5463 ) -> hipError_t;
5464}
5465extern "C" {
5466 #[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"]
5467 pub fn hipStreamWriteValue64(
5468 stream: hipStream_t,
5469 ptr: *mut ::std::os::raw::c_void,
5470 value: u64,
5471 flags: ::std::os::raw::c_uint,
5472 ) -> hipError_t;
5473}
5474extern "C" {
5475 #[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"]
5476 pub fn hipStreamBatchMemOp(
5477 stream: hipStream_t,
5478 count: ::std::os::raw::c_uint,
5479 paramArray: *mut hipStreamBatchMemOpParams,
5480 flags: ::std::os::raw::c_uint,
5481 ) -> hipError_t;
5482}
5483extern "C" {
5484 #[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"]
5485 pub fn hipGraphAddBatchMemOpNode(
5486 phGraphNode: *mut hipGraphNode_t,
5487 hGraph: hipGraph_t,
5488 dependencies: *const hipGraphNode_t,
5489 numDependencies: usize,
5490 nodeParams: *const hipBatchMemOpNodeParams,
5491 ) -> hipError_t;
5492}
5493extern "C" {
5494 #[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"]
5495 pub fn hipGraphBatchMemOpNodeGetParams(
5496 hNode: hipGraphNode_t,
5497 nodeParams_out: *mut hipBatchMemOpNodeParams,
5498 ) -> hipError_t;
5499}
5500extern "C" {
5501 #[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"]
5502 pub fn hipGraphBatchMemOpNodeSetParams(
5503 hNode: hipGraphNode_t,
5504 nodeParams: *mut hipBatchMemOpNodeParams,
5505 ) -> hipError_t;
5506}
5507extern "C" {
5508 #[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"]
5509 pub fn hipGraphExecBatchMemOpNodeSetParams(
5510 hGraphExec: hipGraphExec_t,
5511 hNode: hipGraphNode_t,
5512 nodeParams: *const hipBatchMemOpNodeParams,
5513 ) -> hipError_t;
5514}
5515extern "C" {
5516 #[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"]
5517 pub fn hipEventCreateWithFlags(
5518 event: *mut hipEvent_t,
5519 flags: ::std::os::raw::c_uint,
5520 ) -> hipError_t;
5521}
5522extern "C" {
5523 #[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"]
5524 pub fn hipEventCreate(event: *mut hipEvent_t) -> hipError_t;
5525}
5526extern "C" {
5527 #[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"]
5528 pub fn hipEventRecordWithFlags(
5529 event: hipEvent_t,
5530 stream: hipStream_t,
5531 flags: ::std::os::raw::c_uint,
5532 ) -> hipError_t;
5533}
5534extern "C" {
5535 pub fn hipEventRecord(event: hipEvent_t, stream: hipStream_t) -> hipError_t;
5536}
5537extern "C" {
5538 #[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"]
5539 pub fn hipEventDestroy(event: hipEvent_t) -> hipError_t;
5540}
5541extern "C" {
5542 #[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"]
5543 pub fn hipEventSynchronize(event: hipEvent_t) -> hipError_t;
5544}
5545extern "C" {
5546 #[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"]
5547 pub fn hipEventElapsedTime(ms: *mut f32, start: hipEvent_t, stop: hipEvent_t) -> hipError_t;
5548}
5549extern "C" {
5550 #[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"]
5551 pub fn hipEventQuery(event: hipEvent_t) -> hipError_t;
5552}
5553extern "C" {
5554 #[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"]
5555 pub fn hipPointerSetAttribute(
5556 value: *const ::std::os::raw::c_void,
5557 attribute: hipPointer_attribute,
5558 ptr: hipDeviceptr_t,
5559 ) -> hipError_t;
5560}
5561extern "C" {
5562 #[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"]
5563 pub fn hipPointerGetAttributes(
5564 attributes: *mut hipPointerAttribute_t,
5565 ptr: *const ::std::os::raw::c_void,
5566 ) -> hipError_t;
5567}
5568extern "C" {
5569 #[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"]
5570 pub fn hipPointerGetAttribute(
5571 data: *mut ::std::os::raw::c_void,
5572 attribute: hipPointer_attribute,
5573 ptr: hipDeviceptr_t,
5574 ) -> hipError_t;
5575}
5576extern "C" {
5577 #[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"]
5578 pub fn hipDrvPointerGetAttributes(
5579 numAttributes: ::std::os::raw::c_uint,
5580 attributes: *mut hipPointer_attribute,
5581 data: *mut *mut ::std::os::raw::c_void,
5582 ptr: hipDeviceptr_t,
5583 ) -> hipError_t;
5584}
5585extern "C" {
5586 #[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"]
5587 pub fn hipImportExternalSemaphore(
5588 extSem_out: *mut hipExternalSemaphore_t,
5589 semHandleDesc: *const hipExternalSemaphoreHandleDesc,
5590 ) -> hipError_t;
5591}
5592extern "C" {
5593 #[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"]
5594 pub fn hipSignalExternalSemaphoresAsync(
5595 extSemArray: *const hipExternalSemaphore_t,
5596 paramsArray: *const hipExternalSemaphoreSignalParams,
5597 numExtSems: ::std::os::raw::c_uint,
5598 stream: hipStream_t,
5599 ) -> hipError_t;
5600}
5601extern "C" {
5602 #[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"]
5603 pub fn hipWaitExternalSemaphoresAsync(
5604 extSemArray: *const hipExternalSemaphore_t,
5605 paramsArray: *const hipExternalSemaphoreWaitParams,
5606 numExtSems: ::std::os::raw::c_uint,
5607 stream: hipStream_t,
5608 ) -> hipError_t;
5609}
5610extern "C" {
5611 #[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"]
5612 pub fn hipDestroyExternalSemaphore(extSem: hipExternalSemaphore_t) -> hipError_t;
5613}
5614extern "C" {
5615 #[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"]
5616 pub fn hipImportExternalMemory(
5617 extMem_out: *mut hipExternalMemory_t,
5618 memHandleDesc: *const hipExternalMemoryHandleDesc,
5619 ) -> hipError_t;
5620}
5621extern "C" {
5622 #[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"]
5623 pub fn hipExternalMemoryGetMappedBuffer(
5624 devPtr: *mut *mut ::std::os::raw::c_void,
5625 extMem: hipExternalMemory_t,
5626 bufferDesc: *const hipExternalMemoryBufferDesc,
5627 ) -> hipError_t;
5628}
5629extern "C" {
5630 #[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"]
5631 pub fn hipDestroyExternalMemory(extMem: hipExternalMemory_t) -> hipError_t;
5632}
5633extern "C" {
5634 #[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"]
5635 pub fn hipExternalMemoryGetMappedMipmappedArray(
5636 mipmap: *mut hipMipmappedArray_t,
5637 extMem: hipExternalMemory_t,
5638 mipmapDesc: *const hipExternalMemoryMipmappedArrayDesc,
5639 ) -> hipError_t;
5640}
5641extern "C" {
5642 #[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"]
5643 pub fn hipMalloc(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
5644}
5645extern "C" {
5646 #[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"]
5647 pub fn hipExtMallocWithFlags(
5648 ptr: *mut *mut ::std::os::raw::c_void,
5649 sizeBytes: usize,
5650 flags: ::std::os::raw::c_uint,
5651 ) -> hipError_t;
5652}
5653extern "C" {
5654 #[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"]
5655 pub fn hipMallocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
5656}
5657extern "C" {
5658 #[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"]
5659 pub fn hipMemAllocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
5660}
5661extern "C" {
5662 #[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"]
5663 pub fn hipHostMalloc(
5664 ptr: *mut *mut ::std::os::raw::c_void,
5665 size: usize,
5666 flags: ::std::os::raw::c_uint,
5667 ) -> hipError_t;
5668}
5669extern "C" {
5670 #[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"]
5671 pub fn hipMallocManaged(
5672 dev_ptr: *mut *mut ::std::os::raw::c_void,
5673 size: usize,
5674 flags: ::std::os::raw::c_uint,
5675 ) -> hipError_t;
5676}
5677extern "C" {
5678 #[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."]
5679 pub fn hipMemPrefetchAsync(
5680 dev_ptr: *const ::std::os::raw::c_void,
5681 count: usize,
5682 device: ::std::os::raw::c_int,
5683 stream: hipStream_t,
5684 ) -> hipError_t;
5685}
5686extern "C" {
5687 #[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."]
5688 pub fn hipMemAdvise(
5689 dev_ptr: *const ::std::os::raw::c_void,
5690 count: usize,
5691 advice: hipMemoryAdvise,
5692 device: ::std::os::raw::c_int,
5693 ) -> hipError_t;
5694}
5695extern "C" {
5696 #[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."]
5697 pub fn hipMemRangeGetAttribute(
5698 data: *mut ::std::os::raw::c_void,
5699 data_size: usize,
5700 attribute: hipMemRangeAttribute,
5701 dev_ptr: *const ::std::os::raw::c_void,
5702 count: usize,
5703 ) -> hipError_t;
5704}
5705extern "C" {
5706 #[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."]
5707 pub fn hipMemRangeGetAttributes(
5708 data: *mut *mut ::std::os::raw::c_void,
5709 data_sizes: *mut usize,
5710 attributes: *mut hipMemRangeAttribute,
5711 num_attributes: usize,
5712 dev_ptr: *const ::std::os::raw::c_void,
5713 count: usize,
5714 ) -> hipError_t;
5715}
5716extern "C" {
5717 #[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."]
5718 pub fn hipStreamAttachMemAsync(
5719 stream: hipStream_t,
5720 dev_ptr: *mut ::std::os::raw::c_void,
5721 length: usize,
5722 flags: ::std::os::raw::c_uint,
5723 ) -> hipError_t;
5724}
5725extern "C" {
5726 #[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."]
5727 pub fn hipMallocAsync(
5728 dev_ptr: *mut *mut ::std::os::raw::c_void,
5729 size: usize,
5730 stream: hipStream_t,
5731 ) -> hipError_t;
5732}
5733extern "C" {
5734 #[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."]
5735 pub fn hipFreeAsync(dev_ptr: *mut ::std::os::raw::c_void, stream: hipStream_t) -> hipError_t;
5736}
5737extern "C" {
5738 #[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."]
5739 pub fn hipMemPoolTrimTo(mem_pool: hipMemPool_t, min_bytes_to_hold: usize) -> hipError_t;
5740}
5741extern "C" {
5742 #[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."]
5743 pub fn hipMemPoolSetAttribute(
5744 mem_pool: hipMemPool_t,
5745 attr: hipMemPoolAttr,
5746 value: *mut ::std::os::raw::c_void,
5747 ) -> hipError_t;
5748}
5749extern "C" {
5750 #[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."]
5751 pub fn hipMemPoolGetAttribute(
5752 mem_pool: hipMemPool_t,
5753 attr: hipMemPoolAttr,
5754 value: *mut ::std::os::raw::c_void,
5755 ) -> hipError_t;
5756}
5757extern "C" {
5758 #[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."]
5759 pub fn hipMemPoolSetAccess(
5760 mem_pool: hipMemPool_t,
5761 desc_list: *const hipMemAccessDesc,
5762 count: usize,
5763 ) -> hipError_t;
5764}
5765extern "C" {
5766 #[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."]
5767 pub fn hipMemPoolGetAccess(
5768 flags: *mut hipMemAccessFlags,
5769 mem_pool: hipMemPool_t,
5770 location: *mut hipMemLocation,
5771 ) -> hipError_t;
5772}
5773extern "C" {
5774 #[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."]
5775 pub fn hipMemPoolCreate(
5776 mem_pool: *mut hipMemPool_t,
5777 pool_props: *const hipMemPoolProps,
5778 ) -> hipError_t;
5779}
5780extern "C" {
5781 #[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."]
5782 pub fn hipMemPoolDestroy(mem_pool: hipMemPool_t) -> hipError_t;
5783}
5784extern "C" {
5785 #[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."]
5786 pub fn hipMallocFromPoolAsync(
5787 dev_ptr: *mut *mut ::std::os::raw::c_void,
5788 size: usize,
5789 mem_pool: hipMemPool_t,
5790 stream: hipStream_t,
5791 ) -> hipError_t;
5792}
5793extern "C" {
5794 #[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."]
5795 pub fn hipMemPoolExportToShareableHandle(
5796 shared_handle: *mut ::std::os::raw::c_void,
5797 mem_pool: hipMemPool_t,
5798 handle_type: hipMemAllocationHandleType,
5799 flags: ::std::os::raw::c_uint,
5800 ) -> hipError_t;
5801}
5802extern "C" {
5803 #[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."]
5804 pub fn hipMemPoolImportFromShareableHandle(
5805 mem_pool: *mut hipMemPool_t,
5806 shared_handle: *mut ::std::os::raw::c_void,
5807 handle_type: hipMemAllocationHandleType,
5808 flags: ::std::os::raw::c_uint,
5809 ) -> hipError_t;
5810}
5811extern "C" {
5812 #[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."]
5813 pub fn hipMemPoolExportPointer(
5814 export_data: *mut hipMemPoolPtrExportData,
5815 dev_ptr: *mut ::std::os::raw::c_void,
5816 ) -> hipError_t;
5817}
5818extern "C" {
5819 #[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."]
5820 pub fn hipMemPoolImportPointer(
5821 dev_ptr: *mut *mut ::std::os::raw::c_void,
5822 mem_pool: hipMemPool_t,
5823 export_data: *mut hipMemPoolPtrExportData,
5824 ) -> hipError_t;
5825}
5826extern "C" {
5827 #[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"]
5828 pub fn hipHostAlloc(
5829 ptr: *mut *mut ::std::os::raw::c_void,
5830 size: usize,
5831 flags: ::std::os::raw::c_uint,
5832 ) -> hipError_t;
5833}
5834extern "C" {
5835 #[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"]
5836 pub fn hipHostGetDevicePointer(
5837 devPtr: *mut *mut ::std::os::raw::c_void,
5838 hstPtr: *mut ::std::os::raw::c_void,
5839 flags: ::std::os::raw::c_uint,
5840 ) -> hipError_t;
5841}
5842extern "C" {
5843 #[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"]
5844 pub fn hipHostGetFlags(
5845 flagsPtr: *mut ::std::os::raw::c_uint,
5846 hostPtr: *mut ::std::os::raw::c_void,
5847 ) -> hipError_t;
5848}
5849extern "C" {
5850 #[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"]
5851 pub fn hipHostRegister(
5852 hostPtr: *mut ::std::os::raw::c_void,
5853 sizeBytes: usize,
5854 flags: ::std::os::raw::c_uint,
5855 ) -> hipError_t;
5856}
5857extern "C" {
5858 #[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"]
5859 pub fn hipHostUnregister(hostPtr: *mut ::std::os::raw::c_void) -> hipError_t;
5860}
5861extern "C" {
5862 #[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"]
5863 pub fn hipMallocPitch(
5864 ptr: *mut *mut ::std::os::raw::c_void,
5865 pitch: *mut usize,
5866 width: usize,
5867 height: usize,
5868 ) -> hipError_t;
5869}
5870extern "C" {
5871 #[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"]
5872 pub fn hipMemAllocPitch(
5873 dptr: *mut hipDeviceptr_t,
5874 pitch: *mut usize,
5875 widthInBytes: usize,
5876 height: usize,
5877 elementSizeBytes: ::std::os::raw::c_uint,
5878 ) -> hipError_t;
5879}
5880extern "C" {
5881 #[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"]
5882 pub fn hipFree(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
5883}
5884extern "C" {
5885 #[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"]
5886 pub fn hipFreeHost(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
5887}
5888extern "C" {
5889 #[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"]
5890 pub fn hipHostFree(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
5891}
5892extern "C" {
5893 #[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"]
5894 pub fn hipMemcpy(
5895 dst: *mut ::std::os::raw::c_void,
5896 src: *const ::std::os::raw::c_void,
5897 sizeBytes: usize,
5898 kind: hipMemcpyKind,
5899 ) -> hipError_t;
5900}
5901extern "C" {
5902 #[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"]
5903 pub fn hipMemcpyWithStream(
5904 dst: *mut ::std::os::raw::c_void,
5905 src: *const ::std::os::raw::c_void,
5906 sizeBytes: usize,
5907 kind: hipMemcpyKind,
5908 stream: hipStream_t,
5909 ) -> hipError_t;
5910}
5911extern "C" {
5912 #[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"]
5913 pub fn hipMemcpyHtoD(
5914 dst: hipDeviceptr_t,
5915 src: *mut ::std::os::raw::c_void,
5916 sizeBytes: usize,
5917 ) -> hipError_t;
5918}
5919extern "C" {
5920 #[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"]
5921 pub fn hipMemcpyDtoH(
5922 dst: *mut ::std::os::raw::c_void,
5923 src: hipDeviceptr_t,
5924 sizeBytes: usize,
5925 ) -> hipError_t;
5926}
5927extern "C" {
5928 #[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"]
5929 pub fn hipMemcpyDtoD(dst: hipDeviceptr_t, src: hipDeviceptr_t, sizeBytes: usize) -> hipError_t;
5930}
5931extern "C" {
5932 #[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"]
5933 pub fn hipMemcpyAtoD(
5934 dstDevice: hipDeviceptr_t,
5935 srcArray: hipArray_t,
5936 srcOffset: usize,
5937 ByteCount: usize,
5938 ) -> hipError_t;
5939}
5940extern "C" {
5941 #[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"]
5942 pub fn hipMemcpyDtoA(
5943 dstArray: hipArray_t,
5944 dstOffset: usize,
5945 srcDevice: hipDeviceptr_t,
5946 ByteCount: usize,
5947 ) -> hipError_t;
5948}
5949extern "C" {
5950 #[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"]
5951 pub fn hipMemcpyAtoA(
5952 dstArray: hipArray_t,
5953 dstOffset: usize,
5954 srcArray: hipArray_t,
5955 srcOffset: usize,
5956 ByteCount: usize,
5957 ) -> hipError_t;
5958}
5959extern "C" {
5960 #[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"]
5961 pub fn hipMemcpyHtoDAsync(
5962 dst: hipDeviceptr_t,
5963 src: *mut ::std::os::raw::c_void,
5964 sizeBytes: usize,
5965 stream: hipStream_t,
5966 ) -> hipError_t;
5967}
5968extern "C" {
5969 #[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"]
5970 pub fn hipMemcpyDtoHAsync(
5971 dst: *mut ::std::os::raw::c_void,
5972 src: hipDeviceptr_t,
5973 sizeBytes: usize,
5974 stream: hipStream_t,
5975 ) -> hipError_t;
5976}
5977extern "C" {
5978 #[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"]
5979 pub fn hipMemcpyDtoDAsync(
5980 dst: hipDeviceptr_t,
5981 src: hipDeviceptr_t,
5982 sizeBytes: usize,
5983 stream: hipStream_t,
5984 ) -> hipError_t;
5985}
5986extern "C" {
5987 #[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"]
5988 pub fn hipMemcpyAtoHAsync(
5989 dstHost: *mut ::std::os::raw::c_void,
5990 srcArray: hipArray_t,
5991 srcOffset: usize,
5992 ByteCount: usize,
5993 stream: hipStream_t,
5994 ) -> hipError_t;
5995}
5996extern "C" {
5997 #[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"]
5998 pub fn hipMemcpyHtoAAsync(
5999 dstArray: hipArray_t,
6000 dstOffset: usize,
6001 srcHost: *const ::std::os::raw::c_void,
6002 ByteCount: usize,
6003 stream: hipStream_t,
6004 ) -> hipError_t;
6005}
6006extern "C" {
6007 #[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"]
6008 pub fn hipModuleGetGlobal(
6009 dptr: *mut hipDeviceptr_t,
6010 bytes: *mut usize,
6011 hmod: hipModule_t,
6012 name: *const ::std::os::raw::c_char,
6013 ) -> hipError_t;
6014}
6015extern "C" {
6016 #[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"]
6017 pub fn hipGetSymbolAddress(
6018 devPtr: *mut *mut ::std::os::raw::c_void,
6019 symbol: *const ::std::os::raw::c_void,
6020 ) -> hipError_t;
6021}
6022extern "C" {
6023 #[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"]
6024 pub fn hipGetSymbolSize(size: *mut usize, symbol: *const ::std::os::raw::c_void) -> hipError_t;
6025}
6026extern "C" {
6027 #[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."]
6028 pub fn hipGetProcAddress(
6029 symbol: *const ::std::os::raw::c_char,
6030 pfn: *mut *mut ::std::os::raw::c_void,
6031 hipVersion: ::std::os::raw::c_int,
6032 flags: u64,
6033 symbolStatus: *mut hipDriverProcAddressQueryResult,
6034 ) -> hipError_t;
6035}
6036extern "C" {
6037 #[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"]
6038 pub fn hipMemcpyToSymbol(
6039 symbol: *const ::std::os::raw::c_void,
6040 src: *const ::std::os::raw::c_void,
6041 sizeBytes: usize,
6042 offset: usize,
6043 kind: hipMemcpyKind,
6044 ) -> hipError_t;
6045}
6046extern "C" {
6047 #[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"]
6048 pub fn hipMemcpyToSymbolAsync(
6049 symbol: *const ::std::os::raw::c_void,
6050 src: *const ::std::os::raw::c_void,
6051 sizeBytes: usize,
6052 offset: usize,
6053 kind: hipMemcpyKind,
6054 stream: hipStream_t,
6055 ) -> hipError_t;
6056}
6057extern "C" {
6058 #[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"]
6059 pub fn hipMemcpyFromSymbol(
6060 dst: *mut ::std::os::raw::c_void,
6061 symbol: *const ::std::os::raw::c_void,
6062 sizeBytes: usize,
6063 offset: usize,
6064 kind: hipMemcpyKind,
6065 ) -> hipError_t;
6066}
6067extern "C" {
6068 #[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"]
6069 pub fn hipMemcpyFromSymbolAsync(
6070 dst: *mut ::std::os::raw::c_void,
6071 symbol: *const ::std::os::raw::c_void,
6072 sizeBytes: usize,
6073 offset: usize,
6074 kind: hipMemcpyKind,
6075 stream: hipStream_t,
6076 ) -> hipError_t;
6077}
6078extern "C" {
6079 #[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"]
6080 pub fn hipMemcpyAsync(
6081 dst: *mut ::std::os::raw::c_void,
6082 src: *const ::std::os::raw::c_void,
6083 sizeBytes: usize,
6084 kind: hipMemcpyKind,
6085 stream: hipStream_t,
6086 ) -> hipError_t;
6087}
6088extern "C" {
6089 #[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"]
6090 pub fn hipMemset(
6091 dst: *mut ::std::os::raw::c_void,
6092 value: ::std::os::raw::c_int,
6093 sizeBytes: usize,
6094 ) -> hipError_t;
6095}
6096extern "C" {
6097 #[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"]
6098 pub fn hipMemsetD8(
6099 dest: hipDeviceptr_t,
6100 value: ::std::os::raw::c_uchar,
6101 count: usize,
6102 ) -> hipError_t;
6103}
6104extern "C" {
6105 #[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"]
6106 pub fn hipMemsetD8Async(
6107 dest: hipDeviceptr_t,
6108 value: ::std::os::raw::c_uchar,
6109 count: usize,
6110 stream: hipStream_t,
6111 ) -> hipError_t;
6112}
6113extern "C" {
6114 #[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"]
6115 pub fn hipMemsetD16(
6116 dest: hipDeviceptr_t,
6117 value: ::std::os::raw::c_ushort,
6118 count: usize,
6119 ) -> hipError_t;
6120}
6121extern "C" {
6122 #[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"]
6123 pub fn hipMemsetD16Async(
6124 dest: hipDeviceptr_t,
6125 value: ::std::os::raw::c_ushort,
6126 count: usize,
6127 stream: hipStream_t,
6128 ) -> hipError_t;
6129}
6130extern "C" {
6131 #[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"]
6132 pub fn hipMemsetD32(
6133 dest: hipDeviceptr_t,
6134 value: ::std::os::raw::c_int,
6135 count: usize,
6136 ) -> hipError_t;
6137}
6138extern "C" {
6139 #[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"]
6140 pub fn hipMemsetAsync(
6141 dst: *mut ::std::os::raw::c_void,
6142 value: ::std::os::raw::c_int,
6143 sizeBytes: usize,
6144 stream: hipStream_t,
6145 ) -> hipError_t;
6146}
6147extern "C" {
6148 #[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"]
6149 pub fn hipMemsetD32Async(
6150 dst: hipDeviceptr_t,
6151 value: ::std::os::raw::c_int,
6152 count: usize,
6153 stream: hipStream_t,
6154 ) -> hipError_t;
6155}
6156extern "C" {
6157 #[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"]
6158 pub fn hipMemset2D(
6159 dst: *mut ::std::os::raw::c_void,
6160 pitch: usize,
6161 value: ::std::os::raw::c_int,
6162 width: usize,
6163 height: usize,
6164 ) -> hipError_t;
6165}
6166extern "C" {
6167 #[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"]
6168 pub fn hipMemset2DAsync(
6169 dst: *mut ::std::os::raw::c_void,
6170 pitch: usize,
6171 value: ::std::os::raw::c_int,
6172 width: usize,
6173 height: usize,
6174 stream: hipStream_t,
6175 ) -> hipError_t;
6176}
6177extern "C" {
6178 #[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"]
6179 pub fn hipMemset3D(
6180 pitchedDevPtr: hipPitchedPtr,
6181 value: ::std::os::raw::c_int,
6182 extent: hipExtent,
6183 ) -> hipError_t;
6184}
6185extern "C" {
6186 #[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"]
6187 pub fn hipMemset3DAsync(
6188 pitchedDevPtr: hipPitchedPtr,
6189 value: ::std::os::raw::c_int,
6190 extent: hipExtent,
6191 stream: hipStream_t,
6192 ) -> hipError_t;
6193}
6194extern "C" {
6195 #[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"]
6196 pub fn hipMemGetInfo(free: *mut usize, total: *mut usize) -> hipError_t;
6197}
6198extern "C" {
6199 #[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"]
6200 pub fn hipMemPtrGetInfo(ptr: *mut ::std::os::raw::c_void, size: *mut usize) -> hipError_t;
6201}
6202extern "C" {
6203 #[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"]
6204 pub fn hipMallocArray(
6205 array: *mut hipArray_t,
6206 desc: *const hipChannelFormatDesc,
6207 width: usize,
6208 height: usize,
6209 flags: ::std::os::raw::c_uint,
6210 ) -> hipError_t;
6211}
6212extern "C" {
6213 #[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"]
6214 pub fn hipArrayCreate(
6215 pHandle: *mut hipArray_t,
6216 pAllocateArray: *const HIP_ARRAY_DESCRIPTOR,
6217 ) -> hipError_t;
6218}
6219extern "C" {
6220 #[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"]
6221 pub fn hipArrayDestroy(array: hipArray_t) -> hipError_t;
6222}
6223extern "C" {
6224 #[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"]
6225 pub fn hipArray3DCreate(
6226 array: *mut hipArray_t,
6227 pAllocateArray: *const HIP_ARRAY3D_DESCRIPTOR,
6228 ) -> hipError_t;
6229}
6230extern "C" {
6231 #[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"]
6232 pub fn hipMalloc3D(pitchedDevPtr: *mut hipPitchedPtr, extent: hipExtent) -> hipError_t;
6233}
6234extern "C" {
6235 #[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"]
6236 pub fn hipFreeArray(array: hipArray_t) -> hipError_t;
6237}
6238extern "C" {
6239 #[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"]
6240 pub fn hipMalloc3DArray(
6241 array: *mut hipArray_t,
6242 desc: *const hipChannelFormatDesc,
6243 extent: hipExtent,
6244 flags: ::std::os::raw::c_uint,
6245 ) -> hipError_t;
6246}
6247extern "C" {
6248 #[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"]
6249 pub fn hipArrayGetInfo(
6250 desc: *mut hipChannelFormatDesc,
6251 extent: *mut hipExtent,
6252 flags: *mut ::std::os::raw::c_uint,
6253 array: hipArray_t,
6254 ) -> hipError_t;
6255}
6256extern "C" {
6257 #[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"]
6258 pub fn hipArrayGetDescriptor(
6259 pArrayDescriptor: *mut HIP_ARRAY_DESCRIPTOR,
6260 array: hipArray_t,
6261 ) -> hipError_t;
6262}
6263extern "C" {
6264 #[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"]
6265 pub fn hipArray3DGetDescriptor(
6266 pArrayDescriptor: *mut HIP_ARRAY3D_DESCRIPTOR,
6267 array: hipArray_t,
6268 ) -> hipError_t;
6269}
6270extern "C" {
6271 #[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"]
6272 pub fn hipMemcpy2D(
6273 dst: *mut ::std::os::raw::c_void,
6274 dpitch: usize,
6275 src: *const ::std::os::raw::c_void,
6276 spitch: usize,
6277 width: usize,
6278 height: usize,
6279 kind: hipMemcpyKind,
6280 ) -> hipError_t;
6281}
6282extern "C" {
6283 #[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"]
6284 pub fn hipMemcpyParam2D(pCopy: *const hip_Memcpy2D) -> hipError_t;
6285}
6286extern "C" {
6287 #[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"]
6288 pub fn hipMemcpyParam2DAsync(pCopy: *const hip_Memcpy2D, stream: hipStream_t) -> hipError_t;
6289}
6290extern "C" {
6291 #[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"]
6292 pub fn hipMemcpy2DAsync(
6293 dst: *mut ::std::os::raw::c_void,
6294 dpitch: usize,
6295 src: *const ::std::os::raw::c_void,
6296 spitch: usize,
6297 width: usize,
6298 height: usize,
6299 kind: hipMemcpyKind,
6300 stream: hipStream_t,
6301 ) -> hipError_t;
6302}
6303extern "C" {
6304 #[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"]
6305 pub fn hipMemcpy2DToArray(
6306 dst: hipArray_t,
6307 wOffset: usize,
6308 hOffset: usize,
6309 src: *const ::std::os::raw::c_void,
6310 spitch: usize,
6311 width: usize,
6312 height: usize,
6313 kind: hipMemcpyKind,
6314 ) -> hipError_t;
6315}
6316extern "C" {
6317 #[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"]
6318 pub fn hipMemcpy2DToArrayAsync(
6319 dst: hipArray_t,
6320 wOffset: usize,
6321 hOffset: usize,
6322 src: *const ::std::os::raw::c_void,
6323 spitch: usize,
6324 width: usize,
6325 height: usize,
6326 kind: hipMemcpyKind,
6327 stream: hipStream_t,
6328 ) -> hipError_t;
6329}
6330extern "C" {
6331 #[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"]
6332 pub fn hipMemcpy2DArrayToArray(
6333 dst: hipArray_t,
6334 wOffsetDst: usize,
6335 hOffsetDst: usize,
6336 src: hipArray_const_t,
6337 wOffsetSrc: usize,
6338 hOffsetSrc: usize,
6339 width: usize,
6340 height: usize,
6341 kind: hipMemcpyKind,
6342 ) -> hipError_t;
6343}
6344extern "C" {
6345 #[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."]
6346 pub fn hipMemcpyToArray(
6347 dst: hipArray_t,
6348 wOffset: usize,
6349 hOffset: usize,
6350 src: *const ::std::os::raw::c_void,
6351 count: usize,
6352 kind: hipMemcpyKind,
6353 ) -> hipError_t;
6354}
6355extern "C" {
6356 #[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."]
6357 pub fn hipMemcpyFromArray(
6358 dst: *mut ::std::os::raw::c_void,
6359 srcArray: hipArray_const_t,
6360 wOffset: usize,
6361 hOffset: usize,
6362 count: usize,
6363 kind: hipMemcpyKind,
6364 ) -> hipError_t;
6365}
6366extern "C" {
6367 #[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"]
6368 pub fn hipMemcpy2DFromArray(
6369 dst: *mut ::std::os::raw::c_void,
6370 dpitch: usize,
6371 src: hipArray_const_t,
6372 wOffset: usize,
6373 hOffset: usize,
6374 width: usize,
6375 height: usize,
6376 kind: hipMemcpyKind,
6377 ) -> hipError_t;
6378}
6379extern "C" {
6380 #[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"]
6381 pub fn hipMemcpy2DFromArrayAsync(
6382 dst: *mut ::std::os::raw::c_void,
6383 dpitch: usize,
6384 src: hipArray_const_t,
6385 wOffset: usize,
6386 hOffset: usize,
6387 width: usize,
6388 height: usize,
6389 kind: hipMemcpyKind,
6390 stream: hipStream_t,
6391 ) -> hipError_t;
6392}
6393extern "C" {
6394 #[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"]
6395 pub fn hipMemcpyAtoH(
6396 dst: *mut ::std::os::raw::c_void,
6397 srcArray: hipArray_t,
6398 srcOffset: usize,
6399 count: usize,
6400 ) -> hipError_t;
6401}
6402extern "C" {
6403 #[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"]
6404 pub fn hipMemcpyHtoA(
6405 dstArray: hipArray_t,
6406 dstOffset: usize,
6407 srcHost: *const ::std::os::raw::c_void,
6408 count: usize,
6409 ) -> hipError_t;
6410}
6411extern "C" {
6412 #[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"]
6413 pub fn hipMemcpy3D(p: *const hipMemcpy3DParms) -> hipError_t;
6414}
6415extern "C" {
6416 #[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"]
6417 pub fn hipMemcpy3DAsync(p: *const hipMemcpy3DParms, stream: hipStream_t) -> hipError_t;
6418}
6419extern "C" {
6420 #[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"]
6421 pub fn hipDrvMemcpy3D(pCopy: *const HIP_MEMCPY3D) -> hipError_t;
6422}
6423extern "C" {
6424 #[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"]
6425 pub fn hipDrvMemcpy3DAsync(pCopy: *const HIP_MEMCPY3D, stream: hipStream_t) -> hipError_t;
6426}
6427extern "C" {
6428 #[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"]
6429 pub fn hipDeviceCanAccessPeer(
6430 canAccessPeer: *mut ::std::os::raw::c_int,
6431 deviceId: ::std::os::raw::c_int,
6432 peerDeviceId: ::std::os::raw::c_int,
6433 ) -> hipError_t;
6434}
6435extern "C" {
6436 #[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."]
6437 pub fn hipDeviceEnablePeerAccess(
6438 peerDeviceId: ::std::os::raw::c_int,
6439 flags: ::std::os::raw::c_uint,
6440 ) -> hipError_t;
6441}
6442extern "C" {
6443 #[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"]
6444 pub fn hipDeviceDisablePeerAccess(peerDeviceId: ::std::os::raw::c_int) -> hipError_t;
6445}
6446extern "C" {
6447 #[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"]
6448 pub fn hipMemGetAddressRange(
6449 pbase: *mut hipDeviceptr_t,
6450 psize: *mut usize,
6451 dptr: hipDeviceptr_t,
6452 ) -> hipError_t;
6453}
6454extern "C" {
6455 #[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"]
6456 pub fn hipMemcpyPeer(
6457 dst: *mut ::std::os::raw::c_void,
6458 dstDeviceId: ::std::os::raw::c_int,
6459 src: *const ::std::os::raw::c_void,
6460 srcDeviceId: ::std::os::raw::c_int,
6461 sizeBytes: usize,
6462 ) -> hipError_t;
6463}
6464extern "C" {
6465 #[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"]
6466 pub fn hipMemcpyPeerAsync(
6467 dst: *mut ::std::os::raw::c_void,
6468 dstDeviceId: ::std::os::raw::c_int,
6469 src: *const ::std::os::raw::c_void,
6470 srcDevice: ::std::os::raw::c_int,
6471 sizeBytes: usize,
6472 stream: hipStream_t,
6473 ) -> hipError_t;
6474}
6475extern "C" {
6476 #[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"]
6477 pub fn hipCtxCreate(
6478 ctx: *mut hipCtx_t,
6479 flags: ::std::os::raw::c_uint,
6480 device: hipDevice_t,
6481 ) -> hipError_t;
6482}
6483extern "C" {
6484 #[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."]
6485 pub fn hipCtxDestroy(ctx: hipCtx_t) -> hipError_t;
6486}
6487extern "C" {
6488 #[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."]
6489 pub fn hipCtxPopCurrent(ctx: *mut hipCtx_t) -> hipError_t;
6490}
6491extern "C" {
6492 #[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."]
6493 pub fn hipCtxPushCurrent(ctx: hipCtx_t) -> hipError_t;
6494}
6495extern "C" {
6496 #[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."]
6497 pub fn hipCtxSetCurrent(ctx: hipCtx_t) -> hipError_t;
6498}
6499extern "C" {
6500 #[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."]
6501 pub fn hipCtxGetCurrent(ctx: *mut hipCtx_t) -> hipError_t;
6502}
6503extern "C" {
6504 #[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."]
6505 pub fn hipCtxGetDevice(device: *mut hipDevice_t) -> hipError_t;
6506}
6507extern "C" {
6508 #[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."]
6509 pub fn hipCtxGetApiVersion(ctx: hipCtx_t, apiVersion: *mut ::std::os::raw::c_int)
6510 -> hipError_t;
6511}
6512extern "C" {
6513 #[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."]
6514 pub fn hipCtxGetCacheConfig(cacheConfig: *mut hipFuncCache_t) -> hipError_t;
6515}
6516extern "C" {
6517 #[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."]
6518 pub fn hipCtxSetCacheConfig(cacheConfig: hipFuncCache_t) -> hipError_t;
6519}
6520extern "C" {
6521 #[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."]
6522 pub fn hipCtxSetSharedMemConfig(config: hipSharedMemConfig) -> hipError_t;
6523}
6524extern "C" {
6525 #[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."]
6526 pub fn hipCtxGetSharedMemConfig(pConfig: *mut hipSharedMemConfig) -> hipError_t;
6527}
6528extern "C" {
6529 #[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."]
6530 pub fn hipCtxSynchronize() -> hipError_t;
6531}
6532extern "C" {
6533 #[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."]
6534 pub fn hipCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> hipError_t;
6535}
6536extern "C" {
6537 #[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."]
6538 pub fn hipCtxEnablePeerAccess(peerCtx: hipCtx_t, flags: ::std::os::raw::c_uint) -> hipError_t;
6539}
6540extern "C" {
6541 #[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."]
6542 pub fn hipCtxDisablePeerAccess(peerCtx: hipCtx_t) -> hipError_t;
6543}
6544extern "C" {
6545 #[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."]
6546 pub fn hipDevicePrimaryCtxGetState(
6547 dev: hipDevice_t,
6548 flags: *mut ::std::os::raw::c_uint,
6549 active: *mut ::std::os::raw::c_int,
6550 ) -> hipError_t;
6551}
6552extern "C" {
6553 #[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."]
6554 pub fn hipDevicePrimaryCtxRelease(dev: hipDevice_t) -> hipError_t;
6555}
6556extern "C" {
6557 #[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."]
6558 pub fn hipDevicePrimaryCtxRetain(pctx: *mut hipCtx_t, dev: hipDevice_t) -> hipError_t;
6559}
6560extern "C" {
6561 #[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."]
6562 pub fn hipDevicePrimaryCtxReset(dev: hipDevice_t) -> hipError_t;
6563}
6564extern "C" {
6565 #[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."]
6566 pub fn hipDevicePrimaryCtxSetFlags(
6567 dev: hipDevice_t,
6568 flags: ::std::os::raw::c_uint,
6569 ) -> hipError_t;
6570}
6571extern "C" {
6572 #[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"]
6573 pub fn hipModuleLoad(
6574 module: *mut hipModule_t,
6575 fname: *const ::std::os::raw::c_char,
6576 ) -> hipError_t;
6577}
6578extern "C" {
6579 #[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."]
6580 pub fn hipModuleUnload(module: hipModule_t) -> hipError_t;
6581}
6582extern "C" {
6583 #[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,"]
6584 pub fn hipModuleGetFunction(
6585 function: *mut hipFunction_t,
6586 module: hipModule_t,
6587 kname: *const ::std::os::raw::c_char,
6588 ) -> hipError_t;
6589}
6590extern "C" {
6591 #[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"]
6592 pub fn hipFuncGetAttributes(
6593 attr: *mut hipFuncAttributes,
6594 func: *const ::std::os::raw::c_void,
6595 ) -> hipError_t;
6596}
6597extern "C" {
6598 #[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"]
6599 pub fn hipFuncGetAttribute(
6600 value: *mut ::std::os::raw::c_int,
6601 attrib: hipFunction_attribute,
6602 hfunc: hipFunction_t,
6603 ) -> hipError_t;
6604}
6605extern "C" {
6606 #[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"]
6607 pub fn hipGetFuncBySymbol(
6608 functionPtr: *mut hipFunction_t,
6609 symbolPtr: *const ::std::os::raw::c_void,
6610 ) -> hipError_t;
6611}
6612extern "C" {
6613 #[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"]
6614 pub fn hipModuleGetTexRef(
6615 texRef: *mut *mut textureReference,
6616 hmod: hipModule_t,
6617 name: *const ::std::os::raw::c_char,
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.\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"]
6622 pub fn hipModuleLoadData(
6623 module: *mut hipModule_t,
6624 image: *const ::std::os::raw::c_void,
6625 ) -> hipError_t;
6626}
6627extern "C" {
6628 #[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"]
6629 pub fn hipModuleLoadDataEx(
6630 module: *mut hipModule_t,
6631 image: *const ::std::os::raw::c_void,
6632 numOptions: ::std::os::raw::c_uint,
6633 options: *mut hipJitOption,
6634 optionValues: *mut *mut ::std::os::raw::c_void,
6635 ) -> hipError_t;
6636}
6637extern "C" {
6638 #[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"]
6639 pub fn hipLinkAddData(
6640 state: hipLinkState_t,
6641 type_: hipJitInputType,
6642 data: *mut ::std::os::raw::c_void,
6643 size: usize,
6644 name: *const ::std::os::raw::c_char,
6645 numOptions: ::std::os::raw::c_uint,
6646 options: *mut hipJitOption,
6647 optionValues: *mut *mut ::std::os::raw::c_void,
6648 ) -> hipError_t;
6649}
6650extern "C" {
6651 #[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"]
6652 pub fn hipLinkAddFile(
6653 state: hipLinkState_t,
6654 type_: hipJitInputType,
6655 path: *const ::std::os::raw::c_char,
6656 numOptions: ::std::os::raw::c_uint,
6657 options: *mut hipJitOption,
6658 optionValues: *mut *mut ::std::os::raw::c_void,
6659 ) -> hipError_t;
6660}
6661extern "C" {
6662 #[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"]
6663 pub fn hipLinkComplete(
6664 state: hipLinkState_t,
6665 hipBinOut: *mut *mut ::std::os::raw::c_void,
6666 sizeOut: *mut usize,
6667 ) -> hipError_t;
6668}
6669extern "C" {
6670 #[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"]
6671 pub fn hipLinkCreate(
6672 numOptions: ::std::os::raw::c_uint,
6673 options: *mut hipJitOption,
6674 optionValues: *mut *mut ::std::os::raw::c_void,
6675 stateOut: *mut hipLinkState_t,
6676 ) -> hipError_t;
6677}
6678extern "C" {
6679 #[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"]
6680 pub fn hipLinkDestroy(state: hipLinkState_t) -> hipError_t;
6681}
6682extern "C" {
6683 #[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"]
6684 pub fn hipModuleLaunchKernel(
6685 f: hipFunction_t,
6686 gridDimX: ::std::os::raw::c_uint,
6687 gridDimY: ::std::os::raw::c_uint,
6688 gridDimZ: ::std::os::raw::c_uint,
6689 blockDimX: ::std::os::raw::c_uint,
6690 blockDimY: ::std::os::raw::c_uint,
6691 blockDimZ: ::std::os::raw::c_uint,
6692 sharedMemBytes: ::std::os::raw::c_uint,
6693 stream: hipStream_t,
6694 kernelParams: *mut *mut ::std::os::raw::c_void,
6695 extra: *mut *mut ::std::os::raw::c_void,
6696 ) -> hipError_t;
6697}
6698extern "C" {
6699 #[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"]
6700 pub fn hipModuleLaunchCooperativeKernel(
6701 f: hipFunction_t,
6702 gridDimX: ::std::os::raw::c_uint,
6703 gridDimY: ::std::os::raw::c_uint,
6704 gridDimZ: ::std::os::raw::c_uint,
6705 blockDimX: ::std::os::raw::c_uint,
6706 blockDimY: ::std::os::raw::c_uint,
6707 blockDimZ: ::std::os::raw::c_uint,
6708 sharedMemBytes: ::std::os::raw::c_uint,
6709 stream: hipStream_t,
6710 kernelParams: *mut *mut ::std::os::raw::c_void,
6711 ) -> hipError_t;
6712}
6713extern "C" {
6714 #[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"]
6715 pub fn hipModuleLaunchCooperativeKernelMultiDevice(
6716 launchParamsList: *mut hipFunctionLaunchParams,
6717 numDevices: ::std::os::raw::c_uint,
6718 flags: ::std::os::raw::c_uint,
6719 ) -> hipError_t;
6720}
6721extern "C" {
6722 #[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"]
6723 pub fn hipLaunchCooperativeKernel(
6724 f: *const ::std::os::raw::c_void,
6725 gridDim: dim3,
6726 blockDimX: dim3,
6727 kernelParams: *mut *mut ::std::os::raw::c_void,
6728 sharedMemBytes: ::std::os::raw::c_uint,
6729 stream: hipStream_t,
6730 ) -> hipError_t;
6731}
6732extern "C" {
6733 #[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"]
6734 pub fn hipLaunchCooperativeKernelMultiDevice(
6735 launchParamsList: *mut hipLaunchParams,
6736 numDevices: ::std::os::raw::c_int,
6737 flags: ::std::os::raw::c_uint,
6738 ) -> hipError_t;
6739}
6740extern "C" {
6741 #[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"]
6742 pub fn hipExtLaunchMultiKernelMultiDevice(
6743 launchParamsList: *mut hipLaunchParams,
6744 numDevices: ::std::os::raw::c_int,
6745 flags: ::std::os::raw::c_uint,
6746 ) -> hipError_t;
6747}
6748extern "C" {
6749 #[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"]
6750 pub fn hipModuleOccupancyMaxPotentialBlockSize(
6751 gridSize: *mut ::std::os::raw::c_int,
6752 blockSize: *mut ::std::os::raw::c_int,
6753 f: hipFunction_t,
6754 dynSharedMemPerBlk: usize,
6755 blockSizeLimit: ::std::os::raw::c_int,
6756 ) -> hipError_t;
6757}
6758extern "C" {
6759 #[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"]
6760 pub fn hipModuleOccupancyMaxPotentialBlockSizeWithFlags(
6761 gridSize: *mut ::std::os::raw::c_int,
6762 blockSize: *mut ::std::os::raw::c_int,
6763 f: hipFunction_t,
6764 dynSharedMemPerBlk: usize,
6765 blockSizeLimit: ::std::os::raw::c_int,
6766 flags: ::std::os::raw::c_uint,
6767 ) -> hipError_t;
6768}
6769extern "C" {
6770 #[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"]
6771 pub fn hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(
6772 numBlocks: *mut ::std::os::raw::c_int,
6773 f: hipFunction_t,
6774 blockSize: ::std::os::raw::c_int,
6775 dynSharedMemPerBlk: usize,
6776 ) -> hipError_t;
6777}
6778extern "C" {
6779 #[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"]
6780 pub fn hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
6781 numBlocks: *mut ::std::os::raw::c_int,
6782 f: hipFunction_t,
6783 blockSize: ::std::os::raw::c_int,
6784 dynSharedMemPerBlk: usize,
6785 flags: ::std::os::raw::c_uint,
6786 ) -> hipError_t;
6787}
6788extern "C" {
6789 #[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"]
6790 pub fn hipOccupancyMaxActiveBlocksPerMultiprocessor(
6791 numBlocks: *mut ::std::os::raw::c_int,
6792 f: *const ::std::os::raw::c_void,
6793 blockSize: ::std::os::raw::c_int,
6794 dynSharedMemPerBlk: usize,
6795 ) -> hipError_t;
6796}
6797extern "C" {
6798 #[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"]
6799 pub fn hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
6800 numBlocks: *mut ::std::os::raw::c_int,
6801 f: *const ::std::os::raw::c_void,
6802 blockSize: ::std::os::raw::c_int,
6803 dynSharedMemPerBlk: usize,
6804 flags: ::std::os::raw::c_uint,
6805 ) -> hipError_t;
6806}
6807extern "C" {
6808 #[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"]
6809 pub fn hipOccupancyMaxPotentialBlockSize(
6810 gridSize: *mut ::std::os::raw::c_int,
6811 blockSize: *mut ::std::os::raw::c_int,
6812 f: *const ::std::os::raw::c_void,
6813 dynSharedMemPerBlk: usize,
6814 blockSizeLimit: ::std::os::raw::c_int,
6815 ) -> hipError_t;
6816}
6817extern "C" {
6818 #[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."]
6819 pub fn hipProfilerStart() -> hipError_t;
6820}
6821extern "C" {
6822 #[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."]
6823 pub fn hipProfilerStop() -> hipError_t;
6824}
6825extern "C" {
6826 #[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"]
6827 pub fn hipConfigureCall(
6828 gridDim: dim3,
6829 blockDim: dim3,
6830 sharedMem: usize,
6831 stream: hipStream_t,
6832 ) -> hipError_t;
6833}
6834extern "C" {
6835 #[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"]
6836 pub fn hipSetupArgument(
6837 arg: *const ::std::os::raw::c_void,
6838 size: usize,
6839 offset: usize,
6840 ) -> hipError_t;
6841}
6842extern "C" {
6843 #[doc = " @brief Launch a kernel.\n\n @param [in] func Kernel to launch.\n\n @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue\n"]
6844 pub fn hipLaunchByPtr(func: *const ::std::os::raw::c_void) -> hipError_t;
6845}
6846extern "C" {
6847 #[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"]
6848 pub fn __hipPushCallConfiguration(
6849 gridDim: dim3,
6850 blockDim: dim3,
6851 sharedMem: usize,
6852 stream: hipStream_t,
6853 ) -> hipError_t;
6854}
6855extern "C" {
6856 #[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"]
6857 pub fn __hipPopCallConfiguration(
6858 gridDim: *mut dim3,
6859 blockDim: *mut dim3,
6860 sharedMem: *mut usize,
6861 stream: *mut hipStream_t,
6862 ) -> hipError_t;
6863}
6864extern "C" {
6865 #[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"]
6866 pub fn hipLaunchKernel(
6867 function_address: *const ::std::os::raw::c_void,
6868 numBlocks: dim3,
6869 dimBlocks: dim3,
6870 args: *mut *mut ::std::os::raw::c_void,
6871 sharedMemBytes: usize,
6872 stream: hipStream_t,
6873 ) -> hipError_t;
6874}
6875extern "C" {
6876 #[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."]
6877 pub fn hipLaunchHostFunc(
6878 stream: hipStream_t,
6879 fn_: hipHostFn_t,
6880 userData: *mut ::std::os::raw::c_void,
6881 ) -> hipError_t;
6882}
6883extern "C" {
6884 #[doc = " Copies memory for 2D arrays.\n\n @param pCopy - Parameters for the memory copy\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
6885 pub fn hipDrvMemcpy2DUnaligned(pCopy: *const hip_Memcpy2D) -> hipError_t;
6886}
6887extern "C" {
6888 #[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"]
6889 pub fn hipExtLaunchKernel(
6890 function_address: *const ::std::os::raw::c_void,
6891 numBlocks: dim3,
6892 dimBlocks: dim3,
6893 args: *mut *mut ::std::os::raw::c_void,
6894 sharedMemBytes: usize,
6895 stream: hipStream_t,
6896 startEvent: hipEvent_t,
6897 stopEvent: hipEvent_t,
6898 flags: ::std::os::raw::c_int,
6899 ) -> hipError_t;
6900}
6901extern "C" {
6902 #[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"]
6903 pub fn hipCreateTextureObject(
6904 pTexObject: *mut hipTextureObject_t,
6905 pResDesc: *const hipResourceDesc,
6906 pTexDesc: *const hipTextureDesc,
6907 pResViewDesc: *const hipResourceViewDesc,
6908 ) -> hipError_t;
6909}
6910extern "C" {
6911 #[doc = " @brief Destroys a texture object.\n\n @param [in] textureObject texture object to destroy\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6912 pub fn hipDestroyTextureObject(textureObject: hipTextureObject_t) -> hipError_t;
6913}
6914extern "C" {
6915 #[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"]
6916 pub fn hipGetChannelDesc(
6917 desc: *mut hipChannelFormatDesc,
6918 array: hipArray_const_t,
6919 ) -> hipError_t;
6920}
6921extern "C" {
6922 #[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"]
6923 pub fn hipGetTextureObjectResourceDesc(
6924 pResDesc: *mut hipResourceDesc,
6925 textureObject: hipTextureObject_t,
6926 ) -> hipError_t;
6927}
6928extern "C" {
6929 #[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"]
6930 pub fn hipGetTextureObjectResourceViewDesc(
6931 pResViewDesc: *mut hipResourceViewDesc,
6932 textureObject: hipTextureObject_t,
6933 ) -> hipError_t;
6934}
6935extern "C" {
6936 #[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"]
6937 pub fn hipGetTextureObjectTextureDesc(
6938 pTexDesc: *mut hipTextureDesc,
6939 textureObject: hipTextureObject_t,
6940 ) -> hipError_t;
6941}
6942extern "C" {
6943 #[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"]
6944 pub fn hipTexObjectCreate(
6945 pTexObject: *mut hipTextureObject_t,
6946 pResDesc: *const HIP_RESOURCE_DESC,
6947 pTexDesc: *const HIP_TEXTURE_DESC,
6948 pResViewDesc: *const HIP_RESOURCE_VIEW_DESC,
6949 ) -> hipError_t;
6950}
6951extern "C" {
6952 #[doc = " @brief Destroys a texture object.\n\n @param [in] texObject texture object to destroy\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
6953 pub fn hipTexObjectDestroy(texObject: hipTextureObject_t) -> hipError_t;
6954}
6955extern "C" {
6956 #[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"]
6957 pub fn hipTexObjectGetResourceDesc(
6958 pResDesc: *mut HIP_RESOURCE_DESC,
6959 texObject: hipTextureObject_t,
6960 ) -> hipError_t;
6961}
6962extern "C" {
6963 #[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"]
6964 pub fn hipTexObjectGetResourceViewDesc(
6965 pResViewDesc: *mut HIP_RESOURCE_VIEW_DESC,
6966 texObject: hipTextureObject_t,
6967 ) -> hipError_t;
6968}
6969extern "C" {
6970 #[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"]
6971 pub fn hipTexObjectGetTextureDesc(
6972 pTexDesc: *mut HIP_TEXTURE_DESC,
6973 texObject: hipTextureObject_t,
6974 ) -> hipError_t;
6975}
6976extern "C" {
6977 #[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"]
6978 pub fn hipMallocMipmappedArray(
6979 mipmappedArray: *mut hipMipmappedArray_t,
6980 desc: *const hipChannelFormatDesc,
6981 extent: hipExtent,
6982 numLevels: ::std::os::raw::c_uint,
6983 flags: ::std::os::raw::c_uint,
6984 ) -> hipError_t;
6985}
6986extern "C" {
6987 #[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"]
6988 pub fn hipFreeMipmappedArray(mipmappedArray: hipMipmappedArray_t) -> hipError_t;
6989}
6990extern "C" {
6991 #[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"]
6992 pub fn hipGetMipmappedArrayLevel(
6993 levelArray: *mut hipArray_t,
6994 mipmappedArray: hipMipmappedArray_const_t,
6995 level: ::std::os::raw::c_uint,
6996 ) -> hipError_t;
6997}
6998extern "C" {
6999 #[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."]
7000 pub fn hipMipmappedArrayCreate(
7001 pHandle: *mut hipMipmappedArray_t,
7002 pMipmappedArrayDesc: *mut HIP_ARRAY3D_DESCRIPTOR,
7003 numMipmapLevels: ::std::os::raw::c_uint,
7004 ) -> hipError_t;
7005}
7006extern "C" {
7007 #[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"]
7008 pub fn hipMipmappedArrayDestroy(hMipmappedArray: hipMipmappedArray_t) -> hipError_t;
7009}
7010extern "C" {
7011 #[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"]
7012 pub fn hipMipmappedArrayGetLevel(
7013 pLevelArray: *mut hipArray_t,
7014 hMipMappedArray: hipMipmappedArray_t,
7015 level: ::std::os::raw::c_uint,
7016 ) -> hipError_t;
7017}
7018extern "C" {
7019 #[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"]
7020 pub fn hipBindTextureToMipmappedArray(
7021 tex: *const textureReference,
7022 mipmappedArray: hipMipmappedArray_const_t,
7023 desc: *const hipChannelFormatDesc,
7024 ) -> hipError_t;
7025}
7026extern "C" {
7027 #[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"]
7028 pub fn hipGetTextureReference(
7029 texref: *mut *const textureReference,
7030 symbol: *const ::std::os::raw::c_void,
7031 ) -> hipError_t;
7032}
7033extern "C" {
7034 #[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"]
7035 pub fn hipTexRefGetBorderColor(
7036 pBorderColor: *mut f32,
7037 texRef: *const textureReference,
7038 ) -> hipError_t;
7039}
7040extern "C" {
7041 #[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"]
7042 pub fn hipTexRefGetArray(
7043 pArray: *mut hipArray_t,
7044 texRef: *const textureReference,
7045 ) -> hipError_t;
7046}
7047extern "C" {
7048 #[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"]
7049 pub fn hipTexRefSetAddressMode(
7050 texRef: *mut textureReference,
7051 dim: ::std::os::raw::c_int,
7052 am: hipTextureAddressMode,
7053 ) -> hipError_t;
7054}
7055extern "C" {
7056 #[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"]
7057 pub fn hipTexRefSetArray(
7058 tex: *mut textureReference,
7059 array: hipArray_const_t,
7060 flags: ::std::os::raw::c_uint,
7061 ) -> hipError_t;
7062}
7063extern "C" {
7064 #[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"]
7065 pub fn hipTexRefSetFilterMode(
7066 texRef: *mut textureReference,
7067 fm: hipTextureFilterMode,
7068 ) -> hipError_t;
7069}
7070extern "C" {
7071 #[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"]
7072 pub fn hipTexRefSetFlags(
7073 texRef: *mut textureReference,
7074 Flags: ::std::os::raw::c_uint,
7075 ) -> hipError_t;
7076}
7077extern "C" {
7078 #[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"]
7079 pub fn hipTexRefSetFormat(
7080 texRef: *mut textureReference,
7081 fmt: hipArray_Format,
7082 NumPackedComponents: ::std::os::raw::c_int,
7083 ) -> hipError_t;
7084}
7085extern "C" {
7086 #[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"]
7087 pub fn hipBindTexture(
7088 offset: *mut usize,
7089 tex: *const textureReference,
7090 devPtr: *const ::std::os::raw::c_void,
7091 desc: *const hipChannelFormatDesc,
7092 size: usize,
7093 ) -> hipError_t;
7094}
7095extern "C" {
7096 #[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"]
7097 pub fn hipBindTexture2D(
7098 offset: *mut usize,
7099 tex: *const textureReference,
7100 devPtr: *const ::std::os::raw::c_void,
7101 desc: *const hipChannelFormatDesc,
7102 width: usize,
7103 height: usize,
7104 pitch: usize,
7105 ) -> hipError_t;
7106}
7107extern "C" {
7108 #[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"]
7109 pub fn hipBindTextureToArray(
7110 tex: *const textureReference,
7111 array: hipArray_const_t,
7112 desc: *const hipChannelFormatDesc,
7113 ) -> hipError_t;
7114}
7115extern "C" {
7116 #[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"]
7117 pub fn hipGetTextureAlignmentOffset(
7118 offset: *mut usize,
7119 texref: *const textureReference,
7120 ) -> hipError_t;
7121}
7122extern "C" {
7123 #[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"]
7124 pub fn hipUnbindTexture(tex: *const textureReference) -> hipError_t;
7125}
7126extern "C" {
7127 #[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"]
7128 pub fn hipTexRefGetAddress(
7129 dev_ptr: *mut hipDeviceptr_t,
7130 texRef: *const textureReference,
7131 ) -> hipError_t;
7132}
7133extern "C" {
7134 #[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"]
7135 pub fn hipTexRefGetAddressMode(
7136 pam: *mut hipTextureAddressMode,
7137 texRef: *const textureReference,
7138 dim: ::std::os::raw::c_int,
7139 ) -> hipError_t;
7140}
7141extern "C" {
7142 #[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"]
7143 pub fn hipTexRefGetFilterMode(
7144 pfm: *mut hipTextureFilterMode,
7145 texRef: *const textureReference,
7146 ) -> hipError_t;
7147}
7148extern "C" {
7149 #[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"]
7150 pub fn hipTexRefGetFlags(
7151 pFlags: *mut ::std::os::raw::c_uint,
7152 texRef: *const textureReference,
7153 ) -> hipError_t;
7154}
7155extern "C" {
7156 #[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"]
7157 pub fn hipTexRefGetFormat(
7158 pFormat: *mut hipArray_Format,
7159 pNumChannels: *mut ::std::os::raw::c_int,
7160 texRef: *const textureReference,
7161 ) -> hipError_t;
7162}
7163extern "C" {
7164 #[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"]
7165 pub fn hipTexRefGetMaxAnisotropy(
7166 pmaxAnsio: *mut ::std::os::raw::c_int,
7167 texRef: *const textureReference,
7168 ) -> hipError_t;
7169}
7170extern "C" {
7171 #[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"]
7172 pub fn hipTexRefGetMipmapFilterMode(
7173 pfm: *mut hipTextureFilterMode,
7174 texRef: *const textureReference,
7175 ) -> hipError_t;
7176}
7177extern "C" {
7178 #[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"]
7179 pub fn hipTexRefGetMipmapLevelBias(
7180 pbias: *mut f32,
7181 texRef: *const textureReference,
7182 ) -> hipError_t;
7183}
7184extern "C" {
7185 #[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"]
7186 pub fn hipTexRefGetMipmapLevelClamp(
7187 pminMipmapLevelClamp: *mut f32,
7188 pmaxMipmapLevelClamp: *mut f32,
7189 texRef: *const textureReference,
7190 ) -> hipError_t;
7191}
7192extern "C" {
7193 #[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"]
7194 pub fn hipTexRefGetMipMappedArray(
7195 pArray: *mut hipMipmappedArray_t,
7196 texRef: *const textureReference,
7197 ) -> hipError_t;
7198}
7199extern "C" {
7200 #[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"]
7201 pub fn hipTexRefSetAddress(
7202 ByteOffset: *mut usize,
7203 texRef: *mut textureReference,
7204 dptr: hipDeviceptr_t,
7205 bytes: usize,
7206 ) -> hipError_t;
7207}
7208extern "C" {
7209 #[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"]
7210 pub fn hipTexRefSetAddress2D(
7211 texRef: *mut textureReference,
7212 desc: *const HIP_ARRAY_DESCRIPTOR,
7213 dptr: hipDeviceptr_t,
7214 Pitch: usize,
7215 ) -> hipError_t;
7216}
7217extern "C" {
7218 #[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"]
7219 pub fn hipTexRefSetMaxAnisotropy(
7220 texRef: *mut textureReference,
7221 maxAniso: ::std::os::raw::c_uint,
7222 ) -> hipError_t;
7223}
7224extern "C" {
7225 #[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"]
7226 pub fn hipTexRefSetBorderColor(
7227 texRef: *mut textureReference,
7228 pBorderColor: *mut f32,
7229 ) -> hipError_t;
7230}
7231extern "C" {
7232 #[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"]
7233 pub fn hipTexRefSetMipmapFilterMode(
7234 texRef: *mut textureReference,
7235 fm: hipTextureFilterMode,
7236 ) -> hipError_t;
7237}
7238extern "C" {
7239 #[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"]
7240 pub fn hipTexRefSetMipmapLevelBias(texRef: *mut textureReference, bias: f32) -> hipError_t;
7241}
7242extern "C" {
7243 #[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"]
7244 pub fn hipTexRefSetMipmapLevelClamp(
7245 texRef: *mut textureReference,
7246 minMipMapLevelClamp: f32,
7247 maxMipMapLevelClamp: f32,
7248 ) -> hipError_t;
7249}
7250extern "C" {
7251 #[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"]
7252 pub fn hipTexRefSetMipmappedArray(
7253 texRef: *mut textureReference,
7254 mipmappedArray: *mut hipMipmappedArray,
7255 Flags: ::std::os::raw::c_uint,
7256 ) -> hipError_t;
7257}
7258extern "C" {
7259 #[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"]
7260 pub fn hipApiName(id: u32) -> *const ::std::os::raw::c_char;
7261}
7262extern "C" {
7263 #[doc = " @brief Returns kernel name reference by function name.\n\n @param [in] f Name of function\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
7264 pub fn hipKernelNameRef(f: hipFunction_t) -> *const ::std::os::raw::c_char;
7265}
7266extern "C" {
7267 #[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"]
7268 pub fn hipKernelNameRefByPtr(
7269 hostFunction: *const ::std::os::raw::c_void,
7270 stream: hipStream_t,
7271 ) -> *const ::std::os::raw::c_char;
7272}
7273extern "C" {
7274 #[doc = " @brief Returns device ID on the stream.\n\n @param [in] stream Stream of device executed on.\n\n @returns #hipSuccess, #hipErrorInvalidValue\n"]
7275 pub fn hipGetStreamDeviceId(stream: hipStream_t) -> ::std::os::raw::c_int;
7276}
7277extern "C" {
7278 #[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"]
7279 pub fn hipStreamBeginCapture(stream: hipStream_t, mode: hipStreamCaptureMode) -> hipError_t;
7280}
7281extern "C" {
7282 #[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."]
7283 pub fn hipStreamBeginCaptureToGraph(
7284 stream: hipStream_t,
7285 graph: hipGraph_t,
7286 dependencies: *const hipGraphNode_t,
7287 dependencyData: *const hipGraphEdgeData,
7288 numDependencies: usize,
7289 mode: hipStreamCaptureMode,
7290 ) -> hipError_t;
7291}
7292extern "C" {
7293 #[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"]
7294 pub fn hipStreamEndCapture(stream: hipStream_t, pGraph: *mut hipGraph_t) -> hipError_t;
7295}
7296extern "C" {
7297 #[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"]
7298 pub fn hipStreamGetCaptureInfo(
7299 stream: hipStream_t,
7300 pCaptureStatus: *mut hipStreamCaptureStatus,
7301 pId: *mut ::std::os::raw::c_ulonglong,
7302 ) -> hipError_t;
7303}
7304extern "C" {
7305 #[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"]
7306 pub fn hipStreamGetCaptureInfo_v2(
7307 stream: hipStream_t,
7308 captureStatus_out: *mut hipStreamCaptureStatus,
7309 id_out: *mut ::std::os::raw::c_ulonglong,
7310 graph_out: *mut hipGraph_t,
7311 dependencies_out: *mut *const hipGraphNode_t,
7312 numDependencies_out: *mut usize,
7313 ) -> hipError_t;
7314}
7315extern "C" {
7316 #[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"]
7317 pub fn hipStreamIsCapturing(
7318 stream: hipStream_t,
7319 pCaptureStatus: *mut hipStreamCaptureStatus,
7320 ) -> hipError_t;
7321}
7322extern "C" {
7323 #[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"]
7324 pub fn hipStreamUpdateCaptureDependencies(
7325 stream: hipStream_t,
7326 dependencies: *mut hipGraphNode_t,
7327 numDependencies: usize,
7328 flags: ::std::os::raw::c_uint,
7329 ) -> hipError_t;
7330}
7331extern "C" {
7332 #[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"]
7333 pub fn hipThreadExchangeStreamCaptureMode(mode: *mut hipStreamCaptureMode) -> hipError_t;
7334}
7335extern "C" {
7336 #[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"]
7337 pub fn hipGraphCreate(pGraph: *mut hipGraph_t, flags: ::std::os::raw::c_uint) -> hipError_t;
7338}
7339extern "C" {
7340 #[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"]
7341 pub fn hipGraphDestroy(graph: hipGraph_t) -> hipError_t;
7342}
7343extern "C" {
7344 #[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"]
7345 pub fn hipGraphAddDependencies(
7346 graph: hipGraph_t,
7347 from: *const hipGraphNode_t,
7348 to: *const hipGraphNode_t,
7349 numDependencies: usize,
7350 ) -> hipError_t;
7351}
7352extern "C" {
7353 #[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"]
7354 pub fn hipGraphRemoveDependencies(
7355 graph: hipGraph_t,
7356 from: *const hipGraphNode_t,
7357 to: *const hipGraphNode_t,
7358 numDependencies: usize,
7359 ) -> hipError_t;
7360}
7361extern "C" {
7362 #[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"]
7363 pub fn hipGraphGetEdges(
7364 graph: hipGraph_t,
7365 from: *mut hipGraphNode_t,
7366 to: *mut hipGraphNode_t,
7367 numEdges: *mut usize,
7368 ) -> hipError_t;
7369}
7370extern "C" {
7371 #[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"]
7372 pub fn hipGraphGetNodes(
7373 graph: hipGraph_t,
7374 nodes: *mut hipGraphNode_t,
7375 numNodes: *mut usize,
7376 ) -> hipError_t;
7377}
7378extern "C" {
7379 #[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"]
7380 pub fn hipGraphGetRootNodes(
7381 graph: hipGraph_t,
7382 pRootNodes: *mut hipGraphNode_t,
7383 pNumRootNodes: *mut usize,
7384 ) -> hipError_t;
7385}
7386extern "C" {
7387 #[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"]
7388 pub fn hipGraphNodeGetDependencies(
7389 node: hipGraphNode_t,
7390 pDependencies: *mut hipGraphNode_t,
7391 pNumDependencies: *mut usize,
7392 ) -> hipError_t;
7393}
7394extern "C" {
7395 #[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"]
7396 pub fn hipGraphNodeGetDependentNodes(
7397 node: hipGraphNode_t,
7398 pDependentNodes: *mut hipGraphNode_t,
7399 pNumDependentNodes: *mut usize,
7400 ) -> hipError_t;
7401}
7402extern "C" {
7403 #[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"]
7404 pub fn hipGraphNodeGetType(node: hipGraphNode_t, pType: *mut hipGraphNodeType) -> hipError_t;
7405}
7406extern "C" {
7407 #[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"]
7408 pub fn hipGraphDestroyNode(node: hipGraphNode_t) -> hipError_t;
7409}
7410extern "C" {
7411 #[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"]
7412 pub fn hipGraphClone(pGraphClone: *mut hipGraph_t, originalGraph: hipGraph_t) -> hipError_t;
7413}
7414extern "C" {
7415 #[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"]
7416 pub fn hipGraphNodeFindInClone(
7417 pNode: *mut hipGraphNode_t,
7418 originalNode: hipGraphNode_t,
7419 clonedGraph: hipGraph_t,
7420 ) -> hipError_t;
7421}
7422extern "C" {
7423 #[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"]
7424 pub fn hipGraphInstantiate(
7425 pGraphExec: *mut hipGraphExec_t,
7426 graph: hipGraph_t,
7427 pErrorNode: *mut hipGraphNode_t,
7428 pLogBuffer: *mut ::std::os::raw::c_char,
7429 bufferSize: usize,
7430 ) -> hipError_t;
7431}
7432extern "C" {
7433 #[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."]
7434 pub fn hipGraphInstantiateWithFlags(
7435 pGraphExec: *mut hipGraphExec_t,
7436 graph: hipGraph_t,
7437 flags: ::std::os::raw::c_ulonglong,
7438 ) -> hipError_t;
7439}
7440extern "C" {
7441 #[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."]
7442 pub fn hipGraphInstantiateWithParams(
7443 pGraphExec: *mut hipGraphExec_t,
7444 graph: hipGraph_t,
7445 instantiateParams: *mut hipGraphInstantiateParams,
7446 ) -> hipError_t;
7447}
7448extern "C" {
7449 #[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."]
7450 pub fn hipGraphLaunch(graphExec: hipGraphExec_t, stream: hipStream_t) -> hipError_t;
7451}
7452extern "C" {
7453 #[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."]
7454 pub fn hipGraphUpload(graphExec: hipGraphExec_t, stream: hipStream_t) -> hipError_t;
7455}
7456extern "C" {
7457 #[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."]
7458 pub fn hipGraphAddNode(
7459 pGraphNode: *mut hipGraphNode_t,
7460 graph: hipGraph_t,
7461 pDependencies: *const hipGraphNode_t,
7462 numDependencies: usize,
7463 nodeParams: *mut hipGraphNodeParams,
7464 ) -> hipError_t;
7465}
7466extern "C" {
7467 #[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."]
7468 pub fn hipGraphExecGetFlags(
7469 graphExec: hipGraphExec_t,
7470 flags: *mut ::std::os::raw::c_ulonglong,
7471 ) -> hipError_t;
7472}
7473extern "C" {
7474 #[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."]
7475 pub fn hipGraphNodeSetParams(
7476 node: hipGraphNode_t,
7477 nodeParams: *mut hipGraphNodeParams,
7478 ) -> hipError_t;
7479}
7480extern "C" {
7481 #[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."]
7482 pub fn hipGraphExecNodeSetParams(
7483 graphExec: hipGraphExec_t,
7484 node: hipGraphNode_t,
7485 nodeParams: *mut hipGraphNodeParams,
7486 ) -> hipError_t;
7487}
7488extern "C" {
7489 #[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."]
7490 pub fn hipGraphExecDestroy(graphExec: hipGraphExec_t) -> hipError_t;
7491}
7492extern "C" {
7493 #[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."]
7494 pub fn hipGraphExecUpdate(
7495 hGraphExec: hipGraphExec_t,
7496 hGraph: hipGraph_t,
7497 hErrorNode_out: *mut hipGraphNode_t,
7498 updateResult_out: *mut hipGraphExecUpdateResult,
7499 ) -> hipError_t;
7500}
7501extern "C" {
7502 #[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."]
7503 pub fn hipGraphAddKernelNode(
7504 pGraphNode: *mut hipGraphNode_t,
7505 graph: hipGraph_t,
7506 pDependencies: *const hipGraphNode_t,
7507 numDependencies: usize,
7508 pNodeParams: *const hipKernelNodeParams,
7509 ) -> hipError_t;
7510}
7511extern "C" {
7512 #[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."]
7513 pub fn hipGraphKernelNodeGetParams(
7514 node: hipGraphNode_t,
7515 pNodeParams: *mut hipKernelNodeParams,
7516 ) -> hipError_t;
7517}
7518extern "C" {
7519 #[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."]
7520 pub fn hipGraphKernelNodeSetParams(
7521 node: hipGraphNode_t,
7522 pNodeParams: *const hipKernelNodeParams,
7523 ) -> hipError_t;
7524}
7525extern "C" {
7526 #[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."]
7527 pub fn hipGraphExecKernelNodeSetParams(
7528 hGraphExec: hipGraphExec_t,
7529 node: hipGraphNode_t,
7530 pNodeParams: *const hipKernelNodeParams,
7531 ) -> hipError_t;
7532}
7533extern "C" {
7534 #[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."]
7535 pub fn hipDrvGraphAddMemcpyNode(
7536 phGraphNode: *mut hipGraphNode_t,
7537 hGraph: hipGraph_t,
7538 dependencies: *const hipGraphNode_t,
7539 numDependencies: usize,
7540 copyParams: *const HIP_MEMCPY3D,
7541 ctx: hipCtx_t,
7542 ) -> hipError_t;
7543}
7544extern "C" {
7545 #[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."]
7546 pub fn hipGraphAddMemcpyNode(
7547 pGraphNode: *mut hipGraphNode_t,
7548 graph: hipGraph_t,
7549 pDependencies: *const hipGraphNode_t,
7550 numDependencies: usize,
7551 pCopyParams: *const hipMemcpy3DParms,
7552 ) -> hipError_t;
7553}
7554extern "C" {
7555 #[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."]
7556 pub fn hipGraphMemcpyNodeGetParams(
7557 node: hipGraphNode_t,
7558 pNodeParams: *mut hipMemcpy3DParms,
7559 ) -> hipError_t;
7560}
7561extern "C" {
7562 #[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."]
7563 pub fn hipGraphMemcpyNodeSetParams(
7564 node: hipGraphNode_t,
7565 pNodeParams: *const hipMemcpy3DParms,
7566 ) -> hipError_t;
7567}
7568extern "C" {
7569 #[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."]
7570 pub fn hipGraphKernelNodeSetAttribute(
7571 hNode: hipGraphNode_t,
7572 attr: hipLaunchAttributeID,
7573 value: *const hipLaunchAttributeValue,
7574 ) -> hipError_t;
7575}
7576extern "C" {
7577 #[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."]
7578 pub fn hipGraphKernelNodeGetAttribute(
7579 hNode: hipGraphNode_t,
7580 attr: hipLaunchAttributeID,
7581 value: *mut hipLaunchAttributeValue,
7582 ) -> hipError_t;
7583}
7584extern "C" {
7585 #[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."]
7586 pub fn hipGraphExecMemcpyNodeSetParams(
7587 hGraphExec: hipGraphExec_t,
7588 node: hipGraphNode_t,
7589 pNodeParams: *mut hipMemcpy3DParms,
7590 ) -> hipError_t;
7591}
7592extern "C" {
7593 #[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."]
7594 pub fn hipGraphAddMemcpyNode1D(
7595 pGraphNode: *mut hipGraphNode_t,
7596 graph: hipGraph_t,
7597 pDependencies: *const hipGraphNode_t,
7598 numDependencies: usize,
7599 dst: *mut ::std::os::raw::c_void,
7600 src: *const ::std::os::raw::c_void,
7601 count: usize,
7602 kind: hipMemcpyKind,
7603 ) -> hipError_t;
7604}
7605extern "C" {
7606 #[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."]
7607 pub fn hipGraphMemcpyNodeSetParams1D(
7608 node: hipGraphNode_t,
7609 dst: *mut ::std::os::raw::c_void,
7610 src: *const ::std::os::raw::c_void,
7611 count: usize,
7612 kind: hipMemcpyKind,
7613 ) -> hipError_t;
7614}
7615extern "C" {
7616 #[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."]
7617 pub fn hipGraphExecMemcpyNodeSetParams1D(
7618 hGraphExec: hipGraphExec_t,
7619 node: hipGraphNode_t,
7620 dst: *mut ::std::os::raw::c_void,
7621 src: *const ::std::os::raw::c_void,
7622 count: usize,
7623 kind: hipMemcpyKind,
7624 ) -> hipError_t;
7625}
7626extern "C" {
7627 #[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."]
7628 pub fn hipGraphAddMemcpyNodeFromSymbol(
7629 pGraphNode: *mut hipGraphNode_t,
7630 graph: hipGraph_t,
7631 pDependencies: *const hipGraphNode_t,
7632 numDependencies: usize,
7633 dst: *mut ::std::os::raw::c_void,
7634 symbol: *const ::std::os::raw::c_void,
7635 count: usize,
7636 offset: usize,
7637 kind: hipMemcpyKind,
7638 ) -> hipError_t;
7639}
7640extern "C" {
7641 #[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."]
7642 pub fn hipGraphMemcpyNodeSetParamsFromSymbol(
7643 node: hipGraphNode_t,
7644 dst: *mut ::std::os::raw::c_void,
7645 symbol: *const ::std::os::raw::c_void,
7646 count: usize,
7647 offset: usize,
7648 kind: hipMemcpyKind,
7649 ) -> hipError_t;
7650}
7651extern "C" {
7652 #[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."]
7653 pub fn hipGraphExecMemcpyNodeSetParamsFromSymbol(
7654 hGraphExec: hipGraphExec_t,
7655 node: hipGraphNode_t,
7656 dst: *mut ::std::os::raw::c_void,
7657 symbol: *const ::std::os::raw::c_void,
7658 count: usize,
7659 offset: usize,
7660 kind: hipMemcpyKind,
7661 ) -> hipError_t;
7662}
7663extern "C" {
7664 #[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."]
7665 pub fn hipGraphAddMemcpyNodeToSymbol(
7666 pGraphNode: *mut hipGraphNode_t,
7667 graph: hipGraph_t,
7668 pDependencies: *const hipGraphNode_t,
7669 numDependencies: usize,
7670 symbol: *const ::std::os::raw::c_void,
7671 src: *const ::std::os::raw::c_void,
7672 count: usize,
7673 offset: usize,
7674 kind: hipMemcpyKind,
7675 ) -> hipError_t;
7676}
7677extern "C" {
7678 #[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."]
7679 pub fn hipGraphMemcpyNodeSetParamsToSymbol(
7680 node: hipGraphNode_t,
7681 symbol: *const ::std::os::raw::c_void,
7682 src: *const ::std::os::raw::c_void,
7683 count: usize,
7684 offset: usize,
7685 kind: hipMemcpyKind,
7686 ) -> hipError_t;
7687}
7688extern "C" {
7689 #[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."]
7690 pub fn hipGraphExecMemcpyNodeSetParamsToSymbol(
7691 hGraphExec: hipGraphExec_t,
7692 node: hipGraphNode_t,
7693 symbol: *const ::std::os::raw::c_void,
7694 src: *const ::std::os::raw::c_void,
7695 count: usize,
7696 offset: usize,
7697 kind: hipMemcpyKind,
7698 ) -> hipError_t;
7699}
7700extern "C" {
7701 #[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."]
7702 pub fn hipGraphAddMemsetNode(
7703 pGraphNode: *mut hipGraphNode_t,
7704 graph: hipGraph_t,
7705 pDependencies: *const hipGraphNode_t,
7706 numDependencies: usize,
7707 pMemsetParams: *const hipMemsetParams,
7708 ) -> hipError_t;
7709}
7710extern "C" {
7711 #[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."]
7712 pub fn hipGraphMemsetNodeGetParams(
7713 node: hipGraphNode_t,
7714 pNodeParams: *mut hipMemsetParams,
7715 ) -> hipError_t;
7716}
7717extern "C" {
7718 #[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."]
7719 pub fn hipGraphMemsetNodeSetParams(
7720 node: hipGraphNode_t,
7721 pNodeParams: *const hipMemsetParams,
7722 ) -> hipError_t;
7723}
7724extern "C" {
7725 #[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."]
7726 pub fn hipGraphExecMemsetNodeSetParams(
7727 hGraphExec: hipGraphExec_t,
7728 node: hipGraphNode_t,
7729 pNodeParams: *const hipMemsetParams,
7730 ) -> hipError_t;
7731}
7732extern "C" {
7733 #[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."]
7734 pub fn hipGraphAddHostNode(
7735 pGraphNode: *mut hipGraphNode_t,
7736 graph: hipGraph_t,
7737 pDependencies: *const hipGraphNode_t,
7738 numDependencies: usize,
7739 pNodeParams: *const hipHostNodeParams,
7740 ) -> hipError_t;
7741}
7742extern "C" {
7743 #[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."]
7744 pub fn hipGraphHostNodeGetParams(
7745 node: hipGraphNode_t,
7746 pNodeParams: *mut hipHostNodeParams,
7747 ) -> hipError_t;
7748}
7749extern "C" {
7750 #[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."]
7751 pub fn hipGraphHostNodeSetParams(
7752 node: hipGraphNode_t,
7753 pNodeParams: *const hipHostNodeParams,
7754 ) -> hipError_t;
7755}
7756extern "C" {
7757 #[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."]
7758 pub fn hipGraphExecHostNodeSetParams(
7759 hGraphExec: hipGraphExec_t,
7760 node: hipGraphNode_t,
7761 pNodeParams: *const hipHostNodeParams,
7762 ) -> hipError_t;
7763}
7764extern "C" {
7765 #[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."]
7766 pub fn hipGraphAddChildGraphNode(
7767 pGraphNode: *mut hipGraphNode_t,
7768 graph: hipGraph_t,
7769 pDependencies: *const hipGraphNode_t,
7770 numDependencies: usize,
7771 childGraph: hipGraph_t,
7772 ) -> hipError_t;
7773}
7774extern "C" {
7775 #[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."]
7776 pub fn hipGraphChildGraphNodeGetGraph(
7777 node: hipGraphNode_t,
7778 pGraph: *mut hipGraph_t,
7779 ) -> hipError_t;
7780}
7781extern "C" {
7782 #[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."]
7783 pub fn hipGraphExecChildGraphNodeSetParams(
7784 hGraphExec: hipGraphExec_t,
7785 node: hipGraphNode_t,
7786 childGraph: hipGraph_t,
7787 ) -> hipError_t;
7788}
7789extern "C" {
7790 #[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."]
7791 pub fn hipGraphAddEmptyNode(
7792 pGraphNode: *mut hipGraphNode_t,
7793 graph: hipGraph_t,
7794 pDependencies: *const hipGraphNode_t,
7795 numDependencies: usize,
7796 ) -> hipError_t;
7797}
7798extern "C" {
7799 #[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."]
7800 pub fn hipGraphAddEventRecordNode(
7801 pGraphNode: *mut hipGraphNode_t,
7802 graph: hipGraph_t,
7803 pDependencies: *const hipGraphNode_t,
7804 numDependencies: usize,
7805 event: hipEvent_t,
7806 ) -> hipError_t;
7807}
7808extern "C" {
7809 #[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."]
7810 pub fn hipGraphEventRecordNodeGetEvent(
7811 node: hipGraphNode_t,
7812 event_out: *mut hipEvent_t,
7813 ) -> hipError_t;
7814}
7815extern "C" {
7816 #[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."]
7817 pub fn hipGraphEventRecordNodeSetEvent(node: hipGraphNode_t, event: hipEvent_t) -> hipError_t;
7818}
7819extern "C" {
7820 #[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."]
7821 pub fn hipGraphExecEventRecordNodeSetEvent(
7822 hGraphExec: hipGraphExec_t,
7823 hNode: hipGraphNode_t,
7824 event: hipEvent_t,
7825 ) -> hipError_t;
7826}
7827extern "C" {
7828 #[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."]
7829 pub fn hipGraphAddEventWaitNode(
7830 pGraphNode: *mut hipGraphNode_t,
7831 graph: hipGraph_t,
7832 pDependencies: *const hipGraphNode_t,
7833 numDependencies: usize,
7834 event: hipEvent_t,
7835 ) -> hipError_t;
7836}
7837extern "C" {
7838 #[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."]
7839 pub fn hipGraphEventWaitNodeGetEvent(
7840 node: hipGraphNode_t,
7841 event_out: *mut hipEvent_t,
7842 ) -> hipError_t;
7843}
7844extern "C" {
7845 #[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."]
7846 pub fn hipGraphEventWaitNodeSetEvent(node: hipGraphNode_t, event: hipEvent_t) -> hipError_t;
7847}
7848extern "C" {
7849 #[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."]
7850 pub fn hipGraphExecEventWaitNodeSetEvent(
7851 hGraphExec: hipGraphExec_t,
7852 hNode: hipGraphNode_t,
7853 event: hipEvent_t,
7854 ) -> hipError_t;
7855}
7856extern "C" {
7857 #[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."]
7858 pub fn hipGraphAddMemAllocNode(
7859 pGraphNode: *mut hipGraphNode_t,
7860 graph: hipGraph_t,
7861 pDependencies: *const hipGraphNode_t,
7862 numDependencies: usize,
7863 pNodeParams: *mut hipMemAllocNodeParams,
7864 ) -> hipError_t;
7865}
7866extern "C" {
7867 #[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."]
7868 pub fn hipGraphMemAllocNodeGetParams(
7869 node: hipGraphNode_t,
7870 pNodeParams: *mut hipMemAllocNodeParams,
7871 ) -> hipError_t;
7872}
7873extern "C" {
7874 #[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."]
7875 pub fn hipGraphAddMemFreeNode(
7876 pGraphNode: *mut hipGraphNode_t,
7877 graph: hipGraph_t,
7878 pDependencies: *const hipGraphNode_t,
7879 numDependencies: usize,
7880 dev_ptr: *mut ::std::os::raw::c_void,
7881 ) -> hipError_t;
7882}
7883extern "C" {
7884 #[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."]
7885 pub fn hipGraphMemFreeNodeGetParams(
7886 node: hipGraphNode_t,
7887 dev_ptr: *mut ::std::os::raw::c_void,
7888 ) -> hipError_t;
7889}
7890extern "C" {
7891 #[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."]
7892 pub fn hipDeviceGetGraphMemAttribute(
7893 device: ::std::os::raw::c_int,
7894 attr: hipGraphMemAttributeType,
7895 value: *mut ::std::os::raw::c_void,
7896 ) -> hipError_t;
7897}
7898extern "C" {
7899 #[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."]
7900 pub fn hipDeviceSetGraphMemAttribute(
7901 device: ::std::os::raw::c_int,
7902 attr: hipGraphMemAttributeType,
7903 value: *mut ::std::os::raw::c_void,
7904 ) -> hipError_t;
7905}
7906extern "C" {
7907 #[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."]
7908 pub fn hipDeviceGraphMemTrim(device: ::std::os::raw::c_int) -> hipError_t;
7909}
7910extern "C" {
7911 #[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."]
7912 pub fn hipUserObjectCreate(
7913 object_out: *mut hipUserObject_t,
7914 ptr: *mut ::std::os::raw::c_void,
7915 destroy: hipHostFn_t,
7916 initialRefcount: ::std::os::raw::c_uint,
7917 flags: ::std::os::raw::c_uint,
7918 ) -> hipError_t;
7919}
7920extern "C" {
7921 #[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."]
7922 pub fn hipUserObjectRelease(
7923 object: hipUserObject_t,
7924 count: ::std::os::raw::c_uint,
7925 ) -> hipError_t;
7926}
7927extern "C" {
7928 #[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."]
7929 pub fn hipUserObjectRetain(
7930 object: hipUserObject_t,
7931 count: ::std::os::raw::c_uint,
7932 ) -> hipError_t;
7933}
7934extern "C" {
7935 #[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."]
7936 pub fn hipGraphRetainUserObject(
7937 graph: hipGraph_t,
7938 object: hipUserObject_t,
7939 count: ::std::os::raw::c_uint,
7940 flags: ::std::os::raw::c_uint,
7941 ) -> hipError_t;
7942}
7943extern "C" {
7944 #[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."]
7945 pub fn hipGraphReleaseUserObject(
7946 graph: hipGraph_t,
7947 object: hipUserObject_t,
7948 count: ::std::os::raw::c_uint,
7949 ) -> hipError_t;
7950}
7951extern "C" {
7952 #[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."]
7953 pub fn hipGraphDebugDotPrint(
7954 graph: hipGraph_t,
7955 path: *const ::std::os::raw::c_char,
7956 flags: ::std::os::raw::c_uint,
7957 ) -> hipError_t;
7958}
7959extern "C" {
7960 #[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."]
7961 pub fn hipGraphKernelNodeCopyAttributes(
7962 hSrc: hipGraphNode_t,
7963 hDst: hipGraphNode_t,
7964 ) -> hipError_t;
7965}
7966extern "C" {
7967 #[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."]
7968 pub fn hipGraphNodeSetEnabled(
7969 hGraphExec: hipGraphExec_t,
7970 hNode: hipGraphNode_t,
7971 isEnabled: ::std::os::raw::c_uint,
7972 ) -> hipError_t;
7973}
7974extern "C" {
7975 #[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."]
7976 pub fn hipGraphNodeGetEnabled(
7977 hGraphExec: hipGraphExec_t,
7978 hNode: hipGraphNode_t,
7979 isEnabled: *mut ::std::os::raw::c_uint,
7980 ) -> hipError_t;
7981}
7982extern "C" {
7983 #[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."]
7984 pub fn hipGraphAddExternalSemaphoresWaitNode(
7985 pGraphNode: *mut hipGraphNode_t,
7986 graph: hipGraph_t,
7987 pDependencies: *const hipGraphNode_t,
7988 numDependencies: usize,
7989 nodeParams: *const hipExternalSemaphoreWaitNodeParams,
7990 ) -> hipError_t;
7991}
7992extern "C" {
7993 #[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."]
7994 pub fn hipGraphAddExternalSemaphoresSignalNode(
7995 pGraphNode: *mut hipGraphNode_t,
7996 graph: hipGraph_t,
7997 pDependencies: *const hipGraphNode_t,
7998 numDependencies: usize,
7999 nodeParams: *const hipExternalSemaphoreSignalNodeParams,
8000 ) -> hipError_t;
8001}
8002extern "C" {
8003 #[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."]
8004 pub fn hipGraphExternalSemaphoresSignalNodeSetParams(
8005 hNode: hipGraphNode_t,
8006 nodeParams: *const hipExternalSemaphoreSignalNodeParams,
8007 ) -> hipError_t;
8008}
8009extern "C" {
8010 #[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."]
8011 pub fn hipGraphExternalSemaphoresWaitNodeSetParams(
8012 hNode: hipGraphNode_t,
8013 nodeParams: *const hipExternalSemaphoreWaitNodeParams,
8014 ) -> hipError_t;
8015}
8016extern "C" {
8017 #[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."]
8018 pub fn hipGraphExternalSemaphoresSignalNodeGetParams(
8019 hNode: hipGraphNode_t,
8020 params_out: *mut hipExternalSemaphoreSignalNodeParams,
8021 ) -> hipError_t;
8022}
8023extern "C" {
8024 #[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."]
8025 pub fn hipGraphExternalSemaphoresWaitNodeGetParams(
8026 hNode: hipGraphNode_t,
8027 params_out: *mut hipExternalSemaphoreWaitNodeParams,
8028 ) -> hipError_t;
8029}
8030extern "C" {
8031 #[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."]
8032 pub fn hipGraphExecExternalSemaphoresSignalNodeSetParams(
8033 hGraphExec: hipGraphExec_t,
8034 hNode: hipGraphNode_t,
8035 nodeParams: *const hipExternalSemaphoreSignalNodeParams,
8036 ) -> hipError_t;
8037}
8038extern "C" {
8039 #[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."]
8040 pub fn hipGraphExecExternalSemaphoresWaitNodeSetParams(
8041 hGraphExec: hipGraphExec_t,
8042 hNode: hipGraphNode_t,
8043 nodeParams: *const hipExternalSemaphoreWaitNodeParams,
8044 ) -> hipError_t;
8045}
8046extern "C" {
8047 #[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."]
8048 pub fn hipDrvGraphMemcpyNodeGetParams(
8049 hNode: hipGraphNode_t,
8050 nodeParams: *mut HIP_MEMCPY3D,
8051 ) -> hipError_t;
8052}
8053extern "C" {
8054 #[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."]
8055 pub fn hipDrvGraphMemcpyNodeSetParams(
8056 hNode: hipGraphNode_t,
8057 nodeParams: *const HIP_MEMCPY3D,
8058 ) -> hipError_t;
8059}
8060extern "C" {
8061 #[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."]
8062 pub fn hipDrvGraphAddMemsetNode(
8063 phGraphNode: *mut hipGraphNode_t,
8064 hGraph: hipGraph_t,
8065 dependencies: *const hipGraphNode_t,
8066 numDependencies: usize,
8067 memsetParams: *const HIP_MEMSET_NODE_PARAMS,
8068 ctx: hipCtx_t,
8069 ) -> hipError_t;
8070}
8071extern "C" {
8072 #[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."]
8073 pub fn hipDrvGraphAddMemFreeNode(
8074 phGraphNode: *mut hipGraphNode_t,
8075 hGraph: hipGraph_t,
8076 dependencies: *const hipGraphNode_t,
8077 numDependencies: usize,
8078 dptr: hipDeviceptr_t,
8079 ) -> hipError_t;
8080}
8081extern "C" {
8082 #[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."]
8083 pub fn hipDrvGraphExecMemcpyNodeSetParams(
8084 hGraphExec: hipGraphExec_t,
8085 hNode: hipGraphNode_t,
8086 copyParams: *const HIP_MEMCPY3D,
8087 ctx: hipCtx_t,
8088 ) -> hipError_t;
8089}
8090extern "C" {
8091 #[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."]
8092 pub fn hipDrvGraphExecMemsetNodeSetParams(
8093 hGraphExec: hipGraphExec_t,
8094 hNode: hipGraphNode_t,
8095 memsetParams: *const HIP_MEMSET_NODE_PARAMS,
8096 ctx: hipCtx_t,
8097 ) -> hipError_t;
8098}
8099extern "C" {
8100 #[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."]
8101 pub fn hipMemAddressFree(devPtr: *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
8102}
8103extern "C" {
8104 #[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."]
8105 pub fn hipMemAddressReserve(
8106 ptr: *mut *mut ::std::os::raw::c_void,
8107 size: usize,
8108 alignment: usize,
8109 addr: *mut ::std::os::raw::c_void,
8110 flags: ::std::os::raw::c_ulonglong,
8111 ) -> hipError_t;
8112}
8113extern "C" {
8114 #[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."]
8115 pub fn hipMemCreate(
8116 handle: *mut hipMemGenericAllocationHandle_t,
8117 size: usize,
8118 prop: *const hipMemAllocationProp,
8119 flags: ::std::os::raw::c_ulonglong,
8120 ) -> hipError_t;
8121}
8122extern "C" {
8123 #[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."]
8124 pub fn hipMemExportToShareableHandle(
8125 shareableHandle: *mut ::std::os::raw::c_void,
8126 handle: hipMemGenericAllocationHandle_t,
8127 handleType: hipMemAllocationHandleType,
8128 flags: ::std::os::raw::c_ulonglong,
8129 ) -> hipError_t;
8130}
8131extern "C" {
8132 #[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."]
8133 pub fn hipMemGetAccess(
8134 flags: *mut ::std::os::raw::c_ulonglong,
8135 location: *const hipMemLocation,
8136 ptr: *mut ::std::os::raw::c_void,
8137 ) -> hipError_t;
8138}
8139extern "C" {
8140 #[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"]
8141 pub fn hipMemGetAllocationGranularity(
8142 granularity: *mut usize,
8143 prop: *const hipMemAllocationProp,
8144 option: hipMemAllocationGranularity_flags,
8145 ) -> hipError_t;
8146}
8147extern "C" {
8148 #[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."]
8149 pub fn hipMemGetAllocationPropertiesFromHandle(
8150 prop: *mut hipMemAllocationProp,
8151 handle: hipMemGenericAllocationHandle_t,
8152 ) -> hipError_t;
8153}
8154extern "C" {
8155 #[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."]
8156 pub fn hipMemImportFromShareableHandle(
8157 handle: *mut hipMemGenericAllocationHandle_t,
8158 osHandle: *mut ::std::os::raw::c_void,
8159 shHandleType: hipMemAllocationHandleType,
8160 ) -> hipError_t;
8161}
8162extern "C" {
8163 #[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."]
8164 pub fn hipMemMap(
8165 ptr: *mut ::std::os::raw::c_void,
8166 size: usize,
8167 offset: usize,
8168 handle: hipMemGenericAllocationHandle_t,
8169 flags: ::std::os::raw::c_ulonglong,
8170 ) -> hipError_t;
8171}
8172extern "C" {
8173 #[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."]
8174 pub fn hipMemMapArrayAsync(
8175 mapInfoList: *mut hipArrayMapInfo,
8176 count: ::std::os::raw::c_uint,
8177 stream: hipStream_t,
8178 ) -> hipError_t;
8179}
8180extern "C" {
8181 #[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."]
8182 pub fn hipMemRelease(handle: hipMemGenericAllocationHandle_t) -> hipError_t;
8183}
8184extern "C" {
8185 #[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."]
8186 pub fn hipMemRetainAllocationHandle(
8187 handle: *mut hipMemGenericAllocationHandle_t,
8188 addr: *mut ::std::os::raw::c_void,
8189 ) -> hipError_t;
8190}
8191extern "C" {
8192 #[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."]
8193 pub fn hipMemSetAccess(
8194 ptr: *mut ::std::os::raw::c_void,
8195 size: usize,
8196 desc: *const hipMemAccessDesc,
8197 count: usize,
8198 ) -> hipError_t;
8199}
8200extern "C" {
8201 #[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."]
8202 pub fn hipMemUnmap(ptr: *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
8203}
8204extern "C" {
8205 #[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"]
8206 pub fn hipGraphicsMapResources(
8207 count: ::std::os::raw::c_int,
8208 resources: *mut hipGraphicsResource_t,
8209 stream: hipStream_t,
8210 ) -> hipError_t;
8211}
8212extern "C" {
8213 #[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"]
8214 pub fn hipGraphicsSubResourceGetMappedArray(
8215 array: *mut hipArray_t,
8216 resource: hipGraphicsResource_t,
8217 arrayIndex: ::std::os::raw::c_uint,
8218 mipLevel: ::std::os::raw::c_uint,
8219 ) -> hipError_t;
8220}
8221extern "C" {
8222 #[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"]
8223 pub fn hipGraphicsResourceGetMappedPointer(
8224 devPtr: *mut *mut ::std::os::raw::c_void,
8225 size: *mut usize,
8226 resource: hipGraphicsResource_t,
8227 ) -> hipError_t;
8228}
8229extern "C" {
8230 #[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"]
8231 pub fn hipGraphicsUnmapResources(
8232 count: ::std::os::raw::c_int,
8233 resources: *mut hipGraphicsResource_t,
8234 stream: hipStream_t,
8235 ) -> hipError_t;
8236}
8237extern "C" {
8238 #[doc = " @brief Unregisters a graphics resource.\n\n @param [in] resource - Graphics resources to unregister.\n\n @returns #hipSuccess\n"]
8239 pub fn hipGraphicsUnregisterResource(resource: hipGraphicsResource_t) -> hipError_t;
8240}
8241extern "C" {
8242 #[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"]
8243 pub fn hipCreateSurfaceObject(
8244 pSurfObject: *mut hipSurfaceObject_t,
8245 pResDesc: *const hipResourceDesc,
8246 ) -> hipError_t;
8247}
8248extern "C" {
8249 #[doc = " @brief Destroy a surface object.\n\n @param [in] surfaceObject Surface object to be destroyed.\n\n @returns #hipSuccess, #hipErrorInvalidValue"]
8250 pub fn hipDestroySurfaceObject(surfaceObject: hipSurfaceObject_t) -> hipError_t;
8251}
8252extern "C" {
8253 pub fn hipMemcpy_spt(
8254 dst: *mut ::std::os::raw::c_void,
8255 src: *const ::std::os::raw::c_void,
8256 sizeBytes: usize,
8257 kind: hipMemcpyKind,
8258 ) -> hipError_t;
8259}
8260extern "C" {
8261 pub fn hipMemcpyToSymbol_spt(
8262 symbol: *const ::std::os::raw::c_void,
8263 src: *const ::std::os::raw::c_void,
8264 sizeBytes: usize,
8265 offset: usize,
8266 kind: hipMemcpyKind,
8267 ) -> hipError_t;
8268}
8269extern "C" {
8270 pub fn hipMemcpyFromSymbol_spt(
8271 dst: *mut ::std::os::raw::c_void,
8272 symbol: *const ::std::os::raw::c_void,
8273 sizeBytes: usize,
8274 offset: usize,
8275 kind: hipMemcpyKind,
8276 ) -> hipError_t;
8277}
8278extern "C" {
8279 pub fn hipMemcpy2D_spt(
8280 dst: *mut ::std::os::raw::c_void,
8281 dpitch: usize,
8282 src: *const ::std::os::raw::c_void,
8283 spitch: usize,
8284 width: usize,
8285 height: usize,
8286 kind: hipMemcpyKind,
8287 ) -> hipError_t;
8288}
8289extern "C" {
8290 pub fn hipMemcpy2DFromArray_spt(
8291 dst: *mut ::std::os::raw::c_void,
8292 dpitch: usize,
8293 src: hipArray_const_t,
8294 wOffset: usize,
8295 hOffset: usize,
8296 width: usize,
8297 height: usize,
8298 kind: hipMemcpyKind,
8299 ) -> hipError_t;
8300}
8301extern "C" {
8302 pub fn hipMemcpy3D_spt(p: *const hipMemcpy3DParms) -> hipError_t;
8303}
8304extern "C" {
8305 pub fn hipMemset_spt(
8306 dst: *mut ::std::os::raw::c_void,
8307 value: ::std::os::raw::c_int,
8308 sizeBytes: usize,
8309 ) -> hipError_t;
8310}
8311extern "C" {
8312 pub fn hipMemsetAsync_spt(
8313 dst: *mut ::std::os::raw::c_void,
8314 value: ::std::os::raw::c_int,
8315 sizeBytes: usize,
8316 stream: hipStream_t,
8317 ) -> hipError_t;
8318}
8319extern "C" {
8320 pub fn hipMemset2D_spt(
8321 dst: *mut ::std::os::raw::c_void,
8322 pitch: usize,
8323 value: ::std::os::raw::c_int,
8324 width: usize,
8325 height: usize,
8326 ) -> hipError_t;
8327}
8328extern "C" {
8329 pub fn hipMemset2DAsync_spt(
8330 dst: *mut ::std::os::raw::c_void,
8331 pitch: usize,
8332 value: ::std::os::raw::c_int,
8333 width: usize,
8334 height: usize,
8335 stream: hipStream_t,
8336 ) -> hipError_t;
8337}
8338extern "C" {
8339 pub fn hipMemset3DAsync_spt(
8340 pitchedDevPtr: hipPitchedPtr,
8341 value: ::std::os::raw::c_int,
8342 extent: hipExtent,
8343 stream: hipStream_t,
8344 ) -> hipError_t;
8345}
8346extern "C" {
8347 pub fn hipMemset3D_spt(
8348 pitchedDevPtr: hipPitchedPtr,
8349 value: ::std::os::raw::c_int,
8350 extent: hipExtent,
8351 ) -> hipError_t;
8352}
8353extern "C" {
8354 pub fn hipMemcpyAsync_spt(
8355 dst: *mut ::std::os::raw::c_void,
8356 src: *const ::std::os::raw::c_void,
8357 sizeBytes: usize,
8358 kind: hipMemcpyKind,
8359 stream: hipStream_t,
8360 ) -> hipError_t;
8361}
8362extern "C" {
8363 pub fn hipMemcpy3DAsync_spt(p: *const hipMemcpy3DParms, stream: hipStream_t) -> hipError_t;
8364}
8365extern "C" {
8366 pub fn hipMemcpy2DAsync_spt(
8367 dst: *mut ::std::os::raw::c_void,
8368 dpitch: usize,
8369 src: *const ::std::os::raw::c_void,
8370 spitch: usize,
8371 width: usize,
8372 height: usize,
8373 kind: hipMemcpyKind,
8374 stream: hipStream_t,
8375 ) -> hipError_t;
8376}
8377extern "C" {
8378 pub fn hipMemcpyFromSymbolAsync_spt(
8379 dst: *mut ::std::os::raw::c_void,
8380 symbol: *const ::std::os::raw::c_void,
8381 sizeBytes: usize,
8382 offset: usize,
8383 kind: hipMemcpyKind,
8384 stream: hipStream_t,
8385 ) -> hipError_t;
8386}
8387extern "C" {
8388 pub fn hipMemcpyToSymbolAsync_spt(
8389 symbol: *const ::std::os::raw::c_void,
8390 src: *const ::std::os::raw::c_void,
8391 sizeBytes: usize,
8392 offset: usize,
8393 kind: hipMemcpyKind,
8394 stream: hipStream_t,
8395 ) -> hipError_t;
8396}
8397extern "C" {
8398 pub fn hipMemcpyFromArray_spt(
8399 dst: *mut ::std::os::raw::c_void,
8400 src: hipArray_const_t,
8401 wOffsetSrc: usize,
8402 hOffset: usize,
8403 count: usize,
8404 kind: hipMemcpyKind,
8405 ) -> hipError_t;
8406}
8407extern "C" {
8408 pub fn hipMemcpy2DToArray_spt(
8409 dst: hipArray_t,
8410 wOffset: usize,
8411 hOffset: usize,
8412 src: *const ::std::os::raw::c_void,
8413 spitch: usize,
8414 width: usize,
8415 height: usize,
8416 kind: hipMemcpyKind,
8417 ) -> hipError_t;
8418}
8419extern "C" {
8420 pub fn hipMemcpy2DFromArrayAsync_spt(
8421 dst: *mut ::std::os::raw::c_void,
8422 dpitch: usize,
8423 src: hipArray_const_t,
8424 wOffsetSrc: usize,
8425 hOffsetSrc: usize,
8426 width: usize,
8427 height: usize,
8428 kind: hipMemcpyKind,
8429 stream: hipStream_t,
8430 ) -> hipError_t;
8431}
8432extern "C" {
8433 pub fn hipMemcpy2DToArrayAsync_spt(
8434 dst: hipArray_t,
8435 wOffset: usize,
8436 hOffset: usize,
8437 src: *const ::std::os::raw::c_void,
8438 spitch: usize,
8439 width: usize,
8440 height: usize,
8441 kind: hipMemcpyKind,
8442 stream: hipStream_t,
8443 ) -> hipError_t;
8444}
8445extern "C" {
8446 pub fn hipStreamQuery_spt(stream: hipStream_t) -> hipError_t;
8447}
8448extern "C" {
8449 pub fn hipStreamSynchronize_spt(stream: hipStream_t) -> hipError_t;
8450}
8451extern "C" {
8452 pub fn hipStreamGetPriority_spt(
8453 stream: hipStream_t,
8454 priority: *mut ::std::os::raw::c_int,
8455 ) -> hipError_t;
8456}
8457extern "C" {
8458 pub fn hipStreamWaitEvent_spt(
8459 stream: hipStream_t,
8460 event: hipEvent_t,
8461 flags: ::std::os::raw::c_uint,
8462 ) -> hipError_t;
8463}
8464extern "C" {
8465 pub fn hipStreamGetFlags_spt(
8466 stream: hipStream_t,
8467 flags: *mut ::std::os::raw::c_uint,
8468 ) -> hipError_t;
8469}
8470extern "C" {
8471 pub fn hipStreamAddCallback_spt(
8472 stream: hipStream_t,
8473 callback: hipStreamCallback_t,
8474 userData: *mut ::std::os::raw::c_void,
8475 flags: ::std::os::raw::c_uint,
8476 ) -> hipError_t;
8477}
8478extern "C" {
8479 pub fn hipEventRecord_spt(event: hipEvent_t, stream: hipStream_t) -> hipError_t;
8480}
8481extern "C" {
8482 pub fn hipLaunchCooperativeKernel_spt(
8483 f: *const ::std::os::raw::c_void,
8484 gridDim: dim3,
8485 blockDim: dim3,
8486 kernelParams: *mut *mut ::std::os::raw::c_void,
8487 sharedMemBytes: u32,
8488 hStream: hipStream_t,
8489 ) -> hipError_t;
8490}
8491extern "C" {
8492 pub fn hipLaunchKernel_spt(
8493 function_address: *const ::std::os::raw::c_void,
8494 numBlocks: dim3,
8495 dimBlocks: dim3,
8496 args: *mut *mut ::std::os::raw::c_void,
8497 sharedMemBytes: usize,
8498 stream: hipStream_t,
8499 ) -> hipError_t;
8500}
8501extern "C" {
8502 pub fn hipGraphLaunch_spt(graphExec: hipGraphExec_t, stream: hipStream_t) -> hipError_t;
8503}
8504extern "C" {
8505 pub fn hipStreamBeginCapture_spt(stream: hipStream_t, mode: hipStreamCaptureMode)
8506 -> hipError_t;
8507}
8508extern "C" {
8509 pub fn hipStreamEndCapture_spt(stream: hipStream_t, pGraph: *mut hipGraph_t) -> hipError_t;
8510}
8511extern "C" {
8512 pub fn hipStreamIsCapturing_spt(
8513 stream: hipStream_t,
8514 pCaptureStatus: *mut hipStreamCaptureStatus,
8515 ) -> hipError_t;
8516}
8517extern "C" {
8518 pub fn hipStreamGetCaptureInfo_spt(
8519 stream: hipStream_t,
8520 pCaptureStatus: *mut hipStreamCaptureStatus,
8521 pId: *mut ::std::os::raw::c_ulonglong,
8522 ) -> hipError_t;
8523}
8524extern "C" {
8525 pub fn hipStreamGetCaptureInfo_v2_spt(
8526 stream: hipStream_t,
8527 captureStatus_out: *mut hipStreamCaptureStatus,
8528 id_out: *mut ::std::os::raw::c_ulonglong,
8529 graph_out: *mut hipGraph_t,
8530 dependencies_out: *mut *const hipGraphNode_t,
8531 numDependencies_out: *mut usize,
8532 ) -> hipError_t;
8533}
8534extern "C" {
8535 pub fn hipLaunchHostFunc_spt(
8536 stream: hipStream_t,
8537 fn_: hipHostFn_t,
8538 userData: *mut ::std::os::raw::c_void,
8539 ) -> hipError_t;
8540}
8541#[repr(C)]
8542#[derive(Debug, Copy, Clone)]
8543pub struct __locale_data {
8544 pub _address: u8,
8545}