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