Connect new parser to LLVM bitcode backend (#269)

This is very incomplete. Just enough code to emit LLVM bitcode and continue further development

8 files changed, 0 insertions, 7259 deletions

diff --git a/hip_runtime-sys/Cargo.toml b/hip_runtime-sys/Cargo.toml
deleted file mode 100644
index 3d1241f..0000000
--- a/hip_runtime-sys/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[package]
-name = "hip_runtime-sys"
-version = "0.0.0"
-authors = ["Andrzej Janik <[email protected]>"]
-edition = "2018"
-links = "amdhip"
-
-[lib]
\ No newline at end of file
diff --git a/hip_runtime-sys/README b/hip_runtime-sys/README
deleted file mode 100644
index d1b2e3b..0000000
--- a/hip_runtime-sys/README
+++ /dev/null
@@ -1,2 +0,0 @@
-bindgen include/hip_runtime_api.h -o src/hip_runtime_api.rs --no-layout-tests --size_t-is-usize --default-enum-style=newtype --whitelist-function "hip.*" --whitelist-type "hip.*" -- -I/home/vosen/HIP/include -I/home/vosen/hipamd/include -I/opt/rocm/include
-sed -i 's/pub struct hipError_t/#[must_use]\npub struct hipError_t/g' src/hip_runtime_api.rs
diff --git a/hip_runtime-sys/build.rs b/hip_runtime-sys/build.rs
deleted file mode 100644
index 3bc1250..0000000
--- a/hip_runtime-sys/build.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use std::env::VarError;
-use std::{env, path::PathBuf};
-
-fn main() -> Result<(), VarError> {
-    println!("cargo:rustc-link-lib=dylib=amdhip64");
-    if cfg!(windows) {
-        let env = env::var("CARGO_CFG_TARGET_ENV")?;
-        if env == "msvc" {
-            let mut path = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?);
-            path.push("lib");
-            println!("cargo:rustc-link-search=native={}", path.display());
-        } else {
-            println!("cargo:rustc-link-search=native=C:\\Windows\\System32");
-        };
-    } else {
-        //println!("cargo:rustc-link-search=native=/opt/rocm/lib/");
-        println!("cargo:rustc-link-search=native=/home/ubuntu/hipamd/build/lib");
-        println!("cargo:rustc-link-search=native=/home/vosen/hipamd/build/lib");
-    }
-    Ok(())
-}
diff --git a/hip_runtime-sys/include/hip_runtime_api.h b/hip_runtime-sys/include/hip_runtime_api.h
deleted file mode 100644
index 173daee..0000000
--- a/hip_runtime-sys/include/hip_runtime_api.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#define __HIP_PLATFORM_HCC__
-#include <hip/hip_runtime_api.h>
\ No newline at end of file
diff --git a/hip_runtime-sys/lib/amdhip64.def b/hip_runtime-sys/lib/amdhip64.def
deleted file mode 100644
index 515d5c6..0000000
--- a/hip_runtime-sys/lib/amdhip64.def
+++ /dev/null
@@ -1,308 +0,0 @@
-LIBRARY AMDHIP64

-EXPORTS

-__hipPopCallConfiguration

-__hipPushCallConfiguration

-__hipRegisterFatBinary

-__hipRegisterFunction

-__hipRegisterManagedVar

-__hipRegisterSurface

-__hipRegisterTexture

-__hipRegisterVar

-__hipUnregisterFatBinary

-hipApiName

-hipArray3DCreate

-hipArrayCreate

-hipArrayDestroy

-hipBindTexture

-hipBindTexture2D

-hipBindTextureToArray

-hipBindTextureToMipmappedArray

-hipChooseDevice

-hipConfigureCall

-hipCreateChannelDesc

-hipCreateSurfaceObject

-hipCreateTextureObject

-hipCtxCreate

-hipCtxDestroy

-hipCtxDisablePeerAccess

-hipCtxEnablePeerAccess

-hipCtxGetApiVersion

-hipCtxGetCacheConfig

-hipCtxGetCurrent

-hipCtxGetDevice

-hipCtxGetFlags

-hipCtxGetSharedMemConfig

-hipCtxPopCurrent

-hipCtxPushCurrent

-hipCtxSetCacheConfig

-hipCtxSetCurrent

-hipCtxSetSharedMemConfig

-hipCtxSynchronize

-hipDestroyExternalMemory

-hipDestroyExternalSemaphore

-hipDestroySurfaceObject

-hipDestroyTextureObject

-hipDeviceCanAccessPeer

-hipDeviceComputeCapability

-hipDeviceDisablePeerAccess

-hipDeviceEnablePeerAccess

-hipDeviceGet

-hipDeviceGetAttribute

-hipDeviceGetByPCIBusId

-hipDeviceGetCacheConfig

-hipDeviceGetLimit

-hipDeviceGetName

-hipDeviceGetP2PAttribute

-hipDeviceGetPCIBusId

-hipDeviceGetSharedMemConfig

-hipDeviceGetStreamPriorityRange

-hipDevicePrimaryCtxGetState

-hipDevicePrimaryCtxRelease

-hipDevicePrimaryCtxReset

-hipDevicePrimaryCtxRetain

-hipDevicePrimaryCtxSetFlags

-hipDeviceReset

-hipDeviceSetCacheConfig

-hipDeviceSetSharedMemConfig

-hipDeviceSynchronize

-hipDeviceTotalMem

-hipDriverGetVersion

-hipDrvMemcpy2DUnaligned

-hipDrvMemcpy3D

-hipDrvMemcpy3DAsync

-hipEnableActivityCallback

-hipEventCreate

-hipEventCreateWithFlags

-hipEventDestroy

-hipEventElapsedTime

-hipEventQuery

-hipEventRecord

-hipEventSynchronize

-hipExtGetLinkTypeAndHopCount

-hipExtLaunchKernel

-hipExtLaunchMultiKernelMultiDevice

-hipExtMallocWithFlags

-hipExtModuleLaunchKernel

-hipExtStreamCreateWithCUMask

-hipExtStreamGetCUMask

-hipExternalMemoryGetMappedBuffer

-hipFree

-hipFreeArray

-hipFreeHost

-hipFreeMipmappedArray

-hipFuncGetAttribute

-hipFuncGetAttributes

-hipFuncSetAttribute

-hipFuncSetCacheConfig

-hipFuncSetSharedMemConfig

-hipGLGetDevices

-hipGetChannelDesc

-hipGetCmdName

-hipGetDevice

-hipGetDeviceCount

-hipGetDeviceFlags

-hipGetDeviceProperties

-hipGetErrorName

-hipGetErrorString

-hipGetLastError

-hipGetMipmappedArrayLevel

-hipGetSymbolAddress

-hipGetSymbolSize

-hipGetTextureAlignmentOffset

-hipGetTextureObjectResourceDesc

-hipGetTextureObjectResourceViewDesc

-hipGetTextureObjectTextureDesc

-hipGetTextureReference

-hipGraphAddDependencies

-hipGraphAddEmptyNode

-hipGraphAddKernelNode

-hipGraphAddMemcpyNode

-hipGraphAddMemcpyNode1D

-hipGraphAddMemsetNode

-hipGraphCreate

-hipGraphDestroy

-hipGraphExecDestroy

-hipGraphExecKernelNodeSetParams

-hipGraphGetNodes

-hipGraphGetRootNodes

-hipGraphInstantiate

-hipGraphKernelNodeGetParams

-hipGraphKernelNodeSetParams

-hipGraphLaunch

-hipGraphMemcpyNodeGetParams

-hipGraphMemcpyNodeSetParams

-hipGraphMemsetNodeGetParams

-hipGraphMemsetNodeSetParams

-hipGraphicsGLRegisterBuffer

-hipGraphicsMapResources

-hipGraphicsResourceGetMappedPointer

-hipGraphicsUnmapResources

-hipGraphicsUnregisterResource

-hipHccModuleLaunchKernel

-hipHostAlloc

-hipHostFree

-hipHostGetDevicePointer

-hipHostGetFlags

-hipHostMalloc

-hipHostRegister

-hipHostUnregister

-hipImportExternalMemory

-hipImportExternalSemaphore

-hipInit

-hipInitActivityCallback

-hipIpcCloseMemHandle

-hipIpcGetEventHandle

-hipIpcGetMemHandle

-hipIpcOpenEventHandle

-hipIpcOpenMemHandle

-hipKernelNameRef

-hipLaunchByPtr

-hipLaunchCooperativeKernel

-hipLaunchCooperativeKernelMultiDevice

-hipLaunchKernel

-hipMalloc

-hipMalloc3D

-hipMalloc3DArray

-hipMallocArray

-hipMallocHost

-hipMallocManaged

-hipMallocMipmappedArray

-hipMallocPitch

-hipMemAdvise

-hipMemAllocHost

-hipMemAllocPitch

-hipMemGetAddressRange

-hipMemGetInfo

-hipMemPrefetchAsync

-hipMemPtrGetInfo

-hipMemRangeGetAttribute

-hipMemRangeGetAttributes

-hipMemcpy

-hipMemcpy2D

-hipMemcpy2DAsync

-hipMemcpy2DFromArray

-hipMemcpy2DFromArrayAsync

-hipMemcpy2DToArray

-hipMemcpy2DToArrayAsync

-hipMemcpy3D

-hipMemcpy3DAsync

-hipMemcpyAsync

-hipMemcpyAtoH

-hipMemcpyDtoD

-hipMemcpyDtoDAsync

-hipMemcpyDtoH

-hipMemcpyDtoHAsync

-hipMemcpyFromArray

-hipMemcpyFromSymbol

-hipMemcpyFromSymbolAsync

-hipMemcpyHtoA

-hipMemcpyHtoD

-hipMemcpyHtoDAsync

-hipMemcpyParam2D

-hipMemcpyParam2DAsync

-hipMemcpyPeer

-hipMemcpyPeerAsync

-hipMemcpyToArray

-hipMemcpyToSymbol

-hipMemcpyToSymbolAsync

-hipMemcpyWithStream

-hipMemset

-hipMemset2D

-hipMemset2DAsync

-hipMemset3D

-hipMemset3DAsync

-hipMemsetAsync

-hipMemsetD16

-hipMemsetD16Async

-hipMemsetD32

-hipMemsetD32Async

-hipMemsetD8

-hipMemsetD8Async

-hipMipmappedArrayCreate

-hipMipmappedArrayDestroy

-hipMipmappedArrayGetLevel

-hipModuleGetFunction

-hipModuleGetGlobal

-hipModuleGetTexRef

-hipModuleLaunchKernel

-hipModuleLaunchKernelExt

-hipModuleLoad

-hipModuleLoadData

-hipModuleLoadDataEx

-hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

-hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

-hipModuleOccupancyMaxPotentialBlockSize

-hipModuleOccupancyMaxPotentialBlockSizeWithFlags

-hipModuleUnload

-hipOccupancyMaxActiveBlocksPerMultiprocessor

-hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

-hipOccupancyMaxPotentialBlockSize

-hipPeekAtLastError

-hipPointerGetAttributes

-hipProfilerStart

-hipProfilerStop

-hipRegisterActivityCallback

-hipRegisterApiCallback

-hipRemoveActivityCallback

-hipRemoveApiCallback

-hipRuntimeGetVersion

-hipSetDevice

-hipSetDeviceFlags

-hipSetupArgument

-hipSignalExternalSemaphoresAsync

-hipStreamAddCallback

-hipStreamAttachMemAsync

-hipStreamBeginCapture

-hipStreamCreate

-hipStreamCreateWithFlags

-hipStreamCreateWithPriority

-hipStreamDestroy

-hipStreamEndCapture

-hipStreamGetFlags

-hipStreamGetPriority

-hipStreamIsCapturing

-hipStreamQuery

-hipStreamSynchronize

-hipStreamWaitEvent

-hipTexObjectCreate

-hipTexObjectDestroy

-hipTexObjectGetResourceDesc

-hipTexObjectGetResourceViewDesc

-hipTexObjectGetTextureDesc

-hipTexRefGetAddress

-hipTexRefGetAddressMode

-hipTexRefGetArray

-hipTexRefGetBorderColor

-hipTexRefGetFilterMode

-hipTexRefGetFlags

-hipTexRefGetFormat

-hipTexRefGetMaxAnisotropy

-hipTexRefGetMipmapFilterMode

-hipTexRefGetMipmapLevelBias

-hipTexRefGetMipmapLevelClamp

-hipTexRefGetMipmappedArray

-hipTexRefSetAddress

-hipTexRefSetAddress2D

-hipTexRefSetAddressMode

-hipTexRefSetArray

-hipTexRefSetBorderColor

-hipTexRefSetFilterMode

-hipTexRefSetFlags

-hipTexRefSetFormat

-hipTexRefSetMaxAnisotropy

-hipTexRefSetMipmapFilterMode

-hipTexRefSetMipmapLevelBias

-hipTexRefSetMipmapLevelClamp

-hipTexRefSetMipmappedArray

-hipUnbindTexture

-hipWaitExternalSemaphoresAsync

-hiprtcAddNameExpression

-hiprtcCompileProgram

-hiprtcCreateProgram

-hiprtcDestroyProgram

-hiprtcGetCode

-hiprtcGetCodeSize

-hiprtcGetErrorString

-hiprtcGetLoweredName

-hiprtcGetProgramLog

-hiprtcGetProgramLogSize

