Wrapper for HIP

hip.py

# -*- coding: utf-8 -*-
#
# TARGET arch is: ['-D__HIP_PLATFORM_AMD__', '-I/opt/rocm/include']
# WORD_SIZE is: 8
# POINTER_SIZE is: 8
# LONGDOUBLE_SIZE is: 16
#
import ctypes


class AsDictMixin:
    @classmethod
    def as_dict(cls, self):
        result = {}
        if not isinstance(self, AsDictMixin):
            # not a structure, assume it's already a python object
            return self
        if not hasattr(cls, "_fields_"):
            return result
        # sys.version_info >= (3, 5)
        # for (field, *_) in cls._fields_:  # noqa
        for field_tuple in cls._fields_:  # noqa
            field = field_tuple[0]
            if field.startswith('PADDING_'):
                continue
            value = getattr(self, field)
            type_ = type(value)
            if hasattr(value, "_length_") and hasattr(value, "_type_"):
                # array
                if not hasattr(type_, "as_dict"):
                    value = [v for v in value]
                else:
                    type_ = type_._type_
                    value = [type_.as_dict(v) for v in value]
            elif hasattr(value, "contents") and hasattr(value, "_type_"):
                # pointer
                try:
                    if not hasattr(type_, "as_dict"):
                        value = value.contents
                    else:
                        type_ = type_._type_
                        value = type_.as_dict(value.contents)
                except ValueError:
                    # nullptr
                    value = None
            elif isinstance(value, AsDictMixin):
                # other structure
                value = type_.as_dict(value)
            result[field] = value
        return result


class Structure(ctypes.Structure, AsDictMixin):

    def __init__(self, *args, **kwds):
        # We don't want to use positional arguments fill PADDING_* fields

        args = dict(zip(self.__class__._field_names_(), args))
        args.update(kwds)
        super(Structure, self).__init__(**args)

    @classmethod
    def _field_names_(cls):
        if hasattr(cls, '_fields_'):
            return (f[0] for f in cls._fields_ if not f[0].startswith('PADDING'))
        else:
            return ()

    @classmethod
    def get_type(cls, field):
        for f in cls._fields_:
            if f[0] == field:
                return f[1]
        return None

    @classmethod
    def bind(cls, bound_fields):
        fields = {}
        for name, type_ in cls._fields_:
            if hasattr(type_, "restype"):
                if name in bound_fields:
                    if bound_fields[name] is None:
                        fields[name] = type_()
                    else:
                        # use a closure to capture the callback from the loop scope
                        fields[name] = (
                            type_((lambda callback: lambda *args: callback(*args))(
                                bound_fields[name]))
                        )
                    del bound_fields[name]
                else:
                    # default callback implementation (does nothing)
                    try:
                        default_ = type_(0).restype().value
                    except TypeError:
                        default_ = None
                    fields[name] = type_((
                        lambda default_: lambda *args: default_)(default_))
            else:
                # not a callback function, use default initialization
                if name in bound_fields:
                    fields[name] = bound_fields[name]
                    del bound_fields[name]
                else:
                    fields[name] = type_()
        if len(bound_fields) != 0:
            raise ValueError(
                "Cannot bind the following unknown callback(s) {}.{}".format(
                    cls.__name__, bound_fields.keys()
            ))
        return cls(**fields)


class Union(ctypes.Union, AsDictMixin):
    pass



_libraries = {}
_libraries['libhiprtc.so'] = ctypes.CDLL('/opt/rocm/lib/libhiprtc.so')
def string_cast(char_pointer, encoding='utf-8', errors='strict'):
    value = ctypes.cast(char_pointer, ctypes.c_char_p).value
    if value is not None and encoding is not None:
        value = value.decode(encoding, errors=errors)
    return value


def char_pointer_cast(string, encoding='utf-8'):
    if encoding is not None:
        try:
            string = string.encode(encoding)
        except AttributeError:
            # In Python3, bytes has no encode attribute
            pass
    string = ctypes.c_char_p(string)
    return ctypes.cast(string, ctypes.POINTER(ctypes.c_char))



c_int128 = ctypes.c_ubyte*16
c_uint128 = c_int128
void = None
if ctypes.sizeof(ctypes.c_longdouble) == 16:
    c_long_double_t = ctypes.c_longdouble
else:
    c_long_double_t = ctypes.c_ubyte*16

class FunctionFactoryStub:
    def __getattr__(self, _):
      return ctypes.CFUNCTYPE(lambda y:y)

# libraries['FIXME_STUB'] explanation
# As you did not list (-l libraryname.so) a library that exports this function
# This is a non-working stub instead. 
# You can either re-run clan2py with -l /path/to/library.so
# Or manually fix this by comment the ctypes.CDLL loading
_libraries['FIXME_STUB'] = FunctionFactoryStub() #  ctypes.CDLL('FIXME_STUB')
_libraries['libamdhip64.so'] = ctypes.CDLL('/opt/rocm/lib/libamdhip64.so')



# values for enumeration 'hiprtcResult'
hiprtcResult__enumvalues = {
    0: 'HIPRTC_SUCCESS',
    1: 'HIPRTC_ERROR_OUT_OF_MEMORY',
    2: 'HIPRTC_ERROR_PROGRAM_CREATION_FAILURE',
    3: 'HIPRTC_ERROR_INVALID_INPUT',
    4: 'HIPRTC_ERROR_INVALID_PROGRAM',
    5: 'HIPRTC_ERROR_INVALID_OPTION',
    6: 'HIPRTC_ERROR_COMPILATION',
    7: 'HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE',
    8: 'HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION',
    9: 'HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION',
    10: 'HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID',
    11: 'HIPRTC_ERROR_INTERNAL_ERROR',
    100: 'HIPRTC_ERROR_LINKING',
}
HIPRTC_SUCCESS = 0
HIPRTC_ERROR_OUT_OF_MEMORY = 1
HIPRTC_ERROR_PROGRAM_CREATION_FAILURE = 2
HIPRTC_ERROR_INVALID_INPUT = 3
HIPRTC_ERROR_INVALID_PROGRAM = 4
HIPRTC_ERROR_INVALID_OPTION = 5
HIPRTC_ERROR_COMPILATION = 6
HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE = 7
HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = 8
HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = 9
HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID = 10
HIPRTC_ERROR_INTERNAL_ERROR = 11
HIPRTC_ERROR_LINKING = 100
hiprtcResult = ctypes.c_uint32 # enum

# values for enumeration 'hiprtcJIT_option'
hiprtcJIT_option__enumvalues = {
    0: 'HIPRTC_JIT_MAX_REGISTERS',
    1: 'HIPRTC_JIT_THREADS_PER_BLOCK',
    2: 'HIPRTC_JIT_WALL_TIME',
    3: 'HIPRTC_JIT_INFO_LOG_BUFFER',
    4: 'HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES',
    5: 'HIPRTC_JIT_ERROR_LOG_BUFFER',
    6: 'HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES',
    7: 'HIPRTC_JIT_OPTIMIZATION_LEVEL',
    8: 'HIPRTC_JIT_TARGET_FROM_HIPCONTEXT',
    9: 'HIPRTC_JIT_TARGET',
    10: 'HIPRTC_JIT_FALLBACK_STRATEGY',
    11: 'HIPRTC_JIT_GENERATE_DEBUG_INFO',
    12: 'HIPRTC_JIT_LOG_VERBOSE',
    13: 'HIPRTC_JIT_GENERATE_LINE_INFO',
    14: 'HIPRTC_JIT_CACHE_MODE',
    15: 'HIPRTC_JIT_NEW_SM3X_OPT',
    16: 'HIPRTC_JIT_FAST_COMPILE',
    17: 'HIPRTC_JIT_GLOBAL_SYMBOL_NAMES',
    18: 'HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS',
    19: 'HIPRTC_JIT_GLOBAL_SYMBOL_COUNT',
    20: 'HIPRTC_JIT_LTO',
    21: 'HIPRTC_JIT_FTZ',
    22: 'HIPRTC_JIT_PREC_DIV',
    23: 'HIPRTC_JIT_PREC_SQRT',
    24: 'HIPRTC_JIT_FMA',
    25: 'HIPRTC_JIT_NUM_OPTIONS',
    10000: 'HIPRTC_JIT_IR_TO_ISA_OPT_EXT',
    10001: 'HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT',
}
HIPRTC_JIT_MAX_REGISTERS = 0
HIPRTC_JIT_THREADS_PER_BLOCK = 1
HIPRTC_JIT_WALL_TIME = 2
HIPRTC_JIT_INFO_LOG_BUFFER = 3
HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4
HIPRTC_JIT_ERROR_LOG_BUFFER = 5
HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6
HIPRTC_JIT_OPTIMIZATION_LEVEL = 7
HIPRTC_JIT_TARGET_FROM_HIPCONTEXT = 8
HIPRTC_JIT_TARGET = 9
HIPRTC_JIT_FALLBACK_STRATEGY = 10
HIPRTC_JIT_GENERATE_DEBUG_INFO = 11
HIPRTC_JIT_LOG_VERBOSE = 12
HIPRTC_JIT_GENERATE_LINE_INFO = 13
HIPRTC_JIT_CACHE_MODE = 14
HIPRTC_JIT_NEW_SM3X_OPT = 15
HIPRTC_JIT_FAST_COMPILE = 16
HIPRTC_JIT_GLOBAL_SYMBOL_NAMES = 17
HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS = 18
HIPRTC_JIT_GLOBAL_SYMBOL_COUNT = 19
HIPRTC_JIT_LTO = 20
HIPRTC_JIT_FTZ = 21
HIPRTC_JIT_PREC_DIV = 22
HIPRTC_JIT_PREC_SQRT = 23
HIPRTC_JIT_FMA = 24
HIPRTC_JIT_NUM_OPTIONS = 25
HIPRTC_JIT_IR_TO_ISA_OPT_EXT = 10000
HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT = 10001
hiprtcJIT_option = ctypes.c_uint32 # enum

# values for enumeration 'hiprtcJITInputType'
hiprtcJITInputType__enumvalues = {
    0: 'HIPRTC_JIT_INPUT_CUBIN',
    1: 'HIPRTC_JIT_INPUT_PTX',
    2: 'HIPRTC_JIT_INPUT_FATBINARY',
    3: 'HIPRTC_JIT_INPUT_OBJECT',
    4: 'HIPRTC_JIT_INPUT_LIBRARY',
    5: 'HIPRTC_JIT_INPUT_NVVM',
    6: 'HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES',
    100: 'HIPRTC_JIT_INPUT_LLVM_BITCODE',
    101: 'HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE',
    102: 'HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE',
    9: 'HIPRTC_JIT_NUM_INPUT_TYPES',
}
HIPRTC_JIT_INPUT_CUBIN = 0
HIPRTC_JIT_INPUT_PTX = 1
HIPRTC_JIT_INPUT_FATBINARY = 2
HIPRTC_JIT_INPUT_OBJECT = 3
HIPRTC_JIT_INPUT_LIBRARY = 4
HIPRTC_JIT_INPUT_NVVM = 5
HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES = 6
HIPRTC_JIT_INPUT_LLVM_BITCODE = 100
HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE = 101
HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE = 102
HIPRTC_JIT_NUM_INPUT_TYPES = 9
hiprtcJITInputType = ctypes.c_uint32 # enum
class struct_ihiprtcLinkState(Structure):
    pass

hiprtcLinkState = ctypes.POINTER(struct_ihiprtcLinkState)
hiprtcGetErrorString = _libraries['libhiprtc.so'].hiprtcGetErrorString
hiprtcGetErrorString.restype = ctypes.POINTER(ctypes.c_char)
hiprtcGetErrorString.argtypes = [hiprtcResult]
hiprtcVersion = _libraries['libhiprtc.so'].hiprtcVersion
hiprtcVersion.restype = hiprtcResult
hiprtcVersion.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32)]
class struct__hiprtcProgram(Structure):
    pass

hiprtcProgram = ctypes.POINTER(struct__hiprtcProgram)
hiprtcAddNameExpression = _libraries['libhiprtc.so'].hiprtcAddNameExpression
hiprtcAddNameExpression.restype = hiprtcResult
hiprtcAddNameExpression.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcCompileProgram = _libraries['libhiprtc.so'].hiprtcCompileProgram
hiprtcCompileProgram.restype = hiprtcResult
hiprtcCompileProgram.argtypes = [hiprtcProgram, ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hiprtcCreateProgram = _libraries['libhiprtc.so'].hiprtcCreateProgram
hiprtcCreateProgram.restype = hiprtcResult
hiprtcCreateProgram.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hiprtcProgram)), ctypes.POINTER(ctypes.c_char), ctypes.POINTER(ctypes.c_char), ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(ctypes.c_char)), ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hiprtcDestroyProgram = _libraries['libhiprtc.so'].hiprtcDestroyProgram
hiprtcDestroyProgram.restype = hiprtcResult
hiprtcDestroyProgram.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hiprtcProgram))]
hiprtcGetLoweredName = _libraries['libhiprtc.so'].hiprtcGetLoweredName
hiprtcGetLoweredName.restype = hiprtcResult
hiprtcGetLoweredName.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char), ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hiprtcGetProgramLog = _libraries['libhiprtc.so'].hiprtcGetProgramLog
hiprtcGetProgramLog.restype = hiprtcResult
hiprtcGetProgramLog.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcGetProgramLogSize = _libraries['libhiprtc.so'].hiprtcGetProgramLogSize
hiprtcGetProgramLogSize.restype = hiprtcResult
hiprtcGetProgramLogSize.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_uint64)]
hiprtcGetCode = _libraries['libhiprtc.so'].hiprtcGetCode
hiprtcGetCode.restype = hiprtcResult
hiprtcGetCode.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcGetCodeSize = _libraries['libhiprtc.so'].hiprtcGetCodeSize
hiprtcGetCodeSize.restype = hiprtcResult
hiprtcGetCodeSize.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_uint64)]
hiprtcGetBitcode = _libraries['libhiprtc.so'].hiprtcGetBitcode
hiprtcGetBitcode.restype = hiprtcResult
hiprtcGetBitcode.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcGetBitcodeSize = _libraries['libhiprtc.so'].hiprtcGetBitcodeSize
hiprtcGetBitcodeSize.restype = hiprtcResult
hiprtcGetBitcodeSize.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_uint64)]
hiprtcLinkCreate = _libraries['libhiprtc.so'].hiprtcLinkCreate
hiprtcLinkCreate.restype = hiprtcResult
hiprtcLinkCreate.argtypes = [ctypes.c_uint32, ctypes.POINTER(hiprtcJIT_option), ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.POINTER(struct_ihiprtcLinkState))]
hiprtcLinkAddFile = _libraries['libhiprtc.so'].hiprtcLinkAddFile
hiprtcLinkAddFile.restype = hiprtcResult
hiprtcLinkAddFile.argtypes = [hiprtcLinkState, hiprtcJITInputType, ctypes.POINTER(ctypes.c_char), ctypes.c_uint32, ctypes.POINTER(hiprtcJIT_option), ctypes.POINTER(ctypes.POINTER(None))]
size_t = ctypes.c_uint64
hiprtcLinkAddData = _libraries['libhiprtc.so'].hiprtcLinkAddData
hiprtcLinkAddData.restype = hiprtcResult
hiprtcLinkAddData.argtypes = [hiprtcLinkState, hiprtcJITInputType, ctypes.POINTER(None), size_t, ctypes.POINTER(ctypes.c_char), ctypes.c_uint32, ctypes.POINTER(hiprtcJIT_option), ctypes.POINTER(ctypes.POINTER(None))]
hiprtcLinkComplete = _libraries['libhiprtc.so'].hiprtcLinkComplete
hiprtcLinkComplete.restype = hiprtcResult
hiprtcLinkComplete.argtypes = [hiprtcLinkState, ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64)]
hiprtcLinkDestroy = _libraries['libhiprtc.so'].hiprtcLinkDestroy
hiprtcLinkDestroy.restype = hiprtcResult
hiprtcLinkDestroy.argtypes = [hiprtcLinkState]

# values for enumeration 'c__Ea_HIP_SUCCESS'
c__Ea_HIP_SUCCESS__enumvalues = {
    0: 'HIP_SUCCESS',
    1: 'HIP_ERROR_INVALID_VALUE',
    2: 'HIP_ERROR_NOT_INITIALIZED',
    3: 'HIP_ERROR_LAUNCH_OUT_OF_RESOURCES',
}
HIP_SUCCESS = 0
HIP_ERROR_INVALID_VALUE = 1
HIP_ERROR_NOT_INITIALIZED = 2
HIP_ERROR_LAUNCH_OUT_OF_RESOURCES = 3
c__Ea_HIP_SUCCESS = ctypes.c_uint32 # enum
class struct_c__SA_hipDeviceArch_t(Structure):
    pass

struct_c__SA_hipDeviceArch_t._pack_ = 1 # source:False
struct_c__SA_hipDeviceArch_t._fields_ = [
    ('hasGlobalInt32Atomics', ctypes.c_uint32, 1),
    ('hasGlobalFloatAtomicExch', ctypes.c_uint32, 1),
    ('hasSharedInt32Atomics', ctypes.c_uint32, 1),
    ('hasSharedFloatAtomicExch', ctypes.c_uint32, 1),
    ('hasFloatAtomicAdd', ctypes.c_uint32, 1),
    ('hasGlobalInt64Atomics', ctypes.c_uint32, 1),
    ('hasSharedInt64Atomics', ctypes.c_uint32, 1),
    ('hasDoubles', ctypes.c_uint32, 1),
    ('hasWarpVote', ctypes.c_uint32, 1),
    ('hasWarpBallot', ctypes.c_uint32, 1),
    ('hasWarpShuffle', ctypes.c_uint32, 1),
    ('hasFunnelShift', ctypes.c_uint32, 1),
    ('hasThreadFenceSystem', ctypes.c_uint32, 1),
    ('hasSyncThreadsExt', ctypes.c_uint32, 1),
    ('hasSurfaceFuncs', ctypes.c_uint32, 1),
    ('has3dGrid', ctypes.c_uint32, 1),
    ('hasDynamicParallelism', ctypes.c_uint32, 1),
    ('PADDING_0', ctypes.c_uint16, 15),
]

hipDeviceArch_t = struct_c__SA_hipDeviceArch_t
class struct_hipUUID_t(Structure):
    pass

struct_hipUUID_t._pack_ = 1 # source:False
struct_hipUUID_t._fields_ = [
    ('bytes', ctypes.c_char * 16),
]

hipUUID = struct_hipUUID_t
class struct_hipDeviceProp_t(Structure):
    pass

struct_hipDeviceProp_t._pack_ = 1 # source:False
struct_hipDeviceProp_t._fields_ = [
    ('name', ctypes.c_char * 256),
    ('totalGlobalMem', ctypes.c_uint64),
    ('sharedMemPerBlock', ctypes.c_uint64),
    ('regsPerBlock', ctypes.c_int32),
    ('warpSize', ctypes.c_int32),
    ('maxThreadsPerBlock', ctypes.c_int32),
    ('maxThreadsDim', ctypes.c_int32 * 3),
    ('maxGridSize', ctypes.c_int32 * 3),
    ('clockRate', ctypes.c_int32),
    ('memoryClockRate', ctypes.c_int32),
    ('memoryBusWidth', ctypes.c_int32),
    ('totalConstMem', ctypes.c_uint64),
    ('major', ctypes.c_int32),
    ('minor', ctypes.c_int32),
    ('multiProcessorCount', ctypes.c_int32),
    ('l2CacheSize', ctypes.c_int32),
    ('maxThreadsPerMultiProcessor', ctypes.c_int32),
    ('computeMode', ctypes.c_int32),
    ('clockInstructionRate', ctypes.c_int32),
    ('arch', hipDeviceArch_t),
    ('concurrentKernels', ctypes.c_int32),
    ('pciDomainID', ctypes.c_int32),
    ('pciBusID', ctypes.c_int32),
    ('pciDeviceID', ctypes.c_int32),
    ('maxSharedMemoryPerMultiProcessor', ctypes.c_uint64),
    ('isMultiGpuBoard', ctypes.c_int32),
    ('canMapHostMemory', ctypes.c_int32),
    ('gcnArch', ctypes.c_int32),
    ('gcnArchName', ctypes.c_char * 256),
    ('integrated', ctypes.c_int32),
    ('cooperativeLaunch', ctypes.c_int32),
    ('cooperativeMultiDeviceLaunch', ctypes.c_int32),
    ('maxTexture1DLinear', ctypes.c_int32),
    ('maxTexture1D', ctypes.c_int32),
    ('maxTexture2D', ctypes.c_int32 * 2),
    ('maxTexture3D', ctypes.c_int32 * 3),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('hdpMemFlushCntl', ctypes.POINTER(ctypes.c_uint32)),
    ('hdpRegFlushCntl', ctypes.POINTER(ctypes.c_uint32)),
    ('memPitch', ctypes.c_uint64),
    ('textureAlignment', ctypes.c_uint64),
    ('texturePitchAlignment', ctypes.c_uint64),
    ('kernelExecTimeoutEnabled', ctypes.c_int32),
    ('ECCEnabled', ctypes.c_int32),
    ('tccDriver', ctypes.c_int32),
    ('cooperativeMultiDeviceUnmatchedFunc', ctypes.c_int32),
    ('cooperativeMultiDeviceUnmatchedGridDim', ctypes.c_int32),
    ('cooperativeMultiDeviceUnmatchedBlockDim', ctypes.c_int32),
    ('cooperativeMultiDeviceUnmatchedSharedMem', ctypes.c_int32),
    ('isLargeBar', ctypes.c_int32),
    ('asicRevision', ctypes.c_int32),
    ('managedMemory', ctypes.c_int32),
    ('directManagedMemAccessFromHost', ctypes.c_int32),
    ('concurrentManagedAccess', ctypes.c_int32),
    ('pageableMemoryAccess', ctypes.c_int32),
    ('pageableMemoryAccessUsesHostPageTables', ctypes.c_int32),
]

hipDeviceProp_t = struct_hipDeviceProp_t

# values for enumeration 'hipMemoryType'
hipMemoryType__enumvalues = {
    0: 'hipMemoryTypeHost',
    1: 'hipMemoryTypeDevice',
    2: 'hipMemoryTypeArray',
    3: 'hipMemoryTypeUnified',
    4: 'hipMemoryTypeManaged',
}
hipMemoryTypeHost = 0
hipMemoryTypeDevice = 1
hipMemoryTypeArray = 2
hipMemoryTypeUnified = 3
hipMemoryTypeManaged = 4
hipMemoryType = ctypes.c_uint32 # enum
class struct_hipPointerAttribute_t(Structure):
    pass

class union_hipPointerAttribute_t_0(Union):
    _pack_ = 1 # source:False
    _fields_ = [
    ('memoryType', hipMemoryType),
    ('type', hipMemoryType),
     ]

struct_hipPointerAttribute_t._pack_ = 1 # source:False
struct_hipPointerAttribute_t._anonymous_ = ('_0',)
struct_hipPointerAttribute_t._fields_ = [
    ('_0', union_hipPointerAttribute_t_0),
    ('device', ctypes.c_int32),
    ('devicePointer', ctypes.POINTER(None)),
    ('hostPointer', ctypes.POINTER(None)),
    ('isManaged', ctypes.c_int32),
    ('allocationFlags', ctypes.c_uint32),
]

hipPointerAttribute_t = struct_hipPointerAttribute_t

# values for enumeration 'hipError_t'
hipError_t__enumvalues = {
    0: 'hipSuccess',
    1: 'hipErrorInvalidValue',
    2: 'hipErrorOutOfMemory',
    2: 'hipErrorMemoryAllocation',
    3: 'hipErrorNotInitialized',
    3: 'hipErrorInitializationError',
    4: 'hipErrorDeinitialized',
    5: 'hipErrorProfilerDisabled',
    6: 'hipErrorProfilerNotInitialized',
    7: 'hipErrorProfilerAlreadyStarted',
    8: 'hipErrorProfilerAlreadyStopped',
    9: 'hipErrorInvalidConfiguration',
    12: 'hipErrorInvalidPitchValue',
    13: 'hipErrorInvalidSymbol',
    17: 'hipErrorInvalidDevicePointer',
    21: 'hipErrorInvalidMemcpyDirection',
    35: 'hipErrorInsufficientDriver',
    52: 'hipErrorMissingConfiguration',
    53: 'hipErrorPriorLaunchFailure',
    98: 'hipErrorInvalidDeviceFunction',
    100: 'hipErrorNoDevice',
    101: 'hipErrorInvalidDevice',
    200: 'hipErrorInvalidImage',
    201: 'hipErrorInvalidContext',
    202: 'hipErrorContextAlreadyCurrent',
    205: 'hipErrorMapFailed',
    205: 'hipErrorMapBufferObjectFailed',
    206: 'hipErrorUnmapFailed',
    207: 'hipErrorArrayIsMapped',
    208: 'hipErrorAlreadyMapped',
    209: 'hipErrorNoBinaryForGpu',
    210: 'hipErrorAlreadyAcquired',
    211: 'hipErrorNotMapped',
    212: 'hipErrorNotMappedAsArray',
    213: 'hipErrorNotMappedAsPointer',
    214: 'hipErrorECCNotCorrectable',
    215: 'hipErrorUnsupportedLimit',
    216: 'hipErrorContextAlreadyInUse',
    217: 'hipErrorPeerAccessUnsupported',
    218: 'hipErrorInvalidKernelFile',
    219: 'hipErrorInvalidGraphicsContext',
    300: 'hipErrorInvalidSource',
    301: 'hipErrorFileNotFound',
    302: 'hipErrorSharedObjectSymbolNotFound',
    303: 'hipErrorSharedObjectInitFailed',
    304: 'hipErrorOperatingSystem',
    400: 'hipErrorInvalidHandle',
    400: 'hipErrorInvalidResourceHandle',
    401: 'hipErrorIllegalState',
    500: 'hipErrorNotFound',
    600: 'hipErrorNotReady',
    700: 'hipErrorIllegalAddress',
    701: 'hipErrorLaunchOutOfResources',
    702: 'hipErrorLaunchTimeOut',
    704: 'hipErrorPeerAccessAlreadyEnabled',
    705: 'hipErrorPeerAccessNotEnabled',
    708: 'hipErrorSetOnActiveProcess',
    709: 'hipErrorContextIsDestroyed',
    710: 'hipErrorAssert',
    712: 'hipErrorHostMemoryAlreadyRegistered',
    713: 'hipErrorHostMemoryNotRegistered',
    719: 'hipErrorLaunchFailure',
    720: 'hipErrorCooperativeLaunchTooLarge',
    801: 'hipErrorNotSupported',
    900: 'hipErrorStreamCaptureUnsupported',
    901: 'hipErrorStreamCaptureInvalidated',
    902: 'hipErrorStreamCaptureMerge',
    903: 'hipErrorStreamCaptureUnmatched',
    904: 'hipErrorStreamCaptureUnjoined',
    905: 'hipErrorStreamCaptureIsolation',
    906: 'hipErrorStreamCaptureImplicit',
    907: 'hipErrorCapturedEvent',
    908: 'hipErrorStreamCaptureWrongThread',
    910: 'hipErrorGraphExecUpdateFailure',
    999: 'hipErrorUnknown',
    1052: 'hipErrorRuntimeMemory',
    1053: 'hipErrorRuntimeOther',
    1054: 'hipErrorTbd',
}
hipSuccess = 0
hipErrorInvalidValue = 1
hipErrorOutOfMemory = 2
hipErrorMemoryAllocation = 2
hipErrorNotInitialized = 3
hipErrorInitializationError = 3
hipErrorDeinitialized = 4
hipErrorProfilerDisabled = 5
hipErrorProfilerNotInitialized = 6
hipErrorProfilerAlreadyStarted = 7
hipErrorProfilerAlreadyStopped = 8
hipErrorInvalidConfiguration = 9
hipErrorInvalidPitchValue = 12
hipErrorInvalidSymbol = 13
hipErrorInvalidDevicePointer = 17
hipErrorInvalidMemcpyDirection = 21
hipErrorInsufficientDriver = 35
hipErrorMissingConfiguration = 52
hipErrorPriorLaunchFailure = 53
hipErrorInvalidDeviceFunction = 98
hipErrorNoDevice = 100
hipErrorInvalidDevice = 101
hipErrorInvalidImage = 200
hipErrorInvalidContext = 201
hipErrorContextAlreadyCurrent = 202
hipErrorMapFailed = 205
hipErrorMapBufferObjectFailed = 205
hipErrorUnmapFailed = 206
hipErrorArrayIsMapped = 207
hipErrorAlreadyMapped = 208
hipErrorNoBinaryForGpu = 209
hipErrorAlreadyAcquired = 210
hipErrorNotMapped = 211
hipErrorNotMappedAsArray = 212
hipErrorNotMappedAsPointer = 213
hipErrorECCNotCorrectable = 214
hipErrorUnsupportedLimit = 215
hipErrorContextAlreadyInUse = 216
hipErrorPeerAccessUnsupported = 217
hipErrorInvalidKernelFile = 218
hipErrorInvalidGraphicsContext = 219
hipErrorInvalidSource = 300
hipErrorFileNotFound = 301
hipErrorSharedObjectSymbolNotFound = 302
hipErrorSharedObjectInitFailed = 303
hipErrorOperatingSystem = 304
hipErrorInvalidHandle = 400
hipErrorInvalidResourceHandle = 400
hipErrorIllegalState = 401
hipErrorNotFound = 500
hipErrorNotReady = 600
hipErrorIllegalAddress = 700
hipErrorLaunchOutOfResources = 701
hipErrorLaunchTimeOut = 702
hipErrorPeerAccessAlreadyEnabled = 704
hipErrorPeerAccessNotEnabled = 705
hipErrorSetOnActiveProcess = 708
hipErrorContextIsDestroyed = 709
hipErrorAssert = 710
hipErrorHostMemoryAlreadyRegistered = 712
hipErrorHostMemoryNotRegistered = 713
hipErrorLaunchFailure = 719
hipErrorCooperativeLaunchTooLarge = 720
hipErrorNotSupported = 801
hipErrorStreamCaptureUnsupported = 900
hipErrorStreamCaptureInvalidated = 901
hipErrorStreamCaptureMerge = 902
hipErrorStreamCaptureUnmatched = 903
hipErrorStreamCaptureUnjoined = 904
hipErrorStreamCaptureIsolation = 905
hipErrorStreamCaptureImplicit = 906
hipErrorCapturedEvent = 907
hipErrorStreamCaptureWrongThread = 908
hipErrorGraphExecUpdateFailure = 910
hipErrorUnknown = 999
hipErrorRuntimeMemory = 1052
hipErrorRuntimeOther = 1053
hipErrorTbd = 1054
hipError_t = ctypes.c_uint32 # enum

# values for enumeration 'hipDeviceAttribute_t'
hipDeviceAttribute_t__enumvalues = {
    0: 'hipDeviceAttributeCudaCompatibleBegin',
    0: 'hipDeviceAttributeEccEnabled',
    1: 'hipDeviceAttributeAccessPolicyMaxWindowSize',
    2: 'hipDeviceAttributeAsyncEngineCount',
    3: 'hipDeviceAttributeCanMapHostMemory',
    4: 'hipDeviceAttributeCanUseHostPointerForRegisteredMem',
    5: 'hipDeviceAttributeClockRate',
    6: 'hipDeviceAttributeComputeMode',
    7: 'hipDeviceAttributeComputePreemptionSupported',
    8: 'hipDeviceAttributeConcurrentKernels',
    9: 'hipDeviceAttributeConcurrentManagedAccess',
    10: 'hipDeviceAttributeCooperativeLaunch',
    11: 'hipDeviceAttributeCooperativeMultiDeviceLaunch',
    12: 'hipDeviceAttributeDeviceOverlap',
    13: 'hipDeviceAttributeDirectManagedMemAccessFromHost',
    14: 'hipDeviceAttributeGlobalL1CacheSupported',
    15: 'hipDeviceAttributeHostNativeAtomicSupported',
    16: 'hipDeviceAttributeIntegrated',
    17: 'hipDeviceAttributeIsMultiGpuBoard',
    18: 'hipDeviceAttributeKernelExecTimeout',
    19: 'hipDeviceAttributeL2CacheSize',
    20: 'hipDeviceAttributeLocalL1CacheSupported',
    21: 'hipDeviceAttributeLuid',
    22: 'hipDeviceAttributeLuidDeviceNodeMask',
    23: 'hipDeviceAttributeComputeCapabilityMajor',
    24: 'hipDeviceAttributeManagedMemory',
    25: 'hipDeviceAttributeMaxBlocksPerMultiProcessor',
    26: 'hipDeviceAttributeMaxBlockDimX',
    27: 'hipDeviceAttributeMaxBlockDimY',
    28: 'hipDeviceAttributeMaxBlockDimZ',
    29: 'hipDeviceAttributeMaxGridDimX',
    30: 'hipDeviceAttributeMaxGridDimY',
    31: 'hipDeviceAttributeMaxGridDimZ',
    32: 'hipDeviceAttributeMaxSurface1D',
    33: 'hipDeviceAttributeMaxSurface1DLayered',
    34: 'hipDeviceAttributeMaxSurface2D',
    35: 'hipDeviceAttributeMaxSurface2DLayered',
    36: 'hipDeviceAttributeMaxSurface3D',
    37: 'hipDeviceAttributeMaxSurfaceCubemap',
    38: 'hipDeviceAttributeMaxSurfaceCubemapLayered',
    39: 'hipDeviceAttributeMaxTexture1DWidth',
    40: 'hipDeviceAttributeMaxTexture1DLayered',
    41: 'hipDeviceAttributeMaxTexture1DLinear',
    42: 'hipDeviceAttributeMaxTexture1DMipmap',
    43: 'hipDeviceAttributeMaxTexture2DWidth',
    44: 'hipDeviceAttributeMaxTexture2DHeight',
    45: 'hipDeviceAttributeMaxTexture2DGather',
    46: 'hipDeviceAttributeMaxTexture2DLayered',
    47: 'hipDeviceAttributeMaxTexture2DLinear',
    48: 'hipDeviceAttributeMaxTexture2DMipmap',
    49: 'hipDeviceAttributeMaxTexture3DWidth',
    50: 'hipDeviceAttributeMaxTexture3DHeight',
    51: 'hipDeviceAttributeMaxTexture3DDepth',
    52: 'hipDeviceAttributeMaxTexture3DAlt',
    53: 'hipDeviceAttributeMaxTextureCubemap',
    54: 'hipDeviceAttributeMaxTextureCubemapLayered',
    55: 'hipDeviceAttributeMaxThreadsDim',
    56: 'hipDeviceAttributeMaxThreadsPerBlock',
    57: 'hipDeviceAttributeMaxThreadsPerMultiProcessor',
    58: 'hipDeviceAttributeMaxPitch',
    59: 'hipDeviceAttributeMemoryBusWidth',
    60: 'hipDeviceAttributeMemoryClockRate',
    61: 'hipDeviceAttributeComputeCapabilityMinor',
    62: 'hipDeviceAttributeMultiGpuBoardGroupID',
    63: 'hipDeviceAttributeMultiprocessorCount',
    64: 'hipDeviceAttributeName',
    65: 'hipDeviceAttributePageableMemoryAccess',
    66: 'hipDeviceAttributePageableMemoryAccessUsesHostPageTables',
    67: 'hipDeviceAttributePciBusId',
    68: 'hipDeviceAttributePciDeviceId',
    69: 'hipDeviceAttributePciDomainID',
    70: 'hipDeviceAttributePersistingL2CacheMaxSize',
    71: 'hipDeviceAttributeMaxRegistersPerBlock',
    72: 'hipDeviceAttributeMaxRegistersPerMultiprocessor',
    73: 'hipDeviceAttributeReservedSharedMemPerBlock',
    74: 'hipDeviceAttributeMaxSharedMemoryPerBlock',
    75: 'hipDeviceAttributeSharedMemPerBlockOptin',
    76: 'hipDeviceAttributeSharedMemPerMultiprocessor',
    77: 'hipDeviceAttributeSingleToDoublePrecisionPerfRatio',
    78: 'hipDeviceAttributeStreamPrioritiesSupported',
    79: 'hipDeviceAttributeSurfaceAlignment',
    80: 'hipDeviceAttributeTccDriver',
    81: 'hipDeviceAttributeTextureAlignment',
    82: 'hipDeviceAttributeTexturePitchAlignment',
    83: 'hipDeviceAttributeTotalConstantMemory',
    84: 'hipDeviceAttributeTotalGlobalMem',
    85: 'hipDeviceAttributeUnifiedAddressing',
    86: 'hipDeviceAttributeUuid',
    87: 'hipDeviceAttributeWarpSize',
    88: 'hipDeviceAttributeMemoryPoolsSupported',
    89: 'hipDeviceAttributeVirtualMemoryManagementSupported',
    9999: 'hipDeviceAttributeCudaCompatibleEnd',
    10000: 'hipDeviceAttributeAmdSpecificBegin',
    10000: 'hipDeviceAttributeClockInstructionRate',
    10001: 'hipDeviceAttributeArch',
    10002: 'hipDeviceAttributeMaxSharedMemoryPerMultiprocessor',
    10003: 'hipDeviceAttributeGcnArch',
    10004: 'hipDeviceAttributeGcnArchName',
    10005: 'hipDeviceAttributeHdpMemFlushCntl',
    10006: 'hipDeviceAttributeHdpRegFlushCntl',
    10007: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc',
    10008: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim',
    10009: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim',
    10010: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem',
    10011: 'hipDeviceAttributeIsLargeBar',
    10012: 'hipDeviceAttributeAsicRevision',
    10013: 'hipDeviceAttributeCanUseStreamWaitValue',
    10014: 'hipDeviceAttributeImageSupport',
    10015: 'hipDeviceAttributePhysicalMultiProcessorCount',
    10016: 'hipDeviceAttributeFineGrainSupport',
    10017: 'hipDeviceAttributeWallClockRate',
    19999: 'hipDeviceAttributeAmdSpecificEnd',
    20000: 'hipDeviceAttributeVendorSpecificBegin',
}
hipDeviceAttributeCudaCompatibleBegin = 0
hipDeviceAttributeEccEnabled = 0
hipDeviceAttributeAccessPolicyMaxWindowSize = 1
hipDeviceAttributeAsyncEngineCount = 2
hipDeviceAttributeCanMapHostMemory = 3
hipDeviceAttributeCanUseHostPointerForRegisteredMem = 4
hipDeviceAttributeClockRate = 5
hipDeviceAttributeComputeMode = 6
hipDeviceAttributeComputePreemptionSupported = 7
hipDeviceAttributeConcurrentKernels = 8
hipDeviceAttributeConcurrentManagedAccess = 9
hipDeviceAttributeCooperativeLaunch = 10
hipDeviceAttributeCooperativeMultiDeviceLaunch = 11
hipDeviceAttributeDeviceOverlap = 12
hipDeviceAttributeDirectManagedMemAccessFromHost = 13
hipDeviceAttributeGlobalL1CacheSupported = 14
hipDeviceAttributeHostNativeAtomicSupported = 15
hipDeviceAttributeIntegrated = 16
hipDeviceAttributeIsMultiGpuBoard = 17
hipDeviceAttributeKernelExecTimeout = 18
hipDeviceAttributeL2CacheSize = 19
hipDeviceAttributeLocalL1CacheSupported = 20
hipDeviceAttributeLuid = 21
hipDeviceAttributeLuidDeviceNodeMask = 22
hipDeviceAttributeComputeCapabilityMajor = 23
hipDeviceAttributeManagedMemory = 24
hipDeviceAttributeMaxBlocksPerMultiProcessor = 25
hipDeviceAttributeMaxBlockDimX = 26
hipDeviceAttributeMaxBlockDimY = 27
hipDeviceAttributeMaxBlockDimZ = 28
hipDeviceAttributeMaxGridDimX = 29
hipDeviceAttributeMaxGridDimY = 30
hipDeviceAttributeMaxGridDimZ = 31
hipDeviceAttributeMaxSurface1D = 32
hipDeviceAttributeMaxSurface1DLayered = 33
hipDeviceAttributeMaxSurface2D = 34
hipDeviceAttributeMaxSurface2DLayered = 35
hipDeviceAttributeMaxSurface3D = 36
hipDeviceAttributeMaxSurfaceCubemap = 37
hipDeviceAttributeMaxSurfaceCubemapLayered = 38
hipDeviceAttributeMaxTexture1DWidth = 39
hipDeviceAttributeMaxTexture1DLayered = 40
hipDeviceAttributeMaxTexture1DLinear = 41
hipDeviceAttributeMaxTexture1DMipmap = 42
hipDeviceAttributeMaxTexture2DWidth = 43
hipDeviceAttributeMaxTexture2DHeight = 44
hipDeviceAttributeMaxTexture2DGather = 45
hipDeviceAttributeMaxTexture2DLayered = 46
hipDeviceAttributeMaxTexture2DLinear = 47
hipDeviceAttributeMaxTexture2DMipmap = 48
hipDeviceAttributeMaxTexture3DWidth = 49
hipDeviceAttributeMaxTexture3DHeight = 50
hipDeviceAttributeMaxTexture3DDepth = 51
hipDeviceAttributeMaxTexture3DAlt = 52
hipDeviceAttributeMaxTextureCubemap = 53
hipDeviceAttributeMaxTextureCubemapLayered = 54
hipDeviceAttributeMaxThreadsDim = 55
hipDeviceAttributeMaxThreadsPerBlock = 56
hipDeviceAttributeMaxThreadsPerMultiProcessor = 57
hipDeviceAttributeMaxPitch = 58
hipDeviceAttributeMemoryBusWidth = 59
hipDeviceAttributeMemoryClockRate = 60
hipDeviceAttributeComputeCapabilityMinor = 61
hipDeviceAttributeMultiGpuBoardGroupID = 62
hipDeviceAttributeMultiprocessorCount = 63
hipDeviceAttributeName = 64
hipDeviceAttributePageableMemoryAccess = 65
hipDeviceAttributePageableMemoryAccessUsesHostPageTables = 66
hipDeviceAttributePciBusId = 67
hipDeviceAttributePciDeviceId = 68
hipDeviceAttributePciDomainID = 69
hipDeviceAttributePersistingL2CacheMaxSize = 70
hipDeviceAttributeMaxRegistersPerBlock = 71
hipDeviceAttributeMaxRegistersPerMultiprocessor = 72
hipDeviceAttributeReservedSharedMemPerBlock = 73
hipDeviceAttributeMaxSharedMemoryPerBlock = 74
hipDeviceAttributeSharedMemPerBlockOptin = 75
hipDeviceAttributeSharedMemPerMultiprocessor = 76
hipDeviceAttributeSingleToDoublePrecisionPerfRatio = 77
hipDeviceAttributeStreamPrioritiesSupported = 78
hipDeviceAttributeSurfaceAlignment = 79
hipDeviceAttributeTccDriver = 80
hipDeviceAttributeTextureAlignment = 81
hipDeviceAttributeTexturePitchAlignment = 82
hipDeviceAttributeTotalConstantMemory = 83
hipDeviceAttributeTotalGlobalMem = 84
hipDeviceAttributeUnifiedAddressing = 85
hipDeviceAttributeUuid = 86
hipDeviceAttributeWarpSize = 87
hipDeviceAttributeMemoryPoolsSupported = 88
hipDeviceAttributeVirtualMemoryManagementSupported = 89
hipDeviceAttributeCudaCompatibleEnd = 9999
hipDeviceAttributeAmdSpecificBegin = 10000
hipDeviceAttributeClockInstructionRate = 10000
hipDeviceAttributeArch = 10001
hipDeviceAttributeMaxSharedMemoryPerMultiprocessor = 10002
hipDeviceAttributeGcnArch = 10003
hipDeviceAttributeGcnArchName = 10004
hipDeviceAttributeHdpMemFlushCntl = 10005
hipDeviceAttributeHdpRegFlushCntl = 10006
hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc = 10007
hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim = 10008
hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim = 10009
hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem = 10010
hipDeviceAttributeIsLargeBar = 10011
hipDeviceAttributeAsicRevision = 10012
hipDeviceAttributeCanUseStreamWaitValue = 10013
hipDeviceAttributeImageSupport = 10014
hipDeviceAttributePhysicalMultiProcessorCount = 10015
hipDeviceAttributeFineGrainSupport = 10016
hipDeviceAttributeWallClockRate = 10017
hipDeviceAttributeAmdSpecificEnd = 19999
hipDeviceAttributeVendorSpecificBegin = 20000
hipDeviceAttribute_t = ctypes.c_uint32 # enum

# values for enumeration 'hipComputeMode'
hipComputeMode__enumvalues = {
    0: 'hipComputeModeDefault',
    1: 'hipComputeModeExclusive',
    2: 'hipComputeModeProhibited',
    3: 'hipComputeModeExclusiveProcess',
}
hipComputeModeDefault = 0
hipComputeModeExclusive = 1
hipComputeModeProhibited = 2
hipComputeModeExclusiveProcess = 3
hipComputeMode = ctypes.c_uint32 # enum
hipDeviceptr_t = ctypes.POINTER(None)

# values for enumeration 'hipChannelFormatKind'
hipChannelFormatKind__enumvalues = {
    0: 'hipChannelFormatKindSigned',
    1: 'hipChannelFormatKindUnsigned',
    2: 'hipChannelFormatKindFloat',
    3: 'hipChannelFormatKindNone',
}
hipChannelFormatKindSigned = 0
hipChannelFormatKindUnsigned = 1
hipChannelFormatKindFloat = 2
hipChannelFormatKindNone = 3
hipChannelFormatKind = ctypes.c_uint32 # enum
class struct_hipChannelFormatDesc(Structure):
    pass

struct_hipChannelFormatDesc._pack_ = 1 # source:False
struct_hipChannelFormatDesc._fields_ = [
    ('x', ctypes.c_int32),
    ('y', ctypes.c_int32),
    ('z', ctypes.c_int32),
    ('w', ctypes.c_int32),
    ('f', hipChannelFormatKind),
]

hipChannelFormatDesc = struct_hipChannelFormatDesc

# values for enumeration 'hipArray_Format'
hipArray_Format__enumvalues = {
    1: 'HIP_AD_FORMAT_UNSIGNED_INT8',
    2: 'HIP_AD_FORMAT_UNSIGNED_INT16',
    3: 'HIP_AD_FORMAT_UNSIGNED_INT32',
    8: 'HIP_AD_FORMAT_SIGNED_INT8',
    9: 'HIP_AD_FORMAT_SIGNED_INT16',
    10: 'HIP_AD_FORMAT_SIGNED_INT32',
    16: 'HIP_AD_FORMAT_HALF',
    32: 'HIP_AD_FORMAT_FLOAT',
}
HIP_AD_FORMAT_UNSIGNED_INT8 = 1
HIP_AD_FORMAT_UNSIGNED_INT16 = 2
HIP_AD_FORMAT_UNSIGNED_INT32 = 3
HIP_AD_FORMAT_SIGNED_INT8 = 8
HIP_AD_FORMAT_SIGNED_INT16 = 9
HIP_AD_FORMAT_SIGNED_INT32 = 10
HIP_AD_FORMAT_HALF = 16
HIP_AD_FORMAT_FLOAT = 32
hipArray_Format = ctypes.c_uint32 # enum
class struct_HIP_ARRAY_DESCRIPTOR(Structure):
    pass

struct_HIP_ARRAY_DESCRIPTOR._pack_ = 1 # source:False
struct_HIP_ARRAY_DESCRIPTOR._fields_ = [
    ('Width', ctypes.c_uint64),
    ('Height', ctypes.c_uint64),
    ('Format', hipArray_Format),
    ('NumChannels', ctypes.c_uint32),
]

HIP_ARRAY_DESCRIPTOR = struct_HIP_ARRAY_DESCRIPTOR
class struct_HIP_ARRAY3D_DESCRIPTOR(Structure):
    pass