diff --git a/hip_runtime-sys/lib/amdhip64.lib b/hip_runtime-sys/lib/amdhip64.lib
deleted file mode 100644
index 1d7df96..0000000
--- a/hip_runtime-sys/lib/amdhip64.lib
+++ /dev/null
diff --git a/hip_runtime-sys/src/hip_runtime_api.rs b/hip_runtime-sys/src/hip_runtime_api.rs
deleted file mode 100644
index b6765ce..0000000
--- a/hip_runtime-sys/src/hip_runtime_api.rs
+++ /dev/null
@@ -1,6915 +0,0 @@
-/* automatically generated by rust-bindgen 0.59.1 */
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage> {
-    storage: Storage,
-}
-impl<Storage> __BindgenBitfieldUnit<Storage> {
-    #[inline]
-    pub const fn new(storage: Storage) -> Self {
-        Self { storage }
-    }
-}
-impl<Storage> __BindgenBitfieldUnit<Storage>
-where
-    Storage: AsRef<[u8]> + AsMut<[u8]>,
-{
-    #[inline]
-    pub fn get_bit(&self, index: usize) -> bool {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = self.storage.as_ref()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        byte & mask == mask
-    }
-    #[inline]
-    pub fn set_bit(&mut self, index: usize, val: bool) {
-        debug_assert!(index / 8 < self.storage.as_ref().len());
-        let byte_index = index / 8;
-        let byte = &mut self.storage.as_mut()[byte_index];
-        let bit_index = if cfg!(target_endian = "big") {
-            7 - (index % 8)
-        } else {
-            index % 8
-        };
-        let mask = 1 << bit_index;
-        if val {
-            *byte |= mask;
-        } else {
-            *byte &= !mask;
-        }
-    }
-    #[inline]
-    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
-        let mut val = 0;
-        for i in 0..(bit_width as usize) {
-            if self.get_bit(i + bit_offset) {
-                let index = if cfg!(target_endian = "big") {
-                    bit_width as usize - 1 - i
-                } else {
-                    i
-                };
-                val |= 1 << index;
-            }
-        }
-        val
-    }
-    #[inline]
-    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
-        debug_assert!(bit_width <= 64);
-        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
-        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
-        for i in 0..(bit_width as usize) {
-            let mask = 1 << i;
-            let val_bit_is_set = val & mask == mask;
-            let index = if cfg!(target_endian = "big") {
-                bit_width as usize - 1 - i
-            } else {
-                i
-            };
-            self.set_bit(index + bit_offset, val_bit_is_set);
-        }
-    }
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Copy, Clone)]
-pub struct hipDeviceArch_t {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
-    pub __bindgen_padding_0: u8,
-}
-impl hipDeviceArch_t {
-    #[inline]
-    pub fn hasGlobalInt32Atomics(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasGlobalInt32Atomics(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasGlobalFloatAtomicExch(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasGlobalFloatAtomicExch(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasSharedInt32Atomics(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasSharedInt32Atomics(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasSharedFloatAtomicExch(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasSharedFloatAtomicExch(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasFloatAtomicAdd(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasFloatAtomicAdd(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasGlobalInt64Atomics(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasGlobalInt64Atomics(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasSharedInt64Atomics(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasSharedInt64Atomics(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasDoubles(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasDoubles(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(7usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasWarpVote(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasWarpVote(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasWarpBallot(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasWarpBallot(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(9usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasWarpShuffle(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasWarpShuffle(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(10usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasFunnelShift(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasFunnelShift(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(11usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasThreadFenceSystem(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasThreadFenceSystem(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(12usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasSyncThreadsExt(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasSyncThreadsExt(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(13usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasSurfaceFuncs(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasSurfaceFuncs(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(14usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn has3dGrid(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_has3dGrid(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(15usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn hasDynamicParallelism(&self) -> ::std::os::raw::c_uint {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_hasDynamicParallelism(&mut self, val: ::std::os::raw::c_uint) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        hasGlobalInt32Atomics: ::std::os::raw::c_uint,
-        hasGlobalFloatAtomicExch: ::std::os::raw::c_uint,
-        hasSharedInt32Atomics: ::std::os::raw::c_uint,
-        hasSharedFloatAtomicExch: ::std::os::raw::c_uint,
-        hasFloatAtomicAdd: ::std::os::raw::c_uint,
-        hasGlobalInt64Atomics: ::std::os::raw::c_uint,
-        hasSharedInt64Atomics: ::std::os::raw::c_uint,
-        hasDoubles: ::std::os::raw::c_uint,
-        hasWarpVote: ::std::os::raw::c_uint,
-        hasWarpBallot: ::std::os::raw::c_uint,
-        hasWarpShuffle: ::std::os::raw::c_uint,
-        hasFunnelShift: ::std::os::raw::c_uint,
-        hasThreadFenceSystem: ::std::os::raw::c_uint,
-        hasSyncThreadsExt: ::std::os::raw::c_uint,
-        hasSurfaceFuncs: ::std::os::raw::c_uint,
-        has3dGrid: ::std::os::raw::c_uint,
-        hasDynamicParallelism: ::std::os::raw::c_uint,
-    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let hasGlobalInt32Atomics: u32 =
-                unsafe { ::std::mem::transmute(hasGlobalInt32Atomics) };
-            hasGlobalInt32Atomics as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let hasGlobalFloatAtomicExch: u32 =
-                unsafe { ::std::mem::transmute(hasGlobalFloatAtomicExch) };
-            hasGlobalFloatAtomicExch as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let hasSharedInt32Atomics: u32 =
-                unsafe { ::std::mem::transmute(hasSharedInt32Atomics) };
-            hasSharedInt32Atomics as u64
-        });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
-            let hasSharedFloatAtomicExch: u32 =
-                unsafe { ::std::mem::transmute(hasSharedFloatAtomicExch) };
-            hasSharedFloatAtomicExch as u64
-        });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let hasFloatAtomicAdd: u32 = unsafe { ::std::mem::transmute(hasFloatAtomicAdd) };
-            hasFloatAtomicAdd as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
-            let hasGlobalInt64Atomics: u32 =
-                unsafe { ::std::mem::transmute(hasGlobalInt64Atomics) };
-            hasGlobalInt64Atomics as u64
-        });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let hasSharedInt64Atomics: u32 =
-                unsafe { ::std::mem::transmute(hasSharedInt64Atomics) };
-            hasSharedInt64Atomics as u64
-        });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
-            let hasDoubles: u32 = unsafe { ::std::mem::transmute(hasDoubles) };
-            hasDoubles as u64
-        });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let hasWarpVote: u32 = unsafe { ::std::mem::transmute(hasWarpVote) };
-            hasWarpVote as u64
-        });
-        __bindgen_bitfield_unit.set(9usize, 1u8, {
-            let hasWarpBallot: u32 = unsafe { ::std::mem::transmute(hasWarpBallot) };
-            hasWarpBallot as u64
-        });
-        __bindgen_bitfield_unit.set(10usize, 1u8, {
-            let hasWarpShuffle: u32 = unsafe { ::std::mem::transmute(hasWarpShuffle) };
-            hasWarpShuffle as u64
-        });
-        __bindgen_bitfield_unit.set(11usize, 1u8, {
-            let hasFunnelShift: u32 = unsafe { ::std::mem::transmute(hasFunnelShift) };
-            hasFunnelShift as u64
-        });
-        __bindgen_bitfield_unit.set(12usize, 1u8, {
-            let hasThreadFenceSystem: u32 = unsafe { ::std::mem::transmute(hasThreadFenceSystem) };
-            hasThreadFenceSystem as u64
-        });
-        __bindgen_bitfield_unit.set(13usize, 1u8, {
-            let hasSyncThreadsExt: u32 = unsafe { ::std::mem::transmute(hasSyncThreadsExt) };
-            hasSyncThreadsExt as u64
-        });
-        __bindgen_bitfield_unit.set(14usize, 1u8, {
-            let hasSurfaceFuncs: u32 = unsafe { ::std::mem::transmute(hasSurfaceFuncs) };
-            hasSurfaceFuncs as u64
-        });
-        __bindgen_bitfield_unit.set(15usize, 1u8, {
-            let has3dGrid: u32 = unsafe { ::std::mem::transmute(has3dGrid) };
-            has3dGrid as u64
-        });
-        __bindgen_bitfield_unit.set(16usize, 1u8, {
-            let hasDynamicParallelism: u32 =
-                unsafe { ::std::mem::transmute(hasDynamicParallelism) };
-            hasDynamicParallelism as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[doc = " hipDeviceProp"]
-#[doc = ""]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipDeviceProp_t {
-    #[doc = "< Device name."]
-    pub name: [::std::os::raw::c_char; 256usize],
-    #[doc = "< Size of global memory region (in bytes)."]
-    pub totalGlobalMem: usize,
-    #[doc = "< Size of shared memory region (in bytes)."]
-    pub sharedMemPerBlock: usize,
-    #[doc = "< Registers per block."]
-    pub regsPerBlock: ::std::os::raw::c_int,
-    #[doc = "< Warp size."]
-    pub warpSize: ::std::os::raw::c_int,
-    #[doc = "< Max work items per work group or workgroup max size."]
-    pub maxThreadsPerBlock: ::std::os::raw::c_int,
-    #[doc = "< Max number of threads in each dimension (XYZ) of a block."]
-    pub maxThreadsDim: [::std::os::raw::c_int; 3usize],
-    #[doc = "< Max grid dimensions (XYZ)."]
-    pub maxGridSize: [::std::os::raw::c_int; 3usize],
-    #[doc = "< Max clock frequency of the multiProcessors in khz."]
-    pub clockRate: ::std::os::raw::c_int,
-    #[doc = "< Max global memory clock frequency in khz."]
-    pub memoryClockRate: ::std::os::raw::c_int,
-    #[doc = "< Global memory bus width in bits."]
-    pub memoryBusWidth: ::std::os::raw::c_int,
-    #[doc = "< Size of shared memory region (in bytes)."]
-    pub totalConstMem: usize,
-    #[doc = "< Major compute capability.  On HCC, this is an approximation and features may"]
-    #[doc = "< differ from CUDA CC.  See the arch feature flags for portable ways to query"]
-    #[doc = "< feature caps."]
-    pub major: ::std::os::raw::c_int,
-    #[doc = "< Minor compute capability.  On HCC, this is an approximation and features may"]
-    #[doc = "< differ from CUDA CC.  See the arch feature flags for portable ways to query"]
-    #[doc = "< feature caps."]
-    pub minor: ::std::os::raw::c_int,
-    #[doc = "< Number of multi-processors (compute units)."]
-    pub multiProcessorCount: ::std::os::raw::c_int,
-    #[doc = "< L2 cache size."]
-    pub l2CacheSize: ::std::os::raw::c_int,
-    #[doc = "< Maximum resident threads per multi-processor."]
-    pub maxThreadsPerMultiProcessor: ::std::os::raw::c_int,
-    #[doc = "< Compute mode."]
-    pub computeMode: ::std::os::raw::c_int,
-    #[doc = "< Frequency in khz of the timer used by the device-side \"clock*\""]
-    #[doc = "< instructions.  New for HIP."]
-    pub clockInstructionRate: ::std::os::raw::c_int,
-    #[doc = "< Architectural feature flags.  New for HIP."]
-    pub arch: hipDeviceArch_t,
-    #[doc = "< Device can possibly execute multiple kernels concurrently."]
-    pub concurrentKernels: ::std::os::raw::c_int,
-    #[doc = "< PCI Domain ID"]
-    pub pciDomainID: ::std::os::raw::c_int,
-    #[doc = "< PCI Bus ID."]
-    pub pciBusID: ::std::os::raw::c_int,
-    #[doc = "< PCI Device ID."]
-    pub pciDeviceID: ::std::os::raw::c_int,
-    #[doc = "< Maximum Shared Memory Per Multiprocessor."]
-    pub maxSharedMemoryPerMultiProcessor: usize,
-    #[doc = "< 1 if device is on a multi-GPU board, 0 if not."]
-    pub isMultiGpuBoard: ::std::os::raw::c_int,
-    #[doc = "< Check whether HIP can map host memory"]
-    pub canMapHostMemory: ::std::os::raw::c_int,
-    #[doc = "< DEPRECATED: use gcnArchName instead"]
-    pub gcnArch: ::std::os::raw::c_int,
-    #[doc = "< AMD GCN Arch Name."]
-    pub gcnArchName: [::std::os::raw::c_char; 256usize],
-    #[doc = "< APU vs dGPU"]
-    pub integrated: ::std::os::raw::c_int,
-    #[doc = "< HIP device supports cooperative launch"]
-    pub cooperativeLaunch: ::std::os::raw::c_int,
-    #[doc = "< HIP device supports cooperative launch on multiple devices"]
-    pub cooperativeMultiDeviceLaunch: ::std::os::raw::c_int,
-    #[doc = "< Maximum size for 1D textures bound to linear memory"]
-    pub maxTexture1DLinear: ::std::os::raw::c_int,
-    #[doc = "< Maximum number of elements in 1D images"]
-    pub maxTexture1D: ::std::os::raw::c_int,
-    #[doc = "< Maximum dimensions (width, height) of 2D images, in image elements"]
-    pub maxTexture2D: [::std::os::raw::c_int; 2usize],
-    #[doc = "< Maximum dimensions (width, height, depth) of 3D images, in image elements"]
-    pub maxTexture3D: [::std::os::raw::c_int; 3usize],
-    #[doc = "< Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register"]
-    pub hdpMemFlushCntl: *mut ::std::os::raw::c_uint,
-    #[doc = "< Addres of HDP_REG_COHERENCY_FLUSH_CNTL register"]
-    pub hdpRegFlushCntl: *mut ::std::os::raw::c_uint,
-    #[doc = "<Maximum pitch in bytes allowed by memory copies"]
-    pub memPitch: usize,
-    #[doc = "<Alignment requirement for textures"]
-    pub textureAlignment: usize,
-    #[doc = "<Pitch alignment requirement for texture references bound to pitched memory"]
-    pub texturePitchAlignment: usize,
-    #[doc = "<Run time limit for kernels executed on the device"]
-    pub kernelExecTimeoutEnabled: ::std::os::raw::c_int,
-    #[doc = "<Device has ECC support enabled"]
-    pub ECCEnabled: ::std::os::raw::c_int,
-    #[doc = "< 1:If device is Tesla device using TCC driver, else 0"]
-    pub tccDriver: ::std::os::raw::c_int,
-    #[doc = "< HIP device supports cooperative launch on multiple"]
-    pub cooperativeMultiDeviceUnmatchedFunc: ::std::os::raw::c_int,
-    #[doc = "< HIP device supports cooperative launch on multiple"]
-    pub cooperativeMultiDeviceUnmatchedGridDim: ::std::os::raw::c_int,
-    #[doc = "< HIP device supports cooperative launch on multiple"]
-    pub cooperativeMultiDeviceUnmatchedBlockDim: ::std::os::raw::c_int,
-    #[doc = "< HIP device supports cooperative launch on multiple"]
-    pub cooperativeMultiDeviceUnmatchedSharedMem: ::std::os::raw::c_int,
-    #[doc = "< 1: if it is a large PCI bar device, else 0"]
-    pub isLargeBar: ::std::os::raw::c_int,
-    #[doc = "< Revision of the GPU in this device"]
-    pub asicRevision: ::std::os::raw::c_int,
-    #[doc = "< Device supports allocating managed memory on this system"]
-    pub managedMemory: ::std::os::raw::c_int,
-    #[doc = "< Host can directly access managed memory on the device without migration"]
-    pub directManagedMemAccessFromHost: ::std::os::raw::c_int,
-    #[doc = "< Device can coherently access managed memory concurrently with the CPU"]
-    pub concurrentManagedAccess: ::std::os::raw::c_int,
-    #[doc = "< Device supports coherently accessing pageable memory"]
-    #[doc = "< without calling hipHostRegister on it"]
-    pub pageableMemoryAccess: ::std::os::raw::c_int,
-    #[doc = "< Device accesses pageable memory via the host's page tables"]
-    pub pageableMemoryAccessUsesHostPageTables: ::std::os::raw::c_int,
-}
-impl hipMemoryType {
-    #[doc = "< Memory is physically located on host"]
-    pub const hipMemoryTypeHost: hipMemoryType = hipMemoryType(0);
-}
-impl hipMemoryType {
-    #[doc = "< Memory is physically located on device. (see deviceId for specific"]
-    #[doc = "< device)"]
-    pub const hipMemoryTypeDevice: hipMemoryType = hipMemoryType(1);
-}
-impl hipMemoryType {
-    #[doc = "< Array memory, physically located on device. (see deviceId for specific"]
-    #[doc = "< device)"]
-    pub const hipMemoryTypeArray: hipMemoryType = hipMemoryType(2);
-}
-impl hipMemoryType {
-    #[doc = "< Not used currently"]
-    pub const hipMemoryTypeUnified: hipMemoryType = hipMemoryType(3);
-}
-#[repr(transparent)]
-#[doc = " Memory type (for pointer attributes)"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipMemoryType(pub ::std::os::raw::c_uint);
-#[doc = " Pointer attributes"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipPointerAttribute_t {
-    pub memoryType: hipMemoryType,
-    pub device: ::std::os::raw::c_int,
-    pub devicePointer: *mut ::std::os::raw::c_void,
-    pub hostPointer: *mut ::std::os::raw::c_void,
-    pub isManaged: ::std::os::raw::c_int,
-    pub allocationFlags: ::std::os::raw::c_uint,
-}
-impl hipError_t {
-    #[doc = "< Successful completion."]
-    pub const hipSuccess: hipError_t = hipError_t(0);
-}
-impl hipError_t {
-    #[doc = "< One or more of the parameters passed to the API call is NULL"]
-    #[doc = "< or not in an acceptable range."]
-    pub const hipErrorInvalidValue: hipError_t = hipError_t(1);
-}
-impl hipError_t {
-    pub const hipErrorOutOfMemory: hipError_t = hipError_t(2);
-}
-impl hipError_t {
-    #[doc = "< Memory allocation error."]
-    pub const hipErrorMemoryAllocation: hipError_t = hipError_t(2);
-}
-impl hipError_t {
-    pub const hipErrorNotInitialized: hipError_t = hipError_t(3);
-}
-impl hipError_t {
-    pub const hipErrorInitializationError: hipError_t = hipError_t(3);
-}
-impl hipError_t {
-    pub const hipErrorDeinitialized: hipError_t = hipError_t(4);
-}
-impl hipError_t {
-    pub const hipErrorProfilerDisabled: hipError_t = hipError_t(5);
-}
-impl hipError_t {
-    pub const hipErrorProfilerNotInitialized: hipError_t = hipError_t(6);
-}
-impl hipError_t {
-    pub const hipErrorProfilerAlreadyStarted: hipError_t = hipError_t(7);
-}
-impl hipError_t {
-    pub const hipErrorProfilerAlreadyStopped: hipError_t = hipError_t(8);
-}
-impl hipError_t {
-    pub const hipErrorInvalidConfiguration: hipError_t = hipError_t(9);
-}
-impl hipError_t {
-    pub const hipErrorInvalidPitchValue: hipError_t = hipError_t(12);
-}
-impl hipError_t {
-    pub const hipErrorInvalidSymbol: hipError_t = hipError_t(13);
-}
-impl hipError_t {
-    #[doc = "< Invalid Device Pointer"]
-    pub const hipErrorInvalidDevicePointer: hipError_t = hipError_t(17);
-}
-impl hipError_t {
-    #[doc = "< Invalid memory copy direction"]
-    pub const hipErrorInvalidMemcpyDirection: hipError_t = hipError_t(21);
-}
-impl hipError_t {
-    pub const hipErrorInsufficientDriver: hipError_t = hipError_t(35);
-}
-impl hipError_t {
-    pub const hipErrorMissingConfiguration: hipError_t = hipError_t(52);
-}
-impl hipError_t {
-    pub const hipErrorPriorLaunchFailure: hipError_t = hipError_t(53);
-}
-impl hipError_t {
-    pub const hipErrorInvalidDeviceFunction: hipError_t = hipError_t(98);
-}
-impl hipError_t {
-    #[doc = "< Call to hipGetDeviceCount returned 0 devices"]
-    pub const hipErrorNoDevice: hipError_t = hipError_t(100);
-}
-impl hipError_t {
-    #[doc = "< DeviceID must be in range 0...#compute-devices."]
-    pub const hipErrorInvalidDevice: hipError_t = hipError_t(101);
-}
-impl hipError_t {
-    pub const hipErrorInvalidImage: hipError_t = hipError_t(200);
-}
-impl hipError_t {
-    #[doc = "< Produced when input context is invalid."]
-    pub const hipErrorInvalidContext: hipError_t = hipError_t(201);
-}
-impl hipError_t {
-    pub const hipErrorContextAlreadyCurrent: hipError_t = hipError_t(202);
-}
-impl hipError_t {
-    pub const hipErrorMapFailed: hipError_t = hipError_t(205);
-}
-impl hipError_t {
-    #[doc = "< Produced when the IPC memory attach failed from ROCr."]
-    pub const hipErrorMapBufferObjectFailed: hipError_t = hipError_t(205);
-}
-impl hipError_t {
-    pub const hipErrorUnmapFailed: hipError_t = hipError_t(206);
-}
-impl hipError_t {
-    pub const hipErrorArrayIsMapped: hipError_t = hipError_t(207);
-}
-impl hipError_t {
-    pub const hipErrorAlreadyMapped: hipError_t = hipError_t(208);
-}
-impl hipError_t {
-    pub const hipErrorNoBinaryForGpu: hipError_t = hipError_t(209);
-}
-impl hipError_t {
-    pub const hipErrorAlreadyAcquired: hipError_t = hipError_t(210);
-}
-impl hipError_t {
-    pub const hipErrorNotMapped: hipError_t = hipError_t(211);
-}
-impl hipError_t {
-    pub const hipErrorNotMappedAsArray: hipError_t = hipError_t(212);
-}
-impl hipError_t {
-    pub const hipErrorNotMappedAsPointer: hipError_t = hipError_t(213);
-}
-impl hipError_t {
-    pub const hipErrorECCNotCorrectable: hipError_t = hipError_t(214);
-}
-impl hipError_t {
-    pub const hipErrorUnsupportedLimit: hipError_t = hipError_t(215);
-}
-impl hipError_t {
-    pub const hipErrorContextAlreadyInUse: hipError_t = hipError_t(216);
-}
-impl hipError_t {
-    pub const hipErrorPeerAccessUnsupported: hipError_t = hipError_t(217);
-}
-impl hipError_t {
-    #[doc = "< In CUDA DRV, it is CUDA_ERROR_INVALID_PTX"]
-    pub const hipErrorInvalidKernelFile: hipError_t = hipError_t(218);
-}
-impl hipError_t {
-    pub const hipErrorInvalidGraphicsContext: hipError_t = hipError_t(219);
-}
-impl hipError_t {
-    pub const hipErrorInvalidSource: hipError_t = hipError_t(300);
-}
-impl hipError_t {
-    pub const hipErrorFileNotFound: hipError_t = hipError_t(301);
-}
-impl hipError_t {
-    pub const hipErrorSharedObjectSymbolNotFound: hipError_t = hipError_t(302);
-}
-impl hipError_t {
-    pub const hipErrorSharedObjectInitFailed: hipError_t = hipError_t(303);
-}
-impl hipError_t {
-    pub const hipErrorOperatingSystem: hipError_t = hipError_t(304);
-}
-impl hipError_t {
-    pub const hipErrorInvalidHandle: hipError_t = hipError_t(400);
-}
-impl hipError_t {
-    #[doc = "< Resource handle (hipEvent_t or hipStream_t) invalid."]
-    pub const hipErrorInvalidResourceHandle: hipError_t = hipError_t(400);
-}
-impl hipError_t {
-    pub const hipErrorNotFound: hipError_t = hipError_t(500);
-}
-impl hipError_t {
-    #[doc = "< Indicates that asynchronous operations enqueued earlier are not"]
-    #[doc = "< ready.  This is not actually an error, but is used to distinguish"]
-    #[doc = "< from hipSuccess (which indicates completion).  APIs that return"]
-    #[doc = "< this error include hipEventQuery and hipStreamQuery."]
-    pub const hipErrorNotReady: hipError_t = hipError_t(600);
-}
-impl hipError_t {
-    pub const hipErrorIllegalAddress: hipError_t = hipError_t(700);
-}
-impl hipError_t {
-    #[doc = "< Out of resources error."]
-    pub const hipErrorLaunchOutOfResources: hipError_t = hipError_t(701);
-}
-impl hipError_t {
-    pub const hipErrorLaunchTimeOut: hipError_t = hipError_t(702);
-}
-impl hipError_t {
-    pub const hipErrorPeerAccessAlreadyEnabled: hipError_t = hipError_t(704);
-}
-impl hipError_t {
-    pub const hipErrorPeerAccessNotEnabled: hipError_t = hipError_t(705);
-}
-impl hipError_t {
-    pub const hipErrorSetOnActiveProcess: hipError_t = hipError_t(708);
-}
-impl hipError_t {
-    pub const hipErrorContextIsDestroyed: hipError_t = hipError_t(709);
-}
-impl hipError_t {
-    #[doc = "< Produced when the kernel calls assert."]
-    pub const hipErrorAssert: hipError_t = hipError_t(710);
-}
-impl hipError_t {
-    pub const hipErrorHostMemoryAlreadyRegistered: hipError_t = hipError_t(712);
-}
-impl hipError_t {
-    pub const hipErrorHostMemoryNotRegistered: hipError_t = hipError_t(713);
-}
-impl hipError_t {
-    pub const hipErrorLaunchFailure: hipError_t = hipError_t(719);
-}
-impl hipError_t {
-    pub const hipErrorCooperativeLaunchTooLarge: hipError_t = hipError_t(720);
-}
-impl hipError_t {
-    #[doc = "< Produced when the hip API is not supported/implemented"]
-    pub const hipErrorNotSupported: hipError_t = hipError_t(801);
-}
-impl hipError_t {
-    #[doc = "< The operation is not permitted when the stream"]
-    #[doc = "< is capturing."]
-    pub const hipErrorStreamCaptureUnsupported: hipError_t = hipError_t(900);
-}
-impl hipError_t {
-    #[doc = "< The current capture sequence on the stream"]
-    #[doc = "< has been invalidated due to a previous error."]
-    pub const hipErrorStreamCaptureInvalidated: hipError_t = hipError_t(901);
-}
-impl hipError_t {
-    #[doc = "< The operation would have resulted in a merge of"]
-    #[doc = "< two independent capture sequences."]
-    pub const hipErrorStreamCaptureMerge: hipError_t = hipError_t(902);
-}
-impl hipError_t {
-    #[doc = "< The capture was not initiated in this stream."]
-    pub const hipErrorStreamCaptureUnmatched: hipError_t = hipError_t(903);
-}
-impl hipError_t {
-    #[doc = "< The capture sequence contains a fork that was not"]
-    #[doc = "< joined to the primary stream."]
-    pub const hipErrorStreamCaptureUnjoined: hipError_t = hipError_t(904);
-}
-impl hipError_t {
-    #[doc = "< A dependency would have been created which crosses"]
-    #[doc = "< the capture sequence boundary. Only implicit"]
-    #[doc = "< in-stream ordering dependencies  are allowed"]
-    #[doc = "< to cross the boundary"]
-    pub const hipErrorStreamCaptureIsolation: hipError_t = hipError_t(905);
-}
-impl hipError_t {
-    #[doc = "< The operation would have resulted in a disallowed"]
-    #[doc = "< implicit dependency on a current capture sequence"]
-    #[doc = "< from hipStreamLegacy."]
-    pub const hipErrorStreamCaptureImplicit: hipError_t = hipError_t(906);
-}
-impl hipError_t {
-    #[doc = "< The operation is not permitted on an event which was last"]
-    #[doc = "< recorded in a capturing stream."]
-    pub const hipErrorCapturedEvent: hipError_t = hipError_t(907);
-}
-impl hipError_t {
-    #[doc = "< A stream capture sequence not initiated with"]
-    #[doc = "< the hipStreamCaptureModeRelaxed argument to"]
-    #[doc = "< hipStreamBeginCapture was passed to"]
-    #[doc = "< hipStreamEndCapture in a different thread."]
-    pub const hipErrorStreamCaptureWrongThread: hipError_t = hipError_t(908);
-}
-impl hipError_t {
-    pub const hipErrorUnknown: hipError_t = hipError_t(999);
-}
-impl hipError_t {
-    #[doc = "< HSA runtime memory call returned error.  Typically not seen"]
-    #[doc = "< in production systems."]
-    pub const hipErrorRuntimeMemory: hipError_t = hipError_t(1052);
-}
-impl hipError_t {
-    #[doc = "< HSA runtime call other than memory returned error.  Typically"]
-    #[doc = "< not seen in production systems."]
-    pub const hipErrorRuntimeOther: hipError_t = hipError_t(1053);
-}
-impl hipError_t {
-    #[doc = "< Marker that more error codes are needed."]
-    pub const hipErrorTbd: hipError_t = hipError_t(1054);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-#[must_use]
-pub struct hipError_t(pub ::std::os::raw::c_uint);
-impl hipDeviceAttribute_t {
-    pub const hipDeviceAttributeCudaCompatibleBegin: hipDeviceAttribute_t = hipDeviceAttribute_t(0);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Whether ECC support is enabled."]
-    pub const hipDeviceAttributeEccEnabled: hipDeviceAttribute_t = hipDeviceAttribute_t(0);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. The maximum size of the window policy in bytes."]
-    pub const hipDeviceAttributeAccessPolicyMaxWindowSize: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(1);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Asynchronous engines number."]
-    pub const hipDeviceAttributeAsyncEngineCount: hipDeviceAttribute_t = hipDeviceAttribute_t(2);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Whether host memory can be mapped into device address space"]
-    pub const hipDeviceAttributeCanMapHostMemory: hipDeviceAttribute_t = hipDeviceAttribute_t(3);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Device can access host registered memory"]
-    #[doc = "< at the same virtual address as the CPU"]
-    pub const hipDeviceAttributeCanUseHostPointerForRegisteredMem: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(4);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Peak clock frequency in kilohertz."]
-    pub const hipDeviceAttributeClockRate: hipDeviceAttribute_t = hipDeviceAttribute_t(5);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Compute mode that device is currently in."]
-    pub const hipDeviceAttributeComputeMode: hipDeviceAttribute_t = hipDeviceAttribute_t(6);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Device supports Compute Preemption."]
-    pub const hipDeviceAttributeComputePreemptionSupported: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(7);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device can possibly execute multiple kernels concurrently."]
-    pub const hipDeviceAttributeConcurrentKernels: hipDeviceAttribute_t = hipDeviceAttribute_t(8);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device can coherently access managed memory concurrently with the CPU"]
-    pub const hipDeviceAttributeConcurrentManagedAccess: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(9);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Support cooperative launch"]
-    pub const hipDeviceAttributeCooperativeLaunch: hipDeviceAttribute_t = hipDeviceAttribute_t(10);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Support cooperative launch on multiple devices"]
-    pub const hipDeviceAttributeCooperativeMultiDeviceLaunch: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(11);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Device can concurrently copy memory and execute a kernel."]
-    #[doc = "< Deprecated. Use instead asyncEngineCount."]
-    pub const hipDeviceAttributeDeviceOverlap: hipDeviceAttribute_t = hipDeviceAttribute_t(12);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Host can directly access managed memory on"]
-    #[doc = "< the device without migration"]
-    pub const hipDeviceAttributeDirectManagedMemAccessFromHost: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(13);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Device supports caching globals in L1"]
-    pub const hipDeviceAttributeGlobalL1CacheSupported: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(14);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Link between the device and the host supports native atomic operations"]
-    pub const hipDeviceAttributeHostNativeAtomicSupported: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(15);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device is integrated GPU"]
-    pub const hipDeviceAttributeIntegrated: hipDeviceAttribute_t = hipDeviceAttribute_t(16);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Multiple GPU devices."]
-    pub const hipDeviceAttributeIsMultiGpuBoard: hipDeviceAttribute_t = hipDeviceAttribute_t(17);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Run time limit for kernels executed on the device"]
-    pub const hipDeviceAttributeKernelExecTimeout: hipDeviceAttribute_t = hipDeviceAttribute_t(18);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Size of L2 cache in bytes. 0 if the device doesn't have L2 cache."]
-    pub const hipDeviceAttributeL2CacheSize: hipDeviceAttribute_t = hipDeviceAttribute_t(19);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< caching locals in L1 is supported"]
-    pub const hipDeviceAttributeLocalL1CacheSupported: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(20);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms"]
-    pub const hipDeviceAttributeLuid: hipDeviceAttribute_t = hipDeviceAttribute_t(21);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Luid device node mask. Undefined on TCC and non-Windows platforms"]
-    pub const hipDeviceAttributeLuidDeviceNodeMask: hipDeviceAttribute_t = hipDeviceAttribute_t(22);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Major compute capability version number."]
-    pub const hipDeviceAttributeComputeCapabilityMajor: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(23);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device supports allocating managed memory on this system"]
-    pub const hipDeviceAttributeManagedMemory: hipDeviceAttribute_t = hipDeviceAttribute_t(24);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Max block size per multiprocessor"]
-    pub const hipDeviceAttributeMaxBlocksPerMultiProcessor: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(25);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Max block size in width."]
-    pub const hipDeviceAttributeMaxBlockDimX: hipDeviceAttribute_t = hipDeviceAttribute_t(26);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Max block size in height."]
-    pub const hipDeviceAttributeMaxBlockDimY: hipDeviceAttribute_t = hipDeviceAttribute_t(27);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Max block size in depth."]
-    pub const hipDeviceAttributeMaxBlockDimZ: hipDeviceAttribute_t = hipDeviceAttribute_t(28);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Max grid size  in width."]
-    pub const hipDeviceAttributeMaxGridDimX: hipDeviceAttribute_t = hipDeviceAttribute_t(29);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Max grid size  in height."]
-    pub const hipDeviceAttributeMaxGridDimY: hipDeviceAttribute_t = hipDeviceAttribute_t(30);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Max grid size  in depth."]
-    pub const hipDeviceAttributeMaxGridDimZ: hipDeviceAttribute_t = hipDeviceAttribute_t(31);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum size of 1D surface."]
-    pub const hipDeviceAttributeMaxSurface1D: hipDeviceAttribute_t = hipDeviceAttribute_t(32);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of 1D layered surface."]
-    pub const hipDeviceAttributeMaxSurface1DLayered: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(33);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension (width, height) of 2D surface."]
-    pub const hipDeviceAttributeMaxSurface2D: hipDeviceAttribute_t = hipDeviceAttribute_t(34);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of 2D layered surface."]
-    pub const hipDeviceAttributeMaxSurface2DLayered: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(35);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension (width, height, depth) of 3D surface."]
-    pub const hipDeviceAttributeMaxSurface3D: hipDeviceAttribute_t = hipDeviceAttribute_t(36);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of Cubemap surface."]
-    pub const hipDeviceAttributeMaxSurfaceCubemap: hipDeviceAttribute_t = hipDeviceAttribute_t(37);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimension of Cubemap layered surface."]
-    pub const hipDeviceAttributeMaxSurfaceCubemapLayered: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(38);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum size of 1D texture."]
-    pub const hipDeviceAttributeMaxTexture1DWidth: hipDeviceAttribute_t = hipDeviceAttribute_t(39);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of 1D layered texture."]
-    pub const hipDeviceAttributeMaxTexture1DLayered: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(40);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum number of elements allocatable in a 1D linear texture."]
-    #[doc = "< Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda."]
-    pub const hipDeviceAttributeMaxTexture1DLinear: hipDeviceAttribute_t = hipDeviceAttribute_t(41);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum size of 1D mipmapped texture."]
-    pub const hipDeviceAttributeMaxTexture1DMipmap: hipDeviceAttribute_t = hipDeviceAttribute_t(42);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension width of 2D texture."]
-    pub const hipDeviceAttributeMaxTexture2DWidth: hipDeviceAttribute_t = hipDeviceAttribute_t(43);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension hight of 2D texture."]
-    pub const hipDeviceAttributeMaxTexture2DHeight: hipDeviceAttribute_t = hipDeviceAttribute_t(44);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of 2D texture if gather operations  performed."]
-    pub const hipDeviceAttributeMaxTexture2DGather: hipDeviceAttribute_t = hipDeviceAttribute_t(45);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of 2D layered texture."]
-    pub const hipDeviceAttributeMaxTexture2DLayered: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(46);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory."]
-    pub const hipDeviceAttributeMaxTexture2DLinear: hipDeviceAttribute_t = hipDeviceAttribute_t(47);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of 2D mipmapped texture."]
-    pub const hipDeviceAttributeMaxTexture2DMipmap: hipDeviceAttribute_t = hipDeviceAttribute_t(48);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension width of 3D texture."]
-    pub const hipDeviceAttributeMaxTexture3DWidth: hipDeviceAttribute_t = hipDeviceAttribute_t(49);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension height of 3D texture."]
-    pub const hipDeviceAttributeMaxTexture3DHeight: hipDeviceAttribute_t = hipDeviceAttribute_t(50);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension depth of 3D texture."]
-    pub const hipDeviceAttributeMaxTexture3DDepth: hipDeviceAttribute_t = hipDeviceAttribute_t(51);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of alternate 3D texture."]
-    pub const hipDeviceAttributeMaxTexture3DAlt: hipDeviceAttribute_t = hipDeviceAttribute_t(52);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of Cubemap texture"]
-    pub const hipDeviceAttributeMaxTextureCubemap: hipDeviceAttribute_t = hipDeviceAttribute_t(53);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum dimensions of Cubemap layered texture."]
-    pub const hipDeviceAttributeMaxTextureCubemapLayered: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(54);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum dimension of a block"]
-    pub const hipDeviceAttributeMaxThreadsDim: hipDeviceAttribute_t = hipDeviceAttribute_t(55);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum number of threads per block."]
-    pub const hipDeviceAttributeMaxThreadsPerBlock: hipDeviceAttribute_t = hipDeviceAttribute_t(56);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum resident threads per multiprocessor."]
-    pub const hipDeviceAttributeMaxThreadsPerMultiProcessor: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(57);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum pitch in bytes allowed by memory copies"]
-    pub const hipDeviceAttributeMaxPitch: hipDeviceAttribute_t = hipDeviceAttribute_t(58);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Global memory bus width in bits."]
-    pub const hipDeviceAttributeMemoryBusWidth: hipDeviceAttribute_t = hipDeviceAttribute_t(59);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Peak memory clock frequency in kilohertz."]
-    pub const hipDeviceAttributeMemoryClockRate: hipDeviceAttribute_t = hipDeviceAttribute_t(60);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Minor compute capability version number."]
-    pub const hipDeviceAttributeComputeCapabilityMinor: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(61);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Unique ID of device group on the same multi-GPU board"]
-    pub const hipDeviceAttributeMultiGpuBoardGroupID: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(62);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Number of multiprocessors on the device."]
-    pub const hipDeviceAttributeMultiprocessorCount: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(63);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device name."]
-    pub const hipDeviceAttributeName: hipDeviceAttribute_t = hipDeviceAttribute_t(64);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device supports coherently accessing pageable memory"]
-    #[doc = "< without calling hipHostRegister on it"]
-    pub const hipDeviceAttributePageableMemoryAccess: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(65);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device accesses pageable memory via the host's page tables"]
-    pub const hipDeviceAttributePageableMemoryAccessUsesHostPageTables: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(66);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< PCI Bus ID."]
-    pub const hipDeviceAttributePciBusId: hipDeviceAttribute_t = hipDeviceAttribute_t(67);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< PCI Device ID."]
-    pub const hipDeviceAttributePciDeviceId: hipDeviceAttribute_t = hipDeviceAttribute_t(68);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< PCI Domain ID."]
-    pub const hipDeviceAttributePciDomainID: hipDeviceAttribute_t = hipDeviceAttribute_t(69);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda11 only. Maximum l2 persisting lines capacity in bytes"]
-    pub const hipDeviceAttributePersistingL2CacheMaxSize: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(70);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< 32-bit registers available to a thread block. This number is shared"]
-    #[doc = "< by all thread blocks simultaneously resident on a multiprocessor."]
-    pub const hipDeviceAttributeMaxRegistersPerBlock: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(71);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< 32-bit registers available per block."]
-    pub const hipDeviceAttributeMaxRegistersPerMultiprocessor: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(72);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda11 only. Shared memory reserved by CUDA driver per block."]
-    pub const hipDeviceAttributeReservedSharedMemPerBlock: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(73);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum shared memory available per block in bytes."]
-    pub const hipDeviceAttributeMaxSharedMemoryPerBlock: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(74);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Maximum shared memory per block usable by special opt in."]
-    pub const hipDeviceAttributeSharedMemPerBlockOptin: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(75);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Shared memory available per multiprocessor."]
-    pub const hipDeviceAttributeSharedMemPerMultiprocessor: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(76);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Performance ratio of single precision to double precision."]
-    pub const hipDeviceAttributeSingleToDoublePrecisionPerfRatio: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(77);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Whether to support stream priorities."]
-    pub const hipDeviceAttributeStreamPrioritiesSupported: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(78);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Alignment requirement for surfaces"]
-    pub const hipDeviceAttributeSurfaceAlignment: hipDeviceAttribute_t = hipDeviceAttribute_t(79);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Whether device is a Tesla device using TCC driver"]
-    pub const hipDeviceAttributeTccDriver: hipDeviceAttribute_t = hipDeviceAttribute_t(80);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Alignment requirement for textures"]
-    pub const hipDeviceAttributeTextureAlignment: hipDeviceAttribute_t = hipDeviceAttribute_t(81);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Pitch alignment requirement for 2D texture references bound to pitched memory;"]
-    pub const hipDeviceAttributeTexturePitchAlignment: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(82);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Constant memory size in bytes."]
-    pub const hipDeviceAttributeTotalConstantMemory: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(83);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Global memory available on devicice."]
-    pub const hipDeviceAttributeTotalGlobalMem: hipDeviceAttribute_t = hipDeviceAttribute_t(84);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. An unified address space shared with the host."]
-    pub const hipDeviceAttributeUnifiedAddressing: hipDeviceAttribute_t = hipDeviceAttribute_t(85);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Cuda only. Unique ID in 16 byte."]
-    pub const hipDeviceAttributeUuid: hipDeviceAttribute_t = hipDeviceAttribute_t(86);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Warp size in threads."]
-    pub const hipDeviceAttributeWarpSize: hipDeviceAttribute_t = hipDeviceAttribute_t(87);
-}
-impl hipDeviceAttribute_t {
-    pub const hipDeviceAttributeCudaCompatibleEnd: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(9999);
-}
-impl hipDeviceAttribute_t {
-    pub const hipDeviceAttributeAmdSpecificBegin: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10000);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Frequency in khz of the timer used by the device-side \"clock*\""]
-    pub const hipDeviceAttributeClockInstructionRate: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10000);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device architecture"]
-    pub const hipDeviceAttributeArch: hipDeviceAttribute_t = hipDeviceAttribute_t(10001);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Maximum Shared Memory PerMultiprocessor."]
-    pub const hipDeviceAttributeMaxSharedMemoryPerMultiprocessor: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10002);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device gcn architecture"]
-    pub const hipDeviceAttributeGcnArch: hipDeviceAttribute_t = hipDeviceAttribute_t(10003);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Device gcnArch name in 256 bytes"]
-    pub const hipDeviceAttributeGcnArchName: hipDeviceAttribute_t = hipDeviceAttribute_t(10004);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register"]
-    pub const hipDeviceAttributeHdpMemFlushCntl: hipDeviceAttribute_t = hipDeviceAttribute_t(10005);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Address of the HDP_REG_COHERENCY_FLUSH_CNTL register"]
-    pub const hipDeviceAttributeHdpRegFlushCntl: hipDeviceAttribute_t = hipDeviceAttribute_t(10006);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Supports cooperative launch on multiple"]
-    #[doc = "< devices with unmatched functions"]
-    pub const hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10007);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Supports cooperative launch on multiple"]
-    #[doc = "< devices with unmatched grid dimensions"]
-    pub const hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10008);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Supports cooperative launch on multiple"]
-    #[doc = "< devices with unmatched block dimensions"]
-    pub const hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10009);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Supports cooperative launch on multiple"]
-    #[doc = "< devices with unmatched shared memories"]
-    pub const hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10010);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Whether it is LargeBar"]
-    pub const hipDeviceAttributeIsLargeBar: hipDeviceAttribute_t = hipDeviceAttribute_t(10011);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< Revision of the GPU in this device"]
-    pub const hipDeviceAttributeAsicRevision: hipDeviceAttribute_t = hipDeviceAttribute_t(10012);
-}
-impl hipDeviceAttribute_t {
-    #[doc = "< '1' if Device supports hipStreamWaitValue32() and"]
-    #[doc = "< hipStreamWaitValue64() , '0' otherwise."]
-    pub const hipDeviceAttributeCanUseStreamWaitValue: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(10013);
-}
-impl hipDeviceAttribute_t {
-    pub const hipDeviceAttributeAmdSpecificEnd: hipDeviceAttribute_t = hipDeviceAttribute_t(19999);
-}
-impl hipDeviceAttribute_t {
-    pub const hipDeviceAttributeVendorSpecificBegin: hipDeviceAttribute_t =
-        hipDeviceAttribute_t(20000);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipDeviceAttribute_t(pub ::std::os::raw::c_uint);
-impl hipComputeMode {
-    pub const hipComputeModeDefault: hipComputeMode = hipComputeMode(0);
-}
-impl hipComputeMode {
-    pub const hipComputeModeExclusive: hipComputeMode = hipComputeMode(1);
-}
-impl hipComputeMode {
-    pub const hipComputeModeProhibited: hipComputeMode = hipComputeMode(2);
-}
-impl hipComputeMode {
-    pub const hipComputeModeExclusiveProcess: hipComputeMode = hipComputeMode(3);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipComputeMode(pub ::std::os::raw::c_uint);
-pub type __uint32_t = ::std::os::raw::c_uint;
-pub type __uint64_t = ::std::os::raw::c_ulong;
-pub type hipDeviceptr_t = *mut ::std::os::raw::c_void;
-impl hipChannelFormatKind {
-    pub const hipChannelFormatKindSigned: hipChannelFormatKind = hipChannelFormatKind(0);
-}
-impl hipChannelFormatKind {
-    pub const hipChannelFormatKindUnsigned: hipChannelFormatKind = hipChannelFormatKind(1);
-}
-impl hipChannelFormatKind {
-    pub const hipChannelFormatKindFloat: hipChannelFormatKind = hipChannelFormatKind(2);
-}
-impl hipChannelFormatKind {
-    pub const hipChannelFormatKindNone: hipChannelFormatKind = hipChannelFormatKind(3);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipChannelFormatKind(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipChannelFormatDesc {
-    pub x: ::std::os::raw::c_int,
-    pub y: ::std::os::raw::c_int,
-    pub z: ::std::os::raw::c_int,
-    pub w: ::std::os::raw::c_int,
-    pub f: hipChannelFormatKind,
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_UNSIGNED_INT8: hipArray_Format = hipArray_Format(1);
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_UNSIGNED_INT16: hipArray_Format = hipArray_Format(2);
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_UNSIGNED_INT32: hipArray_Format = hipArray_Format(3);
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_SIGNED_INT8: hipArray_Format = hipArray_Format(8);
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_SIGNED_INT16: hipArray_Format = hipArray_Format(9);
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_SIGNED_INT32: hipArray_Format = hipArray_Format(10);
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_HALF: hipArray_Format = hipArray_Format(16);
-}
-impl hipArray_Format {
-    pub const HIP_AD_FORMAT_FLOAT: hipArray_Format = hipArray_Format(32);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipArray_Format(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_ARRAY_DESCRIPTOR {
-    pub Width: usize,
-    pub Height: usize,
-    pub Format: hipArray_Format,
-    pub NumChannels: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_ARRAY3D_DESCRIPTOR {
-    pub Width: usize,
-    pub Height: usize,
-    pub Depth: usize,
-    pub Format: hipArray_Format,
-    pub NumChannels: ::std::os::raw::c_uint,
-    pub Flags: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipArray {
-    pub data: *mut ::std::os::raw::c_void,
-    pub desc: hipChannelFormatDesc,
-    pub type_: ::std::os::raw::c_uint,
-    pub width: ::std::os::raw::c_uint,
-    pub height: ::std::os::raw::c_uint,
-    pub depth: ::std::os::raw::c_uint,
-    pub Format: hipArray_Format,
-    pub NumChannels: ::std::os::raw::c_uint,
-    pub isDrv: bool,
-    pub textureType: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hip_Memcpy2D {
-    pub srcXInBytes: usize,
-    pub srcY: usize,
-    pub srcMemoryType: hipMemoryType,
-    pub srcHost: *const ::std::os::raw::c_void,
-    pub srcDevice: hipDeviceptr_t,
-    pub srcArray: *mut hipArray,
-    pub srcPitch: usize,
-    pub dstXInBytes: usize,
-    pub dstY: usize,
-    pub dstMemoryType: hipMemoryType,
-    pub dstHost: *mut ::std::os::raw::c_void,
-    pub dstDevice: hipDeviceptr_t,
-    pub dstArray: *mut hipArray,
-    pub dstPitch: usize,
-    pub WidthInBytes: usize,
-    pub Height: usize,
-}
-pub type hipArray_t = *mut hipArray;
-pub type hiparray = hipArray_t;
-pub type hipArray_const_t = *const hipArray;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipMipmappedArray {
-    pub data: *mut ::std::os::raw::c_void,
-    pub desc: hipChannelFormatDesc,
-    pub type_: ::std::os::raw::c_uint,
-    pub width: ::std::os::raw::c_uint,
-    pub height: ::std::os::raw::c_uint,
-    pub depth: ::std::os::raw::c_uint,
-    pub min_mipmap_level: ::std::os::raw::c_uint,
-    pub max_mipmap_level: ::std::os::raw::c_uint,
-    pub flags: ::std::os::raw::c_uint,
-    pub format: hipArray_Format,
-}
-pub type hipMipmappedArray_t = *mut hipMipmappedArray;
-pub type hipMipmappedArray_const_t = *const hipMipmappedArray;
-impl hipResourceType {
-    pub const hipResourceTypeArray: hipResourceType = hipResourceType(0);
-}
-impl hipResourceType {
-    pub const hipResourceTypeMipmappedArray: hipResourceType = hipResourceType(1);
-}
-impl hipResourceType {
-    pub const hipResourceTypeLinear: hipResourceType = hipResourceType(2);
-}
-impl hipResourceType {
-    pub const hipResourceTypePitch2D: hipResourceType = hipResourceType(3);
-}
-#[repr(transparent)]
-#[doc = " hip resource types"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipResourceType(pub ::std::os::raw::c_uint);
-impl HIPresourcetype_enum {
-    #[doc = "< Array resoure"]
-    pub const HIP_RESOURCE_TYPE_ARRAY: HIPresourcetype_enum = HIPresourcetype_enum(0);
-}
-impl HIPresourcetype_enum {
-    #[doc = "< Mipmapped array resource"]
-    pub const HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY: HIPresourcetype_enum = HIPresourcetype_enum(1);
-}
-impl HIPresourcetype_enum {
-    #[doc = "< Linear resource"]
-    pub const HIP_RESOURCE_TYPE_LINEAR: HIPresourcetype_enum = HIPresourcetype_enum(2);
-}
-impl HIPresourcetype_enum {
-    #[doc = "< Pitch 2D resource"]
-    pub const HIP_RESOURCE_TYPE_PITCH2D: HIPresourcetype_enum = HIPresourcetype_enum(3);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct HIPresourcetype_enum(pub ::std::os::raw::c_uint);
-pub use self::HIPresourcetype_enum as HIPresourcetype;
-impl HIPaddress_mode_enum {
-    pub const HIP_TR_ADDRESS_MODE_WRAP: HIPaddress_mode_enum = HIPaddress_mode_enum(0);
-}
-impl HIPaddress_mode_enum {
-    pub const HIP_TR_ADDRESS_MODE_CLAMP: HIPaddress_mode_enum = HIPaddress_mode_enum(1);
-}
-impl HIPaddress_mode_enum {
-    pub const HIP_TR_ADDRESS_MODE_MIRROR: HIPaddress_mode_enum = HIPaddress_mode_enum(2);
-}
-impl HIPaddress_mode_enum {
-    pub const HIP_TR_ADDRESS_MODE_BORDER: HIPaddress_mode_enum = HIPaddress_mode_enum(3);
-}
-#[repr(transparent)]
-#[doc = " hip address modes"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct HIPaddress_mode_enum(pub ::std::os::raw::c_uint);
-#[doc = " hip address modes"]
-pub use self::HIPaddress_mode_enum as HIPaddress_mode;
-impl HIPfilter_mode_enum {
-    pub const HIP_TR_FILTER_MODE_POINT: HIPfilter_mode_enum = HIPfilter_mode_enum(0);
-}
-impl HIPfilter_mode_enum {
-    pub const HIP_TR_FILTER_MODE_LINEAR: HIPfilter_mode_enum = HIPfilter_mode_enum(1);
-}
-#[repr(transparent)]
-#[doc = " hip filter modes"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct HIPfilter_mode_enum(pub ::std::os::raw::c_uint);
-#[doc = " hip filter modes"]
-pub use self::HIPfilter_mode_enum as HIPfilter_mode;
-#[doc = " Texture descriptor"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_TEXTURE_DESC_st {
-    #[doc = "< Address modes"]
-    pub addressMode: [HIPaddress_mode; 3usize],
-    #[doc = "< Filter mode"]
-    pub filterMode: HIPfilter_mode,
-    #[doc = "< Flags"]
-    pub flags: ::std::os::raw::c_uint,
-    #[doc = "< Maximum anisotropy ratio"]
-    pub maxAnisotropy: ::std::os::raw::c_uint,
-    #[doc = "< Mipmap filter mode"]
-    pub mipmapFilterMode: HIPfilter_mode,
-    #[doc = "< Mipmap level bias"]
-    pub mipmapLevelBias: f32,
-    #[doc = "< Mipmap minimum level clamp"]
-    pub minMipmapLevelClamp: f32,
-    #[doc = "< Mipmap maximum level clamp"]
-    pub maxMipmapLevelClamp: f32,
-    #[doc = "< Border Color"]
-    pub borderColor: [f32; 4usize],
-    pub reserved: [::std::os::raw::c_int; 12usize],
-}
-#[doc = " Texture descriptor"]
-pub type HIP_TEXTURE_DESC = HIP_TEXTURE_DESC_st;
-impl hipResourceViewFormat {
-    pub const hipResViewFormatNone: hipResourceViewFormat = hipResourceViewFormat(0);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedChar1: hipResourceViewFormat = hipResourceViewFormat(1);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedChar2: hipResourceViewFormat = hipResourceViewFormat(2);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedChar4: hipResourceViewFormat = hipResourceViewFormat(3);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedChar1: hipResourceViewFormat = hipResourceViewFormat(4);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedChar2: hipResourceViewFormat = hipResourceViewFormat(5);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedChar4: hipResourceViewFormat = hipResourceViewFormat(6);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedShort1: hipResourceViewFormat = hipResourceViewFormat(7);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedShort2: hipResourceViewFormat = hipResourceViewFormat(8);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedShort4: hipResourceViewFormat = hipResourceViewFormat(9);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedShort1: hipResourceViewFormat = hipResourceViewFormat(10);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedShort2: hipResourceViewFormat = hipResourceViewFormat(11);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedShort4: hipResourceViewFormat = hipResourceViewFormat(12);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedInt1: hipResourceViewFormat = hipResourceViewFormat(13);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedInt2: hipResourceViewFormat = hipResourceViewFormat(14);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedInt4: hipResourceViewFormat = hipResourceViewFormat(15);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedInt1: hipResourceViewFormat = hipResourceViewFormat(16);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedInt2: hipResourceViewFormat = hipResourceViewFormat(17);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedInt4: hipResourceViewFormat = hipResourceViewFormat(18);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatHalf1: hipResourceViewFormat = hipResourceViewFormat(19);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatHalf2: hipResourceViewFormat = hipResourceViewFormat(20);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatHalf4: hipResourceViewFormat = hipResourceViewFormat(21);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatFloat1: hipResourceViewFormat = hipResourceViewFormat(22);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatFloat2: hipResourceViewFormat = hipResourceViewFormat(23);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatFloat4: hipResourceViewFormat = hipResourceViewFormat(24);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedBlockCompressed1: hipResourceViewFormat =
-        hipResourceViewFormat(25);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedBlockCompressed2: hipResourceViewFormat =
-        hipResourceViewFormat(26);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedBlockCompressed3: hipResourceViewFormat =
-        hipResourceViewFormat(27);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedBlockCompressed4: hipResourceViewFormat =
-        hipResourceViewFormat(28);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedBlockCompressed4: hipResourceViewFormat =
-        hipResourceViewFormat(29);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedBlockCompressed5: hipResourceViewFormat =
-        hipResourceViewFormat(30);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedBlockCompressed5: hipResourceViewFormat =
-        hipResourceViewFormat(31);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedBlockCompressed6H: hipResourceViewFormat =
-        hipResourceViewFormat(32);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatSignedBlockCompressed6H: hipResourceViewFormat =
-        hipResourceViewFormat(33);
-}
-impl hipResourceViewFormat {
-    pub const hipResViewFormatUnsignedBlockCompressed7: hipResourceViewFormat =
-        hipResourceViewFormat(34);
-}
-#[repr(transparent)]
-#[doc = " hip texture resource view formats"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipResourceViewFormat(pub ::std::os::raw::c_uint);
-impl HIPresourceViewFormat_enum {
-    #[doc = "< No resource view format (use underlying resource format)"]
-    pub const HIP_RES_VIEW_FORMAT_NONE: HIPresourceViewFormat_enum = HIPresourceViewFormat_enum(0);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel unsigned 8-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_1X8: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(1);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel unsigned 8-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_2X8: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(2);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel unsigned 8-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_4X8: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(3);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel signed 8-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_1X8: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(4);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel signed 8-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_2X8: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(5);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel signed 8-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_4X8: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(6);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel unsigned 16-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_1X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(7);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel unsigned 16-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_2X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(8);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel unsigned 16-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_4X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(9);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel signed 16-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_1X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(10);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel signed 16-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_2X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(11);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel signed 16-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_4X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(12);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel unsigned 32-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_1X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(13);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel unsigned 32-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_2X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(14);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel unsigned 32-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_UINT_4X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(15);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel signed 32-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_1X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(16);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel signed 32-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_2X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(17);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel signed 32-bit integers"]
-    pub const HIP_RES_VIEW_FORMAT_SINT_4X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(18);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel 16-bit floating point"]
-    pub const HIP_RES_VIEW_FORMAT_FLOAT_1X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(19);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel 16-bit floating point"]
-    pub const HIP_RES_VIEW_FORMAT_FLOAT_2X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(20);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel 16-bit floating point"]
-    pub const HIP_RES_VIEW_FORMAT_FLOAT_4X16: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(21);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 1 channel 32-bit floating point"]
-    pub const HIP_RES_VIEW_FORMAT_FLOAT_1X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(22);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 2 channel 32-bit floating point"]
-    pub const HIP_RES_VIEW_FORMAT_FLOAT_2X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(23);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< 4 channel 32-bit floating point"]
-    pub const HIP_RES_VIEW_FORMAT_FLOAT_4X32: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(24);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 1"]
-    pub const HIP_RES_VIEW_FORMAT_UNSIGNED_BC1: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(25);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 2"]
-    pub const HIP_RES_VIEW_FORMAT_UNSIGNED_BC2: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(26);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 3"]
-    pub const HIP_RES_VIEW_FORMAT_UNSIGNED_BC3: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(27);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 4 unsigned"]
-    pub const HIP_RES_VIEW_FORMAT_UNSIGNED_BC4: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(28);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 4 signed"]
-    pub const HIP_RES_VIEW_FORMAT_SIGNED_BC4: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(29);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 5 unsigned"]
-    pub const HIP_RES_VIEW_FORMAT_UNSIGNED_BC5: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(30);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 5 signed"]
-    pub const HIP_RES_VIEW_FORMAT_SIGNED_BC5: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(31);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 6 unsigned half-float"]
-    pub const HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(32);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 6 signed half-float"]
-    pub const HIP_RES_VIEW_FORMAT_SIGNED_BC6H: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(33);
-}
-impl HIPresourceViewFormat_enum {
-    #[doc = "< Block compressed 7"]
-    pub const HIP_RES_VIEW_FORMAT_UNSIGNED_BC7: HIPresourceViewFormat_enum =
-        HIPresourceViewFormat_enum(34);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct HIPresourceViewFormat_enum(pub ::std::os::raw::c_uint);
-pub use self::HIPresourceViewFormat_enum as HIPresourceViewFormat;
-#[doc = " HIP resource descriptor"]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct hipResourceDesc {
-    pub resType: hipResourceType,
-    pub res: hipResourceDesc__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union hipResourceDesc__bindgen_ty_1 {
-    pub array: hipResourceDesc__bindgen_ty_1__bindgen_ty_1,
-    pub mipmap: hipResourceDesc__bindgen_ty_1__bindgen_ty_2,
-    pub linear: hipResourceDesc__bindgen_ty_1__bindgen_ty_3,
-    pub pitch2D: hipResourceDesc__bindgen_ty_1__bindgen_ty_4,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_1 {
-    pub array: hipArray_t,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_2 {
-    pub mipmap: hipMipmappedArray_t,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_3 {
-    pub devPtr: *mut ::std::os::raw::c_void,
-    pub desc: hipChannelFormatDesc,
-    pub sizeInBytes: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipResourceDesc__bindgen_ty_1__bindgen_ty_4 {
-    pub devPtr: *mut ::std::os::raw::c_void,
-    pub desc: hipChannelFormatDesc,
-    pub width: usize,
-    pub height: usize,
-    pub pitchInBytes: usize,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct HIP_RESOURCE_DESC_st {
-    #[doc = "< Resource type"]
-    pub resType: HIPresourcetype,
-    pub res: HIP_RESOURCE_DESC_st__bindgen_ty_1,
-    #[doc = "< Flags (must be zero)"]
-    pub flags: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union HIP_RESOURCE_DESC_st__bindgen_ty_1 {
-    pub array: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1,
-    pub mipmap: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2,
-    pub linear: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
-    pub pitch2D: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
-    pub reserved: HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
-    #[doc = "< HIP array"]
-    pub hArray: hipArray_t,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
-    #[doc = "< HIP mipmapped array"]
-    pub hMipmappedArray: hipMipmappedArray_t,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
-    #[doc = "< Device pointer"]
-    pub devPtr: hipDeviceptr_t,
-    #[doc = "< Array format"]
-    pub format: hipArray_Format,
-    #[doc = "< Channels per array element"]
-    pub numChannels: ::std::os::raw::c_uint,
-    #[doc = "< Size in bytes"]
-    pub sizeInBytes: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
-    #[doc = "< Device pointer"]
-    pub devPtr: hipDeviceptr_t,
-    #[doc = "< Array format"]
-    pub format: hipArray_Format,
-    #[doc = "< Channels per array element"]
-    pub numChannels: ::std::os::raw::c_uint,
-    #[doc = "< Width of the array in elements"]
-    pub width: usize,
-    #[doc = "< Height of the array in elements"]
-    pub height: usize,
-    #[doc = "< Pitch between two rows in bytes"]
-    pub pitchInBytes: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
-    pub reserved: [::std::os::raw::c_int; 32usize],
-}
-pub type HIP_RESOURCE_DESC = HIP_RESOURCE_DESC_st;
-#[doc = " hip resource view descriptor"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipResourceViewDesc {
-    pub format: hipResourceViewFormat,
-    pub width: usize,
-    pub height: usize,
-    pub depth: usize,
-    pub firstMipmapLevel: ::std::os::raw::c_uint,
-    pub lastMipmapLevel: ::std::os::raw::c_uint,
-    pub firstLayer: ::std::os::raw::c_uint,
-    pub lastLayer: ::std::os::raw::c_uint,
-}
-#[doc = " Resource view descriptor"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_RESOURCE_VIEW_DESC_st {
-    #[doc = "< Resource view format"]
-    pub format: HIPresourceViewFormat,
-    #[doc = "< Width of the resource view"]
-    pub width: usize,
-    #[doc = "< Height of the resource view"]
-    pub height: usize,
-    #[doc = "< Depth of the resource view"]
-    pub depth: usize,
-    #[doc = "< First defined mipmap level"]
-    pub firstMipmapLevel: ::std::os::raw::c_uint,
-    #[doc = "< Last defined mipmap level"]
-    pub lastMipmapLevel: ::std::os::raw::c_uint,
-    #[doc = "< First layer index"]
-    pub firstLayer: ::std::os::raw::c_uint,
-    #[doc = "< Last layer index"]
-    pub lastLayer: ::std::os::raw::c_uint,
-    pub reserved: [::std::os::raw::c_uint; 16usize],
-}
-#[doc = " Resource view descriptor"]
-pub type HIP_RESOURCE_VIEW_DESC = HIP_RESOURCE_VIEW_DESC_st;
-impl hipMemcpyKind {
-    #[doc = "< Host-to-Host Copy"]
-    pub const hipMemcpyHostToHost: hipMemcpyKind = hipMemcpyKind(0);
-}
-impl hipMemcpyKind {
-    #[doc = "< Host-to-Device Copy"]
-    pub const hipMemcpyHostToDevice: hipMemcpyKind = hipMemcpyKind(1);
-}
-impl hipMemcpyKind {
-    #[doc = "< Device-to-Host Copy"]
-    pub const hipMemcpyDeviceToHost: hipMemcpyKind = hipMemcpyKind(2);
-}
-impl hipMemcpyKind {
-    #[doc = "< Device-to-Device Copy"]
-    pub const hipMemcpyDeviceToDevice: hipMemcpyKind = hipMemcpyKind(3);
-}
-impl hipMemcpyKind {
-    pub const hipMemcpyDefault: hipMemcpyKind = hipMemcpyKind(4);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipMemcpyKind(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipPitchedPtr {
-    pub ptr: *mut ::std::os::raw::c_void,
-    pub pitch: usize,
-    pub xsize: usize,
-    pub ysize: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExtent {
-    pub width: usize,
-    pub height: usize,
-    pub depth: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipPos {
-    pub x: usize,
-    pub y: usize,
-    pub z: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipMemcpy3DParms {
-    pub srcArray: hipArray_t,
-    pub srcPos: hipPos,
-    pub srcPtr: hipPitchedPtr,
-    pub dstArray: hipArray_t,
-    pub dstPos: hipPos,
-    pub dstPtr: hipPitchedPtr,
-    pub extent: hipExtent,
-    pub kind: hipMemcpyKind,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct HIP_MEMCPY3D {
-    pub srcXInBytes: ::std::os::raw::c_uint,
-    pub srcY: ::std::os::raw::c_uint,
-    pub srcZ: ::std::os::raw::c_uint,
-    pub srcLOD: ::std::os::raw::c_uint,
-    pub srcMemoryType: hipMemoryType,
-    pub srcHost: *const ::std::os::raw::c_void,
-    pub srcDevice: hipDeviceptr_t,
-    pub srcArray: hipArray_t,
-    pub srcPitch: ::std::os::raw::c_uint,
-    pub srcHeight: ::std::os::raw::c_uint,
-    pub dstXInBytes: ::std::os::raw::c_uint,
-    pub dstY: ::std::os::raw::c_uint,
-    pub dstZ: ::std::os::raw::c_uint,
-    pub dstLOD: ::std::os::raw::c_uint,
-    pub dstMemoryType: hipMemoryType,
-    pub dstHost: *mut ::std::os::raw::c_void,
-    pub dstDevice: hipDeviceptr_t,
-    pub dstArray: hipArray_t,
-    pub dstPitch: ::std::os::raw::c_uint,
-    pub dstHeight: ::std::os::raw::c_uint,
-    pub WidthInBytes: ::std::os::raw::c_uint,
-    pub Height: ::std::os::raw::c_uint,
-    pub Depth: ::std::os::raw::c_uint,
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK: hipFunction_attribute =
-        hipFunction_attribute(0);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES: hipFunction_attribute =
-        hipFunction_attribute(1);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES: hipFunction_attribute = hipFunction_attribute(2);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES: hipFunction_attribute = hipFunction_attribute(3);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_NUM_REGS: hipFunction_attribute = hipFunction_attribute(4);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_PTX_VERSION: hipFunction_attribute = hipFunction_attribute(5);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_BINARY_VERSION: hipFunction_attribute = hipFunction_attribute(6);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA: hipFunction_attribute = hipFunction_attribute(7);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES: hipFunction_attribute =
-        hipFunction_attribute(8);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT: hipFunction_attribute =
-        hipFunction_attribute(9);
-}
-impl hipFunction_attribute {
-    pub const HIP_FUNC_ATTRIBUTE_MAX: hipFunction_attribute = hipFunction_attribute(10);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipFunction_attribute(pub ::std::os::raw::c_uint);
-extern "C" {
-    pub fn hipCreateChannelDesc(
-        x: ::std::os::raw::c_int,
-        y: ::std::os::raw::c_int,
-        z: ::std::os::raw::c_int,
-        w: ::std::os::raw::c_int,
-        f: hipChannelFormatKind,
-    ) -> hipChannelFormatDesc;
-}
-#[doc = " An opaque value that represents a hip texture object"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct __hip_texture {
-    _unused: [u8; 0],
-}
-pub type hipTextureObject_t = *mut __hip_texture;
-impl hipTextureAddressMode {
-    pub const hipAddressModeWrap: hipTextureAddressMode = hipTextureAddressMode(0);
-}
-impl hipTextureAddressMode {
-    pub const hipAddressModeClamp: hipTextureAddressMode = hipTextureAddressMode(1);
-}
-impl hipTextureAddressMode {
-    pub const hipAddressModeMirror: hipTextureAddressMode = hipTextureAddressMode(2);
-}
-impl hipTextureAddressMode {
-    pub const hipAddressModeBorder: hipTextureAddressMode = hipTextureAddressMode(3);
-}
-#[repr(transparent)]
-#[doc = " hip texture address modes"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipTextureAddressMode(pub ::std::os::raw::c_uint);
-impl hipTextureFilterMode {
-    pub const hipFilterModePoint: hipTextureFilterMode = hipTextureFilterMode(0);
-}
-impl hipTextureFilterMode {
-    pub const hipFilterModeLinear: hipTextureFilterMode = hipTextureFilterMode(1);
-}
-#[repr(transparent)]
-#[doc = " hip texture filter modes"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipTextureFilterMode(pub ::std::os::raw::c_uint);
-impl hipTextureReadMode {
-    pub const hipReadModeElementType: hipTextureReadMode = hipTextureReadMode(0);
-}
-impl hipTextureReadMode {
-    pub const hipReadModeNormalizedFloat: hipTextureReadMode = hipTextureReadMode(1);
-}
-#[repr(transparent)]
-#[doc = " hip texture read modes"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipTextureReadMode(pub ::std::os::raw::c_uint);
-#[doc = " hip texture reference"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct textureReference {
-    pub normalized: ::std::os::raw::c_int,
-    pub readMode: hipTextureReadMode,
-    pub filterMode: hipTextureFilterMode,
-    pub addressMode: [hipTextureAddressMode; 3usize],
-    pub channelDesc: hipChannelFormatDesc,
-    pub sRGB: ::std::os::raw::c_int,
-    pub maxAnisotropy: ::std::os::raw::c_uint,
-    pub mipmapFilterMode: hipTextureFilterMode,
-    pub mipmapLevelBias: f32,
-    pub minMipmapLevelClamp: f32,
-    pub maxMipmapLevelClamp: f32,
-    pub textureObject: hipTextureObject_t,
-    pub numChannels: ::std::os::raw::c_int,
-    pub format: hipArray_Format,
-}
-#[doc = " hip texture descriptor"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipTextureDesc {
-    pub addressMode: [hipTextureAddressMode; 3usize],
-    pub filterMode: hipTextureFilterMode,
-    pub readMode: hipTextureReadMode,
-    pub sRGB: ::std::os::raw::c_int,
-    pub borderColor: [f32; 4usize],
-    pub normalizedCoords: ::std::os::raw::c_int,
-    pub maxAnisotropy: ::std::os::raw::c_uint,
-    pub mipmapFilterMode: hipTextureFilterMode,
-    pub mipmapLevelBias: f32,
-    pub minMipmapLevelClamp: f32,
-    pub maxMipmapLevelClamp: f32,
-}
-#[doc = " An opaque value that represents a hip surface object"]
-pub type hipSurfaceObject_t = ::std::os::raw::c_ulonglong;
-impl hipSurfaceBoundaryMode {
-    pub const hipBoundaryModeZero: hipSurfaceBoundaryMode = hipSurfaceBoundaryMode(0);
-}
-impl hipSurfaceBoundaryMode {
-    pub const hipBoundaryModeTrap: hipSurfaceBoundaryMode = hipSurfaceBoundaryMode(1);
-}
-impl hipSurfaceBoundaryMode {
-    pub const hipBoundaryModeClamp: hipSurfaceBoundaryMode = hipSurfaceBoundaryMode(2);
-}
-#[repr(transparent)]
-#[doc = " hip surface boundary modes"]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipSurfaceBoundaryMode(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ihipCtx_t {
-    _unused: [u8; 0],
-}
-pub type hipCtx_t = *mut ihipCtx_t;
-pub type hipDevice_t = ::std::os::raw::c_int;
-impl hipDeviceP2PAttr {
-    pub const hipDevP2PAttrPerformanceRank: hipDeviceP2PAttr = hipDeviceP2PAttr(0);
-}
-impl hipDeviceP2PAttr {
-    pub const hipDevP2PAttrAccessSupported: hipDeviceP2PAttr = hipDeviceP2PAttr(1);
-}
-impl hipDeviceP2PAttr {
-    pub const hipDevP2PAttrNativeAtomicSupported: hipDeviceP2PAttr = hipDeviceP2PAttr(2);
-}
-impl hipDeviceP2PAttr {
-    pub const hipDevP2PAttrHipArrayAccessSupported: hipDeviceP2PAttr = hipDeviceP2PAttr(3);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipDeviceP2PAttr(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ihipStream_t {
-    _unused: [u8; 0],
-}
-pub type hipStream_t = *mut ihipStream_t;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipIpcMemHandle_st {
-    pub reserved: [::std::os::raw::c_char; 64usize],
-}
-pub type hipIpcMemHandle_t = hipIpcMemHandle_st;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipIpcEventHandle_st {
-    pub reserved: [::std::os::raw::c_char; 64usize],
-}
-pub type hipIpcEventHandle_t = hipIpcEventHandle_st;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ihipModule_t {
-    _unused: [u8; 0],
-}
-pub type hipModule_t = *mut ihipModule_t;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ihipModuleSymbol_t {
-    _unused: [u8; 0],
-}
-pub type hipFunction_t = *mut ihipModuleSymbol_t;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipFuncAttributes {
-    pub binaryVersion: ::std::os::raw::c_int,
-    pub cacheModeCA: ::std::os::raw::c_int,
-    pub constSizeBytes: usize,
-    pub localSizeBytes: usize,
-    pub maxDynamicSharedSizeBytes: ::std::os::raw::c_int,
-    pub maxThreadsPerBlock: ::std::os::raw::c_int,
-    pub numRegs: ::std::os::raw::c_int,
-    pub preferredShmemCarveout: ::std::os::raw::c_int,
-    pub ptxVersion: ::std::os::raw::c_int,
-    pub sharedSizeBytes: usize,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ihipEvent_t {
-    _unused: [u8; 0],
-}
-pub type hipEvent_t = *mut ihipEvent_t;
-impl hipLimit_t {
-    pub const hipLimitPrintfFifoSize: hipLimit_t = hipLimit_t(1);
-}
-impl hipLimit_t {
-    pub const hipLimitMallocHeapSize: hipLimit_t = hipLimit_t(2);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipLimit_t(pub ::std::os::raw::c_uint);
-impl hipMemoryAdvise {
-    #[doc = "< Data will mostly be read and only occassionally"]
-    #[doc = "< be written to"]
-    pub const hipMemAdviseSetReadMostly: hipMemoryAdvise = hipMemoryAdvise(1);
-}
-impl hipMemoryAdvise {
-    #[doc = "< Undo the effect of hipMemAdviseSetReadMostly"]
-    pub const hipMemAdviseUnsetReadMostly: hipMemoryAdvise = hipMemoryAdvise(2);
-}
-impl hipMemoryAdvise {
-    #[doc = "< Set the preferred location for the data as"]
-    #[doc = "< the specified device"]
-    pub const hipMemAdviseSetPreferredLocation: hipMemoryAdvise = hipMemoryAdvise(3);
-}
-impl hipMemoryAdvise {
-    #[doc = "< Clear the preferred location for the data"]
-    pub const hipMemAdviseUnsetPreferredLocation: hipMemoryAdvise = hipMemoryAdvise(4);
-}
-impl hipMemoryAdvise {
-    #[doc = "< Data will be accessed by the specified device,"]
-    #[doc = "< so prevent page faults as much as possible"]
-    pub const hipMemAdviseSetAccessedBy: hipMemoryAdvise = hipMemoryAdvise(5);
-}
-impl hipMemoryAdvise {
-    #[doc = "< Let HIP to decide on the page faulting policy"]
-    #[doc = "< for the specified device"]
-    pub const hipMemAdviseUnsetAccessedBy: hipMemoryAdvise = hipMemoryAdvise(6);
-}
-impl hipMemoryAdvise {
-    #[doc = "< The default memory model is fine-grain. That allows"]
-    #[doc = "< coherent operations between host and device, while"]
-    #[doc = "< executing kernels. The coarse-grain can be used"]
-    #[doc = "< for data that only needs to be coherent at dispatch"]
-    #[doc = "< boundaries for better performance"]
-    pub const hipMemAdviseSetCoarseGrain: hipMemoryAdvise = hipMemoryAdvise(100);
-}
-impl hipMemoryAdvise {
-    #[doc = "< Restores cache coherency policy back to fine-grain"]
-    pub const hipMemAdviseUnsetCoarseGrain: hipMemoryAdvise = hipMemoryAdvise(101);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipMemoryAdvise(pub ::std::os::raw::c_uint);
-impl hipMemRangeCoherencyMode {
-    #[doc = "< Updates to memory with this attribute can be"]
-    #[doc = "< done coherently from all devices"]
-    pub const hipMemRangeCoherencyModeFineGrain: hipMemRangeCoherencyMode =
-        hipMemRangeCoherencyMode(0);
-}
-impl hipMemRangeCoherencyMode {
-    #[doc = "< Writes to memory with this attribute can be"]
-    #[doc = "< performed by a single device at a time"]
-    pub const hipMemRangeCoherencyModeCoarseGrain: hipMemRangeCoherencyMode =
-        hipMemRangeCoherencyMode(1);
-}
-impl hipMemRangeCoherencyMode {
-    #[doc = "< Memory region queried contains subregions with"]
-    #[doc = "< both hipMemRangeCoherencyModeFineGrain and"]
-    #[doc = "< hipMemRangeCoherencyModeCoarseGrain attributes"]
-    pub const hipMemRangeCoherencyModeIndeterminate: hipMemRangeCoherencyMode =
-        hipMemRangeCoherencyMode(2);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipMemRangeCoherencyMode(pub ::std::os::raw::c_uint);
-impl hipMemRangeAttribute {
-    #[doc = "< Whether the range will mostly be read and"]
-    #[doc = "< only occassionally be written to"]
-    pub const hipMemRangeAttributeReadMostly: hipMemRangeAttribute = hipMemRangeAttribute(1);
-}
-impl hipMemRangeAttribute {
-    #[doc = "< The preferred location of the range"]
-    pub const hipMemRangeAttributePreferredLocation: hipMemRangeAttribute = hipMemRangeAttribute(2);
-}
-impl hipMemRangeAttribute {
-    #[doc = "< Memory range has hipMemAdviseSetAccessedBy"]
-    #[doc = "< set for the specified device"]
-    pub const hipMemRangeAttributeAccessedBy: hipMemRangeAttribute = hipMemRangeAttribute(3);
-}
-impl hipMemRangeAttribute {
-    #[doc = "< The last location to where the range was"]
-    #[doc = "< prefetched"]
-    pub const hipMemRangeAttributeLastPrefetchLocation: hipMemRangeAttribute =
-        hipMemRangeAttribute(4);
-}
-impl hipMemRangeAttribute {
-    #[doc = "< Returns coherency mode"]
-    #[doc = "< @ref hipMemRangeCoherencyMode for the range"]
-    pub const hipMemRangeAttributeCoherencyMode: hipMemRangeAttribute = hipMemRangeAttribute(100);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipMemRangeAttribute(pub ::std::os::raw::c_uint);
-impl hipJitOption {
-    pub const hipJitOptionMaxRegisters: hipJitOption = hipJitOption(0);
-}
-impl hipJitOption {
-    pub const hipJitOptionThreadsPerBlock: hipJitOption = hipJitOption(1);
-}
-impl hipJitOption {
-    pub const hipJitOptionWallTime: hipJitOption = hipJitOption(2);
-}
-impl hipJitOption {
-    pub const hipJitOptionInfoLogBuffer: hipJitOption = hipJitOption(3);
-}
-impl hipJitOption {
-    pub const hipJitOptionInfoLogBufferSizeBytes: hipJitOption = hipJitOption(4);
-}
-impl hipJitOption {
-    pub const hipJitOptionErrorLogBuffer: hipJitOption = hipJitOption(5);
-}
-impl hipJitOption {
-    pub const hipJitOptionErrorLogBufferSizeBytes: hipJitOption = hipJitOption(6);
-}
-impl hipJitOption {
-    pub const hipJitOptionOptimizationLevel: hipJitOption = hipJitOption(7);
-}
-impl hipJitOption {
-    pub const hipJitOptionTargetFromContext: hipJitOption = hipJitOption(8);
-}
-impl hipJitOption {
-    pub const hipJitOptionTarget: hipJitOption = hipJitOption(9);
-}
-impl hipJitOption {
-    pub const hipJitOptionFallbackStrategy: hipJitOption = hipJitOption(10);
-}
-impl hipJitOption {
-    pub const hipJitOptionGenerateDebugInfo: hipJitOption = hipJitOption(11);
-}
-impl hipJitOption {
-    pub const hipJitOptionLogVerbose: hipJitOption = hipJitOption(12);
-}
-impl hipJitOption {
-    pub const hipJitOptionGenerateLineInfo: hipJitOption = hipJitOption(13);
-}
-impl hipJitOption {
-    pub const hipJitOptionCacheMode: hipJitOption = hipJitOption(14);
-}
-impl hipJitOption {
-    pub const hipJitOptionSm3xOpt: hipJitOption = hipJitOption(15);
-}
-impl hipJitOption {
-    pub const hipJitOptionFastCompile: hipJitOption = hipJitOption(16);
-}
-impl hipJitOption {
-    pub const hipJitOptionNumOptions: hipJitOption = hipJitOption(17);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipJitOption(pub ::std::os::raw::c_uint);
-impl hipFuncAttribute {
-    pub const hipFuncAttributeMaxDynamicSharedMemorySize: hipFuncAttribute = hipFuncAttribute(8);
-}
-impl hipFuncAttribute {
-    pub const hipFuncAttributePreferredSharedMemoryCarveout: hipFuncAttribute = hipFuncAttribute(9);
-}
-impl hipFuncAttribute {
-    pub const hipFuncAttributeMax: hipFuncAttribute = hipFuncAttribute(10);
-}
-#[repr(transparent)]
-#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipFuncAttribute(pub ::std::os::raw::c_uint);
-impl hipFuncCache_t {
-    #[doc = "< no preference for shared memory or L1 (default)"]
-    pub const hipFuncCachePreferNone: hipFuncCache_t = hipFuncCache_t(0);
-}
-impl hipFuncCache_t {
-    #[doc = "< prefer larger shared memory and smaller L1 cache"]
-    pub const hipFuncCachePreferShared: hipFuncCache_t = hipFuncCache_t(1);
-}
-impl hipFuncCache_t {
-    #[doc = "< prefer larger L1 cache and smaller shared memory"]
-    pub const hipFuncCachePreferL1: hipFuncCache_t = hipFuncCache_t(2);
-}
-impl hipFuncCache_t {
-    #[doc = "< prefer equal size L1 cache and shared memory"]
-    pub const hipFuncCachePreferEqual: hipFuncCache_t = hipFuncCache_t(3);
-}
-#[repr(transparent)]
-#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipFuncCache_t(pub ::std::os::raw::c_uint);
-impl hipSharedMemConfig {
-    #[doc = "< The compiler selects a device-specific value for the banking."]
-    pub const hipSharedMemBankSizeDefault: hipSharedMemConfig = hipSharedMemConfig(0);
-}
-impl hipSharedMemConfig {
-    #[doc = "< Shared mem is banked at 4-bytes intervals and performs best"]
-    #[doc = "< when adjacent threads access data 4 bytes apart."]
-    pub const hipSharedMemBankSizeFourByte: hipSharedMemConfig = hipSharedMemConfig(1);
-}
-impl hipSharedMemConfig {
-    #[doc = "< Shared mem is banked at 8-byte intervals and performs best"]
-    #[doc = "< when adjacent threads access data 4 bytes apart."]
-    pub const hipSharedMemBankSizeEightByte: hipSharedMemConfig = hipSharedMemConfig(2);
-}
-#[repr(transparent)]
-#[doc = " @warning On AMD devices and some Nvidia devices, these hints and controls are ignored."]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipSharedMemConfig(pub ::std::os::raw::c_uint);
-#[doc = " Struct for data in 3D"]
-#[doc = ""]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct dim3 {
-    #[doc = "< x"]
-    pub x: u32,
-    #[doc = "< y"]
-    pub y: u32,
-    #[doc = "< z"]
-    pub z: u32,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipLaunchParams_t {
-    #[doc = "< Device function symbol"]
-    pub func: *mut ::std::os::raw::c_void,
-    #[doc = "< Grid dimentions"]
-    pub gridDim: dim3,
-    #[doc = "< Block dimentions"]
-    pub blockDim: dim3,
-    #[doc = "< Arguments"]
-    pub args: *mut *mut ::std::os::raw::c_void,
-    #[doc = "< Shared memory"]
-    pub sharedMem: usize,
-    #[doc = "< Stream identifier"]
-    pub stream: hipStream_t,
-}
-pub type hipLaunchParams = hipLaunchParams_t;
-impl hipExternalMemoryHandleType_enum {
-    pub const hipExternalMemoryHandleTypeOpaqueFd: hipExternalMemoryHandleType_enum =
-        hipExternalMemoryHandleType_enum(1);
-}
-impl hipExternalMemoryHandleType_enum {
-    pub const hipExternalMemoryHandleTypeOpaqueWin32: hipExternalMemoryHandleType_enum =
-        hipExternalMemoryHandleType_enum(2);
-}
-impl hipExternalMemoryHandleType_enum {
-    pub const hipExternalMemoryHandleTypeOpaqueWin32Kmt: hipExternalMemoryHandleType_enum =
-        hipExternalMemoryHandleType_enum(3);
-}
-impl hipExternalMemoryHandleType_enum {
-    pub const hipExternalMemoryHandleTypeD3D12Heap: hipExternalMemoryHandleType_enum =
-        hipExternalMemoryHandleType_enum(4);
-}
-impl hipExternalMemoryHandleType_enum {
-    pub const hipExternalMemoryHandleTypeD3D12Resource: hipExternalMemoryHandleType_enum =
-        hipExternalMemoryHandleType_enum(5);
-}
-impl hipExternalMemoryHandleType_enum {
-    pub const hipExternalMemoryHandleTypeD3D11Resource: hipExternalMemoryHandleType_enum =
-        hipExternalMemoryHandleType_enum(6);
-}
-impl hipExternalMemoryHandleType_enum {
-    pub const hipExternalMemoryHandleTypeD3D11ResourceKmt: hipExternalMemoryHandleType_enum =
-        hipExternalMemoryHandleType_enum(7);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipExternalMemoryHandleType_enum(pub ::std::os::raw::c_uint);
-pub use self::hipExternalMemoryHandleType_enum as hipExternalMemoryHandleType;
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct hipExternalMemoryHandleDesc_st {
-    pub type_: hipExternalMemoryHandleType,
-    pub handle: hipExternalMemoryHandleDesc_st__bindgen_ty_1,
-    pub size: ::std::os::raw::c_ulonglong,
-    pub flags: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union hipExternalMemoryHandleDesc_st__bindgen_ty_1 {
-    pub fd: ::std::os::raw::c_int,
-    pub win32: hipExternalMemoryHandleDesc_st__bindgen_ty_1__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalMemoryHandleDesc_st__bindgen_ty_1__bindgen_ty_1 {
-    pub handle: *mut ::std::os::raw::c_void,
-    pub name: *const ::std::os::raw::c_void,
-}
-pub type hipExternalMemoryHandleDesc = hipExternalMemoryHandleDesc_st;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalMemoryBufferDesc_st {
-    pub offset: ::std::os::raw::c_ulonglong,
-    pub size: ::std::os::raw::c_ulonglong,
-    pub flags: ::std::os::raw::c_uint,
-}
-pub type hipExternalMemoryBufferDesc = hipExternalMemoryBufferDesc_st;
-pub type hipExternalMemory_t = *mut ::std::os::raw::c_void;
-impl hipExternalSemaphoreHandleType_enum {
-    pub const hipExternalSemaphoreHandleTypeOpaqueFd: hipExternalSemaphoreHandleType_enum =
-        hipExternalSemaphoreHandleType_enum(1);
-}
-impl hipExternalSemaphoreHandleType_enum {
-    pub const hipExternalSemaphoreHandleTypeOpaqueWin32: hipExternalSemaphoreHandleType_enum =
-        hipExternalSemaphoreHandleType_enum(2);
-}
-impl hipExternalSemaphoreHandleType_enum {
-    pub const hipExternalSemaphoreHandleTypeOpaqueWin32Kmt: hipExternalSemaphoreHandleType_enum =
-        hipExternalSemaphoreHandleType_enum(3);
-}
-impl hipExternalSemaphoreHandleType_enum {
-    pub const hipExternalSemaphoreHandleTypeD3D12Fence: hipExternalSemaphoreHandleType_enum =
-        hipExternalSemaphoreHandleType_enum(4);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipExternalSemaphoreHandleType_enum(pub ::std::os::raw::c_uint);
-pub use self::hipExternalSemaphoreHandleType_enum as hipExternalSemaphoreHandleType;
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct hipExternalSemaphoreHandleDesc_st {
-    pub type_: hipExternalSemaphoreHandleType,
-    pub handle: hipExternalSemaphoreHandleDesc_st__bindgen_ty_1,
-    pub flags: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union hipExternalSemaphoreHandleDesc_st__bindgen_ty_1 {
-    pub fd: ::std::os::raw::c_int,
-    pub win32: hipExternalSemaphoreHandleDesc_st__bindgen_ty_1__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreHandleDesc_st__bindgen_ty_1__bindgen_ty_1 {
-    pub handle: *mut ::std::os::raw::c_void,
-    pub name: *const ::std::os::raw::c_void,
-}
-pub type hipExternalSemaphoreHandleDesc = hipExternalSemaphoreHandleDesc_st;
-pub type hipExternalSemaphore_t = *mut ::std::os::raw::c_void;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreSignalParams_st {
-    pub params: hipExternalSemaphoreSignalParams_st__bindgen_ty_1,
-    pub flags: ::std::os::raw::c_uint,
-    pub reserved: [::std::os::raw::c_uint; 16usize],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1 {
-    pub fence: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_1,
-    pub keyedMutex: hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_2,
-    pub reserved: [::std::os::raw::c_uint; 12usize],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_1 {
-    pub value: ::std::os::raw::c_ulonglong,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreSignalParams_st__bindgen_ty_1__bindgen_ty_2 {
-    pub key: ::std::os::raw::c_ulonglong,
-}
-pub type hipExternalSemaphoreSignalParams = hipExternalSemaphoreSignalParams_st;
-#[doc = " External semaphore wait parameters, compatible with driver type"]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreWaitParams_st {
-    pub params: hipExternalSemaphoreWaitParams_st__bindgen_ty_1,
-    pub flags: ::std::os::raw::c_uint,
-    pub reserved: [::std::os::raw::c_uint; 16usize],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1 {
-    pub fence: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_1,
-    pub keyedMutex: hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_2,
-    pub reserved: [::std::os::raw::c_uint; 10usize],
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_1 {
-    pub value: ::std::os::raw::c_ulonglong,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipExternalSemaphoreWaitParams_st__bindgen_ty_1__bindgen_ty_2 {
-    pub key: ::std::os::raw::c_ulonglong,
-    pub timeoutMs: ::std::os::raw::c_uint,
-}
-#[doc = " External semaphore wait parameters, compatible with driver type"]
-pub type hipExternalSemaphoreWaitParams = hipExternalSemaphoreWaitParams_st;
-impl hipGLDeviceList {
-    #[doc = "< All hip devices used by current OpenGL context."]
-    pub const hipGLDeviceListAll: hipGLDeviceList = hipGLDeviceList(1);
-}
-impl hipGLDeviceList {
-    #[doc = "< Hip devices used by current OpenGL context in current"]
-    #[doc = "< frame"]
-    pub const hipGLDeviceListCurrentFrame: hipGLDeviceList = hipGLDeviceList(2);
-}
-impl hipGLDeviceList {
-    #[doc = "< Hip devices used by current OpenGL context in next"]
-    #[doc = "< frame."]
-    pub const hipGLDeviceListNextFrame: hipGLDeviceList = hipGLDeviceList(3);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipGLDeviceList(pub ::std::os::raw::c_uint);
-impl hipGraphicsRegisterFlags {
-    pub const hipGraphicsRegisterFlagsNone: hipGraphicsRegisterFlags = hipGraphicsRegisterFlags(0);
-}
-impl hipGraphicsRegisterFlags {
-    #[doc = "< HIP will not write to this registered resource"]
-    pub const hipGraphicsRegisterFlagsReadOnly: hipGraphicsRegisterFlags =
-        hipGraphicsRegisterFlags(1);
-}
-impl hipGraphicsRegisterFlags {
-    pub const hipGraphicsRegisterFlagsWriteDiscard: hipGraphicsRegisterFlags =
-        hipGraphicsRegisterFlags(2);
-}
-impl hipGraphicsRegisterFlags {
-    #[doc = "< HIP will bind this resource to a surface"]
-    pub const hipGraphicsRegisterFlagsSurfaceLoadStore: hipGraphicsRegisterFlags =
-        hipGraphicsRegisterFlags(4);
-}
-impl hipGraphicsRegisterFlags {
-    pub const hipGraphicsRegisterFlagsTextureGather: hipGraphicsRegisterFlags =
-        hipGraphicsRegisterFlags(8);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipGraphicsRegisterFlags(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct _hipGraphicsResource {
-    _unused: [u8; 0],
-}
-pub type hipGraphicsResource = _hipGraphicsResource;
-pub type hipGraphicsResource_t = *mut hipGraphicsResource;
-extern "C" {
-    #[doc = "  @defgroup API HIP API"]
-    #[doc = "  @{"]
-    #[doc = ""]
-    #[doc = "  Defines the HIP API.  See the individual sections for more information."]
-    #[doc = "  @defgroup Driver Initialization and Version"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the initializtion and version functions of HIP runtime API."]
-    #[doc = ""]
-    #[doc = " @brief Explicitly initializes the HIP runtime."]
-    #[doc = ""]
-    #[doc = " Most HIP APIs implicitly initialize the HIP runtime."]
-    #[doc = " This API provides control over the timing of the initialization."]
-    pub fn hipInit(flags: ::std::os::raw::c_uint) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns the approximate HIP driver version."]
-    #[doc = ""]
-    #[doc = " @param [out] driverVersion"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidValue"]
-    #[doc = ""]
-    #[doc = " @warning The HIP feature set does not correspond to an exact CUDA SDK driver revision."]
-    #[doc = " This function always set *driverVersion to 4 as an approximation though HIP supports"]
-    #[doc = " some features which were introduced in later CUDA SDK revisions."]
-    #[doc = " HIP apps code should not rely on the driver revision number here and should"]
-    #[doc = " use arch feature flags to test device capabilities or conditional compilation."]
-    #[doc = ""]
-    #[doc = " @see hipRuntimeGetVersion"]
-    pub fn hipDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns the approximate HIP Runtime version."]
-    #[doc = ""]
-    #[doc = " @param [out] runtimeVersion"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidValue"]
-    #[doc = ""]
-    #[doc = " @warning On HIP/HCC path this function returns HIP runtime patch version however on"]
-    #[doc = " HIP/NVCC path this function return CUDA runtime version."]
-    #[doc = ""]
-    #[doc = " @see hipDriverGetVersion"]
-    pub fn hipRuntimeGetVersion(runtimeVersion: *mut ::std::os::raw::c_int) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns a handle to a compute device"]
-    #[doc = " @param [out] device"]
-    #[doc = " @param [in] ordinal"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidDevice"]
-    pub fn hipDeviceGet(device: *mut hipDevice_t, ordinal: ::std::os::raw::c_int) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns the compute capability of the device"]
-    #[doc = " @param [out] major"]
-    #[doc = " @param [out] minor"]
-    #[doc = " @param [in] device"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidDevice"]
-    pub fn hipDeviceComputeCapability(
-        major: *mut ::std::os::raw::c_int,
-        minor: *mut ::std::os::raw::c_int,
-        device: hipDevice_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns an identifer string for the device."]
-    #[doc = " @param [out] name"]
-    #[doc = " @param [in] len"]
-    #[doc = " @param [in] device"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidDevice"]
-    pub fn hipDeviceGetName(
-        name: *mut ::std::os::raw::c_char,
-        len: ::std::os::raw::c_int,
-        device: hipDevice_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns a value for attr of link between two devices"]
-    #[doc = " @param [out] value"]
-    #[doc = " @param [in] attr"]
-    #[doc = " @param [in] srcDevice"]
-    #[doc = " @param [in] dstDevice"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidDevice"]
-    pub fn hipDeviceGetP2PAttribute(
-        value: *mut ::std::os::raw::c_int,
-        attr: hipDeviceP2PAttr,
-        srcDevice: ::std::os::raw::c_int,
-        dstDevice: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns a PCI Bus Id string for the device, overloaded to take int device ID."]
-    #[doc = " @param [out] pciBusId"]
-    #[doc = " @param [in] len"]
-    #[doc = " @param [in] device"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidDevice"]
-    pub fn hipDeviceGetPCIBusId(
-        pciBusId: *mut ::std::os::raw::c_char,
-        len: ::std::os::raw::c_int,
-        device: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns a handle to a compute device."]
-    #[doc = " @param [out] device handle"]
-    #[doc = " @param [in] PCI Bus ID"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidDevice, #hipErrorInvalidValue"]
-    pub fn hipDeviceGetByPCIBusId(
-        device: *mut ::std::os::raw::c_int,
-        pciBusId: *const ::std::os::raw::c_char,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns the total amount of memory on the device."]
-    #[doc = " @param [out] bytes"]
-    #[doc = " @param [in] device"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInavlidDevice"]
-    pub fn hipDeviceTotalMem(bytes: *mut usize, device: hipDevice_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "  @defgroup Device Device Management"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the device management functions of HIP runtime API."]
-    #[doc = " @brief Waits on all active streams on current device"]
-    #[doc = ""]
-    #[doc = " When this command is invoked, the host thread gets blocked until all the commands associated"]
-    #[doc = " with streams associated with the device. HIP does not support multiple blocking modes (yet!)."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipSetDevice, hipDeviceReset"]
-    pub fn hipDeviceSynchronize() -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief The state of current device is discarded and updated to a fresh state."]
-    #[doc = ""]
-    #[doc = " Calling this function deletes all streams created, memory allocated, kernels running, events"]
-    #[doc = " created. Make sure that no other thread is using the device or streams, memory, kernels, events"]
-    #[doc = " associated with the current device."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipDeviceSynchronize"]
-    pub fn hipDeviceReset() -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set default device to be used for subsequent hip API calls from this thread."]
-    #[doc = ""]
-    #[doc = " @param[in] deviceId Valid device in range 0...hipGetDeviceCount()."]
-    #[doc = ""]
-    #[doc = " Sets @p device as the default device for the calling host thread.  Valid device id's are 0..."]
-    #[doc = " (hipGetDeviceCount()-1)."]
-    #[doc = ""]
-    #[doc = " Many HIP APIs implicitly use the \"default device\" :"]
-    #[doc = ""]
-    #[doc = " - Any device memory subsequently allocated from this host thread (using hipMalloc) will be"]
-    #[doc = " allocated on device."]
-    #[doc = " - Any streams or events created from this host thread will be associated with device."]
-    #[doc = " - Any kernels launched from this host thread (using hipLaunchKernel) will be executed on device"]
-    #[doc = " (unless a specific stream is specified, in which case the device associated with that stream will"]
-    #[doc = " be used)."]
-    #[doc = ""]
-    #[doc = " This function may be called from any host thread.  Multiple host threads may use the same device."]
-    #[doc = " This function does no synchronization with the previous or new device, and has very little"]
-    #[doc = " runtime overhead. Applications can use hipSetDevice to quickly switch the default device before"]
-    #[doc = " making a HIP runtime call which uses the default device."]
-    #[doc = ""]
-    #[doc = " The default device is stored in thread-local-storage for each thread."]
-    #[doc = " Thread-pool implementations may inherit the default device of the previous thread.  A good"]
-    #[doc = " practice is to always call hipSetDevice at the start of HIP coding sequency to establish a known"]
-    #[doc = " standard device."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorDeviceAlreadyInUse"]
-    #[doc = ""]
-    #[doc = " @see hipGetDevice, hipGetDeviceCount"]
-    pub fn hipSetDevice(deviceId: ::std::os::raw::c_int) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return the default device id for the calling host thread."]
-    #[doc = ""]
-    #[doc = " @param [out] device *device is written with the default device"]
-    #[doc = ""]
-    #[doc = " HIP maintains an default device for each thread using thread-local-storage."]
-    #[doc = " This device is used implicitly for HIP runtime APIs called by this thread."]
-    #[doc = " hipGetDevice returns in * @p device the default device for the calling host thread."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " @see hipSetDevice, hipGetDevicesizeBytes"]
-    pub fn hipGetDevice(deviceId: *mut ::std::os::raw::c_int) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return number of compute-capable devices."]
-    #[doc = ""]
-    #[doc = " @param [output] count Returns number of compute-capable devices."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorNoDevice"]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " Returns in @p *count the number of devices that have ability to run compute commands.  If there"]
-    #[doc = " are no such devices, then @ref hipGetDeviceCount will return #hipErrorNoDevice. If 1 or more"]
-    #[doc = " devices can be found, then hipGetDeviceCount returns #hipSuccess."]
-    pub fn hipGetDeviceCount(count: *mut ::std::os::raw::c_int) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Query for a specific device attribute."]
-    #[doc = ""]
-    #[doc = " @param [out] pi pointer to value to return"]
-    #[doc = " @param [in] attr attribute to query"]
-    #[doc = " @param [in] deviceId which device to query for information"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    pub fn hipDeviceGetAttribute(
-        pi: *mut ::std::os::raw::c_int,
-        attr: hipDeviceAttribute_t,
-        deviceId: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns device properties."]
-    #[doc = ""]
-    #[doc = " @param [out] prop written with device properties"]
-    #[doc = " @param [in]  deviceId which device to query for information"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidDevice"]
-    #[doc = " @bug HCC always returns 0 for maxThreadsPerMultiProcessor"]
-    #[doc = " @bug HCC always returns 0 for regsPerBlock"]
-    #[doc = " @bug HCC always returns 0 for l2CacheSize"]
-    #[doc = ""]
-    #[doc = " Populates hipGetDeviceProperties with information for the specified device."]
-    pub fn hipGetDeviceProperties(
-        prop: *mut hipDeviceProp_t,
-        deviceId: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set L1/Shared cache partition."]
-    #[doc = ""]
-    #[doc = " @param [in] cacheConfig"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorNotInitialized"]
-    #[doc = " Note: AMD devices and some Nvidia GPUS do not support reconfigurable cache.  This hint is ignored"]
-    #[doc = " on those architectures."]
-    #[doc = ""]
-    pub fn hipDeviceSetCacheConfig(cacheConfig: hipFuncCache_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set Cache configuration for a specific function"]
-    #[doc = ""]
-    #[doc = " @param [in] cacheConfig"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorNotInitialized"]
-    #[doc = " Note: AMD devices and some Nvidia GPUS do not support reconfigurable cache.  This hint is ignored"]
-    #[doc = " on those architectures."]
-    #[doc = ""]
-    pub fn hipDeviceGetCacheConfig(cacheConfig: *mut hipFuncCache_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Get Resource limits of current device"]
-    #[doc = ""]
-    #[doc = " @param [out] pValue"]
-    #[doc = " @param [in]  limit"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorUnsupportedLimit, #hipErrorInvalidValue"]
-    #[doc = " Note: Currently, only hipLimitMallocHeapSize is available"]
-    #[doc = ""]
-    pub fn hipDeviceGetLimit(pValue: *mut usize, limit: hipLimit_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns bank width of shared memory for current device"]
-    #[doc = ""]
-    #[doc = " @param [out] pConfig"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    #[doc = ""]
-    #[doc = " Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    pub fn hipDeviceGetSharedMemConfig(pConfig: *mut hipSharedMemConfig) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Gets the flags set for current device"]
-    #[doc = ""]
-    #[doc = " @param [out] flags"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    pub fn hipGetDeviceFlags(flags: *mut ::std::os::raw::c_uint) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief The bank width of shared memory on current device is set"]
-    #[doc = ""]
-    #[doc = " @param [in] config"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    #[doc = ""]
-    #[doc = " Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    pub fn hipDeviceSetSharedMemConfig(config: hipSharedMemConfig) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief The current device behavior is changed according the flags passed."]
-    #[doc = ""]
-    #[doc = " @param [in] flags"]
-    #[doc = ""]
-    #[doc = " The schedule flags impact how HIP waits for the completion of a command running on a device."]
-    #[doc = " hipDeviceScheduleSpin         : HIP runtime will actively spin in the thread which submitted the"]
-    #[doc = " work until the command completes.  This offers the lowest latency, but will consume a CPU core"]
-    #[doc = " and may increase power. hipDeviceScheduleYield        : The HIP runtime will yield the CPU to"]
-    #[doc = " system so that other tasks can use it.  This may increase latency to detect the completion but"]
-    #[doc = " will consume less power and is friendlier to other tasks in the system."]
-    #[doc = " hipDeviceScheduleBlockingSync : On ROCm platform, this is a synonym for hipDeviceScheduleYield."]
-    #[doc = " hipDeviceScheduleAuto         : Use a hueristic to select between Spin and Yield modes.  If the"]
-    #[doc = " number of HIP contexts is greater than the number of logical processors in the system, use Spin"]
-    #[doc = " scheduling.  Else use Yield scheduling."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " hipDeviceMapHost              : Allow mapping host memory.  On ROCM, this is always allowed and"]
-    #[doc = " the flag is ignored. hipDeviceLmemResizeToMax      : @warning ROCm silently ignores this flag."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorSetOnActiveProcess"]
-    #[doc = ""]
-    #[doc = ""]
-    pub fn hipSetDeviceFlags(flags: ::std::os::raw::c_uint) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Device which matches hipDeviceProp_t is returned"]
-    #[doc = ""]
-    #[doc = " @param [out] device ID"]
-    #[doc = " @param [in]  device properties pointer"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipChooseDevice(
-        device: *mut ::std::os::raw::c_int,
-        prop: *const hipDeviceProp_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns the link type and hop count between two devices"]
-    #[doc = ""]
-    #[doc = " @param [in] device1 Ordinal for device1"]
-    #[doc = " @param [in] device2 Ordinal for device2"]
-    #[doc = " @param [out] linktype Returns the link type (See hsa_amd_link_info_type_t) between the two devices"]
-    #[doc = " @param [out] hopcount Returns the hop count between the two devices"]
-    #[doc = ""]
-    #[doc = " Queries and returns the HSA link type and the hop count between the two specified devices."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipInvalidDevice, #hipErrorRuntimeOther"]
-    pub fn hipExtGetLinkTypeAndHopCount(
-        device1: ::std::os::raw::c_int,
-        device2: ::std::os::raw::c_int,
-        linktype: *mut u32,
-        hopcount: *mut u32,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Gets an interprocess memory handle for an existing device memory"]
-    #[doc = "          allocation"]
-    #[doc = ""]
-    #[doc = " Takes a pointer to the base of an existing device memory allocation created"]
-    #[doc = " with hipMalloc and exports it for use in another process. This is a"]
-    #[doc = " lightweight operation and may be called multiple times on an allocation"]
-    #[doc = " without adverse effects."]
-    #[doc = ""]
-    #[doc = " If a region of memory is freed with hipFree and a subsequent call"]
-    #[doc = " to hipMalloc returns memory with the same device address,"]
-    #[doc = " hipIpcGetMemHandle will return a unique handle for the"]
-    #[doc = " new memory."]
-    #[doc = ""]
-    #[doc = " @param handle - Pointer to user allocated hipIpcMemHandle to return"]
-    #[doc = "                    the handle in."]
-    #[doc = " @param devPtr - Base pointer to previously allocated device memory"]
-    #[doc = ""]
-    #[doc = " @returns"]
-    #[doc = " hipSuccess,"]
-    #[doc = " hipErrorInvalidHandle,"]
-    #[doc = " hipErrorOutOfMemory,"]
-    #[doc = " hipErrorMapFailed,"]
-    #[doc = ""]
-    pub fn hipIpcGetMemHandle(
-        handle: *mut hipIpcMemHandle_t,
-        devPtr: *mut ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Opens an interprocess memory handle exported from another process"]
-    #[doc = "          and returns a device pointer usable in the local process."]
-    #[doc = ""]
-    #[doc = " Maps memory exported from another process with hipIpcGetMemHandle into"]
-    #[doc = " the current device address space. For contexts on different devices"]
-    #[doc = " hipIpcOpenMemHandle can attempt to enable peer access between the"]
-    #[doc = " devices as if the user called hipDeviceEnablePeerAccess. This behavior is"]
-    #[doc = " controlled by the hipIpcMemLazyEnablePeerAccess flag."]
-    #[doc = " hipDeviceCanAccessPeer can determine if a mapping is possible."]
-    #[doc = ""]
-    #[doc = " Contexts that may open hipIpcMemHandles are restricted in the following way."]
-    #[doc = " hipIpcMemHandles from each device in a given process may only be opened"]
-    #[doc = " by one context per device per other process."]
-    #[doc = ""]
-    #[doc = " Memory returned from hipIpcOpenMemHandle must be freed with"]
-    #[doc = " hipIpcCloseMemHandle."]
-    #[doc = ""]
-    #[doc = " Calling hipFree on an exported memory region before calling"]
-    #[doc = " hipIpcCloseMemHandle in the importing context will result in undefined"]
-    #[doc = " behavior."]
-    #[doc = ""]
-    #[doc = " @param devPtr - Returned device pointer"]
-    #[doc = " @param handle - hipIpcMemHandle to open"]
-    #[doc = " @param flags  - Flags for this operation. Must be specified as hipIpcMemLazyEnablePeerAccess"]
-    #[doc = ""]
-    #[doc = " @returns"]
-    #[doc = " hipSuccess,"]
-    #[doc = " hipErrorMapFailed,"]
-    #[doc = " hipErrorInvalidHandle,"]
-    #[doc = " hipErrorTooManyPeers"]
-    #[doc = ""]
-    #[doc = " @note No guarantees are made about the address returned in @p *devPtr."]
-    #[doc = " In particular, multiple processes may not receive the same address for the same @p handle."]
-    #[doc = ""]
-    pub fn hipIpcOpenMemHandle(
-        devPtr: *mut *mut ::std::os::raw::c_void,
-        handle: hipIpcMemHandle_t,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Close memory mapped with hipIpcOpenMemHandle"]
-    #[doc = ""]
-    #[doc = " Unmaps memory returnd by hipIpcOpenMemHandle. The original allocation"]
-    #[doc = " in the exporting process as well as imported mappings in other processes"]
-    #[doc = " will be unaffected."]
-    #[doc = ""]
-    #[doc = " Any resources used to enable peer access will be freed if this is the"]
-    #[doc = " last mapping using them."]
-    #[doc = ""]
-    #[doc = " @param devPtr - Device pointer returned by hipIpcOpenMemHandle"]
-    #[doc = ""]
-    #[doc = " @returns"]
-    #[doc = " hipSuccess,"]
-    #[doc = " hipErrorMapFailed,"]
-    #[doc = " hipErrorInvalidHandle,"]
-    #[doc = ""]
-    pub fn hipIpcCloseMemHandle(devPtr: *mut ::std::os::raw::c_void) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Gets an opaque interprocess handle for an event."]
-    #[doc = ""]
-    #[doc = " This opaque handle may be copied into other processes and opened with cudaIpcOpenEventHandle."]
-    #[doc = " Then cudaEventRecord, cudaEventSynchronize, cudaStreamWaitEvent and cudaEventQuery may be used in"]
-    #[doc = " either process. Operations on the imported event after the exported event has been freed with hipEventDestroy"]
-    #[doc = " will result in undefined behavior."]
-    #[doc = ""]
-    #[doc = " @param[out]  handle Pointer to cudaIpcEventHandle to return the opaque event handle"]
-    #[doc = " @param[in]   event  Event allocated with cudaEventInterprocess and cudaEventDisableTiming flags"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidConfiguration, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipIpcGetEventHandle(handle: *mut hipIpcEventHandle_t, event: hipEvent_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Opens an interprocess event handles."]
-    #[doc = ""]
-    #[doc = " Opens an interprocess event handle exported from another process with cudaIpcGetEventHandle. The returned"]
-    #[doc = " hipEvent_t behaves like a locally created event with the hipEventDisableTiming flag specified. This event"]
-    #[doc = " need be freed with hipEventDestroy. Operations on the imported event after the exported event has been freed"]
-    #[doc = " with hipEventDestroy will result in undefined behavior. If the function is called within the same process where"]
-    #[doc = " handle is returned by hipIpcGetEventHandle, it will return hipErrorInvalidContext."]
-    #[doc = ""]
-    #[doc = " @param[out]  event  Pointer to hipEvent_t to return the event"]
-    #[doc = " @param[in]   handle The opaque interprocess handle to open"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidContext"]
-    #[doc = ""]
-    pub fn hipIpcOpenEventHandle(event: *mut hipEvent_t, handle: hipIpcEventHandle_t)
-        -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = ""]
-    #[doc = "  @defgroup Execution Execution Control"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the execution control functions of HIP runtime API."]
-    #[doc = ""]
-    #[doc = " @brief Set attribute for a specific function"]
-    #[doc = ""]
-    #[doc = " @param [in] func;"]
-    #[doc = " @param [in] attr;"]
-    #[doc = " @param [in] value;"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDeviceFunction, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    pub fn hipFuncSetAttribute(
-        func: *const ::std::os::raw::c_void,
-        attr: hipFuncAttribute,
-        value: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set Cache configuration for a specific function"]
-    #[doc = ""]
-    #[doc = " @param [in] config;"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorNotInitialized"]
-    #[doc = " Note: AMD devices and some Nvidia GPUS do not support reconfigurable cache.  This hint is ignored"]
-    #[doc = " on those architectures."]
-    #[doc = ""]
-    pub fn hipFuncSetCacheConfig(
-        func: *const ::std::os::raw::c_void,
-        config: hipFuncCache_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set shared memory configuation for a specific function"]
-    #[doc = ""]
-    #[doc = " @param [in] func"]
-    #[doc = " @param [in] config"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDeviceFunction, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    pub fn hipFuncSetSharedMemConfig(
-        func: *const ::std::os::raw::c_void,
-        config: hipSharedMemConfig,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Error Error Handling"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the error handling functions of HIP runtime API."]
-    #[doc = " @brief Return last error returned by any HIP runtime API call and resets the stored error code to"]
-    #[doc = " #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @returns return code from last HIP called from the active host thread"]
-    #[doc = ""]
-    #[doc = " Returns the last error that has been returned by any of the runtime calls in the same host"]
-    #[doc = " thread, and then resets the saved error to #hipSuccess."]
-    #[doc = ""]
-    #[doc = " @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t"]
-    pub fn hipGetLastError() -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return last error returned by any HIP runtime API call."]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " Returns the last error that has been returned by any of the runtime calls in the same host"]
-    #[doc = " thread. Unlike hipGetLastError, this function does not reset the saved error code."]
-    #[doc = ""]
-    #[doc = " @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t"]
-    pub fn hipPeekAtLastError() -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return name of the specified error code in text form."]
-    #[doc = ""]
-    #[doc = " @param hip_error Error code to convert to name."]
-    #[doc = " @return const char pointer to the NULL-terminated error name"]
-    #[doc = ""]
-    #[doc = " @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t"]
-    pub fn hipGetErrorName(hip_error: hipError_t) -> *const ::std::os::raw::c_char;
-}
-extern "C" {
-    #[doc = " @brief Return handy text string message to explain the error which occurred"]
-    #[doc = ""]
-    #[doc = " @param hipError Error code to convert to string."]
-    #[doc = " @return const char pointer to the NULL-terminated error string"]
-    #[doc = ""]
-    #[doc = " @warning : on HCC, this function returns the name of the error (same as hipGetErrorName)"]
-    #[doc = ""]
-    #[doc = " @see hipGetErrorName, hipGetLastError, hipPeakAtLastError, hipError_t"]
-    pub fn hipGetErrorString(hipError: hipError_t) -> *const ::std::os::raw::c_char;
-}
-extern "C" {
-    #[doc = " @brief Create an asynchronous stream."]
-    #[doc = ""]
-    #[doc = " @param[in, out] stream Valid pointer to hipStream_t.  This function writes the memory with the"]
-    #[doc = " newly created stream."]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Create a new asynchronous stream.  @p stream returns an opaque handle that can be used to"]
-    #[doc = " reference the newly created stream in subsequent hipStream* commands.  The stream is allocated on"]
-    #[doc = " the heap and will remain allocated even if the handle goes out-of-scope.  To release the memory"]
-    #[doc = " used by the stream, applicaiton must call hipStreamDestroy."]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
-    pub fn hipStreamCreate(stream: *mut hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Create an asynchronous stream."]
-    #[doc = ""]
-    #[doc = " @param[in, out] stream Pointer to new stream"]
-    #[doc = " @param[in ] flags to control stream creation."]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Create a new asynchronous stream.  @p stream returns an opaque handle that can be used to"]
-    #[doc = " reference the newly created stream in subsequent hipStream* commands.  The stream is allocated on"]
-    #[doc = " the heap and will remain allocated even if the handle goes out-of-scope.  To release the memory"]
-    #[doc = " used by the stream, applicaiton must call hipStreamDestroy. Flags controls behavior of the"]
-    #[doc = " stream.  See #hipStreamDefault, #hipStreamNonBlocking."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamCreateWithPriority, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
-    pub fn hipStreamCreateWithFlags(
-        stream: *mut hipStream_t,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Create an asynchronous stream with the specified priority."]
-    #[doc = ""]
-    #[doc = " @param[in, out] stream Pointer to new stream"]
-    #[doc = " @param[in ] flags to control stream creation."]
-    #[doc = " @param[in ] priority of the stream. Lower numbers represent higher priorities."]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Create a new asynchronous stream with the specified priority.  @p stream returns an opaque handle"]
-    #[doc = " that can be used to reference the newly created stream in subsequent hipStream* commands.  The"]
-    #[doc = " stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope."]
-    #[doc = " To release the memory used by the stream, applicaiton must call hipStreamDestroy. Flags controls"]
-    #[doc = " behavior of the stream.  See #hipStreamDefault, #hipStreamNonBlocking."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
-    pub fn hipStreamCreateWithPriority(
-        stream: *mut hipStream_t,
-        flags: ::std::os::raw::c_uint,
-        priority: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns numerical values that correspond to the least and greatest stream priority."]
-    #[doc = ""]
-    #[doc = " @param[in, out] leastPriority pointer in which value corresponding to least priority is returned."]
-    #[doc = " @param[in, out] greatestPriority pointer in which value corresponding to greatest priority is returned."]
-    #[doc = ""]
-    #[doc = " Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least"]
-    #[doc = " and greatest stream priority respectively. Stream priorities follow a convention where lower numbers"]
-    #[doc = " imply greater priorities. The range of meaningful stream priorities is given by"]
-    #[doc = " [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value"]
-    #[doc = " that is outside the the meaningful range as specified by this API, the priority is automatically"]
-    #[doc = " clamped to within the valid range."]
-    pub fn hipDeviceGetStreamPriorityRange(
-        leastPriority: *mut ::std::os::raw::c_int,
-        greatestPriority: *mut ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Destroys the specified stream."]
-    #[doc = ""]
-    #[doc = " @param[in, out] stream Valid pointer to hipStream_t.  This function writes the memory with the"]
-    #[doc = " newly created stream."]
-    #[doc = " @return #hipSuccess #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " Destroys the specified stream."]
-    #[doc = ""]
-    #[doc = " If commands are still executing on the specified stream, some may complete execution before the"]
-    #[doc = " queue is deleted."]
-    #[doc = ""]
-    #[doc = " The queue may be destroyed while some commands are still inflight, or may wait for all commands"]
-    #[doc = " queued to the stream before destroying it."]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamQuery, hipStreamWaitEvent,"]
-    #[doc = " hipStreamSynchronize"]
-    pub fn hipStreamDestroy(stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return #hipSuccess if all of the operations in the specified @p stream have completed, or"]
-    #[doc = " #hipErrorNotReady if not."]
-    #[doc = ""]
-    #[doc = " @param[in] stream stream to query"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorNotReady, #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " This is thread-safe and returns a snapshot of the current state of the queue.  However, if other"]
-    #[doc = " host threads are sending work to the stream, the status may change immediately after the function"]
-    #[doc = " is called.  It is typically used for debug."]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamWaitEvent, hipStreamSynchronize,"]
-    #[doc = " hipStreamDestroy"]
-    pub fn hipStreamQuery(stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Wait for all commands in stream to complete."]
-    #[doc = ""]
-    #[doc = " @param[in] stream stream identifier."]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " This command is host-synchronous : the host will block until the specified stream is empty."]
-    #[doc = ""]
-    #[doc = " This command follows standard null-stream semantics.  Specifically, specifying the null stream"]
-    #[doc = " will cause the command to wait for other streams on the same device to complete all pending"]
-    #[doc = " operations."]
-    #[doc = ""]
-    #[doc = " This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active"]
-    #[doc = " or blocking."]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamWaitEvent, hipStreamDestroy"]
-    #[doc = ""]
-    pub fn hipStreamSynchronize(stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Make the specified compute stream wait for an event"]
-    #[doc = ""]
-    #[doc = " @param[in] stream stream to make wait."]
-    #[doc = " @param[in] event event to wait on"]
-    #[doc = " @param[in] flags control operation [must be 0]"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " This function inserts a wait operation into the specified stream."]
-    #[doc = " All future work submitted to @p stream will wait until @p event reports completion before"]
-    #[doc = " beginning execution."]
-    #[doc = ""]
-    #[doc = " This function only waits for commands in the current stream to complete.  Notably,, this function"]
-    #[doc = " does not impliciy wait for commands in the default stream to complete, even if the specified"]
-    #[doc = " stream is created with hipStreamNonBlocking = 0."]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamSynchronize, hipStreamDestroy"]
-    pub fn hipStreamWaitEvent(
-        stream: hipStream_t,
-        event: hipEvent_t,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipStreamGetCtx(stream: hipStream_t, pctx: *mut hipCtx_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return flags associated with this stream."]
-    #[doc = ""]
-    #[doc = " @param[in] stream stream to be queried"]
-    #[doc = " @param[in,out] flags Pointer to an unsigned integer in which the stream's flags are returned"]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess #hipErrorInvalidValue #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " Return flags associated with this stream in *@p flags."]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreateWithFlags"]
-    pub fn hipStreamGetFlags(stream: hipStream_t, flags: *mut ::std::os::raw::c_uint)
-        -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Query the priority of a stream."]
-    #[doc = ""]
-    #[doc = " @param[in] stream stream to be queried"]
-    #[doc = " @param[in,out] priority Pointer to an unsigned integer in which the stream's priority is returned"]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess #hipErrorInvalidValue #hipErrorInvalidHandle"]
-    #[doc = ""]
-    #[doc = " Query the priority of a stream. The priority is returned in in priority."]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreateWithFlags"]
-    pub fn hipStreamGetPriority(
-        stream: hipStream_t,
-        priority: *mut ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Create an asynchronous stream with the specified CU mask."]
-    #[doc = ""]
-    #[doc = " @param[in, out] stream Pointer to new stream"]
-    #[doc = " @param[in ] cuMaskSize Size of CU mask bit array passed in."]
-    #[doc = " @param[in ] cuMask Bit-vector representing the CU mask. Each active bit represents using one CU."]
-    #[doc = " The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical"]
-    #[doc = " CU number (i.e., multiProcessorCount member of hipDeviceProp_t), the extra elements are ignored."]
-    #[doc = " It is user's responsibility to make sure the input is meaningful."]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidHandle, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Create a new asynchronous stream with the specified CU mask.  @p stream returns an opaque handle"]
-    #[doc = " that can be used to reference the newly created stream in subsequent hipStream* commands.  The"]
-    #[doc = " stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope."]
-    #[doc = " To release the memory used by the stream, application must call hipStreamDestroy."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
-    pub fn hipExtStreamCreateWithCUMask(
-        stream: *mut hipStream_t,
-        cuMaskSize: u32,
-        cuMask: *const u32,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Get CU mask associated with an asynchronous stream"]
-    #[doc = ""]
-    #[doc = " @param[in] stream stream to be queried"]
-    #[doc = " @param[in] cuMaskSize number of the block of memories (uint32_t *) allocated by user"]
-    #[doc = " @param[out] cuMask Pointer to a pre-allocated block of memories (uint32_t *) in which"]
-    #[doc = " the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where"]
-    #[doc = " each active bit represents one active CU"]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidHandle, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy"]
-    pub fn hipExtStreamGetCUMask(
-        stream: hipStream_t,
-        cuMaskSize: u32,
-        cuMask: *mut u32,
-    ) -> hipError_t;
-}
-#[doc = " Stream CallBack struct"]
-pub type hipStreamCallback_t = ::std::option::Option<
-    unsafe extern "C" fn(
-        stream: hipStream_t,
-        status: hipError_t,
-        userData: *mut ::std::os::raw::c_void,
-    ),
->;
-extern "C" {
-    #[doc = " @brief Adds a callback to be called on the host after all currently enqueued"]
-    #[doc = " items in the stream have completed.  For each"]
-    #[doc = " hipStreamAddCallback call, a callback will be executed exactly once."]
-    #[doc = " The callback will block later work in the stream until it is finished."]
-    #[doc = " @param[in] stream   - Stream to add callback to"]
-    #[doc = " @param[in] callback - The function to call once preceding stream operations are complete"]
-    #[doc = " @param[in] userData - User specified data to be passed to the callback function"]
-    #[doc = " @param[in] flags    - Reserved for future use, must be 0"]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidHandle, #hipErrorNotSupported"]
-    #[doc = ""]
-    #[doc = " @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamQuery, hipStreamSynchronize,"]
-    #[doc = " hipStreamWaitEvent, hipStreamDestroy, hipStreamCreateWithPriority"]
-    #[doc = ""]
-    pub fn hipStreamAddCallback(
-        stream: hipStream_t,
-        callback: hipStreamCallback_t,
-        userData: *mut ::std::os::raw::c_void,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Stream Memory Operations"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes Stream Memory Wait and Write functions of HIP runtime API."]
-    #[doc = " @brief Enqueues a wait command to the stream.[BETA]"]
-    #[doc = ""]
-    #[doc = " @param [in] stream - Stream identifier"]
-    #[doc = " @param [in] ptr    - Pointer to memory object allocated using 'hipMallocSignalMemory' flag"]
-    #[doc = " @param [in] value  - Value to be used in compare operation"]
-    #[doc = " @param [in] flags  - Defines the compare operation, supported values are hipStreamWaitValueGte"]
-    #[doc = " hipStreamWaitValueEq, hipStreamWaitValueAnd and hipStreamWaitValueNor"]
-    #[doc = " @param [in] mask   - Mask to be applied on value at memory before it is compared with value,"]
-    #[doc = " default value is set to enable every bit"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Enqueues a wait command to the stream, all operations enqueued  on this stream after this, will"]
-    #[doc = " not execute until the defined wait condition is true."]
-    #[doc = ""]
-    #[doc = " hipStreamWaitValueGte: waits until *ptr&mask >= value"]
-    #[doc = " hipStreamWaitValueEq : waits until *ptr&mask == value"]
-    #[doc = " hipStreamWaitValueAnd: waits until ((*ptr&mask) & value) != 0"]
-    #[doc = " hipStreamWaitValueNor: waits until ~((*ptr&mask) | (value&mask)) != 0"]
-    #[doc = ""]
-    #[doc = " @note when using 'hipStreamWaitValueNor', mask is applied on both 'value' and '*ptr'."]
-    #[doc = ""]
-    #[doc = " @note Support for hipStreamWaitValue32 can be queried using 'hipDeviceGetAttribute()' and"]
-    #[doc = " 'hipDeviceAttributeCanUseStreamWaitValue' flag."]
-    #[doc = ""]
-    #[doc = " @beta This API is marked as beta, meaning, while this is feature complete,"]
-    #[doc = " it is still open to changes and may have outstanding issues."]
-    #[doc = ""]
-    #[doc = " @see hipExtMallocWithFlags, hipFree, hipStreamWaitValue64, hipStreamWriteValue64,"]
-    #[doc = " hipStreamWriteValue32, hipDeviceGetAttribute"]
-    pub fn hipStreamWaitValue32(
-        stream: hipStream_t,
-        ptr: *mut ::std::os::raw::c_void,
-        value: u32,
-        flags: ::std::os::raw::c_uint,
-        mask: u32,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Enqueues a wait command to the stream.[BETA]"]
-    #[doc = ""]
-    #[doc = " @param [in] stream - Stream identifier"]
-    #[doc = " @param [in] ptr    - Pointer to memory object allocated using 'hipMallocSignalMemory' flag"]
-    #[doc = " @param [in] value  - Value to be used in compare operation"]
-    #[doc = " @param [in] flags  - Defines the compare operation, supported values are hipStreamWaitValueGte"]
-    #[doc = " hipStreamWaitValueEq, hipStreamWaitValueAnd and hipStreamWaitValueNor."]
-    #[doc = " @param [in] mask   - Mask to be applied on value at memory before it is compared with value"]
-    #[doc = " default value is set to enable every bit"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Enqueues a wait command to the stream, all operations enqueued  on this stream after this, will"]
-    #[doc = " not execute until the defined wait condition is true."]
-    #[doc = ""]
-    #[doc = " hipStreamWaitValueGte: waits until *ptr&mask >= value"]
-    #[doc = " hipStreamWaitValueEq : waits until *ptr&mask == value"]
-    #[doc = " hipStreamWaitValueAnd: waits until ((*ptr&mask) & value) != 0"]
-    #[doc = " hipStreamWaitValueNor: waits until ~((*ptr&mask) | (value&mask)) != 0"]
-    #[doc = ""]
-    #[doc = " @note when using 'hipStreamWaitValueNor', mask is applied on both 'value' and '*ptr'."]
-    #[doc = ""]
-    #[doc = " @note Support for hipStreamWaitValue64 can be queried using 'hipDeviceGetAttribute()' and"]
-    #[doc = " 'hipDeviceAttributeCanUseStreamWaitValue' flag."]
-    #[doc = ""]
-    #[doc = " @beta This API is marked as beta, meaning, while this is feature complete,"]
-    #[doc = " it is still open to changes and may have outstanding issues."]
-    #[doc = ""]
-    #[doc = " @see hipExtMallocWithFlags, hipFree, hipStreamWaitValue32, hipStreamWriteValue64,"]
-    #[doc = " hipStreamWriteValue32, hipDeviceGetAttribute"]
-    pub fn hipStreamWaitValue64(
-        stream: hipStream_t,
-        ptr: *mut ::std::os::raw::c_void,
-        value: u64,
-        flags: ::std::os::raw::c_uint,
-        mask: u64,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Enqueues a write command to the stream.[BETA]"]
-    #[doc = ""]
-    #[doc = " @param [in] stream - Stream identifier"]
-    #[doc = " @param [in] ptr    - Pointer to a GPU accessible memory object"]
-    #[doc = " @param [in] value  - Value to be written"]
-    #[doc = " @param [in] flags  - reserved, ignored for now, will be used in future releases"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Enqueues a write command to the stream, write operation is performed after all earlier commands"]
-    #[doc = " on this stream have completed the execution."]
-    #[doc = ""]
-    #[doc = " @beta This API is marked as beta, meaning, while this is feature complete,"]
-    #[doc = " it is still open to changes and may have outstanding issues."]
-    #[doc = ""]
-    #[doc = " @see hipExtMallocWithFlags, hipFree, hipStreamWriteValue32, hipStreamWaitValue32,"]
-    #[doc = " hipStreamWaitValue64"]
-    pub fn hipStreamWriteValue32(
-        stream: hipStream_t,
-        ptr: *mut ::std::os::raw::c_void,
-        value: u32,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Enqueues a write command to the stream.[BETA]"]
-    #[doc = ""]
-    #[doc = " @param [in] stream - Stream identifier"]
-    #[doc = " @param [in] ptr    - Pointer to a GPU accessible memory object"]
-    #[doc = " @param [in] value  - Value to be written"]
-    #[doc = " @param [in] flags  - reserved, ignored for now, will be used in future releases"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " Enqueues a write command to the stream, write operation is performed after all earlier commands"]
-    #[doc = " on this stream have completed the execution."]
-    #[doc = ""]
-    #[doc = " @beta This API is marked as beta, meaning, while this is feature complete,"]
-    #[doc = " it is still open to changes and may have outstanding issues."]
-    #[doc = ""]
-    #[doc = " @see hipExtMallocWithFlags, hipFree, hipStreamWriteValue32, hipStreamWaitValue32,"]
-    #[doc = " hipStreamWaitValue64"]
-    pub fn hipStreamWriteValue64(
-        stream: hipStream_t,
-        ptr: *mut ::std::os::raw::c_void,
-        value: u64,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Event Event Management"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the event management functions of HIP runtime API."]
-    #[doc = " @brief Create an event with the specified flags"]
-    #[doc = ""]
-    #[doc = " @param[in,out] event Returns the newly created event."]
-    #[doc = " @param[in] flags     Flags to control event behavior.  Valid values are #hipEventDefault,"]
-    #[doc = "#hipEventBlockingSync, #hipEventDisableTiming, #hipEventInterprocess"]
-    #[doc = " #hipEventDefault : Default flag.  The event will use active synchronization and will support"]
-    #[doc = "timing.  Blocking synchronization provides lowest possible latency at the expense of dedicating a"]
-    #[doc = "CPU to poll on the event."]
-    #[doc = " #hipEventBlockingSync : The event will use blocking synchronization : if hipEventSynchronize is"]
-    #[doc = "called on this event, the thread will block until the event completes.  This can increase latency"]
-    #[doc = "for the synchroniation but can result in lower power and more resources for other CPU threads."]
-    #[doc = " #hipEventDisableTiming : Disable recording of timing information. Events created with this flag"]
-    #[doc = "would not record profiling data and provide best performance if used for synchronization."]
-    #[doc = " @warning On AMD platform, hipEventInterprocess support is under development.  Use of this flag"]
-    #[doc = "will return an error."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,"]
-    #[doc = "#hipErrorLaunchFailure, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = " @see hipEventCreate, hipEventSynchronize, hipEventDestroy, hipEventElapsedTime"]
-    pub fn hipEventCreateWithFlags(
-        event: *mut hipEvent_t,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  Create an event"]
-    #[doc = ""]
-    #[doc = " @param[in,out] event Returns the newly created event."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,"]
-    #[doc = " #hipErrorLaunchFailure, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = " @see hipEventCreateWithFlags, hipEventRecord, hipEventQuery, hipEventSynchronize,"]
-    #[doc = " hipEventDestroy, hipEventElapsedTime"]
-    pub fn hipEventCreate(event: *mut hipEvent_t) -> hipError_t;
-}
-extern "C" {
-    pub fn hipEventRecord(event: hipEvent_t, stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Destroy the specified event."]
-    #[doc = ""]
-    #[doc = "  @param[in] event Event to destroy."]
-    #[doc = "  @returns #hipSuccess, #hipErrorNotInitialized, #hipErrorInvalidValue,"]
-    #[doc = " #hipErrorLaunchFailure"]
-    #[doc = ""]
-    #[doc = "  Releases memory associated with the event.  If the event is recording but has not completed"]
-    #[doc = " recording when hipEventDestroy() is called, the function will return immediately and the"]
-    #[doc = " completion_future resources will be released later, when the hipDevice is synchronized."]
-    #[doc = ""]
-    #[doc = " @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventSynchronize, hipEventRecord,"]
-    #[doc = " hipEventElapsedTime"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    pub fn hipEventDestroy(event: hipEvent_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Wait for an event to complete."]
-    #[doc = ""]
-    #[doc = "  This function will block until the event is ready, waiting for all previous work in the stream"]
-    #[doc = " specified when event was recorded with hipEventRecord()."]
-    #[doc = ""]
-    #[doc = "  If hipEventRecord() has not been called on @p event, this function returns immediately."]
-    #[doc = ""]
-    #[doc = "  TODO-hip- This function needs to support hipEventBlockingSync parameter."]
-    #[doc = ""]
-    #[doc = "  @param[in] event Event on which to wait."]
-    #[doc = "  @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized,"]
-    #[doc = " #hipErrorInvalidHandle, #hipErrorLaunchFailure"]
-    #[doc = ""]
-    #[doc = "  @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventDestroy, hipEventRecord,"]
-    #[doc = " hipEventElapsedTime"]
-    pub fn hipEventSynchronize(event: hipEvent_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return the elapsed time between two events."]
-    #[doc = ""]
-    #[doc = " @param[out] ms : Return time between start and stop in ms."]
-    #[doc = " @param[in]   start : Start event."]
-    #[doc = " @param[in]   stop  : Stop event."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorNotReady, #hipErrorInvalidHandle,"]
-    #[doc = " #hipErrorNotInitialized, #hipErrorLaunchFailure"]
-    #[doc = ""]
-    #[doc = " Computes the elapsed time between two events. Time is computed in ms, with"]
-    #[doc = " a resolution of approximately 1 us."]
-    #[doc = ""]
-    #[doc = " Events which are recorded in a NULL stream will block until all commands"]
-    #[doc = " on all other streams complete execution, and then record the timestamp."]
-    #[doc = ""]
-    #[doc = " Events which are recorded in a non-NULL stream will record their timestamp"]
-    #[doc = " when they reach the head of the specified stream, after all previous"]
-    #[doc = " commands in that stream have completed executing.  Thus the time that"]
-    #[doc = " the event recorded may be significantly after the host calls hipEventRecord()."]
-    #[doc = ""]
-    #[doc = " If hipEventRecord() has not been called on either event, then #hipErrorInvalidHandle is"]
-    #[doc = " returned. If hipEventRecord() has been called on both events, but the timestamp has not yet been"]
-    #[doc = " recorded on one or both events (that is, hipEventQuery() would return #hipErrorNotReady on at"]
-    #[doc = " least one of the events), then #hipErrorNotReady is returned."]
-    #[doc = ""]
-    #[doc = " Note, for HIP Events used in kernel dispatch using hipExtLaunchKernelGGL/hipExtLaunchKernel,"]
-    #[doc = " events passed in hipExtLaunchKernelGGL/hipExtLaunchKernel are not explicitly recorded and should"]
-    #[doc = " only be used to get elapsed time for that specific launch. In case events are used across"]
-    #[doc = " multiple dispatches, for example, start and stop events from different hipExtLaunchKernelGGL/"]
-    #[doc = " hipExtLaunchKernel calls, they will be treated as invalid unrecorded events, HIP will throw"]
-    #[doc = " error \"hipErrorInvalidHandle\" from hipEventElapsedTime."]
-    #[doc = ""]
-    #[doc = " @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventDestroy, hipEventRecord,"]
-    #[doc = " hipEventSynchronize"]
-    pub fn hipEventElapsedTime(ms: *mut f32, start: hipEvent_t, stop: hipEvent_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Query event status"]
-    #[doc = ""]
-    #[doc = " @param[in] event Event to query."]
-    #[doc = " @returns #hipSuccess, #hipErrorNotReady, #hipErrorInvalidHandle, #hipErrorInvalidValue,"]
-    #[doc = " #hipErrorNotInitialized, #hipErrorLaunchFailure"]
-    #[doc = ""]
-    #[doc = " Query the status of the specified event.  This function will return #hipErrorNotReady if all"]
-    #[doc = " commands in the appropriate stream (specified to hipEventRecord()) have completed.  If that work"]
-    #[doc = " has not completed, or if hipEventRecord() was not called on the event, then #hipSuccess is"]
-    #[doc = " returned."]
-    #[doc = ""]
-    #[doc = " @see hipEventCreate, hipEventCreateWithFlags, hipEventRecord, hipEventDestroy,"]
-    #[doc = " hipEventSynchronize, hipEventElapsedTime"]
-    pub fn hipEventQuery(event: hipEvent_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Memory Memory Management"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the memory management functions of HIP runtime API."]
-    #[doc = "  The following CUDA APIs are not currently supported:"]
-    #[doc = "  - cudaMalloc3D"]
-    #[doc = "  - cudaMalloc3DArray"]
-    #[doc = "  - TODO - more 2D, 3D, array APIs here."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = "  @brief Return attributes for the specified pointer"]
-    #[doc = ""]
-    #[doc = "  @param[out] attributes for the specified pointer"]
-    #[doc = "  @param[in]  pointer to get attributes for"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipGetDeviceCount, hipGetDevice, hipSetDevice, hipChooseDevice"]
-    pub fn hipPointerGetAttributes(
-        attributes: *mut hipPointerAttribute_t,
-        ptr: *const ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Imports an external semaphore."]
-    #[doc = ""]
-    #[doc = "  @param[out] extSem_out  External semaphores to be waited on"]
-    #[doc = "  @param[in] semHandleDesc Semaphore import handle descriptor"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see"]
-    pub fn hipImportExternalSemaphore(
-        extSem_out: *mut hipExternalSemaphore_t,
-        semHandleDesc: *const hipExternalSemaphoreHandleDesc,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Signals a set of external semaphore objects."]
-    #[doc = ""]
-    #[doc = "  @param[in] extSem_out  External semaphores to be waited on"]
-    #[doc = "  @param[in] paramsArray Array of semaphore parameters"]
-    #[doc = "  @param[in] numExtSems Number of semaphores to wait on"]
-    #[doc = "  @param[in] stream Stream to enqueue the wait operations in"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see"]
-    pub fn hipSignalExternalSemaphoresAsync(
-        extSemArray: *const hipExternalSemaphore_t,
-        paramsArray: *const hipExternalSemaphoreSignalParams,
-        numExtSems: ::std::os::raw::c_uint,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Waits on a set of external semaphore objects"]
-    #[doc = ""]
-    #[doc = "  @param[in] extSem_out  External semaphores to be waited on"]
-    #[doc = "  @param[in] paramsArray Array of semaphore parameters"]
-    #[doc = "  @param[in] numExtSems Number of semaphores to wait on"]
-    #[doc = "  @param[in] stream Stream to enqueue the wait operations in"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see"]
-    pub fn hipWaitExternalSemaphoresAsync(
-        extSemArray: *const hipExternalSemaphore_t,
-        paramsArray: *const hipExternalSemaphoreWaitParams,
-        numExtSems: ::std::os::raw::c_uint,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[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."]
-    #[doc = ""]
-    #[doc = "  @param[in] extSem handle to an external memory object"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see"]
-    pub fn hipDestroyExternalSemaphore(extSem: hipExternalSemaphore_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Imports an external memory object."]
-    #[doc = ""]
-    #[doc = "  @param[out] extMem_out  Returned handle to an external memory object"]
-    #[doc = "  @param[in]  memHandleDesc Memory import handle descriptor"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see"]
-    pub fn hipImportExternalMemory(
-        extMem_out: *mut hipExternalMemory_t,
-        memHandleDesc: *const hipExternalMemoryHandleDesc,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Maps a buffer onto an imported memory object."]
-    #[doc = ""]
-    #[doc = "  @param[out] devPtr Returned device pointer to buffer"]
-    #[doc = "  @param[in]  extMem  Handle to external memory object"]
-    #[doc = "  @param[in]  bufferDesc  Buffer descriptor"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see"]
-    pub fn hipExternalMemoryGetMappedBuffer(
-        devPtr: *mut *mut ::std::os::raw::c_void,
-        extMem: hipExternalMemory_t,
-        bufferDesc: *const hipExternalMemoryBufferDesc,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Destroys an external memory object."]
-    #[doc = ""]
-    #[doc = "  @param[in] extMem  External memory object to be destroyed"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see"]
-    pub fn hipDestroyExternalMemory(extMem: hipExternalMemory_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Allocate memory on the default accelerator"]
-    #[doc = ""]
-    #[doc = "  @param[out] ptr Pointer to the allocated memory"]
-    #[doc = "  @param[in]  size Requested memory size"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorOutOfMemory, #hipErrorInvalidValue (bad context, null *ptr)"]
-    #[doc = ""]
-    #[doc = "  @see hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D, hipMalloc3DArray,"]
-    #[doc = " hipHostFree, hipHostMalloc"]
-    pub fn hipMalloc(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Allocate memory on the default accelerator"]
-    #[doc = ""]
-    #[doc = "  @param[out] ptr Pointer to the allocated memory"]
-    #[doc = "  @param[in]  size Requested memory size"]
-    #[doc = "  @param[in]  flags Type of memory allocation"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorOutOfMemory, #hipErrorInvalidValue (bad context, null *ptr)"]
-    #[doc = ""]
-    #[doc = "  @see hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D, hipMalloc3DArray,"]
-    #[doc = " hipHostFree, hipHostMalloc"]
-    pub fn hipExtMallocWithFlags(
-        ptr: *mut *mut ::std::os::raw::c_void,
-        sizeBytes: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Allocate pinned host memory [Deprecated]"]
-    #[doc = ""]
-    #[doc = "  @param[out] ptr Pointer to the allocated host pinned memory"]
-    #[doc = "  @param[in]  size Requested memory size"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @deprecated use hipHostMalloc() instead"]
-    pub fn hipMallocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Allocate pinned host memory [Deprecated]"]
-    #[doc = ""]
-    #[doc = "  @param[out] ptr Pointer to the allocated host pinned memory"]
-    #[doc = "  @param[in]  size Requested memory size"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @deprecated use hipHostMalloc() instead"]
-    pub fn hipMemAllocHost(ptr: *mut *mut ::std::os::raw::c_void, size: usize) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Allocate device accessible page locked host memory"]
-    #[doc = ""]
-    #[doc = "  @param[out] ptr Pointer to the allocated host pinned memory"]
-    #[doc = "  @param[in]  size Requested memory size"]
-    #[doc = "  @param[in]  flags Type of host memory allocation"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @see hipSetDeviceFlags, hipHostFree"]
-    pub fn hipHostMalloc(
-        ptr: *mut *mut ::std::os::raw::c_void,
-        size: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @addtogroup Memory Managed Memory"]
-    #[doc = "  @{"]
-    #[doc = "  @ingroup Memory"]
-    #[doc = "  This section describes the managed memory management functions of HIP runtime API."]
-    #[doc = ""]
-    #[doc = " @brief Allocates memory that will be automatically managed by HIP."]
-    #[doc = ""]
-    #[doc = " @param [out] dev_ptr - pointer to allocated device memory"]
-    #[doc = " @param [in]  size    - requested allocation size in bytes"]
-    #[doc = " @param [in]  flags   - must be either hipMemAttachGlobal or hipMemAttachHost"]
-    #[doc = "                        (defaults to hipMemAttachGlobal)"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorMemoryAllocation, #hipErrorNotSupported, #hipErrorInvalidValue"]
-    pub fn hipMallocManaged(
-        dev_ptr: *mut *mut ::std::os::raw::c_void,
-        size: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Prefetches memory to the specified destination device using HIP."]
-    #[doc = ""]
-    #[doc = " @param [in] dev_ptr  pointer to be prefetched"]
-    #[doc = " @param [in] count    size in bytes for prefetching"]
-    #[doc = " @param [in] device   destination device to prefetch to"]
-    #[doc = " @param [in] stream   stream to enqueue prefetch operation"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipMemPrefetchAsync(
-        dev_ptr: *const ::std::os::raw::c_void,
-        count: usize,
-        device: ::std::os::raw::c_int,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Advise about the usage of a given memory range to HIP."]
-    #[doc = ""]
-    #[doc = " @param [in] dev_ptr  pointer to memory to set the advice for"]
-    #[doc = " @param [in] count    size in bytes of the memory range"]
-    #[doc = " @param [in] advice   advice to be applied for the specified memory range"]
-    #[doc = " @param [in] device   device to apply the advice for"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipMemAdvise(
-        dev_ptr: *const ::std::os::raw::c_void,
-        count: usize,
-        advice: hipMemoryAdvise,
-        device: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Query an attribute of a given memory range in HIP."]
-    #[doc = ""]
-    #[doc = " @param [in,out] data   a pointer to a memory location where the result of each"]
-    #[doc = "                        attribute query will be written to"]
-    #[doc = " @param [in] data_size  the size of data"]
-    #[doc = " @param [in] attribute  the attribute to query"]
-    #[doc = " @param [in] dev_ptr    start of the range to query"]
-    #[doc = " @param [in] count      size of the range to query"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipMemRangeGetAttribute(
-        data: *mut ::std::os::raw::c_void,
-        data_size: usize,
-        attribute: hipMemRangeAttribute,
-        dev_ptr: *const ::std::os::raw::c_void,
-        count: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Query attributes of a given memory range in HIP."]
-    #[doc = ""]
-    #[doc = " @param [in,out] data     a two-dimensional array containing pointers to memory locations"]
-    #[doc = "                          where the result of each attribute query will be written to"]
-    #[doc = " @param [in] data_sizes   an array, containing the sizes of each result"]
-    #[doc = " @param [in] attributes   the attribute to query"]
-    #[doc = " @param [in] num_attributes  an array of attributes to query (numAttributes and the number"]
-    #[doc = "                          of attributes in this array should match)"]
-    #[doc = " @param [in] dev_ptr      start of the range to query"]
-    #[doc = " @param [in] count        size of the range to query"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipMemRangeGetAttributes(
-        data: *mut *mut ::std::os::raw::c_void,
-        data_sizes: *mut usize,
-        attributes: *mut hipMemRangeAttribute,
-        num_attributes: usize,
-        dev_ptr: *const ::std::os::raw::c_void,
-        count: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Attach memory to a stream asynchronously in HIP."]
-    #[doc = ""]
-    #[doc = " @param [in] stream     - stream in which to enqueue the attach operation"]
-    #[doc = " @param [in] dev_ptr    - pointer to memory (must be a pointer to managed memory or"]
-    #[doc = "                          to a valid host-accessible region of system-allocated memory)"]
-    #[doc = " @param [in] length     - length of memory (defaults to zero)"]
-    #[doc = " @param [in] flags      - must be one of hipMemAttachGlobal, hipMemAttachHost or"]
-    #[doc = "                          hipMemAttachSingle (defaults to hipMemAttachSingle)"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipStreamAttachMemAsync(
-        stream: hipStream_t,
-        dev_ptr: *mut ::std::os::raw::c_void,
-        length: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "  @brief Allocate device accessible page locked host memory [Deprecated]"]
-    #[doc = ""]
-    #[doc = "  @param[out] ptr Pointer to the allocated host pinned memory"]
-    #[doc = "  @param[in]  size Requested memory size"]
-    #[doc = "  @param[in]  flags Type of host memory allocation"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @deprecated use hipHostMalloc() instead"]
-    pub fn hipHostAlloc(
-        ptr: *mut *mut ::std::os::raw::c_void,
-        size: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Get Device pointer from Host Pointer allocated through hipHostMalloc"]
-    #[doc = ""]
-    #[doc = "  @param[out] dstPtr Device Pointer mapped to passed host pointer"]
-    #[doc = "  @param[in]  hstPtr Host Pointer allocated through hipHostMalloc"]
-    #[doc = "  @param[in]  flags Flags to be passed for extension"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @see hipSetDeviceFlags, hipHostMalloc"]
-    pub fn hipHostGetDevicePointer(
-        devPtr: *mut *mut ::std::os::raw::c_void,
-        hstPtr: *mut ::std::os::raw::c_void,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Return flags associated with host pointer"]
-    #[doc = ""]
-    #[doc = "  @param[out] flagsPtr Memory location to store flags"]
-    #[doc = "  @param[in]  hostPtr Host Pointer allocated through hipHostMalloc"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipHostMalloc"]
-    pub fn hipHostGetFlags(
-        flagsPtr: *mut ::std::os::raw::c_uint,
-        hostPtr: *mut ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Register host memory so it can be accessed from the current device."]
-    #[doc = ""]
-    #[doc = "  @param[out] hostPtr Pointer to host memory to be registered."]
-    #[doc = "  @param[in] sizeBytes size of the host memory"]
-    #[doc = "  @param[in] flags.  See below."]
-    #[doc = ""]
-    #[doc = "  Flags:"]
-    #[doc = "  - #hipHostRegisterDefault   Memory is Mapped and Portable"]
-    #[doc = "  - #hipHostRegisterPortable  Memory is considered registered by all contexts.  HIP only supports"]
-    #[doc = " one context so this is always assumed true."]
-    #[doc = "  - #hipHostRegisterMapped    Map the allocation into the address space for the current device."]
-    #[doc = " The device pointer can be obtained with #hipHostGetDevicePointer."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = "  After registering the memory, use #hipHostGetDevicePointer to obtain the mapped device pointer."]
-    #[doc = "  On many systems, the mapped device pointer will have a different value than the mapped host"]
-    #[doc = " pointer.  Applications must use the device pointer in device code, and the host pointer in device"]
-    #[doc = " code."]
-    #[doc = ""]
-    #[doc = "  On some systems, registered memory is pinned.  On some systems, registered memory may not be"]
-    #[doc = " actually be pinned but uses OS or hardware facilities to all GPU access to the host memory."]
-    #[doc = ""]
-    #[doc = "  Developers are strongly encouraged to register memory blocks which are aligned to the host"]
-    #[doc = " cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction)."]
-    #[doc = ""]
-    #[doc = "  If registering non-aligned pointers, the application must take care when register pointers from"]
-    #[doc = " the same cache line on different devices.  HIP's coarse-grained synchronization model does not"]
-    #[doc = " guarantee correct results if different devices write to different parts of the same cache block -"]
-    #[doc = " typically one of the writes will \"win\" and overwrite data from the other registered memory"]
-    #[doc = " region."]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @see hipHostUnregister, hipHostGetFlags, hipHostGetDevicePointer"]
-    pub fn hipHostRegister(
-        hostPtr: *mut ::std::os::raw::c_void,
-        sizeBytes: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Un-register host pointer"]
-    #[doc = ""]
-    #[doc = "  @param[in] hostPtr Host pointer previously registered with #hipHostRegister"]
-    #[doc = "  @return Error code"]
-    #[doc = ""]
-    #[doc = "  @see hipHostRegister"]
-    pub fn hipHostUnregister(hostPtr: *mut ::std::os::raw::c_void) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  Allocates at least width (in bytes) * height bytes of linear memory"]
-    #[doc = "  Padding may occur to ensure alighnment requirements are met for the given row"]
-    #[doc = "  The change in width size due to padding will be returned in *pitch."]
-    #[doc = "  Currently the alignment is set to 128 bytes"]
-    #[doc = ""]
-    #[doc = "  @param[out] ptr Pointer to the allocated device memory"]
-    #[doc = "  @param[out] pitch Pitch for allocation (in bytes)"]
-    #[doc = "  @param[in]  width Requested pitched allocation width (in bytes)"]
-    #[doc = "  @param[in]  height Requested pitched allocation height"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @return Error code"]
-    #[doc = ""]
-    #[doc = "  @see hipMalloc, hipFree, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D,"]
-    #[doc = " hipMalloc3DArray, hipHostMalloc"]
-    pub fn hipMallocPitch(
-        ptr: *mut *mut ::std::os::raw::c_void,
-        pitch: *mut usize,
-        width: usize,
-        height: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  Allocates at least width (in bytes) * height bytes of linear memory"]
-    #[doc = "  Padding may occur to ensure alighnment requirements are met for the given row"]
-    #[doc = "  The change in width size due to padding will be returned in *pitch."]
-    #[doc = "  Currently the alignment is set to 128 bytes"]
-    #[doc = ""]
-    #[doc = "  @param[out] dptr Pointer to the allocated device memory"]
-    #[doc = "  @param[out] pitch Pitch for allocation (in bytes)"]
-    #[doc = "  @param[in]  width Requested pitched allocation width (in bytes)"]
-    #[doc = "  @param[in]  height Requested pitched allocation height"]
-    #[doc = ""]
-    #[doc = "  If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned."]
-    #[doc = "  The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array."]
-    #[doc = "  Given the row and column of an array element of type T, the address is computed as:"]
-    #[doc = "  T* pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;"]
-    #[doc = ""]
-    #[doc = "  @return Error code"]
-    #[doc = ""]
-    #[doc = "  @see hipMalloc, hipFree, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D,"]
-    #[doc = " hipMalloc3DArray, hipHostMalloc"]
-    pub fn hipMemAllocPitch(
-        dptr: *mut hipDeviceptr_t,
-        pitch: *mut usize,
-        widthInBytes: usize,
-        height: usize,
-        elementSizeBytes: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Free memory allocated by the hcc hip memory allocation API."]
-    #[doc = "  This API performs an implicit hipDeviceSynchronize() call."]
-    #[doc = "  If pointer is NULL, the hip runtime is initialized and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @param[in] ptr Pointer to memory to be freed"]
-    #[doc = "  @return #hipSuccess"]
-    #[doc = "  @return #hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated"]
-    #[doc = " with hipHostMalloc)"]
-    #[doc = ""]
-    #[doc = "  @see hipMalloc, hipMallocPitch, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D,"]
-    #[doc = " hipMalloc3DArray, hipHostMalloc"]
-    pub fn hipFree(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Free memory allocated by the hcc hip host memory allocation API.  [Deprecated]"]
-    #[doc = ""]
-    #[doc = "  @param[in] ptr Pointer to memory to be freed"]
-    #[doc = "  @return #hipSuccess,"]
-    #[doc = "          #hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with"]
-    #[doc = "hipMalloc)"]
-    #[doc = "  @deprecated use hipHostFree() instead"]
-    pub fn hipFreeHost(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Free memory allocated by the hcc hip host memory allocation API"]
-    #[doc = "  This API performs an implicit hipDeviceSynchronize() call."]
-    #[doc = "  If pointer is NULL, the hip runtime is initialized and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @param[in] ptr Pointer to memory to be freed"]
-    #[doc = "  @return #hipSuccess,"]
-    #[doc = "          #hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with"]
-    #[doc = " hipMalloc)"]
-    #[doc = ""]
-    #[doc = "  @see hipMalloc, hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D,"]
-    #[doc = " hipMalloc3DArray, hipHostMalloc"]
-    pub fn hipHostFree(ptr: *mut ::std::os::raw::c_void) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from src to dst."]
-    #[doc = ""]
-    #[doc = "  It supports memory from host to device,"]
-    #[doc = "  device to host, device to device and host to host"]
-    #[doc = "  The src and dst must not overlap."]
-    #[doc = ""]
-    #[doc = "  For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice)."]
-    #[doc = "  For multi-gpu or peer-to-peer configurations, it is recommended to set the current device to the"]
-    #[doc = "  device where the src data is physically located. For optimal peer-to-peer copies, the copy device"]
-    #[doc = "  must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy"]
-    #[doc = "  agent as the current device and src/dest as the peerDevice argument.  if this is not done, the"]
-    #[doc = "  hipMemcpy will still work, but will perform the copy using a staging buffer on the host."]
-    #[doc = "  Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in"]
-    #[doc = "  undefined behavior."]
-    #[doc = ""]
-    #[doc = "  @param[out]  dst Data being copy to"]
-    #[doc = "  @param[in]  src Data being copy from"]
-    #[doc = "  @param[in]  sizeBytes Data size in bytes"]
-    #[doc = "  @param[in]  copyType Memory copy type"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree, #hipErrorUnknowni"]
-    #[doc = ""]
-    #[doc = "  @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,"]
-    #[doc = " hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,"]
-    #[doc = " hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,"]
-    #[doc = " hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,"]
-    #[doc = " hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,"]
-    #[doc = " hipMemHostAlloc, hipMemHostGetDevicePointer"]
-    pub fn hipMemcpy(
-        dst: *mut ::std::os::raw::c_void,
-        src: *const ::std::os::raw::c_void,
-        sizeBytes: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMemcpyWithStream(
-        dst: *mut ::std::os::raw::c_void,
-        src: *const ::std::os::raw::c_void,
-        sizeBytes: usize,
-        kind: hipMemcpyKind,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from Host to Device"]
-    #[doc = ""]
-    #[doc = "  @param[out]  dst Data being copy to"]
-    #[doc = "  @param[in]   src Data being copy from"]
-    #[doc = "  @param[in]   sizeBytes Data size in bytes"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorDeInitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,"]
-    #[doc = " #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,"]
-    #[doc = " hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,"]
-    #[doc = " hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,"]
-    #[doc = " hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,"]
-    #[doc = " hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,"]
-    #[doc = " hipMemHostAlloc, hipMemHostGetDevicePointer"]
-    pub fn hipMemcpyHtoD(
-        dst: hipDeviceptr_t,
-        src: *mut ::std::os::raw::c_void,
-        sizeBytes: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from Device to Host"]
-    #[doc = ""]
-    #[doc = "  @param[out]  dst Data being copy to"]
-    #[doc = "  @param[in]   src Data being copy from"]
-    #[doc = "  @param[in]   sizeBytes Data size in bytes"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorDeInitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,"]
-    #[doc = " #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,"]
-    #[doc = " hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,"]
-    #[doc = " hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,"]
-    #[doc = " hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,"]
-    #[doc = " hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,"]
-    #[doc = " hipMemHostAlloc, hipMemHostGetDevicePointer"]
-    pub fn hipMemcpyDtoH(
-        dst: *mut ::std::os::raw::c_void,
-        src: hipDeviceptr_t,
-        sizeBytes: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from Device to Device"]
-    #[doc = ""]
-    #[doc = "  @param[out]  dst Data being copy to"]
-    #[doc = "  @param[in]   src Data being copy from"]
-    #[doc = "  @param[in]   sizeBytes Data size in bytes"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorDeInitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,"]
-    #[doc = " #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,"]
-    #[doc = " hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,"]
-    #[doc = " hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,"]
-    #[doc = " hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,"]
-    #[doc = " hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,"]
-    #[doc = " hipMemHostAlloc, hipMemHostGetDevicePointer"]
-    pub fn hipMemcpyDtoD(dst: hipDeviceptr_t, src: hipDeviceptr_t, sizeBytes: usize) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from Host to Device asynchronously"]
-    #[doc = ""]
-    #[doc = "  @param[out]  dst Data being copy to"]
-    #[doc = "  @param[in]   src Data being copy from"]
-    #[doc = "  @param[in]   sizeBytes Data size in bytes"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorDeInitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,"]
-    #[doc = " #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,"]
-    #[doc = " hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,"]
-    #[doc = " hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,"]
-    #[doc = " hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,"]
-    #[doc = " hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,"]
-    #[doc = " hipMemHostAlloc, hipMemHostGetDevicePointer"]
-    pub fn hipMemcpyHtoDAsync(
-        dst: hipDeviceptr_t,
-        src: *mut ::std::os::raw::c_void,
-        sizeBytes: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from Device to Host asynchronously"]
-    #[doc = ""]
-    #[doc = "  @param[out]  dst Data being copy to"]
-    #[doc = "  @param[in]   src Data being copy from"]
-    #[doc = "  @param[in]   sizeBytes Data size in bytes"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorDeInitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,"]
-    #[doc = " #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,"]
-    #[doc = " hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,"]
-    #[doc = " hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,"]
-    #[doc = " hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,"]
-    #[doc = " hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,"]
-    #[doc = " hipMemHostAlloc, hipMemHostGetDevicePointer"]
-    pub fn hipMemcpyDtoHAsync(
-        dst: *mut ::std::os::raw::c_void,
-        src: hipDeviceptr_t,
-        sizeBytes: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from Device to Device asynchronously"]
-    #[doc = ""]
-    #[doc = "  @param[out]  dst Data being copy to"]
-    #[doc = "  @param[in]   src Data being copy from"]
-    #[doc = "  @param[in]   sizeBytes Data size in bytes"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorDeInitialized, #hipErrorNotInitialized, #hipErrorInvalidContext,"]
-    #[doc = " #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = "  @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost,"]
-    #[doc = " hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA,"]
-    #[doc = " hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD,"]
-    #[doc = " hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync,"]
-    #[doc = " hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo,"]
-    #[doc = " hipMemHostAlloc, hipMemHostGetDevicePointer"]
-    pub fn hipMemcpyDtoDAsync(
-        dst: hipDeviceptr_t,
-        src: hipDeviceptr_t,
-        sizeBytes: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Returns a global pointer from a module."]
-    #[doc = "  Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod."]
-    #[doc = "  If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional."]
-    #[doc = "  If one of them is NULL, it is ignored and hipSuccess is returned."]
-    #[doc = ""]
-    #[doc = "  @param[out]  dptr  Returned global device pointer"]
-    #[doc = "  @param[out]  bytes Returned global size in bytes"]
-    #[doc = "  @param[in]   hmod  Module to retrieve global from"]
-    #[doc = "  @param[in]   name  Name of global to retrieve"]
-    #[doc = ""]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorNotFound, #hipErrorInvalidContext"]
-    #[doc = ""]
-    pub fn hipModuleGetGlobal(
-        dptr: *mut hipDeviceptr_t,
-        bytes: *mut usize,
-        hmod: hipModule_t,
-        name: *const ::std::os::raw::c_char,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetSymbolAddress(
-        devPtr: *mut *mut ::std::os::raw::c_void,
-        symbol: *const ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetSymbolSize(size: *mut usize, symbol: *const ::std::os::raw::c_void) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMemcpyToSymbol(
-        symbol: *const ::std::os::raw::c_void,
-        src: *const ::std::os::raw::c_void,
-        sizeBytes: usize,
-        offset: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMemcpyToSymbolAsync(
-        symbol: *const ::std::os::raw::c_void,
-        src: *const ::std::os::raw::c_void,
-        sizeBytes: usize,
-        offset: usize,
-        kind: hipMemcpyKind,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMemcpyFromSymbol(
-        dst: *mut ::std::os::raw::c_void,
-        symbol: *const ::std::os::raw::c_void,
-        sizeBytes: usize,
-        offset: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMemcpyFromSymbolAsync(
-        dst: *mut ::std::os::raw::c_void,
-        symbol: *const ::std::os::raw::c_void,
-        sizeBytes: usize,
-        offset: usize,
-        kind: hipMemcpyKind,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copy data from src to dst asynchronously."]
-    #[doc = ""]
-    #[doc = "  @warning If host or dest are not pinned, the memory copy will be performed synchronously.  For"]
-    #[doc = " best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously."]
-    #[doc = ""]
-    #[doc = "  @warning on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies."]
-    #[doc = "  For hipMemcpy, the copy is always performed by the device associated with the specified stream."]
-    #[doc = ""]
-    #[doc = "  For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a"]
-    #[doc = " attached to the device where the src data is physically located. For optimal peer-to-peer copies,"]
-    #[doc = " the copy device must be able to access the src and dst pointers (by calling"]
-    #[doc = " hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice"]
-    #[doc = " argument.  if this is not done, the hipMemcpy will still work, but will perform the copy using a"]
-    #[doc = " staging buffer on the host."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Data being copy to"]
-    #[doc = "  @param[in]  src Data being copy from"]
-    #[doc = "  @param[in]  sizeBytes Data size in bytes"]
-    #[doc = "  @param[in]  accelerator_view Accelerator view which the copy is being enqueued"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree, #hipErrorUnknown"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray,"]
-    #[doc = " hipMemcpy2DFromArray, hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyFromSymbol, hipMemcpy2DAsync, hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync,"]
-    #[doc = " hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync, hipMemcpyToSymbolAsync,"]
-    #[doc = " hipMemcpyFromSymbolAsync"]
-    pub fn hipMemcpyAsync(
-        dst: *mut ::std::os::raw::c_void,
-        src: *const ::std::os::raw::c_void,
-        sizeBytes: usize,
-        kind: hipMemcpyKind,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant"]
-    #[doc = " byte value value."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Data being filled"]
-    #[doc = "  @param[in]  constant value to be set"]
-    #[doc = "  @param[in]  sizeBytes Data size in bytes"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    pub fn hipMemset(
-        dst: *mut ::std::os::raw::c_void,
-        value: ::std::os::raw::c_int,
-        sizeBytes: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant"]
-    #[doc = " byte value value."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Data ptr to be filled"]
-    #[doc = "  @param[in]  constant value to be set"]
-    #[doc = "  @param[in]  number of values to be set"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    pub fn hipMemsetD8(
-        dest: hipDeviceptr_t,
-        value: ::std::os::raw::c_uchar,
-        count: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant"]
-    #[doc = " byte value value."]
-    #[doc = ""]
-    #[doc = " hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the"]
-    #[doc = " memset is complete. The operation can optionally be associated to a stream by passing a non-zero"]
-    #[doc = " stream argument. If stream is non-zero, the operation may overlap with operations in other"]
-    #[doc = " streams."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Data ptr to be filled"]
-    #[doc = "  @param[in]  constant value to be set"]
-    #[doc = "  @param[in]  number of values to be set"]
-    #[doc = "  @param[in]  stream - Stream identifier"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    pub fn hipMemsetD8Async(
-        dest: hipDeviceptr_t,
-        value: ::std::os::raw::c_uchar,
-        count: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant"]
-    #[doc = " short value value."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Data ptr to be filled"]
-    #[doc = "  @param[in]  constant value to be set"]
-    #[doc = "  @param[in]  number of values to be set"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    pub fn hipMemsetD16(
-        dest: hipDeviceptr_t,
-        value: ::std::os::raw::c_ushort,
-        count: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant"]
-    #[doc = " short value value."]
-    #[doc = ""]
-    #[doc = " hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the"]
-    #[doc = " memset is complete. The operation can optionally be associated to a stream by passing a non-zero"]
-    #[doc = " stream argument. If stream is non-zero, the operation may overlap with operations in other"]
-    #[doc = " streams."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Data ptr to be filled"]
-    #[doc = "  @param[in]  constant value to be set"]
-    #[doc = "  @param[in]  number of values to be set"]
-    #[doc = "  @param[in]  stream - Stream identifier"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    pub fn hipMemsetD16Async(
-        dest: hipDeviceptr_t,
-        value: ::std::os::raw::c_ushort,
-        count: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the memory area pointed to by dest with the constant integer"]
-    #[doc = " value for specified number of times."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Data being filled"]
-    #[doc = "  @param[in]  constant value to be set"]
-    #[doc = "  @param[in]  number of values to be set"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    pub fn hipMemsetD32(
-        dest: hipDeviceptr_t,
-        value: ::std::os::raw::c_int,
-        count: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant"]
-    #[doc = " byte value value."]
-    #[doc = ""]
-    #[doc = "  hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the"]
-    #[doc = " memset is complete. The operation can optionally be associated to a stream by passing a non-zero"]
-    #[doc = " stream argument. If stream is non-zero, the operation may overlap with operations in other"]
-    #[doc = " streams."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Pointer to device memory"]
-    #[doc = "  @param[in]  value - Value to set for each byte of specified memory"]
-    #[doc = "  @param[in]  sizeBytes - Size in bytes to set"]
-    #[doc = "  @param[in]  stream - Stream identifier"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree"]
-    pub fn hipMemsetAsync(
-        dst: *mut ::std::os::raw::c_void,
-        value: ::std::os::raw::c_int,
-        sizeBytes: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the memory area pointed to by dev with the constant integer"]
-    #[doc = " value for specified number of times."]
-    #[doc = ""]
-    #[doc = "  hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the"]
-    #[doc = " memset is complete. The operation can optionally be associated to a stream by passing a non-zero"]
-    #[doc = " stream argument. If stream is non-zero, the operation may overlap with operations in other"]
-    #[doc = " streams."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Pointer to device memory"]
-    #[doc = "  @param[in]  value - Value to set for each byte of specified memory"]
-    #[doc = "  @param[in]  count - number of values to be set"]
-    #[doc = "  @param[in]  stream - Stream identifier"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree"]
-    pub fn hipMemsetD32Async(
-        dst: hipDeviceptr_t,
-        value: ::std::os::raw::c_int,
-        count: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills the memory area pointed to by dst with the constant value."]
-    #[doc = ""]
-    #[doc = "  @param[out] dst Pointer to device memory"]
-    #[doc = "  @param[in]  pitch - data size in bytes"]
-    #[doc = "  @param[in]  value - constant value to be set"]
-    #[doc = "  @param[in]  width"]
-    #[doc = "  @param[in]  height"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree"]
-    pub fn hipMemset2D(
-        dst: *mut ::std::os::raw::c_void,
-        pitch: usize,
-        value: ::std::os::raw::c_int,
-        width: usize,
-        height: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills asynchronously the memory area pointed to by dst with the constant value."]
-    #[doc = ""]
-    #[doc = "  @param[in]  dst Pointer to device memory"]
-    #[doc = "  @param[in]  pitch - data size in bytes"]
-    #[doc = "  @param[in]  value - constant value to be set"]
-    #[doc = "  @param[in]  width"]
-    #[doc = "  @param[in]  height"]
-    #[doc = "  @param[in]  stream"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree"]
-    pub fn hipMemset2DAsync(
-        dst: *mut ::std::os::raw::c_void,
-        pitch: usize,
-        value: ::std::os::raw::c_int,
-        width: usize,
-        height: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value."]
-    #[doc = ""]
-    #[doc = "  @param[in] pitchedDevPtr"]
-    #[doc = "  @param[in]  value - constant value to be set"]
-    #[doc = "  @param[in]  extent"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree"]
-    pub fn hipMemset3D(
-        pitchedDevPtr: hipPitchedPtr,
-        value: ::std::os::raw::c_int,
-        extent: hipExtent,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value."]
-    #[doc = ""]
-    #[doc = "  @param[in] pitchedDevPtr"]
-    #[doc = "  @param[in]  value - constant value to be set"]
-    #[doc = "  @param[in]  extent"]
-    #[doc = "  @param[in]  stream"]
-    #[doc = "  @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree"]
-    pub fn hipMemset3DAsync(
-        pitchedDevPtr: hipPitchedPtr,
-        value: ::std::os::raw::c_int,
-        extent: hipExtent,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Query memory info."]
-    #[doc = " Return snapshot of free memory, and total allocatable memory on the device."]
-    #[doc = ""]
-    #[doc = " Returns in *free a snapshot of the current free memory."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue"]
-    #[doc = " @warning On HCC, the free memory only accounts for memory allocated by this process and may be"]
-    #[doc = "optimistic."]
-    pub fn hipMemGetInfo(free: *mut usize, total: *mut usize) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMemPtrGetInfo(ptr: *mut ::std::os::raw::c_void, size: *mut usize) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Allocate an array on the device."]
-    #[doc = ""]
-    #[doc = "  @param[out]  array  Pointer to allocated array in device memory"]
-    #[doc = "  @param[in]   desc   Requested channel format"]
-    #[doc = "  @param[in]   width  Requested array allocation width"]
-    #[doc = "  @param[in]   height Requested array allocation height"]
-    #[doc = "  @param[in]   flags  Requested properties of allocated array"]
-    #[doc = "  @return      #hipSuccess, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @see hipMalloc, hipMallocPitch, hipFree, hipFreeArray, hipHostMalloc, hipHostFree"]
-    pub fn hipMallocArray(
-        array: *mut *mut hipArray,
-        desc: *const hipChannelFormatDesc,
-        width: usize,
-        height: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipArrayCreate(
-        pHandle: *mut *mut hipArray,
-        pAllocateArray: *const HIP_ARRAY_DESCRIPTOR,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipArrayDestroy(array: *mut hipArray) -> hipError_t;
-}
-extern "C" {
-    pub fn hipArray3DCreate(
-        array: *mut *mut hipArray,
-        pAllocateArray: *const HIP_ARRAY3D_DESCRIPTOR,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMalloc3D(pitchedDevPtr: *mut hipPitchedPtr, extent: hipExtent) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Frees an array on the device."]
-    #[doc = ""]
-    #[doc = "  @param[in]  array  Pointer to array to free"]
-    #[doc = "  @return     #hipSuccess, #hipErrorInvalidValue, #hipErrorNotInitialized"]
-    #[doc = ""]
-    #[doc = "  @see hipMalloc, hipMallocPitch, hipFree, hipMallocArray, hipHostMalloc, hipHostFree"]
-    pub fn hipFreeArray(array: *mut hipArray) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Frees a mipmapped array on the device"]
-    #[doc = ""]
-    #[doc = " @param[in] mipmappedArray - Pointer to mipmapped array to free"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipFreeMipmappedArray(mipmappedArray: hipMipmappedArray_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Allocate an array on the device."]
-    #[doc = ""]
-    #[doc = "  @param[out]  array  Pointer to allocated array in device memory"]
-    #[doc = "  @param[in]   desc   Requested channel format"]
-    #[doc = "  @param[in]   extent Requested array allocation width, height and depth"]
-    #[doc = "  @param[in]   flags  Requested properties of allocated array"]
-    #[doc = "  @return      #hipSuccess, #hipErrorOutOfMemory"]
-    #[doc = ""]
-    #[doc = "  @see hipMalloc, hipMallocPitch, hipFree, hipFreeArray, hipHostMalloc, hipHostFree"]
-    pub fn hipMalloc3DArray(
-        array: *mut *mut hipArray,
-        desc: *const hipChannelFormatDesc,
-        extent: hipExtent,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Allocate a mipmapped array on the device"]
-    #[doc = ""]
-    #[doc = " @param[out] mipmappedArray  - Pointer to allocated mipmapped array in device memory"]
-    #[doc = " @param[in]  desc            - Requested channel format"]
-    #[doc = " @param[in]  extent          - Requested allocation size (width field in elements)"]
-    #[doc = " @param[in]  numLevels       - Number of mipmap levels to allocate"]
-    #[doc = " @param[in]  flags           - Flags for extensions"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryAllocation"]
-    pub fn hipMallocMipmappedArray(
-        mipmappedArray: *mut hipMipmappedArray_t,
-        desc: *const hipChannelFormatDesc,
-        extent: hipExtent,
-        numLevels: ::std::os::raw::c_uint,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Gets a mipmap level of a HIP mipmapped array"]
-    #[doc = ""]
-    #[doc = " @param[out] levelArray     - Returned mipmap level HIP array"]
-    #[doc = " @param[in]  mipmappedArray - HIP mipmapped array"]
-    #[doc = " @param[in]  level          - Mipmap level"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipGetMipmappedArrayLevel(
-        levelArray: *mut hipArray_t,
-        mipmappedArray: hipMipmappedArray_const_t,
-        level: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst    Destination memory address"]
-    #[doc = "  @param[in]   dpitch Pitch of destination memory"]
-    #[doc = "  @param[in]   src    Source memory address"]
-    #[doc = "  @param[in]   spitch Pitch of source memory"]
-    #[doc = "  @param[in]   width  Width of matrix transfer (columns in bytes)"]
-    #[doc = "  @param[in]   height Height of matrix transfer (rows)"]
-    #[doc = "  @param[in]   kind   Type of transfer"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy2D(
-        dst: *mut ::std::os::raw::c_void,
-        dpitch: usize,
-        src: *const ::std::os::raw::c_void,
-        spitch: usize,
-        width: usize,
-        height: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies memory for 2D arrays."]
-    #[doc = "  @param[in]   pCopy Parameters for the memory copy"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = "  #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray,"]
-    #[doc = " hipMemcpyToSymbol, hipMemcpyAsync"]
-    pub fn hipMemcpyParam2D(pCopy: *const hip_Memcpy2D) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies memory for 2D arrays."]
-    #[doc = "  @param[in]   pCopy Parameters for the memory copy"]
-    #[doc = "  @param[in]   stream Stream to use"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray,"]
-    #[doc = " hipMemcpyToSymbol, hipMemcpyAsync"]
-    pub fn hipMemcpyParam2DAsync(pCopy: *const hip_Memcpy2D, stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst    Destination memory address"]
-    #[doc = "  @param[in]   dpitch Pitch of destination memory"]
-    #[doc = "  @param[in]   src    Source memory address"]
-    #[doc = "  @param[in]   spitch Pitch of source memory"]
-    #[doc = "  @param[in]   width  Width of matrix transfer (columns in bytes)"]
-    #[doc = "  @param[in]   height Height of matrix transfer (rows)"]
-    #[doc = "  @param[in]   kind   Type of transfer"]
-    #[doc = "  @param[in]   stream Stream to use"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy2DAsync(
-        dst: *mut ::std::os::raw::c_void,
-        dpitch: usize,
-        src: *const ::std::os::raw::c_void,
-        spitch: usize,
-        width: usize,
-        height: usize,
-        kind: hipMemcpyKind,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst     Destination memory address"]
-    #[doc = "  @param[in]   wOffset Destination starting X offset"]
-    #[doc = "  @param[in]   hOffset Destination starting Y offset"]
-    #[doc = "  @param[in]   src     Source memory address"]
-    #[doc = "  @param[in]   spitch  Pitch of source memory"]
-    #[doc = "  @param[in]   width   Width of matrix transfer (columns in bytes)"]
-    #[doc = "  @param[in]   height  Height of matrix transfer (rows)"]
-    #[doc = "  @param[in]   kind    Type of transfer"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy2DToArray(
-        dst: *mut hipArray,
-        wOffset: usize,
-        hOffset: usize,
-        src: *const ::std::os::raw::c_void,
-        spitch: usize,
-        width: usize,
-        height: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst     Destination memory address"]
-    #[doc = "  @param[in]   wOffset Destination starting X offset"]
-    #[doc = "  @param[in]   hOffset Destination starting Y offset"]
-    #[doc = "  @param[in]   src     Source memory address"]
-    #[doc = "  @param[in]   spitch  Pitch of source memory"]
-    #[doc = "  @param[in]   width   Width of matrix transfer (columns in bytes)"]
-    #[doc = "  @param[in]   height  Height of matrix transfer (rows)"]
-    #[doc = "  @param[in]   kind    Type of transfer"]
-    #[doc = "  @param[in]   stream    Accelerator view which the copy is being enqueued"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy2DToArrayAsync(
-        dst: *mut hipArray,
-        wOffset: usize,
-        hOffset: usize,
-        src: *const ::std::os::raw::c_void,
-        spitch: usize,
-        width: usize,
-        height: usize,
-        kind: hipMemcpyKind,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst     Destination memory address"]
-    #[doc = "  @param[in]   wOffset Destination starting X offset"]
-    #[doc = "  @param[in]   hOffset Destination starting Y offset"]
-    #[doc = "  @param[in]   src     Source memory address"]
-    #[doc = "  @param[in]   count   size in bytes to copy"]
-    #[doc = "  @param[in]   kind    Type of transfer"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpyToArray(
-        dst: *mut hipArray,
-        wOffset: usize,
-        hOffset: usize,
-        src: *const ::std::os::raw::c_void,
-        count: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst       Destination memory address"]
-    #[doc = "  @param[in]   srcArray  Source memory address"]
-    #[doc = "  @param[in]   woffset   Source starting X offset"]
-    #[doc = "  @param[in]   hOffset   Source starting Y offset"]
-    #[doc = "  @param[in]   count     Size in bytes to copy"]
-    #[doc = "  @param[in]   kind      Type of transfer"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpyFromArray(
-        dst: *mut ::std::os::raw::c_void,
-        srcArray: hipArray_const_t,
-        wOffset: usize,
-        hOffset: usize,
-        count: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst       Destination memory address"]
-    #[doc = "  @param[in]   dpitch    Pitch of destination memory"]
-    #[doc = "  @param[in]   src       Source memory address"]
-    #[doc = "  @param[in]   wOffset   Source starting X offset"]
-    #[doc = "  @param[in]   hOffset   Source starting Y offset"]
-    #[doc = "  @param[in]   width     Width of matrix transfer (columns in bytes)"]
-    #[doc = "  @param[in]   height    Height of matrix transfer (rows)"]
-    #[doc = "  @param[in]   kind      Type of transfer"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy2DFromArray(
-        dst: *mut ::std::os::raw::c_void,
-        dpitch: usize,
-        src: hipArray_const_t,
-        wOffset: usize,
-        hOffset: usize,
-        width: usize,
-        height: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device asynchronously."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst       Destination memory address"]
-    #[doc = "  @param[in]   dpitch    Pitch of destination memory"]
-    #[doc = "  @param[in]   src       Source memory address"]
-    #[doc = "  @param[in]   wOffset   Source starting X offset"]
-    #[doc = "  @param[in]   hOffset   Source starting Y offset"]
-    #[doc = "  @param[in]   width     Width of matrix transfer (columns in bytes)"]
-    #[doc = "  @param[in]   height    Height of matrix transfer (rows)"]
-    #[doc = "  @param[in]   kind      Type of transfer"]
-    #[doc = "  @param[in]   stream    Accelerator view which the copy is being enqueued"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy2DFromArrayAsync(
-        dst: *mut ::std::os::raw::c_void,
-        dpitch: usize,
-        src: hipArray_const_t,
-        wOffset: usize,
-        hOffset: usize,
-        width: usize,
-        height: usize,
-        kind: hipMemcpyKind,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dst       Destination memory address"]
-    #[doc = "  @param[in]   srcArray  Source array"]
-    #[doc = "  @param[in]   srcoffset Offset in bytes of source array"]
-    #[doc = "  @param[in]   count     Size of memory copy in bytes"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpyAtoH(
-        dst: *mut ::std::os::raw::c_void,
-        srcArray: *mut hipArray,
-        srcOffset: usize,
-        count: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   dstArray   Destination memory address"]
-    #[doc = "  @param[in]   dstOffset  Offset in bytes of destination array"]
-    #[doc = "  @param[in]   srcHost    Source host pointer"]
-    #[doc = "  @param[in]   count      Size of memory copy in bytes"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpyHtoA(
-        dstArray: *mut hipArray,
-        dstOffset: usize,
-        srcHost: *const ::std::os::raw::c_void,
-        count: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   p   3D memory copy parameters"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy3D(p: *const hipMemcpy3DParms) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device asynchronously."]
-    #[doc = ""]
-    #[doc = "  @param[in]   p        3D memory copy parameters"]
-    #[doc = "  @param[in]   stream   Stream to use"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = " #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipMemcpy3DAsync(p: *const hipMemcpy3DParms, stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device."]
-    #[doc = ""]
-    #[doc = "  @param[in]   pCopy   3D memory copy parameters"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = "  #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipDrvMemcpy3D(pCopy: *const HIP_MEMCPY3D) -> hipError_t;
-}
-extern "C" {
-    #[doc = "  @brief Copies data between host and device asynchronously."]
-    #[doc = ""]
-    #[doc = "  @param[in]   pCopy    3D memory copy parameters"]
-    #[doc = "  @param[in]   stream   Stream to use"]
-    #[doc = "  @return      #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,"]
-    #[doc = "  #hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection"]
-    #[doc = ""]
-    #[doc = "  @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol,"]
-    #[doc = " hipMemcpyAsync"]
-    pub fn hipDrvMemcpy3DAsync(pCopy: *const HIP_MEMCPY3D, stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup PeerToPeer PeerToPeer Device Memory Access"]
-    #[doc = "  @{"]
-    #[doc = "  @warning PeerToPeer support is experimental."]
-    #[doc = "  This section describes the PeerToPeer device memory access functions of HIP runtime API."]
-    #[doc = " @brief Determine if a device can access a peer's memory."]
-    #[doc = ""]
-    #[doc = " @param [out] canAccessPeer Returns the peer access capability (0 or 1)"]
-    #[doc = " @param [in] device - device from where memory may be accessed."]
-    #[doc = " @param [in] peerDevice - device where memory is physically located"]
-    #[doc = ""]
-    #[doc = " Returns \"1\" in @p canAccessPeer if the specified @p device is capable"]
-    #[doc = " of directly accessing memory physically located on peerDevice , or \"0\" if not."]
-    #[doc = ""]
-    #[doc = " Returns \"0\" in @p canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a"]
-    #[doc = " device is not a peer of itself."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess,"]
-    #[doc = " @returns #hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices"]
-    pub fn hipDeviceCanAccessPeer(
-        canAccessPeer: *mut ::std::os::raw::c_int,
-        deviceId: ::std::os::raw::c_int,
-        peerDeviceId: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Enable direct access from current device's virtual address space to memory allocations"]
-    #[doc = " physically located on a peer device."]
-    #[doc = ""]
-    #[doc = " Memory which already allocated on peer device will be mapped into the address space of the"]
-    #[doc = " current device.  In addition, all future memory allocations on peerDeviceId will be mapped into"]
-    #[doc = " the address space of the current device when the memory is allocated. The peer memory remains"]
-    #[doc = " accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " @param [in] peerDeviceId"]
-    #[doc = " @param [in] flags"]
-    #[doc = ""]
-    #[doc = " Returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue,"]
-    #[doc = " @returns #hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device."]
-    pub fn hipDeviceEnablePeerAccess(
-        peerDeviceId: ::std::os::raw::c_int,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Disable direct access from current device's virtual address space to memory allocations"]
-    #[doc = " physically located on a peer device."]
-    #[doc = ""]
-    #[doc = " Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been"]
-    #[doc = " enabled from the current device."]
-    #[doc = ""]
-    #[doc = " @param [in] peerDeviceId"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorPeerAccessNotEnabled"]
-    pub fn hipDeviceDisablePeerAccess(peerDeviceId: ::std::os::raw::c_int) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Get information on memory allocations."]
-    #[doc = ""]
-    #[doc = " @param [out] pbase - BAse pointer address"]
-    #[doc = " @param [out] psize - Size of allocation"]
-    #[doc = " @param [in]  dptr- Device Pointer"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevicePointer"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipMemGetAddressRange(
-        pbase: *mut hipDeviceptr_t,
-        psize: *mut usize,
-        dptr: hipDeviceptr_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Copies memory from one device to memory on another device."]
-    #[doc = ""]
-    #[doc = " @param [out] dst - Destination device pointer."]
-    #[doc = " @param [in] dstDeviceId - Destination device"]
-    #[doc = " @param [in] src - Source device pointer"]
-    #[doc = " @param [in] srcDeviceId - Source device"]
-    #[doc = " @param [in] sizeBytes - Size of memory copy in bytes"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDevice"]
-    pub fn hipMemcpyPeer(
-        dst: *mut ::std::os::raw::c_void,
-        dstDeviceId: ::std::os::raw::c_int,
-        src: *const ::std::os::raw::c_void,
-        srcDeviceId: ::std::os::raw::c_int,
-        sizeBytes: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Copies memory from one device to memory on another device."]
-    #[doc = ""]
-    #[doc = " @param [out] dst - Destination device pointer."]
-    #[doc = " @param [in] dstDevice - Destination device"]
-    #[doc = " @param [in] src - Source device pointer"]
-    #[doc = " @param [in] srcDevice - Source device"]
-    #[doc = " @param [in] sizeBytes - Size of memory copy in bytes"]
-    #[doc = " @param [in] stream - Stream identifier"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDevice"]
-    pub fn hipMemcpyPeerAsync(
-        dst: *mut ::std::os::raw::c_void,
-        dstDeviceId: ::std::os::raw::c_int,
-        src: *const ::std::os::raw::c_void,
-        srcDevice: ::std::os::raw::c_int,
-        sizeBytes: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Context Context Management"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the context management functions of HIP runtime API."]
-    #[doc = ""]
-    #[doc = "  @addtogroup ContextD Context Management [Deprecated]"]
-    #[doc = "  @{"]
-    #[doc = "  @ingroup Context"]
-    #[doc = "  This section describes the deprecated context management functions of HIP runtime API."]
-    #[doc = " @brief Create a context and set it as current/ default context"]
-    #[doc = ""]
-    #[doc = " @param [out] ctx"]
-    #[doc = " @param [in] flags"]
-    #[doc = " @param [in] associated device handle"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxPushCurrent,"]
-    #[doc = " hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxCreate(
-        ctx: *mut hipCtx_t,
-        flags: ::std::os::raw::c_uint,
-        device: hipDevice_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Destroy a HIP context."]
-    #[doc = ""]
-    #[doc = " @param [in] ctx Context to destroy"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,hipCtxSetCurrent,"]
-    #[doc = " hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice"]
-    pub fn hipCtxDestroy(ctx: hipCtx_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Pop the current/default context and return the popped context."]
-    #[doc = ""]
-    #[doc = " @param [out] ctx"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidContext"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxSetCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxPopCurrent(ctx: *mut hipCtx_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Push the context to be set as current/ default context"]
-    #[doc = ""]
-    #[doc = " @param [in] ctx"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidContext"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice"]
-    pub fn hipCtxPushCurrent(ctx: hipCtx_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set the passed context as current/default"]
-    #[doc = ""]
-    #[doc = " @param [in] ctx"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidContext"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice"]
-    pub fn hipCtxSetCurrent(ctx: hipCtx_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Get the handle of the current/ default context"]
-    #[doc = ""]
-    #[doc = " @param [out] ctx"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidContext"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetDevice, hipCtxGetFlags, hipCtxPopCurrent,"]
-    #[doc = " hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxGetCurrent(ctx: *mut hipCtx_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Get the handle of the device associated with current/default context"]
-    #[doc = ""]
-    #[doc = " @param [out] device"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidContext"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize"]
-    pub fn hipCtxGetDevice(device: *mut hipDevice_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns the approximate HIP api version."]
-    #[doc = ""]
-    #[doc = " @param [in]  ctx Context to check"]
-    #[doc = " @param [out] apiVersion"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @warning The HIP feature set does not correspond to an exact CUDA SDK api revision."]
-    #[doc = " This function always set *apiVersion to 4 as an approximation though HIP supports"]
-    #[doc = " some features which were introduced in later CUDA SDK revisions."]
-    #[doc = " HIP apps code should not rely on the api revision number here and should"]
-    #[doc = " use arch feature flags to test device capabilities or conditional compilation."]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetDevice, hipCtxGetFlags, hipCtxPopCurrent,"]
-    #[doc = " hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxGetApiVersion(ctx: hipCtx_t, apiVersion: *mut ::std::os::raw::c_int)
-        -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set Cache configuration for a specific function"]
-    #[doc = ""]
-    #[doc = " @param [out] cacheConfiguration"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @warning AMD devices and some Nvidia GPUS do not support reconfigurable cache.  This hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxGetCacheConfig(cacheConfig: *mut hipFuncCache_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set L1/Shared cache partition."]
-    #[doc = ""]
-    #[doc = " @param [in] cacheConfiguration"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @warning AMD devices and some Nvidia GPUS do not support reconfigurable cache.  This hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxSetCacheConfig(cacheConfig: hipFuncCache_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set Shared memory bank configuration."]
-    #[doc = ""]
-    #[doc = " @param [in] sharedMemoryConfiguration"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @warning AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxSetSharedMemConfig(config: hipSharedMemConfig) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Get Shared memory bank configuration."]
-    #[doc = ""]
-    #[doc = " @param [out] sharedMemoryConfiguration"]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @warning AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is"]
-    #[doc = " ignored on those architectures."]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxGetSharedMemConfig(pConfig: *mut hipSharedMemConfig) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Blocks until the default context has completed all preceding requested tasks."]
-    #[doc = ""]
-    #[doc = " @return #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @warning This function waits for all streams on the default context to complete execution, and"]
-    #[doc = " then returns."]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxGetDevice"]
-    pub fn hipCtxSynchronize() -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Return flags used for creating default context."]
-    #[doc = ""]
-    #[doc = " @param [out] flags"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Enables direct access to memory allocations in a peer context."]
-    #[doc = ""]
-    #[doc = " Memory which already allocated on peer device will be mapped into the address space of the"]
-    #[doc = " current device.  In addition, all future memory allocations on peerDeviceId will be mapped into"]
-    #[doc = " the address space of the current device when the memory is allocated. The peer memory remains"]
-    #[doc = " accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset."]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " @param [in] peerCtx"]
-    #[doc = " @param [in] flags"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidDevice, #hipErrorInvalidValue,"]
-    #[doc = " #hipErrorPeerAccessAlreadyEnabled"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    #[doc = " @warning PeerToPeer support is experimental."]
-    pub fn hipCtxEnablePeerAccess(peerCtx: hipCtx_t, flags: ::std::os::raw::c_uint) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Disable direct access from current context's virtual address space to memory allocations"]
-    #[doc = " physically located on a peer context.Disables direct access to memory allocations in a peer"]
-    #[doc = " context and unregisters any registered allocations."]
-    #[doc = ""]
-    #[doc = " Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been"]
-    #[doc = " enabled from the current device."]
-    #[doc = ""]
-    #[doc = " @param [in] peerCtx"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorPeerAccessNotEnabled"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    #[doc = " @warning PeerToPeer support is experimental."]
-    pub fn hipCtxDisablePeerAccess(peerCtx: hipCtx_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = " @brief Get the state of the primary context."]
-    #[doc = ""]
-    #[doc = " @param [in] Device to get primary context flags for"]
-    #[doc = " @param [out] Pointer to store flags"]
-    #[doc = " @param [out] Pointer to store context state; 0 = inactive, 1 = active"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipDevicePrimaryCtxGetState(
-        dev: hipDevice_t,
-        flags: *mut ::std::os::raw::c_uint,
-        active: *mut ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Release the primary context on the GPU."]
-    #[doc = ""]
-    #[doc = " @param [in] Device which primary context is released"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    #[doc = " @warning This function return #hipSuccess though doesn't release the primaryCtx by design on"]
-    #[doc = " HIP/HCC path."]
-    pub fn hipDevicePrimaryCtxRelease(dev: hipDevice_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Retain the primary context on the GPU."]
-    #[doc = ""]
-    #[doc = " @param [out] Returned context handle of the new context"]
-    #[doc = " @param [in] Device which primary context is released"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipDevicePrimaryCtxRetain(pctx: *mut hipCtx_t, dev: hipDevice_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Resets the primary context on the GPU."]
-    #[doc = ""]
-    #[doc = " @param [in] Device which primary context is reset"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipDevicePrimaryCtxReset(dev: hipDevice_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set flags for the primary context."]
-    #[doc = ""]
-    #[doc = " @param [in] Device for which the primary context flags are set"]
-    #[doc = " @param [in] New flags for the device"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorContextAlreadyInUse"]
-    #[doc = ""]
-    #[doc = " @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,"]
-    #[doc = " hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice"]
-    pub fn hipDevicePrimaryCtxSetFlags(
-        dev: hipDevice_t,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = ""]
-    #[doc = "  @defgroup Module Module Management"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the module management functions of HIP runtime API."]
-    #[doc = ""]
-    #[doc = " @brief Loads code object from file into a hipModule_t"]
-    #[doc = ""]
-    #[doc = " @param [in] fname"]
-    #[doc = " @param [out] module"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipErrorInvalidValue, hipErrorInvalidContext, hipErrorFileNotFound,"]
-    #[doc = " hipErrorOutOfMemory, hipErrorSharedObjectInitFailed, hipErrorNotInitialized"]
-    #[doc = ""]
-    #[doc = ""]
-    pub fn hipModuleLoad(
-        module: *mut hipModule_t,
-        fname: *const ::std::os::raw::c_char,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Frees the module"]
-    #[doc = ""]
-    #[doc = " @param [in] module"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidValue"]
-    #[doc = " module is freed and the code objects associated with it are destroyed"]
-    #[doc = ""]
-    pub fn hipModuleUnload(module: hipModule_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Function with kname will be extracted if present in module"]
-    #[doc = ""]
-    #[doc = " @param [in] module"]
-    #[doc = " @param [in] kname"]
-    #[doc = " @param [out] function"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipErrorInvalidValue, hipErrorInvalidContext, hipErrorNotInitialized,"]
-    #[doc = " hipErrorNotFound,"]
-    pub fn hipModuleGetFunction(
-        function: *mut hipFunction_t,
-        module: hipModule_t,
-        kname: *const ::std::os::raw::c_char,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Find out attributes for a given function."]
-    #[doc = ""]
-    #[doc = " @param [out] attr"]
-    #[doc = " @param [in] func"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipErrorInvalidValue, hipErrorInvalidDeviceFunction"]
-    pub fn hipFuncGetAttributes(
-        attr: *mut hipFuncAttributes,
-        func: *const ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Find out a specific attribute for a given function."]
-    #[doc = ""]
-    #[doc = " @param [out] value"]
-    #[doc = " @param [in]  attrib"]
-    #[doc = " @param [in]  hfunc"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipErrorInvalidValue, hipErrorInvalidDeviceFunction"]
-    pub fn hipFuncGetAttribute(
-        value: *mut ::std::os::raw::c_int,
-        attrib: hipFunction_attribute,
-        hfunc: hipFunction_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief returns the handle of the texture reference with the name from the module."]
-    #[doc = ""]
-    #[doc = " @param [in] hmod"]
-    #[doc = " @param [in] name"]
-    #[doc = " @param [out] texRef"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipErrorNotInitialized, hipErrorNotFound, hipErrorInvalidValue"]
-    pub fn hipModuleGetTexRef(
-        texRef: *mut *mut textureReference,
-        hmod: hipModule_t,
-        name: *const ::std::os::raw::c_char,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief builds module from code object which resides in host memory. Image is pointer to that"]
-    #[doc = " location."]
-    #[doc = ""]
-    #[doc = " @param [in] image"]
-    #[doc = " @param [out] module"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipErrorNotInitialized, hipErrorOutOfMemory, hipErrorNotInitialized"]
-    pub fn hipModuleLoadData(
-        module: *mut hipModule_t,
-        image: *const ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief builds module from code object which resides in host memory. Image is pointer to that"]
-    #[doc = " location. Options are not used. hipModuleLoadData is called."]
-    #[doc = ""]
-    #[doc = " @param [in] image"]
-    #[doc = " @param [out] module"]
-    #[doc = " @param [in] number of options"]
-    #[doc = " @param [in] options for JIT"]
-    #[doc = " @param [in] option values for JIT"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipErrorNotInitialized, hipErrorOutOfMemory, hipErrorNotInitialized"]
-    pub fn hipModuleLoadDataEx(
-        module: *mut hipModule_t,
-        image: *const ::std::os::raw::c_void,
-        numOptions: ::std::os::raw::c_uint,
-        options: *mut hipJitOption,
-        optionValues: *mut *mut ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief launches kernel f with launch parameters and shared memory on stream with arguments passed"]
-    #[doc = " to kernelparams or extra"]
-    #[doc = ""]
-    #[doc = " @param [in] f         Kernel to launch."]
-    #[doc = " @param [in] gridDimX  X grid dimension specified as multiple of blockDimX."]
-    #[doc = " @param [in] gridDimY  Y grid dimension specified as multiple of blockDimY."]
-    #[doc = " @param [in] gridDimZ  Z grid dimension specified as multiple of blockDimZ."]
-    #[doc = " @param [in] blockDimX X block dimensions specified in work-items"]
-    #[doc = " @param [in] blockDimY Y grid dimension specified in work-items"]
-    #[doc = " @param [in] blockDimZ Z grid dimension specified in work-items"]
-    #[doc = " @param [in] sharedMemBytes Amount of dynamic shared memory to allocate for this kernel. The"]
-    #[doc = " HIP-Clang compiler provides support for extern shared declarations."]
-    #[doc = " @param [in] stream    Stream where the kernel should be dispatched.  May be 0, in which case th"]
-    #[doc = " default stream is used with associated synchronization rules."]
-    #[doc = " @param [in] kernelParams"]
-    #[doc = " @param [in] extra     Pointer to kernel arguments.   These are passed directly to the kernel and"]
-    #[doc = " must be in the memory layout and alignment expected by the kernel."]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorNotInitialized, hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " @warning kernellParams argument is not yet implemented in HIP. Please use extra instead. Please"]
-    #[doc = " refer to hip_porting_driver_api.md for sample usage."]
-    pub fn hipModuleLaunchKernel(
-        f: hipFunction_t,
-        gridDimX: ::std::os::raw::c_uint,
-        gridDimY: ::std::os::raw::c_uint,
-        gridDimZ: ::std::os::raw::c_uint,
-        blockDimX: ::std::os::raw::c_uint,
-        blockDimY: ::std::os::raw::c_uint,
-        blockDimZ: ::std::os::raw::c_uint,
-        sharedMemBytes: ::std::os::raw::c_uint,
-        stream: hipStream_t,
-        kernelParams: *mut *mut ::std::os::raw::c_void,
-        extra: *mut *mut ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief launches kernel f with launch parameters and shared memory on stream with arguments passed"]
-    #[doc = " to kernelparams or extra, where thread blocks can cooperate and synchronize as they execute"]
-    #[doc = ""]
-    #[doc = " @param [in] f         Kernel to launch."]
-    #[doc = " @param [in] gridDim   Grid dimensions specified as multiple of blockDim."]
-    #[doc = " @param [in] blockDim  Block dimensions specified in work-items"]
-    #[doc = " @param [in] kernelParams A list of kernel arguments"]
-    #[doc = " @param [in] sharedMemBytes Amount of dynamic shared memory to allocate for this kernel. The"]
-    #[doc = " HIP-Clang compiler provides support for extern shared declarations."]
-    #[doc = " @param [in] stream    Stream where the kernel should be dispatched.  May be 0, in which case th"]
-    #[doc = " default stream is used with associated synchronization rules."]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorNotInitialized, hipErrorInvalidValue, hipErrorCooperativeLaunchTooLarge"]
-    pub fn hipLaunchCooperativeKernel(
-        f: *const ::std::os::raw::c_void,
-        gridDim: dim3,
-        blockDimX: dim3,
-        kernelParams: *mut *mut ::std::os::raw::c_void,
-        sharedMemBytes: ::std::os::raw::c_uint,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Launches kernels on multiple devices where thread blocks can cooperate and"]
-    #[doc = " synchronize as they execute."]
-    #[doc = ""]
-    #[doc = " @param [in] launchParamsList         List of launch parameters, one per device."]
-    #[doc = " @param [in] numDevices               Size of the launchParamsList array."]
-    #[doc = " @param [in] flags                    Flags to control launch behavior."]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorNotInitialized, hipErrorInvalidValue, hipErrorCooperativeLaunchTooLarge"]
-    pub fn hipLaunchCooperativeKernelMultiDevice(
-        launchParamsList: *mut hipLaunchParams,
-        numDevices: ::std::os::raw::c_int,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Launches kernels on multiple devices and guarantees all specified kernels are dispatched"]
-    #[doc = " on respective streams before enqueuing any other work on the specified streams from any other threads"]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " @param [in] hipLaunchParams          List of launch parameters, one per device."]
-    #[doc = " @param [in] numDevices               Size of the launchParamsList array."]
-    #[doc = " @param [in] flags                    Flags to control launch behavior."]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorNotInitialized, hipErrorInvalidValue"]
-    pub fn hipExtLaunchMultiKernelMultiDevice(
-        launchParamsList: *mut hipLaunchParams,
-        numDevices: ::std::os::raw::c_int,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = ""]
-    #[doc = "  @defgroup Occupancy Occupancy"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the occupancy functions of HIP runtime API."]
-    #[doc = ""]
-    #[doc = " @brief determine the grid and block sizes to achieves maximum occupancy for a kernel"]
-    #[doc = ""]
-    #[doc = " @param [out] gridSize           minimum grid size for maximum potential occupancy"]
-    #[doc = " @param [out] blockSize          block size for maximum potential occupancy"]
-    #[doc = " @param [in]  f                  kernel function for which occupancy is calulated"]
-    #[doc = " @param [in]  dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block"]
-    #[doc = " @param [in]  blockSizeLimit     the maximum block size for the kernel, use 0 for no limit"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorInvalidValue"]
-    pub fn hipModuleOccupancyMaxPotentialBlockSize(
-        gridSize: *mut ::std::os::raw::c_int,
-        blockSize: *mut ::std::os::raw::c_int,
-        f: hipFunction_t,
-        dynSharedMemPerBlk: usize,
-        blockSizeLimit: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief determine the grid and block sizes to achieves maximum occupancy for a kernel"]
-    #[doc = ""]
-    #[doc = " @param [out] gridSize           minimum grid size for maximum potential occupancy"]
-    #[doc = " @param [out] blockSize          block size for maximum potential occupancy"]
-    #[doc = " @param [in]  f                  kernel function for which occupancy is calulated"]
-    #[doc = " @param [in]  dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block"]
-    #[doc = " @param [in]  blockSizeLimit     the maximum block size for the kernel, use 0 for no limit"]
-    #[doc = " @param [in]  flags            Extra flags for occupancy calculation (only default supported)"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorInvalidValue"]
-    pub fn hipModuleOccupancyMaxPotentialBlockSizeWithFlags(
-        gridSize: *mut ::std::os::raw::c_int,
-        blockSize: *mut ::std::os::raw::c_int,
-        f: hipFunction_t,
-        dynSharedMemPerBlk: usize,
-        blockSizeLimit: ::std::os::raw::c_int,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns occupancy for a device function."]
-    #[doc = ""]
-    #[doc = " @param [out] numBlocks        Returned occupancy"]
-    #[doc = " @param [in]  func             Kernel function (hipFunction) for which occupancy is calulated"]
-    #[doc = " @param [in]  blockSize        Block size the kernel is intended to be launched with"]
-    #[doc = " @param [in]  dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block"]
-    pub fn hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(
-        numBlocks: *mut ::std::os::raw::c_int,
-        f: hipFunction_t,
-        blockSize: ::std::os::raw::c_int,
-        dynSharedMemPerBlk: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns occupancy for a device function."]
-    #[doc = ""]
-    #[doc = " @param [out] numBlocks        Returned occupancy"]
-    #[doc = " @param [in]  f                Kernel function(hipFunction_t) for which occupancy is calulated"]
-    #[doc = " @param [in]  blockSize        Block size the kernel is intended to be launched with"]
-    #[doc = " @param [in]  dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block"]
-    #[doc = " @param [in]  flags            Extra flags for occupancy calculation (only default supported)"]
-    pub fn hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
-        numBlocks: *mut ::std::os::raw::c_int,
-        f: hipFunction_t,
-        blockSize: ::std::os::raw::c_int,
-        dynSharedMemPerBlk: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns occupancy for a device function."]
-    #[doc = ""]
-    #[doc = " @param [out] numBlocks        Returned occupancy"]
-    #[doc = " @param [in]  func             Kernel function for which occupancy is calulated"]
-    #[doc = " @param [in]  blockSize        Block size the kernel is intended to be launched with"]
-    #[doc = " @param [in]  dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block"]
-    pub fn hipOccupancyMaxActiveBlocksPerMultiprocessor(
-        numBlocks: *mut ::std::os::raw::c_int,
-        f: *const ::std::os::raw::c_void,
-        blockSize: ::std::os::raw::c_int,
-        dynSharedMemPerBlk: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns occupancy for a device function."]
-    #[doc = ""]
-    #[doc = " @param [out] numBlocks        Returned occupancy"]
-    #[doc = " @param [in]  f                Kernel function for which occupancy is calulated"]
-    #[doc = " @param [in]  blockSize        Block size the kernel is intended to be launched with"]
-    #[doc = " @param [in]  dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block"]
-    #[doc = " @param [in]  flags            Extra flags for occupancy calculation (currently ignored)"]
-    pub fn hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
-        numBlocks: *mut ::std::os::raw::c_int,
-        f: *const ::std::os::raw::c_void,
-        blockSize: ::std::os::raw::c_int,
-        dynSharedMemPerBlk: usize,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief determine the grid and block sizes to achieves maximum occupancy for a kernel"]
-    #[doc = ""]
-    #[doc = " @param [out] gridSize           minimum grid size for maximum potential occupancy"]
-    #[doc = " @param [out] blockSize          block size for maximum potential occupancy"]
-    #[doc = " @param [in]  f                  kernel function for which occupancy is calulated"]
-    #[doc = " @param [in]  dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block"]
-    #[doc = " @param [in]  blockSizeLimit     the maximum block size for the kernel, use 0 for no limit"]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorInvalidValue"]
-    pub fn hipOccupancyMaxPotentialBlockSize(
-        gridSize: *mut ::std::os::raw::c_int,
-        blockSize: *mut ::std::os::raw::c_int,
-        f: *const ::std::os::raw::c_void,
-        dynSharedMemPerBlk: usize,
-        blockSizeLimit: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Start recording of profiling information"]
-    #[doc = " When using this API, start the profiler with profiling disabled.  (--startdisabled)"]
-    #[doc = " @warning : hipProfilerStart API is under development."]
-    pub fn hipProfilerStart() -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Stop recording of profiling information."]
-    #[doc = " When using this API, start the profiler with profiling disabled.  (--startdisabled)"]
-    #[doc = " @warning : hipProfilerStop API is under development."]
-    pub fn hipProfilerStop() -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Clang Launch API to support the triple-chevron syntax"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the API to support the triple-chevron syntax."]
-    #[doc = " @brief Configure a kernel launch."]
-    #[doc = ""]
-    #[doc = " @param [in] gridDim   grid dimension specified as multiple of blockDim."]
-    #[doc = " @param [in] blockDim  block dimensions specified in work-items"]
-    #[doc = " @param [in] sharedMem Amount of dynamic shared memory to allocate for this kernel. The"]
-    #[doc = " HIP-Clang compiler provides support for extern shared declarations."]
-    #[doc = " @param [in] stream    Stream where the kernel should be dispatched.  May be 0, in which case the"]
-    #[doc = " default stream is used with associated synchronization rules."]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorNotInitialized, hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipConfigureCall(
-        gridDim: dim3,
-        blockDim: dim3,
-        sharedMem: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Set a kernel argument."]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorNotInitialized, hipErrorInvalidValue"]
-    #[doc = ""]
-    #[doc = " @param [in] arg    Pointer the argument in host memory."]
-    #[doc = " @param [in] size   Size of the argument."]
-    #[doc = " @param [in] offset Offset of the argument on the argument stack."]
-    #[doc = ""]
-    pub fn hipSetupArgument(
-        arg: *const ::std::os::raw::c_void,
-        size: usize,
-        offset: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Launch a kernel."]
-    #[doc = ""]
-    #[doc = " @param [in] func Kernel to launch."]
-    #[doc = ""]
-    #[doc = " @returns hipSuccess, hipInvalidDevice, hipErrorNotInitialized, hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipLaunchByPtr(func: *const ::std::os::raw::c_void) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief C compliant kernel launch API"]
-    #[doc = ""]
-    #[doc = " @param [in] function_address - kernel stub function pointer."]
-    #[doc = " @param [in] numBlocks - number of blocks"]
-    #[doc = " @param [in] dimBlocks - dimension of a block"]
-    #[doc = " @param [in] args - kernel arguments"]
-    #[doc = " @param [in] sharedMemBytes - Amount of dynamic shared memory to allocate for this kernel. The"]
-    #[doc = " HIP-Clang compiler provides support for extern shared declarations."]
-    #[doc = " @param [in] stream - Stream where the kernel should be dispatched.  May be 0, in which case th"]
-    #[doc = "  default stream is used with associated synchronization rules."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, hipInvalidDevice"]
-    #[doc = ""]
-    pub fn hipLaunchKernel(
-        function_address: *const ::std::os::raw::c_void,
-        numBlocks: dim3,
-        dimBlocks: dim3,
-        args: *mut *mut ::std::os::raw::c_void,
-        sharedMemBytes: usize,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " Copies memory for 2D arrays."]
-    #[doc = ""]
-    #[doc = " @param pCopy           - Parameters for the memory copy"]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    pub fn hipDrvMemcpy2DUnaligned(pCopy: *const hip_Memcpy2D) -> hipError_t;
-}
-extern "C" {
-    pub fn hipExtLaunchKernel(
-        function_address: *const ::std::os::raw::c_void,
-        numBlocks: dim3,
-        dimBlocks: dim3,
-        args: *mut *mut ::std::os::raw::c_void,
-        sharedMemBytes: usize,
-        stream: hipStream_t,
-        startEvent: hipEvent_t,
-        stopEvent: hipEvent_t,
-        flags: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Texture Texture Management"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the texture management functions of HIP runtime API."]
-    #[doc = ""]
-    #[doc = "  @addtogroup TexturD Texture Management [Deprecated]"]
-    #[doc = "  @{"]
-    #[doc = "  @ingroup Texture"]
-    #[doc = "  This section describes the deprecated texture management functions of HIP runtime API."]
-    pub fn hipBindTexture(
-        offset: *mut usize,
-        tex: *const textureReference,
-        devPtr: *const ::std::os::raw::c_void,
-        desc: *const hipChannelFormatDesc,
-        size: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipBindTexture2D(
-        offset: *mut usize,
-        tex: *const textureReference,
-        devPtr: *const ::std::os::raw::c_void,
-        desc: *const hipChannelFormatDesc,
-        width: usize,
-        height: usize,
-        pitch: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipBindTextureToArray(
-        tex: *const textureReference,
-        array: hipArray_const_t,
-        desc: *const hipChannelFormatDesc,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetTextureAlignmentOffset(
-        offset: *mut usize,
-        texref: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipUnbindTexture(tex: *const textureReference) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    pub fn hipBindTextureToMipmappedArray(
-        tex: *const textureReference,
-        mipmappedArray: hipMipmappedArray_const_t,
-        desc: *const hipChannelFormatDesc,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetTextureReference(
-        texref: *mut *const textureReference,
-        symbol: *const ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipCreateTextureObject(
-        pTexObject: *mut hipTextureObject_t,
-        pResDesc: *const hipResourceDesc,
-        pTexDesc: *const hipTextureDesc,
-        pResViewDesc: *const hipResourceViewDesc,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipDestroyTextureObject(textureObject: hipTextureObject_t) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetChannelDesc(
-        desc: *mut hipChannelFormatDesc,
-        array: hipArray_const_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetTextureObjectResourceDesc(
-        pResDesc: *mut hipResourceDesc,
-        textureObject: hipTextureObject_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetTextureObjectResourceViewDesc(
-        pResViewDesc: *mut hipResourceViewDesc,
-        textureObject: hipTextureObject_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGetTextureObjectTextureDesc(
-        pTexDesc: *mut hipTextureDesc,
-        textureObject: hipTextureObject_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetAddress(
-        dev_ptr: *mut hipDeviceptr_t,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetAddressMode(
-        pam: *mut hipTextureAddressMode,
-        texRef: *const textureReference,
-        dim: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetFilterMode(
-        pfm: *mut hipTextureFilterMode,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetFlags(
-        pFlags: *mut ::std::os::raw::c_uint,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetFormat(
-        pFormat: *mut hipArray_Format,
-        pNumChannels: *mut ::std::os::raw::c_int,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetMaxAnisotropy(
-        pmaxAnsio: *mut ::std::os::raw::c_int,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetMipmapFilterMode(
-        pfm: *mut hipTextureFilterMode,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetMipmapLevelBias(
-        pbias: *mut f32,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetMipmapLevelClamp(
-        pminMipmapLevelClamp: *mut f32,
-        pmaxMipmapLevelClamp: *mut f32,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefGetMipMappedArray(
-        pArray: *mut hipMipmappedArray_t,
-        texRef: *const textureReference,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetAddress(
-        ByteOffset: *mut usize,
-        texRef: *mut textureReference,
-        dptr: hipDeviceptr_t,
-        bytes: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetAddress2D(
-        texRef: *mut textureReference,
-        desc: *const HIP_ARRAY_DESCRIPTOR,
-        dptr: hipDeviceptr_t,
-        Pitch: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetAddressMode(
-        texRef: *mut textureReference,
-        dim: ::std::os::raw::c_int,
-        am: hipTextureAddressMode,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetArray(
-        tex: *mut textureReference,
-        array: hipArray_const_t,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetFilterMode(
-        texRef: *mut textureReference,
-        fm: hipTextureFilterMode,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetFlags(
-        texRef: *mut textureReference,
-        Flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetFormat(
-        texRef: *mut textureReference,
-        fmt: hipArray_Format,
-        NumPackedComponents: ::std::os::raw::c_int,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetMaxAnisotropy(
-        texRef: *mut textureReference,
-        maxAniso: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexObjectCreate(
-        pTexObject: *mut hipTextureObject_t,
-        pResDesc: *const HIP_RESOURCE_DESC,
-        pTexDesc: *const HIP_TEXTURE_DESC,
-        pResViewDesc: *const HIP_RESOURCE_VIEW_DESC,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexObjectDestroy(texObject: hipTextureObject_t) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexObjectGetResourceDesc(
-        pResDesc: *mut HIP_RESOURCE_DESC,
-        texObject: hipTextureObject_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexObjectGetResourceViewDesc(
-        pResViewDesc: *mut HIP_RESOURCE_VIEW_DESC,
-        texObject: hipTextureObject_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexObjectGetTextureDesc(
-        pTexDesc: *mut HIP_TEXTURE_DESC,
-        texObject: hipTextureObject_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @}"]
-    pub fn hipTexRefSetBorderColor(
-        texRef: *mut textureReference,
-        pBorderColor: *mut f32,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetMipmapFilterMode(
-        texRef: *mut textureReference,
-        fm: hipTextureFilterMode,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetMipmapLevelBias(texRef: *mut textureReference, bias: f32) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetMipmapLevelClamp(
-        texRef: *mut textureReference,
-        minMipMapLevelClamp: f32,
-        maxMipMapLevelClamp: f32,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipTexRefSetMipmappedArray(
-        texRef: *mut textureReference,
-        mipmappedArray: *mut hipMipmappedArray,
-        Flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMipmappedArrayCreate(
-        pHandle: *mut hipMipmappedArray_t,
-        pMipmappedArrayDesc: *mut HIP_ARRAY3D_DESCRIPTOR,
-        numMipmapLevels: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMipmappedArrayDestroy(hMipmappedArray: hipMipmappedArray_t) -> hipError_t;
-}
-extern "C" {
-    pub fn hipMipmappedArrayGetLevel(
-        pLevelArray: *mut hipArray_t,
-        hMipMappedArray: hipMipmappedArray_t,
-        level: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " Callback/Activity API"]
-    pub fn hipRegisterApiCallback(
-        id: u32,
-        fun: *mut ::std::os::raw::c_void,
-        arg: *mut ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipRemoveApiCallback(id: u32) -> hipError_t;
-}
-extern "C" {
-    pub fn hipRegisterActivityCallback(
-        id: u32,
-        fun: *mut ::std::os::raw::c_void,
-        arg: *mut ::std::os::raw::c_void,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipRemoveActivityCallback(id: u32) -> hipError_t;
-}
-extern "C" {
-    pub fn hipApiName(id: u32) -> *const ::std::os::raw::c_char;
-}
-extern "C" {
-    pub fn hipKernelNameRef(f: hipFunction_t) -> *const ::std::os::raw::c_char;
-}
-extern "C" {
-    pub fn hipKernelNameRefByPtr(
-        hostFunction: *const ::std::os::raw::c_void,
-        stream: hipStream_t,
-    ) -> *const ::std::os::raw::c_char;
-}
-extern "C" {
-    pub fn hipGetStreamDeviceId(stream: hipStream_t) -> ::std::os::raw::c_int;
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ihipGraph {
-    _unused: [u8; 0],
-}
-#[doc = " An opaque value that represents a hip graph"]
-pub type hipGraph_t = *mut ihipGraph;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipGraphNode {
-    _unused: [u8; 0],
-}
-#[doc = " An opaque value that represents a hip graph node"]
-pub type hipGraphNode_t = *mut hipGraphNode;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipGraphExec {
-    _unused: [u8; 0],
-}
-#[doc = " An opaque value that represents a hip graph Exec"]
-pub type hipGraphExec_t = *mut hipGraphExec;
-impl hipGraphNodeType {
-    #[doc = "< GPU kernel node"]
-    pub const hipGraphNodeTypeKernel: hipGraphNodeType = hipGraphNodeType(1);
-}
-impl hipGraphNodeType {
-    #[doc = "< Memcpy 3D node"]
-    pub const hipGraphNodeTypeMemcpy: hipGraphNodeType = hipGraphNodeType(2);
-}
-impl hipGraphNodeType {
-    #[doc = "< Memset 1D node"]
-    pub const hipGraphNodeTypeMemset: hipGraphNodeType = hipGraphNodeType(3);
-}
-impl hipGraphNodeType {
-    #[doc = "< Host (executable) node"]
-    pub const hipGraphNodeTypeHost: hipGraphNodeType = hipGraphNodeType(4);
-}
-impl hipGraphNodeType {
-    #[doc = "< Node which executes an embedded graph"]
-    pub const hipGraphNodeTypeGraph: hipGraphNodeType = hipGraphNodeType(5);
-}
-impl hipGraphNodeType {
-    #[doc = "< Empty (no-op) node"]
-    pub const hipGraphNodeTypeEmpty: hipGraphNodeType = hipGraphNodeType(6);
-}
-impl hipGraphNodeType {
-    #[doc = "< External event wait node"]
-    pub const hipGraphNodeTypeWaitEvent: hipGraphNodeType = hipGraphNodeType(7);
-}
-impl hipGraphNodeType {
-    #[doc = "< External event record node"]
-    pub const hipGraphNodeTypeEventRecord: hipGraphNodeType = hipGraphNodeType(8);
-}
-impl hipGraphNodeType {
-    #[doc = "< Memcpy 1D node"]
-    pub const hipGraphNodeTypeMemcpy1D: hipGraphNodeType = hipGraphNodeType(9);
-}
-impl hipGraphNodeType {
-    #[doc = "< MemcpyFromSymbol node"]
-    pub const hipGraphNodeTypeMemcpyFromSymbol: hipGraphNodeType = hipGraphNodeType(10);
-}
-impl hipGraphNodeType {
-    #[doc = "< MemcpyToSymbol node"]
-    pub const hipGraphNodeTypeMemcpyToSymbol: hipGraphNodeType = hipGraphNodeType(11);
-}
-impl hipGraphNodeType {
-    pub const hipGraphNodeTypeCount: hipGraphNodeType = hipGraphNodeType(12);
-}
-#[repr(transparent)]
-#[doc = " @brief hipGraphNodeType"]
-#[doc = " @enum"]
-#[doc = ""]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipGraphNodeType(pub ::std::os::raw::c_uint);
-pub type hipHostFn_t =
-    ::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void)>;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipHostNodeParams {
-    pub fn_: hipHostFn_t,
-    pub userData: *mut ::std::os::raw::c_void,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipKernelNodeParams {
-    pub blockDim: dim3,
-    pub extra: *mut *mut ::std::os::raw::c_void,
-    pub func: *mut ::std::os::raw::c_void,
-    pub gridDim: dim3,
-    pub kernelParams: *mut *mut ::std::os::raw::c_void,
-    pub sharedMemBytes: ::std::os::raw::c_uint,
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct hipMemsetParams {
-    pub dst: *mut ::std::os::raw::c_void,
-    pub elementSize: ::std::os::raw::c_uint,
-    pub height: usize,
-    pub pitch: usize,
-    pub value: ::std::os::raw::c_uint,
-    pub width: usize,
-}
-impl hipGraphExecUpdateResult {
-    #[doc = "< The update succeeded"]
-    pub const hipGraphExecUpdateSuccess: hipGraphExecUpdateResult = hipGraphExecUpdateResult(0);
-}
-impl hipGraphExecUpdateResult {
-    #[doc = "< The update failed for an unexpected reason which is described"]
-    #[doc = "< in the return value of the function"]
-    pub const hipGraphExecUpdateError: hipGraphExecUpdateResult = hipGraphExecUpdateResult(1);
-}
-impl hipGraphExecUpdateResult {
-    #[doc = "< The update failed because the topology changed"]
-    pub const hipGraphExecUpdateErrorTopologyChanged: hipGraphExecUpdateResult =
-        hipGraphExecUpdateResult(2);
-}
-impl hipGraphExecUpdateResult {
-    #[doc = "< The update failed because a node type changed"]
-    pub const hipGraphExecUpdateErrorNodeTypeChanged: hipGraphExecUpdateResult =
-        hipGraphExecUpdateResult(3);
-}
-impl hipGraphExecUpdateResult {
-    pub const hipGraphExecUpdateErrorFunctionChanged: hipGraphExecUpdateResult =
-        hipGraphExecUpdateResult(4);
-}
-impl hipGraphExecUpdateResult {
-    pub const hipGraphExecUpdateErrorParametersChanged: hipGraphExecUpdateResult =
-        hipGraphExecUpdateResult(5);
-}
-impl hipGraphExecUpdateResult {
-    pub const hipGraphExecUpdateErrorNotSupported: hipGraphExecUpdateResult =
-        hipGraphExecUpdateResult(6);
-}
-impl hipGraphExecUpdateResult {
-    pub const hipGraphExecUpdateErrorUnsupportedFunctionChange: hipGraphExecUpdateResult =
-        hipGraphExecUpdateResult(7);
-}
-#[repr(transparent)]
-#[doc = " @brief hipGraphExecUpdateResult"]
-#[doc = " @enum"]
-#[doc = ""]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipGraphExecUpdateResult(pub ::std::os::raw::c_uint);
-impl hipStreamCaptureMode {
-    pub const hipStreamCaptureModeGlobal: hipStreamCaptureMode = hipStreamCaptureMode(0);
-}
-impl hipStreamCaptureMode {
-    pub const hipStreamCaptureModeThreadLocal: hipStreamCaptureMode = hipStreamCaptureMode(1);
-}
-impl hipStreamCaptureMode {
-    pub const hipStreamCaptureModeRelaxed: hipStreamCaptureMode = hipStreamCaptureMode(2);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipStreamCaptureMode(pub ::std::os::raw::c_uint);
-impl hipStreamCaptureStatus {
-    #[doc = "< Stream is not capturing"]
-    pub const hipStreamCaptureStatusNone: hipStreamCaptureStatus = hipStreamCaptureStatus(0);
-}
-impl hipStreamCaptureStatus {
-    #[doc = "< Stream is actively capturing"]
-    pub const hipStreamCaptureStatusActive: hipStreamCaptureStatus = hipStreamCaptureStatus(1);
-}
-impl hipStreamCaptureStatus {
-    #[doc = "< Stream is part of a capture sequence that has been"]
-    #[doc = "< invalidated, but not terminated"]
-    pub const hipStreamCaptureStatusInvalidated: hipStreamCaptureStatus = hipStreamCaptureStatus(2);
-}
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct hipStreamCaptureStatus(pub ::std::os::raw::c_uint);
-extern "C" {
-    pub fn hipStreamBeginCapture(stream: hipStream_t, mode: hipStreamCaptureMode) -> hipError_t;
-}
-extern "C" {
-    pub fn hipStreamEndCapture(stream: hipStream_t, pGraph: *mut hipGraph_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "-------------------------------------------------------------------------------------------------"]
-    #[doc = "  @defgroup Graph Graph Management"]
-    #[doc = "  @{"]
-    #[doc = "  This section describes the graph management functions of HIP runtime API."]
-    #[doc = " @brief Creates a graph"]
-    #[doc = ""]
-    #[doc = " @param [out] pGraph - pointer to graph to create."]
-    #[doc = " @param [in] flags - flags for graph creation, must be 0."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess."]
-    #[doc = ""]
-    pub fn hipGraphCreate(pGraph: *mut hipGraph_t, flags: ::std::os::raw::c_uint) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Destroys a graph"]
-    #[doc = ""]
-    #[doc = " @param [in] graph - instance of graph to destroy."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess."]
-    #[doc = ""]
-    pub fn hipGraphDestroy(graph: hipGraph_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Destroys an executable graph"]
-    #[doc = ""]
-    #[doc = " @param [in] pGraphExec - instance of executable graph to destry."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess."]
-    #[doc = ""]
-    pub fn hipGraphExecDestroy(pGraphExec: hipGraphExec_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Creates an executable graph from a graph"]
-    #[doc = ""]
-    #[doc = " @param [out] pGraphExec - pointer to instantiated executable graph to create."]
-    #[doc = " @param [in] graph - instance of graph to instantiate."]
-    #[doc = " @param [out] pErrorNode - pointer to error node in case error occured in graph instantiation,"]
-    #[doc = "  it could modify the correponding node."]
-    #[doc = " @param [out] pLogBuffer - pointer to log buffer."]
-    #[doc = " @param [in] bufferSize - the size of log buffer."]
-    #[doc = ""]
-    #[doc = " @returns #hipSuccess, #hipErrorOutOfMemory."]
-    #[doc = ""]
-    pub fn hipGraphInstantiate(
-        pGraphExec: *mut hipGraphExec_t,
-        graph: hipGraph_t,
-        pErrorNode: *mut hipGraphNode_t,
-        pLogBuffer: *mut ::std::os::raw::c_char,
-        bufferSize: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief launches an executable graph in a stream"]
-    #[doc = ""]
-    #[doc = " @param [in] graphExec - instance of executable graph to launch."]
-    #[doc = " @param [in] stream - instance of stream in which to launch executable graph."]
-    #[doc = " @returns #hipSuccess, #hipErrorOutOfMemory, #hipErrorInvalidHandle, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphLaunch(graphExec: hipGraphExec_t, stream: hipStream_t) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Creates a kernel execution node and adds it to a graph."]
-    #[doc = ""]
-    #[doc = " @param [out] pGraphNode - pointer to graph node to create."]
-    #[doc = " @param [in,out] graph - instance of graph to add the created node."]
-    #[doc = " @param [in] pDependencies - pointer to the dependencies on the kernel execution node."]
-    #[doc = " @param [in] numDependencies - the number of the dependencies."]
-    #[doc = " @param [in] pNodeParams - pointer to the parameters to the kernel execution node on the GPU."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidDeviceFunction"]
-    #[doc = ""]
-    pub fn hipGraphAddKernelNode(
-        pGraphNode: *mut hipGraphNode_t,
-        graph: hipGraph_t,
-        pDependencies: *const hipGraphNode_t,
-        numDependencies: usize,
-        pNodeParams: *const hipKernelNodeParams,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Creates a memcpy node and adds it to a graph."]
-    #[doc = ""]
-    #[doc = " @param [out] pGraphNode - pointer to graph node to create."]
-    #[doc = " @param [in,out] graph - instance of graph to add the created node."]
-    #[doc = " @param [in] pDependencies - const pointer to the dependencies on the kernel execution node."]
-    #[doc = " @param [in] numDependencies - the number of the dependencies."]
-    #[doc = " @param [in] pCopyParams - const pointer to the parameters for the memory copy."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphAddMemcpyNode(
-        pGraphNode: *mut hipGraphNode_t,
-        graph: hipGraph_t,
-        pDependencies: *const hipGraphNode_t,
-        numDependencies: usize,
-        pCopyParams: *const hipMemcpy3DParms,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Creates a 1D memcpy node and adds it to a graph."]
-    #[doc = ""]
-    #[doc = " @param [out] pGraphNode - pointer to graph node to create."]
-    #[doc = " @param [in,out] graph - instance of the graph to add the created node."]
-    #[doc = " @param [in] pDependencies - const pointer to the dependencies on the kernel execution node."]
-    #[doc = " @param [in] numDependencies - the number of the dependencies."]
-    #[doc = " @param [in] dst - pointer to memory address to the destination."]
-    #[doc = " @param [in] src - pointer to memory address to the source."]
-    #[doc = " @param [in] count - the size of the memory to copy."]
-    #[doc = " @param [in] kind - the type of memory copy."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphAddMemcpyNode1D(
-        pGraphNode: *mut hipGraphNode_t,
-        graph: hipGraph_t,
-        pDependencies: *const hipGraphNode_t,
-        numDependencies: usize,
-        dst: *mut ::std::os::raw::c_void,
-        src: *const ::std::os::raw::c_void,
-        count: usize,
-        kind: hipMemcpyKind,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Creates a memset node and adds it to a graph."]
-    #[doc = ""]
-    #[doc = " @param [out] pGraphNode - pointer to the graph node to create."]
-    #[doc = " @param [in,out] graph - instance of the graph to add the created node."]
-    #[doc = " @param [in] pDependencies - const pointer to the dependencies on the kernel execution node."]
-    #[doc = " @param [in] numDependencies - the number of the dependencies."]
-    #[doc = " @param [in] pMemsetParams - const pointer to the parameters for the memory set."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphAddMemsetNode(
-        pGraphNode: *mut hipGraphNode_t,
-        graph: hipGraph_t,
-        pDependencies: *const hipGraphNode_t,
-        numDependencies: usize,
-        pMemsetParams: *const hipMemsetParams,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns graph nodes."]
-    #[doc = ""]
-    #[doc = " @param [in] graph - instance of graph to get the nodes."]
-    #[doc = " @param [out] nodes - pointer to the graph nodes."]
-    #[doc = " @param [out] numNodes - the number of graph nodes."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphGetNodes(
-        graph: hipGraph_t,
-        nodes: *mut hipGraphNode_t,
-        numNodes: *mut usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Returns graph's root nodes."]
-    #[doc = ""]
-    #[doc = " @param [in] graph - instance of the graph to get the nodes."]
-    #[doc = " @param [out] pRootNodes - pointer to the graph's root nodes."]
-    #[doc = " @param [out] pNumRootNodes - the number of graph's root nodes."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphGetRootNodes(
-        graph: hipGraph_t,
-        pRootNodes: *mut hipGraphNode_t,
-        pNumRootNodes: *mut usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Gets kernel node's parameters."]
-    #[doc = ""]
-    #[doc = " @param [in] node - instance of the node to get parameters from."]
-    #[doc = " @param [out] pNodeParams - pointer to the parameters"]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphKernelNodeGetParams(
-        node: hipGraphNode_t,
-        pNodeParams: *mut hipKernelNodeParams,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Sets a kernel node's parameters."]
-    #[doc = ""]
-    #[doc = " @param [in] node - instance of the node to set parameters to."]
-    #[doc = " @param [in] pNodeParams - const pointer to the parameters."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphKernelNodeSetParams(
-        node: hipGraphNode_t,
-        pNodeParams: *const hipKernelNodeParams,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Gets a memcpy node's parameters."]
-    #[doc = ""]
-    #[doc = " @param [in] node - instance of the node to get parameters from."]
-    #[doc = " @param [out] pNodeParams - pointer to the parameters."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphMemcpyNodeGetParams(
-        node: hipGraphNode_t,
-        pNodeParams: *mut hipMemcpy3DParms,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Sets a memcpy node's parameters."]
-    #[doc = ""]
-    #[doc = " @param [in] node - instance of the node to set parameters to."]
-    #[doc = " @param [in] pNodeParams - const pointer to the parameters."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphMemcpyNodeSetParams(
-        node: hipGraphNode_t,
-        pNodeParams: *const hipMemcpy3DParms,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Gets a memset node's parameters."]
-    #[doc = ""]
-    #[doc = " @param [in] node - instane of the node to get parameters from."]
-    #[doc = " @param [out] pNodeParams - pointer to the parameters."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphMemsetNodeGetParams(
-        node: hipGraphNode_t,
-        pNodeParams: *mut hipMemsetParams,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Sets a memset node's parameters."]
-    #[doc = ""]
-    #[doc = " @param [in] node - instance of the node to set parameters to."]
-    #[doc = " @param [out] pNodeParams - pointer to the parameters."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphMemsetNodeSetParams(
-        node: hipGraphNode_t,
-        pNodeParams: *const hipMemsetParams,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Sets the parameters for a kernel node in the given graphExec."]
-    #[doc = ""]
-    #[doc = " @param [in] hGraphExec - instance of the executable graph with the node."]
-    #[doc = " @param [in] node - instance of the node to set parameters to."]
-    #[doc = " @param [in] pNodeParams - const pointer to the kernel node parameters."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphExecKernelNodeSetParams(
-        hGraphExec: hipGraphExec_t,
-        node: hipGraphNode_t,
-        pNodeParams: *const hipKernelNodeParams,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Adds dependency edges to a graph."]
-    #[doc = ""]
-    #[doc = " @param [in] graph - instance of the graph to add dependencies."]
-    #[doc = " @param [in] from - pointer to the graph nodes with dependenties to add from."]
-    #[doc = " @param [in] to - pointer to the graph nodes to add dependenties to."]
-    #[doc = " @param [in] numDependencies - the number of dependencies to add."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphAddDependencies(
-        graph: hipGraph_t,
-        from: *const hipGraphNode_t,
-        to: *const hipGraphNode_t,
-        numDependencies: usize,
-    ) -> hipError_t;
-}
-extern "C" {
-    #[doc = " @brief Creates an empty node and adds it to a graph."]
-    #[doc = ""]
-    #[doc = " @param [out] pGraphNode - pointer to the graph node to create and add to the graph."]
-    #[doc = " @param [in,out] graph - instane of the graph the node is add to."]
-    #[doc = " @param [in] pDependencies - const pointer to the node dependenties."]
-    #[doc = " @param [in] numDependencies - the number of dependencies."]
-    #[doc = " @returns #hipSuccess, #hipErrorInvalidValue"]
-    #[doc = ""]
-    pub fn hipGraphAddEmptyNode(
-        pGraphNode: *mut hipGraphNode_t,
-        graph: hipGraph_t,
-        pDependencies: *const hipGraphNode_t,
-        numDependencies: usize,
-    ) -> hipError_t;
-}
-#[doc = "-------------------------------------------------------------------------------------------------"]
-#[doc = "-------------------------------------------------------------------------------------------------"]
-#[doc = "  @defgroup GL Interop"]
-#[doc = "  @{"]
-#[doc = "  This section describes Stream Memory Wait and Write functions of HIP runtime API."]
-pub type GLuint = ::std::os::raw::c_uint;
-extern "C" {
-    pub fn hipGLGetDevices(
-        pHipDeviceCount: *mut ::std::os::raw::c_uint,
-        pHipDevices: *mut ::std::os::raw::c_int,
-        hipDeviceCount: ::std::os::raw::c_uint,
-        deviceList: hipGLDeviceList,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGraphicsGLRegisterBuffer(
-        resource: *mut *mut hipGraphicsResource,
-        buffer: GLuint,
-        flags: ::std::os::raw::c_uint,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGraphicsMapResources(
-        count: ::std::os::raw::c_int,
-        resources: *mut hipGraphicsResource_t,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGraphicsResourceGetMappedPointer(
-        devPtr: *mut *mut ::std::os::raw::c_void,
-        size: *mut usize,
-        resource: hipGraphicsResource_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGraphicsUnmapResources(
-        count: ::std::os::raw::c_int,
-        resources: *mut hipGraphicsResource_t,
-        stream: hipStream_t,
-    ) -> hipError_t;
-}
-extern "C" {
-    pub fn hipGraphicsUnregisterResource(resource: hipGraphicsResource_t) -> hipError_t;
-}
diff --git a/hip_runtime-sys/src/lib.rs b/hip_runtime-sys/src/lib.rs
deleted file mode 100644
index fe25756..0000000
--- a/hip_runtime-sys/src/lib.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#![allow(warnings)]
-pub mod hip_runtime_api;
-pub use hip_runtime_api::*;
\ No newline at end of file