struct_HIP_ARRAY3D_DESCRIPTOR._pack_ = 1 # source:False
struct_HIP_ARRAY3D_DESCRIPTOR._fields_ = [
    ('Width', ctypes.c_uint64),
    ('Height', ctypes.c_uint64),
    ('Depth', ctypes.c_uint64),
    ('Format', hipArray_Format),
    ('NumChannels', ctypes.c_uint32),
    ('Flags', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

HIP_ARRAY3D_DESCRIPTOR = struct_HIP_ARRAY3D_DESCRIPTOR
class struct_hipArray(Structure):
    pass

struct_hipArray._pack_ = 1 # source:False
struct_hipArray._fields_ = [
    ('data', ctypes.POINTER(None)),
    ('desc', struct_hipChannelFormatDesc),
    ('type', ctypes.c_uint32),
    ('width', ctypes.c_uint32),
    ('height', ctypes.c_uint32),
    ('depth', ctypes.c_uint32),
    ('Format', hipArray_Format),
    ('NumChannels', ctypes.c_uint32),
    ('isDrv', ctypes.c_bool),
    ('PADDING_0', ctypes.c_ubyte * 3),
    ('textureType', ctypes.c_uint32),
    ('flags', ctypes.c_uint32),
]

hipArray = struct_hipArray
class struct_hip_Memcpy2D(Structure):
    pass

struct_hip_Memcpy2D._pack_ = 1 # source:False
struct_hip_Memcpy2D._fields_ = [
    ('srcXInBytes', ctypes.c_uint64),
    ('srcY', ctypes.c_uint64),
    ('srcMemoryType', hipMemoryType),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('srcHost', ctypes.POINTER(None)),
    ('srcDevice', ctypes.POINTER(None)),
    ('srcArray', ctypes.POINTER(struct_hipArray)),
    ('srcPitch', ctypes.c_uint64),
    ('dstXInBytes', ctypes.c_uint64),
    ('dstY', ctypes.c_uint64),
    ('dstMemoryType', hipMemoryType),
    ('PADDING_1', ctypes.c_ubyte * 4),
    ('dstHost', ctypes.POINTER(None)),
    ('dstDevice', ctypes.POINTER(None)),
    ('dstArray', ctypes.POINTER(struct_hipArray)),
    ('dstPitch', ctypes.c_uint64),
    ('WidthInBytes', ctypes.c_uint64),
    ('Height', ctypes.c_uint64),
]

hip_Memcpy2D = struct_hip_Memcpy2D
hipArray_t = ctypes.POINTER(struct_hipArray)
hiparray = ctypes.POINTER(struct_hipArray)
hipArray_const_t = ctypes.POINTER(struct_hipArray)
class struct_hipMipmappedArray(Structure):
    pass

struct_hipMipmappedArray._pack_ = 1 # source:False
struct_hipMipmappedArray._fields_ = [
    ('data', ctypes.POINTER(None)),
    ('desc', struct_hipChannelFormatDesc),
    ('type', ctypes.c_uint32),
    ('width', ctypes.c_uint32),
    ('height', ctypes.c_uint32),
    ('depth', ctypes.c_uint32),
    ('min_mipmap_level', ctypes.c_uint32),
    ('max_mipmap_level', ctypes.c_uint32),
    ('flags', ctypes.c_uint32),
    ('format', hipArray_Format),
    ('num_channels', ctypes.c_uint32),
]

hipMipmappedArray = struct_hipMipmappedArray
hipMipmappedArray_t = ctypes.POINTER(struct_hipMipmappedArray)
hipmipmappedArray = ctypes.POINTER(struct_hipMipmappedArray)
hipMipmappedArray_const_t = ctypes.POINTER(struct_hipMipmappedArray)

# values for enumeration 'hipResourceType'
hipResourceType__enumvalues = {
    0: 'hipResourceTypeArray',
    1: 'hipResourceTypeMipmappedArray',
    2: 'hipResourceTypeLinear',
    3: 'hipResourceTypePitch2D',
}
hipResourceTypeArray = 0
hipResourceTypeMipmappedArray = 1
hipResourceTypeLinear = 2
hipResourceTypePitch2D = 3
hipResourceType = ctypes.c_uint32 # enum

# values for enumeration 'HIPresourcetype_enum'
HIPresourcetype_enum__enumvalues = {
    0: 'HIP_RESOURCE_TYPE_ARRAY',
    1: 'HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY',
    2: 'HIP_RESOURCE_TYPE_LINEAR',
    3: 'HIP_RESOURCE_TYPE_PITCH2D',
}
HIP_RESOURCE_TYPE_ARRAY = 0
HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY = 1
HIP_RESOURCE_TYPE_LINEAR = 2
HIP_RESOURCE_TYPE_PITCH2D = 3
HIPresourcetype_enum = ctypes.c_uint32 # enum
HIPresourcetype = HIPresourcetype_enum
HIPresourcetype__enumvalues = HIPresourcetype_enum__enumvalues
hipResourcetype = HIPresourcetype_enum
hipResourcetype__enumvalues = HIPresourcetype_enum__enumvalues

# values for enumeration 'HIPaddress_mode_enum'
HIPaddress_mode_enum__enumvalues = {
    0: 'HIP_TR_ADDRESS_MODE_WRAP',
    1: 'HIP_TR_ADDRESS_MODE_CLAMP',
    2: 'HIP_TR_ADDRESS_MODE_MIRROR',
    3: 'HIP_TR_ADDRESS_MODE_BORDER',
}
HIP_TR_ADDRESS_MODE_WRAP = 0
HIP_TR_ADDRESS_MODE_CLAMP = 1
HIP_TR_ADDRESS_MODE_MIRROR = 2
HIP_TR_ADDRESS_MODE_BORDER = 3
HIPaddress_mode_enum = ctypes.c_uint32 # enum
HIPaddress_mode = HIPaddress_mode_enum
HIPaddress_mode__enumvalues = HIPaddress_mode_enum__enumvalues

# values for enumeration 'HIPfilter_mode_enum'
HIPfilter_mode_enum__enumvalues = {
    0: 'HIP_TR_FILTER_MODE_POINT',
    1: 'HIP_TR_FILTER_MODE_LINEAR',
}
HIP_TR_FILTER_MODE_POINT = 0
HIP_TR_FILTER_MODE_LINEAR = 1
HIPfilter_mode_enum = ctypes.c_uint32 # enum
HIPfilter_mode = HIPfilter_mode_enum
HIPfilter_mode__enumvalues = HIPfilter_mode_enum__enumvalues
class struct_HIP_TEXTURE_DESC_st(Structure):
    pass

struct_HIP_TEXTURE_DESC_st._pack_ = 1 # source:False
struct_HIP_TEXTURE_DESC_st._fields_ = [
    ('addressMode', HIPaddress_mode_enum * 3),
    ('filterMode', HIPfilter_mode),
    ('flags', ctypes.c_uint32),
    ('maxAnisotropy', ctypes.c_uint32),
    ('mipmapFilterMode', HIPfilter_mode),
    ('mipmapLevelBias', ctypes.c_float),
    ('minMipmapLevelClamp', ctypes.c_float),
    ('maxMipmapLevelClamp', ctypes.c_float),
    ('borderColor', ctypes.c_float * 4),
    ('reserved', ctypes.c_int32 * 12),
]

HIP_TEXTURE_DESC = struct_HIP_TEXTURE_DESC_st

# values for enumeration 'hipResourceViewFormat'
hipResourceViewFormat__enumvalues = {
    0: 'hipResViewFormatNone',
    1: 'hipResViewFormatUnsignedChar1',
    2: 'hipResViewFormatUnsignedChar2',
    3: 'hipResViewFormatUnsignedChar4',
    4: 'hipResViewFormatSignedChar1',
    5: 'hipResViewFormatSignedChar2',
    6: 'hipResViewFormatSignedChar4',
    7: 'hipResViewFormatUnsignedShort1',
    8: 'hipResViewFormatUnsignedShort2',
    9: 'hipResViewFormatUnsignedShort4',
    10: 'hipResViewFormatSignedShort1',
    11: 'hipResViewFormatSignedShort2',
    12: 'hipResViewFormatSignedShort4',
    13: 'hipResViewFormatUnsignedInt1',
    14: 'hipResViewFormatUnsignedInt2',
    15: 'hipResViewFormatUnsignedInt4',
    16: 'hipResViewFormatSignedInt1',
    17: 'hipResViewFormatSignedInt2',
    18: 'hipResViewFormatSignedInt4',
    19: 'hipResViewFormatHalf1',
    20: 'hipResViewFormatHalf2',
    21: 'hipResViewFormatHalf4',
    22: 'hipResViewFormatFloat1',
    23: 'hipResViewFormatFloat2',
    24: 'hipResViewFormatFloat4',
    25: 'hipResViewFormatUnsignedBlockCompressed1',
    26: 'hipResViewFormatUnsignedBlockCompressed2',
    27: 'hipResViewFormatUnsignedBlockCompressed3',
    28: 'hipResViewFormatUnsignedBlockCompressed4',
    29: 'hipResViewFormatSignedBlockCompressed4',
    30: 'hipResViewFormatUnsignedBlockCompressed5',
    31: 'hipResViewFormatSignedBlockCompressed5',
    32: 'hipResViewFormatUnsignedBlockCompressed6H',
    33: 'hipResViewFormatSignedBlockCompressed6H',
    34: 'hipResViewFormatUnsignedBlockCompressed7',
}
hipResViewFormatNone = 0
hipResViewFormatUnsignedChar1 = 1
hipResViewFormatUnsignedChar2 = 2
hipResViewFormatUnsignedChar4 = 3
hipResViewFormatSignedChar1 = 4
hipResViewFormatSignedChar2 = 5
hipResViewFormatSignedChar4 = 6
hipResViewFormatUnsignedShort1 = 7
hipResViewFormatUnsignedShort2 = 8
hipResViewFormatUnsignedShort4 = 9
hipResViewFormatSignedShort1 = 10
hipResViewFormatSignedShort2 = 11
hipResViewFormatSignedShort4 = 12
hipResViewFormatUnsignedInt1 = 13
hipResViewFormatUnsignedInt2 = 14
hipResViewFormatUnsignedInt4 = 15
hipResViewFormatSignedInt1 = 16
hipResViewFormatSignedInt2 = 17
hipResViewFormatSignedInt4 = 18
hipResViewFormatHalf1 = 19
hipResViewFormatHalf2 = 20
hipResViewFormatHalf4 = 21
hipResViewFormatFloat1 = 22
hipResViewFormatFloat2 = 23
hipResViewFormatFloat4 = 24
hipResViewFormatUnsignedBlockCompressed1 = 25
hipResViewFormatUnsignedBlockCompressed2 = 26
hipResViewFormatUnsignedBlockCompressed3 = 27
hipResViewFormatUnsignedBlockCompressed4 = 28
hipResViewFormatSignedBlockCompressed4 = 29
hipResViewFormatUnsignedBlockCompressed5 = 30
hipResViewFormatSignedBlockCompressed5 = 31
hipResViewFormatUnsignedBlockCompressed6H = 32
hipResViewFormatSignedBlockCompressed6H = 33
hipResViewFormatUnsignedBlockCompressed7 = 34
hipResourceViewFormat = ctypes.c_uint32 # enum

# values for enumeration 'HIPresourceViewFormat_enum'
HIPresourceViewFormat_enum__enumvalues = {
    0: 'HIP_RES_VIEW_FORMAT_NONE',
    1: 'HIP_RES_VIEW_FORMAT_UINT_1X8',
    2: 'HIP_RES_VIEW_FORMAT_UINT_2X8',
    3: 'HIP_RES_VIEW_FORMAT_UINT_4X8',
    4: 'HIP_RES_VIEW_FORMAT_SINT_1X8',
    5: 'HIP_RES_VIEW_FORMAT_SINT_2X8',
    6: 'HIP_RES_VIEW_FORMAT_SINT_4X8',
    7: 'HIP_RES_VIEW_FORMAT_UINT_1X16',
    8: 'HIP_RES_VIEW_FORMAT_UINT_2X16',
    9: 'HIP_RES_VIEW_FORMAT_UINT_4X16',
    10: 'HIP_RES_VIEW_FORMAT_SINT_1X16',
    11: 'HIP_RES_VIEW_FORMAT_SINT_2X16',
    12: 'HIP_RES_VIEW_FORMAT_SINT_4X16',
    13: 'HIP_RES_VIEW_FORMAT_UINT_1X32',
    14: 'HIP_RES_VIEW_FORMAT_UINT_2X32',
    15: 'HIP_RES_VIEW_FORMAT_UINT_4X32',
    16: 'HIP_RES_VIEW_FORMAT_SINT_1X32',
    17: 'HIP_RES_VIEW_FORMAT_SINT_2X32',
    18: 'HIP_RES_VIEW_FORMAT_SINT_4X32',
    19: 'HIP_RES_VIEW_FORMAT_FLOAT_1X16',
    20: 'HIP_RES_VIEW_FORMAT_FLOAT_2X16',
    21: 'HIP_RES_VIEW_FORMAT_FLOAT_4X16',
    22: 'HIP_RES_VIEW_FORMAT_FLOAT_1X32',
    23: 'HIP_RES_VIEW_FORMAT_FLOAT_2X32',
    24: 'HIP_RES_VIEW_FORMAT_FLOAT_4X32',
    25: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC1',
    26: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC2',
    27: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC3',
    28: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC4',
    29: 'HIP_RES_VIEW_FORMAT_SIGNED_BC4',
    30: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC5',
    31: 'HIP_RES_VIEW_FORMAT_SIGNED_BC5',
    32: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H',
    33: 'HIP_RES_VIEW_FORMAT_SIGNED_BC6H',
    34: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC7',
}
HIP_RES_VIEW_FORMAT_NONE = 0
HIP_RES_VIEW_FORMAT_UINT_1X8 = 1
HIP_RES_VIEW_FORMAT_UINT_2X8 = 2
HIP_RES_VIEW_FORMAT_UINT_4X8 = 3
HIP_RES_VIEW_FORMAT_SINT_1X8 = 4
HIP_RES_VIEW_FORMAT_SINT_2X8 = 5
HIP_RES_VIEW_FORMAT_SINT_4X8 = 6
HIP_RES_VIEW_FORMAT_UINT_1X16 = 7
HIP_RES_VIEW_FORMAT_UINT_2X16 = 8
HIP_RES_VIEW_FORMAT_UINT_4X16 = 9
HIP_RES_VIEW_FORMAT_SINT_1X16 = 10
HIP_RES_VIEW_FORMAT_SINT_2X16 = 11
HIP_RES_VIEW_FORMAT_SINT_4X16 = 12
HIP_RES_VIEW_FORMAT_UINT_1X32 = 13
HIP_RES_VIEW_FORMAT_UINT_2X32 = 14
HIP_RES_VIEW_FORMAT_UINT_4X32 = 15
HIP_RES_VIEW_FORMAT_SINT_1X32 = 16
HIP_RES_VIEW_FORMAT_SINT_2X32 = 17
HIP_RES_VIEW_FORMAT_SINT_4X32 = 18
HIP_RES_VIEW_FORMAT_FLOAT_1X16 = 19
HIP_RES_VIEW_FORMAT_FLOAT_2X16 = 20
HIP_RES_VIEW_FORMAT_FLOAT_4X16 = 21
HIP_RES_VIEW_FORMAT_FLOAT_1X32 = 22
HIP_RES_VIEW_FORMAT_FLOAT_2X32 = 23
HIP_RES_VIEW_FORMAT_FLOAT_4X32 = 24
HIP_RES_VIEW_FORMAT_UNSIGNED_BC1 = 25
HIP_RES_VIEW_FORMAT_UNSIGNED_BC2 = 26
HIP_RES_VIEW_FORMAT_UNSIGNED_BC3 = 27
HIP_RES_VIEW_FORMAT_UNSIGNED_BC4 = 28
HIP_RES_VIEW_FORMAT_SIGNED_BC4 = 29
HIP_RES_VIEW_FORMAT_UNSIGNED_BC5 = 30
HIP_RES_VIEW_FORMAT_SIGNED_BC5 = 31
HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H = 32
HIP_RES_VIEW_FORMAT_SIGNED_BC6H = 33
HIP_RES_VIEW_FORMAT_UNSIGNED_BC7 = 34
HIPresourceViewFormat_enum = ctypes.c_uint32 # enum
HIPresourceViewFormat = HIPresourceViewFormat_enum
HIPresourceViewFormat__enumvalues = HIPresourceViewFormat_enum__enumvalues
class struct_hipResourceDesc(Structure):
    pass

class union_hipResourceDesc_res(Union):
    pass

class struct_hipResourceDesc_0_pitch2D(Structure):
    pass

struct_hipResourceDesc_0_pitch2D._pack_ = 1 # source:False
struct_hipResourceDesc_0_pitch2D._fields_ = [
    ('devPtr', ctypes.POINTER(None)),
    ('desc', struct_hipChannelFormatDesc),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('width', ctypes.c_uint64),
    ('height', ctypes.c_uint64),
    ('pitchInBytes', ctypes.c_uint64),
]

class struct_hipResourceDesc_0_mipmap(Structure):
    pass

struct_hipResourceDesc_0_mipmap._pack_ = 1 # source:False
struct_hipResourceDesc_0_mipmap._fields_ = [
    ('mipmap', ctypes.POINTER(struct_hipMipmappedArray)),
]

class struct_hipResourceDesc_0_array(Structure):
    pass

struct_hipResourceDesc_0_array._pack_ = 1 # source:False
struct_hipResourceDesc_0_array._fields_ = [
    ('array', ctypes.POINTER(struct_hipArray)),
]

class struct_hipResourceDesc_0_linear(Structure):
    pass

struct_hipResourceDesc_0_linear._pack_ = 1 # source:False
struct_hipResourceDesc_0_linear._fields_ = [
    ('devPtr', ctypes.POINTER(None)),
    ('desc', struct_hipChannelFormatDesc),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('sizeInBytes', ctypes.c_uint64),
]

union_hipResourceDesc_res._pack_ = 1 # source:False
union_hipResourceDesc_res._fields_ = [
    ('array', struct_hipResourceDesc_0_array),
    ('mipmap', struct_hipResourceDesc_0_mipmap),
    ('linear', struct_hipResourceDesc_0_linear),
    ('pitch2D', struct_hipResourceDesc_0_pitch2D),
]

struct_hipResourceDesc._pack_ = 1 # source:False
struct_hipResourceDesc._fields_ = [
    ('resType', hipResourceType),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('res', union_hipResourceDesc_res),
]

hipResourceDesc = struct_hipResourceDesc
class struct_HIP_RESOURCE_DESC_st(Structure):
    pass

class union_HIP_RESOURCE_DESC_st_res(Union):
    pass

class struct_HIP_RESOURCE_DESC_st_0_mipmap(Structure):
    pass

struct_HIP_RESOURCE_DESC_st_0_mipmap._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_mipmap._fields_ = [
    ('hMipmappedArray', ctypes.POINTER(struct_hipMipmappedArray)),
]

class struct_HIP_RESOURCE_DESC_st_0_array(Structure):
    pass

struct_HIP_RESOURCE_DESC_st_0_array._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_array._fields_ = [
    ('hArray', ctypes.POINTER(struct_hipArray)),
]

class struct_HIP_RESOURCE_DESC_st_0_linear(Structure):
    pass

struct_HIP_RESOURCE_DESC_st_0_linear._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_linear._fields_ = [
    ('devPtr', ctypes.POINTER(None)),
    ('format', hipArray_Format),
    ('numChannels', ctypes.c_uint32),
    ('sizeInBytes', ctypes.c_uint64),
]

class struct_HIP_RESOURCE_DESC_st_0_pitch2D(Structure):
    pass

struct_HIP_RESOURCE_DESC_st_0_pitch2D._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_pitch2D._fields_ = [
    ('devPtr', ctypes.POINTER(None)),
    ('format', hipArray_Format),
    ('numChannels', ctypes.c_uint32),
    ('width', ctypes.c_uint64),
    ('height', ctypes.c_uint64),
    ('pitchInBytes', ctypes.c_uint64),
]

class struct_HIP_RESOURCE_DESC_st_0_reserved(Structure):
    pass

struct_HIP_RESOURCE_DESC_st_0_reserved._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_reserved._fields_ = [
    ('reserved', ctypes.c_int32 * 32),
]

union_HIP_RESOURCE_DESC_st_res._pack_ = 1 # source:False
union_HIP_RESOURCE_DESC_st_res._fields_ = [
    ('array', struct_HIP_RESOURCE_DESC_st_0_array),
    ('mipmap', struct_HIP_RESOURCE_DESC_st_0_mipmap),
    ('linear', struct_HIP_RESOURCE_DESC_st_0_linear),
    ('pitch2D', struct_HIP_RESOURCE_DESC_st_0_pitch2D),
    ('reserved', struct_HIP_RESOURCE_DESC_st_0_reserved),
]

struct_HIP_RESOURCE_DESC_st._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st._fields_ = [
    ('resType', HIPresourcetype),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('res', union_HIP_RESOURCE_DESC_st_res),
    ('flags', ctypes.c_uint32),
    ('PADDING_1', ctypes.c_ubyte * 4),
]

HIP_RESOURCE_DESC = struct_HIP_RESOURCE_DESC_st
class struct_hipResourceViewDesc(Structure):
    pass

struct_hipResourceViewDesc._pack_ = 1 # source:False
struct_hipResourceViewDesc._fields_ = [
    ('format', hipResourceViewFormat),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('width', ctypes.c_uint64),
    ('height', ctypes.c_uint64),
    ('depth', ctypes.c_uint64),
    ('firstMipmapLevel', ctypes.c_uint32),
    ('lastMipmapLevel', ctypes.c_uint32),
    ('firstLayer', ctypes.c_uint32),
    ('lastLayer', ctypes.c_uint32),
]

class struct_HIP_RESOURCE_VIEW_DESC_st(Structure):
    pass

struct_HIP_RESOURCE_VIEW_DESC_st._pack_ = 1 # source:False
struct_HIP_RESOURCE_VIEW_DESC_st._fields_ = [
    ('format', HIPresourceViewFormat),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('width', ctypes.c_uint64),
    ('height', ctypes.c_uint64),
    ('depth', ctypes.c_uint64),
    ('firstMipmapLevel', ctypes.c_uint32),
    ('lastMipmapLevel', ctypes.c_uint32),
    ('firstLayer', ctypes.c_uint32),
    ('lastLayer', ctypes.c_uint32),
    ('reserved', ctypes.c_uint32 * 16),
]

HIP_RESOURCE_VIEW_DESC = struct_HIP_RESOURCE_VIEW_DESC_st

# values for enumeration 'hipMemcpyKind'
hipMemcpyKind__enumvalues = {
    0: 'hipMemcpyHostToHost',
    1: 'hipMemcpyHostToDevice',
    2: 'hipMemcpyDeviceToHost',
    3: 'hipMemcpyDeviceToDevice',
    4: 'hipMemcpyDefault',
}
hipMemcpyHostToHost = 0
hipMemcpyHostToDevice = 1
hipMemcpyDeviceToHost = 2
hipMemcpyDeviceToDevice = 3
hipMemcpyDefault = 4
hipMemcpyKind = ctypes.c_uint32 # enum
class struct_hipPitchedPtr(Structure):
    pass

struct_hipPitchedPtr._pack_ = 1 # source:False
struct_hipPitchedPtr._fields_ = [
    ('ptr', ctypes.POINTER(None)),
    ('pitch', ctypes.c_uint64),
    ('xsize', ctypes.c_uint64),
    ('ysize', ctypes.c_uint64),
]

hipPitchedPtr = struct_hipPitchedPtr
class struct_hipExtent(Structure):
    pass

struct_hipExtent._pack_ = 1 # source:False
struct_hipExtent._fields_ = [
    ('width', ctypes.c_uint64),
    ('height', ctypes.c_uint64),
    ('depth', ctypes.c_uint64),
]

hipExtent = struct_hipExtent
class struct_hipPos(Structure):
    pass

struct_hipPos._pack_ = 1 # source:False
struct_hipPos._fields_ = [
    ('x', ctypes.c_uint64),
    ('y', ctypes.c_uint64),
    ('z', ctypes.c_uint64),
]

hipPos = struct_hipPos
class struct_hipMemcpy3DParms(Structure):
    pass

struct_hipMemcpy3DParms._pack_ = 1 # source:False
struct_hipMemcpy3DParms._fields_ = [
    ('srcArray', ctypes.POINTER(struct_hipArray)),
    ('srcPos', struct_hipPos),
    ('srcPtr', struct_hipPitchedPtr),
    ('dstArray', ctypes.POINTER(struct_hipArray)),
    ('dstPos', struct_hipPos),
    ('dstPtr', struct_hipPitchedPtr),
    ('extent', struct_hipExtent),
    ('kind', hipMemcpyKind),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

hipMemcpy3DParms = struct_hipMemcpy3DParms
class struct_HIP_MEMCPY3D(Structure):
    pass

struct_HIP_MEMCPY3D._pack_ = 1 # source:False
struct_HIP_MEMCPY3D._fields_ = [
    ('srcXInBytes', ctypes.c_uint32),
    ('srcY', ctypes.c_uint32),
    ('srcZ', ctypes.c_uint32),
    ('srcLOD', ctypes.c_uint32),
    ('srcMemoryType', hipMemoryType),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('srcHost', ctypes.POINTER(None)),
    ('srcDevice', ctypes.POINTER(None)),
    ('srcArray', ctypes.POINTER(struct_hipArray)),
    ('srcPitch', ctypes.c_uint32),
    ('srcHeight', ctypes.c_uint32),
    ('dstXInBytes', ctypes.c_uint32),
    ('dstY', ctypes.c_uint32),
    ('dstZ', ctypes.c_uint32),
    ('dstLOD', ctypes.c_uint32),
    ('dstMemoryType', hipMemoryType),
    ('PADDING_1', ctypes.c_ubyte * 4),
    ('dstHost', ctypes.POINTER(None)),
    ('dstDevice', ctypes.POINTER(None)),
    ('dstArray', ctypes.POINTER(struct_hipArray)),
    ('dstPitch', ctypes.c_uint32),
    ('dstHeight', ctypes.c_uint32),
    ('WidthInBytes', ctypes.c_uint32),
    ('Height', ctypes.c_uint32),
    ('Depth', ctypes.c_uint32),
    ('PADDING_2', ctypes.c_ubyte * 4),
]

HIP_MEMCPY3D = struct_HIP_MEMCPY3D
make_hipPitchedPtr = _libraries['FIXME_STUB'].make_hipPitchedPtr
make_hipPitchedPtr.restype = struct_hipPitchedPtr
make_hipPitchedPtr.argtypes = [ctypes.POINTER(None), size_t, size_t, size_t]
make_hipPos = _libraries['FIXME_STUB'].make_hipPos
make_hipPos.restype = struct_hipPos
make_hipPos.argtypes = [size_t, size_t, size_t]
make_hipExtent = _libraries['FIXME_STUB'].make_hipExtent
make_hipExtent.restype = struct_hipExtent
make_hipExtent.argtypes = [size_t, size_t, size_t]

# values for enumeration 'hipFunction_attribute'
hipFunction_attribute__enumvalues = {
    0: 'HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK',
    1: 'HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES',
    2: 'HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES',
    3: 'HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES',
    4: 'HIP_FUNC_ATTRIBUTE_NUM_REGS',
    5: 'HIP_FUNC_ATTRIBUTE_PTX_VERSION',
    6: 'HIP_FUNC_ATTRIBUTE_BINARY_VERSION',
    7: 'HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA',
    8: 'HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES',
    9: 'HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT',
    10: 'HIP_FUNC_ATTRIBUTE_MAX',
}
HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0
HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1
HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2
HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3
HIP_FUNC_ATTRIBUTE_NUM_REGS = 4
HIP_FUNC_ATTRIBUTE_PTX_VERSION = 5
HIP_FUNC_ATTRIBUTE_BINARY_VERSION = 6
HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7
HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8
HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9
HIP_FUNC_ATTRIBUTE_MAX = 10
hipFunction_attribute = ctypes.c_uint32 # enum

# values for enumeration 'hipPointer_attribute'
hipPointer_attribute__enumvalues = {
    1: 'HIP_POINTER_ATTRIBUTE_CONTEXT',
    2: 'HIP_POINTER_ATTRIBUTE_MEMORY_TYPE',
    3: 'HIP_POINTER_ATTRIBUTE_DEVICE_POINTER',
    4: 'HIP_POINTER_ATTRIBUTE_HOST_POINTER',
    5: 'HIP_POINTER_ATTRIBUTE_P2P_TOKENS',
    6: 'HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS',
    7: 'HIP_POINTER_ATTRIBUTE_BUFFER_ID',
    8: 'HIP_POINTER_ATTRIBUTE_IS_MANAGED',
    9: 'HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL',
    10: 'HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE',
    11: 'HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR',
    12: 'HIP_POINTER_ATTRIBUTE_RANGE_SIZE',
    13: 'HIP_POINTER_ATTRIBUTE_MAPPED',
    14: 'HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES',
    15: 'HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE',
    16: 'HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS',
    17: 'HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE',
}
HIP_POINTER_ATTRIBUTE_CONTEXT = 1
HIP_POINTER_ATTRIBUTE_MEMORY_TYPE = 2
HIP_POINTER_ATTRIBUTE_DEVICE_POINTER = 3
HIP_POINTER_ATTRIBUTE_HOST_POINTER = 4
HIP_POINTER_ATTRIBUTE_P2P_TOKENS = 5
HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6
HIP_POINTER_ATTRIBUTE_BUFFER_ID = 7
HIP_POINTER_ATTRIBUTE_IS_MANAGED = 8
HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL = 9
HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE = 10
HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR = 11
HIP_POINTER_ATTRIBUTE_RANGE_SIZE = 12
HIP_POINTER_ATTRIBUTE_MAPPED = 13
HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = 14
HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = 15
HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS = 16
HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = 17
hipPointer_attribute = ctypes.c_uint32 # enum
class struct_ihipCtx_t(Structure):
    pass

hipCtx_t = ctypes.POINTER(struct_ihipCtx_t)
hipDevice_t = ctypes.c_int32

# values for enumeration 'hipDeviceP2PAttr'
hipDeviceP2PAttr__enumvalues = {
    0: 'hipDevP2PAttrPerformanceRank',
    1: 'hipDevP2PAttrAccessSupported',
    2: 'hipDevP2PAttrNativeAtomicSupported',
    3: 'hipDevP2PAttrHipArrayAccessSupported',
}
hipDevP2PAttrPerformanceRank = 0
hipDevP2PAttrAccessSupported = 1
hipDevP2PAttrNativeAtomicSupported = 2
hipDevP2PAttrHipArrayAccessSupported = 3
hipDeviceP2PAttr = ctypes.c_uint32 # enum
class struct_ihipStream_t(Structure):
    pass

hipStream_t = ctypes.POINTER(struct_ihipStream_t)
class struct_hipIpcMemHandle_st(Structure):
    pass

struct_hipIpcMemHandle_st._pack_ = 1 # source:False
struct_hipIpcMemHandle_st._fields_ = [
    ('reserved', ctypes.c_char * 64),
]

hipIpcMemHandle_t = struct_hipIpcMemHandle_st
class struct_hipIpcEventHandle_st(Structure):
    pass

struct_hipIpcEventHandle_st._pack_ = 1 # source:False
struct_hipIpcEventHandle_st._fields_ = [
    ('reserved', ctypes.c_char * 64),
]

hipIpcEventHandle_t = struct_hipIpcEventHandle_st
class struct_ihipModule_t(Structure):
    pass

hipModule_t = ctypes.POINTER(struct_ihipModule_t)
class struct_ihipModuleSymbol_t(Structure):
    pass

hipFunction_t = ctypes.POINTER(struct_ihipModuleSymbol_t)
class struct_ihipMemPoolHandle_t(Structure):
    pass

hipMemPool_t = ctypes.POINTER(struct_ihipMemPoolHandle_t)
class struct_hipFuncAttributes(Structure):
    pass

struct_hipFuncAttributes._pack_ = 1 # source:False
struct_hipFuncAttributes._fields_ = [
    ('binaryVersion', ctypes.c_int32),
    ('cacheModeCA', ctypes.c_int32),
    ('constSizeBytes', ctypes.c_uint64),
    ('localSizeBytes', ctypes.c_uint64),
    ('maxDynamicSharedSizeBytes', ctypes.c_int32),
    ('maxThreadsPerBlock', ctypes.c_int32),
    ('numRegs', ctypes.c_int32),
    ('preferredShmemCarveout', ctypes.c_int32),
    ('ptxVersion', ctypes.c_int32),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('sharedSizeBytes', ctypes.c_uint64),
]

hipFuncAttributes = struct_hipFuncAttributes
class struct_ihipEvent_t(Structure):
    pass

hipEvent_t = ctypes.POINTER(struct_ihipEvent_t)

# values for enumeration 'hipLimit_t'
hipLimit_t__enumvalues = {
    0: 'hipLimitStackSize',
    1: 'hipLimitPrintfFifoSize',
    2: 'hipLimitMallocHeapSize',
    3: 'hipLimitRange',
}
hipLimitStackSize = 0
hipLimitPrintfFifoSize = 1
hipLimitMallocHeapSize = 2
hipLimitRange = 3
hipLimit_t = ctypes.c_uint32 # enum

# values for enumeration 'hipMemoryAdvise'
hipMemoryAdvise__enumvalues = {
    1: 'hipMemAdviseSetReadMostly',
    2: 'hipMemAdviseUnsetReadMostly',
    3: 'hipMemAdviseSetPreferredLocation',
    4: 'hipMemAdviseUnsetPreferredLocation',
    5: 'hipMemAdviseSetAccessedBy',
    6: 'hipMemAdviseUnsetAccessedBy',
    100: 'hipMemAdviseSetCoarseGrain',
    101: 'hipMemAdviseUnsetCoarseGrain',
}
hipMemAdviseSetReadMostly = 1
hipMemAdviseUnsetReadMostly = 2
hipMemAdviseSetPreferredLocation = 3
hipMemAdviseUnsetPreferredLocation = 4
hipMemAdviseSetAccessedBy = 5
hipMemAdviseUnsetAccessedBy = 6
hipMemAdviseSetCoarseGrain = 100
hipMemAdviseUnsetCoarseGrain = 101
hipMemoryAdvise = ctypes.c_uint32 # enum

# values for enumeration 'hipMemRangeCoherencyMode'
hipMemRangeCoherencyMode__enumvalues = {
    0: 'hipMemRangeCoherencyModeFineGrain',
    1: 'hipMemRangeCoherencyModeCoarseGrain',
    2: 'hipMemRangeCoherencyModeIndeterminate',
}
hipMemRangeCoherencyModeFineGrain = 0
hipMemRangeCoherencyModeCoarseGrain = 1
hipMemRangeCoherencyModeIndeterminate = 2
hipMemRangeCoherencyMode = ctypes.c_uint32 # enum

# values for enumeration 'hipMemRangeAttribute'
hipMemRangeAttribute__enumvalues = {
    1: 'hipMemRangeAttributeReadMostly',
    2: 'hipMemRangeAttributePreferredLocation',
    3: 'hipMemRangeAttributeAccessedBy',
    4: 'hipMemRangeAttributeLastPrefetchLocation',
    100: 'hipMemRangeAttributeCoherencyMode',
}
hipMemRangeAttributeReadMostly = 1
hipMemRangeAttributePreferredLocation = 2
hipMemRangeAttributeAccessedBy = 3
hipMemRangeAttributeLastPrefetchLocation = 4
hipMemRangeAttributeCoherencyMode = 100
hipMemRangeAttribute = ctypes.c_uint32 # enum

# values for enumeration 'hipMemPoolAttr'
hipMemPoolAttr__enumvalues = {
    1: 'hipMemPoolReuseFollowEventDependencies',
    2: 'hipMemPoolReuseAllowOpportunistic',
    3: 'hipMemPoolReuseAllowInternalDependencies',
    4: 'hipMemPoolAttrReleaseThreshold',
    5: 'hipMemPoolAttrReservedMemCurrent',
    6: 'hipMemPoolAttrReservedMemHigh',
    7: 'hipMemPoolAttrUsedMemCurrent',
    8: 'hipMemPoolAttrUsedMemHigh',
}
hipMemPoolReuseFollowEventDependencies = 1
hipMemPoolReuseAllowOpportunistic = 2
hipMemPoolReuseAllowInternalDependencies = 3
hipMemPoolAttrReleaseThreshold = 4
hipMemPoolAttrReservedMemCurrent = 5
hipMemPoolAttrReservedMemHigh = 6
hipMemPoolAttrUsedMemCurrent = 7
hipMemPoolAttrUsedMemHigh = 8
hipMemPoolAttr = ctypes.c_uint32 # enum

# values for enumeration 'hipMemLocationType'
hipMemLocationType__enumvalues = {
    0: 'hipMemLocationTypeInvalid',
    1: 'hipMemLocationTypeDevice',
}
hipMemLocationTypeInvalid = 0
hipMemLocationTypeDevice = 1
hipMemLocationType = ctypes.c_uint32 # enum
class struct_hipMemLocation(Structure):
    pass

struct_hipMemLocation._pack_ = 1 # source:False
struct_hipMemLocation._fields_ = [
    ('type', hipMemLocationType),
    ('id', ctypes.c_int32),
]

hipMemLocation = struct_hipMemLocation

# values for enumeration 'hipMemAccessFlags'
hipMemAccessFlags__enumvalues = {
    0: 'hipMemAccessFlagsProtNone',
    1: 'hipMemAccessFlagsProtRead',
    3: 'hipMemAccessFlagsProtReadWrite',
}
hipMemAccessFlagsProtNone = 0
hipMemAccessFlagsProtRead = 1
hipMemAccessFlagsProtReadWrite = 3
hipMemAccessFlags = ctypes.c_uint32 # enum
class struct_hipMemAccessDesc(Structure):
    _pack_ = 1 # source:False
    _fields_ = [
    ('location', hipMemLocation),
    ('flags', hipMemAccessFlags),
     ]

hipMemAccessDesc = struct_hipMemAccessDesc

# values for enumeration 'hipMemAllocationType'
hipMemAllocationType__enumvalues = {
    0: 'hipMemAllocationTypeInvalid',
    1: 'hipMemAllocationTypePinned',
    2147483647: 'hipMemAllocationTypeMax',
}
hipMemAllocationTypeInvalid = 0
hipMemAllocationTypePinned = 1
hipMemAllocationTypeMax = 2147483647
hipMemAllocationType = ctypes.c_uint32 # enum

# values for enumeration 'hipMemAllocationHandleType'
hipMemAllocationHandleType__enumvalues = {
    0: 'hipMemHandleTypeNone',
    1: 'hipMemHandleTypePosixFileDescriptor',
    2: 'hipMemHandleTypeWin32',
    4: 'hipMemHandleTypeWin32Kmt',
}
hipMemHandleTypeNone = 0
hipMemHandleTypePosixFileDescriptor = 1
hipMemHandleTypeWin32 = 2
hipMemHandleTypeWin32Kmt = 4
hipMemAllocationHandleType = ctypes.c_uint32 # enum
class struct_hipMemPoolProps(Structure):
    pass

struct_hipMemPoolProps._pack_ = 1 # source:False
struct_hipMemPoolProps._fields_ = [
    ('allocType', hipMemAllocationType),
    ('handleTypes', hipMemAllocationHandleType),
    ('location', hipMemLocation),
    ('win32SecurityAttributes', ctypes.POINTER(None)),
    ('reserved', ctypes.c_ubyte * 64),
]

hipMemPoolProps = struct_hipMemPoolProps
class struct_hipMemPoolPtrExportData(Structure):
    pass

struct_hipMemPoolPtrExportData._pack_ = 1 # source:False
struct_hipMemPoolPtrExportData._fields_ = [
    ('reserved', ctypes.c_ubyte * 64),
]

hipMemPoolPtrExportData = struct_hipMemPoolPtrExportData

# values for enumeration 'hipJitOption'
hipJitOption__enumvalues = {
    0: 'hipJitOptionMaxRegisters',
    1: 'hipJitOptionThreadsPerBlock',
    2: 'hipJitOptionWallTime',
    3: 'hipJitOptionInfoLogBuffer',
    4: 'hipJitOptionInfoLogBufferSizeBytes',
    5: 'hipJitOptionErrorLogBuffer',
    6: 'hipJitOptionErrorLogBufferSizeBytes',
    7: 'hipJitOptionOptimizationLevel',
    8: 'hipJitOptionTargetFromContext',
    9: 'hipJitOptionTarget',
    10: 'hipJitOptionFallbackStrategy',
    11: 'hipJitOptionGenerateDebugInfo',
    12: 'hipJitOptionLogVerbose',
    13: 'hipJitOptionGenerateLineInfo',
    14: 'hipJitOptionCacheMode',
    15: 'hipJitOptionSm3xOpt',
    16: 'hipJitOptionFastCompile',
    17: 'hipJitOptionNumOptions',
}
hipJitOptionMaxRegisters = 0
hipJitOptionThreadsPerBlock = 1
hipJitOptionWallTime = 2
hipJitOptionInfoLogBuffer = 3
hipJitOptionInfoLogBufferSizeBytes = 4
hipJitOptionErrorLogBuffer = 5
hipJitOptionErrorLogBufferSizeBytes = 6
hipJitOptionOptimizationLevel = 7
hipJitOptionTargetFromContext = 8
hipJitOptionTarget = 9
hipJitOptionFallbackStrategy = 10
hipJitOptionGenerateDebugInfo = 11
hipJitOptionLogVerbose = 12
hipJitOptionGenerateLineInfo = 13
hipJitOptionCacheMode = 14
hipJitOptionSm3xOpt = 15
hipJitOptionFastCompile = 16
hipJitOptionNumOptions = 17
hipJitOption = ctypes.c_uint32 # enum

# values for enumeration 'hipFuncAttribute'
hipFuncAttribute__enumvalues = {
    8: 'hipFuncAttributeMaxDynamicSharedMemorySize',
    9: 'hipFuncAttributePreferredSharedMemoryCarveout',
    10: 'hipFuncAttributeMax',
}
hipFuncAttributeMaxDynamicSharedMemorySize = 8
hipFuncAttributePreferredSharedMemoryCarveout = 9
hipFuncAttributeMax = 10
hipFuncAttribute = ctypes.c_uint32 # enum

# values for enumeration 'hipFuncCache_t'
hipFuncCache_t__enumvalues = {
    0: 'hipFuncCachePreferNone',
    1: 'hipFuncCachePreferShared',
    2: 'hipFuncCachePreferL1',
    3: 'hipFuncCachePreferEqual',
}
hipFuncCachePreferNone = 0
hipFuncCachePreferShared = 1
hipFuncCachePreferL1 = 2
hipFuncCachePreferEqual = 3
hipFuncCache_t = ctypes.c_uint32 # enum

# values for enumeration 'hipSharedMemConfig'
hipSharedMemConfig__enumvalues = {
    0: 'hipSharedMemBankSizeDefault',
    1: 'hipSharedMemBankSizeFourByte',
    2: 'hipSharedMemBankSizeEightByte',
}
hipSharedMemBankSizeDefault = 0
hipSharedMemBankSizeFourByte = 1
hipSharedMemBankSizeEightByte = 2
hipSharedMemConfig = ctypes.c_uint32 # enum
class struct_dim3(Structure):
    pass

struct_dim3._pack_ = 1 # source:False
struct_dim3._fields_ = [
    ('x', ctypes.c_uint32),
    ('y', ctypes.c_uint32),
    ('z', ctypes.c_uint32),
]

dim3 = struct_dim3
class struct_hipLaunchParams_t(Structure):
    pass

struct_hipLaunchParams_t._pack_ = 1 # source:False
struct_hipLaunchParams_t._fields_ = [
    ('func', ctypes.POINTER(None)),
    ('gridDim', dim3),
    ('blockDim', dim3),
    ('args', ctypes.POINTER(ctypes.POINTER(None))),
    ('sharedMem', ctypes.c_uint64),
    ('stream', ctypes.POINTER(struct_ihipStream_t)),
]

hipLaunchParams = struct_hipLaunchParams_t
class struct_hipFunctionLaunchParams_t(Structure):
    pass

struct_hipFunctionLaunchParams_t._pack_ = 1 # source:False
struct_hipFunctionLaunchParams_t._fields_ = [
    ('function', ctypes.POINTER(struct_ihipModuleSymbol_t)),
    ('gridDimX', ctypes.c_uint32),
    ('gridDimY', ctypes.c_uint32),
    ('gridDimZ', ctypes.c_uint32),
    ('blockDimX', ctypes.c_uint32),
    ('blockDimY', ctypes.c_uint32),
    ('blockDimZ', ctypes.c_uint32),
    ('sharedMemBytes', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('hStream', ctypes.POINTER(struct_ihipStream_t)),
    ('kernelParams', ctypes.POINTER(ctypes.POINTER(None))),
]

hipFunctionLaunchParams = struct_hipFunctionLaunchParams_t

# values for enumeration 'hipExternalMemoryHandleType_enum'
hipExternalMemoryHandleType_enum__enumvalues = {
    1: 'hipExternalMemoryHandleTypeOpaqueFd',
    2: 'hipExternalMemoryHandleTypeOpaqueWin32',
    3: 'hipExternalMemoryHandleTypeOpaqueWin32Kmt',
    4: 'hipExternalMemoryHandleTypeD3D12Heap',
    5: 'hipExternalMemoryHandleTypeD3D12Resource',
    6: 'hipExternalMemoryHandleTypeD3D11Resource',
    7: 'hipExternalMemoryHandleTypeD3D11ResourceKmt',
}
hipExternalMemoryHandleTypeOpaqueFd = 1
hipExternalMemoryHandleTypeOpaqueWin32 = 2
hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3
hipExternalMemoryHandleTypeD3D12Heap = 4
hipExternalMemoryHandleTypeD3D12Resource = 5
hipExternalMemoryHandleTypeD3D11Resource = 6
hipExternalMemoryHandleTypeD3D11ResourceKmt = 7
hipExternalMemoryHandleType_enum = ctypes.c_uint32 # enum
hipExternalMemoryHandleType = hipExternalMemoryHandleType_enum
hipExternalMemoryHandleType__enumvalues = hipExternalMemoryHandleType_enum__enumvalues
class struct_hipExternalMemoryHandleDesc_st(Structure):
    pass

class union_hipExternalMemoryHandleDesc_st_handle(Union):
    pass

class struct_hipExternalMemoryHandleDesc_st_0_win32(Structure):
    pass

struct_hipExternalMemoryHandleDesc_st_0_win32._pack_ = 1 # source:False
struct_hipExternalMemoryHandleDesc_st_0_win32._fields_ = [
    ('handle', ctypes.POINTER(None)),
    ('name', ctypes.POINTER(None)),
]

union_hipExternalMemoryHandleDesc_st_handle._pack_ = 1 # source:False
union_hipExternalMemoryHandleDesc_st_handle._fields_ = [
    ('fd', ctypes.c_int32),
    ('win32', struct_hipExternalMemoryHandleDesc_st_0_win32),
]

struct_hipExternalMemoryHandleDesc_st._pack_ = 1 # source:False
struct_hipExternalMemoryHandleDesc_st._fields_ = [
    ('type', hipExternalMemoryHandleType),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('handle', union_hipExternalMemoryHandleDesc_st_handle),
    ('size', ctypes.c_uint64),
    ('flags', ctypes.c_uint32),
    ('PADDING_1', ctypes.c_ubyte * 4),
]

hipExternalMemoryHandleDesc = struct_hipExternalMemoryHandleDesc_st
class struct_hipExternalMemoryBufferDesc_st(Structure):
    pass

struct_hipExternalMemoryBufferDesc_st._pack_ = 1 # source:False
struct_hipExternalMemoryBufferDesc_st._fields_ = [
    ('offset', ctypes.c_uint64),
    ('size', ctypes.c_uint64),
    ('flags', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

hipExternalMemoryBufferDesc = struct_hipExternalMemoryBufferDesc_st
hipExternalMemory_t = ctypes.POINTER(None)

# values for enumeration 'hipExternalSemaphoreHandleType_enum'
hipExternalSemaphoreHandleType_enum__enumvalues = {
    1: 'hipExternalSemaphoreHandleTypeOpaqueFd',
    2: 'hipExternalSemaphoreHandleTypeOpaqueWin32',
    3: 'hipExternalSemaphoreHandleTypeOpaqueWin32Kmt',
    4: 'hipExternalSemaphoreHandleTypeD3D12Fence',
}
hipExternalSemaphoreHandleTypeOpaqueFd = 1
hipExternalSemaphoreHandleTypeOpaqueWin32 = 2
hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3
hipExternalSemaphoreHandleTypeD3D12Fence = 4
hipExternalSemaphoreHandleType_enum = ctypes.c_uint32 # enum
hipExternalSemaphoreHandleType = hipExternalSemaphoreHandleType_enum
hipExternalSemaphoreHandleType__enumvalues = hipExternalSemaphoreHandleType_enum__enumvalues
class struct_hipExternalSemaphoreHandleDesc_st(Structure):
    pass

class union_hipExternalSemaphoreHandleDesc_st_handle(Union):
    pass

class struct_hipExternalSemaphoreHandleDesc_st_0_win32(Structure):
    pass

struct_hipExternalSemaphoreHandleDesc_st_0_win32._pack_ = 1 # source:False
struct_hipExternalSemaphoreHandleDesc_st_0_win32._fields_ = [
    ('handle', ctypes.POINTER(None)),
    ('name', ctypes.POINTER(None)),
]

union_hipExternalSemaphoreHandleDesc_st_handle._pack_ = 1 # source:False
union_hipExternalSemaphoreHandleDesc_st_handle._fields_ = [
    ('fd', ctypes.c_int32),
    ('win32', struct_hipExternalSemaphoreHandleDesc_st_0_win32),
]

struct_hipExternalSemaphoreHandleDesc_st._pack_ = 1 # source:False
struct_hipExternalSemaphoreHandleDesc_st._fields_ = [
    ('type', hipExternalSemaphoreHandleType),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('handle', union_hipExternalSemaphoreHandleDesc_st_handle),
    ('flags', ctypes.c_uint32),
    ('PADDING_1', ctypes.c_ubyte * 4),
]

hipExternalSemaphoreHandleDesc = struct_hipExternalSemaphoreHandleDesc_st
hipExternalSemaphore_t = ctypes.POINTER(None)
class struct_hipExternalSemaphoreSignalParams_st(Structure):
    pass

class struct_hipExternalSemaphoreSignalParams_st_params(Structure):
    pass

class struct_hipExternalSemaphoreSignalParams_st_0_fence(Structure):
    pass

struct_hipExternalSemaphoreSignalParams_st_0_fence._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st_0_fence._fields_ = [
    ('value', ctypes.c_uint64),
]

class struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex(Structure):
    pass

struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex._fields_ = [
    ('key', ctypes.c_uint64),
]

struct_hipExternalSemaphoreSignalParams_st_params._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st_params._fields_ = [
    ('fence', struct_hipExternalSemaphoreSignalParams_st_0_fence),
    ('keyedMutex', struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex),
    ('reserved', ctypes.c_uint32 * 12),
]

struct_hipExternalSemaphoreSignalParams_st._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st._fields_ = [
    ('params', struct_hipExternalSemaphoreSignalParams_st_params),
    ('flags', ctypes.c_uint32),
    ('reserved', ctypes.c_uint32 * 16),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

hipExternalSemaphoreSignalParams = struct_hipExternalSemaphoreSignalParams_st
class struct_hipExternalSemaphoreWaitParams_st(Structure):
    pass

class struct_hipExternalSemaphoreWaitParams_st_params(Structure):
    pass

class struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex(Structure):
    pass

struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex._fields_ = [
    ('key', ctypes.c_uint64),
    ('timeoutMs', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

class struct_hipExternalSemaphoreWaitParams_st_0_fence(Structure):
    pass

struct_hipExternalSemaphoreWaitParams_st_0_fence._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st_0_fence._fields_ = [
    ('value', ctypes.c_uint64),
]

struct_hipExternalSemaphoreWaitParams_st_params._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st_params._fields_ = [
    ('fence', struct_hipExternalSemaphoreWaitParams_st_0_fence),
    ('keyedMutex', struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex),
    ('reserved', ctypes.c_uint32 * 10),
]

struct_hipExternalSemaphoreWaitParams_st._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st._fields_ = [
    ('params', struct_hipExternalSemaphoreWaitParams_st_params),
    ('flags', ctypes.c_uint32),
    ('reserved', ctypes.c_uint32 * 16),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

hipExternalSemaphoreWaitParams = struct_hipExternalSemaphoreWaitParams_st
__hipGetPCH = _libraries['libamdhip64.so'].__hipGetPCH
__hipGetPCH.restype = None
__hipGetPCH.argtypes = [ctypes.POINTER(ctypes.POINTER(ctypes.c_char)), ctypes.POINTER(ctypes.c_uint32)]

# values for enumeration 'hipGLDeviceList'
hipGLDeviceList__enumvalues = {
    1: 'hipGLDeviceListAll',
    2: 'hipGLDeviceListCurrentFrame',
    3: 'hipGLDeviceListNextFrame',
}
hipGLDeviceListAll = 1
hipGLDeviceListCurrentFrame = 2
hipGLDeviceListNextFrame = 3
hipGLDeviceList = ctypes.c_uint32 # enum

# values for enumeration 'hipGraphicsRegisterFlags'
hipGraphicsRegisterFlags__enumvalues = {
    0: 'hipGraphicsRegisterFlagsNone',
    1: 'hipGraphicsRegisterFlagsReadOnly',
    2: 'hipGraphicsRegisterFlagsWriteDiscard',
    4: 'hipGraphicsRegisterFlagsSurfaceLoadStore',
    8: 'hipGraphicsRegisterFlagsTextureGather',
}
hipGraphicsRegisterFlagsNone = 0
hipGraphicsRegisterFlagsReadOnly = 1
hipGraphicsRegisterFlagsWriteDiscard = 2
hipGraphicsRegisterFlagsSurfaceLoadStore = 4
hipGraphicsRegisterFlagsTextureGather = 8
hipGraphicsRegisterFlags = ctypes.c_uint32 # enum
class struct__hipGraphicsResource(Structure):
    pass

hipGraphicsResource = struct__hipGraphicsResource
hipGraphicsResource_t = ctypes.POINTER(struct__hipGraphicsResource)
class struct_ihipGraph(Structure):
    pass

hipGraph_t = ctypes.POINTER(struct_ihipGraph)
class struct_hipGraphNode(Structure):
    pass

hipGraphNode_t = ctypes.POINTER(struct_hipGraphNode)
class struct_hipGraphExec(Structure):
    pass

hipGraphExec_t = ctypes.POINTER(struct_hipGraphExec)
class struct_hipUserObject(Structure):
    pass

hipUserObject_t = ctypes.POINTER(struct_hipUserObject)

# values for enumeration 'hipGraphNodeType'
hipGraphNodeType__enumvalues = {
    0: 'hipGraphNodeTypeKernel',
    1: 'hipGraphNodeTypeMemcpy',
    2: 'hipGraphNodeTypeMemset',
    3: 'hipGraphNodeTypeHost',
    4: 'hipGraphNodeTypeGraph',
    5: 'hipGraphNodeTypeEmpty',
    6: 'hipGraphNodeTypeWaitEvent',
    7: 'hipGraphNodeTypeEventRecord',
    8: 'hipGraphNodeTypeExtSemaphoreSignal',
    9: 'hipGraphNodeTypeExtSemaphoreWait',
    10: 'hipGraphNodeTypeMemAlloc',
    11: 'hipGraphNodeTypeMemFree',
    12: 'hipGraphNodeTypeMemcpyFromSymbol',
    13: 'hipGraphNodeTypeMemcpyToSymbol',
    14: 'hipGraphNodeTypeCount',
}
hipGraphNodeTypeKernel = 0
hipGraphNodeTypeMemcpy = 1
hipGraphNodeTypeMemset = 2
hipGraphNodeTypeHost = 3
hipGraphNodeTypeGraph = 4
hipGraphNodeTypeEmpty = 5
hipGraphNodeTypeWaitEvent = 6
hipGraphNodeTypeEventRecord = 7
hipGraphNodeTypeExtSemaphoreSignal = 8
hipGraphNodeTypeExtSemaphoreWait = 9
hipGraphNodeTypeMemAlloc = 10
hipGraphNodeTypeMemFree = 11
hipGraphNodeTypeMemcpyFromSymbol = 12
hipGraphNodeTypeMemcpyToSymbol = 13
hipGraphNodeTypeCount = 14
hipGraphNodeType = ctypes.c_uint32 # enum
hipHostFn_t = ctypes.CFUNCTYPE(None, ctypes.POINTER(None))
class struct_hipHostNodeParams(Structure):
    pass

struct_hipHostNodeParams._pack_ = 1 # source:False
struct_hipHostNodeParams._fields_ = [
    ('fn', ctypes.CFUNCTYPE(None, ctypes.POINTER(None))),
    ('userData', ctypes.POINTER(None)),
]

hipHostNodeParams = struct_hipHostNodeParams
class struct_hipKernelNodeParams(Structure):
    pass

struct_hipKernelNodeParams._pack_ = 1 # source:False
struct_hipKernelNodeParams._fields_ = [
    ('blockDim', dim3),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('extra', ctypes.POINTER(ctypes.POINTER(None))),
    ('func', ctypes.POINTER(None)),
    ('gridDim', dim3),
    ('PADDING_1', ctypes.c_ubyte * 4),
    ('kernelParams', ctypes.POINTER(ctypes.POINTER(None))),
    ('sharedMemBytes', ctypes.c_uint32),
    ('PADDING_2', ctypes.c_ubyte * 4),
]

hipKernelNodeParams = struct_hipKernelNodeParams
class struct_hipMemsetParams(Structure):
    pass

struct_hipMemsetParams._pack_ = 1 # source:False
struct_hipMemsetParams._fields_ = [
    ('dst', ctypes.POINTER(None)),
    ('elementSize', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('height', ctypes.c_uint64),
    ('pitch', ctypes.c_uint64),
    ('value', ctypes.c_uint32),
    ('PADDING_1', ctypes.c_ubyte * 4),
    ('width', ctypes.c_uint64),
]

hipMemsetParams = struct_hipMemsetParams
class struct_hipMemAllocNodeParams(Structure):
    pass

struct_hipMemAllocNodeParams._pack_ = 1 # source:False
struct_hipMemAllocNodeParams._fields_ = [
    ('poolProps', hipMemPoolProps),
    ('accessDescs', ctypes.POINTER(struct_hipMemAccessDesc)),
    ('accessDescCount', ctypes.c_uint64),
    ('bytesize', ctypes.c_uint64),
    ('dptr', ctypes.POINTER(None)),
]

hipMemAllocNodeParams = struct_hipMemAllocNodeParams

# values for enumeration 'hipKernelNodeAttrID'
hipKernelNodeAttrID__enumvalues = {
    1: 'hipKernelNodeAttributeAccessPolicyWindow',
    2: 'hipKernelNodeAttributeCooperative',
}
hipKernelNodeAttributeAccessPolicyWindow = 1
hipKernelNodeAttributeCooperative = 2
hipKernelNodeAttrID = ctypes.c_uint32 # enum

# values for enumeration 'hipAccessProperty'
hipAccessProperty__enumvalues = {
    0: 'hipAccessPropertyNormal',
    1: 'hipAccessPropertyStreaming',
    2: 'hipAccessPropertyPersisting',
}
hipAccessPropertyNormal = 0
hipAccessPropertyStreaming = 1
hipAccessPropertyPersisting = 2
hipAccessProperty = ctypes.c_uint32 # enum
class struct_hipAccessPolicyWindow(Structure):
    pass

struct_hipAccessPolicyWindow._pack_ = 1 # source:False
struct_hipAccessPolicyWindow._fields_ = [
    ('base_ptr', ctypes.POINTER(None)),
    ('hitProp', hipAccessProperty),
    ('hitRatio', ctypes.c_float),
    ('missProp', hipAccessProperty),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('num_bytes', ctypes.c_uint64),
]

hipAccessPolicyWindow = struct_hipAccessPolicyWindow
class union_hipKernelNodeAttrValue(Union):
    pass

union_hipKernelNodeAttrValue._pack_ = 1 # source:False
union_hipKernelNodeAttrValue._fields_ = [
    ('accessPolicyWindow', hipAccessPolicyWindow),
    ('cooperative', ctypes.c_int32),
    ('PADDING_0', ctypes.c_ubyte * 28),
]

hipKernelNodeAttrValue = union_hipKernelNodeAttrValue

# values for enumeration 'hipGraphExecUpdateResult'
hipGraphExecUpdateResult__enumvalues = {
    0: 'hipGraphExecUpdateSuccess',
    1: 'hipGraphExecUpdateError',
    2: 'hipGraphExecUpdateErrorTopologyChanged',
    3: 'hipGraphExecUpdateErrorNodeTypeChanged',
    4: 'hipGraphExecUpdateErrorFunctionChanged',
    5: 'hipGraphExecUpdateErrorParametersChanged',
    6: 'hipGraphExecUpdateErrorNotSupported',
    7: 'hipGraphExecUpdateErrorUnsupportedFunctionChange',
}
hipGraphExecUpdateSuccess = 0
hipGraphExecUpdateError = 1
hipGraphExecUpdateErrorTopologyChanged = 2
hipGraphExecUpdateErrorNodeTypeChanged = 3
hipGraphExecUpdateErrorFunctionChanged = 4
hipGraphExecUpdateErrorParametersChanged = 5
hipGraphExecUpdateErrorNotSupported = 6
hipGraphExecUpdateErrorUnsupportedFunctionChange = 7
hipGraphExecUpdateResult = ctypes.c_uint32 # enum

# values for enumeration 'hipStreamCaptureMode'
hipStreamCaptureMode__enumvalues = {
    0: 'hipStreamCaptureModeGlobal',
    1: 'hipStreamCaptureModeThreadLocal',
    2: 'hipStreamCaptureModeRelaxed',
}
hipStreamCaptureModeGlobal = 0
hipStreamCaptureModeThreadLocal = 1
hipStreamCaptureModeRelaxed = 2
hipStreamCaptureMode = ctypes.c_uint32 # enum

# values for enumeration 'hipStreamCaptureStatus'
hipStreamCaptureStatus__enumvalues = {
    0: 'hipStreamCaptureStatusNone',
    1: 'hipStreamCaptureStatusActive',
    2: 'hipStreamCaptureStatusInvalidated',
}
hipStreamCaptureStatusNone = 0
hipStreamCaptureStatusActive = 1
hipStreamCaptureStatusInvalidated = 2
hipStreamCaptureStatus = ctypes.c_uint32 # enum

# values for enumeration 'hipStreamUpdateCaptureDependenciesFlags'
hipStreamUpdateCaptureDependenciesFlags__enumvalues = {
    0: 'hipStreamAddCaptureDependencies',
    1: 'hipStreamSetCaptureDependencies',
}
hipStreamAddCaptureDependencies = 0
hipStreamSetCaptureDependencies = 1
hipStreamUpdateCaptureDependenciesFlags = ctypes.c_uint32 # enum

# values for enumeration 'hipGraphMemAttributeType'
hipGraphMemAttributeType__enumvalues = {
    0: 'hipGraphMemAttrUsedMemCurrent',
    1: 'hipGraphMemAttrUsedMemHigh',
    2: 'hipGraphMemAttrReservedMemCurrent',
    3: 'hipGraphMemAttrReservedMemHigh',
}
hipGraphMemAttrUsedMemCurrent = 0
hipGraphMemAttrUsedMemHigh = 1
hipGraphMemAttrReservedMemCurrent = 2
hipGraphMemAttrReservedMemHigh = 3
hipGraphMemAttributeType = ctypes.c_uint32 # enum

# values for enumeration 'hipUserObjectFlags'
hipUserObjectFlags__enumvalues = {
    1: 'hipUserObjectNoDestructorSync',
}
hipUserObjectNoDestructorSync = 1
hipUserObjectFlags = ctypes.c_uint32 # enum

# values for enumeration 'hipUserObjectRetainFlags'
hipUserObjectRetainFlags__enumvalues = {
    1: 'hipGraphUserObjectMove',
}
hipGraphUserObjectMove = 1
hipUserObjectRetainFlags = ctypes.c_uint32 # enum

# values for enumeration 'hipGraphInstantiateFlags'
hipGraphInstantiateFlags__enumvalues = {
    1: 'hipGraphInstantiateFlagAutoFreeOnLaunch',
    2: 'hipGraphInstantiateFlagUpload',
    4: 'hipGraphInstantiateFlagDeviceLaunch',
    8: 'hipGraphInstantiateFlagUseNodePriority',
}
hipGraphInstantiateFlagAutoFreeOnLaunch = 1
hipGraphInstantiateFlagUpload = 2
hipGraphInstantiateFlagDeviceLaunch = 4
hipGraphInstantiateFlagUseNodePriority = 8
hipGraphInstantiateFlags = ctypes.c_uint32 # enum

# values for enumeration 'hipGraphDebugDotFlags'
hipGraphDebugDotFlags__enumvalues = {
    1: 'hipGraphDebugDotFlagsVerbose',
    4: 'hipGraphDebugDotFlagsKernelNodeParams',
    8: 'hipGraphDebugDotFlagsMemcpyNodeParams',
    16: 'hipGraphDebugDotFlagsMemsetNodeParams',
    32: 'hipGraphDebugDotFlagsHostNodeParams',
    64: 'hipGraphDebugDotFlagsEventNodeParams',
    128: 'hipGraphDebugDotFlagsExtSemasSignalNodeParams',
    256: 'hipGraphDebugDotFlagsExtSemasWaitNodeParams',
    512: 'hipGraphDebugDotFlagsKernelNodeAttributes',
    1024: 'hipGraphDebugDotFlagsHandles',
}
hipGraphDebugDotFlagsVerbose = 1
hipGraphDebugDotFlagsKernelNodeParams = 4
hipGraphDebugDotFlagsMemcpyNodeParams = 8
hipGraphDebugDotFlagsMemsetNodeParams = 16
hipGraphDebugDotFlagsHostNodeParams = 32
hipGraphDebugDotFlagsEventNodeParams = 64
hipGraphDebugDotFlagsExtSemasSignalNodeParams = 128
hipGraphDebugDotFlagsExtSemasWaitNodeParams = 256
hipGraphDebugDotFlagsKernelNodeAttributes = 512
hipGraphDebugDotFlagsHandles = 1024
hipGraphDebugDotFlags = ctypes.c_uint32 # enum
class struct_hipMemAllocationProp(Structure):
    pass

class struct_hipMemAllocationProp_allocFlags(Structure):
    pass

struct_hipMemAllocationProp_allocFlags._pack_ = 1 # source:False
struct_hipMemAllocationProp_allocFlags._fields_ = [
    ('compressionType', ctypes.c_ubyte),
    ('gpuDirectRDMACapable', ctypes.c_ubyte),
    ('usage', ctypes.c_uint16),
]

struct_hipMemAllocationProp._pack_ = 1 # source:False
struct_hipMemAllocationProp._fields_ = [
    ('type', hipMemAllocationType),
    ('requestedHandleType', hipMemAllocationHandleType),
    ('location', hipMemLocation),
    ('win32HandleMetaData', ctypes.POINTER(None)),
    ('allocFlags', struct_hipMemAllocationProp_allocFlags),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

hipMemAllocationProp = struct_hipMemAllocationProp
class struct_hipExternalSemaphoreSignalNodeParams(Structure):
    pass

struct_hipExternalSemaphoreSignalNodeParams._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalNodeParams._fields_ = [
    ('extSemArray', ctypes.POINTER(ctypes.POINTER(None))),
    ('paramsArray', ctypes.POINTER(struct_hipExternalSemaphoreSignalParams_st)),
    ('numExtSems', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

hipExternalSemaphoreSignalNodeParams = struct_hipExternalSemaphoreSignalNodeParams
class struct_hipExternalSemaphoreWaitNodeParams(Structure):
    pass

struct_hipExternalSemaphoreWaitNodeParams._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitNodeParams._fields_ = [
    ('extSemArray', ctypes.POINTER(ctypes.POINTER(None))),
    ('paramsArray', ctypes.POINTER(struct_hipExternalSemaphoreWaitParams_st)),
    ('numExtSems', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
]

hipExternalSemaphoreWaitNodeParams = struct_hipExternalSemaphoreWaitNodeParams
class struct_ihipMemGenericAllocationHandle(Structure):
    pass

hipMemGenericAllocationHandle_t = ctypes.POINTER(struct_ihipMemGenericAllocationHandle)

# values for enumeration 'hipMemAllocationGranularity_flags'
hipMemAllocationGranularity_flags__enumvalues = {
    0: 'hipMemAllocationGranularityMinimum',
    1: 'hipMemAllocationGranularityRecommended',
}
hipMemAllocationGranularityMinimum = 0
hipMemAllocationGranularityRecommended = 1
hipMemAllocationGranularity_flags = ctypes.c_uint32 # enum

# values for enumeration 'hipMemHandleType'
hipMemHandleType__enumvalues = {
    0: 'hipMemHandleTypeGeneric',
}
hipMemHandleTypeGeneric = 0
hipMemHandleType = ctypes.c_uint32 # enum

# values for enumeration 'hipMemOperationType'
hipMemOperationType__enumvalues = {
    1: 'hipMemOperationTypeMap',
    2: 'hipMemOperationTypeUnmap',
}
hipMemOperationTypeMap = 1
hipMemOperationTypeUnmap = 2
hipMemOperationType = ctypes.c_uint32 # enum

# values for enumeration 'hipArraySparseSubresourceType'
hipArraySparseSubresourceType__enumvalues = {
    0: 'hipArraySparseSubresourceTypeSparseLevel',
    1: 'hipArraySparseSubresourceTypeMiptail',
}
hipArraySparseSubresourceTypeSparseLevel = 0
hipArraySparseSubresourceTypeMiptail = 1
hipArraySparseSubresourceType = ctypes.c_uint32 # enum
class struct_hipArrayMapInfo(Structure):
    pass

class union_hipArrayMapInfo_resource(Union):
    pass

union_hipArrayMapInfo_resource._pack_ = 1 # source:False
union_hipArrayMapInfo_resource._fields_ = [
    ('mipmap', hipMipmappedArray),
    ('array', ctypes.POINTER(struct_hipArray)),
    ('PADDING_0', ctypes.c_ubyte * 56),
]

class union_hipArrayMapInfo_subresource(Union):
    pass

class struct_hipArrayMapInfo_1_sparseLevel(Structure):
    pass

struct_hipArrayMapInfo_1_sparseLevel._pack_ = 1 # source:False
struct_hipArrayMapInfo_1_sparseLevel._fields_ = [
    ('level', ctypes.c_uint32),
    ('layer', ctypes.c_uint32),
    ('offsetX', ctypes.c_uint32),
    ('offsetY', ctypes.c_uint32),
    ('offsetZ', ctypes.c_uint32),
    ('extentWidth', ctypes.c_uint32),
    ('extentHeight', ctypes.c_uint32),
    ('extentDepth', ctypes.c_uint32),
]

class struct_hipArrayMapInfo_1_miptail(Structure):
    pass

struct_hipArrayMapInfo_1_miptail._pack_ = 1 # source:False
struct_hipArrayMapInfo_1_miptail._fields_ = [
    ('layer', ctypes.c_uint32),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('offset', ctypes.c_uint64),
    ('size', ctypes.c_uint64),
]

union_hipArrayMapInfo_subresource._pack_ = 1 # source:False
union_hipArrayMapInfo_subresource._fields_ = [
    ('sparseLevel', struct_hipArrayMapInfo_1_sparseLevel),
    ('miptail', struct_hipArrayMapInfo_1_miptail),
    ('PADDING_0', ctypes.c_ubyte * 8),
]

class union_hipArrayMapInfo_memHandle(Union):
    pass

union_hipArrayMapInfo_memHandle._pack_ = 1 # source:False
union_hipArrayMapInfo_memHandle._fields_ = [
    ('memHandle', ctypes.POINTER(struct_ihipMemGenericAllocationHandle)),
]

struct_hipArrayMapInfo._pack_ = 1 # source:False
struct_hipArrayMapInfo._fields_ = [
    ('resourceType', hipResourceType),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('resource', union_hipArrayMapInfo_resource),
    ('subresourceType', hipArraySparseSubresourceType),
    ('PADDING_1', ctypes.c_ubyte * 4),
    ('subresource', union_hipArrayMapInfo_subresource),
    ('memOperationType', hipMemOperationType),
    ('memHandleType', hipMemHandleType),
    ('memHandle', union_hipArrayMapInfo_memHandle),
    ('offset', ctypes.c_uint64),
    ('deviceBitMask', ctypes.c_uint32),
    ('flags', ctypes.c_uint32),
    ('reserved', ctypes.c_uint32 * 2),
]

hipArrayMapInfo = struct_hipArrayMapInfo
hipInit = _libraries['libamdhip64.so'].hipInit
hipInit.restype = hipError_t
hipInit.argtypes = [ctypes.c_uint32]
hipDriverGetVersion = _libraries['libamdhip64.so'].hipDriverGetVersion
hipDriverGetVersion.restype = hipError_t
hipDriverGetVersion.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipRuntimeGetVersion = _libraries['libamdhip64.so'].hipRuntimeGetVersion
hipRuntimeGetVersion.restype = hipError_t
hipRuntimeGetVersion.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipDeviceGet = _libraries['libamdhip64.so'].hipDeviceGet
hipDeviceGet.restype = hipError_t
hipDeviceGet.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.c_int32]
hipDeviceComputeCapability = _libraries['libamdhip64.so'].hipDeviceComputeCapability
hipDeviceComputeCapability.restype = hipError_t
hipDeviceComputeCapability.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), hipDevice_t]
hipDeviceGetName = _libraries['libamdhip64.so'].hipDeviceGetName
hipDeviceGetName.restype = hipError_t
hipDeviceGetName.argtypes = [ctypes.POINTER(ctypes.c_char), ctypes.c_int32, hipDevice_t]
hipDeviceGetUuid = _libraries['libamdhip64.so'].hipDeviceGetUuid
hipDeviceGetUuid.restype = hipError_t
hipDeviceGetUuid.argtypes = [ctypes.POINTER(struct_hipUUID_t), hipDevice_t]
hipDeviceGetP2PAttribute = _libraries['libamdhip64.so'].hipDeviceGetP2PAttribute
hipDeviceGetP2PAttribute.restype = hipError_t
hipDeviceGetP2PAttribute.argtypes = [ctypes.POINTER(ctypes.c_int32), hipDeviceP2PAttr, ctypes.c_int32, ctypes.c_int32]
hipDeviceGetPCIBusId = _libraries['libamdhip64.so'].hipDeviceGetPCIBusId
hipDeviceGetPCIBusId.restype = hipError_t
hipDeviceGetPCIBusId.argtypes = [ctypes.POINTER(ctypes.c_char), ctypes.c_int32, ctypes.c_int32]
hipDeviceGetByPCIBusId = _libraries['libamdhip64.so'].hipDeviceGetByPCIBusId
hipDeviceGetByPCIBusId.restype = hipError_t
hipDeviceGetByPCIBusId.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_char)]
hipDeviceTotalMem = _libraries['libamdhip64.so'].hipDeviceTotalMem
hipDeviceTotalMem.restype = hipError_t
hipDeviceTotalMem.argtypes = [ctypes.POINTER(ctypes.c_uint64), hipDevice_t]
hipDeviceSynchronize = _libraries['libamdhip64.so'].hipDeviceSynchronize
hipDeviceSynchronize.restype = hipError_t
hipDeviceSynchronize.argtypes = []
hipDeviceReset = _libraries['libamdhip64.so'].hipDeviceReset
hipDeviceReset.restype = hipError_t
hipDeviceReset.argtypes = []
hipSetDevice = _libraries['libamdhip64.so'].hipSetDevice
hipSetDevice.restype = hipError_t
hipSetDevice.argtypes = [ctypes.c_int32]
hipGetDevice = _libraries['libamdhip64.so'].hipGetDevice
hipGetDevice.restype = hipError_t
hipGetDevice.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipGetDeviceCount = _libraries['libamdhip64.so'].hipGetDeviceCount
hipGetDeviceCount.restype = hipError_t
hipGetDeviceCount.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipDeviceGetAttribute = _libraries['libamdhip64.so'].hipDeviceGetAttribute
hipDeviceGetAttribute.restype = hipError_t
hipDeviceGetAttribute.argtypes = [ctypes.POINTER(ctypes.c_int32), hipDeviceAttribute_t, ctypes.c_int32]
hipDeviceGetDefaultMemPool = _libraries['libamdhip64.so'].hipDeviceGetDefaultMemPool
hipDeviceGetDefaultMemPool.restype = hipError_t
hipDeviceGetDefaultMemPool.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.c_int32]
hipDeviceSetMemPool = _libraries['libamdhip64.so'].hipDeviceSetMemPool
hipDeviceSetMemPool.restype = hipError_t
hipDeviceSetMemPool.argtypes = [ctypes.c_int32, hipMemPool_t]
hipDeviceGetMemPool = _libraries['libamdhip64.so'].hipDeviceGetMemPool
hipDeviceGetMemPool.restype = hipError_t
hipDeviceGetMemPool.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.c_int32]
hipGetDeviceProperties = _libraries['libamdhip64.so'].hipGetDeviceProperties
hipGetDeviceProperties.restype = hipError_t
hipGetDeviceProperties.argtypes = [ctypes.POINTER(struct_hipDeviceProp_t), ctypes.c_int32]
hipDeviceSetCacheConfig = _libraries['libamdhip64.so'].hipDeviceSetCacheConfig
hipDeviceSetCacheConfig.restype = hipError_t
hipDeviceSetCacheConfig.argtypes = [hipFuncCache_t]
hipDeviceGetCacheConfig = _libraries['libamdhip64.so'].hipDeviceGetCacheConfig
hipDeviceGetCacheConfig.restype = hipError_t
hipDeviceGetCacheConfig.argtypes = [ctypes.POINTER(hipFuncCache_t)]
hipDeviceGetLimit = _libraries['libamdhip64.so'].hipDeviceGetLimit
hipDeviceGetLimit.restype = hipError_t
hipDeviceGetLimit.argtypes = [ctypes.POINTER(ctypes.c_uint64), hipLimit_t]
hipDeviceSetLimit = _libraries['libamdhip64.so'].hipDeviceSetLimit
hipDeviceSetLimit.restype = hipError_t
hipDeviceSetLimit.argtypes = [hipLimit_t, size_t]
hipDeviceGetSharedMemConfig = _libraries['libamdhip64.so'].hipDeviceGetSharedMemConfig
hipDeviceGetSharedMemConfig.restype = hipError_t
hipDeviceGetSharedMemConfig.argtypes = [ctypes.POINTER(hipSharedMemConfig)]
hipGetDeviceFlags = _libraries['libamdhip64.so'].hipGetDeviceFlags
hipGetDeviceFlags.restype = hipError_t
hipGetDeviceFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32)]
hipDeviceSetSharedMemConfig = _libraries['libamdhip64.so'].hipDeviceSetSharedMemConfig
hipDeviceSetSharedMemConfig.restype = hipError_t
hipDeviceSetSharedMemConfig.argtypes = [hipSharedMemConfig]
hipSetDeviceFlags = _libraries['libamdhip64.so'].hipSetDeviceFlags
hipSetDeviceFlags.restype = hipError_t
hipSetDeviceFlags.argtypes = [ctypes.c_uint32]
hipChooseDevice = _libraries['libamdhip64.so'].hipChooseDevice
hipChooseDevice.restype = hipError_t
hipChooseDevice.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(struct_hipDeviceProp_t)]
hipExtGetLinkTypeAndHopCount = _libraries['libamdhip64.so'].hipExtGetLinkTypeAndHopCount
hipExtGetLinkTypeAndHopCount.restype = hipError_t
hipExtGetLinkTypeAndHopCount.argtypes = [ctypes.c_int32, ctypes.c_int32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)]
hipIpcGetMemHandle = _libraries['libamdhip64.so'].hipIpcGetMemHandle
hipIpcGetMemHandle.restype = hipError_t
hipIpcGetMemHandle.argtypes = [ctypes.POINTER(struct_hipIpcMemHandle_st), ctypes.POINTER(None)]
hipIpcOpenMemHandle = _libraries['libamdhip64.so'].hipIpcOpenMemHandle
hipIpcOpenMemHandle.restype = hipError_t
hipIpcOpenMemHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), hipIpcMemHandle_t, ctypes.c_uint32]
hipIpcCloseMemHandle = _libraries['libamdhip64.so'].hipIpcCloseMemHandle
hipIpcCloseMemHandle.restype = hipError_t
hipIpcCloseMemHandle.argtypes = [ctypes.POINTER(None)]
hipIpcGetEventHandle = _libraries['libamdhip64.so'].hipIpcGetEventHandle
hipIpcGetEventHandle.restype = hipError_t
hipIpcGetEventHandle.argtypes = [ctypes.POINTER(struct_hipIpcEventHandle_st), hipEvent_t]
hipIpcOpenEventHandle = _libraries['libamdhip64.so'].hipIpcOpenEventHandle
hipIpcOpenEventHandle.restype = hipError_t
hipIpcOpenEventHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t)), hipIpcEventHandle_t]
hipFuncSetAttribute = _libraries['libamdhip64.so'].hipFuncSetAttribute
hipFuncSetAttribute.restype = hipError_t
hipFuncSetAttribute.argtypes = [ctypes.POINTER(None), hipFuncAttribute, ctypes.c_int32]
hipFuncSetCacheConfig = _libraries['libamdhip64.so'].hipFuncSetCacheConfig
hipFuncSetCacheConfig.restype = hipError_t
hipFuncSetCacheConfig.argtypes = [ctypes.POINTER(None), hipFuncCache_t]
hipFuncSetSharedMemConfig = _libraries['libamdhip64.so'].hipFuncSetSharedMemConfig
hipFuncSetSharedMemConfig.restype = hipError_t
hipFuncSetSharedMemConfig.argtypes = [ctypes.POINTER(None), hipSharedMemConfig]
hipGetLastError = _libraries['libamdhip64.so'].hipGetLastError
hipGetLastError.restype = hipError_t
hipGetLastError.argtypes = []
hipPeekAtLastError = _libraries['libamdhip64.so'].hipPeekAtLastError
hipPeekAtLastError.restype = hipError_t
hipPeekAtLastError.argtypes = []
hipGetErrorName = _libraries['libamdhip64.so'].hipGetErrorName
hipGetErrorName.restype = ctypes.POINTER(ctypes.c_char)
hipGetErrorName.argtypes = [hipError_t]
hipGetErrorString = _libraries['libamdhip64.so'].hipGetErrorString
hipGetErrorString.restype = ctypes.POINTER(ctypes.c_char)
hipGetErrorString.argtypes = [hipError_t]
hipDrvGetErrorName = _libraries['libamdhip64.so'].hipDrvGetErrorName
hipDrvGetErrorName.restype = hipError_t
hipDrvGetErrorName.argtypes = [hipError_t, ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hipDrvGetErrorString = _libraries['libamdhip64.so'].hipDrvGetErrorString
hipDrvGetErrorString.restype = hipError_t
hipDrvGetErrorString.argtypes = [hipError_t, ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hipStreamCreate = _libraries['libamdhip64.so'].hipStreamCreate
hipStreamCreate.restype = hipError_t
hipStreamCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t))]
hipStreamCreateWithFlags = _libraries['libamdhip64.so'].hipStreamCreateWithFlags
hipStreamCreateWithFlags.restype = hipError_t
hipStreamCreateWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t)), ctypes.c_uint32]
hipStreamCreateWithPriority = _libraries['libamdhip64.so'].hipStreamCreateWithPriority
hipStreamCreateWithPriority.restype = hipError_t
hipStreamCreateWithPriority.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t)), ctypes.c_uint32, ctypes.c_int32]
hipDeviceGetStreamPriorityRange = _libraries['libamdhip64.so'].hipDeviceGetStreamPriorityRange
hipDeviceGetStreamPriorityRange.restype = hipError_t
hipDeviceGetStreamPriorityRange.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32)]
hipStreamDestroy = _libraries['libamdhip64.so'].hipStreamDestroy
hipStreamDestroy.restype = hipError_t
hipStreamDestroy.argtypes = [hipStream_t]
hipStreamQuery = _libraries['libamdhip64.so'].hipStreamQuery
hipStreamQuery.restype = hipError_t
hipStreamQuery.argtypes = [hipStream_t]
hipStreamSynchronize = _libraries['libamdhip64.so'].hipStreamSynchronize
hipStreamSynchronize.restype = hipError_t
hipStreamSynchronize.argtypes = [hipStream_t]
hipStreamWaitEvent = _libraries['libamdhip64.so'].hipStreamWaitEvent
hipStreamWaitEvent.restype = hipError_t
hipStreamWaitEvent.argtypes = [hipStream_t, hipEvent_t, ctypes.c_uint32]
hipStreamGetFlags = _libraries['libamdhip64.so'].hipStreamGetFlags
hipStreamGetFlags.restype = hipError_t
hipStreamGetFlags.argtypes = [hipStream_t, ctypes.POINTER(ctypes.c_uint32)]
hipStreamGetPriority = _libraries['libamdhip64.so'].hipStreamGetPriority
hipStreamGetPriority.restype = hipError_t
hipStreamGetPriority.argtypes = [hipStream_t, ctypes.POINTER(ctypes.c_int32)]
hipStreamGetDevice = _libraries['libamdhip64.so'].hipStreamGetDevice
hipStreamGetDevice.restype = hipError_t
hipStreamGetDevice.argtypes = [hipStream_t, ctypes.POINTER(ctypes.c_int32)]
uint32_t = ctypes.c_uint32
hipExtStreamCreateWithCUMask = _libraries['libamdhip64.so'].hipExtStreamCreateWithCUMask
hipExtStreamCreateWithCUMask.restype = hipError_t
hipExtStreamCreateWithCUMask.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t)), uint32_t, ctypes.POINTER(ctypes.c_uint32)]
hipExtStreamGetCUMask = _libraries['libamdhip64.so'].hipExtStreamGetCUMask
hipExtStreamGetCUMask.restype = hipError_t
hipExtStreamGetCUMask.argtypes = [hipStream_t, uint32_t, ctypes.POINTER(ctypes.c_uint32)]
hipStreamCallback_t = ctypes.CFUNCTYPE(None, ctypes.POINTER(struct_ihipStream_t), hipError_t, ctypes.POINTER(None))
hipStreamAddCallback = _libraries['libamdhip64.so'].hipStreamAddCallback
hipStreamAddCallback.restype = hipError_t
hipStreamAddCallback.argtypes = [hipStream_t, hipStreamCallback_t, ctypes.POINTER(None), ctypes.c_uint32]
hipStreamWaitValue32 = _libraries['libamdhip64.so'].hipStreamWaitValue32
hipStreamWaitValue32.restype = hipError_t
hipStreamWaitValue32.argtypes = [hipStream_t, ctypes.POINTER(None), uint32_t, ctypes.c_uint32, uint32_t]
uint64_t = ctypes.c_uint64
hipStreamWaitValue64 = _libraries['libamdhip64.so'].hipStreamWaitValue64
hipStreamWaitValue64.restype = hipError_t
hipStreamWaitValue64.argtypes = [hipStream_t, ctypes.POINTER(None), uint64_t, ctypes.c_uint32, uint64_t]
hipStreamWriteValue32 = _libraries['libamdhip64.so'].hipStreamWriteValue32
hipStreamWriteValue32.restype = hipError_t
hipStreamWriteValue32.argtypes = [hipStream_t, ctypes.POINTER(None), uint32_t, ctypes.c_uint32]
hipStreamWriteValue64 = _libraries['libamdhip64.so'].hipStreamWriteValue64
hipStreamWriteValue64.restype = hipError_t
hipStreamWriteValue64.argtypes = [hipStream_t, ctypes.POINTER(None), uint64_t, ctypes.c_uint32]
hipEventCreateWithFlags = _libraries['libamdhip64.so'].hipEventCreateWithFlags
hipEventCreateWithFlags.restype = hipError_t
hipEventCreateWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t)), ctypes.c_uint32]
hipEventCreate = _libraries['libamdhip64.so'].hipEventCreate
hipEventCreate.restype = hipError_t
hipEventCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t))]
hipEventRecord = _libraries['libamdhip64.so'].hipEventRecord
hipEventRecord.restype = hipError_t
hipEventRecord.argtypes = [hipEvent_t, hipStream_t]
hipEventDestroy = _libraries['libamdhip64.so'].hipEventDestroy
hipEventDestroy.restype = hipError_t
hipEventDestroy.argtypes = [hipEvent_t]
hipEventSynchronize = _libraries['libamdhip64.so'].hipEventSynchronize
hipEventSynchronize.restype = hipError_t
hipEventSynchronize.argtypes = [hipEvent_t]
hipEventElapsedTime = _libraries['libamdhip64.so'].hipEventElapsedTime
hipEventElapsedTime.restype = hipError_t
hipEventElapsedTime.argtypes = [ctypes.POINTER(ctypes.c_float), hipEvent_t, hipEvent_t]
hipEventQuery = _libraries['libamdhip64.so'].hipEventQuery
hipEventQuery.restype = hipError_t
hipEventQuery.argtypes = [hipEvent_t]
hipPointerSetAttribute = _libraries['libamdhip64.so'].hipPointerSetAttribute
hipPointerSetAttribute.restype = hipError_t
hipPointerSetAttribute.argtypes = [ctypes.POINTER(None), hipPointer_attribute, hipDeviceptr_t]
hipPointerGetAttributes = _libraries['libamdhip64.so'].hipPointerGetAttributes
hipPointerGetAttributes.restype = hipError_t
hipPointerGetAttributes.argtypes = [ctypes.POINTER(struct_hipPointerAttribute_t), ctypes.POINTER(None)]
hipPointerGetAttribute = _libraries['libamdhip64.so'].hipPointerGetAttribute
hipPointerGetAttribute.restype = hipError_t
hipPointerGetAttribute.argtypes = [ctypes.POINTER(None), hipPointer_attribute, hipDeviceptr_t]
hipDrvPointerGetAttributes = _libraries['libamdhip64.so'].hipDrvPointerGetAttributes
hipDrvPointerGetAttributes.restype = hipError_t
hipDrvPointerGetAttributes.argtypes = [ctypes.c_uint32, ctypes.POINTER(hipPointer_attribute), ctypes.POINTER(ctypes.POINTER(None)), hipDeviceptr_t]
hipImportExternalSemaphore = _libraries['libamdhip64.so'].hipImportExternalSemaphore
hipImportExternalSemaphore.restype = hipError_t
hipImportExternalSemaphore.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalSemaphoreHandleDesc_st)]
hipSignalExternalSemaphoresAsync = _libraries['libamdhip64.so'].hipSignalExternalSemaphoresAsync
hipSignalExternalSemaphoresAsync.restype = hipError_t
hipSignalExternalSemaphoresAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalSemaphoreSignalParams_st), ctypes.c_uint32, hipStream_t]
hipWaitExternalSemaphoresAsync = _libraries['libamdhip64.so'].hipWaitExternalSemaphoresAsync
hipWaitExternalSemaphoresAsync.restype = hipError_t
hipWaitExternalSemaphoresAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalSemaphoreWaitParams_st), ctypes.c_uint32, hipStream_t]
hipDestroyExternalSemaphore = _libraries['libamdhip64.so'].hipDestroyExternalSemaphore
hipDestroyExternalSemaphore.restype = hipError_t
hipDestroyExternalSemaphore.argtypes = [hipExternalSemaphore_t]
hipImportExternalMemory = _libraries['libamdhip64.so'].hipImportExternalMemory
hipImportExternalMemory.restype = hipError_t
hipImportExternalMemory.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalMemoryHandleDesc_st)]
hipExternalMemoryGetMappedBuffer = _libraries['libamdhip64.so'].hipExternalMemoryGetMappedBuffer
hipExternalMemoryGetMappedBuffer.restype = hipError_t
hipExternalMemoryGetMappedBuffer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), hipExternalMemory_t, ctypes.POINTER(struct_hipExternalMemoryBufferDesc_st)]
hipDestroyExternalMemory = _libraries['libamdhip64.so'].hipDestroyExternalMemory
hipDestroyExternalMemory.restype = hipError_t
hipDestroyExternalMemory.argtypes = [hipExternalMemory_t]
hipMalloc = _libraries['libamdhip64.so'].hipMalloc
hipMalloc.restype = hipError_t
hipMalloc.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t]
hipExtMallocWithFlags = _libraries['libamdhip64.so'].hipExtMallocWithFlags
hipExtMallocWithFlags.restype = hipError_t
hipExtMallocWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipMallocHost = _libraries['libamdhip64.so'].hipMallocHost
hipMallocHost.restype = hipError_t
hipMallocHost.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t]
hipMemAllocHost = _libraries['libamdhip64.so'].hipMemAllocHost
hipMemAllocHost.restype = hipError_t
hipMemAllocHost.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t]
hipHostMalloc = _libraries['libamdhip64.so'].hipHostMalloc
hipHostMalloc.restype = hipError_t
hipHostMalloc.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipMallocManaged = _libraries['libamdhip64.so'].hipMallocManaged
hipMallocManaged.restype = hipError_t
hipMallocManaged.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipMemPrefetchAsync = _libraries['libamdhip64.so'].hipMemPrefetchAsync
hipMemPrefetchAsync.restype = hipError_t
hipMemPrefetchAsync.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_int32, hipStream_t]
hipMemAdvise = _libraries['libamdhip64.so'].hipMemAdvise
hipMemAdvise.restype = hipError_t
hipMemAdvise.argtypes = [ctypes.POINTER(None), size_t, hipMemoryAdvise, ctypes.c_int32]
hipMemRangeGetAttribute = _libraries['libamdhip64.so'].hipMemRangeGetAttribute
hipMemRangeGetAttribute.restype = hipError_t
hipMemRangeGetAttribute.argtypes = [ctypes.POINTER(None), size_t, hipMemRangeAttribute, ctypes.POINTER(None), size_t]
hipMemRangeGetAttributes = _libraries['libamdhip64.so'].hipMemRangeGetAttributes
hipMemRangeGetAttributes.restype = hipError_t
hipMemRangeGetAttributes.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(hipMemRangeAttribute), size_t, ctypes.POINTER(None), size_t]
hipStreamAttachMemAsync = _libraries['libamdhip64.so'].hipStreamAttachMemAsync
hipStreamAttachMemAsync.restype = hipError_t
hipStreamAttachMemAsync.argtypes = [hipStream_t, ctypes.POINTER(None), size_t, ctypes.c_uint32]
hipMallocAsync = _libraries['libamdhip64.so'].hipMallocAsync
hipMallocAsync.restype = hipError_t
hipMallocAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, hipStream_t]
hipFreeAsync = _libraries['libamdhip64.so'].hipFreeAsync
hipFreeAsync.restype = hipError_t
hipFreeAsync.argtypes = [ctypes.POINTER(None), hipStream_t]
hipMemPoolTrimTo = _libraries['libamdhip64.so'].hipMemPoolTrimTo
hipMemPoolTrimTo.restype = hipError_t
hipMemPoolTrimTo.argtypes = [hipMemPool_t, size_t]
hipMemPoolSetAttribute = _libraries['libamdhip64.so'].hipMemPoolSetAttribute
hipMemPoolSetAttribute.restype = hipError_t
hipMemPoolSetAttribute.argtypes = [hipMemPool_t, hipMemPoolAttr, ctypes.POINTER(None)]
hipMemPoolGetAttribute = _libraries['libamdhip64.so'].hipMemPoolGetAttribute
hipMemPoolGetAttribute.restype = hipError_t
hipMemPoolGetAttribute.argtypes = [hipMemPool_t, hipMemPoolAttr, ctypes.POINTER(None)]
hipMemPoolSetAccess = _libraries['libamdhip64.so'].hipMemPoolSetAccess
hipMemPoolSetAccess.restype = hipError_t
hipMemPoolSetAccess.argtypes = [hipMemPool_t, ctypes.POINTER(struct_hipMemAccessDesc), size_t]
hipMemPoolGetAccess = _libraries['libamdhip64.so'].hipMemPoolGetAccess
hipMemPoolGetAccess.restype = hipError_t
hipMemPoolGetAccess.argtypes = [ctypes.POINTER(hipMemAccessFlags), hipMemPool_t, ctypes.POINTER(struct_hipMemLocation)]
hipMemPoolCreate = _libraries['libamdhip64.so'].hipMemPoolCreate
hipMemPoolCreate.restype = hipError_t
hipMemPoolCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.POINTER(struct_hipMemPoolProps)]
hipMemPoolDestroy = _libraries['libamdhip64.so'].hipMemPoolDestroy
hipMemPoolDestroy.restype = hipError_t
hipMemPoolDestroy.argtypes = [hipMemPool_t]
hipMallocFromPoolAsync = _libraries['libamdhip64.so'].hipMallocFromPoolAsync
hipMallocFromPoolAsync.restype = hipError_t
hipMallocFromPoolAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, hipMemPool_t, hipStream_t]
hipMemPoolExportToShareableHandle = _libraries['libamdhip64.so'].hipMemPoolExportToShareableHandle
hipMemPoolExportToShareableHandle.restype = hipError_t
hipMemPoolExportToShareableHandle.argtypes = [ctypes.POINTER(None), hipMemPool_t, hipMemAllocationHandleType, ctypes.c_uint32]
hipMemPoolImportFromShareableHandle = _libraries['libamdhip64.so'].hipMemPoolImportFromShareableHandle
hipMemPoolImportFromShareableHandle.restype = hipError_t
hipMemPoolImportFromShareableHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.POINTER(None), hipMemAllocationHandleType, ctypes.c_uint32]
hipMemPoolExportPointer = _libraries['libamdhip64.so'].hipMemPoolExportPointer
hipMemPoolExportPointer.restype = hipError_t
hipMemPoolExportPointer.argtypes = [ctypes.POINTER(struct_hipMemPoolPtrExportData), ctypes.POINTER(None)]
hipMemPoolImportPointer = _libraries['libamdhip64.so'].hipMemPoolImportPointer
hipMemPoolImportPointer.restype = hipError_t
hipMemPoolImportPointer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), hipMemPool_t, ctypes.POINTER(struct_hipMemPoolPtrExportData)]
hipHostAlloc = _libraries['libamdhip64.so'].hipHostAlloc
hipHostAlloc.restype = hipError_t
hipHostAlloc.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipHostGetDevicePointer = _libraries['libamdhip64.so'].hipHostGetDevicePointer
hipHostGetDevicePointer.restype = hipError_t
hipHostGetDevicePointer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(None), ctypes.c_uint32]
hipHostGetFlags = _libraries['libamdhip64.so'].hipHostGetFlags
hipHostGetFlags.restype = hipError_t
hipHostGetFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(None)]
hipHostRegister = _libraries['libamdhip64.so'].hipHostRegister
hipHostRegister.restype = hipError_t
hipHostRegister.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_uint32]
hipHostUnregister = _libraries['libamdhip64.so'].hipHostUnregister
hipHostUnregister.restype = hipError_t
hipHostUnregister.argtypes = [ctypes.POINTER(None)]
hipMallocPitch = _libraries['libamdhip64.so'].hipMallocPitch
hipMallocPitch.restype = hipError_t
hipMallocPitch.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), size_t, size_t]
hipMemAllocPitch = _libraries['libamdhip64.so'].hipMemAllocPitch
hipMemAllocPitch.restype = hipError_t
hipMemAllocPitch.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), size_t, size_t, ctypes.c_uint32]
hipFree = _libraries['libamdhip64.so'].hipFree
hipFree.restype = hipError_t
hipFree.argtypes = [ctypes.POINTER(None)]
hipFreeHost = _libraries['libamdhip64.so'].hipFreeHost
hipFreeHost.restype = hipError_t
hipFreeHost.argtypes = [ctypes.POINTER(None)]
hipHostFree = _libraries['libamdhip64.so'].hipHostFree
hipHostFree.restype = hipError_t
hipHostFree.argtypes = [ctypes.POINTER(None)]
hipMemcpy = _libraries['libamdhip64.so'].hipMemcpy
hipMemcpy.restype = hipError_t
hipMemcpy.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipMemcpyWithStream = _libraries['libamdhip64.so'].hipMemcpyWithStream
hipMemcpyWithStream.restype = hipError_t
hipMemcpyWithStream.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind, hipStream_t]
hipMemcpyHtoD = _libraries['libamdhip64.so'].hipMemcpyHtoD
hipMemcpyHtoD.restype = hipError_t
hipMemcpyHtoD.argtypes = [hipDeviceptr_t, ctypes.POINTER(None), size_t]
hipMemcpyDtoH = _libraries['libamdhip64.so'].hipMemcpyDtoH
hipMemcpyDtoH.restype = hipError_t
hipMemcpyDtoH.argtypes = [ctypes.POINTER(None), hipDeviceptr_t, size_t]
hipMemcpyDtoD = _libraries['libamdhip64.so'].hipMemcpyDtoD
hipMemcpyDtoD.restype = hipError_t
hipMemcpyDtoD.argtypes = [hipDeviceptr_t, hipDeviceptr_t, size_t]
hipMemcpyHtoDAsync = _libraries['libamdhip64.so'].hipMemcpyHtoDAsync
hipMemcpyHtoDAsync.restype = hipError_t
hipMemcpyHtoDAsync.argtypes = [hipDeviceptr_t, ctypes.POINTER(None), size_t, hipStream_t]
hipMemcpyDtoHAsync = _libraries['libamdhip64.so'].hipMemcpyDtoHAsync
hipMemcpyDtoHAsync.restype = hipError_t
hipMemcpyDtoHAsync.argtypes = [ctypes.POINTER(None), hipDeviceptr_t, size_t, hipStream_t]
hipMemcpyDtoDAsync = _libraries['libamdhip64.so'].hipMemcpyDtoDAsync
hipMemcpyDtoDAsync.restype = hipError_t
hipMemcpyDtoDAsync.argtypes = [hipDeviceptr_t, hipDeviceptr_t, size_t, hipStream_t]
hipModuleGetGlobal = _libraries['libamdhip64.so'].hipModuleGetGlobal
hipModuleGetGlobal.restype = hipError_t
hipModuleGetGlobal.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), hipModule_t, ctypes.POINTER(ctypes.c_char)]
hipGetSymbolAddress = _libraries['libamdhip64.so'].hipGetSymbolAddress
hipGetSymbolAddress.restype = hipError_t
hipGetSymbolAddress.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(None)]
hipGetSymbolSize = _libraries['libamdhip64.so'].hipGetSymbolSize
hipGetSymbolSize.restype = hipError_t
hipGetSymbolSize.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(None)]
hipMemcpyToSymbol = _libraries['libamdhip64.so'].hipMemcpyToSymbol
hipMemcpyToSymbol.restype = hipError_t
hipMemcpyToSymbol.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipMemcpyToSymbolAsync = _libraries['libamdhip64.so'].hipMemcpyToSymbolAsync
hipMemcpyToSymbolAsync.restype = hipError_t
hipMemcpyToSymbolAsync.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyFromSymbol = _libraries['libamdhip64.so'].hipMemcpyFromSymbol
hipMemcpyFromSymbol.restype = hipError_t
hipMemcpyFromSymbol.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipMemcpyFromSymbolAsync = _libraries['libamdhip64.so'].hipMemcpyFromSymbolAsync
hipMemcpyFromSymbolAsync.restype = hipError_t
hipMemcpyFromSymbolAsync.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyAsync = _libraries['libamdhip64.so'].hipMemcpyAsync
hipMemcpyAsync.restype = hipError_t
hipMemcpyAsync.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind, hipStream_t]
hipMemset = _libraries['libamdhip64.so'].hipMemset
hipMemset.restype = hipError_t
hipMemset.argtypes = [ctypes.POINTER(None), ctypes.c_int32, size_t]
hipMemsetD8 = _libraries['libamdhip64.so'].hipMemsetD8
hipMemsetD8.restype = hipError_t
hipMemsetD8.argtypes = [hipDeviceptr_t, ctypes.c_ubyte, size_t]
hipMemsetD8Async = _libraries['libamdhip64.so'].hipMemsetD8Async
hipMemsetD8Async.restype = hipError_t
hipMemsetD8Async.argtypes = [hipDeviceptr_t, ctypes.c_ubyte, size_t, hipStream_t]
hipMemsetD16 = _libraries['libamdhip64.so'].hipMemsetD16
hipMemsetD16.restype = hipError_t
hipMemsetD16.argtypes = [hipDeviceptr_t, ctypes.c_uint16, size_t]
hipMemsetD16Async = _libraries['libamdhip64.so'].hipMemsetD16Async
hipMemsetD16Async.restype = hipError_t
hipMemsetD16Async.argtypes = [hipDeviceptr_t, ctypes.c_uint16, size_t, hipStream_t]
hipMemsetD32 = _libraries['libamdhip64.so'].hipMemsetD32
hipMemsetD32.restype = hipError_t
hipMemsetD32.argtypes = [hipDeviceptr_t, ctypes.c_int32, size_t]
hipMemsetAsync = _libraries['libamdhip64.so'].hipMemsetAsync
hipMemsetAsync.restype = hipError_t
hipMemsetAsync.argtypes = [ctypes.POINTER(None), ctypes.c_int32, size_t, hipStream_t]
hipMemsetD32Async = _libraries['libamdhip64.so'].hipMemsetD32Async
hipMemsetD32Async.restype = hipError_t
hipMemsetD32Async.argtypes = [hipDeviceptr_t, ctypes.c_int32, size_t, hipStream_t]
hipMemset2D = _libraries['libamdhip64.so'].hipMemset2D
hipMemset2D.restype = hipError_t
hipMemset2D.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_int32, size_t, size_t]
hipMemset2DAsync = _libraries['libamdhip64.so'].hipMemset2DAsync
hipMemset2DAsync.restype = hipError_t
hipMemset2DAsync.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_int32, size_t, size_t, hipStream_t]
hipMemset3D = _libraries['libamdhip64.so'].hipMemset3D
hipMemset3D.restype = hipError_t
hipMemset3D.argtypes = [hipPitchedPtr, ctypes.c_int32, hipExtent]
hipMemset3DAsync = _libraries['libamdhip64.so'].hipMemset3DAsync
hipMemset3DAsync.restype = hipError_t
hipMemset3DAsync.argtypes = [hipPitchedPtr, ctypes.c_int32, hipExtent, hipStream_t]
hipMemGetInfo = _libraries['libamdhip64.so'].hipMemGetInfo
hipMemGetInfo.restype = hipError_t
hipMemGetInfo.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64)]
hipMemPtrGetInfo = _libraries['libamdhip64.so'].hipMemPtrGetInfo
hipMemPtrGetInfo.restype = hipError_t
hipMemPtrGetInfo.argtypes = [ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
hipMallocArray = _libraries['libamdhip64.so'].hipMallocArray
hipMallocArray.restype = hipError_t
hipMallocArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_hipChannelFormatDesc), size_t, size_t, ctypes.c_uint32]
hipArrayCreate = _libraries['libamdhip64.so'].hipArrayCreate
hipArrayCreate.restype = hipError_t
hipArrayCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_HIP_ARRAY_DESCRIPTOR)]
hipArrayDestroy = _libraries['libamdhip64.so'].hipArrayDestroy
hipArrayDestroy.restype = hipError_t
hipArrayDestroy.argtypes = [ctypes.POINTER(struct_hipArray)]
hipArray3DCreate = _libraries['libamdhip64.so'].hipArray3DCreate
hipArray3DCreate.restype = hipError_t
hipArray3DCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_HIP_ARRAY3D_DESCRIPTOR)]
hipMalloc3D = _libraries['libamdhip64.so'].hipMalloc3D
hipMalloc3D.restype = hipError_t
hipMalloc3D.argtypes = [ctypes.POINTER(struct_hipPitchedPtr), hipExtent]
hipFreeArray = _libraries['libamdhip64.so'].hipFreeArray
hipFreeArray.restype = hipError_t
hipFreeArray.argtypes = [ctypes.POINTER(struct_hipArray)]
hipMalloc3DArray = _libraries['libamdhip64.so'].hipMalloc3DArray
hipMalloc3DArray.restype = hipError_t
hipMalloc3DArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_hipChannelFormatDesc), struct_hipExtent, ctypes.c_uint32]
hipArrayGetInfo = _libraries['libamdhip64.so'].hipArrayGetInfo
hipArrayGetInfo.restype = hipError_t
hipArrayGetInfo.argtypes = [ctypes.POINTER(struct_hipChannelFormatDesc), ctypes.POINTER(struct_hipExtent), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(struct_hipArray)]
hipArrayGetDescriptor = _libraries['libamdhip64.so'].hipArrayGetDescriptor
hipArrayGetDescriptor.restype = hipError_t
hipArrayGetDescriptor.argtypes = [ctypes.POINTER(struct_HIP_ARRAY_DESCRIPTOR), ctypes.POINTER(struct_hipArray)]
hipArray3DGetDescriptor = _libraries['libamdhip64.so'].hipArray3DGetDescriptor
hipArray3DGetDescriptor.restype = hipError_t
hipArray3DGetDescriptor.argtypes = [ctypes.POINTER(struct_HIP_ARRAY3D_DESCRIPTOR), ctypes.POINTER(struct_hipArray)]
hipMemcpy2D = _libraries['libamdhip64.so'].hipMemcpy2D
hipMemcpy2D.restype = hipError_t
hipMemcpy2D.argtypes = [ctypes.POINTER(None), size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind]
hipMemcpyParam2D = _libraries['libamdhip64.so'].hipMemcpyParam2D
hipMemcpyParam2D.restype = hipError_t
hipMemcpyParam2D.argtypes = [ctypes.POINTER(struct_hip_Memcpy2D)]
hipMemcpyParam2DAsync = _libraries['libamdhip64.so'].hipMemcpyParam2DAsync
hipMemcpyParam2DAsync.restype = hipError_t
hipMemcpyParam2DAsync.argtypes = [ctypes.POINTER(struct_hip_Memcpy2D), hipStream_t]
hipMemcpy2DAsync = _libraries['libamdhip64.so'].hipMemcpy2DAsync
hipMemcpy2DAsync.restype = hipError_t
hipMemcpy2DAsync.argtypes = [ctypes.POINTER(None), size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpy2DToArray = _libraries['libamdhip64.so'].hipMemcpy2DToArray
hipMemcpy2DToArray.restype = hipError_t
hipMemcpy2DToArray.argtypes = [ctypes.POINTER(struct_hipArray), size_t, size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind]
hipMemcpy2DToArrayAsync = _libraries['libamdhip64.so'].hipMemcpy2DToArrayAsync
hipMemcpy2DToArrayAsync.restype = hipError_t
hipMemcpy2DToArrayAsync.argtypes = [ctypes.POINTER(struct_hipArray), size_t, size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyToArray = _libraries['libamdhip64.so'].hipMemcpyToArray
hipMemcpyToArray.restype = hipError_t
hipMemcpyToArray.argtypes = [ctypes.POINTER(struct_hipArray), size_t, size_t, ctypes.POINTER(None), size_t, hipMemcpyKind]
hipMemcpyFromArray = _libraries['libamdhip64.so'].hipMemcpyFromArray
hipMemcpyFromArray.restype = hipError_t
hipMemcpyFromArray.argtypes = [ctypes.POINTER(None), hipArray_const_t, size_t, size_t, size_t, hipMemcpyKind]
hipMemcpy2DFromArray = _libraries['libamdhip64.so'].hipMemcpy2DFromArray
hipMemcpy2DFromArray.restype = hipError_t
hipMemcpy2DFromArray.argtypes = [ctypes.POINTER(None), size_t, hipArray_const_t, size_t, size_t, size_t, size_t, hipMemcpyKind]
hipMemcpy2DFromArrayAsync = _libraries['libamdhip64.so'].hipMemcpy2DFromArrayAsync
hipMemcpy2DFromArrayAsync.restype = hipError_t
hipMemcpy2DFromArrayAsync.argtypes = [ctypes.POINTER(None), size_t, hipArray_const_t, size_t, size_t, size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyAtoH = _libraries['libamdhip64.so'].hipMemcpyAtoH
hipMemcpyAtoH.restype = hipError_t
hipMemcpyAtoH.argtypes = [ctypes.POINTER(None), ctypes.POINTER(struct_hipArray), size_t, size_t]
hipMemcpyHtoA = _libraries['libamdhip64.so'].hipMemcpyHtoA
hipMemcpyHtoA.restype = hipError_t
hipMemcpyHtoA.argtypes = [ctypes.POINTER(struct_hipArray), size_t, ctypes.POINTER(None), size_t]
hipMemcpy3D = _libraries['libamdhip64.so'].hipMemcpy3D
hipMemcpy3D.restype = hipError_t
hipMemcpy3D.argtypes = [ctypes.POINTER(struct_hipMemcpy3DParms)]
hipMemcpy3DAsync = _libraries['libamdhip64.so'].hipMemcpy3DAsync
hipMemcpy3DAsync.restype = hipError_t
hipMemcpy3DAsync.argtypes = [ctypes.POINTER(struct_hipMemcpy3DParms), hipStream_t]
hipDrvMemcpy3D = _libraries['libamdhip64.so'].hipDrvMemcpy3D
hipDrvMemcpy3D.restype = hipError_t
hipDrvMemcpy3D.argtypes = [ctypes.POINTER(struct_HIP_MEMCPY3D)]
hipDrvMemcpy3DAsync = _libraries['libamdhip64.so'].hipDrvMemcpy3DAsync
hipDrvMemcpy3DAsync.restype = hipError_t
hipDrvMemcpy3DAsync.argtypes = [ctypes.POINTER(struct_HIP_MEMCPY3D), hipStream_t]
hipDeviceCanAccessPeer = _libraries['libamdhip64.so'].hipDeviceCanAccessPeer
hipDeviceCanAccessPeer.restype = hipError_t
hipDeviceCanAccessPeer.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.c_int32, ctypes.c_int32]
hipDeviceEnablePeerAccess = _libraries['libamdhip64.so'].hipDeviceEnablePeerAccess
hipDeviceEnablePeerAccess.restype = hipError_t
hipDeviceEnablePeerAccess.argtypes = [ctypes.c_int32, ctypes.c_uint32]
hipDeviceDisablePeerAccess = _libraries['libamdhip64.so'].hipDeviceDisablePeerAccess
hipDeviceDisablePeerAccess.restype = hipError_t
hipDeviceDisablePeerAccess.argtypes = [ctypes.c_int32]
hipMemGetAddressRange = _libraries['libamdhip64.so'].hipMemGetAddressRange
hipMemGetAddressRange.restype = hipError_t
hipMemGetAddressRange.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), hipDeviceptr_t]
hipMemcpyPeer = _libraries['libamdhip64.so'].hipMemcpyPeer
hipMemcpyPeer.restype = hipError_t
hipMemcpyPeer.argtypes = [ctypes.POINTER(None), ctypes.c_int32, ctypes.POINTER(None), ctypes.c_int32, size_t]
hipMemcpyPeerAsync = _libraries['libamdhip64.so'].hipMemcpyPeerAsync
hipMemcpyPeerAsync.restype = hipError_t
hipMemcpyPeerAsync.argtypes = [ctypes.POINTER(None), ctypes.c_int32, ctypes.POINTER(None), ctypes.c_int32, size_t, hipStream_t]
hipCtxCreate = _libraries['libamdhip64.so'].hipCtxCreate
hipCtxCreate.restype = hipError_t
hipCtxCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t)), ctypes.c_uint32, hipDevice_t]
hipCtxDestroy = _libraries['libamdhip64.so'].hipCtxDestroy
hipCtxDestroy.restype = hipError_t
hipCtxDestroy.argtypes = [hipCtx_t]
hipCtxPopCurrent = _libraries['libamdhip64.so'].hipCtxPopCurrent
hipCtxPopCurrent.restype = hipError_t
hipCtxPopCurrent.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t))]
hipCtxPushCurrent = _libraries['libamdhip64.so'].hipCtxPushCurrent
hipCtxPushCurrent.restype = hipError_t
hipCtxPushCurrent.argtypes = [hipCtx_t]
hipCtxSetCurrent = _libraries['libamdhip64.so'].hipCtxSetCurrent
hipCtxSetCurrent.restype = hipError_t
hipCtxSetCurrent.argtypes = [hipCtx_t]
hipCtxGetCurrent = _libraries['libamdhip64.so'].hipCtxGetCurrent
hipCtxGetCurrent.restype = hipError_t
hipCtxGetCurrent.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t))]
hipCtxGetDevice = _libraries['libamdhip64.so'].hipCtxGetDevice
hipCtxGetDevice.restype = hipError_t
hipCtxGetDevice.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipCtxGetApiVersion = _libraries['libamdhip64.so'].hipCtxGetApiVersion
hipCtxGetApiVersion.restype = hipError_t
hipCtxGetApiVersion.argtypes = [hipCtx_t, ctypes.POINTER(ctypes.c_int32)]
hipCtxGetCacheConfig = _libraries['libamdhip64.so'].hipCtxGetCacheConfig
hipCtxGetCacheConfig.restype = hipError_t
hipCtxGetCacheConfig.argtypes = [ctypes.POINTER(hipFuncCache_t)]
hipCtxSetCacheConfig = _libraries['libamdhip64.so'].hipCtxSetCacheConfig
hipCtxSetCacheConfig.restype = hipError_t
hipCtxSetCacheConfig.argtypes = [hipFuncCache_t]
hipCtxSetSharedMemConfig = _libraries['libamdhip64.so'].hipCtxSetSharedMemConfig
hipCtxSetSharedMemConfig.restype = hipError_t
hipCtxSetSharedMemConfig.argtypes = [hipSharedMemConfig]
hipCtxGetSharedMemConfig = _libraries['libamdhip64.so'].hipCtxGetSharedMemConfig
hipCtxGetSharedMemConfig.restype = hipError_t
hipCtxGetSharedMemConfig.argtypes = [ctypes.POINTER(hipSharedMemConfig)]
hipCtxSynchronize = _libraries['libamdhip64.so'].hipCtxSynchronize
hipCtxSynchronize.restype = hipError_t
hipCtxSynchronize.argtypes = []
hipCtxGetFlags = _libraries['libamdhip64.so'].hipCtxGetFlags
hipCtxGetFlags.restype = hipError_t
hipCtxGetFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32)]
hipCtxEnablePeerAccess = _libraries['libamdhip64.so'].hipCtxEnablePeerAccess
hipCtxEnablePeerAccess.restype = hipError_t
hipCtxEnablePeerAccess.argtypes = [hipCtx_t, ctypes.c_uint32]
hipCtxDisablePeerAccess = _libraries['libamdhip64.so'].hipCtxDisablePeerAccess
hipCtxDisablePeerAccess.restype = hipError_t
hipCtxDisablePeerAccess.argtypes = [hipCtx_t]
hipDevicePrimaryCtxGetState = _libraries['libamdhip64.so'].hipDevicePrimaryCtxGetState
hipDevicePrimaryCtxGetState.restype = hipError_t
hipDevicePrimaryCtxGetState.argtypes = [hipDevice_t, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_int32)]
hipDevicePrimaryCtxRelease = _libraries['libamdhip64.so'].hipDevicePrimaryCtxRelease
hipDevicePrimaryCtxRelease.restype = hipError_t
hipDevicePrimaryCtxRelease.argtypes = [hipDevice_t]
hipDevicePrimaryCtxRetain = _libraries['libamdhip64.so'].hipDevicePrimaryCtxRetain
hipDevicePrimaryCtxRetain.restype = hipError_t
hipDevicePrimaryCtxRetain.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t)), hipDevice_t]
hipDevicePrimaryCtxReset = _libraries['libamdhip64.so'].hipDevicePrimaryCtxReset
hipDevicePrimaryCtxReset.restype = hipError_t
hipDevicePrimaryCtxReset.argtypes = [hipDevice_t]
hipDevicePrimaryCtxSetFlags = _libraries['libamdhip64.so'].hipDevicePrimaryCtxSetFlags
hipDevicePrimaryCtxSetFlags.restype = hipError_t
hipDevicePrimaryCtxSetFlags.argtypes = [hipDevice_t, ctypes.c_uint32]
hipModuleLoad = _libraries['libamdhip64.so'].hipModuleLoad
hipModuleLoad.restype = hipError_t
hipModuleLoad.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModule_t)), ctypes.POINTER(ctypes.c_char)]
hipModuleUnload = _libraries['libamdhip64.so'].hipModuleUnload
hipModuleUnload.restype = hipError_t
hipModuleUnload.argtypes = [hipModule_t]
hipModuleGetFunction = _libraries['libamdhip64.so'].hipModuleGetFunction
hipModuleGetFunction.restype = hipError_t
hipModuleGetFunction.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModuleSymbol_t)), hipModule_t, ctypes.POINTER(ctypes.c_char)]
hipFuncGetAttributes = _libraries['libamdhip64.so'].hipFuncGetAttributes
hipFuncGetAttributes.restype = hipError_t
hipFuncGetAttributes.argtypes = [ctypes.POINTER(struct_hipFuncAttributes), ctypes.POINTER(None)]
hipFuncGetAttribute = _libraries['libamdhip64.so'].hipFuncGetAttribute
hipFuncGetAttribute.restype = hipError_t
hipFuncGetAttribute.argtypes = [ctypes.POINTER(ctypes.c_int32), hipFunction_attribute, hipFunction_t]
class struct_textureReference(Structure):
    pass

class struct___hip_texture(Structure):
    pass


# values for enumeration 'hipTextureAddressMode'
hipTextureAddressMode__enumvalues = {
    0: 'hipAddressModeWrap',
    1: 'hipAddressModeClamp',
    2: 'hipAddressModeMirror',
    3: 'hipAddressModeBorder',
}
hipAddressModeWrap = 0
hipAddressModeClamp = 1
hipAddressModeMirror = 2
hipAddressModeBorder = 3
hipTextureAddressMode = ctypes.c_uint32 # enum

# values for enumeration 'hipTextureReadMode'
hipTextureReadMode__enumvalues = {
    0: 'hipReadModeElementType',
    1: 'hipReadModeNormalizedFloat',
}
hipReadModeElementType = 0
hipReadModeNormalizedFloat = 1
hipTextureReadMode = ctypes.c_uint32 # enum

# values for enumeration 'hipTextureFilterMode'
hipTextureFilterMode__enumvalues = {
    0: 'hipFilterModePoint',
    1: 'hipFilterModeLinear',
}
hipFilterModePoint = 0
hipFilterModeLinear = 1
hipTextureFilterMode = ctypes.c_uint32 # enum
struct_textureReference._pack_ = 1 # source:False
struct_textureReference._fields_ = [
    ('normalized', ctypes.c_int32),
    ('readMode', hipTextureReadMode),
    ('filterMode', hipTextureFilterMode),
    ('addressMode', hipTextureAddressMode * 3),
    ('channelDesc', struct_hipChannelFormatDesc),
    ('sRGB', ctypes.c_int32),
    ('maxAnisotropy', ctypes.c_uint32),
    ('mipmapFilterMode', hipTextureFilterMode),
    ('mipmapLevelBias', ctypes.c_float),
    ('minMipmapLevelClamp', ctypes.c_float),
    ('maxMipmapLevelClamp', ctypes.c_float),
    ('PADDING_0', ctypes.c_ubyte * 4),
    ('textureObject', ctypes.POINTER(struct___hip_texture)),
    ('numChannels', ctypes.c_int32),
    ('format', hipArray_Format),
]

hipModuleGetTexRef = _libraries['libamdhip64.so'].hipModuleGetTexRef
hipModuleGetTexRef.restype = hipError_t
hipModuleGetTexRef.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_textureReference)), hipModule_t, ctypes.POINTER(ctypes.c_char)]
hipModuleLoadData = _libraries['libamdhip64.so'].hipModuleLoadData
hipModuleLoadData.restype = hipError_t
hipModuleLoadData.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModule_t)), ctypes.POINTER(None)]
hipModuleLoadDataEx = _libraries['libamdhip64.so'].hipModuleLoadDataEx
hipModuleLoadDataEx.restype = hipError_t
hipModuleLoadDataEx.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModule_t)), ctypes.POINTER(None), ctypes.c_uint32, ctypes.POINTER(hipJitOption), ctypes.POINTER(ctypes.POINTER(None))]
hipModuleLaunchKernel = _libraries['libamdhip64.so'].hipModuleLaunchKernel
hipModuleLaunchKernel.restype = hipError_t
hipModuleLaunchKernel.argtypes = [hipFunction_t, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, hipStream_t, ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.POINTER(None))]
hipModuleLaunchCooperativeKernel = _libraries['libamdhip64.so'].hipModuleLaunchCooperativeKernel
hipModuleLaunchCooperativeKernel.restype = hipError_t
hipModuleLaunchCooperativeKernel.argtypes = [hipFunction_t, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, hipStream_t, ctypes.POINTER(ctypes.POINTER(None))]
hipModuleLaunchCooperativeKernelMultiDevice = _libraries['libamdhip64.so'].hipModuleLaunchCooperativeKernelMultiDevice
hipModuleLaunchCooperativeKernelMultiDevice.restype = hipError_t
hipModuleLaunchCooperativeKernelMultiDevice.argtypes = [ctypes.POINTER(struct_hipFunctionLaunchParams_t), ctypes.c_uint32, ctypes.c_uint32]
hipLaunchCooperativeKernel = _libraries['libamdhip64.so'].hipLaunchCooperativeKernel
hipLaunchCooperativeKernel.restype = hipError_t
hipLaunchCooperativeKernel.argtypes = [ctypes.POINTER(None), dim3, dim3, ctypes.POINTER(ctypes.POINTER(None)), ctypes.c_uint32, hipStream_t]
hipLaunchCooperativeKernelMultiDevice = _libraries['libamdhip64.so'].hipLaunchCooperativeKernelMultiDevice
hipLaunchCooperativeKernelMultiDevice.restype = hipError_t
hipLaunchCooperativeKernelMultiDevice.argtypes = [ctypes.POINTER(struct_hipLaunchParams_t), ctypes.c_int32, ctypes.c_uint32]
hipExtLaunchMultiKernelMultiDevice = _libraries['libamdhip64.so'].hipExtLaunchMultiKernelMultiDevice
hipExtLaunchMultiKernelMultiDevice.restype = hipError_t
hipExtLaunchMultiKernelMultiDevice.argtypes = [ctypes.POINTER(struct_hipLaunchParams_t), ctypes.c_int32, ctypes.c_uint32]
hipModuleOccupancyMaxPotentialBlockSize = _libraries['libamdhip64.so'].hipModuleOccupancyMaxPotentialBlockSize
hipModuleOccupancyMaxPotentialBlockSize.restype = hipError_t
hipModuleOccupancyMaxPotentialBlockSize.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), hipFunction_t, size_t, ctypes.c_int32]
hipModuleOccupancyMaxPotentialBlockSizeWithFlags = _libraries['libamdhip64.so'].hipModuleOccupancyMaxPotentialBlockSizeWithFlags
hipModuleOccupancyMaxPotentialBlockSizeWithFlags.restype = hipError_t
hipModuleOccupancyMaxPotentialBlockSizeWithFlags.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), hipFunction_t, size_t, ctypes.c_int32, ctypes.c_uint32]
hipModuleOccupancyMaxActiveBlocksPerMultiprocessor = _libraries['libamdhip64.so'].hipModuleOccupancyMaxActiveBlocksPerMultiprocessor
hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.restype = hipError_t
hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.argtypes = [ctypes.POINTER(ctypes.c_int32), hipFunction_t, ctypes.c_int32, size_t]
hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = _libraries['libamdhip64.so'].hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.restype = hipError_t
hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.argtypes = [ctypes.POINTER(ctypes.c_int32), hipFunction_t, ctypes.c_int32, size_t, ctypes.c_uint32]
hipOccupancyMaxActiveBlocksPerMultiprocessor = _libraries['libamdhip64.so'].hipOccupancyMaxActiveBlocksPerMultiprocessor
hipOccupancyMaxActiveBlocksPerMultiprocessor.restype = hipError_t
hipOccupancyMaxActiveBlocksPerMultiprocessor.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(None), ctypes.c_int32, size_t]
hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = _libraries['libamdhip64.so'].hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.restype = hipError_t
hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(None), ctypes.c_int32, size_t, ctypes.c_uint32]
hipOccupancyMaxPotentialBlockSize = _libraries['libamdhip64.so'].hipOccupancyMaxPotentialBlockSize
hipOccupancyMaxPotentialBlockSize.restype = hipError_t
hipOccupancyMaxPotentialBlockSize.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(None), size_t, ctypes.c_int32]
hipProfilerStart = _libraries['libamdhip64.so'].hipProfilerStart
hipProfilerStart.restype = hipError_t
hipProfilerStart.argtypes = []
hipProfilerStop = _libraries['libamdhip64.so'].hipProfilerStop
hipProfilerStop.restype = hipError_t
hipProfilerStop.argtypes = []
hipConfigureCall = _libraries['libamdhip64.so'].hipConfigureCall
hipConfigureCall.restype = hipError_t
hipConfigureCall.argtypes = [dim3, dim3, size_t, hipStream_t]
hipSetupArgument = _libraries['libamdhip64.so'].hipSetupArgument
hipSetupArgument.restype = hipError_t
hipSetupArgument.argtypes = [ctypes.POINTER(None), size_t, size_t]
hipLaunchByPtr = _libraries['libamdhip64.so'].hipLaunchByPtr
hipLaunchByPtr.restype = hipError_t
hipLaunchByPtr.argtypes = [ctypes.POINTER(None)]
__hipPushCallConfiguration = _libraries['libamdhip64.so'].__hipPushCallConfiguration
__hipPushCallConfiguration.restype = hipError_t
__hipPushCallConfiguration.argtypes = [dim3, dim3, size_t, hipStream_t]
__hipPopCallConfiguration = _libraries['libamdhip64.so'].__hipPopCallConfiguration
__hipPopCallConfiguration.restype = hipError_t
__hipPopCallConfiguration.argtypes = [ctypes.POINTER(struct_dim3), ctypes.POINTER(struct_dim3), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t))]
hipLaunchKernel = _libraries['libamdhip64.so'].hipLaunchKernel
hipLaunchKernel.restype = hipError_t
hipLaunchKernel.argtypes = [ctypes.POINTER(None), dim3, dim3, ctypes.POINTER(ctypes.POINTER(None)), size_t, hipStream_t]
hipLaunchHostFunc = _libraries['libamdhip64.so'].hipLaunchHostFunc
hipLaunchHostFunc.restype = hipError_t
hipLaunchHostFunc.argtypes = [hipStream_t, hipHostFn_t, ctypes.POINTER(None)]
hipDrvMemcpy2DUnaligned = _libraries['libamdhip64.so'].hipDrvMemcpy2DUnaligned
hipDrvMemcpy2DUnaligned.restype = hipError_t
hipDrvMemcpy2DUnaligned.argtypes = [ctypes.POINTER(struct_hip_Memcpy2D)]
hipExtLaunchKernel = _libraries['libamdhip64.so'].hipExtLaunchKernel
hipExtLaunchKernel.restype = hipError_t
hipExtLaunchKernel.argtypes = [ctypes.POINTER(None), dim3, dim3, ctypes.POINTER(ctypes.POINTER(None)), size_t, hipStream_t, hipEvent_t, hipEvent_t, ctypes.c_int32]
class struct_hipTextureDesc(Structure):
    pass

struct_hipTextureDesc._pack_ = 1 # source:False
struct_hipTextureDesc._fields_ = [
    ('addressMode', hipTextureAddressMode * 3),
    ('filterMode', hipTextureFilterMode),
    ('readMode', hipTextureReadMode),
    ('sRGB', ctypes.c_int32),
    ('borderColor', ctypes.c_float * 4),
    ('normalizedCoords', ctypes.c_int32),
    ('maxAnisotropy', ctypes.c_uint32),
    ('mipmapFilterMode', hipTextureFilterMode),
    ('mipmapLevelBias', ctypes.c_float),
    ('minMipmapLevelClamp', ctypes.c_float),
    ('maxMipmapLevelClamp', ctypes.c_float),
]

hipCreateTextureObject = _libraries['libamdhip64.so'].hipCreateTextureObject
hipCreateTextureObject.restype = hipError_t
hipCreateTextureObject.argtypes = [ctypes.POINTER(ctypes.POINTER(struct___hip_texture)), ctypes.POINTER(struct_hipResourceDesc), ctypes.POINTER(struct_hipTextureDesc), ctypes.POINTER(struct_hipResourceViewDesc)]
hipTextureObject_t = ctypes.POINTER(struct___hip_texture)
hipDestroyTextureObject = _libraries['libamdhip64.so'].hipDestroyTextureObject
hipDestroyTextureObject.restype = hipError_t
hipDestroyTextureObject.argtypes = [hipTextureObject_t]
hipGetChannelDesc = _libraries['libamdhip64.so'].hipGetChannelDesc
hipGetChannelDesc.restype = hipError_t
hipGetChannelDesc.argtypes = [ctypes.POINTER(struct_hipChannelFormatDesc), hipArray_const_t]
hipGetTextureObjectResourceDesc = _libraries['libamdhip64.so'].hipGetTextureObjectResourceDesc
hipGetTextureObjectResourceDesc.restype = hipError_t
hipGetTextureObjectResourceDesc.argtypes = [ctypes.POINTER(struct_hipResourceDesc), hipTextureObject_t]
hipGetTextureObjectResourceViewDesc = _libraries['libamdhip64.so'].hipGetTextureObjectResourceViewDesc
hipGetTextureObjectResourceViewDesc.restype = hipError_t
hipGetTextureObjectResourceViewDesc.argtypes = [ctypes.POINTER(struct_hipResourceViewDesc), hipTextureObject_t]
hipGetTextureObjectTextureDesc = _libraries['libamdhip64.so'].hipGetTextureObjectTextureDesc
hipGetTextureObjectTextureDesc.restype = hipError_t
hipGetTextureObjectTextureDesc.argtypes = [ctypes.POINTER(struct_hipTextureDesc), hipTextureObject_t]
hipTexObjectCreate = _libraries['libamdhip64.so'].hipTexObjectCreate
hipTexObjectCreate.restype = hipError_t
hipTexObjectCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct___hip_texture)), ctypes.POINTER(struct_HIP_RESOURCE_DESC_st), ctypes.POINTER(struct_HIP_TEXTURE_DESC_st), ctypes.POINTER(struct_HIP_RESOURCE_VIEW_DESC_st)]
hipTexObjectDestroy = _libraries['libamdhip64.so'].hipTexObjectDestroy
hipTexObjectDestroy.restype = hipError_t
hipTexObjectDestroy.argtypes = [hipTextureObject_t]
hipTexObjectGetResourceDesc = _libraries['libamdhip64.so'].hipTexObjectGetResourceDesc
hipTexObjectGetResourceDesc.restype = hipError_t
hipTexObjectGetResourceDesc.argtypes = [ctypes.POINTER(struct_HIP_RESOURCE_DESC_st), hipTextureObject_t]
hipTexObjectGetResourceViewDesc = _libraries['libamdhip64.so'].hipTexObjectGetResourceViewDesc
hipTexObjectGetResourceViewDesc.restype = hipError_t
hipTexObjectGetResourceViewDesc.argtypes = [ctypes.POINTER(struct_HIP_RESOURCE_VIEW_DESC_st), hipTextureObject_t]
hipTexObjectGetTextureDesc = _libraries['libamdhip64.so'].hipTexObjectGetTextureDesc
hipTexObjectGetTextureDesc.restype = hipError_t
hipTexObjectGetTextureDesc.argtypes = [ctypes.POINTER(struct_HIP_TEXTURE_DESC_st), hipTextureObject_t]
hipMallocMipmappedArray = _libraries['libamdhip64.so'].hipMallocMipmappedArray
hipMallocMipmappedArray.restype = hipError_t
hipMallocMipmappedArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipMipmappedArray)), ctypes.POINTER(struct_hipChannelFormatDesc), struct_hipExtent, ctypes.c_uint32, ctypes.c_uint32]
hipFreeMipmappedArray = _libraries['libamdhip64.so'].hipFreeMipmappedArray
hipFreeMipmappedArray.restype = hipError_t
hipFreeMipmappedArray.argtypes = [hipMipmappedArray_t]
hipGetMipmappedArrayLevel = _libraries['libamdhip64.so'].hipGetMipmappedArrayLevel
hipGetMipmappedArrayLevel.restype = hipError_t
hipGetMipmappedArrayLevel.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), hipMipmappedArray_const_t, ctypes.c_uint32]
hipMipmappedArrayCreate = _libraries['libamdhip64.so'].hipMipmappedArrayCreate
hipMipmappedArrayCreate.restype = hipError_t
hipMipmappedArrayCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipMipmappedArray)), ctypes.POINTER(struct_HIP_ARRAY3D_DESCRIPTOR), ctypes.c_uint32]
hipMipmappedArrayDestroy = _libraries['libamdhip64.so'].hipMipmappedArrayDestroy
hipMipmappedArrayDestroy.restype = hipError_t
hipMipmappedArrayDestroy.argtypes = [hipMipmappedArray_t]
hipMipmappedArrayGetLevel = _libraries['libamdhip64.so'].hipMipmappedArrayGetLevel
hipMipmappedArrayGetLevel.restype = hipError_t
hipMipmappedArrayGetLevel.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), hipMipmappedArray_t, ctypes.c_uint32]
hipBindTextureToMipmappedArray = _libraries['libamdhip64.so'].hipBindTextureToMipmappedArray
hipBindTextureToMipmappedArray.restype = hipError_t
hipBindTextureToMipmappedArray.argtypes = [ctypes.POINTER(struct_textureReference), hipMipmappedArray_const_t, ctypes.POINTER(struct_hipChannelFormatDesc)]
hipGetTextureReference = _libraries['libamdhip64.so'].hipGetTextureReference
hipGetTextureReference.restype = hipError_t
hipGetTextureReference.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_textureReference)), ctypes.POINTER(None)]
hipTexRefSetAddressMode = _libraries['libamdhip64.so'].hipTexRefSetAddressMode
hipTexRefSetAddressMode.restype = hipError_t
hipTexRefSetAddressMode.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_int32, hipTextureAddressMode]
hipTexRefSetArray = _libraries['libamdhip64.so'].hipTexRefSetArray
hipTexRefSetArray.restype = hipError_t
hipTexRefSetArray.argtypes = [ctypes.POINTER(struct_textureReference), hipArray_const_t, ctypes.c_uint32]
hipTexRefSetFilterMode = _libraries['libamdhip64.so'].hipTexRefSetFilterMode
hipTexRefSetFilterMode.restype = hipError_t
hipTexRefSetFilterMode.argtypes = [ctypes.POINTER(struct_textureReference), hipTextureFilterMode]
hipTexRefSetFlags = _libraries['libamdhip64.so'].hipTexRefSetFlags
hipTexRefSetFlags.restype = hipError_t
hipTexRefSetFlags.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_uint32]
hipTexRefSetFormat = _libraries['libamdhip64.so'].hipTexRefSetFormat
hipTexRefSetFormat.restype = hipError_t
hipTexRefSetFormat.argtypes = [ctypes.POINTER(struct_textureReference), hipArray_Format, ctypes.c_int32]
hipBindTexture = _libraries['libamdhip64.so'].hipBindTexture
hipBindTexture.restype = hipError_t
hipBindTexture.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference), ctypes.POINTER(None), ctypes.POINTER(struct_hipChannelFormatDesc), size_t]
hipBindTexture2D = _libraries['libamdhip64.so'].hipBindTexture2D
hipBindTexture2D.restype = hipError_t
hipBindTexture2D.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference), ctypes.POINTER(None), ctypes.POINTER(struct_hipChannelFormatDesc), size_t, size_t, size_t]
hipBindTextureToArray = _libraries['libamdhip64.so'].hipBindTextureToArray
hipBindTextureToArray.restype = hipError_t
hipBindTextureToArray.argtypes = [ctypes.POINTER(struct_textureReference), hipArray_const_t, ctypes.POINTER(struct_hipChannelFormatDesc)]
hipGetTextureAlignmentOffset = _libraries['libamdhip64.so'].hipGetTextureAlignmentOffset
hipGetTextureAlignmentOffset.restype = hipError_t
hipGetTextureAlignmentOffset.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference)]
hipUnbindTexture = _libraries['libamdhip64.so'].hipUnbindTexture
hipUnbindTexture.restype = hipError_t
hipUnbindTexture.argtypes = [ctypes.POINTER(struct_textureReference)]
hipTexRefGetAddress = _libraries['libamdhip64.so'].hipTexRefGetAddress
hipTexRefGetAddress.restype = hipError_t
hipTexRefGetAddress.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_textureReference)]
hipTexRefGetAddressMode = _libraries['libamdhip64.so'].hipTexRefGetAddressMode
hipTexRefGetAddressMode.restype = hipError_t
hipTexRefGetAddressMode.argtypes = [ctypes.POINTER(hipTextureAddressMode), ctypes.POINTER(struct_textureReference), ctypes.c_int32]
hipTexRefGetFilterMode = _libraries['libamdhip64.so'].hipTexRefGetFilterMode
hipTexRefGetFilterMode.restype = hipError_t
hipTexRefGetFilterMode.argtypes = [ctypes.POINTER(hipTextureFilterMode), ctypes.POINTER(struct_textureReference)]
hipTexRefGetFlags = _libraries['libamdhip64.so'].hipTexRefGetFlags
hipTexRefGetFlags.restype = hipError_t
hipTexRefGetFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(struct_textureReference)]
hipTexRefGetFormat = _libraries['libamdhip64.so'].hipTexRefGetFormat
hipTexRefGetFormat.restype = hipError_t
hipTexRefGetFormat.argtypes = [ctypes.POINTER(hipArray_Format), ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMaxAnisotropy = _libraries['libamdhip64.so'].hipTexRefGetMaxAnisotropy
hipTexRefGetMaxAnisotropy.restype = hipError_t
hipTexRefGetMaxAnisotropy.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipmapFilterMode = _libraries['libamdhip64.so'].hipTexRefGetMipmapFilterMode
hipTexRefGetMipmapFilterMode.restype = hipError_t
hipTexRefGetMipmapFilterMode.argtypes = [ctypes.POINTER(hipTextureFilterMode), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipmapLevelBias = _libraries['libamdhip64.so'].hipTexRefGetMipmapLevelBias
hipTexRefGetMipmapLevelBias.restype = hipError_t
hipTexRefGetMipmapLevelBias.argtypes = [ctypes.POINTER(ctypes.c_float), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipmapLevelClamp = _libraries['libamdhip64.so'].hipTexRefGetMipmapLevelClamp
hipTexRefGetMipmapLevelClamp.restype = hipError_t
hipTexRefGetMipmapLevelClamp.argtypes = [ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipMappedArray = _libraries['FIXME_STUB'].hipTexRefGetMipMappedArray
hipTexRefGetMipMappedArray.restype = hipError_t
hipTexRefGetMipMappedArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipMipmappedArray)), ctypes.POINTER(struct_textureReference)]
hipTexRefSetAddress = _libraries['libamdhip64.so'].hipTexRefSetAddress
hipTexRefSetAddress.restype = hipError_t
hipTexRefSetAddress.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference), hipDeviceptr_t, size_t]
hipTexRefSetAddress2D = _libraries['libamdhip64.so'].hipTexRefSetAddress2D
hipTexRefSetAddress2D.restype = hipError_t
hipTexRefSetAddress2D.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.POINTER(struct_HIP_ARRAY_DESCRIPTOR), hipDeviceptr_t, size_t]
hipTexRefSetMaxAnisotropy = _libraries['libamdhip64.so'].hipTexRefSetMaxAnisotropy
hipTexRefSetMaxAnisotropy.restype = hipError_t
hipTexRefSetMaxAnisotropy.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_uint32]
hipTexRefSetBorderColor = _libraries['libamdhip64.so'].hipTexRefSetBorderColor
hipTexRefSetBorderColor.restype = hipError_t
hipTexRefSetBorderColor.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.POINTER(ctypes.c_float)]
hipTexRefSetMipmapFilterMode = _libraries['libamdhip64.so'].hipTexRefSetMipmapFilterMode
hipTexRefSetMipmapFilterMode.restype = hipError_t
hipTexRefSetMipmapFilterMode.argtypes = [ctypes.POINTER(struct_textureReference), hipTextureFilterMode]
hipTexRefSetMipmapLevelBias = _libraries['libamdhip64.so'].hipTexRefSetMipmapLevelBias
hipTexRefSetMipmapLevelBias.restype = hipError_t
hipTexRefSetMipmapLevelBias.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_float]
hipTexRefSetMipmapLevelClamp = _libraries['libamdhip64.so'].hipTexRefSetMipmapLevelClamp
hipTexRefSetMipmapLevelClamp.restype = hipError_t
hipTexRefSetMipmapLevelClamp.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_float, ctypes.c_float]
hipTexRefSetMipmappedArray = _libraries['libamdhip64.so'].hipTexRefSetMipmappedArray
hipTexRefSetMipmappedArray.restype = hipError_t
hipTexRefSetMipmappedArray.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.POINTER(struct_hipMipmappedArray), ctypes.c_uint32]
hipApiName = _libraries['libamdhip64.so'].hipApiName
hipApiName.restype = ctypes.POINTER(ctypes.c_char)
hipApiName.argtypes = [uint32_t]
hipKernelNameRef = _libraries['libamdhip64.so'].hipKernelNameRef
hipKernelNameRef.restype = ctypes.POINTER(ctypes.c_char)
hipKernelNameRef.argtypes = [hipFunction_t]
hipKernelNameRefByPtr = _libraries['libamdhip64.so'].hipKernelNameRefByPtr
hipKernelNameRefByPtr.restype = ctypes.POINTER(ctypes.c_char)
hipKernelNameRefByPtr.argtypes = [ctypes.POINTER(None), hipStream_t]
hipGetStreamDeviceId = _libraries['libamdhip64.so'].hipGetStreamDeviceId
hipGetStreamDeviceId.restype = ctypes.c_int32
hipGetStreamDeviceId.argtypes = [hipStream_t]
hipStreamBeginCapture = _libraries['libamdhip64.so'].hipStreamBeginCapture
hipStreamBeginCapture.restype = hipError_t
hipStreamBeginCapture.argtypes = [hipStream_t, hipStreamCaptureMode]
hipStreamEndCapture = _libraries['libamdhip64.so'].hipStreamEndCapture
hipStreamEndCapture.restype = hipError_t
hipStreamEndCapture.argtypes = [hipStream_t, ctypes.POINTER(ctypes.POINTER(struct_ihipGraph))]
hipStreamGetCaptureInfo = _libraries['libamdhip64.so'].hipStreamGetCaptureInfo
hipStreamGetCaptureInfo.restype = hipError_t
hipStreamGetCaptureInfo.argtypes = [hipStream_t, ctypes.POINTER(hipStreamCaptureStatus), ctypes.POINTER(ctypes.c_uint64)]
hipStreamGetCaptureInfo_v2 = _libraries['libamdhip64.so'].hipStreamGetCaptureInfo_v2
hipStreamGetCaptureInfo_v2.restype = hipError_t
hipStreamGetCaptureInfo_v2.argtypes = [hipStream_t, ctypes.POINTER(hipStreamCaptureStatus), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.POINTER(struct_ihipGraph)), ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode))), ctypes.POINTER(ctypes.c_uint64)]
hipStreamIsCapturing = _libraries['libamdhip64.so'].hipStreamIsCapturing
hipStreamIsCapturing.restype = hipError_t
hipStreamIsCapturing.argtypes = [hipStream_t, ctypes.POINTER(hipStreamCaptureStatus)]
hipStreamUpdateCaptureDependencies = _libraries['libamdhip64.so'].hipStreamUpdateCaptureDependencies
hipStreamUpdateCaptureDependencies.restype = hipError_t
hipStreamUpdateCaptureDependencies.argtypes = [hipStream_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.c_uint32]
hipThreadExchangeStreamCaptureMode = _libraries['libamdhip64.so'].hipThreadExchangeStreamCaptureMode
hipThreadExchangeStreamCaptureMode.restype = hipError_t
hipThreadExchangeStreamCaptureMode.argtypes = [ctypes.POINTER(hipStreamCaptureMode)]
hipGraphCreate = _libraries['libamdhip64.so'].hipGraphCreate
hipGraphCreate.restype = hipError_t
hipGraphCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipGraph)), ctypes.c_uint32]
hipGraphDestroy = _libraries['libamdhip64.so'].hipGraphDestroy
hipGraphDestroy.restype = hipError_t
hipGraphDestroy.argtypes = [hipGraph_t]
hipGraphAddDependencies = _libraries['libamdhip64.so'].hipGraphAddDependencies
hipGraphAddDependencies.restype = hipError_t
hipGraphAddDependencies.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t]
hipGraphRemoveDependencies = _libraries['libamdhip64.so'].hipGraphRemoveDependencies
hipGraphRemoveDependencies.restype = hipError_t
hipGraphRemoveDependencies.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t]
hipGraphGetEdges = _libraries['libamdhip64.so'].hipGraphGetEdges
hipGraphGetEdges.restype = hipError_t
hipGraphGetEdges.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphGetNodes = _libraries['libamdhip64.so'].hipGraphGetNodes
hipGraphGetNodes.restype = hipError_t
hipGraphGetNodes.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphGetRootNodes = _libraries['libamdhip64.so'].hipGraphGetRootNodes
hipGraphGetRootNodes.restype = hipError_t
hipGraphGetRootNodes.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphNodeGetDependencies = _libraries['libamdhip64.so'].hipGraphNodeGetDependencies
hipGraphNodeGetDependencies.restype = hipError_t
hipGraphNodeGetDependencies.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphNodeGetDependentNodes = _libraries['libamdhip64.so'].hipGraphNodeGetDependentNodes
hipGraphNodeGetDependentNodes.restype = hipError_t
hipGraphNodeGetDependentNodes.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphNodeGetType = _libraries['libamdhip64.so'].hipGraphNodeGetType
hipGraphNodeGetType.restype = hipError_t
hipGraphNodeGetType.argtypes = [hipGraphNode_t, ctypes.POINTER(hipGraphNodeType)]
hipGraphDestroyNode = _libraries['libamdhip64.so'].hipGraphDestroyNode
hipGraphDestroyNode.restype = hipError_t
hipGraphDestroyNode.argtypes = [hipGraphNode_t]
hipGraphClone = _libraries['libamdhip64.so'].hipGraphClone
hipGraphClone.restype = hipError_t
hipGraphClone.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipGraph)), hipGraph_t]
hipGraphNodeFindInClone = _libraries['libamdhip64.so'].hipGraphNodeFindInClone
hipGraphNodeFindInClone.restype = hipError_t
hipGraphNodeFindInClone.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraphNode_t, hipGraph_t]
hipGraphInstantiate = _libraries['libamdhip64.so'].hipGraphInstantiate
hipGraphInstantiate.restype = hipError_t
hipGraphInstantiate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphExec)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_char), size_t]
hipGraphInstantiateWithFlags = _libraries['libamdhip64.so'].hipGraphInstantiateWithFlags
hipGraphInstantiateWithFlags.restype = hipError_t
hipGraphInstantiateWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphExec)), hipGraph_t, ctypes.c_uint64]
hipGraphLaunch = _libraries['libamdhip64.so'].hipGraphLaunch
hipGraphLaunch.restype = hipError_t
hipGraphLaunch.argtypes = [hipGraphExec_t, hipStream_t]
hipGraphUpload = _libraries['libamdhip64.so'].hipGraphUpload
hipGraphUpload.restype = hipError_t
hipGraphUpload.argtypes = [hipGraphExec_t, hipStream_t]
hipGraphExecDestroy = _libraries['libamdhip64.so'].hipGraphExecDestroy
hipGraphExecDestroy.restype = hipError_t
hipGraphExecDestroy.argtypes = [hipGraphExec_t]
hipGraphExecUpdate = _libraries['libamdhip64.so'].hipGraphExecUpdate
hipGraphExecUpdate.restype = hipError_t
hipGraphExecUpdate.argtypes = [hipGraphExec_t, hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(hipGraphExecUpdateResult)]
hipGraphAddKernelNode = _libraries['libamdhip64.so'].hipGraphAddKernelNode
hipGraphAddKernelNode.restype = hipError_t
hipGraphAddKernelNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphKernelNodeGetParams = _libraries['libamdhip64.so'].hipGraphKernelNodeGetParams
hipGraphKernelNodeGetParams.restype = hipError_t
hipGraphKernelNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphKernelNodeSetParams = _libraries['libamdhip64.so'].hipGraphKernelNodeSetParams
hipGraphKernelNodeSetParams.restype = hipError_t
hipGraphKernelNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphExecKernelNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecKernelNodeSetParams
hipGraphExecKernelNodeSetParams.restype = hipError_t
hipGraphExecKernelNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphAddMemcpyNode = _libraries['libamdhip64.so'].hipGraphAddMemcpyNode
hipGraphAddMemcpyNode.restype = hipError_t
hipGraphAddMemcpyNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphMemcpyNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemcpyNodeGetParams
hipGraphMemcpyNodeGetParams.restype = hipError_t
hipGraphMemcpyNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphMemcpyNodeSetParams = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParams
hipGraphMemcpyNodeSetParams.restype = hipError_t
hipGraphMemcpyNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphKernelNodeSetAttribute = _libraries['libamdhip64.so'].hipGraphKernelNodeSetAttribute
hipGraphKernelNodeSetAttribute.restype = hipError_t
hipGraphKernelNodeSetAttribute.argtypes = [hipGraphNode_t, hipKernelNodeAttrID, ctypes.POINTER(union_hipKernelNodeAttrValue)]
hipGraphKernelNodeGetAttribute = _libraries['libamdhip64.so'].hipGraphKernelNodeGetAttribute
hipGraphKernelNodeGetAttribute.restype = hipError_t
hipGraphKernelNodeGetAttribute.argtypes = [hipGraphNode_t, hipKernelNodeAttrID, ctypes.POINTER(union_hipKernelNodeAttrValue)]
hipGraphExecMemcpyNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParams
hipGraphExecMemcpyNodeSetParams.restype = hipError_t
hipGraphExecMemcpyNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphAddMemcpyNode1D = _libraries['libamdhip64.so'].hipGraphAddMemcpyNode1D
hipGraphAddMemcpyNode1D.restype = hipError_t
hipGraphAddMemcpyNode1D.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipGraphMemcpyNodeSetParams1D = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParams1D
hipGraphMemcpyNodeSetParams1D.restype = hipError_t
hipGraphMemcpyNodeSetParams1D.argtypes = [hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipGraphExecMemcpyNodeSetParams1D = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParams1D
hipGraphExecMemcpyNodeSetParams1D.restype = hipError_t
hipGraphExecMemcpyNodeSetParams1D.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipGraphAddMemcpyNodeFromSymbol = _libraries['libamdhip64.so'].hipGraphAddMemcpyNodeFromSymbol
hipGraphAddMemcpyNodeFromSymbol.restype = hipError_t
hipGraphAddMemcpyNodeFromSymbol.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphMemcpyNodeSetParamsFromSymbol = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParamsFromSymbol
hipGraphMemcpyNodeSetParamsFromSymbol.restype = hipError_t
hipGraphMemcpyNodeSetParamsFromSymbol.argtypes = [hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphExecMemcpyNodeSetParamsFromSymbol = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParamsFromSymbol
hipGraphExecMemcpyNodeSetParamsFromSymbol.restype = hipError_t
hipGraphExecMemcpyNodeSetParamsFromSymbol.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphAddMemcpyNodeToSymbol = _libraries['libamdhip64.so'].hipGraphAddMemcpyNodeToSymbol
hipGraphAddMemcpyNodeToSymbol.restype = hipError_t
hipGraphAddMemcpyNodeToSymbol.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphMemcpyNodeSetParamsToSymbol = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParamsToSymbol
hipGraphMemcpyNodeSetParamsToSymbol.restype = hipError_t
hipGraphMemcpyNodeSetParamsToSymbol.argtypes = [hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphExecMemcpyNodeSetParamsToSymbol = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParamsToSymbol
hipGraphExecMemcpyNodeSetParamsToSymbol.restype = hipError_t
hipGraphExecMemcpyNodeSetParamsToSymbol.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphAddMemsetNode = _libraries['libamdhip64.so'].hipGraphAddMemsetNode
hipGraphAddMemsetNode.restype = hipError_t
hipGraphAddMemsetNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphMemsetNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemsetNodeGetParams
hipGraphMemsetNodeGetParams.restype = hipError_t
hipGraphMemsetNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphMemsetNodeSetParams = _libraries['libamdhip64.so'].hipGraphMemsetNodeSetParams
hipGraphMemsetNodeSetParams.restype = hipError_t
hipGraphMemsetNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphExecMemsetNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecMemsetNodeSetParams
hipGraphExecMemsetNodeSetParams.restype = hipError_t
hipGraphExecMemsetNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphAddHostNode = _libraries['libamdhip64.so'].hipGraphAddHostNode
hipGraphAddHostNode.restype = hipError_t
hipGraphAddHostNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphHostNodeGetParams = _libraries['libamdhip64.so'].hipGraphHostNodeGetParams
hipGraphHostNodeGetParams.restype = hipError_t
hipGraphHostNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphHostNodeSetParams = _libraries['libamdhip64.so'].hipGraphHostNodeSetParams
hipGraphHostNodeSetParams.restype = hipError_t
hipGraphHostNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphExecHostNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecHostNodeSetParams
hipGraphExecHostNodeSetParams.restype = hipError_t
hipGraphExecHostNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphAddChildGraphNode = _libraries['libamdhip64.so'].hipGraphAddChildGraphNode
hipGraphAddChildGraphNode.restype = hipError_t
hipGraphAddChildGraphNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, hipGraph_t]
hipGraphChildGraphNodeGetGraph = _libraries['libamdhip64.so'].hipGraphChildGraphNodeGetGraph
hipGraphChildGraphNodeGetGraph.restype = hipError_t
hipGraphChildGraphNodeGetGraph.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_ihipGraph))]
hipGraphExecChildGraphNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecChildGraphNodeSetParams
hipGraphExecChildGraphNodeSetParams.restype = hipError_t
hipGraphExecChildGraphNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, hipGraph_t]
hipGraphAddEmptyNode = _libraries['libamdhip64.so'].hipGraphAddEmptyNode
hipGraphAddEmptyNode.restype = hipError_t
hipGraphAddEmptyNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t]
hipGraphAddEventRecordNode = _libraries['libamdhip64.so'].hipGraphAddEventRecordNode
hipGraphAddEventRecordNode.restype = hipError_t
hipGraphAddEventRecordNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, hipEvent_t]
hipGraphEventRecordNodeGetEvent = _libraries['libamdhip64.so'].hipGraphEventRecordNodeGetEvent
hipGraphEventRecordNodeGetEvent.restype = hipError_t
hipGraphEventRecordNodeGetEvent.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t))]
hipGraphEventRecordNodeSetEvent = _libraries['libamdhip64.so'].hipGraphEventRecordNodeSetEvent
hipGraphEventRecordNodeSetEvent.restype = hipError_t
hipGraphEventRecordNodeSetEvent.argtypes = [hipGraphNode_t, hipEvent_t]
hipGraphExecEventRecordNodeSetEvent = _libraries['libamdhip64.so'].hipGraphExecEventRecordNodeSetEvent
hipGraphExecEventRecordNodeSetEvent.restype = hipError_t
hipGraphExecEventRecordNodeSetEvent.argtypes = [hipGraphExec_t, hipGraphNode_t, hipEvent_t]
hipGraphAddEventWaitNode = _libraries['libamdhip64.so'].hipGraphAddEventWaitNode
hipGraphAddEventWaitNode.restype = hipError_t
hipGraphAddEventWaitNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, hipEvent_t]
hipGraphEventWaitNodeGetEvent = _libraries['libamdhip64.so'].hipGraphEventWaitNodeGetEvent
hipGraphEventWaitNodeGetEvent.restype = hipError_t
hipGraphEventWaitNodeGetEvent.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t))]
hipGraphEventWaitNodeSetEvent = _libraries['libamdhip64.so'].hipGraphEventWaitNodeSetEvent
hipGraphEventWaitNodeSetEvent.restype = hipError_t
hipGraphEventWaitNodeSetEvent.argtypes = [hipGraphNode_t, hipEvent_t]
hipGraphExecEventWaitNodeSetEvent = _libraries['libamdhip64.so'].hipGraphExecEventWaitNodeSetEvent
hipGraphExecEventWaitNodeSetEvent.restype = hipError_t
hipGraphExecEventWaitNodeSetEvent.argtypes = [hipGraphExec_t, hipGraphNode_t, hipEvent_t]
hipGraphAddMemAllocNode = _libraries['libamdhip64.so'].hipGraphAddMemAllocNode
hipGraphAddMemAllocNode.restype = hipError_t
hipGraphAddMemAllocNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipMemAllocNodeParams)]
hipGraphMemAllocNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemAllocNodeGetParams
hipGraphMemAllocNodeGetParams.restype = hipError_t
hipGraphMemAllocNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemAllocNodeParams)]
hipGraphAddMemFreeNode = _libraries['libamdhip64.so'].hipGraphAddMemFreeNode
hipGraphAddMemFreeNode.restype = hipError_t
hipGraphAddMemFreeNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None)]
hipGraphMemFreeNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemFreeNodeGetParams
hipGraphMemFreeNodeGetParams.restype = hipError_t
hipGraphMemFreeNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(None)]
hipDeviceGetGraphMemAttribute = _libraries['libamdhip64.so'].hipDeviceGetGraphMemAttribute
hipDeviceGetGraphMemAttribute.restype = hipError_t
hipDeviceGetGraphMemAttribute.argtypes = [ctypes.c_int32, hipGraphMemAttributeType, ctypes.POINTER(None)]
hipDeviceSetGraphMemAttribute = _libraries['libamdhip64.so'].hipDeviceSetGraphMemAttribute
hipDeviceSetGraphMemAttribute.restype = hipError_t
hipDeviceSetGraphMemAttribute.argtypes = [ctypes.c_int32, hipGraphMemAttributeType, ctypes.POINTER(None)]
hipDeviceGraphMemTrim = _libraries['libamdhip64.so'].hipDeviceGraphMemTrim
hipDeviceGraphMemTrim.restype = hipError_t
hipDeviceGraphMemTrim.argtypes = [ctypes.c_int32]
hipUserObjectCreate = _libraries['libamdhip64.so'].hipUserObjectCreate
hipUserObjectCreate.restype = hipError_t
hipUserObjectCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipUserObject)), ctypes.POINTER(None), hipHostFn_t, ctypes.c_uint32, ctypes.c_uint32]
hipUserObjectRelease = _libraries['libamdhip64.so'].hipUserObjectRelease
hipUserObjectRelease.restype = hipError_t
hipUserObjectRelease.argtypes = [hipUserObject_t, ctypes.c_uint32]
hipUserObjectRetain = _libraries['libamdhip64.so'].hipUserObjectRetain
hipUserObjectRetain.restype = hipError_t
hipUserObjectRetain.argtypes = [hipUserObject_t, ctypes.c_uint32]
hipGraphRetainUserObject = _libraries['libamdhip64.so'].hipGraphRetainUserObject
hipGraphRetainUserObject.restype = hipError_t
hipGraphRetainUserObject.argtypes = [hipGraph_t, hipUserObject_t, ctypes.c_uint32, ctypes.c_uint32]
hipGraphReleaseUserObject = _libraries['libamdhip64.so'].hipGraphReleaseUserObject
hipGraphReleaseUserObject.restype = hipError_t
hipGraphReleaseUserObject.argtypes = [hipGraph_t, hipUserObject_t, ctypes.c_uint32]
hipGraphDebugDotPrint = _libraries['libamdhip64.so'].hipGraphDebugDotPrint
hipGraphDebugDotPrint.restype = hipError_t
hipGraphDebugDotPrint.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.c_char), ctypes.c_uint32]
hipGraphKernelNodeCopyAttributes = _libraries['libamdhip64.so'].hipGraphKernelNodeCopyAttributes
hipGraphKernelNodeCopyAttributes.restype = hipError_t
hipGraphKernelNodeCopyAttributes.argtypes = [hipGraphNode_t, hipGraphNode_t]
hipGraphNodeSetEnabled = _libraries['libamdhip64.so'].hipGraphNodeSetEnabled
hipGraphNodeSetEnabled.restype = hipError_t
hipGraphNodeSetEnabled.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.c_uint32]
hipGraphNodeGetEnabled = _libraries['libamdhip64.so'].hipGraphNodeGetEnabled
hipGraphNodeGetEnabled.restype = hipError_t
hipGraphNodeGetEnabled.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(ctypes.c_uint32)]
hipGraphAddExternalSemaphoresWaitNode = _libraries['FIXME_STUB'].hipGraphAddExternalSemaphoresWaitNode
hipGraphAddExternalSemaphoresWaitNode.restype = hipError_t
hipGraphAddExternalSemaphoresWaitNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipGraphAddExternalSemaphoresSignalNode = _libraries['FIXME_STUB'].hipGraphAddExternalSemaphoresSignalNode
hipGraphAddExternalSemaphoresSignalNode.restype = hipError_t
hipGraphAddExternalSemaphoresSignalNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExternalSemaphoresSignalNodeSetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresSignalNodeSetParams
hipGraphExternalSemaphoresSignalNodeSetParams.restype = hipError_t
hipGraphExternalSemaphoresSignalNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExternalSemaphoresWaitNodeSetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresWaitNodeSetParams
hipGraphExternalSemaphoresWaitNodeSetParams.restype = hipError_t
hipGraphExternalSemaphoresWaitNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipGraphExternalSemaphoresSignalNodeGetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresSignalNodeGetParams
hipGraphExternalSemaphoresSignalNodeGetParams.restype = hipError_t
hipGraphExternalSemaphoresSignalNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExternalSemaphoresWaitNodeGetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresWaitNodeGetParams
hipGraphExternalSemaphoresWaitNodeGetParams.restype = hipError_t
hipGraphExternalSemaphoresWaitNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipGraphExecExternalSemaphoresSignalNodeSetParams = _libraries['FIXME_STUB'].hipGraphExecExternalSemaphoresSignalNodeSetParams
hipGraphExecExternalSemaphoresSignalNodeSetParams.restype = hipError_t
hipGraphExecExternalSemaphoresSignalNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExecExternalSemaphoresWaitNodeSetParams = _libraries['FIXME_STUB'].hipGraphExecExternalSemaphoresWaitNodeSetParams
hipGraphExecExternalSemaphoresWaitNodeSetParams.restype = hipError_t
hipGraphExecExternalSemaphoresWaitNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipMemAddressFree = _libraries['libamdhip64.so'].hipMemAddressFree
hipMemAddressFree.restype = hipError_t
hipMemAddressFree.argtypes = [ctypes.POINTER(None), size_t]
hipMemAddressReserve = _libraries['libamdhip64.so'].hipMemAddressReserve
hipMemAddressReserve.restype = hipError_t
hipMemAddressReserve.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, size_t, ctypes.POINTER(None), ctypes.c_uint64]
hipMemCreate = _libraries['libamdhip64.so'].hipMemCreate
hipMemCreate.restype = hipError_t
hipMemCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemGenericAllocationHandle)), size_t, ctypes.POINTER(struct_hipMemAllocationProp), ctypes.c_uint64]
hipMemExportToShareableHandle = _libraries['libamdhip64.so'].hipMemExportToShareableHandle
hipMemExportToShareableHandle.restype = hipError_t
hipMemExportToShareableHandle.argtypes = [ctypes.POINTER(None), hipMemGenericAllocationHandle_t, hipMemAllocationHandleType, ctypes.c_uint64]
hipMemGetAccess = _libraries['libamdhip64.so'].hipMemGetAccess
hipMemGetAccess.restype = hipError_t
hipMemGetAccess.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_hipMemLocation), ctypes.POINTER(None)]
hipMemGetAllocationGranularity = _libraries['libamdhip64.so'].hipMemGetAllocationGranularity
hipMemGetAllocationGranularity.restype = hipError_t
hipMemGetAllocationGranularity.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_hipMemAllocationProp), hipMemAllocationGranularity_flags]
hipMemGetAllocationPropertiesFromHandle = _libraries['libamdhip64.so'].hipMemGetAllocationPropertiesFromHandle
hipMemGetAllocationPropertiesFromHandle.restype = hipError_t
hipMemGetAllocationPropertiesFromHandle.argtypes = [ctypes.POINTER(struct_hipMemAllocationProp), hipMemGenericAllocationHandle_t]
hipMemImportFromShareableHandle = _libraries['libamdhip64.so'].hipMemImportFromShareableHandle
hipMemImportFromShareableHandle.restype = hipError_t
hipMemImportFromShareableHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemGenericAllocationHandle)), ctypes.POINTER(None), hipMemAllocationHandleType]
hipMemMap = _libraries['libamdhip64.so'].hipMemMap
hipMemMap.restype = hipError_t
hipMemMap.argtypes = [ctypes.POINTER(None), size_t, size_t, hipMemGenericAllocationHandle_t, ctypes.c_uint64]
hipMemMapArrayAsync = _libraries['libamdhip64.so'].hipMemMapArrayAsync
hipMemMapArrayAsync.restype = hipError_t
hipMemMapArrayAsync.argtypes = [ctypes.POINTER(struct_hipArrayMapInfo), ctypes.c_uint32, hipStream_t]
hipMemRelease = _libraries['libamdhip64.so'].hipMemRelease
hipMemRelease.restype = hipError_t
hipMemRelease.argtypes = [hipMemGenericAllocationHandle_t]
hipMemRetainAllocationHandle = _libraries['libamdhip64.so'].hipMemRetainAllocationHandle
hipMemRetainAllocationHandle.restype = hipError_t
hipMemRetainAllocationHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemGenericAllocationHandle)), ctypes.POINTER(None)]
hipMemSetAccess = _libraries['libamdhip64.so'].hipMemSetAccess
hipMemSetAccess.restype = hipError_t
hipMemSetAccess.argtypes = [ctypes.POINTER(None), size_t, ctypes.POINTER(struct_hipMemAccessDesc), size_t]
hipMemUnmap = _libraries['libamdhip64.so'].hipMemUnmap
hipMemUnmap.restype = hipError_t
hipMemUnmap.argtypes = [ctypes.POINTER(None), size_t]
GLuint = ctypes.c_uint32
GLenum = ctypes.c_uint32
hipGLGetDevices = _libraries['libamdhip64.so'].hipGLGetDevices
hipGLGetDevices.restype = hipError_t
hipGLGetDevices.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_int32), ctypes.c_uint32, hipGLDeviceList]
hipGraphicsGLRegisterBuffer = _libraries['libamdhip64.so'].hipGraphicsGLRegisterBuffer
hipGraphicsGLRegisterBuffer.restype = hipError_t
hipGraphicsGLRegisterBuffer.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), GLuint, ctypes.c_uint32]
hipGraphicsGLRegisterImage = _libraries['libamdhip64.so'].hipGraphicsGLRegisterImage
hipGraphicsGLRegisterImage.restype = hipError_t
hipGraphicsGLRegisterImage.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), GLuint, GLenum, ctypes.c_uint32]
hipGraphicsMapResources = _libraries['libamdhip64.so'].hipGraphicsMapResources
hipGraphicsMapResources.restype = hipError_t
hipGraphicsMapResources.argtypes = [ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), hipStream_t]
hipGraphicsSubResourceGetMappedArray = _libraries['libamdhip64.so'].hipGraphicsSubResourceGetMappedArray
hipGraphicsSubResourceGetMappedArray.restype = hipError_t
hipGraphicsSubResourceGetMappedArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), hipGraphicsResource_t, ctypes.c_uint32, ctypes.c_uint32]
hipGraphicsResourceGetMappedPointer = _libraries['libamdhip64.so'].hipGraphicsResourceGetMappedPointer
hipGraphicsResourceGetMappedPointer.restype = hipError_t
hipGraphicsResourceGetMappedPointer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), hipGraphicsResource_t]
hipGraphicsUnmapResources = _libraries['libamdhip64.so'].hipGraphicsUnmapResources
hipGraphicsUnmapResources.restype = hipError_t
hipGraphicsUnmapResources.argtypes = [ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), hipStream_t]
hipGraphicsUnregisterResource = _libraries['libamdhip64.so'].hipGraphicsUnregisterResource
hipGraphicsUnregisterResource.restype = hipError_t
hipGraphicsUnregisterResource.argtypes = [hipGraphicsResource_t]
class struct___hip_surface(Structure):
    pass

hipCreateSurfaceObject = _libraries['libamdhip64.so'].hipCreateSurfaceObject
hipCreateSurfaceObject.restype = hipError_t
hipCreateSurfaceObject.argtypes = [ctypes.POINTER(ctypes.POINTER(struct___hip_surface)), ctypes.POINTER(struct_hipResourceDesc)]
hipSurfaceObject_t = ctypes.POINTER(struct___hip_surface)
hipDestroySurfaceObject = _libraries['libamdhip64.so'].hipDestroySurfaceObject
hipDestroySurfaceObject.restype = hipError_t
hipDestroySurfaceObject.argtypes = [hipSurfaceObject_t]
__all__ = \
    ['GLenum', 'GLuint', 'HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE',
    'HIPRTC_ERROR_COMPILATION', 'HIPRTC_ERROR_INTERNAL_ERROR',
    'HIPRTC_ERROR_INVALID_INPUT', 'HIPRTC_ERROR_INVALID_OPTION',
    'HIPRTC_ERROR_INVALID_PROGRAM', 'HIPRTC_ERROR_LINKING',
    'HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID',
    'HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION',
    'HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION',
    'HIPRTC_ERROR_OUT_OF_MEMORY',
    'HIPRTC_ERROR_PROGRAM_CREATION_FAILURE', 'HIPRTC_JIT_CACHE_MODE',
    'HIPRTC_JIT_ERROR_LOG_BUFFER',
    'HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES',
    'HIPRTC_JIT_FALLBACK_STRATEGY', 'HIPRTC_JIT_FAST_COMPILE',
    'HIPRTC_JIT_FMA', 'HIPRTC_JIT_FTZ',
    'HIPRTC_JIT_GENERATE_DEBUG_INFO', 'HIPRTC_JIT_GENERATE_LINE_INFO',
    'HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS',
    'HIPRTC_JIT_GLOBAL_SYMBOL_COUNT',
    'HIPRTC_JIT_GLOBAL_SYMBOL_NAMES', 'HIPRTC_JIT_INFO_LOG_BUFFER',
    'HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES', 'HIPRTC_JIT_INPUT_CUBIN',
    'HIPRTC_JIT_INPUT_FATBINARY', 'HIPRTC_JIT_INPUT_LIBRARY',
    'HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE',
    'HIPRTC_JIT_INPUT_LLVM_BITCODE',
    'HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE', 'HIPRTC_JIT_INPUT_NVVM',
    'HIPRTC_JIT_INPUT_OBJECT', 'HIPRTC_JIT_INPUT_PTX',
    'HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT',
    'HIPRTC_JIT_IR_TO_ISA_OPT_EXT', 'HIPRTC_JIT_LOG_VERBOSE',
    'HIPRTC_JIT_LTO', 'HIPRTC_JIT_MAX_REGISTERS',
    'HIPRTC_JIT_NEW_SM3X_OPT', 'HIPRTC_JIT_NUM_INPUT_TYPES',
    'HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES', 'HIPRTC_JIT_NUM_OPTIONS',
    'HIPRTC_JIT_OPTIMIZATION_LEVEL', 'HIPRTC_JIT_PREC_DIV',
    'HIPRTC_JIT_PREC_SQRT', 'HIPRTC_JIT_TARGET',
    'HIPRTC_JIT_TARGET_FROM_HIPCONTEXT',
    'HIPRTC_JIT_THREADS_PER_BLOCK', 'HIPRTC_JIT_WALL_TIME',
    'HIPRTC_SUCCESS', 'HIP_AD_FORMAT_FLOAT', 'HIP_AD_FORMAT_HALF',
    'HIP_AD_FORMAT_SIGNED_INT16', 'HIP_AD_FORMAT_SIGNED_INT32',
    'HIP_AD_FORMAT_SIGNED_INT8', 'HIP_AD_FORMAT_UNSIGNED_INT16',
    'HIP_AD_FORMAT_UNSIGNED_INT32', 'HIP_AD_FORMAT_UNSIGNED_INT8',
    'HIP_ARRAY3D_DESCRIPTOR', 'HIP_ARRAY_DESCRIPTOR',
    'HIP_ERROR_INVALID_VALUE', 'HIP_ERROR_LAUNCH_OUT_OF_RESOURCES',
    'HIP_ERROR_NOT_INITIALIZED', 'HIP_FUNC_ATTRIBUTE_BINARY_VERSION',
    'HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA',
    'HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES',
    'HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES', 'HIP_FUNC_ATTRIBUTE_MAX',
    'HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES',
    'HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK',
    'HIP_FUNC_ATTRIBUTE_NUM_REGS',
    'HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT',
    'HIP_FUNC_ATTRIBUTE_PTX_VERSION',
    'HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES', 'HIP_MEMCPY3D',
    'HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS',
    'HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES',
    'HIP_POINTER_ATTRIBUTE_BUFFER_ID',
    'HIP_POINTER_ATTRIBUTE_CONTEXT',
    'HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL',
    'HIP_POINTER_ATTRIBUTE_DEVICE_POINTER',
    'HIP_POINTER_ATTRIBUTE_HOST_POINTER',
    'HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE',
    'HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE',
    'HIP_POINTER_ATTRIBUTE_IS_MANAGED',
    'HIP_POINTER_ATTRIBUTE_MAPPED',
    'HIP_POINTER_ATTRIBUTE_MEMORY_TYPE',
    'HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE',
    'HIP_POINTER_ATTRIBUTE_P2P_TOKENS',
    'HIP_POINTER_ATTRIBUTE_RANGE_SIZE',
    'HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR',
    'HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS', 'HIP_RESOURCE_DESC',
    'HIP_RESOURCE_TYPE_ARRAY', 'HIP_RESOURCE_TYPE_LINEAR',
    'HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY', 'HIP_RESOURCE_TYPE_PITCH2D',
    'HIP_RESOURCE_VIEW_DESC', 'HIP_RES_VIEW_FORMAT_FLOAT_1X16',
    'HIP_RES_VIEW_FORMAT_FLOAT_1X32',
    'HIP_RES_VIEW_FORMAT_FLOAT_2X16',
    'HIP_RES_VIEW_FORMAT_FLOAT_2X32',
    'HIP_RES_VIEW_FORMAT_FLOAT_4X16',
    'HIP_RES_VIEW_FORMAT_FLOAT_4X32', 'HIP_RES_VIEW_FORMAT_NONE',
    'HIP_RES_VIEW_FORMAT_SIGNED_BC4',
    'HIP_RES_VIEW_FORMAT_SIGNED_BC5',
    'HIP_RES_VIEW_FORMAT_SIGNED_BC6H',
    'HIP_RES_VIEW_FORMAT_SINT_1X16', 'HIP_RES_VIEW_FORMAT_SINT_1X32',
    'HIP_RES_VIEW_FORMAT_SINT_1X8', 'HIP_RES_VIEW_FORMAT_SINT_2X16',
    'HIP_RES_VIEW_FORMAT_SINT_2X32', 'HIP_RES_VIEW_FORMAT_SINT_2X8',
    'HIP_RES_VIEW_FORMAT_SINT_4X16', 'HIP_RES_VIEW_FORMAT_SINT_4X32',
    'HIP_RES_VIEW_FORMAT_SINT_4X8', 'HIP_RES_VIEW_FORMAT_UINT_1X16',
    'HIP_RES_VIEW_FORMAT_UINT_1X32', 'HIP_RES_VIEW_FORMAT_UINT_1X8',
    'HIP_RES_VIEW_FORMAT_UINT_2X16', 'HIP_RES_VIEW_FORMAT_UINT_2X32',
    'HIP_RES_VIEW_FORMAT_UINT_2X8', 'HIP_RES_VIEW_FORMAT_UINT_4X16',
    'HIP_RES_VIEW_FORMAT_UINT_4X32', 'HIP_RES_VIEW_FORMAT_UINT_4X8',
    'HIP_RES_VIEW_FORMAT_UNSIGNED_BC1',
    'HIP_RES_VIEW_FORMAT_UNSIGNED_BC2',
    'HIP_RES_VIEW_FORMAT_UNSIGNED_BC3',
    'HIP_RES_VIEW_FORMAT_UNSIGNED_BC4',
    'HIP_RES_VIEW_FORMAT_UNSIGNED_BC5',
    'HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H',
    'HIP_RES_VIEW_FORMAT_UNSIGNED_BC7', 'HIP_SUCCESS',
    'HIP_TEXTURE_DESC', 'HIP_TR_ADDRESS_MODE_BORDER',
    'HIP_TR_ADDRESS_MODE_CLAMP', 'HIP_TR_ADDRESS_MODE_MIRROR',
    'HIP_TR_ADDRESS_MODE_WRAP', 'HIP_TR_FILTER_MODE_LINEAR',
    'HIP_TR_FILTER_MODE_POINT', 'HIPaddress_mode',
    'HIPaddress_mode__enumvalues', 'HIPaddress_mode_enum',
    'HIPfilter_mode', 'HIPfilter_mode__enumvalues',
    'HIPfilter_mode_enum', 'HIPresourceViewFormat',
    'HIPresourceViewFormat__enumvalues', 'HIPresourceViewFormat_enum',
    'HIPresourcetype', 'HIPresourcetype__enumvalues',
    'HIPresourcetype_enum', '__hipGetPCH',
    '__hipPopCallConfiguration', '__hipPushCallConfiguration',
    'c__Ea_HIP_SUCCESS', 'dim3', 'hipAccessPolicyWindow',
    'hipAccessProperty', 'hipAccessPropertyNormal',
    'hipAccessPropertyPersisting', 'hipAccessPropertyStreaming',
    'hipAddressModeBorder', 'hipAddressModeClamp',
    'hipAddressModeMirror', 'hipAddressModeWrap', 'hipApiName',
    'hipArray', 'hipArray3DCreate', 'hipArray3DGetDescriptor',
    'hipArrayCreate', 'hipArrayDestroy', 'hipArrayGetDescriptor',
    'hipArrayGetInfo', 'hipArrayMapInfo',
    'hipArraySparseSubresourceType',
    'hipArraySparseSubresourceTypeMiptail',
    'hipArraySparseSubresourceTypeSparseLevel', 'hipArray_Format',
    'hipArray_const_t', 'hipArray_t', 'hipBindTexture',
    'hipBindTexture2D', 'hipBindTextureToArray',
    'hipBindTextureToMipmappedArray', 'hipChannelFormatDesc',
    'hipChannelFormatKind', 'hipChannelFormatKindFloat',
    'hipChannelFormatKindNone', 'hipChannelFormatKindSigned',
    'hipChannelFormatKindUnsigned', 'hipChooseDevice',
    'hipComputeMode', 'hipComputeModeDefault',
    'hipComputeModeExclusive', 'hipComputeModeExclusiveProcess',
    'hipComputeModeProhibited', 'hipConfigureCall',
    'hipCreateSurfaceObject', 'hipCreateTextureObject',
    'hipCtxCreate', 'hipCtxDestroy', 'hipCtxDisablePeerAccess',
    'hipCtxEnablePeerAccess', 'hipCtxGetApiVersion',
    'hipCtxGetCacheConfig', 'hipCtxGetCurrent', 'hipCtxGetDevice',
    'hipCtxGetFlags', 'hipCtxGetSharedMemConfig', 'hipCtxPopCurrent',
    'hipCtxPushCurrent', 'hipCtxSetCacheConfig', 'hipCtxSetCurrent',
    'hipCtxSetSharedMemConfig', 'hipCtxSynchronize', 'hipCtx_t',
    'hipDestroyExternalMemory', 'hipDestroyExternalSemaphore',
    'hipDestroySurfaceObject', 'hipDestroyTextureObject',
    'hipDevP2PAttrAccessSupported',
    'hipDevP2PAttrHipArrayAccessSupported',
    'hipDevP2PAttrNativeAtomicSupported',
    'hipDevP2PAttrPerformanceRank', 'hipDeviceArch_t',
    'hipDeviceAttributeAccessPolicyMaxWindowSize',
    'hipDeviceAttributeAmdSpecificBegin',
    'hipDeviceAttributeAmdSpecificEnd', 'hipDeviceAttributeArch',
    'hipDeviceAttributeAsicRevision',
    'hipDeviceAttributeAsyncEngineCount',
    'hipDeviceAttributeCanMapHostMemory',
    'hipDeviceAttributeCanUseHostPointerForRegisteredMem',
    'hipDeviceAttributeCanUseStreamWaitValue',
    'hipDeviceAttributeClockInstructionRate',
    'hipDeviceAttributeClockRate',
    'hipDeviceAttributeComputeCapabilityMajor',
    'hipDeviceAttributeComputeCapabilityMinor',
    'hipDeviceAttributeComputeMode',
    'hipDeviceAttributeComputePreemptionSupported',
    'hipDeviceAttributeConcurrentKernels',
    'hipDeviceAttributeConcurrentManagedAccess',
    'hipDeviceAttributeCooperativeLaunch',
    'hipDeviceAttributeCooperativeMultiDeviceLaunch',
    'hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim',
    'hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc',
    'hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim',
    'hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem',
    'hipDeviceAttributeCudaCompatibleBegin',
    'hipDeviceAttributeCudaCompatibleEnd',
    'hipDeviceAttributeDeviceOverlap',
    'hipDeviceAttributeDirectManagedMemAccessFromHost',
    'hipDeviceAttributeEccEnabled',
    'hipDeviceAttributeFineGrainSupport', 'hipDeviceAttributeGcnArch',
    'hipDeviceAttributeGcnArchName',
    'hipDeviceAttributeGlobalL1CacheSupported',
    'hipDeviceAttributeHdpMemFlushCntl',
    'hipDeviceAttributeHdpRegFlushCntl',
    'hipDeviceAttributeHostNativeAtomicSupported',
    'hipDeviceAttributeImageSupport', 'hipDeviceAttributeIntegrated',
    'hipDeviceAttributeIsLargeBar',
    'hipDeviceAttributeIsMultiGpuBoard',
    'hipDeviceAttributeKernelExecTimeout',
    'hipDeviceAttributeL2CacheSize',
    'hipDeviceAttributeLocalL1CacheSupported',
    'hipDeviceAttributeLuid', 'hipDeviceAttributeLuidDeviceNodeMask',
    'hipDeviceAttributeManagedMemory',
    'hipDeviceAttributeMaxBlockDimX',
    'hipDeviceAttributeMaxBlockDimY',
    'hipDeviceAttributeMaxBlockDimZ',
    'hipDeviceAttributeMaxBlocksPerMultiProcessor',
    'hipDeviceAttributeMaxGridDimX', 'hipDeviceAttributeMaxGridDimY',
    'hipDeviceAttributeMaxGridDimZ', 'hipDeviceAttributeMaxPitch',
    'hipDeviceAttributeMaxRegistersPerBlock',
    'hipDeviceAttributeMaxRegistersPerMultiprocessor',
    'hipDeviceAttributeMaxSharedMemoryPerBlock',
    'hipDeviceAttributeMaxSharedMemoryPerMultiprocessor',
    'hipDeviceAttributeMaxSurface1D',
    'hipDeviceAttributeMaxSurface1DLayered',
    'hipDeviceAttributeMaxSurface2D',
    'hipDeviceAttributeMaxSurface2DLayered',
    'hipDeviceAttributeMaxSurface3D',
    'hipDeviceAttributeMaxSurfaceCubemap',
    'hipDeviceAttributeMaxSurfaceCubemapLayered',
    'hipDeviceAttributeMaxTexture1DLayered',
    'hipDeviceAttributeMaxTexture1DLinear',
    'hipDeviceAttributeMaxTexture1DMipmap',
    'hipDeviceAttributeMaxTexture1DWidth',
    'hipDeviceAttributeMaxTexture2DGather',
    'hipDeviceAttributeMaxTexture2DHeight',
    'hipDeviceAttributeMaxTexture2DLayered',
    'hipDeviceAttributeMaxTexture2DLinear',
    'hipDeviceAttributeMaxTexture2DMipmap',
    'hipDeviceAttributeMaxTexture2DWidth',
    'hipDeviceAttributeMaxTexture3DAlt',
    'hipDeviceAttributeMaxTexture3DDepth',
    'hipDeviceAttributeMaxTexture3DHeight',
    'hipDeviceAttributeMaxTexture3DWidth',
    'hipDeviceAttributeMaxTextureCubemap',
    'hipDeviceAttributeMaxTextureCubemapLayered',
    'hipDeviceAttributeMaxThreadsDim',
    'hipDeviceAttributeMaxThreadsPerBlock',
    'hipDeviceAttributeMaxThreadsPerMultiProcessor',
    'hipDeviceAttributeMemoryBusWidth',
    'hipDeviceAttributeMemoryClockRate',
    'hipDeviceAttributeMemoryPoolsSupported',
    'hipDeviceAttributeMultiGpuBoardGroupID',
    'hipDeviceAttributeMultiprocessorCount', 'hipDeviceAttributeName',
    'hipDeviceAttributePageableMemoryAccess',
    'hipDeviceAttributePageableMemoryAccessUsesHostPageTables',
    'hipDeviceAttributePciBusId', 'hipDeviceAttributePciDeviceId',
    'hipDeviceAttributePciDomainID',
    'hipDeviceAttributePersistingL2CacheMaxSize',
    'hipDeviceAttributePhysicalMultiProcessorCount',
    'hipDeviceAttributeReservedSharedMemPerBlock',
    'hipDeviceAttributeSharedMemPerBlockOptin',
    'hipDeviceAttributeSharedMemPerMultiprocessor',
    'hipDeviceAttributeSingleToDoublePrecisionPerfRatio',
    'hipDeviceAttributeStreamPrioritiesSupported',
    'hipDeviceAttributeSurfaceAlignment',
    'hipDeviceAttributeTccDriver',
    'hipDeviceAttributeTextureAlignment',
    'hipDeviceAttributeTexturePitchAlignment',
    'hipDeviceAttributeTotalConstantMemory',
    'hipDeviceAttributeTotalGlobalMem',
    'hipDeviceAttributeUnifiedAddressing', 'hipDeviceAttributeUuid',
    'hipDeviceAttributeVendorSpecificBegin',
    'hipDeviceAttributeVirtualMemoryManagementSupported',
    'hipDeviceAttributeWallClockRate', 'hipDeviceAttributeWarpSize',
    'hipDeviceAttribute_t', 'hipDeviceCanAccessPeer',
    'hipDeviceComputeCapability', 'hipDeviceDisablePeerAccess',
    'hipDeviceEnablePeerAccess', 'hipDeviceGet',
    'hipDeviceGetAttribute', 'hipDeviceGetByPCIBusId',
    'hipDeviceGetCacheConfig', 'hipDeviceGetDefaultMemPool',
    'hipDeviceGetGraphMemAttribute', 'hipDeviceGetLimit',
    'hipDeviceGetMemPool', 'hipDeviceGetName',
    'hipDeviceGetP2PAttribute', 'hipDeviceGetPCIBusId',
    'hipDeviceGetSharedMemConfig', 'hipDeviceGetStreamPriorityRange',
    'hipDeviceGetUuid', 'hipDeviceGraphMemTrim', 'hipDeviceP2PAttr',
    'hipDevicePrimaryCtxGetState', 'hipDevicePrimaryCtxRelease',
    'hipDevicePrimaryCtxReset', 'hipDevicePrimaryCtxRetain',
    'hipDevicePrimaryCtxSetFlags', 'hipDeviceProp_t',
    'hipDeviceReset', 'hipDeviceSetCacheConfig',
    'hipDeviceSetGraphMemAttribute', 'hipDeviceSetLimit',
    'hipDeviceSetMemPool', 'hipDeviceSetSharedMemConfig',
    'hipDeviceSynchronize', 'hipDeviceTotalMem', 'hipDevice_t',
    'hipDeviceptr_t', 'hipDriverGetVersion', 'hipDrvGetErrorName',
    'hipDrvGetErrorString', 'hipDrvMemcpy2DUnaligned',
    'hipDrvMemcpy3D', 'hipDrvMemcpy3DAsync',
    'hipDrvPointerGetAttributes', 'hipErrorAlreadyAcquired',
    'hipErrorAlreadyMapped', 'hipErrorArrayIsMapped',
    'hipErrorAssert', 'hipErrorCapturedEvent',
    'hipErrorContextAlreadyCurrent', 'hipErrorContextAlreadyInUse',
    'hipErrorContextIsDestroyed', 'hipErrorCooperativeLaunchTooLarge',
    'hipErrorDeinitialized', 'hipErrorECCNotCorrectable',
    'hipErrorFileNotFound', 'hipErrorGraphExecUpdateFailure',
    'hipErrorHostMemoryAlreadyRegistered',
    'hipErrorHostMemoryNotRegistered', 'hipErrorIllegalAddress',
    'hipErrorIllegalState', 'hipErrorInitializationError',
    'hipErrorInsufficientDriver', 'hipErrorInvalidConfiguration',
    'hipErrorInvalidContext', 'hipErrorInvalidDevice',
    'hipErrorInvalidDeviceFunction', 'hipErrorInvalidDevicePointer',
    'hipErrorInvalidGraphicsContext', 'hipErrorInvalidHandle',
    'hipErrorInvalidImage', 'hipErrorInvalidKernelFile',
    'hipErrorInvalidMemcpyDirection', 'hipErrorInvalidPitchValue',
    'hipErrorInvalidResourceHandle', 'hipErrorInvalidSource',
    'hipErrorInvalidSymbol', 'hipErrorInvalidValue',
    'hipErrorLaunchFailure', 'hipErrorLaunchOutOfResources',
    'hipErrorLaunchTimeOut', 'hipErrorMapBufferObjectFailed',
    'hipErrorMapFailed', 'hipErrorMemoryAllocation',
    'hipErrorMissingConfiguration', 'hipErrorNoBinaryForGpu',
    'hipErrorNoDevice', 'hipErrorNotFound', 'hipErrorNotInitialized',
    'hipErrorNotMapped', 'hipErrorNotMappedAsArray',
    'hipErrorNotMappedAsPointer', 'hipErrorNotReady',
    'hipErrorNotSupported', 'hipErrorOperatingSystem',
    'hipErrorOutOfMemory', 'hipErrorPeerAccessAlreadyEnabled',
    'hipErrorPeerAccessNotEnabled', 'hipErrorPeerAccessUnsupported',
    'hipErrorPriorLaunchFailure', 'hipErrorProfilerAlreadyStarted',
    'hipErrorProfilerAlreadyStopped', 'hipErrorProfilerDisabled',
    'hipErrorProfilerNotInitialized', 'hipErrorRuntimeMemory',
    'hipErrorRuntimeOther', 'hipErrorSetOnActiveProcess',
    'hipErrorSharedObjectInitFailed',
    'hipErrorSharedObjectSymbolNotFound',
    'hipErrorStreamCaptureImplicit',
    'hipErrorStreamCaptureInvalidated',
    'hipErrorStreamCaptureIsolation', 'hipErrorStreamCaptureMerge',
    'hipErrorStreamCaptureUnjoined', 'hipErrorStreamCaptureUnmatched',
    'hipErrorStreamCaptureUnsupported',
    'hipErrorStreamCaptureWrongThread', 'hipErrorTbd',
    'hipErrorUnknown', 'hipErrorUnmapFailed',
    'hipErrorUnsupportedLimit', 'hipError_t', 'hipEventCreate',
    'hipEventCreateWithFlags', 'hipEventDestroy',
    'hipEventElapsedTime', 'hipEventQuery', 'hipEventRecord',
    'hipEventSynchronize', 'hipEvent_t',
    'hipExtGetLinkTypeAndHopCount', 'hipExtLaunchKernel',
    'hipExtLaunchMultiKernelMultiDevice', 'hipExtMallocWithFlags',
    'hipExtStreamCreateWithCUMask', 'hipExtStreamGetCUMask',
    'hipExtent', 'hipExternalMemoryBufferDesc',
    'hipExternalMemoryGetMappedBuffer', 'hipExternalMemoryHandleDesc',
    'hipExternalMemoryHandleType',
    'hipExternalMemoryHandleTypeD3D11Resource',
    'hipExternalMemoryHandleTypeD3D11ResourceKmt',
    'hipExternalMemoryHandleTypeD3D12Heap',
    'hipExternalMemoryHandleTypeD3D12Resource',
    'hipExternalMemoryHandleTypeOpaqueFd',
    'hipExternalMemoryHandleTypeOpaqueWin32',
    'hipExternalMemoryHandleTypeOpaqueWin32Kmt',
    'hipExternalMemoryHandleType__enumvalues',
    'hipExternalMemoryHandleType_enum', 'hipExternalMemory_t',
    'hipExternalSemaphoreHandleDesc',
    'hipExternalSemaphoreHandleType',
    'hipExternalSemaphoreHandleTypeD3D12Fence',
    'hipExternalSemaphoreHandleTypeOpaqueFd',
    'hipExternalSemaphoreHandleTypeOpaqueWin32',
    'hipExternalSemaphoreHandleTypeOpaqueWin32Kmt',
    'hipExternalSemaphoreHandleType__enumvalues',
    'hipExternalSemaphoreHandleType_enum',
    'hipExternalSemaphoreSignalNodeParams',
    'hipExternalSemaphoreSignalParams',
    'hipExternalSemaphoreWaitNodeParams',
    'hipExternalSemaphoreWaitParams', 'hipExternalSemaphore_t',
    'hipFilterModeLinear', 'hipFilterModePoint', 'hipFree',
    'hipFreeArray', 'hipFreeAsync', 'hipFreeHost',
    'hipFreeMipmappedArray', 'hipFuncAttribute',
    'hipFuncAttributeMax',
    'hipFuncAttributeMaxDynamicSharedMemorySize',
    'hipFuncAttributePreferredSharedMemoryCarveout',
    'hipFuncAttributes', 'hipFuncCachePreferEqual',
    'hipFuncCachePreferL1', 'hipFuncCachePreferNone',
    'hipFuncCachePreferShared', 'hipFuncCache_t',
    'hipFuncGetAttribute', 'hipFuncGetAttributes',
    'hipFuncSetAttribute', 'hipFuncSetCacheConfig',
    'hipFuncSetSharedMemConfig', 'hipFunctionLaunchParams',
    'hipFunction_attribute', 'hipFunction_t', 'hipGLDeviceList',
    'hipGLDeviceListAll', 'hipGLDeviceListCurrentFrame',
    'hipGLDeviceListNextFrame', 'hipGLGetDevices',
    'hipGetChannelDesc', 'hipGetDevice', 'hipGetDeviceCount',
    'hipGetDeviceFlags', 'hipGetDeviceProperties', 'hipGetErrorName',
    'hipGetErrorString', 'hipGetLastError',
    'hipGetMipmappedArrayLevel', 'hipGetStreamDeviceId',
    'hipGetSymbolAddress', 'hipGetSymbolSize',
    'hipGetTextureAlignmentOffset', 'hipGetTextureObjectResourceDesc',
    'hipGetTextureObjectResourceViewDesc',
    'hipGetTextureObjectTextureDesc', 'hipGetTextureReference',
    'hipGraphAddChildGraphNode', 'hipGraphAddDependencies',
    'hipGraphAddEmptyNode', 'hipGraphAddEventRecordNode',
    'hipGraphAddEventWaitNode',
    'hipGraphAddExternalSemaphoresSignalNode',
    'hipGraphAddExternalSemaphoresWaitNode', 'hipGraphAddHostNode',
    'hipGraphAddKernelNode', 'hipGraphAddMemAllocNode',
    'hipGraphAddMemFreeNode', 'hipGraphAddMemcpyNode',
    'hipGraphAddMemcpyNode1D', 'hipGraphAddMemcpyNodeFromSymbol',
    'hipGraphAddMemcpyNodeToSymbol', 'hipGraphAddMemsetNode',
    'hipGraphChildGraphNodeGetGraph', 'hipGraphClone',
    'hipGraphCreate', 'hipGraphDebugDotFlags',
    'hipGraphDebugDotFlagsEventNodeParams',
    'hipGraphDebugDotFlagsExtSemasSignalNodeParams',
    'hipGraphDebugDotFlagsExtSemasWaitNodeParams',
    'hipGraphDebugDotFlagsHandles',
    'hipGraphDebugDotFlagsHostNodeParams',
    'hipGraphDebugDotFlagsKernelNodeAttributes',
    'hipGraphDebugDotFlagsKernelNodeParams',
    'hipGraphDebugDotFlagsMemcpyNodeParams',
    'hipGraphDebugDotFlagsMemsetNodeParams',
    'hipGraphDebugDotFlagsVerbose', 'hipGraphDebugDotPrint',
    'hipGraphDestroy', 'hipGraphDestroyNode',
    'hipGraphEventRecordNodeGetEvent',
    'hipGraphEventRecordNodeSetEvent',
    'hipGraphEventWaitNodeGetEvent', 'hipGraphEventWaitNodeSetEvent',
    'hipGraphExecChildGraphNodeSetParams', 'hipGraphExecDestroy',
    'hipGraphExecEventRecordNodeSetEvent',
    'hipGraphExecEventWaitNodeSetEvent',
    'hipGraphExecExternalSemaphoresSignalNodeSetParams',
    'hipGraphExecExternalSemaphoresWaitNodeSetParams',
    'hipGraphExecHostNodeSetParams',
    'hipGraphExecKernelNodeSetParams',
    'hipGraphExecMemcpyNodeSetParams',
    'hipGraphExecMemcpyNodeSetParams1D',
    'hipGraphExecMemcpyNodeSetParamsFromSymbol',
    'hipGraphExecMemcpyNodeSetParamsToSymbol',
    'hipGraphExecMemsetNodeSetParams', 'hipGraphExecUpdate',
    'hipGraphExecUpdateError',
    'hipGraphExecUpdateErrorFunctionChanged',
    'hipGraphExecUpdateErrorNodeTypeChanged',
    'hipGraphExecUpdateErrorNotSupported',
    'hipGraphExecUpdateErrorParametersChanged',
    'hipGraphExecUpdateErrorTopologyChanged',
    'hipGraphExecUpdateErrorUnsupportedFunctionChange',
    'hipGraphExecUpdateResult', 'hipGraphExecUpdateSuccess',
    'hipGraphExec_t', 'hipGraphExternalSemaphoresSignalNodeGetParams',
    'hipGraphExternalSemaphoresSignalNodeSetParams',
    'hipGraphExternalSemaphoresWaitNodeGetParams',
    'hipGraphExternalSemaphoresWaitNodeSetParams', 'hipGraphGetEdges',
    'hipGraphGetNodes', 'hipGraphGetRootNodes',
    'hipGraphHostNodeGetParams', 'hipGraphHostNodeSetParams',
    'hipGraphInstantiate', 'hipGraphInstantiateFlagAutoFreeOnLaunch',
    'hipGraphInstantiateFlagDeviceLaunch',
    'hipGraphInstantiateFlagUpload',
    'hipGraphInstantiateFlagUseNodePriority',
    'hipGraphInstantiateFlags', 'hipGraphInstantiateWithFlags',
    'hipGraphKernelNodeCopyAttributes',
    'hipGraphKernelNodeGetAttribute', 'hipGraphKernelNodeGetParams',
    'hipGraphKernelNodeSetAttribute', 'hipGraphKernelNodeSetParams',
    'hipGraphLaunch', 'hipGraphMemAllocNodeGetParams',
    'hipGraphMemAttrReservedMemCurrent',
    'hipGraphMemAttrReservedMemHigh', 'hipGraphMemAttrUsedMemCurrent',
    'hipGraphMemAttrUsedMemHigh', 'hipGraphMemAttributeType',
    'hipGraphMemFreeNodeGetParams', 'hipGraphMemcpyNodeGetParams',
    'hipGraphMemcpyNodeSetParams', 'hipGraphMemcpyNodeSetParams1D',
    'hipGraphMemcpyNodeSetParamsFromSymbol',
    'hipGraphMemcpyNodeSetParamsToSymbol',
    'hipGraphMemsetNodeGetParams', 'hipGraphMemsetNodeSetParams',
    'hipGraphNodeFindInClone', 'hipGraphNodeGetDependencies',
    'hipGraphNodeGetDependentNodes', 'hipGraphNodeGetEnabled',
    'hipGraphNodeGetType', 'hipGraphNodeSetEnabled',
    'hipGraphNodeType', 'hipGraphNodeTypeCount',
    'hipGraphNodeTypeEmpty', 'hipGraphNodeTypeEventRecord',
    'hipGraphNodeTypeExtSemaphoreSignal',
    'hipGraphNodeTypeExtSemaphoreWait', 'hipGraphNodeTypeGraph',
    'hipGraphNodeTypeHost', 'hipGraphNodeTypeKernel',
    'hipGraphNodeTypeMemAlloc', 'hipGraphNodeTypeMemFree',
    'hipGraphNodeTypeMemcpy', 'hipGraphNodeTypeMemcpyFromSymbol',
    'hipGraphNodeTypeMemcpyToSymbol', 'hipGraphNodeTypeMemset',
    'hipGraphNodeTypeWaitEvent', 'hipGraphNode_t',
    'hipGraphReleaseUserObject', 'hipGraphRemoveDependencies',
    'hipGraphRetainUserObject', 'hipGraphUpload',
    'hipGraphUserObjectMove', 'hipGraph_t',
    'hipGraphicsGLRegisterBuffer', 'hipGraphicsGLRegisterImage',
    'hipGraphicsMapResources', 'hipGraphicsRegisterFlags',
    'hipGraphicsRegisterFlagsNone',
    'hipGraphicsRegisterFlagsReadOnly',
    'hipGraphicsRegisterFlagsSurfaceLoadStore',
    'hipGraphicsRegisterFlagsTextureGather',
    'hipGraphicsRegisterFlagsWriteDiscard', 'hipGraphicsResource',
    'hipGraphicsResourceGetMappedPointer', 'hipGraphicsResource_t',
    'hipGraphicsSubResourceGetMappedArray',
    'hipGraphicsUnmapResources', 'hipGraphicsUnregisterResource',
    'hipHostAlloc', 'hipHostFn_t', 'hipHostFree',
    'hipHostGetDevicePointer', 'hipHostGetFlags', 'hipHostMalloc',
    'hipHostNodeParams', 'hipHostRegister', 'hipHostUnregister',
    'hipImportExternalMemory', 'hipImportExternalSemaphore',
    'hipInit', 'hipIpcCloseMemHandle', 'hipIpcEventHandle_t',
    'hipIpcGetEventHandle', 'hipIpcGetMemHandle', 'hipIpcMemHandle_t',
    'hipIpcOpenEventHandle', 'hipIpcOpenMemHandle', 'hipJitOption',
    'hipJitOptionCacheMode', 'hipJitOptionErrorLogBuffer',
    'hipJitOptionErrorLogBufferSizeBytes',
    'hipJitOptionFallbackStrategy', 'hipJitOptionFastCompile',
    'hipJitOptionGenerateDebugInfo', 'hipJitOptionGenerateLineInfo',
    'hipJitOptionInfoLogBuffer', 'hipJitOptionInfoLogBufferSizeBytes',
    'hipJitOptionLogVerbose', 'hipJitOptionMaxRegisters',
    'hipJitOptionNumOptions', 'hipJitOptionOptimizationLevel',
    'hipJitOptionSm3xOpt', 'hipJitOptionTarget',
    'hipJitOptionTargetFromContext', 'hipJitOptionThreadsPerBlock',
    'hipJitOptionWallTime', 'hipKernelNameRef',
    'hipKernelNameRefByPtr', 'hipKernelNodeAttrID',
    'hipKernelNodeAttrValue',
    'hipKernelNodeAttributeAccessPolicyWindow',
    'hipKernelNodeAttributeCooperative', 'hipKernelNodeParams',
    'hipLaunchByPtr', 'hipLaunchCooperativeKernel',
    'hipLaunchCooperativeKernelMultiDevice', 'hipLaunchHostFunc',
    'hipLaunchKernel', 'hipLaunchParams', 'hipLimitMallocHeapSize',
    'hipLimitPrintfFifoSize', 'hipLimitRange', 'hipLimitStackSize',
    'hipLimit_t', 'hipMalloc', 'hipMalloc3D', 'hipMalloc3DArray',
    'hipMallocArray', 'hipMallocAsync', 'hipMallocFromPoolAsync',
    'hipMallocHost', 'hipMallocManaged', 'hipMallocMipmappedArray',
    'hipMallocPitch', 'hipMemAccessDesc', 'hipMemAccessFlags',
    'hipMemAccessFlagsProtNone', 'hipMemAccessFlagsProtRead',
    'hipMemAccessFlagsProtReadWrite', 'hipMemAddressFree',
    'hipMemAddressReserve', 'hipMemAdvise',
    'hipMemAdviseSetAccessedBy', 'hipMemAdviseSetCoarseGrain',
    'hipMemAdviseSetPreferredLocation', 'hipMemAdviseSetReadMostly',
    'hipMemAdviseUnsetAccessedBy', 'hipMemAdviseUnsetCoarseGrain',
    'hipMemAdviseUnsetPreferredLocation',
    'hipMemAdviseUnsetReadMostly', 'hipMemAllocHost',
    'hipMemAllocNodeParams', 'hipMemAllocPitch',
    'hipMemAllocationGranularityMinimum',
    'hipMemAllocationGranularityRecommended',
    'hipMemAllocationGranularity_flags', 'hipMemAllocationHandleType',
    'hipMemAllocationProp', 'hipMemAllocationType',
    'hipMemAllocationTypeInvalid', 'hipMemAllocationTypeMax',
    'hipMemAllocationTypePinned', 'hipMemCreate',
    'hipMemExportToShareableHandle',
    'hipMemGenericAllocationHandle_t', 'hipMemGetAccess',
    'hipMemGetAddressRange', 'hipMemGetAllocationGranularity',
    'hipMemGetAllocationPropertiesFromHandle', 'hipMemGetInfo',
    'hipMemHandleType', 'hipMemHandleTypeGeneric',
    'hipMemHandleTypeNone', 'hipMemHandleTypePosixFileDescriptor',
    'hipMemHandleTypeWin32', 'hipMemHandleTypeWin32Kmt',
    'hipMemImportFromShareableHandle', 'hipMemLocation',
    'hipMemLocationType', 'hipMemLocationTypeDevice',
    'hipMemLocationTypeInvalid', 'hipMemMap', 'hipMemMapArrayAsync',
    'hipMemOperationType', 'hipMemOperationTypeMap',
    'hipMemOperationTypeUnmap', 'hipMemPoolAttr',
    'hipMemPoolAttrReleaseThreshold',
    'hipMemPoolAttrReservedMemCurrent',
    'hipMemPoolAttrReservedMemHigh', 'hipMemPoolAttrUsedMemCurrent',
    'hipMemPoolAttrUsedMemHigh', 'hipMemPoolCreate',
    'hipMemPoolDestroy', 'hipMemPoolExportPointer',
    'hipMemPoolExportToShareableHandle', 'hipMemPoolGetAccess',
    'hipMemPoolGetAttribute', 'hipMemPoolImportFromShareableHandle',
    'hipMemPoolImportPointer', 'hipMemPoolProps',
    'hipMemPoolPtrExportData',
    'hipMemPoolReuseAllowInternalDependencies',
    'hipMemPoolReuseAllowOpportunistic',
    'hipMemPoolReuseFollowEventDependencies', 'hipMemPoolSetAccess',
    'hipMemPoolSetAttribute', 'hipMemPoolTrimTo', 'hipMemPool_t',
    'hipMemPrefetchAsync', 'hipMemPtrGetInfo', 'hipMemRangeAttribute',
    'hipMemRangeAttributeAccessedBy',
    'hipMemRangeAttributeCoherencyMode',
    'hipMemRangeAttributeLastPrefetchLocation',
    'hipMemRangeAttributePreferredLocation',
    'hipMemRangeAttributeReadMostly', 'hipMemRangeCoherencyMode',
    'hipMemRangeCoherencyModeCoarseGrain',
    'hipMemRangeCoherencyModeFineGrain',
    'hipMemRangeCoherencyModeIndeterminate',
    'hipMemRangeGetAttribute', 'hipMemRangeGetAttributes',
    'hipMemRelease', 'hipMemRetainAllocationHandle',
    'hipMemSetAccess', 'hipMemUnmap', 'hipMemcpy', 'hipMemcpy2D',
    'hipMemcpy2DAsync', 'hipMemcpy2DFromArray',
    'hipMemcpy2DFromArrayAsync', 'hipMemcpy2DToArray',
    'hipMemcpy2DToArrayAsync', 'hipMemcpy3D', 'hipMemcpy3DAsync',
    'hipMemcpy3DParms', 'hipMemcpyAsync', 'hipMemcpyAtoH',
    'hipMemcpyDefault', 'hipMemcpyDeviceToDevice',
    'hipMemcpyDeviceToHost', 'hipMemcpyDtoD', 'hipMemcpyDtoDAsync',
    'hipMemcpyDtoH', 'hipMemcpyDtoHAsync', 'hipMemcpyFromArray',
    'hipMemcpyFromSymbol', 'hipMemcpyFromSymbolAsync',
    'hipMemcpyHostToDevice', 'hipMemcpyHostToHost', 'hipMemcpyHtoA',
    'hipMemcpyHtoD', 'hipMemcpyHtoDAsync', 'hipMemcpyKind',
    'hipMemcpyParam2D', 'hipMemcpyParam2DAsync', 'hipMemcpyPeer',
    'hipMemcpyPeerAsync', 'hipMemcpyToArray', 'hipMemcpyToSymbol',
    'hipMemcpyToSymbolAsync', 'hipMemcpyWithStream',
    'hipMemoryAdvise', 'hipMemoryType', 'hipMemoryTypeArray',
    'hipMemoryTypeDevice', 'hipMemoryTypeHost',
    'hipMemoryTypeManaged', 'hipMemoryTypeUnified', 'hipMemset',
    'hipMemset2D', 'hipMemset2DAsync', 'hipMemset3D',
    'hipMemset3DAsync', 'hipMemsetAsync', 'hipMemsetD16',
    'hipMemsetD16Async', 'hipMemsetD32', 'hipMemsetD32Async',
    'hipMemsetD8', 'hipMemsetD8Async', 'hipMemsetParams',
    'hipMipmappedArray', 'hipMipmappedArrayCreate',
    'hipMipmappedArrayDestroy', 'hipMipmappedArrayGetLevel',
    'hipMipmappedArray_const_t', 'hipMipmappedArray_t',
    'hipModuleGetFunction', 'hipModuleGetGlobal',
    'hipModuleGetTexRef', 'hipModuleLaunchCooperativeKernel',
    'hipModuleLaunchCooperativeKernelMultiDevice',
    'hipModuleLaunchKernel', 'hipModuleLoad', 'hipModuleLoadData',
    'hipModuleLoadDataEx',
    'hipModuleOccupancyMaxActiveBlocksPerMultiprocessor',
    'hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags',
    'hipModuleOccupancyMaxPotentialBlockSize',
    'hipModuleOccupancyMaxPotentialBlockSizeWithFlags',
    'hipModuleUnload', 'hipModule_t',
    'hipOccupancyMaxActiveBlocksPerMultiprocessor',
    'hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags',
    'hipOccupancyMaxPotentialBlockSize', 'hipPeekAtLastError',
    'hipPitchedPtr', 'hipPointerAttribute_t',
    'hipPointerGetAttribute', 'hipPointerGetAttributes',
    'hipPointerSetAttribute', 'hipPointer_attribute', 'hipPos',
    'hipProfilerStart', 'hipProfilerStop', 'hipReadModeElementType',
    'hipReadModeNormalizedFloat', 'hipResViewFormatFloat1',
    'hipResViewFormatFloat2', 'hipResViewFormatFloat4',
    'hipResViewFormatHalf1', 'hipResViewFormatHalf2',
    'hipResViewFormatHalf4', 'hipResViewFormatNone',
    'hipResViewFormatSignedBlockCompressed4',
    'hipResViewFormatSignedBlockCompressed5',
    'hipResViewFormatSignedBlockCompressed6H',
    'hipResViewFormatSignedChar1', 'hipResViewFormatSignedChar2',
    'hipResViewFormatSignedChar4', 'hipResViewFormatSignedInt1',
    'hipResViewFormatSignedInt2', 'hipResViewFormatSignedInt4',
    'hipResViewFormatSignedShort1', 'hipResViewFormatSignedShort2',
    'hipResViewFormatSignedShort4',
    'hipResViewFormatUnsignedBlockCompressed1',
    'hipResViewFormatUnsignedBlockCompressed2',
    'hipResViewFormatUnsignedBlockCompressed3',
    'hipResViewFormatUnsignedBlockCompressed4',
    'hipResViewFormatUnsignedBlockCompressed5',
    'hipResViewFormatUnsignedBlockCompressed6H',
    'hipResViewFormatUnsignedBlockCompressed7',
    'hipResViewFormatUnsignedChar1', 'hipResViewFormatUnsignedChar2',
    'hipResViewFormatUnsignedChar4', 'hipResViewFormatUnsignedInt1',
    'hipResViewFormatUnsignedInt2', 'hipResViewFormatUnsignedInt4',
    'hipResViewFormatUnsignedShort1',
    'hipResViewFormatUnsignedShort2',
    'hipResViewFormatUnsignedShort4', 'hipResourceDesc',
    'hipResourceType', 'hipResourceTypeArray',
    'hipResourceTypeLinear', 'hipResourceTypeMipmappedArray',
    'hipResourceTypePitch2D', 'hipResourceViewFormat',
    'hipResourcetype', 'hipResourcetype__enumvalues',
    'hipRuntimeGetVersion', 'hipSetDevice', 'hipSetDeviceFlags',
    'hipSetupArgument', 'hipSharedMemBankSizeDefault',
    'hipSharedMemBankSizeEightByte', 'hipSharedMemBankSizeFourByte',
    'hipSharedMemConfig', 'hipSignalExternalSemaphoresAsync',
    'hipStreamAddCallback', 'hipStreamAddCaptureDependencies',
    'hipStreamAttachMemAsync', 'hipStreamBeginCapture',
    'hipStreamCallback_t', 'hipStreamCaptureMode',
    'hipStreamCaptureModeGlobal', 'hipStreamCaptureModeRelaxed',
    'hipStreamCaptureModeThreadLocal', 'hipStreamCaptureStatus',
    'hipStreamCaptureStatusActive',
    'hipStreamCaptureStatusInvalidated', 'hipStreamCaptureStatusNone',
    'hipStreamCreate', 'hipStreamCreateWithFlags',
    'hipStreamCreateWithPriority', 'hipStreamDestroy',
    'hipStreamEndCapture', 'hipStreamGetCaptureInfo',
    'hipStreamGetCaptureInfo_v2', 'hipStreamGetDevice',
    'hipStreamGetFlags', 'hipStreamGetPriority',
    'hipStreamIsCapturing', 'hipStreamQuery',
    'hipStreamSetCaptureDependencies', 'hipStreamSynchronize',
    'hipStreamUpdateCaptureDependencies',
    'hipStreamUpdateCaptureDependenciesFlags', 'hipStreamWaitEvent',
    'hipStreamWaitValue32', 'hipStreamWaitValue64',
    'hipStreamWriteValue32', 'hipStreamWriteValue64', 'hipStream_t',
    'hipSuccess', 'hipSurfaceObject_t', 'hipTexObjectCreate',
    'hipTexObjectDestroy', 'hipTexObjectGetResourceDesc',
    'hipTexObjectGetResourceViewDesc', 'hipTexObjectGetTextureDesc',
    'hipTexRefGetAddress', 'hipTexRefGetAddressMode',
    'hipTexRefGetFilterMode', 'hipTexRefGetFlags',
    'hipTexRefGetFormat', 'hipTexRefGetMaxAnisotropy',
    'hipTexRefGetMipMappedArray', 'hipTexRefGetMipmapFilterMode',
    'hipTexRefGetMipmapLevelBias', 'hipTexRefGetMipmapLevelClamp',
    'hipTexRefSetAddress', 'hipTexRefSetAddress2D',
    'hipTexRefSetAddressMode', 'hipTexRefSetArray',
    'hipTexRefSetBorderColor', 'hipTexRefSetFilterMode',
    'hipTexRefSetFlags', 'hipTexRefSetFormat',
    'hipTexRefSetMaxAnisotropy', 'hipTexRefSetMipmapFilterMode',
    'hipTexRefSetMipmapLevelBias', 'hipTexRefSetMipmapLevelClamp',
    'hipTexRefSetMipmappedArray', 'hipTextureAddressMode',
    'hipTextureFilterMode', 'hipTextureObject_t',
    'hipTextureReadMode', 'hipThreadExchangeStreamCaptureMode',
    'hipUUID', 'hipUnbindTexture', 'hipUserObjectCreate',
    'hipUserObjectFlags', 'hipUserObjectNoDestructorSync',
    'hipUserObjectRelease', 'hipUserObjectRetain',
    'hipUserObjectRetainFlags', 'hipUserObject_t',
    'hipWaitExternalSemaphoresAsync', 'hip_Memcpy2D', 'hiparray',
    'hipmipmappedArray', 'hiprtcAddNameExpression',
    'hiprtcCompileProgram', 'hiprtcCreateProgram',
    'hiprtcDestroyProgram', 'hiprtcGetBitcode',
    'hiprtcGetBitcodeSize', 'hiprtcGetCode', 'hiprtcGetCodeSize',
    'hiprtcGetErrorString', 'hiprtcGetLoweredName',
    'hiprtcGetProgramLog', 'hiprtcGetProgramLogSize',
    'hiprtcJITInputType', 'hiprtcJIT_option', 'hiprtcLinkAddData',
    'hiprtcLinkAddFile', 'hiprtcLinkComplete', 'hiprtcLinkCreate',
    'hiprtcLinkDestroy', 'hiprtcLinkState', 'hiprtcProgram',
    'hiprtcResult', 'hiprtcVersion', 'make_hipExtent',
    'make_hipPitchedPtr', 'make_hipPos', 'size_t',
    'struct_HIP_ARRAY3D_DESCRIPTOR', 'struct_HIP_ARRAY_DESCRIPTOR',
    'struct_HIP_MEMCPY3D', 'struct_HIP_RESOURCE_DESC_st',
    'struct_HIP_RESOURCE_DESC_st_0_array',
    'struct_HIP_RESOURCE_DESC_st_0_linear',
    'struct_HIP_RESOURCE_DESC_st_0_mipmap',
    'struct_HIP_RESOURCE_DESC_st_0_pitch2D',
    'struct_HIP_RESOURCE_DESC_st_0_reserved',
    'struct_HIP_RESOURCE_VIEW_DESC_st', 'struct_HIP_TEXTURE_DESC_st',
    'struct___hip_surface', 'struct___hip_texture',
    'struct__hipGraphicsResource', 'struct__hiprtcProgram',
    'struct_c__SA_hipDeviceArch_t', 'struct_dim3',
    'struct_hipAccessPolicyWindow', 'struct_hipArray',
    'struct_hipArrayMapInfo', 'struct_hipArrayMapInfo_1_miptail',
    'struct_hipArrayMapInfo_1_sparseLevel',
    'struct_hipChannelFormatDesc', 'struct_hipDeviceProp_t',
    'struct_hipExtent', 'struct_hipExternalMemoryBufferDesc_st',
    'struct_hipExternalMemoryHandleDesc_st',
    'struct_hipExternalMemoryHandleDesc_st_0_win32',
    'struct_hipExternalSemaphoreHandleDesc_st',
    'struct_hipExternalSemaphoreHandleDesc_st_0_win32',
    'struct_hipExternalSemaphoreSignalNodeParams',
    'struct_hipExternalSemaphoreSignalParams_st',
    'struct_hipExternalSemaphoreSignalParams_st_0_fence',
    'struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex',
    'struct_hipExternalSemaphoreSignalParams_st_params',
    'struct_hipExternalSemaphoreWaitNodeParams',
    'struct_hipExternalSemaphoreWaitParams_st',
    'struct_hipExternalSemaphoreWaitParams_st_0_fence',
    'struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex',
    'struct_hipExternalSemaphoreWaitParams_st_params',
    'struct_hipFuncAttributes', 'struct_hipFunctionLaunchParams_t',
    'struct_hipGraphExec', 'struct_hipGraphNode',
    'struct_hipHostNodeParams', 'struct_hipIpcEventHandle_st',
    'struct_hipIpcMemHandle_st', 'struct_hipKernelNodeParams',
    'struct_hipLaunchParams_t', 'struct_hipMemAccessDesc',
    'struct_hipMemAllocNodeParams', 'struct_hipMemAllocationProp',
    'struct_hipMemAllocationProp_allocFlags', 'struct_hipMemLocation',
    'struct_hipMemPoolProps', 'struct_hipMemPoolPtrExportData',
    'struct_hipMemcpy3DParms', 'struct_hipMemsetParams',
    'struct_hipMipmappedArray', 'struct_hipPitchedPtr',
    'struct_hipPointerAttribute_t', 'struct_hipPos',
    'struct_hipResourceDesc', 'struct_hipResourceDesc_0_array',
    'struct_hipResourceDesc_0_linear',
    'struct_hipResourceDesc_0_mipmap',
    'struct_hipResourceDesc_0_pitch2D', 'struct_hipResourceViewDesc',
    'struct_hipTextureDesc', 'struct_hipUUID_t',
    'struct_hipUserObject', 'struct_hip_Memcpy2D', 'struct_ihipCtx_t',
    'struct_ihipEvent_t', 'struct_ihipGraph',
    'struct_ihipMemGenericAllocationHandle',
    'struct_ihipMemPoolHandle_t', 'struct_ihipModuleSymbol_t',
    'struct_ihipModule_t', 'struct_ihipStream_t',
    'struct_ihiprtcLinkState', 'struct_textureReference', 'uint32_t',
    'uint64_t', 'union_HIP_RESOURCE_DESC_st_res',
    'union_hipArrayMapInfo_memHandle',
    'union_hipArrayMapInfo_resource',
    'union_hipArrayMapInfo_subresource',
    'union_hipExternalMemoryHandleDesc_st_handle',
    'union_hipExternalSemaphoreHandleDesc_st_handle',
    'union_hipKernelNodeAttrValue', 'union_hipPointerAttribute_t_0',
    'union_hipResourceDesc_res']